@polkadot/types

  • Version 8.7.1
  • Published
  • 1.69 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 U8aFixed {}
                                    • 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);

                                      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 toRawType

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

                                      method toString

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

                                      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 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 registry

                                                      readonly registry: Registry;

                                                        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 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 Base<
                                                                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: GenericEventData;
                                                                    • 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 section

                                                                      readonly section: string;
                                                                      • The section as a string

                                                                      property typeDef

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

                                                                      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

                                                                        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 Base<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: Hash;
                                                                              • The block [[Hash]] the signature applies to (mortal/immortal)

                                                                              property era

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

                                                                              property genesisHash

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

                                                                              property method

                                                                              readonly method: Raw;
                                                                              • The [[Raw]] 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: Hash;
                                                                                  • The block [[Hash]] the signature applies to (mortal/immortal)

                                                                                  property era

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

                                                                                  property genesisHash

                                                                                  readonly genesisHash: Hash;
                                                                                  • The genesis [[Hash]] 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 registry

                                                                                    readonly registry: Registry;

                                                                                      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 registry

                                                                                          readonly registry: Registry;

                                                                                            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 Base<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: Hash;

                                                                                                            property blockNumber

                                                                                                            readonly blockNumber: INumber;

                                                                                                              property era

                                                                                                              readonly era: ExtrinsicEra;

                                                                                                                property genesisHash

                                                                                                                readonly genesisHash: Hash;

                                                                                                                  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 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;

                                                                                                                                          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 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 | 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: string,
                                                                                                                                                                                    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 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 elections

                                                                                                                                                                                                                                                                const elections: Definitions;

                                                                                                                                                                                                                                                                  variable engine

                                                                                                                                                                                                                                                                  const engine: Definitions;

                                                                                                                                                                                                                                                                    variable eth

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

                                                                                                                                                                                                                                                                      variable evm

                                                                                                                                                                                                                                                                      const evm: Definitions;

                                                                                                                                                                                                                                                                        variable extrinsics

                                                                                                                                                                                                                                                                        const extrinsics: 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 offchain

                                                                                                                                                                                                                                                                                          const offchain: Definitions;

                                                                                                                                                                                                                                                                                            variable offences

                                                                                                                                                                                                                                                                                            const offences: Definitions;

                                                                                                                                                                                                                                                                                              variable parachains

                                                                                                                                                                                                                                                                                              const parachains: Definitions;

                                                                                                                                                                                                                                                                                                variable payment

                                                                                                                                                                                                                                                                                                const payment: Definitions;

                                                                                                                                                                                                                                                                                                  variable poll

                                                                                                                                                                                                                                                                                                  const poll: 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 uniques

                                                                                                                                                                                                                                                                                                                                    const uniques: Definitions;

                                                                                                                                                                                                                                                                                                                                      variable utility

                                                                                                                                                                                                                                                                                                                                      const utility: Definitions;

                                                                                                                                                                                                                                                                                                                                        variable vesting

                                                                                                                                                                                                                                                                                                                                        const vesting: Definitions;

                                                                                                                                                                                                                                                                                                                                          variable xcm

                                                                                                                                                                                                                                                                                                                                          const xcm: Definitions;

                                                                                                                                                                                                                                                                                                                                            Package Files (93)

                                                                                                                                                                                                                                                                                                                                            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>