Skip to content

Instantly share code, notes, and snippets.

@xlc

xlc/metadata

Last active February 28, 2019 10:55
Show Gist options
  • Save xlc/19d010e55f84bf6d43afafdc5e5b5df6 to your computer and use it in GitHub Desktop.
Save xlc/19d010e55f84bf6d43afafdc5e5b5df6 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
metadata
RuntimeMetadataPrefixed(
1635018093,
V2(
RuntimeMetadataV2 {
modules: [
ModuleMetadata {
name: "system",
prefix: "System",
storage: Some(
[
StorageFunctionMetadata {
name: "AccountNonce",
modifier: Default,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: U64,
display_name: "T::Index"
}
},
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: []
},
StorageFunctionMetadata {
name: "ExtrinsicCount",
modifier: Optional,
ty: Plain(
TypeName {
type_name: U32,
display_name: "u32"
}
),
default: [
0
],
documentation: []
},
StorageFunctionMetadata {
name: "AllExtrinsicsLen",
modifier: Optional,
ty: Plain(
TypeName {
type_name: U32,
display_name: "u32"
}
),
default: [
0
],
documentation: []
},
StorageFunctionMetadata {
name: "BlockHash",
modifier: Default,
ty: Map {
key: TypeName {
type_name: U64,
display_name: "T::BlockNumber"
},
value: TypeName {
type_name: H256,
display_name: "T::Hash"
}
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: []
},
StorageFunctionMetadata {
name: "ExtrinsicData",
modifier: Default,
ty: Map {
key: TypeName {
type_name: U32,
display_name: "u32"
},
value: TypeName {
type_name: Vector(
U8
),
display_name: "Vec<u8>"
}
},
default: [
0
],
documentation: []
},
StorageFunctionMetadata {
name: "RandomSeed",
modifier: Default,
ty: Plain(
TypeName {
type_name: H256,
display_name: "T::Hash"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: []
},
StorageFunctionMetadata {
name: "Number",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The current block number being processed. Set by `execute_block`."
]
},
StorageFunctionMetadata {
name: "ParentHash",
modifier: Default,
ty: Plain(
TypeName {
type_name: H256,
display_name: "T::Hash"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: []
},
StorageFunctionMetadata {
name: "ExtrinsicsRoot",
modifier: Default,
ty: Plain(
TypeName {
type_name: H256,
display_name: "T::Hash"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: []
},
StorageFunctionMetadata {
name: "Digest",
modifier: Default,
ty: Plain(
TypeName {
type_name: CustomWithGenerics(
"sr_primitives::generic::digest",
"Digest",
[
Custom(
"node_runtime",
"Log"
)
]
),
display_name: "T::Digest"
}
),
default: [
0
],
documentation: []
},
StorageFunctionMetadata {
name: "Events",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
CustomWithGenerics(
"srml_system",
"EventRecord",
[
Custom(
"node_runtime",
"Event"
)
]
)
),
display_name: "Vec<EventRecord<T::Event>>"
}
),
default: [
0
],
documentation: []
}
]
),
calls: None,
event: Some(
[
EventMetadata {
name: "ExtrinsicSuccess",
arguments: [],
documentation: [
" An extrinsic completed successfully."
]
},
EventMetadata {
name: "ExtrinsicFailed",
arguments: [],
documentation: [
" An extrinsic failed."
]
}
]
)
},
ModuleMetadata {
name: "aura",
prefix: "",
storage: None,
calls: None,
event: None
},
ModuleMetadata {
name: "timestamp",
prefix: "Timestamp",
storage: Some(
[
StorageFunctionMetadata {
name: "Now",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::Moment"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" Current time for the current block."
]
},
StorageFunctionMetadata {
name: "BlockPeriod",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::Moment"
}
),
default: [
5,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The minimum (and advised) period between blocks."
]
},
StorageFunctionMetadata {
name: "DidUpdate",
modifier: Default,
ty: Plain(
TypeName {
type_name: Bool,
display_name: "bool"
}
),
default: [
0
],
documentation: [
" Did the timestamp get updated in this block?"
]
}
]
),
calls: Some(
[
FunctionMetadata {
name: "set",
arguments: [
FunctionArgumentMetadata {
name: "now",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::Moment>"
}
}
],
documentation: [
" Set the current time.",
"",
" Extrinsic with this call should be placed at the specific position in the each block",
" (specified by the Trait::TIMESTAMP_SET_POSITION) typically at the start of the each block.",
" This call should be invoked exactly once per block. It will panic at the finalization phase,",
" if this call hasn\'t been invoked by that time.",
"",
" The timestamp should be greater than the previous one by the amount specified by `block_period`."
]
}
]
),
event: None
},
ModuleMetadata {
name: "consensus",
prefix: "Consensus",
storage: Some(
[
StorageFunctionMetadata {
name: "OriginalAuthorities",
modifier: Optional,
ty: Plain(
TypeName {
type_name: Vector(
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
)
),
display_name: "Vec<T::SessionKey>"
}
),
default: [
0
],
documentation: []
}
]
),
calls: Some(
[
FunctionMetadata {
name: "report_misbehavior",
arguments: [
FunctionArgumentMetadata {
name: "_report",
ty: TypeName {
type_name: Vector(
U8
),
display_name: "Vec<u8>"
}
}
],
documentation: [
" Report some misbehaviour."
]
},
FunctionMetadata {
name: "note_offline",
arguments: [
FunctionArgumentMetadata {
name: "offline",
ty: TypeName {
type_name: Unit,
display_name: "<T::InherentOfflineReport as InherentOfflineReport>::Inherent"
}
}
],
documentation: [
" Note the previous block\'s validator missed their opportunity to propose a block."
]
},
FunctionMetadata {
name: "remark",
arguments: [
FunctionArgumentMetadata {
name: "_remark",
ty: TypeName {
type_name: Vector(
U8
),
display_name: "Vec<u8>"
}
}
],
documentation: [
" Make some on-chain remark."
]
},
FunctionMetadata {
name: "set_heap_pages",
arguments: [
FunctionArgumentMetadata {
name: "pages",
ty: TypeName {
type_name: U64,
display_name: "u64"
}
}
],
documentation: [
" Set the number of pages in the WebAssembly environment\'s heap."
]
},
FunctionMetadata {
name: "set_code",
arguments: [
FunctionArgumentMetadata {
name: "new",
ty: TypeName {
type_name: Vector(
U8
),
display_name: "Vec<u8>"
}
}
],
documentation: [
" Set the new code."
]
},
FunctionMetadata {
name: "set_storage",
arguments: [
FunctionArgumentMetadata {
name: "items",
ty: TypeName {
type_name: Vector(
Tuple(
[
Vector(
U8
),
Vector(
U8
)
]
)
),
display_name: "Vec<KeyValue>"
}
}
],
documentation: [
" Set some items of storage."
]
}
]
),
event: None
},
ModuleMetadata {
name: "indices",
prefix: "Indices",
storage: Some(
[
StorageFunctionMetadata {
name: "NextEnumSet",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "T::AccountIndex"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" The next free enumeration set."
]
},
StorageFunctionMetadata {
name: "EnumSet",
modifier: Default,
ty: Map {
key: TypeName {
type_name: U32,
display_name: "T::AccountIndex"
},
value: TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<T::AccountId>"
}
},
default: [
0
],
documentation: [
" The enumeration sets."
]
}
]
),
calls: Some(
[]
),
event: Some(
[
EventMetadata {
name: "NewAccountIndex",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: U32,
display_name: "AccountIndex"
}
],
documentation: [
" A new account index was assigned.",
"",
" This event is not triggered when an existing index is reassigned",
" to another `AccountId`."
]
}
]
)
},
ModuleMetadata {
name: "balances",
prefix: "Balances",
storage: Some(
[
StorageFunctionMetadata {
name: "TotalIssuance",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "T::Balance"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The total amount of stake on the system."
]
},
StorageFunctionMetadata {
name: "ExistentialDeposit",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "T::Balance"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The minimum amount allowed to keep an account open."
]
},
StorageFunctionMetadata {
name: "TransferFee",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "T::Balance"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The fee required to make a transfer."
]
},
StorageFunctionMetadata {
name: "CreationFee",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "T::Balance"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The fee required to create an account. At least as big as ReclaimRebate."
]
},
StorageFunctionMetadata {
name: "Vesting",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: CustomWithGenerics(
"srml_balances",
"VestingSchedule",
[
U128
]
),
display_name: "VestingSchedule<T::Balance>"
}
},
default: [
0
],
documentation: [
" Information regarding the vesting of a given account."
]
},
StorageFunctionMetadata {
name: "FreeBalance",
modifier: Default,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: U128,
display_name: "T::Balance"
}
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The \'free\' balance of a given account.",
"",
" This is the only balance that matters in terms of most operations on tokens. It is",
" alone used to determine the balance when in the contract execution environment. When this",
" balance falls below the value of `ExistentialDeposit`, then the \'current account\' is",
" deleted: specifically `FreeBalance`. Furthermore, `OnFreeBalanceZero` callback",
" is invoked, giving a chance to external modules to cleanup data associated with",
" the deleted account.",
"",
" `system::AccountNonce` is also deleted if `ReservedBalance` is also zero (it also gets",
" collapsed to zero if it ever becomes less than `ExistentialDeposit`."
]
},
StorageFunctionMetadata {
name: "ReservedBalance",
modifier: Default,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: U128,
display_name: "T::Balance"
}
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The amount of the balance of a given account that is externally reserved; this can still get",
" slashed, but gets slashed last of all.",
"",
" This balance is a \'reserve\' balance that other subsystems use in order to set aside tokens",
" that are still \'owned\' by the account holder, but which are suspendable. (This is different",
" and wholly unrelated to the `Bondage` system used in the staking module.)",
"",
" When this balance falls below the value of `ExistentialDeposit`, then this \'reserve account\'",
" is deleted: specifically, `ReservedBalance`.",
"",
" `system::AccountNonce` is also deleted if `FreeBalance` is also zero (it also gets",
" collapsed to zero if it ever becomes less than `ExistentialDeposit`."
]
}
]
),
calls: Some(
[
FunctionMetadata {
name: "transfer",
arguments: [
FunctionArgumentMetadata {
name: "dest",
ty: TypeName {
type_name: Custom(
"srml_indices::address",
"Address"
),
display_name: "<T::Lookup as StaticLookup>::Source"
}
},
FunctionArgumentMetadata {
name: "value",
ty: TypeName {
type_name: Compact(
U128
),
display_name: "Compact<T::Balance>"
}
}
],
documentation: [
" Transfer some liquid free balance to another staker."
]
},
FunctionMetadata {
name: "set_balance",
arguments: [
FunctionArgumentMetadata {
name: "who",
ty: TypeName {
type_name: Custom(
"srml_indices::address",
"Address"
),
display_name: "<T::Lookup as StaticLookup>::Source"
}
},
FunctionArgumentMetadata {
name: "free",
ty: TypeName {
type_name: Compact(
U128
),
display_name: "Compact<T::Balance>"
}
},
FunctionArgumentMetadata {
name: "reserved",
ty: TypeName {
type_name: Compact(
U128
),
display_name: "Compact<T::Balance>"
}
}
],
documentation: [
" Set the balances of a given account."
]
}
]
),
event: Some(
[
EventMetadata {
name: "NewAccount",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: U128,
display_name: "Balance"
}
],
documentation: [
" A new account was created."
]
},
EventMetadata {
name: "ReapedAccount",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
}
],
documentation: [
" An account was reaped."
]
},
EventMetadata {
name: "Transfer",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: U128,
display_name: "Balance"
},
TypeName {
type_name: U128,
display_name: "Balance"
}
],
documentation: [
" Transfer succeeded (from, to, value, fees)."
]
}
]
)
},
ModuleMetadata {
name: "session",
prefix: "Session",
storage: Some(
[
StorageFunctionMetadata {
name: "Validators",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<T::AccountId>"
}
),
default: [
0
],
documentation: [
" The current set of validators."
]
},
StorageFunctionMetadata {
name: "SessionLength",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
232,
3,
0,
0,
0,
0,
0,
0
],
documentation: [
" Current length of the session."
]
},
StorageFunctionMetadata {
name: "CurrentIndex",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" Current index of the session."
]
},
StorageFunctionMetadata {
name: "CurrentStart",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::Moment"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" Timestamp when current session started."
]
},
StorageFunctionMetadata {
name: "ForcingNewSession",
modifier: Optional,
ty: Plain(
TypeName {
type_name: Bool,
display_name: "bool"
}
),
default: [
0
],
documentation: [
" New session is being forced is this entry exists; in which case, the boolean value is whether",
" the new session should be considered a normal rotation (rewardable) or exceptional (slashable)."
]
},
StorageFunctionMetadata {
name: "LastLengthChange",
modifier: Optional,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
0
],
documentation: [
" Block at which the session length last changed."
]
},
StorageFunctionMetadata {
name: "NextKeyFor",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
),
display_name: "T::SessionKey"
}
},
default: [
0
],
documentation: [
" The next key for a given validator."
]
},
StorageFunctionMetadata {
name: "NextSessionLength",
modifier: Optional,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
0
],
documentation: [
" The next session length."
]
}
]
),
calls: Some(
[
FunctionMetadata {
name: "set_key",
arguments: [
FunctionArgumentMetadata {
name: "key",
ty: TypeName {
type_name: Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
),
display_name: "T::SessionKey"
}
}
],
documentation: [
" Sets the session key of `_validator` to `_key`. This doesn\'t take effect until the next",
" session."
]
},
FunctionMetadata {
name: "set_length",
arguments: [
FunctionArgumentMetadata {
name: "new",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::BlockNumber>"
}
}
],
documentation: [
" Set a new session length. Won\'t kick in until the next session change (at current length)."
]
},
FunctionMetadata {
name: "force_new_session",
arguments: [
FunctionArgumentMetadata {
name: "apply_rewards",
ty: TypeName {
type_name: Bool,
display_name: "bool"
}
}
],
documentation: [
" Forces a new session."
]
}
]
),
event: Some(
[
EventMetadata {
name: "NewSession",
arguments: [
TypeName {
type_name: U64,
display_name: "BlockNumber"
}
],
documentation: [
" New session has happened. Note that the argument is the session index, not the block",
" number as the type might suggest."
]
}
]
)
},
ModuleMetadata {
name: "staking",
prefix: "Staking",
storage: Some(
[
StorageFunctionMetadata {
name: "ValidatorCount",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "u32"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" The ideal number of staking participants."
]
},
StorageFunctionMetadata {
name: "MinimumValidatorCount",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "u32"
}
),
default: [
4,
0,
0,
0
],
documentation: [
" Minimum number of staking participants before emergency conditions are imposed."
]
},
StorageFunctionMetadata {
name: "SessionsPerEra",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
232,
3,
0,
0,
0,
0,
0,
0
],
documentation: [
" The length of a staking era in sessions."
]
},
StorageFunctionMetadata {
name: "SessionReward",
modifier: Default,
ty: Plain(
TypeName {
type_name: Custom(
"sr_primitives",
"Perbill"
),
display_name: "Perbill"
}
),
default: [
60,
0,
0,
0
],
documentation: [
" Maximum reward, per validator, that is provided per acceptable session."
]
},
StorageFunctionMetadata {
name: "OfflineSlash",
modifier: Default,
ty: Plain(
TypeName {
type_name: Custom(
"sr_primitives",
"Perbill"
),
display_name: "Perbill"
}
),
default: [
64,
66,
15,
0
],
documentation: [
" Slash, per validator that is taken for the first time they are found to be offline."
]
},
StorageFunctionMetadata {
name: "OfflineSlashGrace",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "u32"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" Number of instances of offline reports before slashing begins for validators."
]
},
StorageFunctionMetadata {
name: "BondingDuration",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
232,
3,
0,
0,
0,
0,
0,
0
],
documentation: [
" The length of the bonding duration in blocks."
]
},
StorageFunctionMetadata {
name: "Invulerables",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<T::AccountId>"
}
),
default: [
0
],
documentation: [
" Any validators that may never be slashed or forcible kicked. It\'s a Vec since they\'re easy to initialise",
" and the performance hit is minimal (we expect no more than four invulnerables) and restricted to testnets."
]
},
StorageFunctionMetadata {
name: "CurrentEra",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The current era index."
]
},
StorageFunctionMetadata {
name: "ValidatorPreferences",
modifier: Default,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: CustomWithGenerics(
"srml_staking",
"ValidatorPrefs",
[
U128
]
),
display_name: "ValidatorPrefs<BalanceOf<T>>"
}
},
default: [
12,
0
],
documentation: [
" Preferences that a validator has."
]
},
StorageFunctionMetadata {
name: "Intentions",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<T::AccountId>"
}
),
default: [
0
],
documentation: [
" All the accounts with a desire to stake."
]
},
StorageFunctionMetadata {
name: "Nominating",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
}
},
default: [
0
],
documentation: [
" All nominator -> nominee relationships."
]
},
StorageFunctionMetadata {
name: "NominatorsFor",
modifier: Default,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<T::AccountId>"
}
},
default: [
0
],
documentation: [
" Nominators for a particular account."
]
},
StorageFunctionMetadata {
name: "CurrentNominatorsFor",
modifier: Default,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<T::AccountId>"
}
},
default: [
0
],
documentation: [
" Nominators for a particular account that is in action right now."
]
},
StorageFunctionMetadata {
name: "CurrentSessionReward",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "BalanceOf<T>"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" Maximum reward, per validator, that is provided per acceptable session."
]
},
StorageFunctionMetadata {
name: "CurrentOfflineSlash",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "BalanceOf<T>"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" Slash, per validator that is taken for the first time they are found to be offline."
]
},
StorageFunctionMetadata {
name: "NextSessionsPerEra",
modifier: Optional,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
0
],
documentation: [
" The next value of sessions per era."
]
},
StorageFunctionMetadata {
name: "LastEraLengthChange",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The session index at which the era length last changed."
]
},
StorageFunctionMetadata {
name: "StakeRange",
modifier: Default,
ty: Plain(
TypeName {
type_name: Tuple(
[
U128,
U128
]
),
display_name: "PairOf<BalanceOf<T>>"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The highest and lowest staked validator slashable balances."
]
},
StorageFunctionMetadata {
name: "Bondage",
modifier: Default,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
},
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The block at which the `who`\'s funds become entirely liquid."
]
},
StorageFunctionMetadata {
name: "SlashCount",
modifier: Default,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: U32,
display_name: "u32"
}
},
default: [
0,
0,
0,
0
],
documentation: [
" The number of times a given validator has been reported offline. This gets decremented by one each era that passes."
]
},
StorageFunctionMetadata {
name: "ForcingNewEra",
modifier: Optional,
ty: Plain(
TypeName {
type_name: Unit,
display_name: "()"
}
),
default: [
0
],
documentation: [
" We are forcing a new era."
]
},
StorageFunctionMetadata {
name: "RecentlyOffline",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
Tuple(
[
Custom(
"sr_primitives",
"AccountId"
),
U64,
U32
]
)
),
display_name: "Vec<(T::AccountId, T::BlockNumber, u32)>"
}
),
default: [
0
],
documentation: [
" Most recent `RECENT_OFFLINE_COUNT` instances. (who it was, when it was reported, how many instances they were offline for)."
]
}
]
),
calls: Some(
[
FunctionMetadata {
name: "stake",
arguments: [],
documentation: [
" Declare the desire to stake for the transactor.",
"",
" Effects will be felt at the beginning of the next era."
]
},
FunctionMetadata {
name: "unstake",
arguments: [
FunctionArgumentMetadata {
name: "intentions_index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
}
],
documentation: [
" Retract the desire to stake for the transactor.",
"",
" Effects will be felt at the beginning of the next era."
]
},
FunctionMetadata {
name: "nominate",
arguments: [
FunctionArgumentMetadata {
name: "target",
ty: TypeName {
type_name: Custom(
"srml_indices::address",
"Address"
),
display_name: "<T::Lookup as StaticLookup>::Source"
}
}
],
documentation: []
},
FunctionMetadata {
name: "unnominate",
arguments: [
FunctionArgumentMetadata {
name: "target_index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
}
],
documentation: [
" Will panic if called when source isn\'t currently nominating target.",
" Updates Nominating, NominatorsFor and NominationBalance."
]
},
FunctionMetadata {
name: "register_preferences",
arguments: [
FunctionArgumentMetadata {
name: "intentions_index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
},
FunctionArgumentMetadata {
name: "prefs",
ty: TypeName {
type_name: CustomWithGenerics(
"srml_staking",
"ValidatorPrefs",
[
U128
]
),
display_name: "ValidatorPrefs<BalanceOf<T>>"
}
}
],
documentation: [
" Set the given account\'s preference for slashing behaviour should they be a validator.",
"",
" An error (no-op) if `Self::intentions()[intentions_index] != origin`."
]
},
FunctionMetadata {
name: "set_sessions_per_era",
arguments: [
FunctionArgumentMetadata {
name: "new",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::BlockNumber>"
}
}
],
documentation: [
" Set the number of sessions in an era."
]
},
FunctionMetadata {
name: "set_bonding_duration",
arguments: [
FunctionArgumentMetadata {
name: "new",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::BlockNumber>"
}
}
],
documentation: [
" The length of the bonding duration in eras."
]
},
FunctionMetadata {
name: "set_validator_count",
arguments: [
FunctionArgumentMetadata {
name: "new",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
}
],
documentation: [
" The ideal number of validators."
]
},
FunctionMetadata {
name: "force_new_era",
arguments: [
FunctionArgumentMetadata {
name: "apply_rewards",
ty: TypeName {
type_name: Bool,
display_name: "bool"
}
}
],
documentation: [
" Force there to be a new era. This also forces a new session immediately after.",
" `apply_rewards` should be true for validators to get the session reward."
]
},
FunctionMetadata {
name: "set_offline_slash_grace",
arguments: [
FunctionArgumentMetadata {
name: "new",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
}
],
documentation: [
" Set the offline slash grace period."
]
},
FunctionMetadata {
name: "set_invulnerables",
arguments: [
FunctionArgumentMetadata {
name: "validators",
ty: TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<T::AccountId>"
}
}
],
documentation: [
" Set the validators who cannot be slashed (if any)."
]
}
]
),
event: Some(
[
EventMetadata {
name: "Reward",
arguments: [
TypeName {
type_name: U128,
display_name: "Balance"
}
],
documentation: [
" All validators have been rewarded by the given balance."
]
},
EventMetadata {
name: "OfflineWarning",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: U32,
display_name: "u32"
}
],
documentation: [
" One validator (and their nominators) has been given a offline-warning (they\'re still",
" within their grace). The accrued number of slashes is recorded, too."
]
},
EventMetadata {
name: "OfflineSlash",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: U128,
display_name: "Balance"
}
],
documentation: [
" One validator (and their nominators) has been slashed by the given amount."
]
}
]
)
},
ModuleMetadata {
name: "democracy",
prefix: "Democracy",
storage: Some(
[
StorageFunctionMetadata {
name: "PublicPropCount",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "PropIndex"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" The number of (public) proposals that have been made so far."
]
},
StorageFunctionMetadata {
name: "PublicProps",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
Tuple(
[
U32,
Custom(
"node_runtime",
"Call"
),
Custom(
"sr_primitives",
"AccountId"
)
]
)
),
display_name: "Vec<(PropIndex, T::Proposal, T::AccountId)>"
}
),
default: [
0
],
documentation: [
" The public proposals. Unsorted."
]
},
StorageFunctionMetadata {
name: "DepositOf",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: U32,
display_name: "PropIndex"
},
value: TypeName {
type_name: Tuple(
[
U128,
Vector(
Custom(
"sr_primitives",
"AccountId"
)
)
]
),
display_name: "(BalanceOf<T>, Vec<T::AccountId>)"
}
},
default: [
0
],
documentation: [
" Those who have locked a deposit."
]
},
StorageFunctionMetadata {
name: "LaunchPeriod",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
232,
3,
0,
0,
0,
0,
0,
0
],
documentation: [
" How often (in blocks) new public referenda are launched."
]
},
StorageFunctionMetadata {
name: "MinimumDeposit",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "BalanceOf<T>"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The minimum amount to be used as a deposit for a public referendum proposal."
]
},
StorageFunctionMetadata {
name: "PublicDelay",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The delay before enactment for all public referenda."
]
},
StorageFunctionMetadata {
name: "MaxLockPeriods",
modifier: Default,
ty: Plain(
TypeName {
type_name: I8,
display_name: "LockPeriods"
}
),
default: [
0
],
documentation: [
" The maximum number of additional lock periods a voter may offer to strengthen their vote. Multiples of `PublicDelay`."
]
},
StorageFunctionMetadata {
name: "VotingPeriod",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
232,
3,
0,
0,
0,
0,
0,
0
],
documentation: [
" How often (in blocks) to check for new votes."
]
},
StorageFunctionMetadata {
name: "ReferendumCount",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "ReferendumIndex"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" The next free referendum index, aka the number of referendums started so far."
]
},
StorageFunctionMetadata {
name: "NextTally",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "ReferendumIndex"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" The next referendum index that should be tallied."
]
},
StorageFunctionMetadata {
name: "ReferendumInfoOf",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: U32,
display_name: "ReferendumIndex"
},
value: TypeName {
type_name: CustomWithGenerics(
"srml_democracy",
"ReferendumInfo",
[
U64,
Custom(
"node_runtime",
"Call"
)
]
),
display_name: "(ReferendumInfo<T::BlockNumber, T::Proposal>)"
}
},
default: [
0
],
documentation: [
" Information concerning any given referendum."
]
},
StorageFunctionMetadata {
name: "DispatchQueue",
modifier: Default,
ty: Map {
key: TypeName {
type_name: U64,
display_name: "T::BlockNumber"
},
value: TypeName {
type_name: Vector(
Option(
Tuple(
[
Custom(
"node_runtime",
"Call"
),
U32
]
)
)
),
display_name: "Vec<Option<(T::Proposal, ReferendumIndex)>>"
}
},
default: [
0
],
documentation: [
" Queue of successful referenda to be dispatched."
]
},
StorageFunctionMetadata {
name: "Bondage",
modifier: Default,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
},
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The block at which the `who`\'s funds become liquid."
]
},
StorageFunctionMetadata {
name: "VotersFor",
modifier: Default,
ty: Map {
key: TypeName {
type_name: U32,
display_name: "ReferendumIndex"
},
value: TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<T::AccountId>"
}
},
default: [
0
],
documentation: [
" Get the voters for the current proposal."
]
},
StorageFunctionMetadata {
name: "VoteOf",
modifier: Default,
ty: Map {
key: TypeName {
type_name: Tuple(
[
U32,
Custom(
"sr_primitives",
"AccountId"
)
]
),
display_name: "(ReferendumIndex, T::AccountId)"
},
value: TypeName {
type_name: Custom(
"srml_democracy",
"Vote"
),
display_name: "Vote"
}
},
default: [
0
],
documentation: [
" Get the vote in a given referendum of a particular voter. The result is meaningful only if `voters_for` includes the",
" voter when called with the referendum (you\'ll get the default `Vote` value otherwise). If you don\'t want to check",
" `voters_for`, then you can also check for simple existence with `VoteOf::exists` first."
]
}
]
),
calls: Some(
[
FunctionMetadata {
name: "propose",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: TypeName {
type_name: Custom(
"node_runtime",
"Call"
),
display_name: "Box<T::Proposal>"
}
},
FunctionArgumentMetadata {
name: "value",
ty: TypeName {
type_name: Compact(
U128
),
display_name: "Compact<BalanceOf<T>>"
}
}
],
documentation: [
" Propose a sensitive action to be taken."
]
},
FunctionMetadata {
name: "second",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<PropIndex>"
}
}
],
documentation: [
" Propose a sensitive action to be taken."
]
},
FunctionMetadata {
name: "vote",
arguments: [
FunctionArgumentMetadata {
name: "ref_index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<ReferendumIndex>"
}
},
FunctionArgumentMetadata {
name: "vote",
ty: TypeName {
type_name: Custom(
"srml_democracy",
"Vote"
),
display_name: "Vote"
}
}
],
documentation: [
" Vote in a referendum. If `vote.is_aye()`, the vote is to enact the proposal;",
" otherwise it is a vote to keep the status quo."
]
},
FunctionMetadata {
name: "start_referendum",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: TypeName {
type_name: Custom(
"node_runtime",
"Call"
),
display_name: "Box<T::Proposal>"
}
},
FunctionArgumentMetadata {
name: "threshold",
ty: TypeName {
type_name: Custom(
"srml_democracy::vote_threshold",
"VoteThreshold"
),
display_name: "VoteThreshold"
}
},
FunctionArgumentMetadata {
name: "delay",
ty: TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
}
],
documentation: [
" Start a referendum."
]
},
FunctionMetadata {
name: "cancel_referendum",
arguments: [
FunctionArgumentMetadata {
name: "ref_index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<ReferendumIndex>"
}
}
],
documentation: [
" Remove a referendum."
]
},
FunctionMetadata {
name: "cancel_queued",
arguments: [
FunctionArgumentMetadata {
name: "when",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::BlockNumber>"
}
},
FunctionArgumentMetadata {
name: "which",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
}
],
documentation: [
" Cancel a proposal queued for enactment."
]
}
]
),
event: Some(
[
EventMetadata {
name: "Proposed",
arguments: [
TypeName {
type_name: U32,
display_name: "PropIndex"
},
TypeName {
type_name: U128,
display_name: "Balance"
}
],
documentation: []
},
EventMetadata {
name: "Tabled",
arguments: [
TypeName {
type_name: U32,
display_name: "PropIndex"
},
TypeName {
type_name: U128,
display_name: "Balance"
},
TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<AccountId>"
}
],
documentation: []
},
EventMetadata {
name: "Started",
arguments: [
TypeName {
type_name: U32,
display_name: "ReferendumIndex"
},
TypeName {
type_name: Custom(
"srml_democracy::vote_threshold",
"VoteThreshold"
),
display_name: "VoteThreshold"
}
],
documentation: []
},
EventMetadata {
name: "Passed",
arguments: [
TypeName {
type_name: U32,
display_name: "ReferendumIndex"
}
],
documentation: []
},
EventMetadata {
name: "NotPassed",
arguments: [
TypeName {
type_name: U32,
display_name: "ReferendumIndex"
}
],
documentation: []
},
EventMetadata {
name: "Cancelled",
arguments: [
TypeName {
type_name: U32,
display_name: "ReferendumIndex"
}
],
documentation: []
},
EventMetadata {
name: "Executed",
arguments: [
TypeName {
type_name: U32,
display_name: "ReferendumIndex"
},
TypeName {
type_name: Bool,
display_name: "bool"
}
],
documentation: []
}
]
)
},
ModuleMetadata {
name: "council",
prefix: "Council",
storage: Some(
[
StorageFunctionMetadata {
name: "CandidacyBond",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "BalanceOf<T>"
}
),
default: [
9,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" How much should be locked up in order to submit one\'s candidacy."
]
},
StorageFunctionMetadata {
name: "VotingBond",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "BalanceOf<T>"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" How much should be locked up in order to be able to submit votes."
]
},
StorageFunctionMetadata {
name: "PresentSlashPerVoter",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "BalanceOf<T>"
}
),
default: [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The punishment, per voter, if you provide an invalid presentation."
]
},
StorageFunctionMetadata {
name: "CarryCount",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "u32"
}
),
default: [
2,
0,
0,
0
],
documentation: [
" How many runners-up should have their approvals persist until the next vote."
]
},
StorageFunctionMetadata {
name: "PresentationDuration",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
232,
3,
0,
0,
0,
0,
0,
0
],
documentation: [
" How long to give each top candidate to present themselves after the vote ends."
]
},
StorageFunctionMetadata {
name: "InactiveGracePeriod",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "VoteIndex"
}
),
default: [
1,
0,
0,
0
],
documentation: [
" How many vote indexes need to go by after a target voter\'s last vote before they can be reaped if their",
" approvals are moot."
]
},
StorageFunctionMetadata {
name: "VotingPeriod",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
232,
3,
0,
0,
0,
0,
0,
0
],
documentation: [
" How often (in blocks) to check for new votes."
]
},
StorageFunctionMetadata {
name: "TermDuration",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
5,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" How long each position is active for."
]
},
StorageFunctionMetadata {
name: "DesiredSeats",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "u32"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" Number of accounts that should be sitting on the council."
]
},
StorageFunctionMetadata {
name: "ActiveCouncil",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
Tuple(
[
Custom(
"sr_primitives",
"AccountId"
),
U64
]
)
),
display_name: "Vec<(T::AccountId, T::BlockNumber)>"
}
),
default: [
0
],
documentation: [
" The current council. When there\'s a vote going on, this should still be used for executive",
" matters. The block number (second element in the tuple) is the block that their position is",
" active until (calculated by the sum of the block number when the council member was elected",
" and their term duration)."
]
},
StorageFunctionMetadata {
name: "VoteCount",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "VoteIndex"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" The total number of votes that have happened or are in progress."
]
},
StorageFunctionMetadata {
name: "ApprovalsOf",
modifier: Default,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: Vector(
Bool
),
display_name: "Vec<bool>"
}
},
default: [
0
],
documentation: [
" A list of votes for each voter, respecting the last cleared vote index that this voter was",
" last active at."
]
},
StorageFunctionMetadata {
name: "RegisterInfoOf",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: Tuple(
[
U32,
U32
]
),
display_name: "(VoteIndex, u32)"
}
},
default: [
0
],
documentation: [
" The vote index and list slot that the candidate `who` was registered or `None` if they are not",
" currently registered."
]
},
StorageFunctionMetadata {
name: "LastActiveOf",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: U32,
display_name: "VoteIndex"
}
},
default: [
0
],
documentation: [
" The last cleared vote index that this voter was last active at."
]
},
StorageFunctionMetadata {
name: "Voters",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<T::AccountId>"
}
),
default: [
0
],
documentation: [
" The present voter list."
]
},
StorageFunctionMetadata {
name: "Candidates",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<T::AccountId>"
}
),
default: [
0
],
documentation: [
" The present candidate list."
]
},
StorageFunctionMetadata {
name: "CandidateCount",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "u32"
}
),
default: [
0,
0,
0,
0
],
documentation: []
},
StorageFunctionMetadata {
name: "NextFinalise",
modifier: Optional,
ty: Plain(
TypeName {
type_name: Tuple(
[
U64,
U32,
Vector(
Custom(
"sr_primitives",
"AccountId"
)
)
]
),
display_name: "(T::BlockNumber, u32, Vec<T::AccountId>)"
}
),
default: [
0
],
documentation: [
" The accounts holding the seats that will become free on the next tally."
]
},
StorageFunctionMetadata {
name: "SnapshotedStakes",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
U128
),
display_name: "Vec<BalanceOf<T>>"
}
),
default: [
0
],
documentation: [
" The stakes as they were at the point that the vote ended."
]
},
StorageFunctionMetadata {
name: "Leaderboard",
modifier: Optional,
ty: Plain(
TypeName {
type_name: Vector(
Tuple(
[
U128,
Custom(
"sr_primitives",
"AccountId"
)
]
)
),
display_name: "Vec<(BalanceOf<T>, T::AccountId)>"
}
),
default: [
0
],
documentation: [
" Get the leaderboard if we;re in the presentation phase."
]
}
]
),
calls: Some(
[
FunctionMetadata {
name: "set_approvals",
arguments: [
FunctionArgumentMetadata {
name: "votes",
ty: TypeName {
type_name: Vector(
Bool
),
display_name: "Vec<bool>"
}
},
FunctionArgumentMetadata {
name: "index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<VoteIndex>"
}
}
],
documentation: [
" Set candidate approvals. Approval slots stay valid as long as candidates in those slots",
" are registered."
]
},
FunctionMetadata {
name: "reap_inactive_voter",
arguments: [
FunctionArgumentMetadata {
name: "reporter_index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
},
FunctionArgumentMetadata {
name: "who",
ty: TypeName {
type_name: Custom(
"srml_indices::address",
"Address"
),
display_name: "<T::Lookup as StaticLookup>::Source"
}
},
FunctionArgumentMetadata {
name: "who_index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
},
FunctionArgumentMetadata {
name: "assumed_vote_index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<VoteIndex>"
}
}
],
documentation: [
" Remove a voter. For it not to be a bond-consuming no-op, all approved candidate indices",
" must now be either unregistered or registered to a candidate that registered the slot after",
" the voter gave their last approval set.",
"",
" May be called by anyone. Returns the voter deposit to `signed`."
]
},
FunctionMetadata {
name: "retract_voter",
arguments: [
FunctionArgumentMetadata {
name: "index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
}
],
documentation: [
" Remove a voter. All votes are cancelled and the voter deposit is returned."
]
},
FunctionMetadata {
name: "submit_candidacy",
arguments: [
FunctionArgumentMetadata {
name: "slot",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
}
],
documentation: [
" Submit oneself for candidacy.",
"",
" Account must have enough transferrable funds in it to pay the bond."
]
},
FunctionMetadata {
name: "present_winner",
arguments: [
FunctionArgumentMetadata {
name: "candidate",
ty: TypeName {
type_name: Custom(
"srml_indices::address",
"Address"
),
display_name: "<T::Lookup as StaticLookup>::Source"
}
},
FunctionArgumentMetadata {
name: "total",
ty: TypeName {
type_name: Compact(
U128
),
display_name: "Compact<BalanceOf<T>>"
}
},
FunctionArgumentMetadata {
name: "index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<VoteIndex>"
}
}
],
documentation: [
" Claim that `signed` is one of the top Self::carry_count() + current_vote().1 candidates.",
" Only works if the `block_number >= current_vote().0` and `< current_vote().0 + presentation_duration()``",
" `signed` should have at least"
]
},
FunctionMetadata {
name: "set_desired_seats",
arguments: [
FunctionArgumentMetadata {
name: "count",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
}
],
documentation: [
" Set the desired member count; if lower than the current count, then seats will not be up",
" election when they expire. If more, then a new vote will be started if one is not already",
" in progress."
]
},
FunctionMetadata {
name: "remove_member",
arguments: [
FunctionArgumentMetadata {
name: "who",
ty: TypeName {
type_name: Custom(
"srml_indices::address",
"Address"
),
display_name: "<T::Lookup as StaticLookup>::Source"
}
}
],
documentation: [
" Remove a particular member. A tally will happen instantly (if not already in a presentation",
" period) to fill the seat if removal means that the desired members are not met.",
" This is effective immediately."
]
},
FunctionMetadata {
name: "set_presentation_duration",
arguments: [
FunctionArgumentMetadata {
name: "count",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::BlockNumber>"
}
}
],
documentation: [
" Set the presentation duration. If there is currently a vote being presented for, will",
" invoke `finalise_vote`."
]
},
FunctionMetadata {
name: "set_term_duration",
arguments: [
FunctionArgumentMetadata {
name: "count",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::BlockNumber>"
}
}
],
documentation: [
" Set the presentation duration. If there is current a vote being presented for, will",
" invoke `finalise_vote`."
]
}
]
),
event: Some(
[
EventMetadata {
name: "VoterReaped",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
}
],
documentation: [
" reaped voter, reaper"
]
},
EventMetadata {
name: "BadReaperSlashed",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
}
],
documentation: [
" slashed reaper"
]
},
EventMetadata {
name: "TallyStarted",
arguments: [
TypeName {
type_name: U32,
display_name: "u32"
}
],
documentation: [
" A tally (for approval votes of council seat(s)) has started."
]
},
EventMetadata {
name: "TallyFinalised",
arguments: [
TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<AccountId>"
},
TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<AccountId>"
}
],
documentation: [
" A tally (for approval votes of council seat(s)) has ended (with one or more new members)."
]
}
]
)
},
ModuleMetadata {
name: "council_voting",
prefix: "CouncilVoting",
storage: Some(
[
StorageFunctionMetadata {
name: "CooloffPeriod",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
232,
3,
0,
0,
0,
0,
0,
0
],
documentation: []
},
StorageFunctionMetadata {
name: "VotingPeriod",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
3,
0,
0,
0,
0,
0,
0,
0
],
documentation: []
},
StorageFunctionMetadata {
name: "EnactDelayPeriod",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" Number of blocks by which to delay enactment of successful, non-unanimous-council-instigated referendum proposals."
]
},
StorageFunctionMetadata {
name: "Proposals",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
Tuple(
[
U64,
H256
]
)
),
display_name: "Vec<(T::BlockNumber, T::Hash)>"
}
),
default: [
0
],
documentation: []
},
StorageFunctionMetadata {
name: "ProposalOf",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: H256,
display_name: "T::Hash"
},
value: TypeName {
type_name: Custom(
"node_runtime",
"Call"
),
display_name: "T::Proposal"
}
},
default: [
0
],
documentation: []
},
StorageFunctionMetadata {
name: "ProposalVoters",
modifier: Default,
ty: Map {
key: TypeName {
type_name: H256,
display_name: "T::Hash"
},
value: TypeName {
type_name: Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
display_name: "Vec<T::AccountId>"
}
},
default: [
0
],
documentation: []
},
StorageFunctionMetadata {
name: "CouncilVoteOf",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: Tuple(
[
H256,
Custom(
"sr_primitives",
"AccountId"
)
]
),
display_name: "(T::Hash, T::AccountId)"
},
value: TypeName {
type_name: Bool,
display_name: "bool"
}
},
default: [
0
],
documentation: []
},
StorageFunctionMetadata {
name: "VetoedProposal",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: H256,
display_name: "T::Hash"
},
value: TypeName {
type_name: Tuple(
[
U64,
Vector(
Custom(
"sr_primitives",
"AccountId"
)
)
]
),
display_name: "(T::BlockNumber, Vec<T::AccountId>)"
}
},
default: [
0
],
documentation: []
}
]
),
calls: Some(
[
FunctionMetadata {
name: "propose",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: TypeName {
type_name: Custom(
"node_runtime",
"Call"
),
display_name: "Box<T::Proposal>"
}
}
],
documentation: []
},
FunctionMetadata {
name: "vote",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: TypeName {
type_name: H256,
display_name: "T::Hash"
}
},
FunctionArgumentMetadata {
name: "approve",
ty: TypeName {
type_name: Bool,
display_name: "bool"
}
}
],
documentation: []
},
FunctionMetadata {
name: "veto",
arguments: [
FunctionArgumentMetadata {
name: "proposal_hash",
ty: TypeName {
type_name: H256,
display_name: "T::Hash"
}
}
],
documentation: []
},
FunctionMetadata {
name: "set_cooloff_period",
arguments: [
FunctionArgumentMetadata {
name: "blocks",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::BlockNumber>"
}
}
],
documentation: []
},
FunctionMetadata {
name: "set_voting_period",
arguments: [
FunctionArgumentMetadata {
name: "blocks",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::BlockNumber>"
}
}
],
documentation: []
}
]
),
event: Some(
[
EventMetadata {
name: "TallyCancelation",
arguments: [
TypeName {
type_name: H256,
display_name: "Hash"
},
TypeName {
type_name: U32,
display_name: "u32"
},
TypeName {
type_name: U32,
display_name: "u32"
},
TypeName {
type_name: U32,
display_name: "u32"
}
],
documentation: [
" A voting tally has happened for a referendum cancellation vote.",
" Last three are yes, no, abstain counts."
]
},
EventMetadata {
name: "TallyReferendum",
arguments: [
TypeName {
type_name: H256,
display_name: "Hash"
},
TypeName {
type_name: U32,
display_name: "u32"
},
TypeName {
type_name: U32,
display_name: "u32"
},
TypeName {
type_name: U32,
display_name: "u32"
}
],
documentation: [
" A voting tally has happened for a referendum vote.",
" Last three are yes, no, abstain counts."
]
}
]
)
},
ModuleMetadata {
name: "council_motions",
prefix: "CouncilMotions",
storage: Some(
[
StorageFunctionMetadata {
name: "Proposals",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
H256
),
display_name: "Vec<T::Hash>"
}
),
default: [
0
],
documentation: [
" The (hashes of) the active proposals."
]
},
StorageFunctionMetadata {
name: "ProposalOf",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: H256,
display_name: "T::Hash"
},
value: TypeName {
type_name: Custom(
"node_runtime",
"Call"
),
display_name: "<T as Trait>::Proposal"
}
},
default: [
0
],
documentation: [
" Actual proposal for a given hash, if it\'s current."
]
},
StorageFunctionMetadata {
name: "Voting",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: H256,
display_name: "T::Hash"
},
value: TypeName {
type_name: Tuple(
[
U32,
U32,
Vector(
Custom(
"sr_primitives",
"AccountId"
)
),
Vector(
Custom(
"sr_primitives",
"AccountId"
)
)
]
),
display_name: "(ProposalIndex, u32, Vec<T::AccountId>, Vec<T::AccountId>)"
}
},
default: [
0
],
documentation: [
" Votes for a given proposal: (required_yes_votes, yes_voters, no_voters)."
]
},
StorageFunctionMetadata {
name: "ProposalCount",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "u32"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" Proposals so far."
]
}
]
),
calls: Some(
[
FunctionMetadata {
name: "propose",
arguments: [
FunctionArgumentMetadata {
name: "threshold",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<u32>"
}
},
FunctionArgumentMetadata {
name: "proposal",
ty: TypeName {
type_name: Custom(
"node_runtime",
"Call"
),
display_name: "Box<<T as Trait>::Proposal>"
}
}
],
documentation: []
},
FunctionMetadata {
name: "vote",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: TypeName {
type_name: H256,
display_name: "T::Hash"
}
},
FunctionArgumentMetadata {
name: "index",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<ProposalIndex>"
}
},
FunctionArgumentMetadata {
name: "approve",
ty: TypeName {
type_name: Bool,
display_name: "bool"
}
}
],
documentation: []
}
]
),
event: Some(
[
EventMetadata {
name: "Proposed",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: U32,
display_name: "ProposalIndex"
},
TypeName {
type_name: H256,
display_name: "Hash"
},
TypeName {
type_name: U32,
display_name: "u32"
}
],
documentation: [
" A motion (given hash) has been proposed (by given account) with a threshold (given u32)."
]
},
EventMetadata {
name: "Voted",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: H256,
display_name: "Hash"
},
TypeName {
type_name: Bool,
display_name: "bool"
},
TypeName {
type_name: U32,
display_name: "u32"
},
TypeName {
type_name: U32,
display_name: "u32"
}
],
documentation: [
" A motion (given hash) has been voted on by given account, leaving",
" a tally (yes votes and no votes given as u32s respectively)."
]
},
EventMetadata {
name: "Approved",
arguments: [
TypeName {
type_name: H256,
display_name: "Hash"
}
],
documentation: [
" A motion was approved by the required threshold."
]
},
EventMetadata {
name: "Disapproved",
arguments: [
TypeName {
type_name: H256,
display_name: "Hash"
}
],
documentation: [
" A motion was not approved by the required threshold."
]
},
EventMetadata {
name: "Executed",
arguments: [
TypeName {
type_name: H256,
display_name: "Hash"
},
TypeName {
type_name: Bool,
display_name: "bool"
}
],
documentation: [
" A motion was executed; `bool` is true if returned without error."
]
}
]
)
},
ModuleMetadata {
name: "grandpa",
prefix: "GrandpaFinality",
storage: Some(
[
StorageFunctionMetadata {
name: "PendingChange",
modifier: Optional,
ty: Plain(
TypeName {
type_name: CustomWithGenerics(
"srml_grandpa",
"StoredPendingChange",
[
U64,
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
)
]
),
display_name: "StoredPendingChange<T::BlockNumber, T::SessionKey>"
}
),
default: [
0
],
documentation: []
}
]
),
calls: Some(
[
FunctionMetadata {
name: "report_misbehavior",
arguments: [
FunctionArgumentMetadata {
name: "_report",
ty: TypeName {
type_name: Vector(
U8
),
display_name: "Vec<u8>"
}
}
],
documentation: [
" Report some misbehaviour."
]
}
]
),
event: Some(
[
EventMetadata {
name: "NewAuthorities",
arguments: [
TypeName {
type_name: Vector(
Tuple(
[
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
),
U64
]
)
),
display_name: "Vec<(SessionKey, u64)>"
}
],
documentation: [
" New authority set has been applied."
]
}
]
)
},
ModuleMetadata {
name: "treasury",
prefix: "Treasury",
storage: Some(
[
StorageFunctionMetadata {
name: "ProposalBond",
modifier: Default,
ty: Plain(
TypeName {
type_name: Custom(
"sr_primitives",
"Permill"
),
display_name: "Permill"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" Proportion of funds that should be bonded in order to place a proposal. An accepted",
" proposal gets these back. A rejected proposal doesn\'t."
]
},
StorageFunctionMetadata {
name: "ProposalBondMinimum",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "BalanceOf<T>"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" Minimum amount of funds that should be placed in a deposit for making a proposal."
]
},
StorageFunctionMetadata {
name: "SpendPeriod",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::BlockNumber"
}
),
default: [
1,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" Period between successive spends."
]
},
StorageFunctionMetadata {
name: "Burn",
modifier: Default,
ty: Plain(
TypeName {
type_name: Custom(
"sr_primitives",
"Permill"
),
display_name: "Permill"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" Percentage of spare funds (if any) that are burnt per spend period."
]
},
StorageFunctionMetadata {
name: "Pot",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "BalanceOf<T>"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" Total funds available to this module for spending."
]
},
StorageFunctionMetadata {
name: "ProposalCount",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "ProposalIndex"
}
),
default: [
0,
0,
0,
0
],
documentation: [
" Number of proposals that have been made."
]
},
StorageFunctionMetadata {
name: "Proposals",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: U32,
display_name: "ProposalIndex"
},
value: TypeName {
type_name: CustomWithGenerics(
"srml_treasury",
"Proposal",
[
Custom(
"sr_primitives",
"AccountId"
),
U128
]
),
display_name: "Proposal<T::AccountId, BalanceOf<T>>"
}
},
default: [
0
],
documentation: [
" Proposals that have been made."
]
},
StorageFunctionMetadata {
name: "Approvals",
modifier: Default,
ty: Plain(
TypeName {
type_name: Vector(
U32
),
display_name: "Vec<ProposalIndex>"
}
),
default: [
0
],
documentation: [
" Proposal indices that have been approved but not yet awarded."
]
}
]
),
calls: Some(
[
FunctionMetadata {
name: "propose_spend",
arguments: [
FunctionArgumentMetadata {
name: "value",
ty: TypeName {
type_name: Compact(
U128
),
display_name: "Compact<BalanceOf<T>>"
}
},
FunctionArgumentMetadata {
name: "beneficiary",
ty: TypeName {
type_name: Custom(
"srml_indices::address",
"Address"
),
display_name: "<T::Lookup as StaticLookup>::Source"
}
}
],
documentation: [
" Put forward a suggestion for spending. A deposit proportional to the value",
" is reserved and slashed if the proposal is rejected. It is returned once the",
" proposal is awarded."
]
},
FunctionMetadata {
name: "set_pot",
arguments: [
FunctionArgumentMetadata {
name: "new_pot",
ty: TypeName {
type_name: Compact(
U128
),
display_name: "Compact<BalanceOf<T>>"
}
}
],
documentation: [
" Set the balance of funds available to spend."
]
},
FunctionMetadata {
name: "configure",
arguments: [
FunctionArgumentMetadata {
name: "proposal_bond",
ty: TypeName {
type_name: Compact(
Custom(
"sr_primitives",
"Permill"
)
),
display_name: "Compact<Permill>"
}
},
FunctionArgumentMetadata {
name: "proposal_bond_minimum",
ty: TypeName {
type_name: Compact(
U128
),
display_name: "Compact<BalanceOf<T>>"
}
},
FunctionArgumentMetadata {
name: "spend_period",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::BlockNumber>"
}
},
FunctionArgumentMetadata {
name: "burn",
ty: TypeName {
type_name: Compact(
Custom(
"sr_primitives",
"Permill"
)
),
display_name: "Compact<Permill>"
}
}
],
documentation: [
" (Re-)configure this module."
]
},
FunctionMetadata {
name: "reject_proposal",
arguments: [
FunctionArgumentMetadata {
name: "proposal_id",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<ProposalIndex>"
}
}
],
documentation: [
" Reject a proposed spend. The original deposit will be slashed."
]
},
FunctionMetadata {
name: "approve_proposal",
arguments: [
FunctionArgumentMetadata {
name: "proposal_id",
ty: TypeName {
type_name: Compact(
U32
),
display_name: "Compact<ProposalIndex>"
}
}
],
documentation: [
" Approve a proposal. At a later time, the proposal will be allocated to the beneficiary",
" and the original deposit will be returned."
]
}
]
),
event: Some(
[
EventMetadata {
name: "Proposed",
arguments: [
TypeName {
type_name: U32,
display_name: "ProposalIndex"
}
],
documentation: [
" New proposal."
]
},
EventMetadata {
name: "Spending",
arguments: [
TypeName {
type_name: U128,
display_name: "Balance"
}
],
documentation: [
" We have ended a spend period and will now allocate funds."
]
},
EventMetadata {
name: "Awarded",
arguments: [
TypeName {
type_name: U32,
display_name: "ProposalIndex"
},
TypeName {
type_name: U128,
display_name: "Balance"
},
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
}
],
documentation: [
" Some funds have been allocated."
]
},
EventMetadata {
name: "Burnt",
arguments: [
TypeName {
type_name: U128,
display_name: "Balance"
}
],
documentation: [
" Some of our funds have been burnt."
]
},
EventMetadata {
name: "Rollover",
arguments: [
TypeName {
type_name: U128,
display_name: "Balance"
}
],
documentation: [
" Spending has finished; this is the amount that rolls over until next spend."
]
}
]
)
},
ModuleMetadata {
name: "contract",
prefix: "Contract",
storage: Some(
[
StorageFunctionMetadata {
name: "ContractFee",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "T::Balance"
}
),
default: [
21,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The fee required to create a contract. At least as big as staking\'s ReclaimRebate."
]
},
StorageFunctionMetadata {
name: "CallBaseFee",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::Gas"
}
),
default: [
135,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The fee charged for a call into a contract."
]
},
StorageFunctionMetadata {
name: "CreateBaseFee",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::Gas"
}
),
default: [
175,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The fee charged for a create of a contract."
]
},
StorageFunctionMetadata {
name: "GasPrice",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "T::Balance"
}
),
default: [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The price of one unit of gas."
]
},
StorageFunctionMetadata {
name: "MaxDepth",
modifier: Default,
ty: Plain(
TypeName {
type_name: U32,
display_name: "u32"
}
),
default: [
100,
0,
0,
0
],
documentation: [
" The maximum nesting level of a call/create stack."
]
},
StorageFunctionMetadata {
name: "BlockGasLimit",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::Gas"
}
),
default: [
64,
66,
15,
0,
0,
0,
0,
0
],
documentation: [
" The maximum amount of gas that could be expended per block."
]
},
StorageFunctionMetadata {
name: "GasSpent",
modifier: Default,
ty: Plain(
TypeName {
type_name: U64,
display_name: "T::Gas"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" Gas spent so far in this block."
]
},
StorageFunctionMetadata {
name: "CurrentSchedule",
modifier: Default,
ty: Plain(
TypeName {
type_name: CustomWithGenerics(
"srml_contract",
"Schedule",
[
U64
]
),
display_name: "Schedule<T::Gas>"
}
),
default: [
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
16,
0,
0,
0
],
documentation: [
" Current cost schedule for contracts."
]
},
StorageFunctionMetadata {
name: "CodeHashOf",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
},
value: TypeName {
type_name: H256,
display_name: "CodeHash<T>"
}
},
default: [
0
],
documentation: [
" The code associated with a given account."
]
},
StorageFunctionMetadata {
name: "PristineCode",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: H256,
display_name: "CodeHash<T>"
},
value: TypeName {
type_name: Vector(
U8
),
display_name: "Vec<u8>"
}
},
default: [
0
],
documentation: [
" A mapping from an original code hash to the original code, untouched by instrumentation."
]
},
StorageFunctionMetadata {
name: "CodeStorage",
modifier: Optional,
ty: Map {
key: TypeName {
type_name: H256,
display_name: "CodeHash<T>"
},
value: TypeName {
type_name: Custom(
"srml_contract::wasm",
"PrefabWasmModule"
),
display_name: "wasm::PrefabWasmModule"
}
},
default: [
0
],
documentation: [
" A mapping between an original code hash and instrumented wasm code, ready for the execution."
]
}
]
),
calls: Some(
[
FunctionMetadata {
name: "update_schedule",
arguments: [
FunctionArgumentMetadata {
name: "schedule",
ty: TypeName {
type_name: CustomWithGenerics(
"srml_contract",
"Schedule",
[
U64
]
),
display_name: "Schedule<T::Gas>"
}
}
],
documentation: [
" Updates the schedule for metering contracts.",
"",
" The schedule must have a greater version than the stored schedule."
]
},
FunctionMetadata {
name: "put_code",
arguments: [
FunctionArgumentMetadata {
name: "gas_limit",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::Gas>"
}
},
FunctionArgumentMetadata {
name: "code",
ty: TypeName {
type_name: Vector(
U8
),
display_name: "Vec<u8>"
}
}
],
documentation: [
" Stores code in the storage. You can instantiate contracts only with stored code."
]
},
FunctionMetadata {
name: "call",
arguments: [
FunctionArgumentMetadata {
name: "dest",
ty: TypeName {
type_name: Custom(
"srml_indices::address",
"Address"
),
display_name: "<T::Lookup as StaticLookup>::Source"
}
},
FunctionArgumentMetadata {
name: "value",
ty: TypeName {
type_name: Compact(
U128
),
display_name: "Compact<T::Balance>"
}
},
FunctionArgumentMetadata {
name: "gas_limit",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::Gas>"
}
},
FunctionArgumentMetadata {
name: "data",
ty: TypeName {
type_name: Vector(
U8
),
display_name: "Vec<u8>"
}
}
],
documentation: [
" Make a call to a specified account, optionally transferring some balance."
]
},
FunctionMetadata {
name: "create",
arguments: [
FunctionArgumentMetadata {
name: "endowment",
ty: TypeName {
type_name: Compact(
U128
),
display_name: "Compact<T::Balance>"
}
},
FunctionArgumentMetadata {
name: "gas_limit",
ty: TypeName {
type_name: Compact(
U64
),
display_name: "Compact<T::Gas>"
}
},
FunctionArgumentMetadata {
name: "code_hash",
ty: TypeName {
type_name: H256,
display_name: "CodeHash<T>"
}
},
FunctionArgumentMetadata {
name: "data",
ty: TypeName {
type_name: Vector(
U8
),
display_name: "Vec<u8>"
}
}
],
documentation: [
" Create a new contract, optionally transfering some balance to the created account.",
"",
" Creation is executed as follows:",
"",
" - the destination address is computed based on the sender and hash of the code.",
" - account is created at the computed address.",
" - the `ctor_code` is executed in the context of the newly created account. Buffer returned",
" after the execution is saved as the `code` of the account. That code will be invoked",
" upon any message received by this account."
]
}
]
),
event: Some(
[
EventMetadata {
name: "Transfer",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: U128,
display_name: "Balance"
}
],
documentation: [
" Transfer happened `from` -> `to` with given `value` as part of a `message-call` or `create`."
]
},
EventMetadata {
name: "Instantiated",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
}
],
documentation: [
" Contract deployed by address at the specified address."
]
},
EventMetadata {
name: "CodeStored",
arguments: [
TypeName {
type_name: H256,
display_name: "Hash"
}
],
documentation: [
" Code with the specified hash has been stored."
]
},
EventMetadata {
name: "ScheduleUpdated",
arguments: [
TypeName {
type_name: U32,
display_name: "u32"
}
],
documentation: [
" Triggered when the current schedule is updated."
]
},
EventMetadata {
name: "Dispatched",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
},
TypeName {
type_name: Bool,
display_name: "bool"
}
],
documentation: [
" A call was dispatched from the given account. The bool signals whether it was",
" successful execution or not."
]
}
]
)
},
ModuleMetadata {
name: "sudo",
prefix: "Sudo",
storage: Some(
[
StorageFunctionMetadata {
name: "Key",
modifier: Default,
ty: Plain(
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "T::AccountId"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: []
}
]
),
calls: Some(
[
FunctionMetadata {
name: "sudo",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: TypeName {
type_name: Custom(
"node_runtime",
"Call"
),
display_name: "Box<T::Proposal>"
}
}
],
documentation: []
},
FunctionMetadata {
name: "set_key",
arguments: [
FunctionArgumentMetadata {
name: "new",
ty: TypeName {
type_name: Custom(
"srml_indices::address",
"Address"
),
display_name: "<T::Lookup as StaticLookup>::Source"
}
}
],
documentation: []
}
]
),
event: Some(
[
EventMetadata {
name: "Sudid",
arguments: [
TypeName {
type_name: Bool,
display_name: "bool"
}
],
documentation: [
" A sudo just took place."
]
},
EventMetadata {
name: "KeyChanged",
arguments: [
TypeName {
type_name: Custom(
"sr_primitives",
"AccountId"
),
display_name: "AccountId"
}
],
documentation: [
" The sudoer just switched identity; the old key is supplied."
]
}
]
)
},
ModuleMetadata {
name: "fees",
prefix: "Fees",
storage: Some(
[
StorageFunctionMetadata {
name: "TransactionBaseFee",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "AssetOf<T>"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The fee to be paid for making a transaction; the base."
]
},
StorageFunctionMetadata {
name: "TransactionByteFee",
modifier: Default,
ty: Plain(
TypeName {
type_name: U128,
display_name: "AssetOf<T>"
}
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The fee to be paid for making a transaction; the per-byte portion."
]
},
StorageFunctionMetadata {
name: "CurrentTransactionFee",
modifier: Default,
ty: Map {
key: TypeName {
type_name: U32,
display_name: "u32"
},
value: TypeName {
type_name: U128,
display_name: "AssetOf<T>"
}
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
documentation: [
" The `extrinsic_index => accumulated_fees` map, containing records to",
" track the overall charged fees for each transaction.",
"",
" All records should be removed at finalise stage."
]
}
]
),
calls: None,
event: Some(
[
EventMetadata {
name: "Charged",
arguments: [
TypeName {
type_name: U32,
display_name: "u32"
},
TypeName {
type_name: U128,
display_name: "Amount"
}
],
documentation: [
" Fee charged (extrinsic_index, fee_amount)"
]
}
]
)
}
],
module_path: "node_runtime",
type_registry: MetadataRegistry {
list: [
TypeMetadata {
name: CustomWithGenerics(
"sr_primitives::generic::block",
"Block",
[
CustomWithGenerics(
"sr_primitives::generic::header",
"Header",
[
U64,
Custom(
"sr_primitives::traits",
"BlakeTwo256"
),
Custom(
"node_runtime",
"Log"
)
]
),
CustomWithGenerics(
"sr_primitives::generic::unchecked_mortal_compact_extrinsic",
"UncheckedMortalCompactExtrinsic",
[
Custom(
"srml_indices::address",
"Address"
),
U64,
Custom(
"node_runtime",
"Call"
),
Custom(
"sr_primitives",
"Ed25519Signature"
)
]
)
]
),
kind: Struct(
[
FieldMetadata {
name: Named(
"header"
),
ty: CustomWithGenerics(
"sr_primitives::generic::header",
"Header",
[
U64,
Custom(
"sr_primitives::traits",
"BlakeTwo256"
),
Custom(
"node_runtime",
"Log"
)
]
)
},
FieldMetadata {
name: Named(
"extrinsics"
),
ty: Vector(
CustomWithGenerics(
"sr_primitives::generic::unchecked_mortal_compact_extrinsic",
"UncheckedMortalCompactExtrinsic",
[
Custom(
"srml_indices::address",
"Address"
),
U64,
Custom(
"node_runtime",
"Call"
),
Custom(
"sr_primitives",
"Ed25519Signature"
)
]
)
)
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"sr_primitives::generic::header",
"Header",
[
U64,
Custom(
"sr_primitives::traits",
"BlakeTwo256"
),
Custom(
"node_runtime",
"Log"
)
]
),
kind: Struct(
[
FieldMetadata {
name: Named(
"parent_hash"
),
ty: H256
},
FieldMetadata {
name: Named(
"number"
),
ty: U64
},
FieldMetadata {
name: Named(
"state_root"
),
ty: H256
},
FieldMetadata {
name: Named(
"extrinsics_root"
),
ty: H256
},
FieldMetadata {
name: Named(
"digest"
),
ty: CustomWithGenerics(
"sr_primitives::generic::digest",
"Digest",
[
Custom(
"node_runtime",
"Log"
)
]
)
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"sr_primitives::generic::digest",
"Digest",
[
Custom(
"node_runtime",
"Log"
)
]
),
kind: Struct(
[
FieldMetadata {
name: Named(
"logs"
),
ty: Vector(
Custom(
"node_runtime",
"Log"
)
)
}
]
)
},
TypeMetadata {
name: Custom(
"node_runtime",
"Log"
),
kind: Struct(
[
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"node_runtime",
"InternalLog"
)
}
]
)
},
TypeMetadata {
name: Custom(
"node_runtime",
"InternalLog"
),
kind: Enum(
[
EnumVariantMetadata {
name: "system",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_system",
"RawLog",
[
H256
]
)
}
]
},
EnumVariantMetadata {
name: "consensus",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_consensus",
"RawLog",
[
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
)
]
)
}
]
},
EnumVariantMetadata {
name: "grandpa",
index: 2,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_grandpa",
"RawLog",
[
U64,
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
)
]
)
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_system",
"RawLog",
[
H256
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "ChangesTrieRoot",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: H256
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_consensus",
"RawLog",
[
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
)
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "AuthoritiesChange",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Vector(
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
)
)
}
]
}
]
)
},
TypeMetadata {
name: Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
),
kind: Struct(
[
FieldMetadata {
name: Unnamed(
0
),
ty: Array(
32,
U8
)
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_grandpa",
"RawLog",
[
U64,
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
)
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "AuthoritiesChangeSignal",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U64
},
FieldMetadata {
name: Unnamed(
1
),
ty: Vector(
Tuple(
[
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
),
U64
]
)
)
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"sr_primitives::generic::unchecked_mortal_compact_extrinsic",
"UncheckedMortalCompactExtrinsic",
[
Custom(
"srml_indices::address",
"Address"
),
U64,
Custom(
"node_runtime",
"Call"
),
Custom(
"sr_primitives",
"Ed25519Signature"
)
]
),
kind: Struct(
[
FieldMetadata {
name: Named(
"signature"
),
ty: Option(
Tuple(
[
Custom(
"srml_indices::address",
"Address"
),
Custom(
"sr_primitives",
"Ed25519Signature"
),
Compact(
U64
),
Custom(
"sr_primitives::generic::era",
"Era"
)
]
)
)
},
FieldMetadata {
name: Named(
"function"
),
ty: Custom(
"node_runtime",
"Call"
)
}
]
)
},
TypeMetadata {
name: Custom(
"srml_indices::address",
"Address"
),
kind: Primitive
},
TypeMetadata {
name: Custom(
"sr_primitives",
"Ed25519Signature"
),
kind: Struct(
[
FieldMetadata {
name: Unnamed(
0
),
ty: H512
}
]
)
},
TypeMetadata {
name: Custom(
"sr_primitives::generic::era",
"Era"
),
kind: Enum(
[
EnumVariantMetadata {
name: "Immortal",
index: 0,
fields: []
},
EnumVariantMetadata {
name: "Mortal",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U64
},
FieldMetadata {
name: Unnamed(
1
),
ty: U64
}
]
}
]
)
},
TypeMetadata {
name: Custom(
"node_runtime",
"Call"
),
kind: Enum(
[
EnumVariantMetadata {
name: "Timestamp",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_timestamp",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "Consensus",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_consensus",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "Indices",
index: 2,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_indices",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "Balances",
index: 3,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_balances",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "Session",
index: 4,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_session",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "Staking",
index: 5,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_staking",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "Democracy",
index: 6,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_democracy",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "Council",
index: 7,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_council::seats",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "CouncilVoting",
index: 8,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_council::voting",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "CouncilMotions",
index: 9,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_council::motions",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "Grandpa",
index: 10,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_grandpa",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "Treasury",
index: 11,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_treasury",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "Contract",
index: 12,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_contract",
"Module"
)
}
]
},
EnumVariantMetadata {
name: "Sudo",
index: 13,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_sudo",
"Module"
)
}
]
}
]
)
},
TypeMetadata {
name: Custom(
"srml_timestamp",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_consensus",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_indices",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_balances",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_session",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_staking",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_democracy",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_council::seats",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_council::voting",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_council::motions",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_grandpa",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_treasury",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_contract",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"srml_sudo",
"Module"
),
kind: Struct(
[]
)
},
TypeMetadata {
name: Custom(
"sr_primitives",
"AccountId"
),
kind: Struct(
[
FieldMetadata {
name: Unnamed(
0
),
ty: H256
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_system",
"EventRecord",
[
Custom(
"node_runtime",
"Event"
)
]
),
kind: Struct(
[
FieldMetadata {
name: Named(
"phase"
),
ty: Custom(
"srml_system",
"Phase"
)
},
FieldMetadata {
name: Named(
"event"
),
ty: Custom(
"node_runtime",
"Event"
)
}
]
)
},
TypeMetadata {
name: Custom(
"srml_system",
"Phase"
),
kind: Enum(
[
EnumVariantMetadata {
name: "ApplyExtrinsic",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
}
]
},
EnumVariantMetadata {
name: "Finalization",
index: 1,
fields: []
}
]
)
},
TypeMetadata {
name: Custom(
"node_runtime",
"Event"
),
kind: Enum(
[
EnumVariantMetadata {
name: "system",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"srml_system",
"Event"
)
}
]
},
EnumVariantMetadata {
name: "indices",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_indices",
"RawEvent",
[
Custom(
"sr_primitives",
"AccountId"
),
U32
]
)
}
]
},
EnumVariantMetadata {
name: "balances",
index: 2,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_balances",
"RawEvent",
[
Custom(
"sr_primitives",
"AccountId"
),
U128
]
)
}
]
},
EnumVariantMetadata {
name: "session",
index: 3,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_session",
"RawEvent",
[
U64
]
)
}
]
},
EnumVariantMetadata {
name: "staking",
index: 4,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_staking",
"RawEvent",
[
U128,
Custom(
"sr_primitives",
"AccountId"
)
]
)
}
]
},
EnumVariantMetadata {
name: "democracy",
index: 5,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_democracy",
"RawEvent",
[
U128,
Custom(
"sr_primitives",
"AccountId"
)
]
)
}
]
},
EnumVariantMetadata {
name: "council",
index: 6,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_council::seats",
"RawEvent",
[
Custom(
"sr_primitives",
"AccountId"
)
]
)
}
]
},
EnumVariantMetadata {
name: "council_voting",
index: 7,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_council::voting",
"RawEvent",
[
H256
]
)
}
]
},
EnumVariantMetadata {
name: "council_motions",
index: 8,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_council::motions",
"RawEvent",
[
H256,
Custom(
"sr_primitives",
"AccountId"
)
]
)
}
]
},
EnumVariantMetadata {
name: "grandpa",
index: 9,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_grandpa",
"RawEvent",
[
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
)
]
)
}
]
},
EnumVariantMetadata {
name: "treasury",
index: 10,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_treasury",
"RawEvent",
[
U128,
Custom(
"sr_primitives",
"AccountId"
)
]
)
}
]
},
EnumVariantMetadata {
name: "contract",
index: 11,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_contract",
"RawEvent",
[
U128,
Custom(
"sr_primitives",
"AccountId"
),
H256
]
)
}
]
},
EnumVariantMetadata {
name: "sudo",
index: 12,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_sudo",
"RawEvent",
[
Custom(
"sr_primitives",
"AccountId"
)
]
)
}
]
},
EnumVariantMetadata {
name: "fees",
index: 13,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: CustomWithGenerics(
"srml_fees",
"RawEvent",
[
U128
]
)
}
]
}
]
)
},
TypeMetadata {
name: Custom(
"srml_system",
"Event"
),
kind: Enum(
[
EnumVariantMetadata {
name: "ExtrinsicSuccess",
index: 0,
fields: []
},
EnumVariantMetadata {
name: "ExtrinsicFailed",
index: 1,
fields: []
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_indices",
"RawEvent",
[
Custom(
"sr_primitives",
"AccountId"
),
U32
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "NewAccountIndex",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: U32
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_balances",
"RawEvent",
[
Custom(
"sr_primitives",
"AccountId"
),
U128
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "NewAccount",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: U128
}
]
},
EnumVariantMetadata {
name: "ReapedAccount",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
}
]
},
EnumVariantMetadata {
name: "Transfer",
index: 2,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
2
),
ty: U128
},
FieldMetadata {
name: Unnamed(
3
),
ty: U128
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_session",
"RawEvent",
[
U64
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "NewSession",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U64
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_staking",
"RawEvent",
[
U128,
Custom(
"sr_primitives",
"AccountId"
)
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "Reward",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U128
}
]
},
EnumVariantMetadata {
name: "OfflineWarning",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: U32
}
]
},
EnumVariantMetadata {
name: "OfflineSlash",
index: 2,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: U128
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_democracy",
"RawEvent",
[
U128,
Custom(
"sr_primitives",
"AccountId"
)
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "Proposed",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
},
FieldMetadata {
name: Unnamed(
1
),
ty: U128
}
]
},
EnumVariantMetadata {
name: "Tabled",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
},
FieldMetadata {
name: Unnamed(
1
),
ty: U128
},
FieldMetadata {
name: Unnamed(
2
),
ty: Vector(
Custom(
"sr_primitives",
"AccountId"
)
)
}
]
},
EnumVariantMetadata {
name: "Started",
index: 2,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
},
FieldMetadata {
name: Unnamed(
1
),
ty: Custom(
"srml_democracy::vote_threshold",
"VoteThreshold"
)
}
]
},
EnumVariantMetadata {
name: "Passed",
index: 3,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
}
]
},
EnumVariantMetadata {
name: "NotPassed",
index: 4,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
}
]
},
EnumVariantMetadata {
name: "Cancelled",
index: 5,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
}
]
},
EnumVariantMetadata {
name: "Executed",
index: 6,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
},
FieldMetadata {
name: Unnamed(
1
),
ty: Bool
}
]
}
]
)
},
TypeMetadata {
name: Custom(
"srml_democracy::vote_threshold",
"VoteThreshold"
),
kind: Enum(
[
EnumVariantMetadata {
name: "SuperMajorityApprove",
index: 0,
fields: []
},
EnumVariantMetadata {
name: "SuperMajorityAgainst",
index: 1,
fields: []
},
EnumVariantMetadata {
name: "SimpleMajority",
index: 2,
fields: []
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_council::seats",
"RawEvent",
[
Custom(
"sr_primitives",
"AccountId"
)
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "VoterReaped",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: Custom(
"sr_primitives",
"AccountId"
)
}
]
},
EnumVariantMetadata {
name: "BadReaperSlashed",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
}
]
},
EnumVariantMetadata {
name: "TallyStarted",
index: 2,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
}
]
},
EnumVariantMetadata {
name: "TallyFinalised",
index: 3,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Vector(
Custom(
"sr_primitives",
"AccountId"
)
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: Vector(
Custom(
"sr_primitives",
"AccountId"
)
)
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_council::voting",
"RawEvent",
[
H256
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "TallyCancelation",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: H256
},
FieldMetadata {
name: Unnamed(
1
),
ty: U32
},
FieldMetadata {
name: Unnamed(
2
),
ty: U32
},
FieldMetadata {
name: Unnamed(
3
),
ty: U32
}
]
},
EnumVariantMetadata {
name: "TallyReferendum",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: H256
},
FieldMetadata {
name: Unnamed(
1
),
ty: U32
},
FieldMetadata {
name: Unnamed(
2
),
ty: U32
},
FieldMetadata {
name: Unnamed(
3
),
ty: U32
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_council::motions",
"RawEvent",
[
H256,
Custom(
"sr_primitives",
"AccountId"
)
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "Proposed",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: U32
},
FieldMetadata {
name: Unnamed(
2
),
ty: H256
},
FieldMetadata {
name: Unnamed(
3
),
ty: U32
}
]
},
EnumVariantMetadata {
name: "Voted",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: H256
},
FieldMetadata {
name: Unnamed(
2
),
ty: Bool
},
FieldMetadata {
name: Unnamed(
3
),
ty: U32
},
FieldMetadata {
name: Unnamed(
4
),
ty: U32
}
]
},
EnumVariantMetadata {
name: "Approved",
index: 2,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: H256
}
]
},
EnumVariantMetadata {
name: "Disapproved",
index: 3,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: H256
}
]
},
EnumVariantMetadata {
name: "Executed",
index: 4,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: H256
},
FieldMetadata {
name: Unnamed(
1
),
ty: Bool
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_grandpa",
"RawEvent",
[
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
)
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "NewAuthorities",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Vector(
Tuple(
[
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
),
U64
]
)
)
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_treasury",
"RawEvent",
[
U128,
Custom(
"sr_primitives",
"AccountId"
)
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "Proposed",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
}
]
},
EnumVariantMetadata {
name: "Spending",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U128
}
]
},
EnumVariantMetadata {
name: "Awarded",
index: 2,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
},
FieldMetadata {
name: Unnamed(
1
),
ty: U128
},
FieldMetadata {
name: Unnamed(
2
),
ty: Custom(
"sr_primitives",
"AccountId"
)
}
]
},
EnumVariantMetadata {
name: "Burnt",
index: 3,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U128
}
]
},
EnumVariantMetadata {
name: "Rollover",
index: 4,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U128
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_contract",
"RawEvent",
[
U128,
Custom(
"sr_primitives",
"AccountId"
),
H256
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "Transfer",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
2
),
ty: U128
}
]
},
EnumVariantMetadata {
name: "Instantiated",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: Custom(
"sr_primitives",
"AccountId"
)
}
]
},
EnumVariantMetadata {
name: "CodeStored",
index: 2,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: H256
}
]
},
EnumVariantMetadata {
name: "ScheduleUpdated",
index: 3,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
}
]
},
EnumVariantMetadata {
name: "Dispatched",
index: 4,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Unnamed(
1
),
ty: Bool
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_sudo",
"RawEvent",
[
Custom(
"sr_primitives",
"AccountId"
)
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "Sudid",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Bool
}
]
},
EnumVariantMetadata {
name: "KeyChanged",
index: 1,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: Custom(
"sr_primitives",
"AccountId"
)
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_fees",
"RawEvent",
[
U128
]
),
kind: Enum(
[
EnumVariantMetadata {
name: "Charged",
index: 0,
fields: [
FieldMetadata {
name: Unnamed(
0
),
ty: U32
},
FieldMetadata {
name: Unnamed(
1
),
ty: U128
}
]
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_balances",
"VestingSchedule",
[
U128
]
),
kind: Struct(
[
FieldMetadata {
name: Named(
"offset"
),
ty: U128
},
FieldMetadata {
name: Named(
"per_block"
),
ty: U128
}
]
)
},
TypeMetadata {
name: Custom(
"sr_primitives",
"Perbill"
),
kind: Struct(
[
FieldMetadata {
name: Unnamed(
0
),
ty: U32
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_staking",
"ValidatorPrefs",
[
U128
]
),
kind: Struct(
[
FieldMetadata {
name: Named(
"unstake_threshold"
),
ty: Compact(
U32
)
},
FieldMetadata {
name: Named(
"validator_payment"
),
ty: Compact(
U128
)
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_democracy",
"ReferendumInfo",
[
U64,
Custom(
"node_runtime",
"Call"
)
]
),
kind: Struct(
[
FieldMetadata {
name: Named(
"end"
),
ty: U64
},
FieldMetadata {
name: Named(
"proposal"
),
ty: Custom(
"node_runtime",
"Call"
)
},
FieldMetadata {
name: Named(
"threshold"
),
ty: Custom(
"srml_democracy::vote_threshold",
"VoteThreshold"
)
},
FieldMetadata {
name: Named(
"delay"
),
ty: U64
}
]
)
},
TypeMetadata {
name: Custom(
"srml_democracy",
"Vote"
),
kind: Struct(
[
FieldMetadata {
name: Unnamed(
0
),
ty: I8
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_grandpa",
"StoredPendingChange",
[
U64,
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
)
]
),
kind: Struct(
[
FieldMetadata {
name: Named(
"scheduled_at"
),
ty: U64
},
FieldMetadata {
name: Named(
"delay"
),
ty: U64
},
FieldMetadata {
name: Named(
"next_authorities"
),
ty: Vector(
Tuple(
[
Custom(
"substrate_primitives::authority_id",
"Ed25519AuthorityId"
),
U64
]
)
)
}
]
)
},
TypeMetadata {
name: Custom(
"sr_primitives",
"Permill"
),
kind: Struct(
[
FieldMetadata {
name: Unnamed(
0
),
ty: U32
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_treasury",
"Proposal",
[
Custom(
"sr_primitives",
"AccountId"
),
U128
]
),
kind: Struct(
[
FieldMetadata {
name: Named(
"proposer"
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Named(
"value"
),
ty: U128
},
FieldMetadata {
name: Named(
"beneficiary"
),
ty: Custom(
"sr_primitives",
"AccountId"
)
},
FieldMetadata {
name: Named(
"bond"
),
ty: U128
}
]
)
},
TypeMetadata {
name: CustomWithGenerics(
"srml_contract",
"Schedule",
[
U64
]
),
kind: Struct(
[
FieldMetadata {
name: Named(
"version"
),
ty: U32
},
FieldMetadata {
name: Named(
"put_code_per_byte_cost"
),
ty: U64
},
FieldMetadata {
name: Named(
"grow_mem_cost"
),
ty: U64
},
FieldMetadata {
name: Named(
"regular_op_cost"
),
ty: U64
},
FieldMetadata {
name: Named(
"return_data_per_byte_cost"
),
ty: U64
},
FieldMetadata {
name: Named(
"sandbox_data_read_cost"
),
ty: U64
},
FieldMetadata {
name: Named(
"sandbox_data_write_cost"
),
ty: U64
},
FieldMetadata {
name: Named(
"max_stack_height"
),
ty: U32
},
FieldMetadata {
name: Named(
"max_memory_pages"
),
ty: U32
}
]
)
},
TypeMetadata {
name: Custom(
"srml_contract::wasm",
"PrefabWasmModule"
),
kind: Struct(
[
FieldMetadata {
name: Named(
"schedule_version"
),
ty: Compact(
U32
)
},
FieldMetadata {
name: Named(
"initial"
),
ty: Compact(
U32
)
},
FieldMetadata {
name: Named(
"maximum"
),
ty: Compact(
U32
)
},
FieldMetadata {
name: Named(
"_reserved"
),
ty: Option(
Unit
)
},
FieldMetadata {
name: Named(
"code"
),
ty: Vector(
U8
)
}
]
)
}
]
},
block: CustomWithGenerics(
"sr_primitives::generic::block",
"Block",
[
CustomWithGenerics(
"sr_primitives::generic::header",
"Header",
[
U64,
Custom(
"sr_primitives::traits",
"BlakeTwo256"
),
Custom(
"node_runtime",
"Log"
)
]
),
CustomWithGenerics(
"sr_primitives::generic::unchecked_mortal_compact_extrinsic",
"UncheckedMortalCompactExtrinsic",
[
Custom(
"srml_indices::address",
"Address"
),
U64,
Custom(
"node_runtime",
"Call"
),
Custom(
"sr_primitives",
"Ed25519Signature"
)
]
)
]
)
}
)
)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment