@pezkuwi/types 16.5.5

package/README.md

@@ -0,0 +1,3 @@
+# @pezkuwi/types
+
+Implementation of the types and their (de-)serialisation via SCALE codec. On the Rust side, the codec types and primitive types are implemented via the [parity-codec](https://github.com/paritytech/parity-codec).

package/build/bundle.d.ts

@@ -0,0 +1,11 @@
+import * as typeDefinitions from './interfaces/definitions.js';
+import rpcDefinitions from './interfaces/jsonrpc.js';
+export { TypeDefInfo } from '@pezkuwi/types-create';
+export { convertSiV0toV1 } from './metadata/PortableRegistry/index.js';
+export { packageInfo } from './packageInfo.js';
+export { unwrapStorageType } from './util/index.js';
+export * from './codec/index.js';
+export * from './create/index.js';
+export * from './index.types.js';
+export * from './metadata/index.js';
+export { rpcDefinitions, typeDefinitions };

package/build/codec/index.d.ts

@@ -0,0 +1 @@
+export { BTreeMap, BTreeSet, CodecMap, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Json, Linkage, Map, Option, Range, RangeInclusive, Raw, Result, Set, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from '@pezkuwi/types-codec';

package/build/codec/types.d.ts

@@ -0,0 +1 @@
+export type { U8aBitLength, UIntBitLength } from '@pezkuwi/types-codec/types';

package/build/create/createClass.d.ts

@@ -0,0 +1,3 @@
+import type { Codec, CodecClass, Registry } from '@pezkuwi/types-codec/types';
+import type { DetectCodec } from '../types/index.js';
+export declare function createClass<T extends Codec = Codec, K extends string = string>(registry: Registry, type: K): CodecClass<DetectCodec<T, K>>;

package/build/create/createType.d.ts

@@ -0,0 +1,9 @@
+import type { Codec, Registry } from '@pezkuwi/types-codec/types';
+import type { DetectCodec } from '../types/index.js';
+/**
+ * Create an instance of a `type` with a given `params`.
+ * @param type - A recognizable string representing the type to create an
+ * instance from
+ * @param params - The value to instantiate the type with
+ */
+export declare function createType<T extends Codec = Codec, K extends string = string>(registry: Registry, type: K, ...params: unknown[]): DetectCodec<T, K>;

package/build/create/index.d.ts

@@ -0,0 +1,5 @@
+export * from '@pezkuwi/types-create/exports';
+export * from './createClass.js';
+export * from './createType.js';
+export * from './lazy.js';
+export * from './registry.js';

package/build/create/lazy.d.ts

@@ -0,0 +1,7 @@
+import type { SiLookupTypeId, SiVariant } from '../interfaces/index.js';
+import type { PortableRegistry } from '../metadata/index.js';
+interface TypeHolder {
+    type: SiLookupTypeId;
+}
+export declare function lazyVariants<T>(lookup: PortableRegistry, { type }: TypeHolder, getName: (v: SiVariant) => string, creator: (v: SiVariant) => T): Record<string, T>;
+export {};

package/build/create/registry.d.ts

@@ -0,0 +1,74 @@
+import type { AnyString, Codec, CodecClass, IU8a, LookupString } from '@pezkuwi/types-codec/types';
+import type { CreateOptions, TypeDef } from '@pezkuwi/types-create/types';
+import type { ExtDef } from '../extrinsic/signedExtensions/types.js';
+import type { ChainProperties, DispatchErrorModule, DispatchErrorModuleU8, DispatchErrorModuleU8a, Hash, MetadataLatest, SiLookupTypeId } from '../interfaces/types.js';
+import type { CallFunction, CodecHasher, DetectCodec, RegisteredTypes, Registry, RegistryError, RegistryTypes } from '../types/index.js';
+import { GenericEventData } from '../generic/Event.js';
+import { Metadata } from '../metadata/Metadata.js';
+import { PortableRegistry } from '../metadata/PortableRegistry/index.js';
+export declare class TypeRegistry implements Registry {
+    #private;
+    createdAtHash?: Hash;
+    constructor(createdAtHash?: Hash | Uint8Array | string);
+    get chainDecimals(): number[];
+    get chainIsEthereum(): boolean;
+    get chainSS58(): number | undefined;
+    get chainTokens(): string[];
+    get firstCallIndex(): Uint8Array;
+    /**
+     * @description Returns true if the type is in a Compat format
+     */
+    isLookupType(value: string): value is LookupString;
+    /**
+     * @description Creates a lookup string from the supplied id
+     */
+    createLookupType(lookupId: SiLookupTypeId | number): LookupString;
+    get knownTypes(): RegisteredTypes;
+    get lookup(): PortableRegistry;
+    get metadata(): MetadataLatest;
+    get unknownTypes(): string[];
+    get signedExtensions(): string[];
+    clearCache(): void;
+    /**
+     * @describe Creates an instance of the class
+     */
+    createClass<T extends Codec = Codec, K extends string = string>(type: K): CodecClass<DetectCodec<T, K>>;
+    /**
+     * @describe Creates an instance of the class
+     */
+    createClassUnsafe<T extends Codec = Codec, K extends string = string>(type: K): CodecClass<T>;
+    /**
+     * @description Creates an instance of a type as registered
+     */
+    createType<T extends Codec = Codec, K extends string = string>(type: K, ...params: unknown[]): DetectCodec<T, K>;
+    /**
+     * @description Creates an instance of a type as registered
+     */
+    createTypeUnsafe<T extends Codec = Codec, K extends string = string>(type: K, params: unknown[], options?: CreateOptions): T;
+    findMetaCall(callIndex: Uint8Array): CallFunction;
+    findMetaError(errorIndex: Uint8Array | DispatchErrorModule | DispatchErrorModuleU8 | DispatchErrorModuleU8a): RegistryError;
+    findMetaEvent(eventIndex: Uint8Array): CodecClass<GenericEventData>;
+    get<T extends Codec = Codec, K extends string = string>(name: K, withUnknown?: boolean, knownTypeDef?: TypeDef): CodecClass<T> | undefined;
+    getUnsafe<T extends Codec = Codec, K extends string = string>(name: K, withUnknown?: boolean, knownTypeDef?: TypeDef): CodecClass<T> | undefined;
+    getChainProperties(): ChainProperties | undefined;
+    getClassName(Type: CodecClass): string | undefined;
+    getDefinition(typeName: string): string | undefined;
+    getModuleInstances(specName: AnyString, moduleName: string): string[] | undefined;
+    getOrThrow<T extends Codec = Codec, K extends string = string, R = DetectCodec<T, K>>(name: K): CodecClass<R>;
+    getOrUnknown<T extends Codec = Codec, K extends string = string, R = DetectCodec<T, K>>(name: K): CodecClass<R>;
+    getTransactionExtensionVersion(): number;
+    getSignedExtensionExtra(): Record<string, string>;
+    getSignedExtensionTypes(): Record<string, string>;
+    hasClass(name: string): boolean;
+    hasDef(name: string): boolean;
+    hasType(name: string): boolean;
+    hash(data: Uint8Array): IU8a;
+    register(type: CodecClass | RegistryTypes): void;
+    register(name: string, type: CodecClass): void;
+    setChainProperties(properties?: ChainProperties): void;
+    setHasher(hasher?: CodecHasher | null): void;
+    setKnownTypes(knownTypes: RegisteredTypes): void;
+    setLookup(lookup: PortableRegistry): void;
+    setMetadata(metadata: Metadata, signedExtensions?: string[], userExtensions?: ExtDef, noInitWarn?: boolean): void;
+    setSignedExtensions(signedExtensions?: string[], userExtensions?: ExtDef, noInitWarn?: boolean): void;
+}

package/build/create/types.d.ts

@@ -0,0 +1,3 @@
+export type { CodecCreateOptions as CreateOptions } from '@pezkuwi/types-codec/types';
+export type { TypeDef } from '@pezkuwi/types-create/types';
+export { TypeDefInfo } from '@pezkuwi/types-create';

package/build/ethereum/AccountId.d.ts

@@ -0,0 +1,36 @@
+import type { AnyU8a, Registry } from '@pezkuwi/types-codec/types';
+import { U8aFixed } from '@pezkuwi/types-codec';
+/**
+ * @name GenericEthereumAccountId
+ * @description
+ * 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.
+ */
+export declare class GenericEthereumAccountId extends U8aFixed {
+    constructor(registry: Registry, value?: AnyU8a);
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(): string;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): string;
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive(): string;
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString(): string;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/build/ethereum/LookupSource.d.ts

@@ -0,0 +1,41 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+import { AbstractBase } from '@pezkuwi/types-codec';
+import { GenericAccountIndex } from '../generic/AccountIndex.js';
+import { GenericEthereumAccountId } from './AccountId.js';
+type AnyAddress = bigint | BN | GenericEthereumLookupSource | GenericEthereumAccountId | GenericAccountIndex | number[] | Uint8Array | number | string;
+export declare const ACCOUNT_ID_PREFIX: Uint8Array<ArrayBuffer>;
+/**
+ * @name GenericEthereumLookupSource
+ * @description
+ * 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
+ */
+export declare class GenericEthereumLookupSource extends AbstractBase<GenericEthereumAccountId | GenericAccountIndex> {
+    constructor(registry: Registry, value?: AnyAddress);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description The length of the raw value, either AccountIndex or AccountId
+     */
+    protected get _rawLength(): number;
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex(): HexString;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}
+export {};

package/build/ethereum/index.d.ts

@@ -0,0 +1,2 @@
+export { GenericEthereumAccountId } from './AccountId.js';
+export { GenericEthereumLookupSource } from './LookupSource.js';

package/build/extrinsic/Extrinsic.d.ts

@@ -0,0 +1,166 @@
+import type { AnyJson, AnyTuple, AnyU8a, ArgsDef, IMethod, Inspect, IOption } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { GeneralExtrinsic } from '../index.types.js';
+import type { EcdsaSignature, Ed25519Signature, ExtrinsicUnknown, ExtrinsicV5, Sr25519Signature } from '../interfaces/extrinsics/index.js';
+import type { FunctionMetadataLatest } from '../interfaces/metadata/index.js';
+import type { Address, Call, CodecHash, Hash } from '../interfaces/runtime/index.js';
+import type { MultiLocation } from '../interfaces/types.js';
+import type { CallBase, ExtrinsicPayloadValue, ICompact, IExtrinsic, IKeyringPair, INumber, Registry, SignatureOptions } from '../types/index.js';
+import type { GenericExtrinsicEra } from './ExtrinsicEra.js';
+import type { Preamble } from './types.js';
+import type { ExtrinsicValueV5 } from './v5/Extrinsic.js';
+import { AbstractBase } from '@pezkuwi/types-codec';
+import { LATEST_EXTRINSIC_VERSION } from './constants.js';
+interface CreateOptions {
+    version?: number;
+    preamble?: Preamble;
+}
+type ExtrinsicVx = ExtrinsicV5 | GeneralExtrinsic;
+type ExtrinsicValue = ExtrinsicValueV5;
+export { LATEST_EXTRINSIC_VERSION };
+declare abstract class ExtrinsicBase<A extends AnyTuple> extends AbstractBase<ExtrinsicVx | ExtrinsicUnknown> {
+    #private;
+    constructor(registry: Registry, value: ExtrinsicVx | ExtrinsicUnknown, initialU8aLength?: number, preamble?: Preamble);
+    isGeneral(): boolean;
+    /**
+     * @description The arguments passed to for the call, exposes args so it is compatible with [[Call]]
+     */
+    get args(): A;
+    /**
+     * @description The argument definitions, compatible with [[Call]]
+     */
+    get argsDef(): ArgsDef;
+    /**
+     * @description The actual `[sectionIndex, methodIndex]` as used in the Call
+     */
+    get callIndex(): Uint8Array;
+    /**
+     * @description The actual data for the Call
+     */
+    get data(): Uint8Array;
+    /**
+     * @description The era for this extrinsic
+     */
+    get era(): GenericExtrinsicEra;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description `true` id the extrinsic is signed
+     */
+    get isSigned(): boolean;
+    /**
+     * @description The length of the actual data, excluding prefix
+     */
+    get length(): number;
+    /**
+     * @description The [[FunctionMetadataLatest]] that describes the extrinsic
+     */
+    get meta(): FunctionMetadataLatest;
+    /**
+     * @description The [[Call]] this extrinsic wraps
+     */
+    get method(): CallBase<A>;
+    /**
+     * @description The nonce for this extrinsic
+     */
+    get nonce(): ICompact<INumber>;
+    /**
+     * @description The actual [[EcdsaSignature]], [[Ed25519Signature]] or [[Sr25519Signature]]
+     */
+    get signature(): EcdsaSignature | Ed25519Signature | Sr25519Signature;
+    /**
+     * @description The [[Address]] that signed
+     */
+    get signer(): Address;
+    /**
+     * @description Forwards compat
+     */
+    get tip(): ICompact<INumber>;
+    /**
+     * @description Forward compat
+     */
+    get assetId(): IOption<INumber | MultiLocation>;
+    /**
+     * @description Forward compat
+     */
+    get metadataHash(): IOption<Hash>;
+    /**
+     * @description Forward compat
+     */
+    get mode(): INumber;
+    /**
+     * @description Returns the raw transaction version (not flagged with signing information)
+    */
+    get type(): number;
+    get inner(): ExtrinsicVx;
+    /**
+     * @description Returns the encoded version flag
+    */
+    get version(): number;
+    /**
+     * @description Checks if the source matches this in type
+     */
+    is(other: IMethod<AnyTuple>): other is IMethod<A>;
+    unwrap(): ExtrinsicVx;
+}
+/**
+ * @name GenericExtrinsic
+ * @description
+ * Representation of an Extrinsic in the system. It contains the actual call,
+ * (optional) signature and encodes with an actual length prefix
+ *
+ * {@link 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
+ */
+export declare class GenericExtrinsic<A extends AnyTuple = AnyTuple> extends ExtrinsicBase<A> implements IExtrinsic<A> {
+    #private;
+    static LATEST_EXTRINSIC_VERSION: number;
+    constructor(registry: Registry, value?: GenericExtrinsic | ExtrinsicValue | AnyU8a | Call, { preamble, version }?: CreateOptions);
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash(): CodecHash;
+    /**
+     * @description Injects an already-generated signature into the extrinsic
+     */
+    addSignature(signer: Address | Uint8Array | string, signature: Uint8Array | HexString, payload: ExtrinsicPayloadValue | Uint8Array | HexString): GenericExtrinsic<A>;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @description Sign the extrinsic with a specific keypair
+     */
+    sign(account: IKeyringPair, options: SignatureOptions): GenericExtrinsic<A>;
+    /**
+     * @describe Adds a fake signature to the extrinsic
+     */
+    signFake(signer: Address | Uint8Array | string, options: SignatureOptions): GenericExtrinsic<A>;
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex(isBare?: boolean): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExpanded?: boolean, disableAscii?: boolean): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): string;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value is not length-prefixed
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+    toU8aInner(): Uint8Array[];
+}

package/build/extrinsic/ExtrinsicEra.d.ts

@@ -0,0 +1,97 @@
+import type { AnyU8a, Registry } from '@pezkuwi/types-codec/types';
+import type { BN } from '@pezkuwi/util';
+import type { IExtrinsicEra, INumber } from '../types/index.js';
+import { Enum, Raw, Tuple } from '@pezkuwi/types-codec';
+interface MortalMethod {
+    current: number;
+    period: number;
+}
+/**
+ * @name ImmortalEra
+ * @description
+ * The ImmortalEra for an extrinsic
+ */
+export declare class ImmortalEra extends Raw {
+    constructor(registry: Registry, _value?: AnyU8a);
+}
+/**
+ * @name MortalEra
+ * @description
+ * The MortalEra for an extrinsic, indicating period and phase
+ */
+export declare class MortalEra extends Tuple {
+    constructor(registry: Registry, value?: MortalMethod | Uint8Array | number[] | string);
+    /**
+     * @description Encoded length for mortals occupy 2 bytes, different from the actual Tuple since it is encoded. This is a shortcut fro `toU8a().length`
+     */
+    get encodedLength(): number;
+    /**
+     * @description The period of this Mortal wraps as a [[U64]]
+     */
+    get period(): INumber;
+    /**
+     * @description The phase of this Mortal wraps as a [[U64]]
+     */
+    get phase(): INumber;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(): any;
+    /**
+     * @description Returns a JSON representation of the actual value
+     */
+    toJSON(): any;
+    /**
+     * @description Encodes the value as a Uint8Array as per the parity-codec specifications
+     * @param 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.
+     */
+    toU8a(_isBare?: boolean): Uint8Array;
+    /**
+     * @description Get the block number of the start of the era whose properties this object describes that `current` belongs to.
+     */
+    birth(current: BN | bigint | number | string): number;
+    /**
+     * @description Get the block number of the first block at which the era has ended.
+     */
+    death(current: BN | bigint | number | string): number;
+}
+/**
+ * @name GenericExtrinsicEra
+ * @description
+ * The era for an extrinsic, indicating either a mortal or immortal extrinsic
+ */
+export declare class GenericExtrinsicEra extends Enum implements IExtrinsicEra {
+    constructor(registry: Registry, value?: unknown);
+    /**
+     * @description Override the encoded length method
+     */
+    get encodedLength(): number;
+    /**
+     * @description Returns the item as a [[ImmortalEra]]
+     */
+    get asImmortalEra(): ImmortalEra;
+    /**
+     * @description Returns the item as a [[MortalEra]]
+     */
+    get asMortalEra(): MortalEra;
+    /**
+     * @description `true` if Immortal
+     */
+    get isImmortalEra(): boolean;
+    /**
+     * @description `true` if Mortal
+     */
+    get isMortalEra(): boolean;
+    /**
+     * @description Encodes the value as a Uint8Array as per the parity-codec specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}
+export {};

package/build/extrinsic/ExtrinsicPayload.d.ts

@@ -0,0 +1,117 @@
+import type { Bytes } from '@pezkuwi/types-codec';
+import type { AnyJson, BareOpts, Registry } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { BlockHash } from '../interfaces/chain/index.js';
+import type { ExtrinsicPayloadV5 } from '../interfaces/extrinsics/index.js';
+import type { Hash, MultiLocation } from '../interfaces/types.js';
+import type { ExtrinsicPayloadValue, ICompact, IKeyringPair, INumber, IOption } from '../types/index.js';
+import type { GenericExtrinsicEra } from './ExtrinsicEra.js';
+import type { Preamble } from './types.js';
+import { AbstractBase } from '@pezkuwi/types-codec';
+interface ExtrinsicPayloadOptions {
+    version?: number;
+    preamble?: Preamble;
+}
+type ExtrinsicPayloadVx = ExtrinsicPayloadV5;
+/**
+ * HACK: In order to change the assetId from `number | object` to HexString (While maintaining the true type ie Option<TAssetConversion>),
+ * to allow for easier generalization of the SignerPayloadJSON interface the below check is necessary. The ExtrinsicPayloadV4 class does not like
+ * a value passed in as an Option, and can't decode it properly. Therefore, we ensure to convert the following below, and then pass the option as a unwrapped
+ * JSON value.
+ *
+ * ref: https://github.com/polkadot-js/api/pull/5968
+ * ref: https://github.com/polkadot-js/api/pull/5967
+ */
+export declare function decodeAssetId(registry: Registry, payload?: ExtrinsicPayloadValue | Uint8Array | HexString): `0x${string}` | Uint8Array<ArrayBufferLike> | ExtrinsicPayloadValue | {
+    assetId: AnyJson;
+    blockHash: import("@pezkuwi/types-codec/types").AnyU8a;
+    era: import("@pezkuwi/types-codec/types").AnyU8a | import("../types/extrinsic.js").IExtrinsicEra;
+    genesisHash: import("@pezkuwi/types-codec/types").AnyU8a;
+    method: import("@pezkuwi/types-codec/types").AnyU8a | import("../types/interfaces.js").IMethod<import("@pezkuwi/types-codec/types").AnyTuple>;
+    nonce: import("@pezkuwi/types-codec/types").AnyNumber;
+    specVersion: import("@pezkuwi/types-codec/types").AnyNumber;
+    tip: import("@pezkuwi/types-codec/types").AnyNumber;
+    transactionVersion: import("@pezkuwi/types-codec/types").AnyNumber;
+    mode?: import("@pezkuwi/types-codec/types").AnyNumber;
+    metadataHash?: import("@pezkuwi/types-codec/types").AnyU8a;
+};
+/**
+ * @name GenericExtrinsicPayload
+ * @description
+ * A signing payload for an [[Extrinsic]]. For the final encoding, it is variable length based
+ * on the contents included
+ */
+export declare class GenericExtrinsicPayload extends AbstractBase<ExtrinsicPayloadVx> {
+    constructor(registry: Registry, value?: Partial<ExtrinsicPayloadValue> | Uint8Array | string, { preamble, version }?: ExtrinsicPayloadOptions);
+    /**
+     * @description The block [[BlockHash]] the signature applies to (mortal/immortal)
+     */
+    get blockHash(): BlockHash;
+    /**
+     * @description The [[ExtrinsicEra]]
+     */
+    get era(): GenericExtrinsicEra;
+    /**
+     * @description The genesis block [[BlockHash]] the signature applies to
+     */
+    get genesisHash(): BlockHash;
+    /**
+     * @description The [[Bytes]] contained in the payload
+     */
+    get method(): Bytes;
+    /**
+     * @description The [[Index]]
+     */
+    get nonce(): ICompact<INumber>;
+    /**
+     * @description The specVersion as a [[u32]] for this payload
+     */
+    get specVersion(): INumber;
+    /**
+     * @description The [[Balance]]
+     */
+    get tip(): ICompact<INumber>;
+    /**
+     * @description The transaction version as a [[u32]] for this payload
+     */
+    get transactionVersion(): INumber;
+    /**
+     * @description The (optional) asset id as a [[u32]] or [[MultiLocation]] for this payload
+     */
+    get assetId(): IOption<INumber | MultiLocation>;
+    /**
+     * @description The (optional) [[Hash]] of the genesis metadata for this payload
+     */
+    get metadataHash(): IOption<Hash>;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Sign the payload with the keypair
+     */
+    sign(signerPair: IKeyringPair): {
+        signature: HexString;
+    };
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended?: boolean, disableAscii?: boolean): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): any;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString(): string;
+    /**
+     * @description Returns a serialized u8a form
+     */
+    toU8a(isBare?: BareOpts): Uint8Array;
+}
+export {};

package/build/extrinsic/ExtrinsicPayloadUnknown.d.ts

@@ -0,0 +1,11 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { ExtrinsicPayloadOptions } from './types.js';
+import { Struct } from '@pezkuwi/types-codec';
+/**
+ * @name GenericExtrinsicPayloadUnknown
+ * @description
+ * A default handler for payloads where the version is not known (default throw)
+ */
+export declare class GenericExtrinsicPayloadUnknown extends Struct {
+    constructor(registry: Registry, _value?: unknown, { version }?: Partial<ExtrinsicPayloadOptions>);
+}

package/build/extrinsic/ExtrinsicUnknown.d.ts

@@ -0,0 +1,11 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { ExtrinsicOptions } from './types.js';
+import { Struct } from '@pezkuwi/types-codec';
+/**
+ * @name GenericExtrinsicUnknown
+ * @description
+ * A default handler for extrinsics where the version is not known (default throw)
+ */
+export declare class GenericExtrinsicUnknown extends Struct {
+    constructor(registry: Registry, _value?: unknown, { isSigned, version }?: Partial<ExtrinsicOptions>);
+}