@polkadot/types

  • Version 9.12.1
  • Published
  • 1.93 MB
  • 8 dependencies
  • Apache-2.0 license

Install

npm i @polkadot/types
yarn add @polkadot/types
pnpm add @polkadot/types

Overview

Implementation of the Parity codec

Index

Variables

Functions

Classes

Namespaces

Variables

variable packageInfo

const packageInfo: { name: string; path: string; type: string; version: string };

    variable rpcDefinitions

    const rpcDefinitions: Record<string, Record<string, DefinitionRpcExt>>;

      Functions

      function convertSiV0toV1

      convertSiV0toV1: (registry: Registry, types: Si0Type[]) => PortableType[];

        function createClass

        createClass: <T extends Codec = Codec, K extends string = string>(
        registry: Registry,
        type: K
        ) => CodecClass<DetectCodec<T, K>>;

          function createType

          createType: <T extends Codec = Codec, K extends string = string>(
          registry: Registry,
          type: K,
          ...params: unknown[]
          ) => DetectCodec<T, K>;
          • Create an instance of a type with a given params.

            Parameter type

            A recognizable string representing the type to create an instance from

            Parameter params

            The value to instantiate the type with

          function expandMetadata

          expandMetadata: (registry: Registry, metadata: Metadata) => DecoratedMeta;
          • Expands the metadata by decoration into consts, query and tx sections

          function lazyVariants

          lazyVariants: <T>(
          lookup: PortableRegistry,
          { type }: TypeHolder,
          getName: (v: SiVariant) => string,
          creator: (v: SiVariant) => T
          ) => Record<string, T>;

            Classes

            class Data

            class Data extends Enum {}
            • Data A [[Data]] container with node, raw or hashed data

            constructor

            constructor(registry: Registry, value?: any);

              property asBlakeTwo256

              readonly asBlakeTwo256: H256;

                property asKeccak256

                readonly asKeccak256: H256;

                  property asRaw

                  readonly asRaw: Bytes;

                    property asSha256

                    readonly asSha256: H256;

                      property asShaThree256

                      readonly asShaThree256: H256;

                        property encodedLength

                        readonly encodedLength: number;
                        • The encoded length

                        property isBlakeTwo256

                        readonly isBlakeTwo256: boolean;

                          property isKeccak256

                          readonly isKeccak256: boolean;

                            property isNone

                            readonly isNone: boolean;

                              property isRaw

                              readonly isRaw: boolean;

                                property isSha256

                                readonly isSha256: boolean;

                                  property isShaThree256

                                  readonly isShaThree256: boolean;

                                    method toU8a

                                    toU8a: () => Uint8Array;
                                    • Encodes the value as a Uint8Array as per the SCALE specifications

                                    class GenericAccountId

                                    class GenericAccountId extends BaseAccountId {}
                                    • GenericAccountId A wrapper around an AccountId/PublicKey representation. Since we are dealing with underlying PublicKeys (32 bytes in length), we extend from U8aFixed which is just a Uint8Array wrapper with a fixed length.

                                    constructor

                                    constructor(registry: Registry, value?: AnyU8a);

                                      class GenericAccountId32

                                      class GenericAccountId extends BaseAccountId {}
                                      • GenericAccountId A wrapper around an AccountId/PublicKey representation. Since we are dealing with underlying PublicKeys (32 bytes in length), we extend from U8aFixed which is just a Uint8Array wrapper with a fixed length.

                                      constructor

                                      constructor(registry: Registry, value?: AnyU8a);

                                        class GenericAccountId33

                                        class GenericAccountId33 extends BaseAccountId {}

                                          constructor

                                          constructor(registry: Registry, value?: AnyU8a);

                                            class GenericAccountIndex

                                            class GenericAccountIndex extends u32 {}
                                            • GenericAccountIndex A wrapper around an AccountIndex, which is a shortened, variable-length encoding for an Account. We extends from [[U32]] to provide the number-like properties.

                                            constructor

                                            constructor(registry: Registry, value?: AnyNumber);

                                              method calcLength

                                              static calcLength: (_value: BN | number) => number;

                                                method eq

                                                eq: (other?: unknown) => boolean;
                                                • Compares the value of the input to see if there is a match

                                                method readLength

                                                static readLength: (input: Uint8Array) => [number, number];

                                                  method toHuman

                                                  toHuman: () => string;
                                                  • Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

                                                  method toJSON

                                                  toJSON: () => string;
                                                  • Converts the Object to JSON, typically used for RPC transfers

                                                  method toPrimitive

                                                  toPrimitive: () => string;
                                                  • Converts the value in a best-fit primitive form

                                                  method toRawType

                                                  toRawType: () => string;
                                                  • Returns the base runtime type name for this instance

                                                  method toString

                                                  toString: () => string;
                                                  • Returns the string representation of the value

                                                  method writeLength

                                                  static writeLength: (input: Uint8Array) => Uint8Array;

                                                    class GenericAddress

                                                    class GenericMultiAddress extends Enum {}

                                                      constructor

                                                      constructor(registry: Registry, value?: {});

                                                        method inspect

                                                        inspect: () => Inspect;
                                                        • Returns a breakdown of the hex encoding for this Codec

                                                        method toString

                                                        toString: () => string;
                                                        • Returns the string representation of the value

                                                        class GenericBlock

                                                        class GenericBlock extends Struct {}
                                                        • GenericBlock A block encoded with header and extrinsics

                                                        constructor

                                                        constructor(registry: Registry, value?: Uint8Array | BlockValue);

                                                          property contentHash

                                                          readonly contentHash: IU8a;
                                                          • Encodes a content [[Hash]] for the block

                                                          property extrinsics

                                                          readonly extrinsics: Vec<GenericExtrinsic<AnyTuple>>;
                                                          • The [[Extrinsic]] contained in the block

                                                          property hash

                                                          readonly hash: IU8a;
                                                          • Block/header [[Hash]]

                                                          property header

                                                          readonly header: Header;
                                                          • The [[Header]] of the block

                                                          class GenericCall

                                                          class GenericCall<A extends AnyTuple = AnyTuple>
                                                          extends Struct
                                                          implements CallBase<A> {}
                                                          • GenericCall Extrinsic function descriptor

                                                          constructor

                                                          constructor(registry: Registry, value: {}, meta?: FunctionMetadataLatest);

                                                            property args

                                                            readonly args: AnyTuple;
                                                            • The arguments for the function call

                                                            property argsDef

                                                            readonly argsDef: ArgsDef;
                                                            • The argument definitions

                                                            property argsEntries

                                                            readonly argsEntries: [string, Codec][];
                                                            • The argument entries

                                                            property callIndex

                                                            readonly callIndex: Uint8Array;
                                                            • The encoded [sectionIndex, methodIndex] identifier

                                                            property data

                                                            readonly data: Uint8Array;
                                                            • The encoded data

                                                            property meta

                                                            readonly meta: FunctionMetadataLatest;
                                                            • The [[FunctionMetadata]]

                                                            property method

                                                            readonly method: string;
                                                            • Returns the name of the method

                                                            property section

                                                            readonly section: string;
                                                            • Returns the module containing the method

                                                            method is

                                                            is: (other: IMethod<AnyTuple>) => other is IMethod<A>;
                                                            • Checks if the source matches this in type

                                                            method toHuman

                                                            toHuman: (isExpanded?: boolean) => Record<string, AnyJson>;
                                                            • Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

                                                            method toRawType

                                                            toRawType: () => string;
                                                            • Returns the base runtime type name for this instance

                                                            class GenericChainProperties

                                                            class GenericChainProperties extends Json {}

                                                              constructor

                                                              constructor(
                                                              registry: Registry,
                                                              value?: Record<string, unknown> | Map<string, unknown>
                                                              );

                                                                property ss58Format

                                                                readonly ss58Format: Option<u32>;
                                                                • The chain ss58Format

                                                                property tokenDecimals

                                                                readonly tokenDecimals: Option<Vec<u32>>;
                                                                • The decimals for each of the tokens

                                                                property tokenSymbol

                                                                readonly tokenSymbol: Option<Vec<Text>>;
                                                                • The symbols for the tokens

                                                                class GenericConsensusEngineId

                                                                class GenericConsensusEngineId extends U8aFixed {}
                                                                • GenericConsensusEngineId A 4-byte identifier identifying the engine

                                                                constructor

                                                                constructor(registry: Registry, value?: AnyU8a);

                                                                  property isAura

                                                                  readonly isAura: boolean;
                                                                  • true if the engine matches aura

                                                                  property isBabe

                                                                  readonly isBabe: boolean;
                                                                  • true is the engine matches babe

                                                                  property isGrandpa

                                                                  readonly isGrandpa: boolean;
                                                                  • true is the engine matches grandpa

                                                                  property isPow

                                                                  readonly isPow: boolean;
                                                                  • true is the engine matches pow

                                                                  method extractAuthor

                                                                  extractAuthor: (
                                                                  bytes: Bytes,
                                                                  sessionValidators: AccountId[]
                                                                  ) => AccountId | undefined;
                                                                  • From the input bytes, decode into an author

                                                                  method toHuman

                                                                  toHuman: () => string;
                                                                  • Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

                                                                  method toRawType

                                                                  toRawType: () => string;
                                                                  • Returns the base runtime type name for this instance

                                                                  method toString

                                                                  toString: () => string;
                                                                  • Override the default toString to return a 4-byte string

                                                                  class GenericEthereumAccountId

                                                                  class GenericEthereumAccountId extends U8aFixed {}
                                                                  • GenericEthereumAccountId A wrapper around an Ethereum-compatible AccountId. Since we are dealing with underlying addresses (20 bytes in length), we extend from U8aFixed which is just a Uint8Array wrapper with a fixed length.

                                                                  constructor

                                                                  constructor(registry: Registry, value?: AnyU8a);

                                                                    method eq

                                                                    eq: (other?: unknown) => boolean;
                                                                    • Compares the value of the input to see if there is a match

                                                                    method toHuman

                                                                    toHuman: () => string;
                                                                    • Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

                                                                    method toJSON

                                                                    toJSON: () => string;
                                                                    • Converts the Object to JSON, typically used for RPC transfers

                                                                    method toPrimitive

                                                                    toPrimitive: () => string;
                                                                    • Converts the value in a best-fit primitive form

                                                                    method toRawType

                                                                    toRawType: () => string;
                                                                    • Returns the base runtime type name for this instance

                                                                    method toString

                                                                    toString: () => string;
                                                                    • Returns the string representation of the value

                                                                    class GenericEthereumLookupSource

                                                                    class GenericEthereumLookupSource extends AbstractBase<
                                                                    GenericEthereumAccountId | GenericAccountIndex
                                                                    > {}
                                                                    • GenericEthereumLookupSource A wrapper around an EthereumAccountId and/or AccountIndex that is encoded with a prefix. Since we are dealing with underlying publicKeys (or shorter encoded addresses), we extend from Base with an AccountId/AccountIndex wrapper. Basically the Address is encoded as [ <prefix-byte>, ...publicKey/...bytes ] as per spec

                                                                    constructor

                                                                    constructor(registry: Registry, value?: any);

                                                                      property encodedLength

                                                                      readonly encodedLength: number;
                                                                      • The length of the value when encoded as a Uint8Array

                                                                      method toHex

                                                                      toHex: () => HexString;
                                                                      • Returns a hex string representation of the value

                                                                      method toRawType

                                                                      toRawType: () => string;
                                                                      • Returns the base runtime type name for this instance

                                                                      method toU8a

                                                                      toU8a: (isBare?: boolean) => Uint8Array;
                                                                      • Encodes the value as a Uint8Array as per the SCALE specifications

                                                                        Parameter isBare

                                                                        true when the value has none of the type-specific prefixes (internal)

                                                                      class GenericEvent

                                                                      class GenericEvent extends Struct implements IEvent<Codec[]> {}
                                                                      • GenericEvent A representation of a system event. These are generated via the [[Metadata]] interfaces and specific to a specific Substrate runtime

                                                                      constructor

                                                                      constructor(registry: Registry, _value?: Uint8Array);

                                                                        property data

                                                                        readonly data: Codec[] & IEventData;
                                                                        • The wrapped [[EventData]]

                                                                        property index

                                                                        readonly index: EventId;
                                                                        • The [[EventId]], identifying the raw event

                                                                        property meta

                                                                        readonly meta: EventMetadataLatest;
                                                                        • The [[EventMetadata]] with the documentation

                                                                        property method

                                                                        readonly method: string;
                                                                        • The method string identifying the event

                                                                        property section

                                                                        readonly section: string;
                                                                        • The section string identifying the event

                                                                        property typeDef

                                                                        readonly typeDef: TypeDef[];
                                                                        • The [[TypeDef]] for the event

                                                                        method toHuman

                                                                        toHuman: (isExpanded?: boolean) => Record<string, AnyJson>;
                                                                        • Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

                                                                        class GenericEventData

                                                                        class GenericEventData extends Tuple implements IEventData {}
                                                                        • GenericEventData Wrapper for the actual data that forms part of an [[Event]]

                                                                        constructor

                                                                        constructor(
                                                                        registry: Registry,
                                                                        value: Uint8Array,
                                                                        meta: EventMetadataLatest,
                                                                        section?: string,
                                                                        method?: string
                                                                        );

                                                                          property meta

                                                                          readonly meta: EventMetadataLatest;
                                                                          • The wrapped [[EventMetadata]]

                                                                          property method

                                                                          readonly method: string;
                                                                          • The method as a string

                                                                          property names

                                                                          readonly names: string[];
                                                                          • The field names (as available)

                                                                          property section

                                                                          readonly section: string;
                                                                          • The section as a string

                                                                          property typeDef

                                                                          readonly typeDef: TypeDef[];
                                                                          • The [[TypeDef]] for this event

                                                                          method toHuman

                                                                          toHuman: (isExtended?: boolean) => AnyJson;
                                                                          • Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

                                                                          class GenericExtrinsic

                                                                          class GenericExtrinsic<A extends AnyTuple = AnyTuple>
                                                                          extends ExtrinsicBase<A>
                                                                          implements IExtrinsic<A> {}

                                                                          constructor

                                                                          constructor(registry: Registry, value?: any, { version }?: CreateOptions);

                                                                            property hash

                                                                            readonly hash: CodecHash;
                                                                            • returns a hash of the contents

                                                                            property LATEST_EXTRINSIC_VERSION

                                                                            static LATEST_EXTRINSIC_VERSION: number;

                                                                              method addSignature

                                                                              addSignature: (
                                                                              signer: Address | Uint8Array | string,
                                                                              signature: Uint8Array | HexString,
                                                                              payload: ExtrinsicPayloadValue | Uint8Array | HexString
                                                                              ) => GenericExtrinsic<A>;
                                                                              • Injects an already-generated signature into the extrinsic

                                                                              method inspect

                                                                              inspect: () => Inspect;
                                                                              • Returns a breakdown of the hex encoding for this Codec

                                                                              method sign

                                                                              sign: (account: IKeyringPair, options: SignatureOptions) => GenericExtrinsic<A>;
                                                                              • Sign the extrinsic with a specific keypair

                                                                              method signFake

                                                                              signFake: (
                                                                              signer: Address | Uint8Array | string,
                                                                              options: SignatureOptions
                                                                              ) => GenericExtrinsic<A>;
                                                                              • Adds a fake signature to the extrinsic

                                                                              method toHex

                                                                              toHex: (isBare?: boolean) => HexString;
                                                                              • Returns a hex string representation of the value

                                                                              method toHuman

                                                                              toHuman: (isExpanded?: boolean) => AnyJson;
                                                                              • Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

                                                                              method toJSON

                                                                              toJSON: () => string;
                                                                              • Converts the Object to JSON, typically used for RPC transfers

                                                                              method toRawType

                                                                              toRawType: () => string;
                                                                              • Returns the base runtime type name for this instance

                                                                              method toU8a

                                                                              toU8a: (isBare?: boolean) => Uint8Array;
                                                                              • Encodes the value as a Uint8Array as per the SCALE specifications

                                                                                Parameter isBare

                                                                                true when the value is not length-prefixed

                                                                              method toU8aInner

                                                                              toU8aInner: () => Uint8Array[];

                                                                                class GenericExtrinsicEra

                                                                                class GenericExtrinsicEra extends Enum implements IExtrinsicEra {}
                                                                                • GenericExtrinsicEra The era for an extrinsic, indicating either a mortal or immortal extrinsic

                                                                                constructor

                                                                                constructor(registry: Registry, value?: {});

                                                                                  property asImmortalEra

                                                                                  readonly asImmortalEra: ImmortalEra;
                                                                                  • Returns the item as a [[ImmortalEra]]

                                                                                  property asMortalEra

                                                                                  readonly asMortalEra: MortalEra;
                                                                                  • Returns the item as a [[MortalEra]]

                                                                                  property encodedLength

                                                                                  readonly encodedLength: number;
                                                                                  • Override the encoded length method

                                                                                  property isImmortalEra

                                                                                  readonly isImmortalEra: boolean;
                                                                                  • true if Immortal

                                                                                  property isMortalEra

                                                                                  readonly isMortalEra: boolean;
                                                                                  • true if Mortal

                                                                                  method toU8a

                                                                                  toU8a: (isBare?: boolean) => Uint8Array;
                                                                                  • Encodes the value as a Uint8Array as per the parity-codec specifications

                                                                                    Parameter isBare

                                                                                    true when the value has none of the type-specific prefixes (internal)

                                                                                  class GenericExtrinsicPayload

                                                                                  class GenericExtrinsicPayload extends AbstractBase<ExtrinsicPayloadVx> {}
                                                                                  • GenericExtrinsicPayload A signing payload for an [[Extrinsic]]. For the final encoding, it is variable length based on the contents included

                                                                                  constructor

                                                                                  constructor(
                                                                                  registry: Registry,
                                                                                  value?: string | Uint8Array | Partial<ExtrinsicPayloadValue>,
                                                                                  { version }?: ExtrinsicPayloadOptions
                                                                                  );

                                                                                    property blockHash

                                                                                    readonly blockHash: BlockHash;
                                                                                    • The block [[BlockHash]] the signature applies to (mortal/immortal)

                                                                                    property era

                                                                                    readonly era: GenericExtrinsicEra;
                                                                                    • The [[ExtrinsicEra]]

                                                                                    property genesisHash

                                                                                    readonly genesisHash: BlockHash;
                                                                                    • The genesis block [[BlockHash]] the signature applies to

                                                                                    property method

                                                                                    readonly method: Bytes;
                                                                                    • The [[Bytes]] contained in the payload

                                                                                    property nonce

                                                                                    readonly nonce: ICompact<INumber>;
                                                                                    • The [[Index]]

                                                                                    property specVersion

                                                                                    readonly specVersion: INumber;
                                                                                    • The specVersion as a [[u32]] for this payload

                                                                                    property tip

                                                                                    readonly tip: ICompact<INumber>;
                                                                                    • The [[Balance]]

                                                                                    property transactionVersion

                                                                                    readonly transactionVersion: INumber;
                                                                                    • The transaction version as a [[u32]] for this payload

                                                                                    method eq

                                                                                    eq: (other?: unknown) => boolean;
                                                                                    • Compares the value of the input to see if there is a match

                                                                                    method sign

                                                                                    sign: (signerPair: IKeyringPair) => { signature: HexString };
                                                                                    • Sign the payload with the keypair

                                                                                    method toHuman

                                                                                    toHuman: (isExtended?: boolean) => AnyJson;
                                                                                    • Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

                                                                                    method toJSON

                                                                                    toJSON: () => any;
                                                                                    • Converts the Object to JSON, typically used for RPC transfers

                                                                                    method toString

                                                                                    toString: () => string;
                                                                                    • Returns the string representation of the value

                                                                                    method toU8a

                                                                                    toU8a: (isBare?: BareOpts) => Uint8Array;
                                                                                    • Returns a serialized u8a form

                                                                                    class GenericExtrinsicPayloadUnknown

                                                                                    class GenericExtrinsicPayloadUnknown extends Struct {}
                                                                                    • GenericExtrinsicPayloadUnknown A default handler for payloads where the version is not known (default throw)

                                                                                    constructor

                                                                                    constructor(
                                                                                    registry: Registry,
                                                                                    value?: {},
                                                                                    { version }?: Partial<ExtrinsicPayloadOptions>
                                                                                    );

                                                                                      class GenericExtrinsicPayloadV4

                                                                                      class GenericExtrinsicPayloadV4 extends Struct {}
                                                                                      • GenericExtrinsicPayloadV4 A signing payload for an [[Extrinsic]]. For the final encoding, it is variable length based on the contents included

                                                                                      constructor

                                                                                      constructor(registry: Registry, value?: any);

                                                                                        property assetId

                                                                                        readonly assetId: IOption<INumber>;
                                                                                        • The (optional) asset id for this signature for chains that support transaction fees in assets

                                                                                        property blockHash

                                                                                        readonly blockHash: BlockHash;
                                                                                        • The block [[BlockHash]] the signature applies to (mortal/immortal)

                                                                                        property era

                                                                                        readonly era: ExtrinsicEra;
                                                                                        • The [[ExtrinsicEra]]

                                                                                        property genesisHash

                                                                                        readonly genesisHash: BlockHash;
                                                                                        • The genesis [[BlockHash]] the signature applies to (mortal/immortal)

                                                                                        property method

                                                                                        readonly method: Bytes;
                                                                                        • The [[Bytes]] contained in the payload

                                                                                        property nonce

                                                                                        readonly nonce: ICompact<INumber>;
                                                                                        • The [[Index]]

                                                                                        property specVersion

                                                                                        readonly specVersion: INumber;
                                                                                        • The specVersion for this signature

                                                                                        property tip

                                                                                        readonly tip: ICompact<INumber>;
                                                                                        • The tip [[Balance]]

                                                                                        property transactionVersion

                                                                                        readonly transactionVersion: INumber;
                                                                                        • The transactionVersion for this signature

                                                                                        method inspect

                                                                                        inspect: () => Inspect;
                                                                                        • Returns a breakdown of the hex encoding for this Codec

                                                                                        method sign

                                                                                        sign: (signerPair: IKeyringPair) => Uint8Array;
                                                                                        • Sign the payload with the keypair

                                                                                        class GenericExtrinsicSignatureV4

                                                                                        class GenericExtrinsicSignatureV4 extends Struct implements IExtrinsicSignature {}
                                                                                        • GenericExtrinsicSignatureV4 A container for the [[Signature]] associated with a specific [[Extrinsic]]

                                                                                        constructor

                                                                                        constructor(
                                                                                        registry: Registry,
                                                                                        value?: Uint8Array | GenericExtrinsicSignatureV4,
                                                                                        { isSigned }?: ExtrinsicSignatureOptions
                                                                                        );

                                                                                          property encodedLength

                                                                                          readonly encodedLength: number;
                                                                                          • The length of the value when encoded as a Uint8Array

                                                                                          property era

                                                                                          readonly era: ExtrinsicEra;
                                                                                          • The [[ExtrinsicEra]] (mortal or immortal) this signature applies to

                                                                                          property isSigned

                                                                                          readonly isSigned: boolean;
                                                                                          • true if the signature is valid

                                                                                          property multiSignature

                                                                                          readonly multiSignature: ExtrinsicSignature;
                                                                                          • The raw [[ExtrinsicSignature]]

                                                                                          property nonce

                                                                                          readonly nonce: ICompact<INumber>;
                                                                                          • The [[Index]] for the signature

                                                                                          property signature

                                                                                          readonly signature: EcdsaSignature | Ed25519Signature | Sr25519Signature;
                                                                                          • The actual [[EcdsaSignature]], [[Ed25519Signature]] or [[Sr25519Signature]]

                                                                                          property signer

                                                                                          readonly signer: Address;
                                                                                          • The [[Address]] that signed

                                                                                          property tip

                                                                                          readonly tip: ICompact<INumber>;
                                                                                          • The [[Balance]] tip

                                                                                          method addSignature

                                                                                          addSignature: (
                                                                                          signer: Address | Uint8Array | string,
                                                                                          signature: Uint8Array | HexString,
                                                                                          payload: ExtrinsicPayloadValue | Uint8Array | HexString
                                                                                          ) => IExtrinsicSignature;
                                                                                          • Adds a raw signature

                                                                                          method createPayload

                                                                                          createPayload: (
                                                                                          method: Call,
                                                                                          options: SignatureOptions
                                                                                          ) => GenericExtrinsicPayloadV4;
                                                                                          • Creates a payload from the supplied options

                                                                                          method sign

                                                                                          sign: (
                                                                                          method: Call,
                                                                                          account: IKeyringPair,
                                                                                          options: SignatureOptions
                                                                                          ) => IExtrinsicSignature;
                                                                                          • Generate a payload and applies the signature from a keypair

                                                                                          method signFake

                                                                                          signFake: (
                                                                                          method: Call,
                                                                                          address: Address | Uint8Array | string,
                                                                                          options: SignatureOptions
                                                                                          ) => IExtrinsicSignature;
                                                                                          • Generate a payload and applies a fake signature

                                                                                          method toU8a

                                                                                          toU8a: (isBare?: boolean) => Uint8Array;
                                                                                          • Encodes the value as a Uint8Array as per the SCALE specifications

                                                                                            Parameter isBare

                                                                                            true when the value has none of the type-specific prefixes (internal)

                                                                                          class GenericExtrinsicUnknown

                                                                                          class GenericExtrinsicUnknown extends Struct {}
                                                                                          • GenericExtrinsicUnknown A default handler for extrinsics where the version is not known (default throw)

                                                                                          constructor

                                                                                          constructor(
                                                                                          registry: Registry,
                                                                                          value?: {},
                                                                                          { isSigned, version }?: Partial<ExtrinsicOptions>
                                                                                          );

                                                                                            class GenericExtrinsicV4

                                                                                            class GenericExtrinsicV4 extends Struct implements IExtrinsicImpl {}
                                                                                            • GenericExtrinsicV4 The third generation of compact extrinsics

                                                                                            constructor

                                                                                            constructor(
                                                                                            registry: Registry,
                                                                                            value?: Uint8Array | ExtrinsicValueV4 | Call,
                                                                                            { isSigned }?: Partial<ExtrinsicOptions>
                                                                                            );

                                                                                              property encodedLength

                                                                                              readonly encodedLength: number;
                                                                                              • The length of the value when encoded as a Uint8Array

                                                                                              property method

                                                                                              readonly method: Call;
                                                                                              • The [[Call]] this extrinsic wraps

                                                                                              property signature

                                                                                              readonly signature: ExtrinsicSignatureV4;
                                                                                              • The [[ExtrinsicSignatureV4]]

                                                                                              property version

                                                                                              readonly version: number;
                                                                                              • The version for the signature

                                                                                              method addSignature

                                                                                              addSignature: (
                                                                                              signer: Address | Uint8Array | string,
                                                                                              signature: Uint8Array | HexString,
                                                                                              payload: ExtrinsicPayloadValue | Uint8Array | HexString
                                                                                              ) => GenericExtrinsicV4;
                                                                                              • Add an [[ExtrinsicSignatureV4]] to the extrinsic (already generated)

                                                                                              method sign

                                                                                              sign: (account: IKeyringPair, options: SignatureOptions) => GenericExtrinsicV4;
                                                                                              • Sign the extrinsic with a specific keypair

                                                                                              method signFake

                                                                                              signFake: (
                                                                                              signer: Address | Uint8Array | string,
                                                                                              options: SignatureOptions
                                                                                              ) => GenericExtrinsicV4;
                                                                                              • Adds a fake signature to the extrinsic

                                                                                              class GenericImmortalEra

                                                                                              class ImmortalEra extends Raw {}
                                                                                              • ImmortalEra The ImmortalEra for an extrinsic

                                                                                              constructor

                                                                                              constructor(registry: Registry, value?: AnyU8a);

                                                                                                class GenericLookupSource

                                                                                                class GenericLookupSource extends AbstractBase<
                                                                                                GenericAccountId | GenericAccountIndex
                                                                                                > {}
                                                                                                • LookupSource A wrapper around an AccountId and/or AccountIndex that is encoded with a prefix. Since we are dealing with underlying publicKeys (or shorter encoded addresses), we extend from Base with an AccountId/AccountIndex wrapper. Basically the Address is encoded as [ <prefix-byte>, ...publicKey/...bytes ] as per spec

                                                                                                constructor

                                                                                                constructor(registry: Registry, value?: any);

                                                                                                  property encodedLength

                                                                                                  readonly encodedLength: number;
                                                                                                  • The length of the value when encoded as a Uint8Array

                                                                                                  method inspect

                                                                                                  inspect: () => Inspect;
                                                                                                  • Returns a breakdown of the hex encoding for this Codec

                                                                                                  method toHex

                                                                                                  toHex: () => HexString;
                                                                                                  • Returns a hex string representation of the value

                                                                                                  method toRawType

                                                                                                  toRawType: () => string;
                                                                                                  • Returns the base runtime type name for this instance

                                                                                                  method toU8a

                                                                                                  toU8a: (isBare?: boolean) => Uint8Array;
                                                                                                  • Encodes the value as a Uint8Array as per the SCALE specifications

                                                                                                    Parameter isBare

                                                                                                    true when the value has none of the type-specific prefixes (internal)

                                                                                                  class GenericMortalEra

                                                                                                  class MortalEra extends Tuple {}
                                                                                                  • MortalEra The MortalEra for an extrinsic, indicating period and phase

                                                                                                  constructor

                                                                                                  constructor(
                                                                                                  registry: Registry,
                                                                                                  value?: string | Uint8Array | number[] | MortalMethod
                                                                                                  );

                                                                                                    property encodedLength

                                                                                                    readonly encodedLength: number;
                                                                                                    • Encoded length for mortals occupy 2 bytes, different from the actual Tuple since it is encoded. This is a shortcut fro toU8a().length

                                                                                                    property period

                                                                                                    readonly period: INumber;
                                                                                                    • The period of this Mortal wraps as a [[U64]]

                                                                                                    property phase

                                                                                                    readonly phase: INumber;
                                                                                                    • The phase of this Mortal wraps as a [[U64]]

                                                                                                    method birth

                                                                                                    birth: (current: BN | bigint | number | string) => number;
                                                                                                    • Get the block number of the start of the era whose properties this object describes that current belongs to.

                                                                                                    method death

                                                                                                    death: (current: BN | bigint | number | string) => number;
                                                                                                    • Get the block number of the first block at which the era has ended.

                                                                                                    method toHuman

                                                                                                    toHuman: () => any;
                                                                                                    • Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

                                                                                                    method toJSON

                                                                                                    toJSON: () => any;
                                                                                                    • Returns a JSON representation of the actual value

                                                                                                    method toU8a

                                                                                                    toU8a: (isBare?: boolean) => Uint8Array;
                                                                                                    • Encodes the value as a Uint8Array as per the parity-codec specifications

                                                                                                      Parameter isBare

                                                                                                      true when the value has none of the type-specific prefixes (internal) Period and phase are encoded: - The period of validity from the block hash found in the signing material. - The phase in the period that this transaction's lifetime begins (and, importantly, implies which block hash is included in the signature material). If the period is greater than 1 << 12, then it will be a factor of the times greater than 1<<12 that period is.

                                                                                                    class GenericMultiAddress

                                                                                                    class GenericMultiAddress extends Enum {}

                                                                                                      constructor

                                                                                                      constructor(registry: Registry, value?: {});

                                                                                                        method inspect

                                                                                                        inspect: () => Inspect;
                                                                                                        • Returns a breakdown of the hex encoding for this Codec

                                                                                                        method toString

                                                                                                        toString: () => string;
                                                                                                        • Returns the string representation of the value

                                                                                                        class GenericSignerPayload

                                                                                                        class GenericSignerPayload
                                                                                                        extends Struct
                                                                                                        implements ISignerPayload, SignerPayloadType {}
                                                                                                        • GenericSignerPayload A generic signer payload that can be used for serialization between API and signer

                                                                                                        constructor

                                                                                                        constructor(registry: Registry, value?: any);

                                                                                                          property address

                                                                                                          readonly address: Address;

                                                                                                            property blockHash

                                                                                                            readonly blockHash: BlockHash;

                                                                                                              property blockNumber

                                                                                                              readonly blockNumber: INumber;

                                                                                                                property era

                                                                                                                readonly era: ExtrinsicEra;

                                                                                                                  property genesisHash

                                                                                                                  readonly genesisHash: BlockHash;

                                                                                                                    property method

                                                                                                                    readonly method: Call;

                                                                                                                      property nonce

                                                                                                                      readonly nonce: ICompact<INumber>;

                                                                                                                        property runtimeVersion

                                                                                                                        readonly runtimeVersion: IRuntimeVersion;

                                                                                                                          property signedExtensions

                                                                                                                          readonly signedExtensions: Vec<Text>;

                                                                                                                            property tip

                                                                                                                            readonly tip: ICompact<INumber>;

                                                                                                                              property version

                                                                                                                              readonly version: INumber;

                                                                                                                                method toPayload

                                                                                                                                toPayload: () => SignerPayloadJSON;
                                                                                                                                • Creates an representation of the structure as an ISignerPayload JSON

                                                                                                                                method toRaw

                                                                                                                                toRaw: () => SignerPayloadRaw;
                                                                                                                                • Creates a representation of the payload in raw Exrinsic form

                                                                                                                                class GenericVote

                                                                                                                                class GenericVote extends U8aFixed {}
                                                                                                                                • GenericVote A number of lock periods, plus a vote, one way or the other.

                                                                                                                                constructor

                                                                                                                                constructor(registry: Registry, value?: InputTypes);

                                                                                                                                  property conviction

                                                                                                                                  readonly conviction: Conviction;
                                                                                                                                  • returns a V2 conviction

                                                                                                                                  property isAye

                                                                                                                                  readonly isAye: boolean;
                                                                                                                                  • true if the wrapped value is a positive vote

                                                                                                                                  property isNay

                                                                                                                                  readonly isNay: boolean;
                                                                                                                                  • true if the wrapped value is a negative vote

                                                                                                                                  method toHuman

                                                                                                                                  toHuman: (isExpanded?: boolean) => AnyJson;
                                                                                                                                  • Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

                                                                                                                                  method toPrimitive

                                                                                                                                  toPrimitive: () => any;
                                                                                                                                  • Converts the value in a best-fit primitive form

                                                                                                                                  method toRawType

                                                                                                                                  toRawType: () => string;
                                                                                                                                  • Returns the base runtime type name for this instance

                                                                                                                                  class Metadata

                                                                                                                                  class Metadata extends MetadataVersioned {}
                                                                                                                                  • Metadata The versioned runtime metadata as a decoded structure

                                                                                                                                  constructor

                                                                                                                                  constructor(registry: Registry, value?: any);

                                                                                                                                    class PortableRegistry

                                                                                                                                    class PortableRegistry extends Struct implements ILookup {}

                                                                                                                                      constructor

                                                                                                                                      constructor(registry: Registry, value?: Uint8Array, isContract?: boolean);

                                                                                                                                        property names

                                                                                                                                        readonly names: string[];

                                                                                                                                          property types

                                                                                                                                          readonly types: Vec<PortableType>;
                                                                                                                                          • The types of the registry

                                                                                                                                          method getName

                                                                                                                                          getName: (lookupId: SiLookupTypeId | string | number) => string | undefined;
                                                                                                                                          • Returns the name for a specific lookup

                                                                                                                                          method getSiType

                                                                                                                                          getSiType: (lookupId: SiLookupTypeId | string | number) => SiType;
                                                                                                                                          • Finds a specific type in the registry

                                                                                                                                          method getTypeDef

                                                                                                                                          getTypeDef: (lookupId: SiLookupTypeId | string | number) => TypeDef;
                                                                                                                                          • Lookup the type definition for the index

                                                                                                                                          method register

                                                                                                                                          register: () => void;

                                                                                                                                            method sanitizeField

                                                                                                                                            sanitizeField: (name: Option<Text>) => [string | null, string | null];

                                                                                                                                              class StorageKey

                                                                                                                                              class StorageKey<A extends AnyTuple = AnyTuple>
                                                                                                                                              extends Bytes
                                                                                                                                              implements IStorageKey<A> {}
                                                                                                                                              • StorageKey A representation of a storage key (typically hashed) in the system. It can be constructed by passing in a raw key or a StorageEntry with (optional) arguments.

                                                                                                                                              constructor

                                                                                                                                              constructor(
                                                                                                                                              registry: Registry,
                                                                                                                                              value?:
                                                                                                                                              | string
                                                                                                                                              | Uint8Array
                                                                                                                                              | StorageKey<AnyTuple>
                                                                                                                                              | StorageEntry
                                                                                                                                              | [StorageEntry, unknown[]?],
                                                                                                                                              override?: Partial<StorageKeyExtra>
                                                                                                                                              );

                                                                                                                                                property args

                                                                                                                                                readonly args: AnyTuple;
                                                                                                                                                • Return the decoded arguments (applicable to map with decodable values)

                                                                                                                                                property meta

                                                                                                                                                readonly meta: StorageEntryMetadataLatest;
                                                                                                                                                • The metadata or undefined when not available

                                                                                                                                                property method

                                                                                                                                                readonly method: string;
                                                                                                                                                • The key method or undefined when not specified

                                                                                                                                                property outputType

                                                                                                                                                readonly outputType: string;
                                                                                                                                                • The output type

                                                                                                                                                property section

                                                                                                                                                readonly section: string;
                                                                                                                                                • The key section or undefined when not specified

                                                                                                                                                method is

                                                                                                                                                is: (key: IStorageKey<AnyTuple>) => key is IStorageKey<A>;

                                                                                                                                                  method setMeta

                                                                                                                                                  setMeta: (
                                                                                                                                                  meta?: StorageEntryMetadataLatest,
                                                                                                                                                  section?: string,
                                                                                                                                                  method?: string
                                                                                                                                                  ) => this;
                                                                                                                                                  • Sets the meta for this key

                                                                                                                                                  method toHuman

                                                                                                                                                  toHuman: () => AnyJson;
                                                                                                                                                  • Returns the Human representation for this type

                                                                                                                                                  method toRawType

                                                                                                                                                  toRawType: () => string;
                                                                                                                                                  • Returns the raw type for this

                                                                                                                                                  class TypeRegistry

                                                                                                                                                  class TypeRegistry implements Registry {}

                                                                                                                                                    constructor

                                                                                                                                                    constructor(createdAtHash?: string | Hash | Uint8Array);

                                                                                                                                                      property chainDecimals

                                                                                                                                                      readonly chainDecimals: number[];

                                                                                                                                                        property chainSS58

                                                                                                                                                        readonly chainSS58: number;

                                                                                                                                                          property chainTokens

                                                                                                                                                          readonly chainTokens: string[];

                                                                                                                                                            property createdAtHash

                                                                                                                                                            createdAtHash?: Hash;

                                                                                                                                                              property firstCallIndex

                                                                                                                                                              readonly firstCallIndex: Uint8Array;

                                                                                                                                                                property knownTypes

                                                                                                                                                                readonly knownTypes: RegisteredTypes;

                                                                                                                                                                  property lookup

                                                                                                                                                                  readonly lookup: PortableRegistry;

                                                                                                                                                                    property metadata

                                                                                                                                                                    readonly metadata: MetadataLatest;

                                                                                                                                                                      property signedExtensions

                                                                                                                                                                      readonly signedExtensions: string[];

                                                                                                                                                                        property unknownTypes

                                                                                                                                                                        readonly unknownTypes: string[];

                                                                                                                                                                          method clearCache

                                                                                                                                                                          clearCache: () => void;

                                                                                                                                                                            method createClass

                                                                                                                                                                            createClass: <T extends Codec = Codec, K extends string = string>(
                                                                                                                                                                            type: K
                                                                                                                                                                            ) => CodecClass<DetectCodec<T, K>>;
                                                                                                                                                                            • Creates an instance of the class

                                                                                                                                                                            method createClassUnsafe

                                                                                                                                                                            createClassUnsafe: <T extends Codec = Codec, K extends string = string>(
                                                                                                                                                                            type: K
                                                                                                                                                                            ) => CodecClass<T>;
                                                                                                                                                                            • Creates an instance of the class

                                                                                                                                                                            method createLookupType

                                                                                                                                                                            createLookupType: (lookupId: SiLookupTypeId | number) => string;
                                                                                                                                                                            • Creates a lookup string from the supplied id

                                                                                                                                                                            method createType

                                                                                                                                                                            createType: <T extends Codec = Codec, K extends string = string>(
                                                                                                                                                                            type: K,
                                                                                                                                                                            ...params: unknown[]
                                                                                                                                                                            ) => DetectCodec<T, K>;
                                                                                                                                                                            • Creates an instance of a type as registered

                                                                                                                                                                            method createTypeUnsafe

                                                                                                                                                                            createTypeUnsafe: <T extends Codec = Codec, K extends string = string>(
                                                                                                                                                                            type: K,
                                                                                                                                                                            params: unknown[],
                                                                                                                                                                            options?: CreateOptions
                                                                                                                                                                            ) => T;
                                                                                                                                                                            • Creates an instance of a type as registered

                                                                                                                                                                            method findMetaCall

                                                                                                                                                                            findMetaCall: (callIndex: Uint8Array) => CallFunction;

                                                                                                                                                                              method findMetaError

                                                                                                                                                                              findMetaError: (
                                                                                                                                                                              errorIndex:
                                                                                                                                                                              | Uint8Array
                                                                                                                                                                              | DispatchErrorModule
                                                                                                                                                                              | DispatchErrorModuleU8
                                                                                                                                                                              | DispatchErrorModuleU8a
                                                                                                                                                                              ) => RegistryError;

                                                                                                                                                                                method findMetaEvent

                                                                                                                                                                                findMetaEvent: (eventIndex: Uint8Array) => CodecClass<GenericEventData>;

                                                                                                                                                                                  method get

                                                                                                                                                                                  get: <T extends Codec = Codec, K extends string = string>(
                                                                                                                                                                                  name: K,
                                                                                                                                                                                  withUnknown?: boolean,
                                                                                                                                                                                  knownTypeDef?: TypeDef
                                                                                                                                                                                  ) => CodecClass<T> | undefined;

                                                                                                                                                                                    method getChainProperties

                                                                                                                                                                                    getChainProperties: () => ChainProperties | undefined;

                                                                                                                                                                                      method getClassName

                                                                                                                                                                                      getClassName: (Type: CodecClass) => string | undefined;

                                                                                                                                                                                        method getDefinition

                                                                                                                                                                                        getDefinition: (typeName: string) => string | undefined;

                                                                                                                                                                                          method getModuleInstances

                                                                                                                                                                                          getModuleInstances: (
                                                                                                                                                                                          specName: AnyString,
                                                                                                                                                                                          moduleName: string
                                                                                                                                                                                          ) => string[] | undefined;

                                                                                                                                                                                            method getOrThrow

                                                                                                                                                                                            getOrThrow: <
                                                                                                                                                                                            T extends Codec = Codec,
                                                                                                                                                                                            K extends string = string,
                                                                                                                                                                                            R = DetectCodec<T, K>
                                                                                                                                                                                            >(
                                                                                                                                                                                            name: K,
                                                                                                                                                                                            msg?: string
                                                                                                                                                                                            ) => CodecClass<R>;

                                                                                                                                                                                              method getOrUnknown

                                                                                                                                                                                              getOrUnknown: <
                                                                                                                                                                                              T extends Codec = Codec,
                                                                                                                                                                                              K extends string = string,
                                                                                                                                                                                              R = DetectCodec<T, K>
                                                                                                                                                                                              >(
                                                                                                                                                                                              name: K
                                                                                                                                                                                              ) => CodecClass<R>;

                                                                                                                                                                                                method getSignedExtensionExtra

                                                                                                                                                                                                getSignedExtensionExtra: () => Record<string, string>;

                                                                                                                                                                                                  method getSignedExtensionTypes

                                                                                                                                                                                                  getSignedExtensionTypes: () => Record<string, string>;

                                                                                                                                                                                                    method getUnsafe

                                                                                                                                                                                                    getUnsafe: <T extends Codec = Codec, K extends string = string>(
                                                                                                                                                                                                    name: K,
                                                                                                                                                                                                    withUnknown?: boolean,
                                                                                                                                                                                                    knownTypeDef?: TypeDef
                                                                                                                                                                                                    ) => CodecClass<T> | undefined;

                                                                                                                                                                                                      method hasClass

                                                                                                                                                                                                      hasClass: (name: string) => boolean;

                                                                                                                                                                                                        method hasDef

                                                                                                                                                                                                        hasDef: (name: string) => boolean;

                                                                                                                                                                                                          method hash

                                                                                                                                                                                                          hash: (data: Uint8Array) => IU8a;

                                                                                                                                                                                                            method hasType

                                                                                                                                                                                                            hasType: (name: string) => boolean;

                                                                                                                                                                                                              method isLookupType

                                                                                                                                                                                                              isLookupType: (value: string) => boolean;
                                                                                                                                                                                                              • Returns true if the type is in a Compat format

                                                                                                                                                                                                              method register

                                                                                                                                                                                                              register: {
                                                                                                                                                                                                              (type: CodecClass | RegistryTypes): void;
                                                                                                                                                                                                              (name: string, type: CodecClass): void;
                                                                                                                                                                                                              };

                                                                                                                                                                                                                method setChainProperties

                                                                                                                                                                                                                setChainProperties: (properties?: ChainProperties) => void;

                                                                                                                                                                                                                  method setHasher

                                                                                                                                                                                                                  setHasher: (hasher?: CodecHasher | null) => void;

                                                                                                                                                                                                                    method setKnownTypes

                                                                                                                                                                                                                    setKnownTypes: (knownTypes: RegisteredTypes) => void;

                                                                                                                                                                                                                      method setLookup

                                                                                                                                                                                                                      setLookup: (lookup: PortableRegistry) => void;

                                                                                                                                                                                                                        method setMetadata

                                                                                                                                                                                                                        setMetadata: (
                                                                                                                                                                                                                        metadata: Metadata,
                                                                                                                                                                                                                        signedExtensions?: string[],
                                                                                                                                                                                                                        userExtensions?: ExtDef
                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                          method setSignedExtensions

                                                                                                                                                                                                                          setSignedExtensions: (
                                                                                                                                                                                                                          signedExtensions?: string[],
                                                                                                                                                                                                                          userExtensions?: ExtDef
                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                            Namespaces

                                                                                                                                                                                                                            namespace typeDefinitions

                                                                                                                                                                                                                            module 'interfaces/definitions.d.ts' {}

                                                                                                                                                                                                                              variable assets

                                                                                                                                                                                                                              const assets: Definitions;

                                                                                                                                                                                                                                variable attestations

                                                                                                                                                                                                                                const attestations: Definitions;

                                                                                                                                                                                                                                  variable aura

                                                                                                                                                                                                                                  const aura: Definitions;

                                                                                                                                                                                                                                    variable author

                                                                                                                                                                                                                                    const author: Definitions;

                                                                                                                                                                                                                                      variable authorship

                                                                                                                                                                                                                                      const authorship: Definitions;

                                                                                                                                                                                                                                        variable babe

                                                                                                                                                                                                                                        const babe: Definitions;

                                                                                                                                                                                                                                          variable balances

                                                                                                                                                                                                                                          const balances: Definitions;

                                                                                                                                                                                                                                            variable beefy

                                                                                                                                                                                                                                            const beefy: Definitions;

                                                                                                                                                                                                                                              variable benchmark

                                                                                                                                                                                                                                              const benchmark: Definitions;

                                                                                                                                                                                                                                                variable blockbuilder

                                                                                                                                                                                                                                                const blockbuilder: Definitions;

                                                                                                                                                                                                                                                  variable bridges

                                                                                                                                                                                                                                                  const bridges: Definitions;

                                                                                                                                                                                                                                                    variable chain

                                                                                                                                                                                                                                                    const chain: Definitions;

                                                                                                                                                                                                                                                      variable childstate

                                                                                                                                                                                                                                                      const childstate: Definitions;

                                                                                                                                                                                                                                                        variable claims

                                                                                                                                                                                                                                                        const claims: Definitions;

                                                                                                                                                                                                                                                          variable collective

                                                                                                                                                                                                                                                          const collective: Definitions;

                                                                                                                                                                                                                                                            variable consensus

                                                                                                                                                                                                                                                            const consensus: Definitions;

                                                                                                                                                                                                                                                              variable contracts

                                                                                                                                                                                                                                                              const contracts: Definitions;

                                                                                                                                                                                                                                                                variable contractsAbi

                                                                                                                                                                                                                                                                const contractsAbi: Definitions;

                                                                                                                                                                                                                                                                  variable crowdloan

                                                                                                                                                                                                                                                                  const crowdloan: Definitions;

                                                                                                                                                                                                                                                                    variable cumulus

                                                                                                                                                                                                                                                                    const cumulus: Definitions;

                                                                                                                                                                                                                                                                      variable democracy

                                                                                                                                                                                                                                                                      const democracy: Definitions;

                                                                                                                                                                                                                                                                        variable dev

                                                                                                                                                                                                                                                                        const dev: Definitions;

                                                                                                                                                                                                                                                                          variable discovery

                                                                                                                                                                                                                                                                          const discovery: Definitions;

                                                                                                                                                                                                                                                                            variable elections

                                                                                                                                                                                                                                                                            const elections: Definitions;

                                                                                                                                                                                                                                                                              variable engine

                                                                                                                                                                                                                                                                              const engine: Definitions;

                                                                                                                                                                                                                                                                                variable eth

                                                                                                                                                                                                                                                                                const eth: {
                                                                                                                                                                                                                                                                                rpc: import('../../types').DefinitionsRpc;
                                                                                                                                                                                                                                                                                runtime: import('../../types').DefinitionsCall;
                                                                                                                                                                                                                                                                                types: DefinitionsTypes;
                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                  variable evm

                                                                                                                                                                                                                                                                                  const evm: Definitions;

                                                                                                                                                                                                                                                                                    variable extrinsics

                                                                                                                                                                                                                                                                                    const extrinsics: Definitions;

                                                                                                                                                                                                                                                                                      variable finality

                                                                                                                                                                                                                                                                                      const finality: Definitions;

                                                                                                                                                                                                                                                                                        variable genericAsset

                                                                                                                                                                                                                                                                                        const genericAsset: Definitions;

                                                                                                                                                                                                                                                                                          variable gilt

                                                                                                                                                                                                                                                                                          const gilt: Definitions;

                                                                                                                                                                                                                                                                                            variable grandpa

                                                                                                                                                                                                                                                                                            const grandpa: Definitions;

                                                                                                                                                                                                                                                                                              variable identity

                                                                                                                                                                                                                                                                                              const identity: Definitions;

                                                                                                                                                                                                                                                                                                variable imOnline

                                                                                                                                                                                                                                                                                                const imOnline: Definitions;

                                                                                                                                                                                                                                                                                                  variable lottery

                                                                                                                                                                                                                                                                                                  const lottery: Definitions;

                                                                                                                                                                                                                                                                                                    variable metadata

                                                                                                                                                                                                                                                                                                    const metadata: Definitions;

                                                                                                                                                                                                                                                                                                      variable mmr

                                                                                                                                                                                                                                                                                                      const mmr: Definitions;

                                                                                                                                                                                                                                                                                                        variable nimbus

                                                                                                                                                                                                                                                                                                        const nimbus: Definitions;

                                                                                                                                                                                                                                                                                                          variable nompools

                                                                                                                                                                                                                                                                                                          const nompools: Definitions;

                                                                                                                                                                                                                                                                                                            variable offchain

                                                                                                                                                                                                                                                                                                            const offchain: Definitions;

                                                                                                                                                                                                                                                                                                              variable offences

                                                                                                                                                                                                                                                                                                              const offences: Definitions;

                                                                                                                                                                                                                                                                                                                variable ormlOracle

                                                                                                                                                                                                                                                                                                                const ormlOracle: Definitions;

                                                                                                                                                                                                                                                                                                                  variable ormlTokens

                                                                                                                                                                                                                                                                                                                  const ormlTokens: Definitions;

                                                                                                                                                                                                                                                                                                                    variable parachains

                                                                                                                                                                                                                                                                                                                    const parachains: Definitions;

                                                                                                                                                                                                                                                                                                                      variable payment

                                                                                                                                                                                                                                                                                                                      const payment: Definitions;

                                                                                                                                                                                                                                                                                                                        variable poll

                                                                                                                                                                                                                                                                                                                        const poll: Definitions;

                                                                                                                                                                                                                                                                                                                          variable pow

                                                                                                                                                                                                                                                                                                                          const pow: Definitions;

                                                                                                                                                                                                                                                                                                                            variable proxy

                                                                                                                                                                                                                                                                                                                            const proxy: Definitions;

                                                                                                                                                                                                                                                                                                                              variable purchase

                                                                                                                                                                                                                                                                                                                              const purchase: Definitions;

                                                                                                                                                                                                                                                                                                                                variable recovery

                                                                                                                                                                                                                                                                                                                                const recovery: Definitions;

                                                                                                                                                                                                                                                                                                                                  variable rpc

                                                                                                                                                                                                                                                                                                                                  const rpc: Definitions;

                                                                                                                                                                                                                                                                                                                                    variable runtime

                                                                                                                                                                                                                                                                                                                                    const runtime: Definitions;

                                                                                                                                                                                                                                                                                                                                      variable scaleInfo

                                                                                                                                                                                                                                                                                                                                      const scaleInfo: Definitions;

                                                                                                                                                                                                                                                                                                                                        variable scheduler

                                                                                                                                                                                                                                                                                                                                        const scheduler: Definitions;

                                                                                                                                                                                                                                                                                                                                          variable session

                                                                                                                                                                                                                                                                                                                                          const session: Definitions;

                                                                                                                                                                                                                                                                                                                                            variable society

                                                                                                                                                                                                                                                                                                                                            const society: Definitions;

                                                                                                                                                                                                                                                                                                                                              variable staking

                                                                                                                                                                                                                                                                                                                                              const staking: Definitions;

                                                                                                                                                                                                                                                                                                                                                variable state

                                                                                                                                                                                                                                                                                                                                                const state: Definitions;

                                                                                                                                                                                                                                                                                                                                                  variable support

                                                                                                                                                                                                                                                                                                                                                  const support: Definitions;

                                                                                                                                                                                                                                                                                                                                                    variable syncstate

                                                                                                                                                                                                                                                                                                                                                    const syncstate: Definitions;

                                                                                                                                                                                                                                                                                                                                                      variable system

                                                                                                                                                                                                                                                                                                                                                      const system: Definitions;

                                                                                                                                                                                                                                                                                                                                                        variable treasury

                                                                                                                                                                                                                                                                                                                                                        const treasury: Definitions;

                                                                                                                                                                                                                                                                                                                                                          variable txpayment

                                                                                                                                                                                                                                                                                                                                                          const txpayment: Definitions;

                                                                                                                                                                                                                                                                                                                                                            variable txqueue

                                                                                                                                                                                                                                                                                                                                                            const txqueue: Definitions;

                                                                                                                                                                                                                                                                                                                                                              variable uniques

                                                                                                                                                                                                                                                                                                                                                              const uniques: Definitions;

                                                                                                                                                                                                                                                                                                                                                                variable utility

                                                                                                                                                                                                                                                                                                                                                                const utility: Definitions;

                                                                                                                                                                                                                                                                                                                                                                  variable vesting

                                                                                                                                                                                                                                                                                                                                                                  const vesting: Definitions;

                                                                                                                                                                                                                                                                                                                                                                    variable xcm

                                                                                                                                                                                                                                                                                                                                                                    const xcm: Definitions;

                                                                                                                                                                                                                                                                                                                                                                      Package Files (103)

                                                                                                                                                                                                                                                                                                                                                                      Dependencies (8)

                                                                                                                                                                                                                                                                                                                                                                      Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                      No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                      Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                      No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                      Badge

                                                                                                                                                                                                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@polkadot/types.

                                                                                                                                                                                                                                                                                                                                                                      • Markdown
                                                                                                                                                                                                                                                                                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@polkadot/types)
                                                                                                                                                                                                                                                                                                                                                                      • HTML
                                                                                                                                                                                                                                                                                                                                                                        <a href="https://www.jsdocs.io/package/@polkadot/types"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>