@polkadot/types

@polkadot/types

Version 16.4.9
Published 13 days ago
3.13 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

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 GeneralExtrinsic

class GeneralExtrinsic extends Struct {}

constructor

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

property assetId

readonly assetId: IOption<any>;

The (optional) asset id for this signature for chains that support transaction fees in assets

property encodedLength

readonly encodedLength: number;

The length of the value when encoded as a Uint8Array

property era

readonly era: ExtrinsicEra;

The [[ExtrinsicEra]]

property metadataHash

readonly metadataHash: IOption<Hash>;

The (optional) [[Hash]] for the metadata proof

property method

readonly method: Call;

The [[Call]] this extrinsic wraps

property mode

readonly mode: INumber;

The mode used for the CheckMetadataHash TransactionExtension

property nonce

readonly nonce: ICompact<INumber>;

The [[Index]]

property preamble

readonly preamble: number;

The [[Preamble]] for the extrinsic

property tip

readonly tip: ICompact<INumber>;

The tip [[Balance]]

property transactionExtensionVersion

readonly transactionExtensionVersion: INumber;

The version of the TransactionExtensions used in this extrinsic

property version

readonly version: number;

The extrinsic's version

method addSignature

addSignature: () => void;

method decodeExtrinsic

static decodeExtrinsic: (
    registry: Registry,
    value?: GeneralExtrinsicValue | Uint8Array | HexString
) => object;

method encode

encode: () => Uint8Array;

Returns an encoded GeneralExtrinsic

method sign

sign: () => void;

method signature

signature: () => void;

method signFake

signFake: () => void;

method toHex

toHex: (isBare?: boolean) => HexString;

method toRawType

toRawType: () => string;

method toU8a

toU8a: (isBare?: boolean) => Uint8Array;

class GenericAccountId

class GenericAccountId extends BaseAccountId {}

GenericAccountId A wrapper around an AccountId/PublicKey representation. Since we are dealing with underlying PublicKeys (32 bytes in length), we extend from U8aFixed which is just a Uint8Array wrapper with a fixed length. If constructed with an empty value ([], "", undefined) it will result in the zero account 0x000...000.

constructor

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

class GenericAccountId32

class GenericAccountId extends BaseAccountId {}

GenericAccountId A wrapper around an AccountId/PublicKey representation. Since we are dealing with underlying PublicKeys (32 bytes in length), we extend from U8aFixed which is just a Uint8Array wrapper with a fixed length. If constructed with an empty value ([], "", undefined) it will result in the zero account 0x000...000.

constructor

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

class GenericAccountId33

class GenericAccountId33 extends BaseAccountId {}

constructor

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

class GenericAccountIndex

class GenericAccountIndex extends u32 {}

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

constructor

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

method calcLength

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

method eq

eq: (other?: unknown) => boolean;

Compares the value of the input to see if there is a match

method readLength

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

method toHuman

toHuman: () => string;

Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

method toJSON

toJSON: () => string;

Converts the Object to JSON, typically used for RPC transfers

method toPrimitive

toPrimitive: () => string;

Converts the value in a best-fit primitive form

method toRawType

toRawType: () => string;

Returns the base runtime type name for this instance

method toString

toString: () => string;

Returns the string representation of the value

method writeLength

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

class GenericAddress

class GenericMultiAddress extends Enum {}

constructor

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

method inspect

inspect: () => Inspect;

Returns a breakdown of the hex encoding for this Codec

method toString

toString: () => string;

Returns the string representation of the value

class GenericBlock

class GenericBlock extends Struct {}

GenericBlock A block encoded with header and extrinsics

constructor

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

property contentHash

readonly contentHash: IU8a;

Encodes a content [[Hash]] for the block

property extrinsics

readonly extrinsics: Vec<GenericExtrinsic<AnyTuple>>;

The [[Extrinsic]] contained in the block

property hash

readonly hash: IU8a;

Block/header [[Hash]]

readonly header: Header;

The [[Header]] of the block

class GenericCall

class GenericCall<A extends AnyTuple = AnyTuple>
    extends Struct
    implements CallBase<A> {}

GenericCall Extrinsic function descriptor

constructor

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

property args

readonly args: AnyTuple;

The arguments for the function call

property argsDef

readonly argsDef: ArgsDef;

The argument definitions

property argsEntries

readonly argsEntries: [string, Codec][];

The argument entries

property callIndex

readonly callIndex: Uint8Array;

The encoded [sectionIndex, methodIndex] identifier

property data

readonly data: Uint8Array;

The encoded data

property meta

readonly meta: FunctionMetadataLatest;

The [[FunctionMetadata]]

property method

readonly method: string;

Returns the name of the method

property section

readonly section: string;

Returns the module containing the method

method is

is: (other: IMethod<AnyTuple>) => other is IMethod<A>;

Checks if the source matches this in type

method toHuman

toHuman: (
    isExpanded?: boolean,
    disableAscii?: 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 isEthereum

readonly isEthereum: Bool;

The chain uses Ethereum addresses

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 isNimbus

readonly isNimbus: boolean;

true is the engine matches nimbus

property isPow

readonly isPow: boolean;

true is the engine matches pow

method extractAuthor

extractAuthor: (
    bytes: Bytes,
    sessionValidators: AccountId[]
) => AccountId | undefined;

From the input bytes, decode into an author

method toHuman

toHuman: () => string;

Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

method toRawType

toRawType: () => string;

Returns the base runtime type name for this instance

method toString

toString: () => string;

Override the default toString to return a 4-byte string

class GenericEthereumAccountId

class GenericEthereumAccountId extends U8aFixed {}

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

constructor

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

method eq

eq: (other?: unknown) => boolean;

Compares the value of the input to see if there is a match

method toHuman

toHuman: () => string;

Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

method toJSON

toJSON: () => string;

Converts the Object to JSON, typically used for RPC transfers

method toPrimitive

toPrimitive: () => string;

Converts the value in a best-fit primitive form

method toRawType

toRawType: () => string;

Returns the base runtime type name for this instance

method toString

toString: () => string;

Returns the string representation of the value

class GenericEthereumLookupSource

class GenericEthereumLookupSource extends AbstractBase<
    GenericEthereumAccountId | GenericAccountIndex
> {}

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

constructor

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

property encodedLength

readonly encodedLength: number;

The length of the value when encoded as a Uint8Array

method toHex

toHex: () => HexString;

Returns a hex string representation of the value

method toRawType

toRawType: () => string;

Returns the base runtime type name for this instance

method toU8a

toU8a: (isBare?: boolean) => Uint8Array;

Encodes the value as a Uint8Array as per the SCALE specifications
Parameter isBare
true when the value has none of the type-specific prefixes (internal)

class GenericEvent

class GenericEvent extends Struct implements IEvent<Codec[]> {}

GenericEvent A representation of a system event. These are generated via the [[Metadata]] interfaces and specific to a specific Substrate runtime

constructor

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

property data

readonly data: Codec[] & IEventData;

The wrapped [[EventData]]

property index

readonly index: EventId;

The [[EventId]], identifying the raw event

property meta

readonly meta: EventMetadataLatest;

The [[EventMetadata]] with the documentation

property method

readonly method: string;

The method string identifying the event

property section

readonly section: string;

The section string identifying the event

property typeDef

readonly typeDef: TypeDef[];

The [[TypeDef]] for the event

method toHuman

toHuman: (
    isExpanded?: boolean,
    disableAscii?: boolean
) => Record<string, AnyJson>;

Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

class GenericEventData

class GenericEventData extends Tuple implements IEventData {}

GenericEventData Wrapper for the actual data that forms part of an [[Event]]

constructor

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

property meta

readonly meta: EventMetadataLatest;

The wrapped [[EventMetadata]]

property method

readonly method: string;

The method as a string

property names

readonly names: string[];

The field names (as available)

property section

readonly section: string;

The section as a string

property typeDef

readonly typeDef: TypeDef[];

The [[TypeDef]] for this event

method toHuman

toHuman: (isExtended?: boolean, disableAscii?: boolean) => AnyJson;

Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

class GenericExtrinsic

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

GenericExtrinsic Representation of an Extrinsic in the system. It contains the actual call, (optional) signature and encodes with an actual length prefix
https://github.com/paritytech/wiki/blob/master/Extrinsic.md#the-extrinsic-format-for-node.
Can be: - signed, to create a transaction - left as is, to create an inherent

constructor

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

property hash

readonly hash: CodecHash;

returns a hash of the contents

property LATEST_EXTRINSIC_VERSION

static LATEST_EXTRINSIC_VERSION: number;

method addSignature

addSignature: (
    signer: Address | Uint8Array | string,
    signature: Uint8Array | HexString,
    payload: ExtrinsicPayloadValue | Uint8Array | HexString
) => GenericExtrinsic<A>;

Injects an already-generated signature into the extrinsic

method inspect

inspect: () => Inspect;

Returns a breakdown of the hex encoding for this Codec

method sign

sign: (account: IKeyringPair, options: SignatureOptions) => GenericExtrinsic<A>;

Sign the extrinsic with a specific keypair

method signFake

signFake: (
    signer: Address | Uint8Array | string,
    options: SignatureOptions
) => GenericExtrinsic<A>;

Adds a fake signature to the extrinsic

method toHex

toHex: (isBare?: boolean) => HexString;

Returns a hex string representation of the value

method toHuman

toHuman: (isExpanded?: boolean, disableAscii?: boolean) => AnyJson;

Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

method toJSON

toJSON: () => string;

Converts the Object to JSON, typically used for RPC transfers

method toRawType

toRawType: () => string;

Returns the base runtime type name for this instance

method toU8a

toU8a: (isBare?: boolean) => Uint8Array;

Encodes the value as a Uint8Array as per the SCALE specifications
Parameter isBare
true when the value is not length-prefixed

method toU8aInner

toU8aInner: () => Uint8Array[];

class GenericExtrinsicEra

class GenericExtrinsicEra extends Enum implements IExtrinsicEra {}

GenericExtrinsicEra The era for an extrinsic, indicating either a mortal or immortal extrinsic

constructor

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

property asImmortalEra

readonly asImmortalEra: ImmortalEra;

Returns the item as a [[ImmortalEra]]

property asMortalEra

readonly asMortalEra: MortalEra;

Returns the item as a [[MortalEra]]

property encodedLength

readonly encodedLength: number;

Override the encoded length method

property isImmortalEra

readonly isImmortalEra: boolean;

true if Immortal

property isMortalEra

readonly isMortalEra: boolean;

true if Mortal

method toU8a

toU8a: (isBare?: boolean) => Uint8Array;

Encodes the value as a Uint8Array as per the parity-codec specifications
Parameter isBare
true when the value has none of the type-specific prefixes (internal)

class GenericExtrinsicPayload

class GenericExtrinsicPayload extends AbstractBase<ExtrinsicPayloadVx> {}

GenericExtrinsicPayload A signing payload for an [[Extrinsic]]. For the final encoding, it is variable length based on the contents included

constructor

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

property assetId

readonly assetId: IOption<any>;

The (optional) asset id as a [[u32]] or [[MultiLocation]] for this payload

property blockHash

readonly blockHash: BlockHash;

The block [[BlockHash]] the signature applies to (mortal/immortal)

property era

readonly era: GenericExtrinsicEra;

The [[ExtrinsicEra]]

property genesisHash

readonly genesisHash: BlockHash;

The genesis block [[BlockHash]] the signature applies to

property metadataHash

readonly metadataHash: IOption<Hash>;

The (optional) [[Hash]] of the genesis metadata for this payload

property method

readonly method: Bytes;

The [[Bytes]] contained in the payload

property nonce

readonly nonce: ICompact<INumber>;

The [[Index]]

property specVersion

readonly specVersion: INumber;

The specVersion as a [[u32]] for this payload

property tip

readonly tip: ICompact<INumber>;

The [[Balance]]

property transactionVersion

readonly transactionVersion: INumber;

The transaction version as a [[u32]] for this payload

method eq

eq: (other?: unknown) => boolean;

Compares the value of the input to see if there is a match

method sign

sign: (signerPair: IKeyringPair) => { signature: HexString };

Sign the payload with the keypair

method toHuman

toHuman: (isExtended?: boolean, disableAscii?: 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 toRawType

toRawType: () => string;

Returns the base runtime type name for this instance

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

The (optional) asset id for this signature for chains that support transaction fees in assets

property blockHash

readonly blockHash: BlockHash;

The block [[BlockHash]] the signature applies to (mortal/immortal)

property era

readonly era: ExtrinsicEra;

The [[ExtrinsicEra]]

property genesisHash

readonly genesisHash: BlockHash;

The genesis [[BlockHash]] the signature applies to (mortal/immortal)

property metadataHash

readonly metadataHash: IOption<Hash>;

The (optional) asset id for this signature for chains that support transaction fees in assets

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 GenericExtrinsicPayloadV5

class GenericExtrinsicPayloadV5 extends Struct {}

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

The (optional) asset id for this signature for chains that support transaction fees in assets

property blockHash

readonly blockHash: BlockHash;

The block [[BlockHash]] the signature applies to (mortal/immortal)

property era

readonly era: ExtrinsicEra;

The [[ExtrinsicEra]]

property genesisHash

readonly genesisHash: BlockHash;

The genesis [[BlockHash]] the signature applies to (mortal/immortal)

property metadataHash

readonly metadataHash: IOption<Hash>;

The (optional) metadataHash proof for the CheckMetadataHash TransactionExtension

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
[Disabled for ExtrinsicV5]

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 assetId

readonly assetId: IOption<any>;

The [[u32]] or [[MultiLocation]] assetId

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 metadataHash

readonly metadataHash: IOption<Hash>;

The [[Hash]] for the metadata

property mode

readonly mode: INumber;

the [[u32]] mode

property multiSignature

readonly multiSignature: ExtrinsicSignature;

The raw [[ExtrinsicSignature]]

property nonce

readonly nonce: ICompact<INumber>;

The [[Index]] for the signature

property signature

readonly signature: EcdsaSignature | Ed25519Signature | Sr25519Signature;

The actual [[EcdsaSignature]], [[Ed25519Signature]] or [[Sr25519Signature]]

property signer

readonly signer: Address;

The [[Address]] that signed

property tip

readonly tip: ICompact<INumber>;

The [[Balance]] tip

method addSignature

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

Adds a raw signature

method createPayload

createPayload: (
    method: Call,
    options: SignatureOptions
) => GenericExtrinsicPayloadV4;

Creates a payload from the supplied options

method sign

sign: (
    method: Call,
    account: IKeyringPair,
    options: SignatureOptions
) => IExtrinsicSignature;

Generate a payload and applies the signature from a keypair

method signFake

signFake: (
    method: Call,
    address: Address | Uint8Array | string,
    options: SignatureOptions
) => IExtrinsicSignature;

Generate a payload and applies a fake signature

method toU8a

toU8a: (isBare?: boolean) => Uint8Array;

Encodes the value as a Uint8Array as per the SCALE specifications
Parameter isBare
true when the value has none of the type-specific prefixes (internal)

class GenericExtrinsicSignatureV5

class GenericExtrinsicSignatureV5 extends Struct implements IExtrinsicSignature {}

GenericExtrinsicSignatureV5 A container for the [[Signature]] associated with a specific [[Extrinsic]]

constructor

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

property assetId

readonly assetId: IOption<any>;

The [[u32]] or [[MultiLocation]] assetId

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 metadataHash

readonly metadataHash: IOption<Hash>;

The (optional) [[Hash]] for the metadata proof

property mode

readonly mode: INumber;

the [[u32]] mode

property multiSignature

readonly multiSignature: ExtrinsicSignature;

The raw [[ExtrinsicSignature]]

property nonce

readonly nonce: ICompact<INumber>;

The [[Index]] for the signature

property signature

readonly signature: EcdsaSignature | Ed25519Signature | Sr25519Signature;

The actual [[EcdsaSignature]], [[Ed25519Signature]] or [[Sr25519Signature]]

property signer

readonly signer: Address;

The [[Address]] that signed

property tip

readonly tip: ICompact<INumber>;

The [[Balance]] tip

property transactionExtensionVersion

readonly transactionExtensionVersion: INumber;

The [[u8]] for the TransactionExtension version

method addSignature

addSignature: (
    _signer: Address | Uint8Array | string,
    _signature: Uint8Array | HexString,
    _payload: ExtrinsicPayloadValue | Uint8Array | HexString
) => IExtrinsicSignature;

Adds a raw signature
[Disabled for ExtrinsicV5]

method createPayload

createPayload: (
    method: Call,
    options: SignatureOptions
) => GenericExtrinsicPayloadV5;

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
[Disabled for ExtrinsicV5]

method signFake

signFake: (
    _method: Call,
    _address: Address | Uint8Array | string,
    _options: SignatureOptions
) => IExtrinsicSignature;

Generate a payload and applies a fake signature
[Disabled for ExtrinsicV5]

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 | Call | ExtrinsicValueV4,
    { isSigned }?: Partial<ExtrinsicOptions>
);

property encodedLength

readonly encodedLength: number;

The length of the value when encoded as a Uint8Array

property method

readonly method: Call;

The [[Call]] this extrinsic wraps

property signature

readonly signature: ExtrinsicSignatureV4;

The [[ExtrinsicSignatureV4]]

property version

readonly version: number;

The version for the signature

method addSignature

addSignature: (
    signer: Address | Uint8Array | string,
    signature: Uint8Array | HexString,
    payload: ExtrinsicPayloadValue | Uint8Array | HexString
) => GenericExtrinsicV4;

Add an [[ExtrinsicSignatureV4]] to the extrinsic (already generated)

method sign

sign: (account: IKeyringPair, options: SignatureOptions) => GenericExtrinsicV4;

Sign the extrinsic with a specific keypair

method signFake

signFake: (
    signer: Address | Uint8Array | string,
    options: SignatureOptions
) => GenericExtrinsicV4;

Adds a fake signature to the extrinsic

class GenericExtrinsicV5

class GenericExtrinsicV5 extends Struct implements IExtrinsicV5Impl {}

GenericExtrinsicV5 The fourth generation of compact extrinsics

constructor

constructor(
    registry: Registry,
    value?: Uint8Array | ExtrinsicValueV5 | 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 preamble

readonly preamble: Preamble;

The [[Preamble]] for the extrinsic

property signature

readonly signature: ExtrinsicSignatureV5;

The [[ExtrinsicSignatureV5]]

property version

readonly version: number;

The version for the signature

method addSignature

addSignature: (
    _signer: Address | Uint8Array | string,
    _signature: Uint8Array | HexString,
    _payload: ExtrinsicPayloadValue | Uint8Array | HexString
) => GenericExtrinsicV5;

Add an [[ExtrinsicSignatureV5]] to the extrinsic (already generated)
[Disabled for ExtrinsicV5]

method sign

sign: (_account: IKeyringPair, _options: SignatureOptions) => GenericExtrinsicV5;

Sign the extrinsic with a specific keypair
[Disabled for ExtrinsicV5]

method signFake

signFake: (
    _signer: Address | Uint8Array | string,
    _options: SignatureOptions
) => GenericExtrinsicV5;

Adds a fake signature to the extrinsic
[Disabled for ExtrinsicV5]

class GenericImmortalEra

class ImmortalEra extends Raw {}

ImmortalEra The ImmortalEra for an extrinsic

constructor

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

class GenericLookupSource

class GenericLookupSource extends AbstractBase<
    GenericAccountId | GenericAccountIndex
> {}

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

constructor

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

property encodedLength

readonly encodedLength: number;

The length of the value when encoded as a Uint8Array

method inspect

inspect: () => Inspect;

Returns a breakdown of the hex encoding for this Codec

method toHex

toHex: () => HexString;

Returns a hex string representation of the value

method toRawType

toRawType: () => string;

Returns the base runtime type name for this instance

method toU8a

toU8a: (isBare?: boolean) => Uint8Array;

Encodes the value as a Uint8Array as per the SCALE specifications
Parameter isBare
true when the value has none of the type-specific prefixes (internal)

class GenericMortalEra

class MortalEra extends Tuple {}

MortalEra The MortalEra for an extrinsic, indicating period and phase

constructor

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

property encodedLength

readonly encodedLength: number;

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

property period

readonly period: INumber;

The period of this Mortal wraps as a [[U64]]

property phase

readonly phase: INumber;

The phase of this Mortal wraps as a [[U64]]

method birth

birth: (current: BN | bigint | number | string) => number;

Get the block number of the start of the era whose properties this object describes that current belongs to.

method death

death: (current: BN | bigint | number | string) => number;

Get the block number of the first block at which the era has ended.

method toHuman

toHuman: () => any;

Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

method toJSON

toJSON: () => any;

Returns a JSON representation of the actual value

method toU8a

toU8a: (_isBare?: boolean) => Uint8Array;

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

class GenericMultiAddress

class GenericMultiAddress extends Enum {}

constructor

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

method inspect

inspect: () => Inspect;

Returns a breakdown of the hex encoding for this Codec

method toString

toString: () => string;

Returns the string representation of the value

class GenericSignerPayload

class GenericSignerPayload
    extends Struct
    implements ISignerPayload, SignerPayloadType {}

GenericSignerPayload A generic signer payload that can be used for serialization between API and signer

constructor

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

property address

readonly address: Address;

property assetId

readonly assetId: IOption<any>;

property blockHash

readonly blockHash: BlockHash;

property blockNumber

readonly blockNumber: INumber;

property era

readonly era: ExtrinsicEra;

property genesisHash

readonly genesisHash: BlockHash;

property metadataHash

readonly metadataHash: IOption<Hash>;

property method

readonly method: Call;

property mode

readonly mode: INumber;

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;

property withSignedTransaction

readonly withSignedTransaction: boolean;

method toPayload

toPayload: () => SignerPayloadJSON;

Creates an representation of the structure as an ISignerPayload JSON

method toRaw

toRaw: () => SignerPayloadRaw;

Creates a representation of the payload in raw Exrinsic form

class GenericVote

class GenericVote extends U8aFixed {}

GenericVote A number of lock periods, plus a vote, one way or the other.

constructor

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

property conviction

readonly conviction: Conviction;

returns a V2 conviction

property isAye

readonly isAye: boolean;

true if the wrapped value is a positive vote

property isNay

readonly isNay: boolean;

true if the wrapped value is a negative vote

method toHuman

toHuman: (isExpanded?: boolean) => AnyJson;

Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information

method toPrimitive

toPrimitive: () => any;

Converts the value in a best-fit primitive form

method toRawType

toRawType: () => string;

Returns the base runtime type name for this instance

class Metadata

class Metadata extends MetadataVersioned {}

Metadata The versioned runtime metadata as a decoded structure

constructor

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

class PortableRegistry

class PortableRegistry extends Struct implements ILookup {}

constructor

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

property names

readonly names: string[];

Returns all the available type names for this chain

property paramTypes

readonly paramTypes: TypeInfoParams;

Returns all the available parameterized types for this chain

property types

readonly types: Vec<PortableType>;

The types of the registry

method getName

getName: (
    lookupId: SiLookupTypeId | LookupString | number
) => string | undefined;

Returns the name for a specific lookup

method getSiType

getSiType: (lookupId: SiLookupTypeId | LookupString | number) => SiType;

Finds a specific type in the registry

method getTypeDef

getTypeDef: (lookupId: SiLookupTypeId | LookupString | number) => TypeDef;

Lookup the type definition for the index

method register

register: () => void;

method sanitizeField

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

For a specific field, perform adjustments to not have built-in conflicts

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: (_isExtended?: boolean, disableAscii?: boolean) => 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 chainIsEthereum

readonly chainIsEthereum: boolean;

property chainSS58

readonly chainSS58: number;

property chainTokens

readonly chainTokens: string[];

property createdAtHash

createdAtHash?: Hash;

property firstCallIndex

readonly firstCallIndex: Uint8Array;

property knownTypes

readonly knownTypes: RegisteredTypes;

property lookup

readonly lookup: PortableRegistry;

property metadata

readonly metadata: MetadataLatest;

property signedExtensions

readonly signedExtensions: string[];

property unknownTypes

readonly unknownTypes: string[];

method clearCache

clearCache: () => void;

method createClass

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

Creates an instance of the class

method createClassUnsafe

createClassUnsafe: <T extends Codec = Codec, K extends string = string>(
    type: K
) => CodecClass<T>;

Creates an instance of the class

method createLookupType

createLookupType: (lookupId: SiLookupTypeId | number) => LookupString;

Creates a lookup string from the supplied id

method createType

createType: <T extends Codec = Codec, K extends string = string>(
    type: K,
    ...params: unknown[]
) => DetectCodec<T, K>;

Creates an instance of a type as registered

method createTypeUnsafe

createTypeUnsafe: <T extends Codec = Codec, K extends string = string>(
    type: K,
    params: unknown[],
    options?: CreateOptions
) => T;

Creates an instance of a type as registered

method findMetaCall

findMetaCall: (callIndex: Uint8Array) => CallFunction;

method findMetaError

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

method findMetaEvent

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

method get

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

method getChainProperties

getChainProperties: () => ChainProperties | undefined;

method getClassName

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

method getDefinition

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

method getModuleInstances

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

method getOrThrow

getOrThrow: <
    T extends Codec = Codec,
    K extends string = string,
    R = DetectCodec<T, K>
>(
    name: K
) => 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 getTransactionExtensionVersion

getTransactionExtensionVersion: () => number;

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) => value is LookupString;

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,
    noInitWarn?: boolean
) => void;

method setSignedExtensions

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

Namespaces

namespace typeDefinitions

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

variable assetConversion

const assetConversion: Definitions;

variable assets

const assets: Definitions;

variable attestations

const attestations: Definitions;

variable aura

const aura: Definitions;

variable author

const author: Definitions;

variable authorship

const authorship: Definitions;

variable babe

const babe: Definitions;

variable balances

const balances: Definitions;

variable beefy

const beefy: Definitions;

variable benchmark

const benchmark: Definitions;

variable blockbuilder

const blockbuilder: Definitions;

variable bridges

const bridges: Definitions;

variable chain

const chain: Definitions;

variable childstate

const childstate: Definitions;

variable claims

const claims: Definitions;

variable collective

const collective: Definitions;

variable consensus

const consensus: Definitions;

variable contracts

const contracts: Definitions;

variable contractsAbi

const contractsAbi: Definitions;

variable crowdloan

const crowdloan: Definitions;

variable cumulus

const cumulus: Definitions;

variable democracy

const democracy: Definitions;

variable dev

const dev: Definitions;

variable discovery

const discovery: Definitions;

variable dryRunApi

const dryRunApi: Definitions;

variable elections

const elections: Definitions;

variable engine

const engine: Definitions;

variable eth

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

variable evm

const evm: Definitions;

variable extrinsics

const extrinsics: Definitions;

variable finality

const finality: Definitions;

variable fungibles

const fungibles: Definitions;

variable genericAsset

const genericAsset: Definitions;

variable genesisBuilder

const genesisBuilder: 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 mixnet

const mixnet: Definitions;

variable mmr

const mmr: Definitions;

variable nfts

const nfts: Definitions;

variable nimbus

const nimbus: Definitions;

variable nompools

const nompools: Definitions;

variable offchain

const offchain: Definitions;

variable offences

const offences: Definitions;

variable ormlOracle

const ormlOracle: Definitions;

variable ormlTokens

const ormlTokens: Definitions;

variable parachains

const parachains: Definitions;

variable payment

const payment: Definitions;

variable poll

const poll: Definitions;

variable pow

const pow: Definitions;

variable proxy

const proxy: Definitions;

variable purchase

const purchase: Definitions;

variable recovery

const recovery: Definitions;

variable rpc

const rpc: Definitions;

variable runtime

const runtime: Definitions;

variable scaleInfo

const scaleInfo: Definitions;

variable scheduler

const scheduler: Definitions;

variable session

const session: Definitions;

variable society

const society: Definitions;

variable staking

const staking: Definitions;

variable state

const state: Definitions;

variable statement

const statement: Definitions;

variable support

const support: Definitions;

variable syncstate

const syncstate: Definitions;

variable system

const system: Definitions;

variable treasury

const treasury: Definitions;

variable txpayment

const txpayment: Definitions;

variable txqueue

const txqueue: Definitions;

variable uniques

const uniques: Definitions;

variable utility

const utility: Definitions;

variable vesting

const vesting: Definitions;

variable xcm

const xcm: Definitions;

variable xcmPaymentApi

const xcmPaymentApi: Definitions;

variable xcmRuntimeApi

const xcmRuntimeApi: Definitions;

Package Files (116)

Dependencies (8)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto 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>

Updated 13 days ago.
Package analyzed in 11438 ms.
Missing or incorrect documentation? Open an issue for this package.

@polkadot/types

Install

Overview

Index

Variables

Functions

Classes

Namespaces

Variables

variable packageInfo

variable rpcDefinitions

Functions

function convertSiV0toV1

function createClass

function createType

Parameter type

Parameter params

function expandMetadata

function lazyVariants

Classes

class Data

property asBlakeTwo256

property asKeccak256

property asRaw

property asSha256

property asShaThree256

property encodedLength

property isBlakeTwo256

property isKeccak256

property isNone

property isRaw

property isSha256

property isShaThree256

method toU8a

class GeneralExtrinsic

property assetId

property encodedLength

property era

property metadataHash

property method

property mode

property nonce

property preamble

property tip

property transactionExtensionVersion

property version

method addSignature

method decodeExtrinsic

method encode

method sign

method signature

method signFake

method toHex

method toRawType

method toU8a

class GenericAccountId

class GenericAccountId32

class GenericAccountId33

class GenericAccountIndex

method calcLength

method eq

method readLength

method toHuman

method toJSON

method toPrimitive

method toRawType

method toString

method writeLength

class GenericAddress

method inspect

method toString

class GenericBlock

property contentHash

property extrinsics

property hash

property header

class GenericCall

property args

property argsDef

property argsEntries