@pezkuwi/types 16.5.5

package/build/extrinsic/SignerPayload.d.ts

@@ -0,0 +1,54 @@
+import type { Text, Vec } from '@pezkuwi/types-codec';
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { Address, BlockHash, Call, ExtrinsicEra, Hash, MultiLocation } from '../interfaces/index.js';
+import type { Codec, ICompact, INumber, IOption, IRuntimeVersion, ISignerPayload, SignerPayloadJSON, SignerPayloadRaw } from '../types/index.js';
+import { Struct } from '@pezkuwi/types-codec';
+export interface SignerPayloadType extends Codec {
+    address: Address;
+    assetId: IOption<INumber | MultiLocation>;
+    blockHash: Hash;
+    blockNumber: INumber;
+    era: ExtrinsicEra;
+    genesisHash: Hash;
+    metadataHash: IOption<Hash>;
+    method: Call;
+    mode: INumber;
+    nonce: ICompact<INumber>;
+    runtimeVersion: IRuntimeVersion;
+    signedExtensions: Vec<Text>;
+    tip: ICompact<INumber>;
+    version: INumber;
+}
+/**
+ * @name GenericSignerPayload
+ * @description
+ * A generic signer payload that can be used for serialization between API and signer
+ */
+export declare class GenericSignerPayload extends Struct implements ISignerPayload, SignerPayloadType {
+    #private;
+    constructor(registry: Registry, value?: HexString | Record<string, unknown> | Map<unknown, unknown> | unknown[]);
+    get address(): Address;
+    get blockHash(): BlockHash;
+    get blockNumber(): INumber;
+    get era(): ExtrinsicEra;
+    get genesisHash(): BlockHash;
+    get method(): Call;
+    get nonce(): ICompact<INumber>;
+    get runtimeVersion(): IRuntimeVersion;
+    get signedExtensions(): Vec<Text>;
+    get tip(): ICompact<INumber>;
+    get assetId(): IOption<INumber | MultiLocation>;
+    get version(): INumber;
+    get mode(): INumber;
+    get metadataHash(): IOption<Hash>;
+    get withSignedTransaction(): boolean;
+    /**
+     * @description Creates an representation of the structure as an ISignerPayload JSON
+     */
+    toPayload(): SignerPayloadJSON;
+    /**
+     * @description Creates a representation of the payload in raw Exrinsic form
+     */
+    toRaw(): SignerPayloadRaw;
+}

package/build/extrinsic/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const BIT_SIGNED = 128;
+export declare const BIT_UNSIGNED = 0;
+export declare const EMPTY_U8A: Uint8Array<ArrayBuffer>;
+export declare const IMMORTAL_ERA: Uint8Array<ArrayBuffer>;
+export declare const UNMASK_VERSION = 127;
+export declare const DEFAULT_PREAMBLE = "bare";
+export declare const LATEST_EXTRINSIC_VERSION = 4;
+export declare const VERSION_MASK = 63;
+export declare const TYPE_MASK = 192;
+export declare const BARE_EXTRINSIC = 0;
+export declare const GENERAL_EXTRINSIC = 64;
+export declare const LOWEST_SUPPORTED_EXTRINSIC_FORMAT_VERSION = 4;

package/build/extrinsic/index.d.ts

@@ -0,0 +1,8 @@
+export { GenericExtrinsic } from './Extrinsic.js';
+export { GenericExtrinsicEra, ImmortalEra as GenericImmortalEra, MortalEra as GenericMortalEra } from './ExtrinsicEra.js';
+export { GenericExtrinsicPayload } from './ExtrinsicPayload.js';
+export { GenericExtrinsicPayloadUnknown } from './ExtrinsicPayloadUnknown.js';
+export { GenericExtrinsicUnknown } from './ExtrinsicUnknown.js';
+export { GenericSignerPayload } from './SignerPayload.js';
+export * from './v4/index.js';
+export * from './v5/index.js';

package/build/extrinsic/signedExtensions/emptyCheck.d.ts

@@ -0,0 +1,2 @@
+import type { ExtInfo } from './types.js';
+export declare const emptyCheck: ExtInfo;

package/build/extrinsic/signedExtensions/index.d.ts

@@ -0,0 +1,5 @@
+import type { ExtDef, ExtInfo, ExtTypes } from './types.js';
+export declare const allExtensions: ExtDef;
+export declare const fallbackExtensions: string[];
+export declare function findUnknownExtensions(extensions: string[], userExtensions?: ExtDef): string[];
+export declare function expandExtensionTypes(extensions: string[], type: keyof ExtInfo, userExtensions?: ExtDef): ExtTypes;

package/build/extrinsic/signedExtensions/polkadot.d.ts

@@ -0,0 +1,2 @@
+import type { ExtDef } from './types.js';
+export declare const polkadot: ExtDef;

package/build/extrinsic/signedExtensions/shell.d.ts

@@ -0,0 +1,2 @@
+import type { ExtDef } from './types.js';
+export declare const shell: ExtDef;

package/build/extrinsic/signedExtensions/statemint.d.ts

@@ -0,0 +1,2 @@
+import type { ExtDef } from './types.js';
+export declare const statemint: ExtDef;

package/build/extrinsic/signedExtensions/substrate.d.ts

@@ -0,0 +1,2 @@
+import type { ExtDef } from './types.js';
+export declare const substrate: ExtDef;

package/build/extrinsic/signedExtensions/types.d.ts

@@ -0,0 +1,6 @@
+export type ExtTypes = Record<string, string>;
+export interface ExtInfo {
+    extrinsic: ExtTypes;
+    payload: ExtTypes;
+}
+export type ExtDef = Record<string, ExtInfo>;

package/build/extrinsic/types.d.ts

@@ -0,0 +1,17 @@
+import type { AnyNumber } from '@pezkuwi/types-codec/types';
+export interface ExtrinsicOptions {
+    isSigned: boolean;
+    version: number;
+}
+export interface ExtrinsicPayloadOptions {
+    version: number;
+}
+export interface ExtrinsicSignatureOptions {
+    isSigned?: boolean;
+}
+export interface ExtrinsicExtraValue {
+    era?: Uint8Array;
+    nonce?: AnyNumber;
+    tip?: AnyNumber;
+}
+export type Preamble = 'bare' | 'general';

package/build/extrinsic/util.d.ts

@@ -0,0 +1,5 @@
+import type { SignOptions } from '@pezkuwi/keyring/types';
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { IKeyringPair } from '../types/index.js';
+export declare function sign(_registry: Registry, signerPair: IKeyringPair, u8a: Uint8Array, options?: SignOptions): Uint8Array;
+export declare function signGeneral(registry: Registry, u8a: Uint8Array): Uint8Array;

package/build/extrinsic/v4/Extrinsic.d.ts

@@ -0,0 +1,49 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { ExtrinsicSignatureV4 } from '../../interfaces/extrinsics/index.js';
+import type { Address, Call } from '../../interfaces/runtime/index.js';
+import type { ExtrinsicPayloadValue, IExtrinsicImpl, IKeyringPair, Registry, SignatureOptions } from '../../types/index.js';
+import type { ExtrinsicOptions } from '../types.js';
+import { Struct } from '@pezkuwi/types-codec';
+export declare const EXTRINSIC_VERSION = 4;
+export interface ExtrinsicValueV4 {
+    method?: Call;
+    signature?: ExtrinsicSignatureV4;
+}
+/**
+ * @name GenericExtrinsicV4
+ * @description
+ * The third generation of compact extrinsics
+ */
+export declare class GenericExtrinsicV4 extends Struct implements IExtrinsicImpl {
+    constructor(registry: Registry, value?: Uint8Array | ExtrinsicValueV4 | Call, { isSigned }?: Partial<ExtrinsicOptions>);
+    /** @internal */
+    static decodeExtrinsic(registry: Registry, value?: Call | Uint8Array | ExtrinsicValueV4, isSigned?: boolean): ExtrinsicValueV4;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description The [[Call]] this extrinsic wraps
+     */
+    get method(): Call;
+    /**
+     * @description The [[ExtrinsicSignatureV4]]
+     */
+    get signature(): ExtrinsicSignatureV4;
+    /**
+     * @description The version for the signature
+     */
+    get version(): number;
+    /**
+     * @description Add an [[ExtrinsicSignatureV4]] to the extrinsic (already generated)
+     */
+    addSignature(signer: Address | Uint8Array | string, signature: Uint8Array | HexString, payload: ExtrinsicPayloadValue | Uint8Array | HexString): GenericExtrinsicV4;
+    /**
+     * @description Sign the extrinsic with a specific keypair
+     */
+    sign(account: IKeyringPair, options: SignatureOptions): GenericExtrinsicV4;
+    /**
+     * @describe Adds a fake signature to the extrinsic
+     */
+    signFake(signer: Address | Uint8Array | string, options: SignatureOptions): GenericExtrinsicV4;
+}

package/build/extrinsic/v4/ExtrinsicPayload.d.ts

@@ -0,0 +1,66 @@
+import type { Hash, MultiLocation } from '@pezkuwi/types/interfaces';
+import type { Bytes } from '@pezkuwi/types-codec';
+import type { Inspect, Registry } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { BlockHash } from '../../interfaces/chain/index.js';
+import type { ExtrinsicEra } from '../../interfaces/extrinsics/index.js';
+import type { ExtrinsicPayloadValue, ICompact, IKeyringPair, INumber, IOption } from '../../types/index.js';
+import { Struct } from '@pezkuwi/types-codec';
+/**
+ * @name GenericExtrinsicPayloadV4
+ * @description
+ * A signing payload for an [[Extrinsic]]. For the final encoding, it is
+ * variable length based on the contents included
+ */
+export declare class GenericExtrinsicPayloadV4 extends Struct {
+    #private;
+    constructor(registry: Registry, value?: ExtrinsicPayloadValue | Uint8Array | HexString);
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @description The block [[BlockHash]] the signature applies to (mortal/immortal)
+     */
+    get blockHash(): BlockHash;
+    /**
+     * @description The [[ExtrinsicEra]]
+     */
+    get era(): ExtrinsicEra;
+    /**
+     * @description The genesis [[BlockHash]] the signature applies to (mortal/immortal)
+     */
+    get genesisHash(): BlockHash;
+    /**
+     * @description The [[Bytes]] contained in the payload
+     */
+    get method(): Bytes;
+    /**
+     * @description The [[Index]]
+     */
+    get nonce(): ICompact<INumber>;
+    /**
+     * @description The specVersion for this signature
+     */
+    get specVersion(): INumber;
+    /**
+     * @description The tip [[Balance]]
+     */
+    get tip(): ICompact<INumber>;
+    /**
+     * @description The transactionVersion for this signature
+     */
+    get transactionVersion(): INumber;
+    /**
+     * @description The (optional) asset id for this signature for chains that support transaction fees in assets
+     */
+    get assetId(): IOption<INumber | MultiLocation>;
+    /**
+     * @description The (optional) asset id for this signature for chains that support transaction fees in assets
+     */
+    get metadataHash(): IOption<Hash>;
+    /**
+     * @description Sign the payload with the keypair
+     */
+    sign(signerPair: IKeyringPair): Uint8Array;
+}

package/build/extrinsic/v4/ExtrinsicSignature.d.ts

@@ -0,0 +1,85 @@
+import type { MultiLocation } from '@pezkuwi/types/interfaces';
+import type { HexString } from '@pezkuwi/util/types';
+import type { EcdsaSignature, Ed25519Signature, ExtrinsicEra, ExtrinsicSignature, Sr25519Signature } from '../../interfaces/extrinsics/index.js';
+import type { Address, Call, Hash } from '../../interfaces/runtime/index.js';
+import type { ExtrinsicPayloadValue, ICompact, IExtrinsicSignature, IKeyringPair, INumber, IOption, Registry, SignatureOptions } from '../../types/index.js';
+import type { ExtrinsicSignatureOptions } from '../types.js';
+import { Struct } from '@pezkuwi/types-codec';
+import { GenericExtrinsicPayloadV4 } from './ExtrinsicPayload.js';
+/**
+ * @name GenericExtrinsicSignatureV4
+ * @description
+ * A container for the [[Signature]] associated with a specific [[Extrinsic]]
+ */
+export declare class GenericExtrinsicSignatureV4 extends Struct implements IExtrinsicSignature {
+    #private;
+    constructor(registry: Registry, value?: GenericExtrinsicSignatureV4 | Uint8Array, { isSigned }?: ExtrinsicSignatureOptions);
+    /** @internal */
+    static decodeExtrinsicSignature(value?: GenericExtrinsicSignatureV4 | Uint8Array, isSigned?: boolean): GenericExtrinsicSignatureV4 | Uint8Array;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description `true` if the signature is valid
+     */
+    get isSigned(): boolean;
+    /**
+     * @description The [[ExtrinsicEra]] (mortal or immortal) this signature applies to
+     */
+    get era(): ExtrinsicEra;
+    /**
+     * @description The [[Index]] for the signature
+     */
+    get nonce(): ICompact<INumber>;
+    /**
+     * @description The actual [[EcdsaSignature]], [[Ed25519Signature]] or [[Sr25519Signature]]
+     */
+    get signature(): EcdsaSignature | Ed25519Signature | Sr25519Signature;
+    /**
+     * @description The raw [[ExtrinsicSignature]]
+     */
+    get multiSignature(): ExtrinsicSignature;
+    /**
+     * @description The [[Address]] that signed
+     */
+    get signer(): Address;
+    /**
+     * @description The [[Balance]] tip
+     */
+    get tip(): ICompact<INumber>;
+    /**
+     * @description The [[u32]] or [[MultiLocation]] assetId
+     */
+    get assetId(): IOption<INumber | MultiLocation>;
+    /**
+     * @description the [[u32]] mode
+     */
+    get mode(): INumber;
+    /**
+     * @description The [[Hash]] for the metadata
+     */
+    get metadataHash(): IOption<Hash>;
+    protected _injectSignature(signer: Address, signature: ExtrinsicSignature, payload: GenericExtrinsicPayloadV4): IExtrinsicSignature;
+    /**
+     * @description Adds a raw signature
+     */
+    addSignature(signer: Address | Uint8Array | string, signature: Uint8Array | HexString, payload: ExtrinsicPayloadValue | Uint8Array | HexString): IExtrinsicSignature;
+    /**
+     * @description Creates a payload from the supplied options
+     */
+    createPayload(method: Call, options: SignatureOptions): GenericExtrinsicPayloadV4;
+    /**
+     * @description Generate a payload and applies the signature from a keypair
+     */
+    sign(method: Call, account: IKeyringPair, options: SignatureOptions): IExtrinsicSignature;
+    /**
+     * @description Generate a payload and applies a fake signature
+     */
+    signFake(method: Call, address: Address | Uint8Array | string, options: SignatureOptions): IExtrinsicSignature;
+    /**
+     * @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;
+}

package/build/extrinsic/v4/index.d.ts

@@ -0,0 +1,3 @@
+export { GenericExtrinsicV4 } from './Extrinsic.js';
+export { GenericExtrinsicPayloadV4 } from './ExtrinsicPayload.js';
+export { GenericExtrinsicSignatureV4 } from './ExtrinsicSignature.js';

package/build/extrinsic/v5/Extrinsic.d.ts

@@ -0,0 +1,59 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { ExtrinsicSignatureV5 } from '../../interfaces/extrinsics/index.js';
+import type { Address, Call } from '../../interfaces/runtime/index.js';
+import type { ExtrinsicPayloadValue, IExtrinsicV5Impl, IKeyringPair, Registry, SignatureOptions } from '../../types/index.js';
+import type { ExtrinsicOptions, Preamble } from '../types.js';
+import { Struct } from '@pezkuwi/types-codec';
+export declare const EXTRINSIC_VERSION = 5;
+export interface ExtrinsicValueV5 {
+    method?: Call;
+    signature?: ExtrinsicSignatureV5;
+}
+/**
+ * @name GenericExtrinsicV5
+ * @description
+ * The fourth generation of compact extrinsics
+ */
+export declare class GenericExtrinsicV5 extends Struct implements IExtrinsicV5Impl {
+    constructor(registry: Registry, value?: Uint8Array | ExtrinsicValueV5 | Call, { isSigned }?: Partial<ExtrinsicOptions>);
+    /** @internal */
+    static decodeExtrinsic(registry: Registry, value?: Call | Uint8Array | ExtrinsicValueV5, isSigned?: boolean): ExtrinsicValueV5;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description The [[Call]] this extrinsic wraps
+     */
+    get method(): Call;
+    /**
+     * @description The [[ExtrinsicSignatureV5]]
+     */
+    get signature(): ExtrinsicSignatureV5;
+    /**
+     * @description The version for the signature
+     */
+    get version(): number;
+    /**
+     * @description The [[Preamble]] for the extrinsic
+     */
+    get preamble(): Preamble;
+    /**
+     * @description Add an [[ExtrinsicSignatureV5]] to the extrinsic (already generated)
+     *
+     * [Disabled for ExtrinsicV5]
+     */
+    addSignature(_signer: Address | Uint8Array | string, _signature: Uint8Array | HexString, _payload: ExtrinsicPayloadValue | Uint8Array | HexString): GenericExtrinsicV5;
+    /**
+     * @description Sign the extrinsic with a specific keypair
+     *
+     * [Disabled for ExtrinsicV5]
+     */
+    sign(_account: IKeyringPair, _options: SignatureOptions): GenericExtrinsicV5;
+    /**
+     * @describe Adds a fake signature to the extrinsic
+     *
+     * [Disabled for ExtrinsicV5]
+     */
+    signFake(_signer: Address | Uint8Array | string, _options: SignatureOptions): GenericExtrinsicV5;
+}

package/build/extrinsic/v5/ExtrinsicPayload.d.ts

@@ -0,0 +1,67 @@
+import type { Hash, MultiLocation } from '@pezkuwi/types/interfaces';
+import type { Bytes } from '@pezkuwi/types-codec';
+import type { Inspect, Registry } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { BlockHash } from '../../interfaces/chain/index.js';
+import type { ExtrinsicEra } from '../../interfaces/extrinsics/index.js';
+import type { ExtrinsicPayloadValue, ICompact, IKeyringPair, INumber, IOption } from '../../types/index.js';
+import { Struct } from '@pezkuwi/types-codec';
+/**
+ * @name GenericExtrinsicPayloadV5
+ * @description
+ * A signing payload for an [[Extrinsic]]. For the final encoding, it is
+ * variable length based on the contents included
+ */
+export declare class GenericExtrinsicPayloadV5 extends Struct {
+    constructor(registry: Registry, value?: ExtrinsicPayloadValue | Uint8Array | HexString);
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @description The block [[BlockHash]] the signature applies to (mortal/immortal)
+     */
+    get blockHash(): BlockHash;
+    /**
+     * @description The [[ExtrinsicEra]]
+     */
+    get era(): ExtrinsicEra;
+    /**
+     * @description The genesis [[BlockHash]] the signature applies to (mortal/immortal)
+     */
+    get genesisHash(): BlockHash;
+    /**
+     * @description The [[Bytes]] contained in the payload
+     */
+    get method(): Bytes;
+    /**
+     * @description The [[Index]]
+     */
+    get nonce(): ICompact<INumber>;
+    /**
+     * @description The specVersion for this signature
+     */
+    get specVersion(): INumber;
+    /**
+     * @description The tip [[Balance]]
+     */
+    get tip(): ICompact<INumber>;
+    /**
+     * @description The transactionVersion for this signature
+     */
+    get transactionVersion(): INumber;
+    /**
+     * @description The (optional) asset id for this signature for chains that support transaction fees in assets
+     */
+    get assetId(): IOption<INumber | MultiLocation>;
+    /**
+     * @description The (optional) metadataHash proof for the CheckMetadataHash TransactionExtension
+     */
+    get metadataHash(): IOption<Hash>;
+    /**
+     * @description Sign the payload with the keypair
+     *
+     * [Disabled for ExtrinsicV5]
+     */
+    sign(_signerPair: IKeyringPair): Uint8Array;
+}

package/build/extrinsic/v5/ExtrinsicSignature.d.ts

@@ -0,0 +1,98 @@
+import type { MultiLocation } from '@pezkuwi/types/interfaces';
+import type { HexString } from '@pezkuwi/util/types';
+import type { EcdsaSignature, Ed25519Signature, ExtrinsicEra, ExtrinsicSignature, Sr25519Signature } from '../../interfaces/extrinsics/index.js';
+import type { Address, Call, Hash } from '../../interfaces/runtime/index.js';
+import type { ExtrinsicPayloadValue, ICompact, IExtrinsicSignature, IKeyringPair, INumber, IOption, Registry, SignatureOptions } from '../../types/index.js';
+import type { ExtrinsicSignatureOptions } from '../types.js';
+import { Struct } from '@pezkuwi/types-codec';
+import { GenericExtrinsicPayloadV5 } from './ExtrinsicPayload.js';
+/**
+ * @name GenericExtrinsicSignatureV5
+ * @description
+ * A container for the [[Signature]] associated with a specific [[Extrinsic]]
+ */
+export declare class GenericExtrinsicSignatureV5 extends Struct implements IExtrinsicSignature {
+    #private;
+    constructor(registry: Registry, value?: GenericExtrinsicSignatureV5 | Uint8Array, { isSigned }?: ExtrinsicSignatureOptions);
+    /** @internal */
+    static decodeExtrinsicSignature(value?: GenericExtrinsicSignatureV5 | Uint8Array, isSigned?: boolean): GenericExtrinsicSignatureV5 | Uint8Array;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description `true` if the signature is valid
+     */
+    get isSigned(): boolean;
+    /**
+     * @description The [[ExtrinsicEra]] (mortal or immortal) this signature applies to
+     */
+    get era(): ExtrinsicEra;
+    /**
+     * @description The [[Index]] for the signature
+     */
+    get nonce(): ICompact<INumber>;
+    /**
+     * @description The actual [[EcdsaSignature]], [[Ed25519Signature]] or [[Sr25519Signature]]
+     */
+    get signature(): EcdsaSignature | Ed25519Signature | Sr25519Signature;
+    /**
+     * @description The raw [[ExtrinsicSignature]]
+     */
+    get multiSignature(): ExtrinsicSignature;
+    /**
+     * @description The [[Address]] that signed
+     */
+    get signer(): Address;
+    /**
+     * @description The [[Balance]] tip
+     */
+    get tip(): ICompact<INumber>;
+    /**
+     * @description The [[u32]] or [[MultiLocation]] assetId
+     */
+    get assetId(): IOption<INumber | MultiLocation>;
+    /**
+     * @description the [[u32]] mode
+     */
+    get mode(): INumber;
+    /**
+     * @description The (optional)  [[Hash]] for the metadata proof
+     */
+    get metadataHash(): IOption<Hash>;
+    /**
+     * @description The [[u8]] for the TransactionExtension version
+     */
+    get transactionExtensionVersion(): INumber;
+    /**
+     * [Disabled for ExtrinsicV5]
+     */
+    protected _injectSignature(_signer: Address, _signature: ExtrinsicSignature, _payload: GenericExtrinsicPayloadV5): IExtrinsicSignature;
+    /**
+     * @description Adds a raw signature
+     *
+     * [Disabled for ExtrinsicV5]
+     */
+    addSignature(_signer: Address | Uint8Array | string, _signature: Uint8Array | HexString, _payload: ExtrinsicPayloadValue | Uint8Array | HexString): IExtrinsicSignature;
+    /**
+     * @description Creates a payload from the supplied options
+     */
+    createPayload(method: Call, options: SignatureOptions): GenericExtrinsicPayloadV5;
+    /**
+     * @description Generate a payload and applies the signature from a keypair
+     *
+     * [Disabled for ExtrinsicV5]
+     */
+    sign(_method: Call, _account: IKeyringPair, _options: SignatureOptions): IExtrinsicSignature;
+    /**
+     * @description Generate a payload and applies a fake signature
+     *
+     * [Disabled for ExtrinsicV5]
+     */
+    signFake(_method: Call, _address: Address | Uint8Array | string, _options: SignatureOptions): IExtrinsicSignature;
+    /**
+     * @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;
+}

package/build/extrinsic/v5/GeneralExtrinsic.d.ts

@@ -0,0 +1,85 @@
+import type { Call, ExtrinsicEra, Hash, MultiLocation } from '@pezkuwi/types/interfaces';
+import type { AnyNumber, AnyU8a, ICompact, IExtrinsicEra, INumber, IOption, Registry } from '@pezkuwi/types/types';
+import type { AnyTuple, IMethod } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import { Struct } from '@pezkuwi/types-codec';
+interface TransactionExtensionValues {
+    era: AnyU8a | IExtrinsicEra;
+    nonce: AnyNumber;
+    tip: AnyNumber;
+    transactionVersion: AnyNumber;
+    assetId?: HexString;
+    mode?: AnyNumber;
+    metadataHash?: AnyU8a;
+}
+interface GeneralExtrinsicPayloadValues extends TransactionExtensionValues {
+    method: AnyU8a | IMethod<AnyTuple>;
+}
+interface GeneralExtrinsicValue {
+    payload?: GeneralExtrinsicPayloadValues;
+    transactionExtensionVersion?: number;
+}
+export declare class GeneralExtrinsic extends Struct {
+    #private;
+    constructor(registry: Registry, value?: GeneralExtrinsicValue | Uint8Array | HexString, opt?: {
+        version: number;
+    });
+    static decodeExtrinsic(registry: Registry, value?: GeneralExtrinsicValue | Uint8Array | HexString): object;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description The [[ExtrinsicEra]]
+     */
+    get era(): ExtrinsicEra;
+    /**
+     * @description The [[Index]]
+     */
+    get nonce(): ICompact<INumber>;
+    /**
+     * @description The tip [[Balance]]
+     */
+    get tip(): ICompact<INumber>;
+    /**
+     * @description The (optional) asset id for this signature for chains that support transaction fees in assets
+     */
+    get assetId(): IOption<INumber | MultiLocation>;
+    /**
+     * @description The mode used for the CheckMetadataHash TransactionExtension
+     */
+    get mode(): INumber;
+    /**
+     * @description The (optional) [[Hash]] for the metadata proof
+     */
+    get metadataHash(): IOption<Hash>;
+    /**
+     * @description The version of the TransactionExtensions used in this extrinsic
+     */
+    get transactionExtensionVersion(): INumber;
+    /**
+     * @description The [[Call]] this extrinsic wraps
+     */
+    get method(): Call;
+    /**
+     * @description The extrinsic's version
+     */
+    get version(): number;
+    /**
+     * @description The [[Preamble]] for the extrinsic
+     */
+    get preamble(): number;
+    toHex(isBare?: boolean): HexString;
+    toU8a(isBare?: boolean): Uint8Array;
+    toRawType(): string;
+    /**
+     *
+     * @description Returns an encoded GeneralExtrinsic
+     */
+    encode(): Uint8Array<ArrayBufferLike>;
+    signFake(): void;
+    addSignature(): void;
+    sign(): void;
+    signature(): void;
+}
+export {};

package/build/extrinsic/v5/index.d.ts

@@ -0,0 +1,4 @@
+export { GenericExtrinsicV5 } from './Extrinsic.js';
+export { GenericExtrinsicPayloadV5 } from './ExtrinsicPayload.js';
+export { GenericExtrinsicSignatureV5 } from './ExtrinsicSignature.js';
+export { GeneralExtrinsic } from './GeneralExtrinsic.js';