@pezkuwi/types 16.5.5

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

@@ -0,0 +1,86 @@
+// 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 { GenericExtrinsicV4 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('ExtrinsicV4', (): 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('creates 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()
+    ).toEqual(
+      '0x' +
+      '00' +
+      'd172a74cda4c865912c32ba0a80a57ae69abae410e5ccb59dee84e2f4432db4f' +
+      '00' + // ed25519
+      'bac8e442c7d6e6827fe3b72a2dee6bd036e059e1b0a2a5cfb00ec39184d60536' +
+      'a4f3b5f3bfcd31e6e5b5cf6482914dc989fbe9483043a13c90376dfe28c5e00f' +
+      '0004080000' + // era. nonce, tip, mode
+      '0600' +
+      '00' +
+      'd7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9' +
+      'e56c'
+    );
+  });
+});

package/src/extrinsic/v4/Extrinsic.ts

@@ -0,0 +1,108 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { HexString } from '@pezkuwi/util/types';
+import type { ExtrinsicSignatureV4 } from '../../interfaces/extrinsics/index.js';
+import type { Address, Call } from '../../interfaces/runtime/index.js';
+import type { ExtrinsicPayloadValue, IExtrinsicImpl, IKeyringPair, Registry, SignatureOptions } from '../../types/index.js';
+import type { ExtrinsicOptions } from '../types.js';
+
+import { Struct } from '@pezkuwi/types-codec';
+import { isU8a } from '@pezkuwi/util';
+
+export const EXTRINSIC_VERSION = 4;
+
+export interface ExtrinsicValueV4 {
+  method?: Call;
+  signature?: ExtrinsicSignatureV4;
+}
+
+/**
+ * @name GenericExtrinsicV4
+ * @description
+ * The third generation of compact extrinsics
+ */
+export class GenericExtrinsicV4 extends Struct implements IExtrinsicImpl {
+  constructor (registry: Registry, value?: Uint8Array | ExtrinsicValueV4 | Call, { isSigned }: Partial<ExtrinsicOptions> = {}) {
+    super(registry, {
+      signature: 'ExtrinsicSignatureV4',
+      // eslint-disable-next-line sort-keys
+      method: 'Call'
+    }, GenericExtrinsicV4.decodeExtrinsic(registry, value, isSigned));
+  }
+
+  /** @internal */
+  public static decodeExtrinsic (registry: Registry, value?: Call | Uint8Array | ExtrinsicValueV4, isSigned = false): ExtrinsicValueV4 {
+    if (value instanceof GenericExtrinsicV4) {
+      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<ExtrinsicSignatureV4>('ExtrinsicSignatureV4', [value, { isSigned }]);
+      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 [[ExtrinsicSignatureV4]]
+   */
+  public get signature (): ExtrinsicSignatureV4 {
+    return this.getT('signature');
+  }
+
+  /**
+   * @description The version for the signature
+   */
+  public get version (): number {
+    return EXTRINSIC_VERSION;
+  }
+
+  /**
+   * @description Add an [[ExtrinsicSignatureV4]] to the extrinsic (already generated)
+   */
+  public addSignature (signer: Address | Uint8Array | string, signature: Uint8Array | HexString, payload: ExtrinsicPayloadValue | Uint8Array | HexString): GenericExtrinsicV4 {
+    this.signature.addSignature(signer, signature, payload);
+
+    return this;
+  }
+
+  /**
+   * @description Sign the extrinsic with a specific keypair
+   */
+  public sign (account: IKeyringPair, options: SignatureOptions): GenericExtrinsicV4 {
+    this.signature.sign(this.method, account, options);
+
+    return this;
+  }
+
+  /**
+   * @describe Adds a fake signature to the extrinsic
+   */
+  public signFake (signer: Address | Uint8Array | string, options: SignatureOptions): GenericExtrinsicV4 {
+    this.signature.signFake(this.method, signer, options);
+
+    return this;
+  }
+}

package/src/extrinsic/v4/ExtrinsicPayload.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 rpcMetadata from '@pezkuwi/types-support/metadata/static-substrate';
+
+import { TypeRegistry } from '../../create/index.js';
+import { decorateExtrinsics, Metadata } from '../../metadata/index.js';
+import { fallbackExtensions } from '../signedExtensions/index.js';
+import { GenericExtrinsicPayloadV4 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])] }
+      ]
+    });
+  });
+
+  it('Correctly decodes assetId', () => {
+    const TEST_VALUE = {
+      address: 'J97drEQy6sYPXf2D1uj1hJfeHsxjvwr4tVGKs9o8VDSht8r',
+      assetId: '0x010002043205011f' as `0x${string}`,
+      blockHash: '0x28a464e6b40fccec3b9e7989db97d2627d3653c644a3c801f8239910eaaa58a8',
+      era: '0x4401',
+      genesisHash: '0x48239ef607d7928874027a43a67689209727dfb3d3dc5e5b03a39bdc2eda771a',
+      method: '0x0a0300d27001b334c34489c67b81dfbbdc86eba5b433163bd08226d89b081914e9aa490284d717',
+      nonce: '0x0000000a',
+      specVersion: '0x000f4dfc',
+      tip: '0x00000000000000000000000000000000',
+      transactionVersion: '0x0000000f'
+    };
+
+    const reg = new TypeRegistry();
+
+    reg.setSignedExtensions(fallbackExtensions.concat(['ChargeAssetTxPayment']));
+    const ext = new ExtrinsicPayload(reg, TEST_VALUE);
+
+    expect(ext.assetId.toJSON()).toEqual({
+      interior: {
+        x2: [
+          {
+            palletInstance: 50
+          },
+          {
+            generalIndex: 1984
+          }
+        ]
+      },
+      parents: 0
+    });
+  });
+});

package/src/extrinsic/v4/ExtrinsicPayload.ts

@@ -0,0 +1,131 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { SignOptions } from '@pezkuwi/keyring/types';
+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 { Enum, Struct } from '@pezkuwi/types-codec';
+import { objectSpread } from '@pezkuwi/util';
+
+import { decodeAssetId } from '../ExtrinsicPayload.js';
+import { sign } from '../util.js';
+
+/**
+ * @name GenericExtrinsicPayloadV4
+ * @description
+ * A signing payload for an [[Extrinsic]]. For the final encoding, it is
+ * variable length based on the contents included
+ */
+export class GenericExtrinsicPayloadV4 extends Struct {
+  #signOptions: SignOptions;
+
+  constructor (registry: Registry, value?: ExtrinsicPayloadValue | Uint8Array | HexString) {
+    super(registry, objectSpread(
+      { method: 'Bytes' },
+      registry.getSignedExtensionTypes(),
+      registry.getSignedExtensionExtra()
+    ), decodeAssetId(registry, value));
+
+    // Do detection for the type of extrinsic, in the case of MultiSignature
+    // this is an enum, in the case of AnySignature, this is a Hash only
+    // (which may be 64 or 65 bytes)
+    this.#signOptions = {
+      withType: registry.createTypeUnsafe('ExtrinsicSignature', []) instanceof Enum
+    };
+  }
+
+  /**
+   * @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) asset id for this signature for chains that support transaction fees in assets
+   */
+  public get metadataHash (): IOption<Hash> {
+    return this.getT('metadataHash');
+  }
+
+  /**
+   * @description Sign the payload with the keypair
+   */
+  public sign (signerPair: IKeyringPair): Uint8Array {
+    // NOTE The `toU8a({ method: true })` argument is absolutely critical, we
+    // don't want the method (Bytes) to have the length prefix included. This
+    // means that the data-as-signed is un-decodable, but is also doesn't need
+    // the extra information, only the pure data (and is not decoded) ...
+    // The same applies to V1..V3, if we have a V5, carry this comment
+    return sign(this.registry, signerPair, this.toU8a({ method: true }), this.#signOptions);
+  }
+}

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

@@ -0,0 +1,160 @@
+// 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 { GenericExtrinsicSignatureV4 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,
+      // 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()
+    ).toEqual(
+      '0x' +
+      '00' + // MultiAddress
+      'd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d' +
+      '01' +
+      '0101010101010101010101010101010101010101010101010101010101010101' +
+      '0101010101010101010101010101010101010101010101010101010101010101' +
+      '00a5010000' +
+      '00' // Mode
+    );
+  });
+
+  it('fake signs default (AccountId address)', (): 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()
+    ).toEqual(
+      '0x' +
+      // Address = AccountId, no prefix
+      'd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d' +
+      // This is a prefix-less signature, anySignture as opposed to Multi above
+      '0101010101010101010101010101010101010101010101010101010101010101' +
+      '0101010101010101010101010101010101010101010101010101010101010101' +
+      '00a5010000' +
+      '00' // mode
+    );
+  });
+
+  it('fake signs with non-enum signature', (): void => {
+    const registry = new TypeRegistry();
+    const metadata = new Metadata(registry, metadataStatic);
+
+    registry.setMetadata(metadata);
+    registry.register({
+      Address: 'AccountId',
+      ExtrinsicSignature: '[u8;65]'
+    });
+
+    expect(
+      new ExtrinsicSignature(registry).signFake(
+        registry.createType('Call'),
+        pairs.alice.address,
+        signOptions
+      ).toHex()
+    ).toEqual(
+      '0x' +
+      // Address = AccountId, no prefix
+      'd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d' +
+      // 65 bytes here
+      '01' +
+      '0101010101010101010101010101010101010101010101010101010101010101' +
+      '0101010101010101010101010101010101010101010101010101010101010101' +
+      '00a5010000' +
+      '00' // mode
+    );
+  });
+
+  it('injects 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()
+    ).toEqual(
+      '0x' +
+      '00' + // MultiAddress
+      'd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d' +
+      '01' +
+      '0101010101010101010101010101010101010101010101010101010101010101' +
+      '0101010101010101010101010101010101010101010101010101010101010101' +
+      '00000000' +
+      '00' // mode
+    );
+  });
+});