@pezkuwi/types 16.5.5

package/src/types/augmentRegistry.ts

@@ -0,0 +1,53 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+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/src/types/calls.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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/src/types/codec.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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';
+
+// helper to extract keys from an array
+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/src/types/definitions.ts

@@ -0,0 +1,119 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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;
+}

package/src/types/detect.ts

@@ -0,0 +1,148 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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> =
+  // This is weird - it looks the wrong way around (i.e. T check should be done first), however
+  // it does work (as evident with checkTypes) and is problematic the other way around
+  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;
+
+// trim leading and trailing spaces and unused portions, e.g `...;<length>]`
+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>;
+}
+
+// FIXME We don't cater for Int< & UInt< here. These could be problematic, since it has
+// a variable number of inner arguments, better would be to just strip them inside the sanitize
+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
+      : [
+        // __CodecFirst<K>
+        K extends keyof InterfaceTypes
+          ? InterfaceTypes[K]
+          : K extends unknown[]
+            ? __ToTuple<__Codecs<K>>
+            : K extends Record<string, unknown>
+              // __ToStruct<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];
+
+// FIXME At this point enum/set/struct are empty, no field indicators, just type indicators
+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]>>;
+
+// NOTE For recursion limits, it is more optimal to use __Sanitize with conjunction with __Tokenize
+// below, even while we do more matching (Number of characters iterated through is the most problematic)
+export type __Tokenize<K extends string, V extends __Value[] = [], I extends string = ''> =
+  K extends '' | '>' | ')' | '}'
+    ? [__Combine<V, I>, '']
+    : K extends `${__Wrap}${infer R}`
+      // __TokenizeWrapped<K extends string, V extends __Value[], I extends string, R extends string>
+      ? 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}`
+                // __TokenizeKnown<K extends string, V extends __Value[], I extends string, R extends string>
+                ? 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/src/types/events.ts

@@ -0,0 +1,37 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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/src/types/extrinsic.ts

@@ -0,0 +1,262 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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;
+}

package/src/types/index.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// augment our internal Lookup & Registry interfaces
+import './augmentLookup.js';
+import './augmentRegistry.js';
+
+// augmented exports
+export * from '@pezkuwi/types/types/registry';
+
+// used inside augmented definitions
+export type { Observable } from 'rxjs';
+
+// other exports
+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';