@pezkuwi/types 16.5.5

package/src/extrinsic/ExtrinsicEra.ts

@@ -0,0 +1,299 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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, U64 } from '@pezkuwi/types-codec';
+import { bnToBn, formatNumber, hexToU8a, isHex, isObject, isU8a, u8aToBn, u8aToU8a } from '@pezkuwi/util';
+
+import { IMMORTAL_ERA } from './constants.js';
+
+type MortalEraValue = [INumber, INumber];
+
+interface MortalMethod {
+  current: number;
+  period: number;
+}
+
+interface MortalEnumDef {
+  MortalEra: string;
+}
+
+interface ImmortalEnumDef {
+  ImmortalEra: string;
+}
+
+function getTrailingZeros (period: number): number {
+  const binary = period.toString(2);
+  let index = 0;
+
+  while (binary[binary.length - 1 - index] === '0') {
+    index++;
+  }
+
+  return index;
+}
+
+/** @internal */
+function decodeMortalEra (registry: Registry, value?: MortalMethod | Uint8Array | number[] | string): MortalEraValue {
+  if (isU8a(value) || isHex(value) || Array.isArray(value)) {
+    return decodeMortalU8a(registry, u8aToU8a(value));
+  } else if (!value) {
+    return [new U64(registry), new U64(registry)];
+  } else if (isObject(value)) {
+    return decodeMortalObject(registry, value);
+  }
+
+  throw new Error('Invalid data passed to Mortal era');
+}
+
+/** @internal */
+function decodeMortalObject (registry: Registry, value: MortalMethod): MortalEraValue {
+  const { current, period } = value;
+  let calPeriod = Math.pow(2, Math.ceil(Math.log2(period)));
+
+  calPeriod = Math.min(Math.max(calPeriod, 4), 1 << 16);
+
+  const phase = current % calPeriod;
+  const quantizeFactor = Math.max(calPeriod >> 12, 1);
+  const quantizedPhase = phase / quantizeFactor * quantizeFactor;
+
+  return [new U64(registry, calPeriod), new U64(registry, quantizedPhase)];
+}
+
+/** @internal */
+function decodeMortalU8a (registry: Registry, value: Uint8Array): MortalEraValue {
+  if (value.length === 0) {
+    return [new U64(registry), new U64(registry)];
+  }
+
+  const first = u8aToBn(value.subarray(0, 1)).toNumber();
+  const second = u8aToBn(value.subarray(1, 2)).toNumber();
+  const encoded: number = first + (second << 8);
+  const period = 2 << (encoded % (1 << 4));
+  const quantizeFactor = Math.max(period >> 12, 1);
+  const phase = (encoded >> 4) * quantizeFactor;
+
+  if (period < 4 || phase >= period) {
+    throw new Error('Invalid data passed to Mortal era');
+  }
+
+  return [new U64(registry, period), new U64(registry, phase)];
+}
+
+/** @internal */
+// eslint-disable-next-line @typescript-eslint/ban-types
+function decodeExtrinsicEra (value: IExtrinsicEra | MortalMethod | MortalEnumDef | ImmortalEnumDef | Uint8Array | string = new Uint8Array()): Uint8Array | Object | undefined {
+  if (isU8a(value)) {
+    return (!value.length || value[0] === 0)
+      ? new Uint8Array([0])
+      : new Uint8Array([1, value[0], value[1]]);
+  } else if (!value) {
+    return new Uint8Array([0]);
+  } else if (value instanceof GenericExtrinsicEra) {
+    return decodeExtrinsicEra(value.toU8a());
+  } else if (isHex(value)) {
+    return decodeExtrinsicEra(hexToU8a(value));
+  } else if (isObject(value)) {
+    const entries = Object.entries(value as MortalEnumDef).map(([k, v]): [string, any] => [k.toLowerCase(), v]);
+    const mortal = entries.find(([k]) => k.toLowerCase() === 'mortalera');
+    const immortal = entries.find(([k]) => k.toLowerCase() === 'immortalera');
+
+    // this is to de-serialize from JSON
+    return mortal
+      ? { MortalEra: mortal[1] as string }
+      : immortal
+        ? { ImmortalEra: immortal[1] as string }
+        : { MortalEra: value };
+  }
+
+  throw new Error('Invalid data passed to Era');
+}
+
+/**
+ * @name ImmortalEra
+ * @description
+ * The ImmortalEra for an extrinsic
+ */
+export class ImmortalEra extends Raw {
+  constructor (registry: Registry, _value?: AnyU8a) {
+    // For immortals, we always provide the known value (i.e. treated as a
+    // constant no matter how it is constructed - it is a fixed structure)
+    super(registry, IMMORTAL_ERA);
+  }
+}
+
+/**
+ * @name MortalEra
+ * @description
+ * The MortalEra for an extrinsic, indicating period and phase
+ */
+export class MortalEra extends Tuple {
+  constructor (registry: Registry, value?: MortalMethod | Uint8Array | number[] | string) {
+    super(registry, {
+      period: U64,
+      phase: U64
+    }, decodeMortalEra(registry, value));
+  }
+
+  /**
+   * @description Encoded length for mortals occupy 2 bytes, different from the actual Tuple since it is encoded. This is a shortcut fro `toU8a().length`
+   */
+  public override get encodedLength (): number {
+    return 2 | 0;
+  }
+
+  /**
+   * @description The period of this Mortal wraps as a [[U64]]
+   */
+  public get period (): INumber {
+    return this[0] as INumber;
+  }
+
+  /**
+   * @description The phase of this Mortal wraps as a [[U64]]
+   */
+  public get phase (): INumber {
+    return this[1] as INumber;
+  }
+
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  public override toHuman (): any {
+    return {
+      period: formatNumber(this.period),
+      phase: formatNumber(this.phase)
+    };
+  }
+
+  /**
+   * @description Returns a JSON representation of the actual value
+   */
+  public override toJSON (): any {
+    return this.toHex();
+  }
+
+  /**
+   * @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.
+   */
+  public override toU8a (_isBare?: boolean): Uint8Array {
+    const period = this.period.toNumber();
+    const encoded = Math.min(
+      15,
+      Math.max(1, getTrailingZeros(period) - 1)
+    ) + (
+      (
+        this.phase.toNumber() / Math.max(period >> 12, 1)
+      ) << 4
+    );
+
+    return new Uint8Array([
+      encoded & 0xff,
+      encoded >> 8
+    ]);
+  }
+
+  /**
+   * @description Get the block number of the start of the era whose properties this object describes that `current` belongs to.
+   */
+  public birth (current: BN | bigint | number | string): number {
+    const phase = this.phase.toNumber();
+    const period = this.period.toNumber();
+
+    // FIXME No toNumber() here
+    return (
+      ~~(
+        (
+          Math.max(bnToBn(current).toNumber(), phase) - phase
+        ) / period
+      ) * period
+    ) + phase;
+  }
+
+  /**
+   * @description Get the block number of the first block at which the era has ended.
+   */
+  public death (current: BN | bigint | number | string): number {
+    // FIXME No toNumber() here
+    return this.birth(current) + this.period.toNumber();
+  }
+}
+
+/**
+ * @name GenericExtrinsicEra
+ * @description
+ * The era for an extrinsic, indicating either a mortal or immortal extrinsic
+ */
+export class GenericExtrinsicEra extends Enum implements IExtrinsicEra {
+  constructor (registry: Registry, value?: unknown) {
+    super(registry, {
+      ImmortalEra,
+      MortalEra
+    }, decodeExtrinsicEra(value as string));
+  }
+
+  /**
+   * @description Override the encoded length method
+   */
+  public override get encodedLength (): number {
+    return this.isImmortalEra
+      ? this.asImmortalEra.encodedLength
+      : this.asMortalEra.encodedLength;
+  }
+
+  /**
+   * @description Returns the item as a [[ImmortalEra]]
+   */
+  public get asImmortalEra (): ImmortalEra {
+    if (!this.isImmortalEra) {
+      throw new Error(`Cannot convert '${this.type}' via asImmortalEra`);
+    }
+
+    return this.inner as ImmortalEra;
+  }
+
+  /**
+   * @description Returns the item as a [[MortalEra]]
+   */
+  public get asMortalEra (): MortalEra {
+    if (!this.isMortalEra) {
+      throw new Error(`Cannot convert '${this.type}' via asMortalEra`);
+    }
+
+    return this.inner as MortalEra;
+  }
+
+  /**
+   * @description `true` if Immortal
+   */
+  public get isImmortalEra (): boolean {
+    return this.index === 0;
+  }
+
+  /**
+   * @description `true` if Mortal
+   */
+  public get isMortalEra (): boolean {
+    return this.index > 0;
+  }
+
+  /**
+   * @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)
+   */
+  public override toU8a (isBare?: boolean): Uint8Array {
+    return this.isMortalEra
+      ? this.asMortalEra.toU8a(isBare)
+      : this.asImmortalEra.toU8a(isBare);
+  }
+}

package/src/extrinsic/ExtrinsicPayload.spec.ts

@@ -0,0 +1,116 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { u8aToHex } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../create/index.js';
+import { fallbackExtensions } from './signedExtensions/index.js';
+import { GenericExtrinsicPayload as ExtrinsicPayload } from './index.js';
+
+describe('ExtrinsicPayload', (): void => {
+  const registry = new TypeRegistry();
+  const TEST = {
+    address: '5DTestUPts3kjeXSTMyerHihn1uwMfLj8vU8sqF7qYrFabHE',
+    blockHash: '0xde8f69eeb5e065e18c6950ff708d7e551f68dc9bf59a07c52367c0280f805ec7',
+    era: '0x0703',
+    genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
+    method: '0x0600ffd7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9e56c',
+    nonce: '0x00001234',
+    specVersion: 123,
+    tip: '0x00000000000000000000000000005678'
+  };
+
+  const TEST_WITH_ASSET = {
+    address: '5DTestUPts3kjeXSTMyerHihn1uwMfLj8vU8sqF7qYrFabHE',
+    assetId: '0x010002043205011f' as `0x${string}`,
+    blockHash: '0xde8f69eeb5e065e18c6950ff708d7e551f68dc9bf59a07c52367c0280f805ec7',
+    era: '0x0703',
+    genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
+    method: '0x0600ffd7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9e56c',
+    nonce: '0x00001234',
+    specVersion: 123,
+    tip: '0x00000000000000000000000000005678'
+  };
+
+  it('creates and can re-create from itself (U8a)', (): void => {
+    const a = new ExtrinsicPayload(registry, TEST, { version: 4 });
+    const b = new ExtrinsicPayload(registry, a.toU8a(), { version: 4 });
+
+    expect(a.inspect()).toEqual(b.inspect());
+    expect(a.toJSON()).toEqual(b.toJSON());
+  });
+
+  it('creates and can re-create from itself (hex)', (): void => {
+    const a = new ExtrinsicPayload(registry, TEST, { version: 4 });
+    const b = new ExtrinsicPayload(registry, a.toHex(), { version: 4 });
+
+    expect(a.inspect()).toEqual(b.inspect());
+    expect(a.toJSON()).toEqual(b.toJSON());
+  });
+
+  it('handles assetId correctly', () => {
+    const reg = new TypeRegistry();
+
+    reg.setSignedExtensions(fallbackExtensions.concat(['ChargeAssetTxPayment']));
+    const ext = new ExtrinsicPayload(reg, TEST_WITH_ASSET, { version: 4 });
+    // remove option byte
+    const ext2 = new ExtrinsicPayload(reg, { ...TEST_WITH_ASSET, assetId: `0x${TEST_WITH_ASSET.assetId.slice(4)}` }, { version: 4 });
+
+    expect(ext.assetId.toJSON()).toEqual({
+      interior: {
+        x2: [
+          {
+            palletInstance: 50
+          },
+          {
+            generalIndex: 1984
+          }
+        ]
+      },
+      parents: 0
+    });
+    expect(ext.assetId.toJSON()).toEqual(ext2.assetId.toJSON());
+  });
+
+  it('handles toU8a(true) correctly', (): void => {
+    expect(
+      u8aToHex(
+        new ExtrinsicPayload(registry, TEST, { version: 4 }).toU8a(true)
+      )
+    ).toEqual(
+      // no method length prefix
+      '0x0600ffd7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9e56c0703d148e25901007b000000dcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025bde8f69eeb5e065e18c6950ff708d7e551f68dc9bf59a07c52367c0280f805ec7'
+    );
+  });
+
+  it('handles toU8a(false) correctly', (): void => {
+    expect(
+      u8aToHex(
+        new ExtrinsicPayload(registry, TEST, { version: 4 }).toU8a()
+      )
+    ).toEqual(
+      // with method length prefix
+      '0x940600ffd7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9e56c0703d148e25901007b000000dcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025bde8f69eeb5e065e18c6950ff708d7e551f68dc9bf59a07c52367c0280f805ec7'
+    );
+  });
+
+  it('has a sane inspect of an empty value', (): void => {
+    const reg = new TypeRegistry();
+
+    reg.setSignedExtensions(fallbackExtensions.concat(['ChargeAssetTxPayment']));
+    expect(new ExtrinsicPayload(reg, undefined).inspect()).toEqual({
+      inner: [
+        { name: 'method', outer: [new Uint8Array()] },
+        { inner: undefined, name: 'era', outer: [new Uint8Array([0]), new Uint8Array([0])] },
+        { name: 'nonce', outer: [new Uint8Array([0])] },
+        { name: 'tip', outer: [new Uint8Array([0])] },
+        { name: 'assetId', outer: [new Uint8Array([0])] },
+        { name: 'specVersion', outer: [new Uint8Array([0, 0, 0, 0])] },
+        { name: 'genesisHash', outer: [new Uint8Array(32)] },
+        { name: 'blockHash', outer: [new Uint8Array(32)] }
+      ]
+    });
+  });
+});

package/src/extrinsic/ExtrinsicPayload.ts

@@ -0,0 +1,223 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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';
+import { hexToU8a, isHex, u8aToHex } from '@pezkuwi/util';
+
+import { DEFAULT_PREAMBLE, LATEST_EXTRINSIC_VERSION } from './constants.js';
+
+interface ExtrinsicPayloadOptions {
+  version?: number;
+  preamble?: Preamble;
+}
+
+// all our known types that can be returned
+type ExtrinsicPayloadVx = ExtrinsicPayloadV5;
+
+const VERSIONS = [
+  'ExtrinsicPayloadUnknown', // v0 is unknown
+  'ExtrinsicPayloadUnknown',
+  'ExtrinsicPayloadUnknown',
+  'ExtrinsicPayloadUnknown',
+  'ExtrinsicPayloadV4',
+  'ExtrinsicPayloadV5'
+];
+
+const PREAMBLES = {
+  bare: 'ExtrinsicPayloadV5',
+  // Not supported yet
+  general: '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 function decodeAssetId (registry: Registry, payload?: ExtrinsicPayloadValue | Uint8Array | HexString) {
+  const maybeAsset = (payload as ExtrinsicPayloadValue)?.assetId;
+
+  if (maybeAsset && isHex(maybeAsset)) {
+    const assetId = registry.createType('TAssetConversion', hexToU8a(maybeAsset));
+
+    // we only want to adjust the payload if the hex passed has the option
+    if (maybeAsset === '0x00' || maybeAsset === '0x01' + assetId.toHex().slice(2)) {
+      return {
+        ...(payload as ExtrinsicPayloadValue),
+        assetId: assetId.toJSON()
+      };
+    }
+  }
+
+  return payload;
+}
+
+/** @internal */
+function decodeExtrinsicPayload (registry: Registry, value?: GenericExtrinsicPayload | ExtrinsicPayloadValue | Uint8Array | string, version = LATEST_EXTRINSIC_VERSION, preamble: Preamble = DEFAULT_PREAMBLE): ExtrinsicPayloadVx {
+  if (value instanceof GenericExtrinsicPayload) {
+    return value.unwrap();
+  }
+
+  const extVersion = version === 5 ? PREAMBLES[preamble] : VERSIONS[version] || VERSIONS[0];
+  const payload = decodeAssetId(registry, value as ExtrinsicPayloadValue);
+
+  return registry.createTypeUnsafe(extVersion, [payload, { version }]);
+}
+
+/**
+ * @name GenericExtrinsicPayload
+ * @description
+ * A signing payload for an [[Extrinsic]]. For the final encoding, it is variable length based
+ * on the contents included
+ */
+export class GenericExtrinsicPayload extends AbstractBase<ExtrinsicPayloadVx> {
+  constructor (registry: Registry, value?: Partial<ExtrinsicPayloadValue> | Uint8Array | string, { preamble, version }: ExtrinsicPayloadOptions = {}) {
+    super(registry, decodeExtrinsicPayload(registry, value as ExtrinsicPayloadValue, version, preamble));
+  }
+
+  /**
+   * @description The block [[BlockHash]] the signature applies to (mortal/immortal)
+   */
+  public get blockHash (): BlockHash {
+    return this.inner.blockHash;
+  }
+
+  /**
+   * @description The [[ExtrinsicEra]]
+   */
+  public get era (): GenericExtrinsicEra {
+    return this.inner.era;
+  }
+
+  /**
+   * @description The genesis block [[BlockHash]] the signature applies to
+   */
+  public get genesisHash (): BlockHash {
+    // NOTE only v3+
+    return this.inner.genesisHash || this.registry.createTypeUnsafe('Hash', []);
+  }
+
+  /**
+   * @description The [[Bytes]] contained in the payload
+   */
+  public get method (): Bytes {
+    return this.inner.method;
+  }
+
+  /**
+   * @description The [[Index]]
+   */
+  public get nonce (): ICompact<INumber> {
+    return this.inner.nonce;
+  }
+
+  /**
+   * @description The specVersion as a [[u32]] for this payload
+   */
+  public get specVersion (): INumber {
+    // NOTE only v3+
+    return this.inner.specVersion || this.registry.createTypeUnsafe('u32', []);
+  }
+
+  /**
+   * @description The [[Balance]]
+   */
+  public get tip (): ICompact<INumber> {
+    // NOTE from v2+
+    return this.inner.tip || this.registry.createTypeUnsafe('Compact<Balance>', []);
+  }
+
+  /**
+   * @description The transaction version as a [[u32]] for this payload
+   */
+  public get transactionVersion (): INumber {
+    // NOTE only v4+
+    return this.inner.transactionVersion || this.registry.createTypeUnsafe('u32', []);
+  }
+
+  /**
+   * @description The (optional) asset id as a [[u32]] or [[MultiLocation]] for this payload
+   */
+  public get assetId (): IOption<INumber | MultiLocation> {
+    return this.inner.assetId;
+  }
+
+  /**
+   * @description The (optional) [[Hash]] of the genesis metadata for this payload
+   */
+  public get metadataHash (): IOption<Hash> {
+    return this.inner.metadataHash;
+  }
+
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+  public override eq (other?: unknown): boolean {
+    return this.inner.eq(other);
+  }
+
+  /**
+   * @description Sign the payload with the keypair
+   */
+  public sign (signerPair: IKeyringPair): { signature: HexString } {
+    const signature = this.inner.sign(signerPair);
+
+    // This is extensible, so we could quite readily extend to send back extra
+    // information, such as for instance the payload, i.e. `payload: this.toHex()`
+    // For the case here we sign via the extrinsic, we ignore the return, so generally
+    // this is applicable for external signing
+    return {
+      signature: u8aToHex(signature)
+    };
+  }
+
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  public override toHuman (isExtended?: boolean, disableAscii?: boolean): AnyJson {
+    return this.inner.toHuman(isExtended, disableAscii);
+  }
+
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+  public override toJSON (): any {
+    return this.toHex();
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public toRawType (): string {
+    return 'ExtrinsicPayload';
+  }
+
+  /**
+   * @description Returns the string representation of the value
+   */
+  public override toString (): string {
+    return this.toHex();
+  }
+
+  /**
+   * @description Returns a serialized u8a form
+   */
+  public override toU8a (isBare?: BareOpts): Uint8Array {
+    // call our parent, with only the method stripped
+    return super.toU8a(isBare ? { method: true } : false);
+  }
+}

package/src/extrinsic/ExtrinsicPayloadUnknown.ts

@@ -0,0 +1,20 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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 class GenericExtrinsicPayloadUnknown extends Struct {
+  constructor (registry: Registry, _value?: unknown, { version = 0 }: Partial<ExtrinsicPayloadOptions> = {}) {
+    super(registry, {});
+
+    throw new Error(`Unsupported extrinsic payload version ${version}`);
+  }
+}

package/src/extrinsic/ExtrinsicUnknown.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { ExtrinsicOptions } from './types.js';
+
+import { Struct } from '@pezkuwi/types-codec';
+
+import { UNMASK_VERSION } from './constants.js';
+
+/**
+ * @name GenericExtrinsicUnknown
+ * @description
+ * A default handler for extrinsics where the version is not known (default throw)
+ */
+export class GenericExtrinsicUnknown extends Struct {
+  constructor (registry: Registry, _value?: unknown, { isSigned = false, version = 0 }: Partial<ExtrinsicOptions> = {}) {
+    super(registry, {});
+
+    throw new Error(`Unsupported ${isSigned ? '' : 'un'}signed extrinsic version ${version & UNMASK_VERSION}`);
+  }
+}