@pezkuwi/types 16.5.5

package/src/extrinsic/v4/ExtrinsicSignature.ts

@@ -0,0 +1,229 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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 { isU8a, isUndefined, objectProperties, objectSpread, stringify, u8aToHex } from '@pezkuwi/util';
+
+import { EMPTY_U8A, IMMORTAL_ERA } from '../constants.js';
+import { GenericExtrinsicPayloadV4 } from './ExtrinsicPayload.js';
+
+// Ensure we have enough data for all types of signatures
+const FAKE_SIGNATURE = new Uint8Array(256).fill(1);
+
+function toAddress (registry: Registry, address: Address | Uint8Array | string): Address {
+  return registry.createTypeUnsafe('Address', [isU8a(address) ? u8aToHex(address) : address]);
+}
+
+/**
+ * @name GenericExtrinsicSignatureV4
+ * @description
+ * A container for the [[Signature]] associated with a specific [[Extrinsic]]
+ */
+export class GenericExtrinsicSignatureV4 extends Struct implements IExtrinsicSignature {
+  #signKeys: string[];
+
+  constructor (registry: Registry, value?: GenericExtrinsicSignatureV4 | Uint8Array, { isSigned }: ExtrinsicSignatureOptions = {}) {
+    const signTypes = registry.getSignedExtensionTypes();
+
+    super(
+      registry,
+      objectSpread(
+        // eslint-disable-next-line sort-keys
+        { signer: 'Address', signature: 'ExtrinsicSignature' },
+        signTypes
+      ),
+      GenericExtrinsicSignatureV4.decodeExtrinsicSignature(value, isSigned)
+    );
+
+    this.#signKeys = Object.keys(signTypes);
+
+    objectProperties(this, this.#signKeys, (k) => this.get(k));
+  }
+
+  /** @internal */
+  public static decodeExtrinsicSignature (value?: GenericExtrinsicSignatureV4 | Uint8Array, isSigned = false): GenericExtrinsicSignatureV4 | Uint8Array {
+    if (!value) {
+      return EMPTY_U8A;
+    } else if (value instanceof GenericExtrinsicSignatureV4) {
+      return value;
+    }
+
+    return isSigned
+      ? value
+      : EMPTY_U8A;
+  }
+
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+  public override get encodedLength (): number {
+    return this.isSigned
+      ? super.encodedLength
+      : 0;
+  }
+
+  /**
+   * @description `true` if the signature is valid
+   */
+  public get isSigned (): boolean {
+    return !this.signature.isEmpty;
+  }
+
+  /**
+   * @description The [[ExtrinsicEra]] (mortal or immortal) this signature applies to
+   */
+  public get era (): ExtrinsicEra {
+    return this.getT('era');
+  }
+
+  /**
+   * @description The [[Index]] for the signature
+   */
+  public get nonce (): ICompact<INumber> {
+    return this.getT('nonce');
+  }
+
+  /**
+   * @description The actual [[EcdsaSignature]], [[Ed25519Signature]] or [[Sr25519Signature]]
+   */
+  public get signature (): EcdsaSignature | Ed25519Signature | Sr25519Signature {
+    // the second case here is when we don't have an enum signature, treat as raw
+    return (this.multiSignature.value || this.multiSignature) as Sr25519Signature;
+  }
+
+  /**
+   * @description The raw [[ExtrinsicSignature]]
+   */
+  public get multiSignature (): ExtrinsicSignature {
+    return this.getT('signature');
+  }
+
+  /**
+   * @description The [[Address]] that signed
+   */
+  public get signer (): Address {
+    return this.getT('signer');
+  }
+
+  /**
+   * @description The [[Balance]] tip
+   */
+  public get tip (): ICompact<INumber> {
+    return this.getT('tip');
+  }
+
+  /**
+   * @description The [[u32]] or [[MultiLocation]] assetId
+   */
+  public get assetId (): IOption<INumber | MultiLocation> {
+    return this.getT('assetId');
+  }
+
+  /**
+   * @description the [[u32]] mode
+   */
+  public get mode (): INumber {
+    return this.getT('mode');
+  }
+
+  /**
+   * @description The [[Hash]] for the metadata
+   */
+  public get metadataHash (): IOption<Hash> {
+    return this.getT('metadataHash');
+  }
+
+  protected _injectSignature (signer: Address, signature: ExtrinsicSignature, payload: GenericExtrinsicPayloadV4): IExtrinsicSignature {
+    // use the fields exposed to guide the getters
+    for (let i = 0, count = this.#signKeys.length; i < count; i++) {
+      const k = this.#signKeys[i];
+      const v = payload.get(k);
+
+      if (!isUndefined(v)) {
+        this.set(k, v);
+      }
+    }
+
+    // additional fields (exposed in struct itself)
+    this.set('signer', signer);
+    this.set('signature', signature);
+
+    return this;
+  }
+
+  /**
+   * @description Adds a raw signature
+   */
+  public addSignature (signer: Address | Uint8Array | string, signature: Uint8Array | HexString, payload: ExtrinsicPayloadValue | Uint8Array | HexString): IExtrinsicSignature {
+    return this._injectSignature(
+      toAddress(this.registry, signer),
+      this.registry.createTypeUnsafe('ExtrinsicSignature', [signature]),
+      new GenericExtrinsicPayloadV4(this.registry, payload)
+    );
+  }
+
+  /**
+   * @description Creates a payload from the supplied options
+   */
+  public createPayload (method: Call, options: SignatureOptions): GenericExtrinsicPayloadV4 {
+    const { era, runtimeVersion: { specVersion, transactionVersion } } = options;
+
+    return new GenericExtrinsicPayloadV4(this.registry, objectSpread<ExtrinsicPayloadValue>({}, options, {
+      era: era || IMMORTAL_ERA,
+      method: method.toHex(),
+      specVersion,
+      transactionVersion
+    }));
+  }
+
+  /**
+   * @description Generate a payload and applies the signature from a keypair
+   */
+  public sign (method: Call, account: IKeyringPair, options: SignatureOptions): IExtrinsicSignature {
+    if (!account?.addressRaw) {
+      throw new Error(`Expected a valid keypair for signing, found ${stringify(account)}`);
+    }
+
+    const payload = this.createPayload(method, options);
+
+    return this._injectSignature(
+      toAddress(this.registry, account.addressRaw),
+      this.registry.createTypeUnsafe('ExtrinsicSignature', [payload.sign(account)]),
+      payload
+    );
+  }
+
+  /**
+   * @description Generate a payload and applies a fake signature
+   */
+  public signFake (method: Call, address: Address | Uint8Array | string, options: SignatureOptions): IExtrinsicSignature {
+    if (!address) {
+      throw new Error(`Expected a valid address for signing, found ${stringify(address)}`);
+    }
+
+    const payload = this.createPayload(method, options);
+
+    return this._injectSignature(
+      toAddress(this.registry, address),
+      this.registry.createTypeUnsafe('ExtrinsicSignature', [FAKE_SIGNATURE]),
+      payload
+    );
+  }
+
+  /**
+   * @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)
+   */
+  public override toU8a (isBare?: boolean): Uint8Array {
+    return this.isSigned
+      ? super.toU8a(isBare)
+      : EMPTY_U8A;
+  }
+}

package/src/extrinsic/v4/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { GenericExtrinsicV4 } from './Extrinsic.js';
+export { GenericExtrinsicPayloadV4 } from './ExtrinsicPayload.js';
+export { GenericExtrinsicSignatureV4 } from './ExtrinsicSignature.js';

package/src/extrinsic/v5/Extrinsic.spec.ts

@@ -0,0 +1,74 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { createTestPairs } from '@pezkuwi/keyring/testingPairs';
+import rpcMetadata from '@pezkuwi/types-support/metadata/static-substrate';
+import { BN } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../../create/index.js';
+import { decorateExtrinsics, Metadata } from '../../metadata/index.js';
+import { GenericExtrinsicV5 as Extrinsic } from './index.js';
+
+const registry = new TypeRegistry();
+const metadata = new Metadata(registry, rpcMetadata);
+const keyring = createTestPairs({ type: 'ed25519' }, false);
+
+registry.setMetadata(metadata);
+
+const tx = decorateExtrinsics(registry, metadata.asLatest, metadata.version);
+
+describe('ExtrinsicV5', (): void => {
+  it('constructs a sane Uint8Array (default)', (): void => {
+    const xt = new Extrinsic(registry);
+
+    // expect(`${xt.method.section}${xt.method.method}`).toEqual('system.fillBlock');
+    expect(`${xt.method.section}.${xt.method.method}`).toEqual('system.remark');
+
+    expect(xt.toU8a()).toEqual(new Uint8Array([
+      0, 0, // index
+      // 0, 0, 0, 0 // fillBlock, Perbill
+      0 // remark, Vec<u8>
+    ]));
+  });
+
+  it('creates a unsigned extrinsic', (): void => {
+    expect(
+      new Extrinsic(
+        registry,
+        tx['balances']['transferAllowDeath'](keyring.bob.publicKey, 6969n)
+      ).toHex()
+    ).toEqual(
+      '0x' +
+      '0600' + // balance.transferAllowDeath
+      '00' +
+      'd7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9' +
+      'e56c'
+    );
+  });
+
+  it('Errors when creating a signed Extrinsic', (): void => {
+    expect(
+      () => new Extrinsic(
+        registry,
+        tx['balances']['transferAllowDeath'](keyring.bob.publicKey, 6969n)
+      ).sign(keyring.alice, {
+        blockHash: '0xec7afaf1cca720ce88c1d1b689d81f0583cc15a97d621cf046dd9abf605ef22f',
+        genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
+        mode: 0,
+        nonce: 1,
+        runtimeVersion: {
+          apis: [],
+          authoringVersion: new BN(123),
+          implName: 'test',
+          implVersion: new BN(123),
+          specName: 'test',
+          specVersion: new BN(123),
+          transactionVersion: new BN(123)
+        },
+        tip: 2
+      }).toHex()
+    ).toThrow('Extrinsic: ExtrinsicV5 does not include signing support');
+  });
+});

package/src/extrinsic/v5/Extrinsic.ts

@@ -0,0 +1,116 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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';
+import { isU8a } from '@pezkuwi/util';
+
+export const EXTRINSIC_VERSION = 5;
+
+export interface ExtrinsicValueV5 {
+  method?: Call;
+  signature?: ExtrinsicSignatureV5;
+}
+
+/**
+ * @name GenericExtrinsicV5
+ * @description
+ * The fourth generation of compact extrinsics
+ */
+export class GenericExtrinsicV5 extends Struct implements IExtrinsicV5Impl {
+  constructor (registry: Registry, value?: Uint8Array | ExtrinsicValueV5 | Call, { isSigned }: Partial<ExtrinsicOptions> = {}) {
+    super(registry, {
+      signature: 'ExtrinsicSignatureV5',
+      // eslint-disable-next-line sort-keys
+      method: 'Call'
+    }, GenericExtrinsicV5.decodeExtrinsic(registry, value, isSigned));
+  }
+
+  /** @internal */
+  public static decodeExtrinsic (registry: Registry, value?: Call | Uint8Array | ExtrinsicValueV5, isSigned = false): ExtrinsicValueV5 {
+    if (value instanceof GenericExtrinsicV5) {
+      return value;
+    } else if (value instanceof registry.createClassUnsafe<Call>('Call')) {
+      return { method: value };
+    } else if (isU8a(value)) {
+      // here we decode manually since we need to pull through the version information
+      const signature = registry.createTypeUnsafe<ExtrinsicSignatureV5>('ExtrinsicSignatureV5', [value, { isSigned }]);
+      // We add 2 here since the length of the TransactionExtension Version needs to be accounted for
+      const method = registry.createTypeUnsafe<Call>('Call', [value.subarray(signature.encodedLength)]);
+
+      return {
+        method,
+        signature
+      };
+    }
+
+    return value || {};
+  }
+
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+  public override get encodedLength (): number {
+    return this.toU8a().length;
+  }
+
+  /**
+   * @description The [[Call]] this extrinsic wraps
+   */
+  public get method (): Call {
+    return this.getT('method');
+  }
+
+  /**
+   * @description The [[ExtrinsicSignatureV5]]
+   */
+  public get signature (): ExtrinsicSignatureV5 {
+    return this.getT('signature');
+  }
+
+  /**
+   * @description The version for the signature
+   */
+  public get version (): number {
+    return EXTRINSIC_VERSION;
+  }
+
+  /**
+   * @description The [[Preamble]] for the extrinsic
+   */
+  public get preamble (): Preamble {
+    return this.getT('preamble');
+  }
+
+  /**
+   * @description Add an [[ExtrinsicSignatureV5]] to the extrinsic (already generated)
+   *
+   * [Disabled for ExtrinsicV5]
+   */
+  public addSignature (_signer: Address | Uint8Array | string, _signature: Uint8Array | HexString, _payload: ExtrinsicPayloadValue | Uint8Array | HexString): GenericExtrinsicV5 {
+    throw new Error('Extrinsic: ExtrinsicV5 does not include signing support');
+  }
+
+  /**
+   * @description Sign the extrinsic with a specific keypair
+   *
+   * [Disabled for ExtrinsicV5]
+   */
+  public sign (_account: IKeyringPair, _options: SignatureOptions): GenericExtrinsicV5 {
+    throw new Error('Extrinsic: ExtrinsicV5 does not include signing support');
+  }
+
+  /**
+   * @describe Adds a fake signature to the extrinsic
+   *
+   * [Disabled for ExtrinsicV5]
+   */
+  public signFake (_signer: Address | Uint8Array | string, _options: SignatureOptions): GenericExtrinsicV5 {
+    throw new Error('Extrinsic: ExtrinsicV5 does not include signing support');
+  }
+}

package/src/extrinsic/v5/ExtrinsicPayload.spec.ts

@@ -0,0 +1,39 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import rpcMetadata from '@pezkuwi/types-support/metadata/static-substrate';
+
+import { TypeRegistry } from '../../create/index.js';
+import { decorateExtrinsics, Metadata } from '../../metadata/index.js';
+import { GenericExtrinsicPayloadV5 as ExtrinsicPayload } from './index.js';
+
+const registry = new TypeRegistry();
+const metadata = new Metadata(registry, rpcMetadata);
+
+registry.setMetadata(metadata);
+
+const tx = decorateExtrinsics(registry, metadata.asLatest, metadata.version);
+
+describe('ExtrinsicPayload', (): void => {
+  it('has a sane inspect', (): void => {
+    // we don't expect this to fail, however it is actually a good
+    // reference for the ordering in base Substrate
+    expect(new ExtrinsicPayload(registry, { method: tx['timestamp']['set'](0).toHex() } as never).inspect()).toEqual({
+      inner: [
+        { name: 'method', outer: [new Uint8Array([3, 0, 0])] },
+        { 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: 'mode', outer: [new Uint8Array([0])] },
+        { name: 'specVersion', outer: [new Uint8Array([0, 0, 0, 0])] },
+        { name: 'transactionVersion', outer: [new Uint8Array([0, 0, 0, 0])] },
+        { name: 'genesisHash', outer: [new Uint8Array(32)] },
+        { name: 'blockHash', outer: [new Uint8Array(32)] },
+        { name: 'metadataHash', outer: [new Uint8Array([0])] }
+      ]
+    });
+  });
+});

package/src/extrinsic/v5/ExtrinsicPayload.ts

@@ -0,0 +1,115 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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';
+import { objectSpread } from '@pezkuwi/util';
+
+/**
+ * @name GenericExtrinsicPayloadV5
+ * @description
+ * A signing payload for an [[Extrinsic]]. For the final encoding, it is
+ * variable length based on the contents included
+ */
+export class GenericExtrinsicPayloadV5 extends Struct {
+  constructor (registry: Registry, value?: ExtrinsicPayloadValue | Uint8Array | HexString) {
+    super(registry, objectSpread(
+      { method: 'Bytes' },
+      registry.getSignedExtensionTypes(),
+      registry.getSignedExtensionExtra()
+    ), value);
+  }
+
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+  public override inspect (): Inspect {
+    return super.inspect({ method: true });
+  }
+
+  /**
+   * @description The block [[BlockHash]] the signature applies to (mortal/immortal)
+   */
+  public get blockHash (): BlockHash {
+    return this.getT('blockHash');
+  }
+
+  /**
+   * @description The [[ExtrinsicEra]]
+   */
+  public get era (): ExtrinsicEra {
+    return this.getT('era');
+  }
+
+  /**
+   * @description The genesis [[BlockHash]] the signature applies to (mortal/immortal)
+   */
+  public get genesisHash (): BlockHash {
+    return this.getT('genesisHash');
+  }
+
+  /**
+   * @description The [[Bytes]] contained in the payload
+   */
+  public get method (): Bytes {
+    return this.getT('method');
+  }
+
+  /**
+   * @description The [[Index]]
+   */
+  public get nonce (): ICompact<INumber> {
+    return this.getT('nonce');
+  }
+
+  /**
+   * @description The specVersion for this signature
+   */
+  public get specVersion (): INumber {
+    return this.getT('specVersion');
+  }
+
+  /**
+   * @description The tip [[Balance]]
+   */
+  public get tip (): ICompact<INumber> {
+    return this.getT('tip');
+  }
+
+  /**
+   * @description The transactionVersion for this signature
+   */
+  public get transactionVersion (): INumber {
+    return this.getT('transactionVersion');
+  }
+
+  /**
+   * @description The (optional) asset id for this signature for chains that support transaction fees in assets
+   */
+  public get assetId (): IOption<INumber | MultiLocation> {
+    return this.getT('assetId');
+  }
+
+  /**
+   * @description The (optional) metadataHash proof for the CheckMetadataHash TransactionExtension
+   */
+  public get metadataHash (): IOption<Hash> {
+    return this.getT('metadataHash');
+  }
+
+  /**
+   * @description Sign the payload with the keypair
+   *
+   * [Disabled for ExtrinsicV5]
+   */
+  public sign (_signerPair: IKeyringPair): Uint8Array {
+    throw new Error('Extrinsic: ExtrinsicV5 does not include signing support');
+  }
+}

package/src/extrinsic/v5/ExtrinsicSignature.spec.ts

@@ -0,0 +1,105 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { createTestPairs } from '@pezkuwi/keyring/testingPairs';
+import metadataStatic from '@pezkuwi/types-support/metadata/static-substrate';
+import { BN_ZERO } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../../create/index.js';
+import { Metadata } from '../../metadata/index.js';
+import { GenericExtrinsicSignatureV5 as ExtrinsicSignature } from './index.js';
+
+const signOptions = {
+  blockHash: '0x1234567890123456789012345678901234567890123456789012345678901234',
+  genesisHash: '0x1234567890123456789012345678901234567890123456789012345678901234',
+  nonce: '0x69',
+  runtimeVersion: {
+    apis: [],
+    authoringVersion: BN_ZERO,
+    implName: String('test'),
+    implVersion: BN_ZERO,
+    specName: String('test'),
+    specVersion: BN_ZERO,
+    transactionVersion: BN_ZERO
+  }
+};
+
+describe('ExtrinsicSignatureV4', (): void => {
+  const pairs = createTestPairs({ type: 'ed25519' });
+
+  it('encodes to a sane Uint8Array (default)', (): void => {
+    const registry = new TypeRegistry();
+
+    const u8a = new Uint8Array([
+      // signer as an AccountIndex
+      0x01, 0x08, // 4 << 2
+      // signature type
+      0x01,
+      // signature
+      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+      0x00, // TransactionExtension version
+      // extra stuff
+      0x00, // immortal,
+      0x04, // nonce, compact
+      0x08 // tip, compact
+    ]);
+
+    expect(
+      new ExtrinsicSignature(registry, u8a, { isSigned: true }).toU8a()
+    ).toEqual(u8a);
+  });
+
+  it('fake signs default', (): void => {
+    const registry = new TypeRegistry();
+    const metadata = new Metadata(registry, metadataStatic);
+
+    registry.setMetadata(metadata);
+
+    expect(
+      () => new ExtrinsicSignature(registry).signFake(
+        registry.createType('Call'),
+        pairs.alice.publicKey,
+        signOptions
+      ).toHex()
+    ).toThrow('Extrinsic: ExtrinsicV5 does not include signing support');
+  });
+
+  it('Errors on fake sign', (): void => {
+    const registry = new TypeRegistry();
+    const metadata = new Metadata(registry, metadataStatic);
+
+    registry.setMetadata(metadata);
+    registry.register({
+      Address: 'AccountId',
+      ExtrinsicSignature: 'AnySignature'
+    });
+
+    expect(
+      () => new ExtrinsicSignature(registry).signFake(
+        registry.createType('Call'),
+        pairs.alice.address,
+        signOptions
+      ).toHex()
+    ).toThrow('Extrinsic: ExtrinsicV5 does not include signing support');
+  });
+
+  it('Errors on injecting a signature', (): void => {
+    const registry = new TypeRegistry();
+    const metadata = new Metadata(registry, metadataStatic);
+
+    registry.setMetadata(metadata);
+
+    expect(
+      () => new ExtrinsicSignature(registry).addSignature(
+        pairs.alice.publicKey,
+        new Uint8Array(65).fill(1),
+        new Uint8Array(0)
+      ).toHex()
+    ).toThrow('Extrinsic: ExtrinsicV5 does not include signing support');
+  });
+});