@pezkuwi/types 16.5.5

package/build/primitive/StorageKey.d.ts

@@ -0,0 +1,53 @@
+import type { AnyJson, AnyTuple } from '@pezkuwi/types-codec/types';
+import type { StorageEntryMetadataLatest } from '../interfaces/metadata/index.js';
+import type { IStorageKey, Registry } from '../types/index.js';
+import type { StorageEntry } from './types.js';
+import { Bytes } from '@pezkuwi/types-codec';
+interface StorageKeyExtra {
+    method: string;
+    section: string;
+}
+/**
+ * @name StorageKey
+ * @description
+ * 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.
+ */
+export declare class StorageKey<A extends AnyTuple = AnyTuple> extends Bytes implements IStorageKey<A> {
+    #private;
+    constructor(registry: Registry, value?: string | Uint8Array | StorageKey | StorageEntry | [StorageEntry, unknown[]?], override?: Partial<StorageKeyExtra>);
+    /**
+     * @description Return the decoded arguments (applicable to map with decodable values)
+     */
+    get args(): A;
+    /**
+     * @description The metadata or `undefined` when not available
+     */
+    get meta(): StorageEntryMetadataLatest | undefined;
+    /**
+     * @description The key method or `undefined` when not specified
+     */
+    get method(): string | undefined;
+    /**
+     * @description The output type
+     */
+    get outputType(): string;
+    /**
+     * @description The key section or `undefined` when not specified
+     */
+    get section(): string | undefined;
+    is(key: IStorageKey<AnyTuple>): key is IStorageKey<A>;
+    /**
+     * @description Sets the meta for this key
+     */
+    setMeta(meta?: StorageEntryMetadataLatest, section?: string, method?: string): this;
+    /**
+     * @description Returns the Human representation for this type
+     */
+    toHuman(_isExtended?: boolean, disableAscii?: boolean): AnyJson;
+    /**
+     * @description Returns the raw type for this
+     */
+    toRawType(): string;
+}
+export {};

package/build/primitive/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @summary Type definitions that are used in the system
+ */
+export { BitVec, Bool, bool, Bytes, F32, f32, F64, f64, I8, i8, I16, i16, I32, i32, I64, i64, I128, i128, I256, i256, ISize, isize, Null, OptionBool, Text, Type, U8, u8, U16, u16, U32, u32, U64, u64, U128, u128, U256, u256, USize, usize } from '@pezkuwi/types-codec';
+export { Data } from './Data.js';
+export { StorageKey } from './StorageKey.js';

package/build/primitive/types.d.ts

@@ -0,0 +1,17 @@
+import type { StorageEntryMetadataLatest } from '../interfaces/metadata/index.js';
+import type { Codec, Inspect } from '../types/index.js';
+export interface StorageEntryIterator {
+    (...args: unknown[]): Uint8Array & Codec;
+    meta: StorageEntryMetadataLatest;
+}
+export interface StorageEntry {
+    (...args: unknown[]): Uint8Array;
+    iterKey?: StorageEntryIterator;
+    inspect: (...args: unknown[]) => Inspect;
+    keyPrefix: (...args: unknown[]) => Uint8Array;
+    meta: StorageEntryMetadataLatest;
+    method: string;
+    prefix: string;
+    section: string;
+    toJSON: () => any;
+}

package/build/types/augmentLookup.d.ts

@@ -0,0 +1,15 @@
+import '@pezkuwi/types-create/types/lookup';
+import type { Vec } from '@pezkuwi/types-codec';
+import type { LookupString } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { PortableType } from '../interfaces/metadata/index.js';
+import type { SiLookupTypeId, SiType } from '../interfaces/scaleInfo/index.js';
+declare module '@pezkuwi/types-create/types/lookup' {
+    interface ILookup {
+        readonly names: string[];
+        readonly types: Vec<PortableType>;
+        getName(lookupId: SiLookupTypeId | LookupString | number): string | undefined;
+        getSiType(lookupId: SiLookupTypeId | LookupString | number): SiType;
+        getTypeDef(lookupId: SiLookupTypeId | LookupString | number): TypeDef;
+    }
+}

package/build/types/augmentRegistry.d.ts

@@ -0,0 +1,39 @@
+import '@pezkuwi/types-codec/types/registry';
+import '@pezkuwi/types-create/types/augmentRegistry';
+import type { AnyString, Codec, CodecClass, LookupString } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { ExtDef } from '../extrinsic/signedExtensions/types.js';
+import type { MetadataLatest } from '../interfaces/metadata/index.js';
+import type { SiField, SiLookupTypeId } from '../interfaces/scaleInfo/index.js';
+import type { ChainProperties } from '../interfaces/system/index.js';
+import type { Metadata, PortableRegistry } from '../metadata/index.js';
+import type { CallFunction as CallFunctionExt } from './calls.js';
+import type { DetectCodec } from './detect.js';
+import type { CodecHasher, RegisteredTypes } from './registry.js';
+declare module '@pezkuwi/types-codec/types/registry' {
+    interface RegistryError {
+        fields: SiField[];
+    }
+    interface Registry {
+        readonly firstCallIndex: Uint8Array;
+        readonly knownTypes: RegisteredTypes;
+        readonly metadata: MetadataLatest;
+        readonly unknownTypes: string[];
+        readonly signedExtensions: string[];
+        findMetaCall(callIndex: Uint8Array): CallFunctionExt;
+        clearCache(): void;
+        createLookupType(lookupId: SiLookupTypeId | number): LookupString;
+        createClass<T extends Codec = Codec, K extends string = string>(type: K): CodecClass<DetectCodec<T, K>>;
+        createType<T extends Codec = Codec, K extends string = string>(type: K, ...params: unknown[]): DetectCodec<T, K>;
+        get<T extends Codec = Codec, K extends string = string>(name: K, withUnknown?: boolean, knownTypeDef?: TypeDef): CodecClass<DetectCodec<T, K>> | undefined;
+        getChainProperties(): ChainProperties | undefined;
+        getDefinition(typeName: string): string | undefined;
+        getModuleInstances(specName: AnyString, moduleName: string): string[] | undefined;
+        setKnownTypes(types: RegisteredTypes): void;
+        setChainProperties(properties?: ChainProperties): void;
+        setHasher(hasher?: CodecHasher | null): void;
+        setLookup(lookup: PortableRegistry): void;
+        setMetadata(metadata: Metadata, signedExtensions?: string[], userExtensions?: ExtDef): void;
+        setSignedExtensions(signedExtensions?: string[], userExtensions?: ExtDef): void;
+    }
+}

package/build/types/calls.d.ts

@@ -0,0 +1,10 @@
+import type { AnyTuple, CallBase as CallBaseBase, CallFunction as CallFunctionBase, IMethod } from '@pezkuwi/types-codec/types';
+import type { FunctionMetadataLatest } from '../interfaces/metadata/index.js';
+import type { Call } from '../interfaces/runtime/index.js';
+import type { Registry } from './registry.js';
+export interface CallBase<A extends AnyTuple, M = FunctionMetadataLatest> extends CallBaseBase<A, M> {
+    registry: Registry;
+}
+export interface CallFunction<A extends AnyTuple = AnyTuple, M = FunctionMetadataLatest> extends CallFunctionBase<A, M> {
+    (...args: any[]): Call & IMethod<A, M>;
+}

package/build/types/codec.d.ts

@@ -0,0 +1,4 @@
+import type { Codec } from '@pezkuwi/types-codec/types';
+export type { AnyFunction, AnyJson, AnyNumber, AnyString, AnyTuple, AnyU8a, ArgsDef, BareOpts, Codec, CodecClass, CodecTo, Inspect } from '@pezkuwi/types-codec/types';
+export type ArrayElementType<T extends readonly unknown[]> = T extends readonly (infer ElementType)[] ? ElementType : never;
+export type Callback<T, E = undefined> = E extends Codec ? (result: T, extra: E) => void | Promise<void> : (result: T) => void | Promise<void>;

package/build/types/definitions.d.ts

@@ -0,0 +1,108 @@
+import type { HexString } from '@pezkuwi/util/types';
+export type DefinitionTypeType = string;
+export type DefinitionTypeEnum = {
+    _fallback?: DefinitionTypeType;
+} & ({
+    _enum: DefinitionTypeType[];
+} | {
+    _enum: Record<string, DefinitionTypeType | null>;
+});
+export interface DefinitionTypeSet {
+    _fallback?: DefinitionTypeType;
+    _set: Record<string, number>;
+}
+type DefinitionTypeStructExtra = {
+    _alias?: Record<string, DefinitionTypeType>;
+    _fallback?: DefinitionTypeType;
+} & Record<string, unknown>;
+export type DefinitionTypeStruct = Record<string, DefinitionTypeType> | DefinitionTypeStructExtra;
+export type DefinitionType = string | DefinitionTypeEnum | DefinitionTypeSet | DefinitionTypeStruct;
+export interface DefinitionRpcParam {
+    /** true if the parameter is a blockhash that is to be used in historic queries */
+    isHistoric?: boolean;
+    /** true if this is an optional parameter (we forgo the use of Option<T> types) */
+    isOptional?: boolean;
+    /** The name of the parameter */
+    name: string;
+    /** The type of the parameter */
+    type: DefinitionTypeType;
+}
+export interface DefinitionRpc {
+    /** Alias to a specific method (this allows replacements and renames) */
+    alias?: string[];
+    /** Alias to a section */
+    aliasSection?: string;
+    /** A string describing a deprecated interface, along with to-use information */
+    deprecated?: string;
+    /** The description for this RPC call */
+    description: string;
+    /** The (optional) endpoint override. If not specified the section_method is used */
+    endpoint?: string;
+    /** true if this needs a signed submission, e.g. when submitting extrinsics */
+    isSigned?: boolean;
+    /** true if this is an RPC call that has been marked unsafe */
+    isUnsafe?: boolean;
+    /** Don't log any errors if they occur (should be used sparingly for exceptions only) */
+    noErrorLog?: boolean;
+    /** The applicable parameters for the call */
+    params: DefinitionRpcParam[];
+    /** The return type for the RPC call */
+    type: DefinitionTypeType;
+}
+export interface DefinitionRpcExt extends DefinitionRpc {
+    /** true if this is a method yielding a subscription */
+    isSubscription: boolean;
+    /** The jsonrpc name for this method, typically section_method */
+    jsonrpc: string;
+    /** The method name for this RPC */
+    method: string;
+    /** Optional subscription information in the form [subscription name, subscribe method, unsubscribe method] */
+    pubsub?: [subname: string, subscribe: string, unsubscribe: string];
+    /** The section name for this RPC */
+    section: string;
+}
+export interface DefinitionCallParam {
+    /** The name for this parameter */
+    name: string;
+    /** The return type for this parameter */
+    type: DefinitionTypeType;
+}
+export interface DefinitionCall {
+    /** The description of this runtime call (generally extracted from the Rust code as-is) */
+    description: string;
+    /** The applicable call parameters */
+    params: DefinitionCallParam[];
+    /** The return type for this call */
+    type: DefinitionTypeType;
+}
+export interface DefinitionRpcSub extends DefinitionRpc {
+    /** Subscription information in the form [subscription name, subscribe method, unsubscribe method] */
+    pubsub: [subname: string, subscribe: string, unsubscribe: string];
+}
+export type DefinitionsRpc = Record<string, DefinitionRpc | DefinitionRpcSub>;
+export interface DefinitionsCallEntry {
+    /** The method that are available on this interface */
+    methods: Record<string, DefinitionCall>;
+    /** The version of the runtime api that this definition applies to */
+    version: number;
+}
+export type DefinitionsCall = Record<string, DefinitionsCallEntry[]>;
+export interface DefinitionCallNamed extends DefinitionCall {
+    /** The method for this call (combined with section to form name) */
+    method: string;
+    /** The actual name of the runtime call as exposed by the runtime itself */
+    name: string;
+    /** The section for this call (combined with method to form name) */
+    section: string;
+    /** The hash of this section (these map to what is available in state_getRuntimeVersion) */
+    sectionHash: HexString;
+    /** The version of the runtime interface */
+    version: number;
+}
+export type DefinitionsTypes = Record<string, DefinitionType>;
+export interface Definitions {
+    rpc?: DefinitionsRpc;
+    runtime?: DefinitionsCall;
+    types: DefinitionsTypes;
+}
+export {};

package/build/types/detect.d.ts

@@ -0,0 +1,42 @@
+import type { InterfaceTypes } from '@pezkuwi/types/types';
+import type { bool, BTreeMap, BTreeSet, Bytes, CodecSet, Compact, Enum, HashMap, Linkage, Null, Option, OptionBool, Range, RangeInclusive, Result, Struct, u8, U8aFixed, Vec, VecFixed } from '@pezkuwi/types-codec';
+import type { Codec, ICompact, IEnum, IMap, IMethod, INumber, IOption, IResult, ISet, IStruct, ITuple, IU8a, IVec } from '@pezkuwi/types-codec/types';
+export type DetectCodec<T extends Codec, K extends string> = K extends keyof InterfaceTypes ? InterfaceTypes[K] : T extends ICompact | IEnum | IMap | IMethod | INumber | IOption | IResult | ISet | IStruct | ITuple | IU8a | IVec ? T : __Codec<__Codecs<__Tokenize<__Sanitize<K>>[0]>>;
+export type __Codec<V extends Codec[]> = V[0] extends Codec ? V[0] : Codec;
+export type __Sanitize<K extends string> = K extends ` ${infer X}` | `${infer X} ` | ` ${infer X} ` ? __Sanitize<X> : K extends `${infer A} ${infer B}` ? __Sanitize<`${A}${B}`> : K extends `${infer A};${string}]${infer B}` ? __Sanitize<`${A}${B}`> : K extends `${infer X};${string}]` ? __Sanitize<X> : K;
+export type __Value = string | Record<string, unknown> | __Value[];
+export interface __MapWrapOne<C extends Codec> {
+    'BTreeSet<': BTreeSet<C>;
+    'Compact<': C extends INumber ? Compact<C> : Codec;
+    'Linkage<': Linkage<C>;
+    'Option<': C extends bool ? OptionBool : Option<C>;
+    'Range<': C extends INumber ? Range<C> : Codec;
+    'RangeInclusive<': C extends INumber ? RangeInclusive<C> : Codec;
+    'Vec<': C extends u8 ? Bytes : Vec<C>;
+    '[': C extends u8 ? U8aFixed : VecFixed<C>;
+}
+export interface __MapWrapTwo<K extends Codec, V extends Codec> {
+    'BTreeMap<': BTreeMap<K, V>;
+    'HashMap<': HashMap<K, V>;
+    'Result<': Result<K, V>;
+}
+export type __WrapOne = keyof __MapWrapOne<Codec>;
+export type __WrapTwo = keyof __MapWrapTwo<Codec, Codec>;
+export type __Wrap = __WrapOne | __WrapTwo;
+export type __ToTuple<O extends Codec[]> = O[0] extends Codec ? O[1] extends Codec ? ITuple<O> : O[0] : Null;
+export type __CodecsNext<K, C extends Codec[]> = K extends __WrapOne ? C extends [Codec, ...infer X] ? [__MapWrapOne<C[0]>[K], ...X] : Codec : K extends __WrapTwo ? C extends [Codec, Codec, ...infer X] ? [__MapWrapTwo<C[0], C[1]>[K], ...X] : Codec : [
+    K extends keyof InterfaceTypes ? InterfaceTypes[K] : K extends unknown[] ? __ToTuple<__Codecs<K>> : K extends Record<string, unknown> ? K['_enum'] extends true ? Enum : K['_set'] extends true ? CodecSet : Struct : Codec,
+    ...C
+];
+export type __Codecs<T extends unknown[]> = T extends [infer K, ...infer N] ? __CodecsNext<K, __Codecs<N>> : [];
+export type __Combine<V extends __Value[], I extends string> = I extends '' ? V : [...V, I];
+export type __CombineInner<V extends __Value[], I extends string, X extends __Value> = I extends '' ? [...V, X] : [I, ...V, X];
+export type __TokenizeStruct<T extends [__Value[], string], V extends __Value[], I extends string, R extends string> = __Tokenize<T[1], __CombineInner<V, I, R extends `"_set"${string}` ? {
+    _set: true;
+} : R extends `"_enum"${string}` ? {
+    _enum: true;
+} : {
+    _fields: true;
+}>>;
+export type __TokenizeTuple<T extends [__Value[], string], V extends __Value[], I extends string> = __Tokenize<T[1], __CombineInner<V, I, T[0]>>;
+export type __Tokenize<K extends string, V extends __Value[] = [], I extends string = ''> = K extends '' | '>' | ')' | '}' ? [__Combine<V, I>, ''] : K extends `${__Wrap}${infer R}` ? K extends `${infer X}${R}` ? X extends '[' ? __Tokenize<R, [...__Combine<V, I>, '[']> : __Tokenize<R, __Combine<V, `${I}${X}`>> : never : K extends `${',' | '>'}${infer R}` ? __Tokenize<R, __Combine<V, I>> : K extends `${')' | '}'}${infer R}` ? [__Combine<V, I>, R] : K extends `(${infer R}` ? __TokenizeTuple<__Tokenize<R>, V, I> : K extends `{${infer R}` ? __TokenizeStruct<__Tokenize<R>, V, I, R> : K extends `${keyof InterfaceTypes}${',' | '>'}${infer R}` ? K extends `${infer X}${',' | '>'}${R}` ? __Tokenize<R, __Combine<V, `${I}${X}`>> : never : K extends `${infer C}${infer R}` ? __Tokenize<R, V, `${I}${C}`> : [__Combine<V, I>, ''];

package/build/types/events.d.ts

@@ -0,0 +1,28 @@
+import type { Codec } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { EventMetadataLatest } from '../interfaces/metadata/index.js';
+import type { Hash } from '../interfaces/runtime/index.js';
+import type { EventId, Phase } from '../interfaces/system/index.js';
+export interface IEventRecord<T extends Codec[]> extends Codec {
+    readonly phase: Phase;
+    readonly event: IEvent<T>;
+    readonly topics: Hash[];
+}
+export interface IEventData extends Codec {
+    readonly meta: EventMetadataLatest;
+    readonly method: string;
+    readonly names: string[] | null;
+    readonly section: string;
+    readonly typeDef: TypeDef[];
+}
+export interface IEventLike {
+    readonly index: unknown;
+    readonly method: unknown;
+    readonly section: unknown;
+}
+export interface IEvent<T extends Codec[], N = unknown> extends IEventLike, Codec {
+    readonly data: N extends Record<string, Codec> ? N & T & IEventData : T & IEventData;
+    readonly index: EventId;
+    readonly method: string;
+    readonly section: string;
+}

package/build/types/extrinsic.d.ts

@@ -0,0 +1,220 @@
+import type { AnyJson, AnyNumber, AnyTuple, AnyU8a, Codec } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { ExtrinsicStatus } from '../interfaces/author/index.js';
+import type { EcdsaSignature, Ed25519Signature, Sr25519Signature } from '../interfaces/extrinsics/index.js';
+import type { Address, Call, H256, Hash } from '../interfaces/runtime/index.js';
+import type { DispatchError, DispatchInfo, EventRecord } from '../interfaces/system/index.js';
+import type { ICompact, IKeyringPair, IMethod, INumber, IRuntimeVersionBase } from './interfaces.js';
+import type { Registry } from './registry.js';
+export interface ISubmittableResult {
+    readonly dispatchError?: DispatchError | undefined;
+    readonly dispatchInfo?: DispatchInfo | undefined;
+    readonly events: EventRecord[];
+    readonly internalError?: Error | undefined;
+    readonly status: ExtrinsicStatus;
+    readonly isCompleted: boolean;
+    readonly isError: boolean;
+    readonly isFinalized: boolean;
+    readonly isInBlock: boolean;
+    readonly isWarning: boolean;
+    readonly txHash: Hash;
+    readonly txIndex?: number | undefined;
+    filterRecords(section: string, method: string): EventRecord[];
+    findRecord(section: string, method: string): EventRecord | undefined;
+    toHuman(isExtended?: boolean): AnyJson;
+}
+export interface SignerPayloadJSON {
+    /**
+     * @description The ss-58 encoded address
+     */
+    address: string;
+    /**
+     * @description The id of the asset used to pay fees, in hex
+     */
+    assetId?: HexString;
+    /**
+     * @description The checkpoint hash of the block, in hex
+     */
+    blockHash: HexString;
+    /**
+     * @description The checkpoint block number, in hex
+     */
+    blockNumber: HexString;
+    /**
+     * @description The era for this transaction, in hex
+     */
+    era: HexString;
+    /**
+     * @description The genesis hash of the chain, in hex
+     */
+    genesisHash: HexString;
+    /**
+     * @description The metadataHash for the CheckMetadataHash SignedExtension, as hex
+     */
+    metadataHash?: HexString;
+    /**
+     * @description The encoded method (with arguments) in hex
+     */
+    method: string;
+    /**
+     * @description The mode for the CheckMetadataHash SignedExtension, in hex
+     */
+    mode?: number;
+    /**
+     * @description The nonce for this transaction, in hex
+     */
+    nonce: HexString;
+    /**
+     * @description The current spec version for the runtime
+     */
+    specVersion: HexString;
+    /**
+     * @description The tip for this transaction, in hex
+     */
+    tip: HexString;
+    /**
+     * @description The current transaction version for the runtime
+     */
+    transactionVersion: HexString;
+    /**
+     * @description The applicable signed extensions for this runtime
+     */
+    signedExtensions: string[];
+    /**
+     * @description The version of the extrinsic we are dealing with
+     */
+    version: number;
+    /**
+     * @description Optional flag that enables the use of the `signedTransaction` field in
+     * `singAndSend`, `signAsync`, and `dryRun`.
+     */
+    withSignedTransaction?: boolean;
+}
+export interface SignerPayloadRawBase {
+    /**
+     * @description The hex-encoded data for this request
+     */
+    data: string;
+    /**
+     * @description The type of the contained data
+     */
+    type?: 'bytes' | 'payload';
+}
+export interface SignerPayloadRaw extends SignerPayloadRawBase {
+    /**
+     * @description The ss-58 encoded address
+     */
+    address: string;
+    /**
+     * @description The type of the contained data
+     */
+    type: 'bytes' | 'payload';
+}
+export interface ISignerPayload {
+    toPayload(): SignerPayloadJSON;
+    toRaw(): SignerPayloadRaw;
+}
+export interface SignerResult {
+    /**
+     * @description The id for this request
+     */
+    id: number;
+    /**
+     * @description The resulting signature in hex
+     */
+    signature: HexString;
+    /**
+     * @description The payload constructed by the signer. This allows the
+     * inputted signed transaction to bypass `signAndSend` from adding the signature to the payload,
+     * and instead broadcasting the transaction directly. There is a small validation layer. Please refer
+     * to the implementation for more information. If the inputted signed transaction is not actually signed, it will fail with an error.
+     *
+     * This will also work for `signAsync`. The new payload will be added to the Extrinsic, and will be sent once the consumer calls `.send()`.
+     *
+     * NOTE: This is only implemented for `signPayload`, and will only work when the `withSignedTransaction` option is enabled as an option.
+     */
+    signedTransaction?: HexString | Uint8Array;
+}
+export interface Signer {
+    /**
+     * @description signs an extrinsic payload from a serialized form
+     */
+    signPayload?: (payload: SignerPayloadJSON) => Promise<SignerResult>;
+    /**
+     * @description signs a raw payload, only the bytes data as supplied
+     */
+    signRaw?: (raw: SignerPayloadRaw) => Promise<SignerResult>;
+    /**
+     * @description Receives an update for the extrinsic signed by a `signer.sign`
+     */
+    update?: (id: number, status: H256 | ISubmittableResult) => void;
+}
+export interface IExtrinsicEra extends Codec {
+    asImmortalEra: Codec;
+    asMortalEra: Codec;
+}
+export interface SignatureOptions {
+    allowCallDataAlteration?: boolean;
+    blockHash: Uint8Array | string;
+    era?: IExtrinsicEra;
+    genesisHash: Uint8Array | string;
+    nonce: AnyNumber;
+    runtimeVersion: IRuntimeVersionBase;
+    signedExtensions?: string[];
+    signer?: Signer;
+    tip?: AnyNumber;
+    assetId?: AnyNumber | object;
+    mode?: AnyNumber;
+    metadataHash?: Uint8Array | string;
+    withSignedTransaction?: boolean;
+}
+interface ExtrinsicSignatureBase {
+    readonly isSigned: boolean;
+    readonly era: IExtrinsicEra;
+    readonly nonce: ICompact<INumber>;
+    readonly signature: EcdsaSignature | Ed25519Signature | Sr25519Signature;
+    readonly signer: Address;
+    readonly tip: ICompact<INumber>;
+}
+export interface ExtrinsicPayloadValue {
+    blockHash: AnyU8a;
+    era: AnyU8a | IExtrinsicEra;
+    genesisHash: AnyU8a;
+    method: AnyU8a | IMethod<AnyTuple>;
+    nonce: AnyNumber;
+    specVersion: AnyNumber;
+    tip: AnyNumber;
+    transactionVersion: AnyNumber;
+    assetId?: HexString;
+    mode?: AnyNumber;
+    metadataHash?: AnyU8a;
+}
+export interface IExtrinsicSignature extends ExtrinsicSignatureBase, Codec {
+    addSignature(signer: Address | Uint8Array | string, signature: Uint8Array | HexString, payload: Uint8Array | HexString): IExtrinsicSignature;
+    sign(method: Call, account: IKeyringPair, options: SignatureOptions): IExtrinsicSignature;
+    signFake(method: Call, address: Address | Uint8Array | string, options: SignatureOptions): IExtrinsicSignature;
+    readonly registry: Registry;
+}
+interface IExtrinsicSignable<T> extends Codec {
+    addSignature(signer: Address | Uint8Array | string, signature: Uint8Array | HexString, payload: ExtrinsicPayloadValue | Uint8Array | HexString): T;
+    sign(account: IKeyringPair, options: SignatureOptions): T;
+    signFake(address: Address | Uint8Array | string, options: SignatureOptions): T;
+    readonly registry: Registry;
+}
+export interface IExtrinsicImpl extends IExtrinsicSignable<IExtrinsicImpl> {
+    readonly method: Call;
+    readonly signature: IExtrinsicSignature;
+    readonly version: number;
+}
+export interface IExtrinsicV5Impl extends IExtrinsicSignable<IExtrinsicV5Impl> {
+    readonly method: Call;
+    readonly signature: IExtrinsicSignature;
+    readonly version: number;
+}
+export interface IExtrinsic<A extends AnyTuple = AnyTuple> extends IExtrinsicSignable<IExtrinsic<A>>, ExtrinsicSignatureBase, IMethod<A> {
+    readonly length: number;
+    readonly method: IMethod<A>;
+    readonly type: number;
+    readonly version: number;
+}
+export {};

package/build/types/index.d.ts

@@ -0,0 +1,12 @@
+import './augmentLookup.js';
+import './augmentRegistry.js';
+export * from '@pezkuwi/types/types/registry';
+export type { Observable } from 'rxjs';
+export * from '../create/types.js';
+export * from './calls.js';
+export * from './codec.js';
+export * from './definitions.js';
+export * from './detect.js';
+export * from './events.js';
+export * from './extrinsic.js';
+export * from './interfaces.js';

package/build/types/interfaces.d.ts

@@ -0,0 +1,40 @@
+import type { SignOptions } from '@pezkuwi/keyring/types';
+import type { AnyTuple, Codec, IMethod as IMethodBase, INumber, IText } from '@pezkuwi/types-codec/types';
+import type { FunctionMetadataLatest, StorageEntryMetadataLatest } from '../interfaces/metadata/index.js';
+import type { Registry } from './registry.js';
+export type { ICompact, IEnum, IMap, INumber, IOption, IResult, ISet, IStruct, IText, ITuple, IU8a, IVec } from '@pezkuwi/types-codec/types';
+export interface IMethod<A extends AnyTuple = AnyTuple, M = FunctionMetadataLatest> extends IMethodBase<A, M> {
+    readonly registry: Registry;
+}
+export interface IKeyringPair {
+    readonly address: string;
+    readonly addressRaw: Uint8Array;
+    readonly publicKey: Uint8Array;
+    sign: (data: Uint8Array, options?: SignOptions) => Uint8Array;
+}
+export interface IRuntimeVersionBase {
+    readonly apis: unknown[];
+    readonly authoringVersion: unknown;
+    readonly implName: unknown;
+    readonly implVersion: unknown;
+    readonly specName: unknown;
+    readonly specVersion: unknown;
+    readonly transactionVersion: unknown;
+}
+export interface IRuntimeVersion extends IRuntimeVersionBase {
+    readonly apis: Codec[];
+    readonly authoringVersion: INumber;
+    readonly implName: IText;
+    readonly implVersion: INumber;
+    readonly specName: IText;
+    readonly specVersion: INumber;
+    readonly transactionVersion: INumber;
+}
+export interface IStorageKey<A extends AnyTuple> {
+    readonly args: A;
+    readonly meta: StorageEntryMetadataLatest | undefined;
+    readonly method: string | undefined;
+    readonly outputType: string;
+    readonly section: string | undefined;
+    is: (key: IStorageKey<AnyTuple>) => key is IStorageKey<A>;
+}