types

type AccountID ¶

type AccountID [AccountIDLen]byte

AccountID represents a public key (an 32 byte array)

func NewAccountID(b []byte) (*AccountID, error)

func NewAccountIDFromHexString(accountIDHex string) (*AccountID, error)

func (a *AccountID) Equal(accountID *AccountID) bool

func (a AccountID) MarshalJSON() ([]byte, error)

func (a *AccountID) ToBytes() []byte

func (a *AccountID) ToHexString() string

func (a *AccountID) UnmarshalJSON(data []byte) error

type AccountIndex ¶

type AccountIndex uint32

AccountIndex is a shortened, variable-length encoding for an Account

func NewAccountIndex(i uint32) AccountIndex

type AccountInfo ¶

type AccountInfo struct {
	Nonce       U32
	Consumers   U32
	Providers   U32
	Sufficients U32
	Data        struct {
		Free       U128
		Reserved   U128
		MiscFrozen U128
		Flags      U128
	}
}

AccountInfo contains information of an account

type Address ¶

type Address struct {
	IsAccountID    bool
	AsAccountID    AccountID
	IsAccountIndex bool
	AsAccountIndex AccountIndex
}

Address is a wrapper around an AccountId or an AccountIndex. It is encoded with a prefix in case of an AccountID. Basically the Address is encoded as `[ <prefix-byte>, ...publicKey/...bytes ]` as per spec

func NewAddressFromAccountID(b []byte) (Address, error)

func NewAddressFromAccountIndex(u uint32) Address

func NewAddressFromHexAccountID(str string) (Address, error)

func (a *Address) Decode(decoder scale.Decoder) error

func (a Address) Encode(encoder scale.Encoder) error

type Args ¶

type Args []byte

Args are the encoded arguments for a Call

func (a *Args) Decode(decoder scale.Decoder) error

func (a Args) Encode(encoder scale.Encoder) error

type ArithmeticError ¶

type ArithmeticError struct {
	IsUnderflow bool

	IsOverflow bool

	IsDivisionByZero bool
}

func (a *ArithmeticError) Decode(decoder scale.Decoder) error

func (a ArithmeticError) Encode(encoder scale.Encoder) error

type AssetID ¶

type AssetID struct {
	Parents  U8
	Interior JunctionsV1
}

func (a *AssetID) Decode(decoder scale.Decoder) error

func (a AssetID) Encode(encoder scale.Encoder) error

type AssetInstance ¶

type AssetInstance struct {
	IsUndefined bool

	IsIndex bool
	Index   U128

	IsArray4 bool
	Array4   [4]U8

	IsArray8 bool
	Array8   [8]U8

	IsArray16 bool
	Array16   [16]U8

	IsArray32 bool
	Array32   [32]U8

	IsBlob bool
	Blob   []U8
}

func (a *AssetInstance) Decode(decoder scale.Decoder) error

func (a AssetInstance) Encode(encoder scale.Encoder) error

type AssetMetadata ¶

type AssetMetadata struct {
	Decimals           U32
	Name               []U8
	Symbol             []U8
	ExistentialBalance U128
	Location           Option[VersionedMultiLocation]
	Additional         CustomMetadata
}

type AuthorityID ¶

type AuthorityID [32]byte

AuthorityID represents a public key (an 32 byte array)

func NewAuthorityID(b [32]byte) AuthorityID

type BalanceStatus ¶

type BalanceStatus byte

const (
	// Funds are free, as corresponding to `free` item in Balances.
	Free BalanceStatus = 0
	// Funds are reserved, as corresponding to `reserved` item in Balances.
	Reserved BalanceStatus = 1
)

func (bs *BalanceStatus) Decode(decoder scale.Decoder) error

func (bs BalanceStatus) Encode(encoder scale.Encoder) error

type BeefyNextAuthoritySet ¶

type BeefyNextAuthoritySet struct {
	// ID
	ID U64
	// Number of validators in the set.
	Len U32
	// Merkle Root Hash build from BEEFY uncompressed AuthorityIds.
	Root H256
}

type BeefySignature ¶

type BeefySignature [65]byte

BeefySignature is a beefy signature

type BitOrder ¶

type BitOrder uint

const (
	BitOrderLsb0 BitOrder = iota
	BitOrderMsb0
)

func NewBitOrderFromString(s string) (BitOrder, error)

func (b *BitOrder) String() string

type BitVec ¶

type BitVec struct {
	BitOrder BitOrder

	ByteSlice []uint8
}

func NewBitVec(bitOrder BitOrder) *BitVec

func (b *BitVec) Decode(decoder scale.Decoder) error

func (b *BitVec) GetMinimumNumberOfBytes(decoder scale.Decoder) (uint, error)

func (b *BitVec) String() string

type BlockNumber ¶

type BlockNumber U32

func (b *BlockNumber) Decode(decoder scale.Decoder) error

func (b BlockNumber) Encode(encoder scale.Encoder) error

func (b BlockNumber) MarshalJSON() ([]byte, error)

func (b *BlockNumber) UnmarshalJSON(bz []byte) error

type BodyID ¶

type BodyID struct {
	IsUnit bool

	IsNamed bool
	Body    []U8

	IsIndex bool
	Index   U32

	IsExecutive bool

	IsTechnical bool

	IsLegislative bool

	IsJudicial bool
}

func (b *BodyID) Decode(decoder scale.Decoder) error

func (b BodyID) Encode(encoder scale.Encoder) error

type BodyPart ¶

type BodyPart struct {
	IsVoice bool

	IsMembers    bool
	MembersCount U32

	IsFraction    bool
	FractionNom   U32
	FractionDenom U32

	IsAtLeastProportion    bool
	AtLeastProportionNom   U32
	AtLeastProportionDenom U32

	IsMoreThanProportion    bool
	MoreThanProportionNom   U32
	MoreThanProportionDenom U32
}

func (b *BodyPart) Decode(decoder scale.Decoder) error

func (b BodyPart) Encode(encoder scale.Encoder) error

type Bool ¶

type Bool bool

Bool represents boolean values

func NewBool(b bool) Bool

type BountyIndex ¶

type BountyIndex U32

type Bytes ¶

type Bytes []byte

Bytes represents byte slices. Bytes has a variable length, it is encoded with a scale prefix

func NewBytes(b []byte) Bytes

type Bytes8 ¶

type Bytes8 [8]byte

Bytes8 represents an 8 byte array

func NewBytes8(b [8]byte) Bytes8

type Bytes16 ¶

type Bytes16 [16]byte

Bytes16 represents an 16 byte array

func NewBytes16(b [16]byte) Bytes16

type Bytes32 ¶

type Bytes32 [32]byte

Bytes32 represents an 32 byte array

func NewBytes32(b [32]byte) Bytes32

type Bytes64 ¶

type Bytes64 [64]byte

Bytes64 represents an 64 byte array

func NewBytes64(b [64]byte) Bytes64

type Bytes128 ¶

type Bytes128 [128]byte

Bytes128 represents an 128 byte array

func NewBytes128(b [128]byte) Bytes128

type Bytes256 ¶

type Bytes256 [256]byte

Bytes256 represents an 256 byte array

func NewBytes256(b [256]byte) Bytes256

type Bytes512 ¶

type Bytes512 [512]byte

Bytes512 represents an 512 byte array

func NewBytes512(b [512]byte) Bytes512

type Bytes1024 ¶

type Bytes1024 [1024]byte

Bytes1024 represents an 1024 byte array

func NewBytes1024(b [1024]byte) Bytes1024

type Bytes2048 ¶

type Bytes2048 [2048]byte

Bytes2048 represents an 2048 byte array

func NewBytes2048(b [2048]byte) Bytes2048

type BytesBare ¶

type BytesBare []byte

BytesBare represents byte slices that will be encoded bare, i. e. without a compact length prefix. This makes it impossible to decode the bytes, but is used as the payload for signing.

func (b *BytesBare) Decode(decoder scale.Decoder) error

func (b BytesBare) Encode(encoder scale.Encoder) error

type Call ¶

type Call struct {
	CallIndex CallIndex
	Args      Args
}

Call is the extrinsic function descriptor

func NewCall(m *Metadata, call string, args ...interface{}) (Call, error)

type CallIndex ¶

type CallIndex struct {
	SectionIndex uint8
	MethodIndex  uint8
}

Callindex is a 16 bit wrapper around the `[sectionIndex, methodIndex]` value that uniquely identifies a method

func (m *CallIndex) Decode(decoder scale.Decoder) error

func (m CallIndex) Encode(encoder scale.Encoder) error

type CandidateDescriptor ¶

type CandidateDescriptor struct {
	ParachainID                  ParachainID
	RelayParent                  Hash
	CollatorID                   CollatorID
	PersistentValidationDataHash Hash
	PoVHash                      Hash
	ErasureRoot                  Hash
	CollatorSignature            CollatorSignature
	ParaHead                     Hash
	ValidationCodeHash           Hash
}

type CandidateReceipt ¶

type CandidateReceipt struct {
	Descriptor CandidateDescriptor

	CommitmentsHash Hash
}

type ChainProperties ¶

type ChainProperties struct {
	IsSS58Format    bool
	AsSS58Format    U8
	IsTokenDecimals bool
	AsTokenDecimals U32
	IsTokenSymbol   bool
	AsTokenSymbol   Text
}

ChainProperties contains the SS58 format, the token decimals and the token symbol

func (a *ChainProperties) Decode(decoder scale.Decoder) error

func (a ChainProperties) Encode(encoder scale.Encoder) error

type ChangesTrieConfiguration ¶

type ChangesTrieConfiguration struct {
	DigestInterval U32
	DigestLevels   U32
}

type ChangesTrieSignal ¶

type ChangesTrieSignal struct {
	IsNewConfiguration bool
	AsNewConfiguration Bytes
}

func (c *ChangesTrieSignal) Decode(decoder scale.Decoder) error

func (c ChangesTrieSignal) Encode(encoder scale.Encoder) error

type ClassMetadata ¶

type ClassMetadata struct {
	Deposit  U128
	Data     Bytes
	IsFrozen bool
}

func (c *ClassMetadata) Decode(decoder scale.Decoder) error

func (c ClassMetadata) Encode(encoder scale.Encoder) error

type CollatorID ¶

type CollatorID [32]U8

type CollatorSignature ¶

type CollatorSignature [64]U8

type CollectionDetails ¶

type CollectionDetails struct {
	Owner             AccountID
	Issuer            AccountID
	Admin             AccountID
	Freezer           AccountID
	TotalDeposit      U128
	FreeHolding       bool
	Instances         U32
	InstanceMetadatas U32
	Attributes        U32
	IsFrozen          bool
}

func (c *CollectionDetails) Decode(decoder scale.Decoder) error

func (c CollectionDetails) Encode(encoder scale.Encoder) error

type Commitment ¶

type Commitment struct {
	Payload        []PayloadItem
	BlockNumber    uint32
	ValidatorSetID uint64
}

Commitment is a beefy commitment

type CompactSignedCommitment ¶

type CompactSignedCommitment struct {
	Commitment        Commitment
	SignaturesFrom    []byte
	ValidatorSetLen   uint32
	SignaturesCompact []BeefySignature
}

type Consensus ¶

type Consensus struct {
	ConsensusEngineID ConsensusEngineID
	Bytes             Bytes
}

type ConsensusEngineID ¶

type ConsensusEngineID U32

ConsensusEngineID is a 4-byte identifier (actually a [u8; 4]) identifying the engine, e.g. for Aura it would be [b'a', b'u', b'r', b'a']

type ConstantMetadataV14 ¶

type ConstantMetadataV14 struct {
	Name  Text
	Type  Si1LookupTypeID
	Value Bytes
	Docs  []Text
}

type CoreIndex ¶

type CoreIndex U32

type CrossChainTransferability ¶

type CrossChainTransferability struct {
	IsNone bool

	IsXcm bool
	AsXcm XcmMetadata

	IsConnectors bool

	IsAll bool
	AsAll XcmMetadata
}

func (c *CrossChainTransferability) Decode(decoder scale.Decoder) error

func (c CrossChainTransferability) Encode(encoder scale.Encoder) error

type CrowloadMemo ¶

type CrowloadMemo []byte

type CurrencyID ¶

type CurrencyID struct {
	IsNative bool

	IsTranche bool
	Tranche   Tranche

	IsKSM bool

	IsAUSD bool

	IsForeignAsset bool
	AsForeignAsset U32

	IsStaking bool
	AsStaking StakingCurrency
}

func (c *CurrencyID) Decode(decoder scale.Decoder) error

func (c CurrencyID) Encode(encoder scale.Encoder) error

type CustomMetadata ¶

type CustomMetadata struct {
	Transferability CrossChainTransferability
	Mintable        bool
	Permissioned    bool
	PoolCurrency    bool
}

type Data ¶

type Data []byte

Data is a raw data structure, containing raw bytes that are not decoded/encoded (without any length encoding). Be careful using this in your own structs – it only works as the last value in a struct since it will consume the remainder of the encoded data. The reason for this is that it does not contain any length encoding, so it would not know where to stop.

func NewData(b []byte) Data

func (d *Data) Decode(decoder scale.Decoder) error

func (d Data) Encode(encoder scale.Encoder) error

func (d Data) Hex() string

type DemocracyConviction ¶

type DemocracyConviction byte

func (dc *DemocracyConviction) Decode(decoder scale.Decoder) error

func (dc DemocracyConviction) Encode(encoder scale.Encoder) error

type DemocracyVote ¶

type DemocracyVote struct {
	Aye        bool
	Conviction DemocracyConviction
}

func (d *DemocracyVote) Decode(decoder scale.Decoder) error

func (d DemocracyVote) Encode(encoder scale.Encoder) error

type Digest ¶

type Digest []DigestItem

Digest contains logs

func (d Digest) MarshalJSON() ([]byte, error)

func (d *Digest) UnmarshalJSON(bz []byte) error

type DigestItem ¶

type DigestItem struct {
	IsChangesTrieRoot   bool // 2
	AsChangesTrieRoot   Hash
	IsPreRuntime        bool // 6
	AsPreRuntime        PreRuntime
	IsConsensus         bool // 4
	AsConsensus         Consensus
	IsSeal              bool // 5
	AsSeal              Seal
	IsChangesTrieSignal bool // 7
	AsChangesTrieSignal ChangesTrieSignal
	IsOther             bool // 0
	AsOther             Bytes
}

DigestItem specifies the item in the logs of a digest

func (m *DigestItem) Decode(decoder scale.Decoder) error

func (m DigestItem) Encode(encoder scale.Encoder) error

type DigestOf ¶

type DigestOf []DigestItem

DigestOf contains logs

func (d DigestOf) MarshalJSON() ([]byte, error)

func (d *DigestOf) UnmarshalJSON(bz []byte) error

type DispatchClass ¶

type DispatchClass struct {
	// A normal dispatch
	IsNormal bool
	// An operational dispatch
	IsOperational bool
	// A mandatory dispatch
	IsMandatory bool
}

DispatchClass is a generalized group of dispatch types. This is only distinguishing normal, user-triggered transactions (`Normal`) and anything beyond which serves a higher purpose to the system (`Operational`).

func (d *DispatchClass) Decode(decoder scale.Decoder) error

func (d DispatchClass) Encode(encoder scale.Encoder) error

type DispatchError ¶

type DispatchError struct {
	IsOther bool

	IsCannotLookup bool

	IsBadOrigin bool

	IsModule    bool
	ModuleError ModuleError

	IsConsumerRemaining bool

	IsNoProviders bool

	IsTooManyConsumers bool

	IsToken    bool
	TokenError TokenError

	IsArithmetic    bool
	ArithmeticError ArithmeticError

	IsTransactional    bool
	TransactionalError TransactionalError
}

DispatchError is an error occurring during extrinsic dispatch

func (d *DispatchError) Decode(decoder scale.Decoder) error

func (d DispatchError) Encode(encoder scale.Encoder) error

type DispatchErrorWithPostInfo ¶

type DispatchErrorWithPostInfo struct {
	PostInfo PostDispatchInfo
	Error    DispatchError
}

DispatchErrorWithPostInfo is used in DispatchResultWithPostInfo.

func (d *DispatchErrorWithPostInfo) Decode(decoder scale.Decoder) error

func (d DispatchErrorWithPostInfo) Encode(encoder scale.Encoder) error

type DispatchInfo ¶

type DispatchInfo struct {
	// Weight of this transaction
	Weight Weight
	// Class of this transaction
	Class DispatchClass
	// PaysFee indicates whether this transaction pays fees
	PaysFee Pays
}

DispatchInfo contains a bundle of static information collected from the `#[weight = $x]` attributes.

func (d *DispatchInfo) Decode(decoder scale.Decoder) error

type DispatchResult ¶

type DispatchResult struct {
	Ok    bool
	Error DispatchError
}

DispatchResult can be returned from dispatchable functions

func (d *DispatchResult) Decode(decoder scale.Decoder) error

func (d DispatchResult) Encode(encoder scale.Encoder) error

type DispatchResultWithPostInfo ¶

type DispatchResultWithPostInfo struct {
	IsOk bool
	Ok   PostDispatchInfo

	IsError bool
	Error   DispatchErrorWithPostInfo
}

DispatchResultWithPostInfo can be returned from dispatch able functions.

func (d *DispatchResultWithPostInfo) Decode(decoder scale.Decoder) error

func (d DispatchResultWithPostInfo) Encode(encoder scale.Encoder) error

type DisputeLocation ¶

type DisputeLocation struct {
	IsLocal bool

	IsRemote bool
}

func (d *DisputeLocation) Decode(decoder scale.Decoder) error

func (d DisputeLocation) Encode(encoder scale.Encoder) error

type DisputeResult ¶

type DisputeResult struct {
	IsValid bool

	IsInvalid bool
}

func (d *DisputeResult) Decode(decoder scale.Decoder) error

func (d DisputeResult) Encode(encoder scale.Encoder) error

type DoubleMapTypeV4 ¶

type DoubleMapTypeV4 struct {
	Hasher     StorageHasher
	Key1       Type
	Key2       Type
	Value      Type
	Key2Hasher Text
}

type DoubleMapTypeV5 ¶

type DoubleMapTypeV5 struct {
	Hasher     StorageHasher
	Key1       Type
	Key2       Type
	Value      Type
	Key2Hasher StorageHasher
}

type DoubleMapTypeV10 ¶

type DoubleMapTypeV10 struct {
	Hasher     StorageHasherV10
	Key1       Type
	Key2       Type
	Value      Type
	Key2Hasher StorageHasherV10
}

type EcdsaSignature ¶

type EcdsaSignature [65]byte

EcdsaSignature is a 65 byte array

func NewEcdsaSignature(b []byte) EcdsaSignature

func (eh EcdsaSignature) Hex() string

type ElectionCompute ¶

type ElectionCompute byte

const (
	// OnChain means that the result was forcefully computed on chain at the end of the session.
	OnChain ElectionCompute = 0
	// Signed means that the result was submitted and accepted to the chain via a signed transaction.
	Signed ElectionCompute = 1
	// Unsigned means that the result was submitted and accepted to the chain via
	// an unsigned transaction (by an authority).
	Unsigned ElectionCompute = 2
)

func NewElectionCompute(b byte) ElectionCompute

func (ec *ElectionCompute) Decode(decoder scale.Decoder) error

func (ec ElectionCompute) Encode(encoder scale.Encoder) error

type EncodedCall ¶

type EncodedCall struct {
	Call []U8
}

func (e *EncodedCall) Decode(decoder scale.Decoder) error

func (e EncodedCall) Encode(encoder scale.Encoder) error

type ErrorMetadataV8 ¶

type ErrorMetadataV8 struct {
	Name          Text
	Documentation []Text
}

type ErrorMetadataV14 ¶

type ErrorMetadataV14 struct {
	Type Si1LookupTypeID
}

type EventAssetApprovalCancelled ¶

type EventAssetApprovalCancelled struct {
	Phase    Phase
	AssetID  U32
	Owner    AccountID
	Delegate AccountID
	Topics   []Hash
}

EventAssetApprovalCancelled is emitted when an approval for account `delegate` was cancelled by `owner`.

type EventAssetApprovedTransfer ¶

type EventAssetApprovedTransfer struct {
	Phase    Phase
	AssetID  U32
	Source   AccountID
	Delegate AccountID
	Amount   U128
	Topics   []Hash
}

EventAssetApprovedTransfer is emitted when (additional) funds have been approved for transfer to a destination account.

type EventAssetAssetFrozen ¶

type EventAssetAssetFrozen struct {
	Phase   Phase
	AssetID U32
	Topics  []Hash
}

EventAssetAssetFrozen is emitted when some asset `asset_id` was frozen.

type EventAssetAssetStatusChanged ¶

type EventAssetAssetStatusChanged struct {
	Phase   Phase
	AssetID U32
	Topics  []Hash
}

EventAssetAssetStatusChanged is emitted when an asset has had its attributes changed by the `Force` origin.

type EventAssetAssetThawed ¶

type EventAssetAssetThawed struct {
	Phase   Phase
	AssetID U32
	Topics  []Hash
}

EventAssetAssetThawed is emitted when some asset `asset_id` was thawed.

type EventAssetBurned ¶

type EventAssetBurned struct {
	Phase   Phase
	AssetID U32
	Owner   AccountID
	Balance U128
	Topics  []Hash
}

EventAssetBurned is emitted when an asset is destroyed.

type EventAssetCreated ¶

type EventAssetCreated struct {
	Phase   Phase
	AssetID U32
	Creator AccountID
	Owner   AccountID
	Topics  []Hash
}

EventAssetCreated is emitted when an asset is created.

type EventAssetDestroyed ¶

type EventAssetDestroyed struct {
	Phase   Phase
	AssetID U32
	Topics  []Hash
}

EventAssetDestroyed is emitted when an asset class is destroyed.

type EventAssetForceCreated ¶

type EventAssetForceCreated struct {
	Phase   Phase
	AssetID U32
	Owner   AccountID
	Topics  []Hash
}

EventAssetForceCreated is emitted when some asset class was force-created.

type EventAssetFrozen ¶

type EventAssetFrozen struct {
	Phase   Phase
	AssetID U32
	Who     AccountID
	Topics  []Hash
}

EventAssetFrozen is emitted when some account `who` was frozen.

type EventAssetIssued ¶

type EventAssetIssued struct {
	Phase   Phase
	AssetID U32
	Who     AccountID
	Balance U128
	Topics  []Hash
}

EventAssetIssued is emitted when an asset is issued.

type EventAssetMetadataCleared ¶

type EventAssetMetadataCleared struct {
	Phase   Phase
	AssetID U32
	Topics  []Hash
}

EventAssetMetadataCleared is emitted when metadata has been cleared for an asset.

type EventAssetMetadataSet ¶

type EventAssetMetadataSet struct {
	Phase    Phase
	AssetID  U32
	Name     MetadataSetName
	Symbol   MetadataSetSymbol
	Decimals U8
	IsFrozen bool
	Topics   []Hash
}

EventAssetMetadataSet is emitted when new metadata has been set for an asset.

type EventAssetOwnerChanged ¶

type EventAssetOwnerChanged struct {
	Phase   Phase
	AssetID U32
	Owner   AccountID
	Topics  []Hash
}

EventAssetOwnerChanged is emitted when the owner changed.

type EventAssetTeamChanged ¶

type EventAssetTeamChanged struct {
	Phase   Phase
	AssetID U32
	Issuer  AccountID
	Admin   AccountID
	Freezer AccountID
	Topics  []Hash
}

EventAssetTeamChanged is emitted when the management team changed.

type EventAssetThawed ¶

type EventAssetThawed struct {
	Phase   Phase
	AssetID U32
	Who     AccountID
	Topics  []Hash
}

EventAssetThawed is emitted when some account `who` was thawed.

type EventAssetTransferred ¶

type EventAssetTransferred struct {
	Phase   Phase
	AssetID U32
	To      AccountID
	From    AccountID
	Balance U128
	Topics  []Hash
}

EventAssetTransferred is emitted when an asset is transferred.

type EventAssetTransferredApproved ¶

type EventAssetTransferredApproved struct {
	Phase       Phase
	AssetID     U32
	Owner       AccountID
	Delegate    AccountID
	Destination AccountID
	Amount      U128
	Topics      []Hash
}

EventAssetTransferredApproved is emitted when an `amount` was transferred in its entirety from `owner` to `destination` by the approved `delegate`.

type EventAuctionsAuctionClosed ¶

type EventAuctionsAuctionClosed struct {
	Phase        Phase
	AuctionIndex U32
	Topics       []Hash
}

EventAuctionsAuctionClosed is emitted when an auction ended. All funds become unreserved.

type EventAuctionsAuctionStarted ¶

type EventAuctionsAuctionStarted struct {
	Phase        Phase
	AuctionIndex U32
	LeasePeriod  U32
	Ending       U32
	Topics       []Hash
}

EventAuctionsAuctionStarted is emitted when an auction started. Provides its index and the block number where it will begin to close and the first lease period of the quadruplet that is auctioned.

type EventAuctionsBidAccepted ¶

type EventAuctionsBidAccepted struct {
	Phase       Phase
	Who         AccountID
	ParachainID ParachainID
	Amount      U128
	FirstSlot   U32
	LastSlot    U32
	Topics      []Hash
}

EventAuctionsBidAccepted is emitted when a new bid has been accepted as the current winner.

type EventAuctionsReserveConfiscated ¶

type EventAuctionsReserveConfiscated struct {
	Phase       Phase
	ParachainID ParachainID
	Leaser      AccountID
	Amount      U128
	Topics      []Hash
}

EventAuctionsReserveConfiscated is emitted when someone attempted to lease the same slot twice for a parachain. The amount is held in reserve but no parachain slot has been leased.

type EventAuctionsReserved ¶

type EventAuctionsReserved struct {
	Phase         Phase
	Bidder        AccountID
	ExtraReserved U128
	TotalAmount   U128
	Topics        []Hash
}

EventAuctionsReserved is emitted when funds were reserved for a winning bid. First balance is the extra amount reserved. Second is the total.

type EventAuctionsUnreserved ¶

type EventAuctionsUnreserved struct {
	Phase  Phase
	Bidder AccountID
	Amount U128
	Topics []Hash
}

EventAuctionsUnreserved is emitted when funds were unreserved since bidder is no longer active.

type EventAuctionsWinningOffset ¶

type EventAuctionsWinningOffset struct {
	Phase        Phase
	AuctionIndex U32
	BlockNumber  U32
	Topics       []Hash
}

EventAuctionsWinningOffset is emitted when the winning offset was chosen for an auction. This will map into the `Winning` storage map.

type EventBagsListRebagged ¶

type EventBagsListRebagged struct {
	Phase  Phase
	Who    AccountID
	From   U64
	To     U64
	Topics []Hash
}

EventBagsListRebagged is emitted when an account was moved from one bag to another.

type EventBalancesBalanceSet ¶

type EventBalancesBalanceSet struct {
	Phase    Phase
	Who      AccountID
	Free     U128
	Reserved U128
	Topics   []Hash
}

EventBalancesBalanceSet is emitted when a balance is set by root

type EventBalancesDeposit ¶

type EventBalancesDeposit struct {
	Phase   Phase
	Who     AccountID
	Balance U128
	Topics  []Hash
}

EventBalancesDeposit is emitted when an account receives some free balance

type EventBalancesDustLost ¶

type EventBalancesDustLost struct {
	Phase   Phase
	Who     AccountID
	Balance U128
	Topics  []Hash
}

EventBalancesDustLost is emitted when an account is removed with a balance that is non-zero but below ExistentialDeposit, resulting in a loss.

type EventBalancesEndowed ¶

type EventBalancesEndowed struct {
	Phase   Phase
	Who     AccountID
	Balance U128
	Topics  []Hash
}

EventBalancesEndowed is emitted when an account is created with some free balance

type EventBalancesReserveRepatriated ¶

type EventBalancesReserveRepatriated struct {
	Phase             Phase
	From              AccountID
	To                AccountID
	Balance           U128
	DestinationStatus BalanceStatus
	Topics            []Hash
}

EventBalancesReserveRepatriated is emitted when some balance was moved from the reserve of the first account to the second account.

type EventBalancesReserved ¶

type EventBalancesReserved struct {
	Phase   Phase
	Who     AccountID
	Balance U128
	Topics  []Hash
}

EventBalancesReserved is emitted when some balance was reserved (moved from free to reserved)

type EventBalancesSlashed ¶

type EventBalancesSlashed struct {
	Phase   Phase
	Who     AccountID
	Balance U128
	Topics  []Hash
}

EventBalancesSlashed is emitted when some amount was removed from the account (e.g. for misbehavior)

type EventBalancesTransfer ¶

type EventBalancesTransfer struct {
	Phase  Phase
	From   AccountID
	To     AccountID
	Value  U128
	Topics []Hash
}

EventBalancesTransfer is emitted when a transfer succeeded (from, to, value)

type EventBalancesUnreserved ¶

type EventBalancesUnreserved struct {
	Phase   Phase
	Who     AccountID
	Balance U128
	Topics  []Hash
}

EventBalancesUnreserved is emitted when some balance was unreserved (moved from reserved to free)

type EventBalancesWithdraw ¶

type EventBalancesWithdraw struct {
	Phase   Phase
	Who     AccountID
	Balance U128
	Topics  []Hash
}

EventBalancesWithdraw is emitted when some amount was withdrawn from the account (e.g. for transaction fees)

type EventBountiesBountyAwarded ¶

type EventBountiesBountyAwarded struct {
	Phase       Phase
	Index       BountyIndex
	Beneficiary AccountID
	Topics      []Hash
}

EventBountiesBountyAwarded is emitted when a bounty is awarded to a beneficiary

type EventBountiesBountyBecameActive ¶

type EventBountiesBountyBecameActive struct {
	Phase  Phase
	Index  BountyIndex
	Topics []Hash
}

EventBountiesBountyBecameActive is emitted when a bounty proposal is funded and became active

type EventBountiesBountyCanceled ¶

type EventBountiesBountyCanceled struct {
	Phase  Phase
	Index  BountyIndex
	Topics []Hash
}

EventBountiesBountyCanceled is emitted when a bounty is cancelled.

type EventBountiesBountyClaimed ¶

type EventBountiesBountyClaimed struct {
	Phase       Phase
	Index       BountyIndex
	Payout      U128
	Beneficiary AccountID
	Topics      []Hash
}

EventBountiesBountyClaimed is emitted when a bounty is claimed by beneficiary

type EventBountiesBountyExtended ¶

type EventBountiesBountyExtended struct {
	Phase  Phase
	Index  BountyIndex
	Topics []Hash
}

EventBountiesBountyExtended is emitted when a bounty is extended.

type EventBountiesBountyProposed ¶

type EventBountiesBountyProposed struct {
	Phase         Phase
	ProposalIndex BountyIndex
	Topics        []Hash
}

EventBountiesBountyProposed is emitted for a new bounty proposal.

type EventBountiesBountyRejected ¶

type EventBountiesBountyRejected struct {
	Phase         Phase
	ProposalIndex BountyIndex
	Bond          U128
	Topics        []Hash
}

EventBountiesBountyRejected is emitted when a bounty proposal was rejected; funds were slashed.

type EventChildBountiesAdded ¶

type EventChildBountiesAdded struct {
	Phase      Phase
	Index      BountyIndex
	ChildIndex BountyIndex
	Topics     []Hash
}

EventChildBountiesAdded is emitted when a child-bounty is added.

type EventChildBountiesAwarded ¶

type EventChildBountiesAwarded struct {
	Phase       Phase
	Index       BountyIndex
	ChildIndex  BountyIndex
	Beneficiary AccountID
	Topics      []Hash
}

EventChildBountiesAwarded is emitted when a child-bounty is awarded to a beneficiary.

type EventChildBountiesCanceled ¶

type EventChildBountiesCanceled struct {
	Phase      Phase
	Index      BountyIndex
	ChildIndex BountyIndex
	Topics     []Hash
}

EventChildBountiesCanceled is emitted when a child-bounty is canceled.

type EventChildBountiesClaimed ¶

type EventChildBountiesClaimed struct {
	Phase       Phase
	Index       BountyIndex
	ChildIndex  BountyIndex
	Payout      U128
	Beneficiary AccountID
	Topics      []Hash
}

EventChildBountiesClaimed is emitted when a child-bounty is claimed by a beneficiary.

type EventClaimsClaimed ¶

type EventClaimsClaimed struct {
	Phase           Phase
	Who             AccountID
	EthereumAddress H160
	Amount          U128
	Topics          []Hash
}

EventClaimsClaimed is emitted when an account claims some DOTs

type EventCollatorSelectionCandidateAdded ¶

type EventCollatorSelectionCandidateAdded struct {
	Phase          Phase
	CandidateAdded AccountID
	Bond           U128
	Topics         []Hash
}

type EventCollatorSelectionCandidateRemoved ¶

type EventCollatorSelectionCandidateRemoved struct {
	Phase            Phase
	CandidateRemoved AccountID
	Topics           []Hash
}

type EventCollatorSelectionNewCandidacyBond ¶

type EventCollatorSelectionNewCandidacyBond struct {
	Phase            Phase
	NewCandidacyBond U128
	Topics           []Hash
}

type EventCollatorSelectionNewDesiredCandidates ¶

type EventCollatorSelectionNewDesiredCandidates struct {
	Phase                Phase
	NewDesiredCandidates U32
	Topics               []Hash
}

type EventCollatorSelectionNewInvulnerables ¶

type EventCollatorSelectionNewInvulnerables struct {
	Phase            Phase
	NewInvulnerables []AccountID
	Topics           []Hash
}

type EventContractsCodeRemoved ¶

type EventContractsCodeRemoved struct {
	Phase    Phase
	CodeHash Hash
	Topics   []Hash
}

EventContractsCodeRemoved is emitted when code with the specified hash was removed

type EventContractsCodeStored ¶

type EventContractsCodeStored struct {
	Phase    Phase
	CodeHash Hash
	Topics   []Hash
}

EventContractsCodeStored is emitted when code with the specified hash has been stored

type EventContractsContractCodeUpdated ¶

type EventContractsContractCodeUpdated struct {
	Phase       Phase
	Contract    AccountID
	NewCodeHash Hash
	OldCodeHash Hash
	Topics      []Hash
}

EventContractsContractCodeUpdated is emitted when a contract's code was updated

type EventContractsContractEmitted ¶

type EventContractsContractEmitted struct {
	Phase    Phase
	Contract AccountID
	Data     Bytes
	Topics   []Hash
}

EventContractsContractEmitted is emitted when a custom event emitted by the contract

type EventContractsContractExecution ¶

type EventContractsContractExecution struct {
	Phase   Phase
	Account AccountID
	Data    Bytes
	Topics  []Hash
}

EventContractsContractExecution is triggered when an event deposited upon execution of a contract from the account

type EventContractsInstantiated ¶

type EventContractsInstantiated struct {
	Phase    Phase
	Deployer AccountID
	Contract AccountID
	Topics   []Hash
}

EventContractsInstantiated is emitted when a contract is deployed by address at the specified address

type EventContractsScheduleUpdated ¶

type EventContractsScheduleUpdated struct {
	Phase    Phase
	Schedule U32
	Topics   []Hash
}

EventContractsScheduleUpdated is triggered when the current [schedule] is updated

type EventContractsTerminated ¶

type EventContractsTerminated struct {
	Phase       Phase
	Contract    AccountID
	Beneficiary AccountID
	Topics      []Hash
}

EventContractsTerminated The only way for a contract to be removed and emitting this event is by calling `seal_terminate`

type EventConvictionVotingDelegated ¶

type EventConvictionVotingDelegated struct {
	Phase  Phase
	Who    AccountID
	Target AccountID
	Topics []Hash
}

EventConvictionVotingDelegated is emitted when an account has delegated their vote to another account.

type EventConvictionVotingUndelegated ¶

type EventConvictionVotingUndelegated struct {
	Phase  Phase
	Who    AccountID
	Target AccountID
	Topics []Hash
}

EventConvictionVotingUndelegated is emitted when an account has delegated their vote to another account.

type EventCouncilApproved ¶

type EventCouncilApproved struct {
	Phase    Phase
	Proposal Hash
	Topics   []Hash
}

EventCouncilApproved is emitted when a motion was approved by the required threshold.

type EventCouncilClosed ¶

type EventCouncilClosed struct {
	Phase    Phase
	Proposal Hash
	YesCount U32
	NoCount  U32
	Topics   []Hash
}

EventCouncilClosed is emitted when a proposal was closed after its duration was up.

type EventCouncilDisapproved ¶

type EventCouncilDisapproved struct {
	Phase    Phase
	Proposal Hash
	Topics   []Hash
}

EventCouncilDisapproved is emitted when a motion was not approved by the required threshold.

type EventCouncilExecuted ¶

type EventCouncilExecuted struct {
	Phase    Phase
	Proposal Hash
	Result   DispatchResult
	Topics   []Hash
}

EventCouncilExecuted is emitted when a motion was executed; `result` is true if returned without error.

type EventCouncilMemberExecuted ¶

type EventCouncilMemberExecuted struct {
	Phase    Phase
	Proposal Hash
	Result   DispatchResult
	Topics   []Hash
}

EventCouncilMemberExecuted is emitted when a single member did some action; `result` is true if returned without error.

type EventCouncilProposed ¶

type EventCouncilProposed struct {
	Phase         Phase
	Who           AccountID
	ProposalIndex U32
	Proposal      Hash
	MemberCount   U32
	Topics        []Hash
}

EventCouncilProposed is emitted when a motion (given hash) has been proposed (by given account) with a threshold (given `MemberCount`).

type EventCouncilVoted ¶

type EventCouncilVoted struct {
	Phase    Phase
	Who      AccountID
	Proposal Hash
	Approve  bool
	YesCount U32
	NoCount  U32
	Topics   []Hash
}

EventCollectiveVote is emitted when a motion (given hash) has been voted on by given account, leaving a tally (yes votes and no votes given respectively as `MemberCount`).

type EventCrowdloanAddedToNewRaise ¶

type EventCrowdloanAddedToNewRaise struct {
	Phase     Phase
	FundIndex U32
	Topics    []Hash
}

EventCrowdloanAddedToNewRaise is emitted when a parachain has been moved to `NewRaise`.

type EventCrowdloanAllRefunded ¶

type EventCrowdloanAllRefunded struct {
	Phase     Phase
	FundIndex U32
	Topics    []Hash
}

EventCrowdloanAllRefunded is emitted when all loans in a fund have been refunded.

type EventCrowdloanContributed ¶

type EventCrowdloanContributed struct {
	Phase     Phase
	Who       AccountID
	FundIndex U32
	Amount    U128
	Topics    []Hash
}

EventCrowdloanContributed is emitted when `who` contributed to a crowd sale.

type EventCrowdloanCreated ¶

type EventCrowdloanCreated struct {
	Phase     Phase
	FundIndex U32
	Topics    []Hash
}

EventCrowdloanCreated is emitted when a new crowdloaning campaign is created.

type EventCrowdloanDissolved ¶

type EventCrowdloanDissolved struct {
	Phase     Phase
	FundIndex U32
	Topics    []Hash
}

EventCrowdloanDissolved is emitted when the fund is dissolved.

type EventCrowdloanEdited ¶

type EventCrowdloanEdited struct {
	Phase     Phase
	FundIndex U32
	Topics    []Hash
}

EventCrowdloanEdited is emitted when the configuration to a crowdloan has been edited.

type EventCrowdloanHandleBidResult ¶

type EventCrowdloanHandleBidResult struct {
	Phase          Phase
	FundIndex      U32
	DispatchResult DispatchResult
	Topics         []Hash
}

EventCrowdloanHandleBidResult is emitted when trying to submit a new bid to the Slots pallet.

type EventCrowdloanMemoUpdated ¶

type EventCrowdloanMemoUpdated struct {
	Phase     Phase
	Who       AccountID
	FundIndex U32
	Memo      CrowloadMemo
	Topics    []Hash
}

EventCrowdloanMemoUpdated is emitted when a memo has been updated.

type EventCrowdloanPartiallyRefunded ¶

type EventCrowdloanPartiallyRefunded struct {
	Phase     Phase
	FundIndex U32
	Topics    []Hash
}

EventCrowdloanPartiallyRefunded is emitted when the loans in a fund have been partially dissolved, i.e. there are some left over child keys that still need to be killed.

type EventCrowdloanWithdrew ¶

type EventCrowdloanWithdrew struct {
	Phase     Phase
	Who       AccountID
	FundIndex U32
	Amount    U128
	Topics    []Hash
}

EventCrowdloanWithdrew is emitted when the full balance of a contributor was withdrawn.

type EventDemocracyBlacklisted ¶

type EventDemocracyBlacklisted struct {
	Phase  Phase
	Hash   Hash
	Topics []Hash
}

EventDemocracyBlacklisted is emitted when A proposal has been blacklisted permanently

type EventDemocracyCancelled ¶

type EventDemocracyCancelled struct {
	Phase           Phase
	ReferendumIndex U32
	Topics          []Hash
}

EventDemocracyCancelled is emitted when a referendum has been cancelled.

type EventDemocracyDelegated ¶

type EventDemocracyDelegated struct {
	Phase  Phase
	Who    AccountID
	Target AccountID
	Topics []Hash
}

EventDemocracyDelegated is emitted when an account has delegated their vote to another account.

type EventDemocracyExecuted ¶

type EventDemocracyExecuted struct {
	Phase           Phase
	ReferendumIndex U32
	Result          DispatchResult
	Topics          []Hash
}

EventDemocracyExecuted is emitted when a proposal has been enacted.

type EventDemocracyExternalTabled ¶

type EventDemocracyExternalTabled struct {
	Phase  Phase
	Topics []Hash
}

EventDemocracyExternalTabled is emitted when an external proposal has been tabled.

type EventDemocracyNotPassed ¶

type EventDemocracyNotPassed struct {
	Phase           Phase
	ReferendumIndex U32
	Topics          []Hash
}

EventDemocracyNotPassed is emitted when a proposal has been rejected by referendum.

type EventDemocracyPassed ¶

type EventDemocracyPassed struct {
	Phase           Phase
	ReferendumIndex U32
	Topics          []Hash
}

EventDemocracyPassed is emitted when a proposal has been approved by referendum.

type EventDemocracyPreimageInvalid ¶

type EventDemocracyPreimageInvalid struct {
	Phase           Phase
	Hash            Hash
	ReferendumIndex U32
	Topics          []Hash
}

EventDemocracyPreimageInvalid is emitted when a proposal could not be executed because its preimage was invalid.

type EventDemocracyPreimageMissing ¶

type EventDemocracyPreimageMissing struct {
	Phase           Phase
	Hash            Hash
	ReferendumIndex U32
	Topics          []Hash
}

EventDemocracyPreimageMissing is emitted when a proposal could not be executed because its preimage was missing.

type EventDemocracyPreimageNoted ¶

type EventDemocracyPreimageNoted struct {
	Phase     Phase
	Hash      Hash
	AccountID AccountID
	Balance   U128
	Topics    []Hash
}

EventDemocracyPreimageNoted is emitted when a proposal's preimage was noted, and the deposit taken.

type EventDemocracyPreimageReaped ¶

type EventDemocracyPreimageReaped struct {
	Phase    Phase
	Hash     Hash
	Provider AccountID
	Balance  U128
	Who      AccountID
	Topics   []Hash
}

EventDemocracyPreimageReaped is emitted when a registered preimage was removed and the deposit collected by the reaper (last item).

type EventDemocracyPreimageUsed ¶

type EventDemocracyPreimageUsed struct {
	Phase     Phase
	Hash      Hash
	AccountID AccountID
	Balance   U128
	Topics    []Hash
}

EventDemocracyPreimageUsed is emitted when a proposal preimage was removed and used (the deposit was returned).

type EventDemocracyProposed ¶

type EventDemocracyProposed struct {
	Phase         Phase
	ProposalIndex U32
	Balance       U128
	Topics        []Hash
}

EventDemocracyProposed is emitted when a motion has been proposed by a public account.

type EventDemocracySeconded ¶

type EventDemocracySeconded struct {
	Phase     Phase
	AccountID AccountID
	Balance   U128
	Topics    []Hash
}

EventDemocracySeconded is emitted when an account has seconded a proposal.

type EventDemocracyStarted ¶

type EventDemocracyStarted struct {
	Phase           Phase
	ReferendumIndex U32
	VoteThreshold   VoteThreshold
	Topics          []Hash
}

EventDemocracyStarted is emitted when a referendum has begun.

type EventDemocracyTabled ¶

type EventDemocracyTabled struct {
	Phase         Phase
	ProposalIndex U32
	Balance       U128
	Accounts      []AccountID
	Topics        []Hash
}

EventDemocracyTabled is emitted when a public proposal has been tabled for referendum vote.

type EventDemocracyUndelegated ¶

type EventDemocracyUndelegated struct {
	Phase  Phase
	Target AccountID
	Topics []Hash
}

EventDemocracyUndelegated is emitted when an account has cancelled a previous delegation operation.

type EventDemocracyVetoed ¶

type EventDemocracyVetoed struct {
	Phase       Phase
	Who         AccountID
	Hash        Hash
	BlockNumber U32
	Topics      []Hash
}

EventDemocracyVetoed is emitted when an external proposal has been vetoed.

type EventDemocracyVoted ¶

type EventDemocracyVoted struct {
	Phase           Phase
	Who             AccountID
	ReferendumIndex U32
	Vote            VoteAccountVote
	Topics          []Hash
}

EventDemocracyVoted is emitted when an account has voted in a referendum.

type EventElectionProviderMultiPhaseElectionFinalized ¶

type EventElectionProviderMultiPhaseElectionFinalized struct {
	Phase           Phase
	ElectionCompute OptionElectionCompute
	Topics          []Hash
}

EventElectionProviderMultiPhaseElectionFinalized is emitted when the election has been finalized, with `Some` of the given computation, or else if the election failed, `None`.

type EventElectionProviderMultiPhaseRewarded ¶

type EventElectionProviderMultiPhaseRewarded struct {
	Phase   Phase
	Account AccountID
	Value   U128
	Topics  []Hash
}

EventElectionProviderMultiPhaseRewarded is emitted when an account has been rewarded for their signed submission being finalized.

type EventElectionProviderMultiPhaseSignedPhaseStarted ¶

type EventElectionProviderMultiPhaseSignedPhaseStarted struct {
	Phase  Phase
	Round  U32
	Topics []Hash
}

EventElectionProviderMultiPhaseSignedPhaseStarted is emitted when the signed phase of the given round has started.

type EventElectionProviderMultiPhaseSlashed ¶

type EventElectionProviderMultiPhaseSlashed struct {
	Phase   Phase
	Account AccountID
	Value   U128
	Topics  []Hash
}

EventElectionProviderMultiPhaseSlashed is emitted when an account has been slashed for submitting an invalid signed submission.

type EventElectionProviderMultiPhaseSolutionStored ¶

type EventElectionProviderMultiPhaseSolutionStored struct {
	Phase           Phase
	ElectionCompute ElectionCompute
	PrevEjected     bool
	Topics          []Hash
}

EventElectionProviderMultiPhaseSolutionStored is emitted when a solution was stored with the given compute.

If the solution is signed, this means that it hasn't yet been processed. If the solution is unsigned, this means that it has also been processed.

The `bool` is `true` when a previous solution was ejected to make room for this one.

type EventElectionProviderMultiPhaseUnsignedPhaseStarted ¶

type EventElectionProviderMultiPhaseUnsignedPhaseStarted struct {
	Phase  Phase
	Round  U32
	Topics []Hash
}

EventElectionProviderMultiPhaseUnsignedPhaseStarted is emitted when the unsigned phase of the given round has started.

type EventElectionsCandidateSlashed ¶

type EventElectionsCandidateSlashed struct {
	Phase   Phase
	Who     AccountID
	Balance U128
	Topics  []Hash
}

EventElectionsCandidateSlashed is emitted when a candidate was slashed by amount due to failing to obtain a seat as member or runner-up. Note that old members and runners-up are also candidates.

type EventElectionsElectionError ¶

type EventElectionsElectionError struct {
	Phase  Phase
	Topics []Hash
}

EventElectionsElectionError is emitted when an internal error happened while trying to perform election

type EventElectionsEmptyTerm ¶

type EventElectionsEmptyTerm struct {
	Phase  Phase
	Topics []Hash
}

EventElectionsEmptyTerm is emitted when No (or not enough) candidates existed for this round.

type EventElectionsMemberKicked ¶

type EventElectionsMemberKicked struct {
	Phase  Phase
	Member AccountID
	Topics []Hash
}

EventElectionsMemberKicked is emitted when a member has been removed. This should always be followed by either `NewTerm` or `EmptyTerm`.

type EventElectionsNewTerm ¶

type EventElectionsNewTerm struct {
	Phase      Phase
	NewMembers []struct {
		Member  AccountID
		Balance U128
	}
	Topics []Hash
}

EventElectionsNewTerm is emitted when a new term with new members. This indicates that enough candidates existed, not that enough have has been elected. The inner value must be examined for this purpose.

type EventElectionsRenounced ¶

type EventElectionsRenounced struct {
	Phase  Phase
	Member AccountID
	Topics []Hash
}

EventElectionsRenounced is emitted when a member has renounced their candidacy.

type EventElectionsSeatHolderSlashed ¶

type EventElectionsSeatHolderSlashed struct {
	Phase   Phase
	Who     AccountID
	Balance U128
	Topics  []Hash
}

EventElectionsSeatHolderSlashed is emitted when a seat holder was slashed by amount by being forcefully removed from the set

type EventGiltBidPlaced ¶

type EventGiltBidPlaced struct {
	Phase    Phase
	Who      AccountID
	Amount   U128
	Duration U32
	Topics   []Hash
}

EventGiltBidPlaced is emitted when a bid was successfully placed.

type EventGiltBidRetracted ¶

type EventGiltBidRetracted struct {
	Phase    Phase
	Who      AccountID
	Amount   U128
	Duration U32
	Topics   []Hash
}

EventGiltBidRetracted is emitted when a bid was successfully removed (before being accepted as a gilt).

type EventGiltGiltIssued ¶

type EventGiltGiltIssued struct {
	Phase  Phase
	Index  U32
	Expiry U32
	Who    AccountID
	Amount U128
	Topics []Hash
}

EventGiltGiltIssued is emitted when a bid was accepted as a gilt. The balance may not be released until expiry.

type EventGiltGiltThawed ¶

type EventGiltGiltThawed struct {
	Phase            Phase
	Index            U32
	Who              AccountID
	OriginalAmount   U128
	AdditionalAmount U128
	Topics           []Hash
}

EventGiltGiltThawed is emitted when an expired gilt has been thawed.

type EventGrandpaNewAuthorities ¶

type EventGrandpaNewAuthorities struct {
	Phase          Phase
	NewAuthorities []struct {
		AuthorityID     AuthorityID
		AuthorityWeight U64
	}
	Topics []Hash
}

EventGrandpaNewAuthorities is emitted when a new authority set has been applied

type EventGrandpaPaused ¶

type EventGrandpaPaused struct {
	Phase  Phase
	Topics []Hash
}

EventGrandpaPaused is emitted when the current authority set has been paused

type EventGrandpaResumed ¶

type EventGrandpaResumed struct {
	Phase  Phase
	Topics []Hash
}

EventGrandpaResumed is emitted when the current authority set has been resumed

type EventHRMPChannelClosed ¶

type EventHRMPChannelClosed struct {
	Phase       Phase
	ByParachain ParachainID
	ChannelID   HRMPChannelID
	Topics      []Hash
}

EventHRMPChannelClosed is emitted when an HRMP channel is closed.

type EventHRMPOpenChannelAccepted ¶

type EventHRMPOpenChannelAccepted struct {
	Phase     Phase
	Sender    ParachainID
	Recipient ParachainID
	Topics    []Hash
}

EventHRMPOpenChannelAccepted is emitted when an open HRMP channel is accepted.

type EventHRMPOpenChannelCanceled ¶

type EventHRMPOpenChannelCanceled struct {
	Phase       Phase
	ByParachain ParachainID
	ChannelID   HRMPChannelID
	Topics      []Hash
}

EventHRMPOpenChannelCanceled is emitted when an HRMP channel request sent by the receiver was canceled by either party.

type EventHRMPOpenChannelRequested ¶

type EventHRMPOpenChannelRequested struct {
	Phase                  Phase
	Sender                 ParachainID
	Recipient              ParachainID
	ProposedMaxCapacity    U32
	ProposedMaxMessageSize U32
	Topics                 []Hash
}

EventHRMPOpenChannelRequested is emitted when an open HRMP channel is requested.

type EventID ¶

type EventID [2]byte

type EventIdentityCleared ¶

type EventIdentityCleared struct {
	Phase    Phase
	Identity AccountID
	Balance  U128
	Topics   []Hash
}