TransactionExtension, ExtrinsicV5

packages/types-augment/src/registry/interfaces.ts

@@ -35,7 +35,7 @@ import type { ApprovalFlag, DefunctVoter, Renouncing, SetIndex, Vote, VoteIndex,
 import type { CreatedBlock, ImportedAux } from '@polkadot/types/interfaces/engine';
 import type { BlockV0, BlockV1, BlockV2, EIP1559Transaction, EIP2930Transaction, EthAccessList, EthAccessListItem, EthAccount, EthAddress, EthBlock, EthBloom, EthCallRequest, EthFeeHistory, EthFilter, EthFilterAddress, EthFilterChanges, EthFilterTopic, EthFilterTopicEntry, EthFilterTopicInner, EthHeader, EthLog, EthReceipt, EthReceiptV0, EthReceiptV3, EthRichBlock, EthRichHeader, EthStorageProof, EthSubKind, EthSubParams, EthSubResult, EthSyncInfo, EthSyncStatus, EthTransaction, EthTransactionAction, EthTransactionCondition, EthTransactionRequest, EthTransactionSignature, EthTransactionStatus, EthWork, EthereumAccountId, EthereumAddress, EthereumLookupSource, EthereumSignature, LegacyTransaction, TransactionV0, TransactionV1, TransactionV2 } from '@polkadot/types/interfaces/eth';
 import type { EvmAccount, EvmCallInfo, EvmCallInfoV2, EvmCreateInfo, EvmCreateInfoV2, EvmLog, EvmVicinity, EvmWeightInfo, ExitError, ExitFatal, ExitReason, ExitRevert, ExitSucceed } from '@polkadot/types/interfaces/evm';
-import type { AnySignature, EcdsaSignature, Ed25519Signature, Era, Extrinsic, ExtrinsicEra, ExtrinsicPayload, ExtrinsicPayloadUnknown, ExtrinsicPayloadV4, ExtrinsicSignature, ExtrinsicSignatureV4, ExtrinsicUnknown, ExtrinsicV4, ImmortalEra, MortalEra, MultiSignature, Signature, SignerPayload, Sr25519Signature } from '@polkadot/types/interfaces/extrinsics';
+import type { AnySignature, EcdsaSignature, Ed25519Signature, Era, Extrinsic, ExtrinsicEra, ExtrinsicPayload, ExtrinsicPayloadUnknown, ExtrinsicPayloadV4, ExtrinsicPayloadV5, ExtrinsicSignature, ExtrinsicSignatureV4, ExtrinsicSignatureV5, ExtrinsicUnknown, ExtrinsicV4, ExtrinsicV5, ImmortalEra, MortalEra, MultiSignature, Signature, SignerPayload, Sr25519Signature } from '@polkadot/types/interfaces/extrinsics';
 import type { FungiblesAccessError } from '@polkadot/types/interfaces/fungibles';
 import type { AssetOptions, Owner, PermissionLatest, PermissionVersions, PermissionsV1 } from '@polkadot/types/interfaces/genericAsset';
 import type { GenesisBuildErr } from '@polkadot/types/interfaces/genesisBuilder';
@@ -504,12 +504,15 @@ declare module '@polkadot/types/types/registry' {
     ExtrinsicPayload: ExtrinsicPayload;
     ExtrinsicPayloadUnknown: ExtrinsicPayloadUnknown;
     ExtrinsicPayloadV4: ExtrinsicPayloadV4;
+    ExtrinsicPayloadV5: ExtrinsicPayloadV5;
     ExtrinsicSignature: ExtrinsicSignature;
     ExtrinsicSignatureV4: ExtrinsicSignatureV4;
+    ExtrinsicSignatureV5: ExtrinsicSignatureV5;
     ExtrinsicStatus: ExtrinsicStatus;
     ExtrinsicsWeight: ExtrinsicsWeight;
     ExtrinsicUnknown: ExtrinsicUnknown;
     ExtrinsicV4: ExtrinsicV4;
+    ExtrinsicV5: ExtrinsicV5;
     f32: f32;
     F32: F32;
     f64: f64;

packages/types/src/extrinsic/Extrinsic.ts

@@ -3,69 +3,84 @@
 
 import type { AnyJson, AnyTuple, AnyU8a, ArgsDef, IMethod, Inspect, IOption } from '@polkadot/types-codec/types';
 import type { HexString } from '@polkadot/util/types';
-import type { EcdsaSignature, Ed25519Signature, ExtrinsicUnknown, ExtrinsicV4, Sr25519Signature } from '../interfaces/extrinsics/index.js';
+import type { EcdsaSignature, Ed25519Signature, ExtrinsicUnknown, ExtrinsicV5, Sr25519Signature } from '../interfaces/extrinsics/index.js';
 import type { FunctionMetadataLatest } from '../interfaces/metadata/index.js';
 import type { Address, Call, CodecHash, Hash } from '../interfaces/runtime/index.js';
 import type { MultiLocation } from '../interfaces/types.js';
 import type { CallBase, ExtrinsicPayloadValue, ICompact, IExtrinsic, IKeyringPair, INumber, Registry, SignatureOptions } from '../types/index.js';
 import type { GenericExtrinsicEra } from './ExtrinsicEra.js';
-import type { ExtrinsicValueV4 } from './v4/Extrinsic.js';
+import type { Preamble } from './types.js';
+import type { ExtrinsicValueV5 } from './v5/Extrinsic.js';
 
 import { AbstractBase } from '@polkadot/types-codec';
 import { compactAddLength, compactFromU8a, compactToU8a, isHex, isU8a, objectProperty, objectSpread, u8aConcat, u8aToHex, u8aToU8a } from '@polkadot/util';
 
-import { EXTRINSIC_VERSION as LATEST_EXTRINSIC_VERSION } from './v4/Extrinsic.js';
-import { BIT_SIGNED, BIT_UNSIGNED, DEFAULT_VERSION, UNMASK_VERSION } from './constants.js';
+import { BARE_EXTRINSIC, BIT_SIGNED, BIT_UNSIGNED, DEFAULT_PREAMBLE, GENERAL_EXTRINSIC, LATEST_EXTRINSIC_VERSION, LOWEST_SUPPORTED_EXTRINSIC_FORMAT_VERSION, SIGNED_EXTRINSIC, UNMASK_VERSION } from './constants.js';
 
 interface CreateOptions {
   version?: number;
+  preamble?: Preamble;
 }
 
 // NOTE The following 2 types, as well as the VERSION structure and the latest export
 // is to be changed with the addition of a new extrinsic version
 
-type ExtrinsicVx = ExtrinsicV4;
-type ExtrinsicValue = ExtrinsicValueV4;
+type ExtrinsicVx = ExtrinsicV5;
+type ExtrinsicValue = ExtrinsicValueV5;
 
 const VERSIONS = [
   'ExtrinsicUnknown', // v0 is unknown
   'ExtrinsicUnknown',
   'ExtrinsicUnknown',
   'ExtrinsicUnknown',
-  'ExtrinsicV4'
+  'ExtrinsicV4',
+  'ExtrinsicV5'
 ];
 
+const PREAMBLE = {
+  bare: 'ExtrinsicV5',
+  // Not supported yet
+  general: 'ExtrinsicV5',
+  signed: 'ExtrinsicV5'
+};
+
+const PreambleMask = {
+  bare: BARE_EXTRINSIC,
+  general: GENERAL_EXTRINSIC,
+  signed: SIGNED_EXTRINSIC
+};
+
 export { LATEST_EXTRINSIC_VERSION };
 
 /** @internal */
-function newFromValue (registry: Registry, value: any, version: number): ExtrinsicVx | ExtrinsicUnknown {
+function newFromValue (registry: Registry, value: any, version: number, preamble: Preamble): ExtrinsicVx | ExtrinsicUnknown {
   if (value instanceof GenericExtrinsic) {
     return value.unwrap();
   }
 
   const isSigned = (version & BIT_SIGNED) === BIT_SIGNED;
-  const type = VERSIONS[version & UNMASK_VERSION] || VERSIONS[0];
+  const type = (version & UNMASK_VERSION) === 5 ? PREAMBLE[preamble] : VERSIONS[version & UNMASK_VERSION] || VERSIONS[0];
 
   // we cast here since the VERSION definition is incredibly broad - we don't have a
   // slice for "only add extrinsic types", and more string definitions become unwieldy
   return registry.createTypeUnsafe(type, [value, { isSigned, version }]);
 }
 
 /** @internal */
-function decodeExtrinsic (registry: Registry, value?: GenericExtrinsic | ExtrinsicValue | AnyU8a | Call, version: number = DEFAULT_VERSION): ExtrinsicVx | ExtrinsicUnknown {
+function decodeExtrinsic (registry: Registry, value?: GenericExtrinsic | ExtrinsicValue | AnyU8a | Call, version: number = LOWEST_SUPPORTED_EXTRINSIC_FORMAT_VERSION, preamble: Preamble = DEFAULT_PREAMBLE): ExtrinsicVx | ExtrinsicUnknown {
   if (isU8a(value) || Array.isArray(value) || isHex(value)) {
-    return decodeU8a(registry, u8aToU8a(value), version);
+    return decodeU8a(registry, u8aToU8a(value), version, preamble);
   } else if (value instanceof registry.createClassUnsafe('Call')) {
-    return newFromValue(registry, { method: value }, version);
+    return newFromValue(registry, { method: value }, version, preamble);
   }
 
-  return newFromValue(registry, value, version);
+  return newFromValue(registry, value, version, preamble);
 }
 
 /** @internal */
-function decodeU8a (registry: Registry, value: Uint8Array, version: number): ExtrinsicVx | ExtrinsicUnknown {
+function decodeU8a (registry: Registry, value: Uint8Array, version: number, preamble: Preamble): ExtrinsicVx | ExtrinsicUnknown {
   if (!value.length) {
-    return newFromValue(registry, new Uint8Array(), version);
+    return newFromValue(registry, new Uint8Array(), version, preamble);
   }
 
   const [offset, length] = compactFromU8a(value);
@@ -77,11 +92,13 @@ function decodeU8a (registry: Registry, value: Uint8Array, version: number): Ext
 
   const data = value.subarray(offset, total);
 
-  return newFromValue(registry, data.subarray(1), data[0]);
+  return newFromValue(registry, data.subarray(1), data[0], preamble);
 }
 
 abstract class ExtrinsicBase<A extends AnyTuple> extends AbstractBase<ExtrinsicVx | ExtrinsicUnknown> {
-  constructor (registry: Registry, value: ExtrinsicV4 | ExtrinsicUnknown, initialU8aLength?: number) {
+  readonly #preamble: Preamble;
+
+  constructor (registry: Registry, value: ExtrinsicV5 | ExtrinsicUnknown, initialU8aLength?: number, preamble?: Preamble) {
     super(registry, value, initialU8aLength);
 
     const signKeys = Object.keys(registry.getSignedExtensionTypes());
@@ -92,6 +109,8 @@ abstract class ExtrinsicBase<A extends AnyTuple> extends AbstractBase<ExtrinsicV
     for (let i = 0, count = signKeys.length; i < count; i++) {
       objectProperty(this, signKeys[i], getter);
     }
+
+    this.#preamble = preamble || DEFAULT_PREAMBLE;
   }
 
   /**
@@ -228,7 +247,11 @@ abstract class ExtrinsicBase<A extends AnyTuple> extends AbstractBase<ExtrinsicV
    * @description Returns the encoded version flag
   */
   public get version (): number {
-    return this.type | (this.isSigned ? BIT_SIGNED : BIT_UNSIGNED);
+    if (this.type <= LOWEST_SUPPORTED_EXTRINSIC_FORMAT_VERSION) {
+      return this.type | (this.isSigned ? BIT_SIGNED : BIT_UNSIGNED);
+    } else {
+      return this.type | PreambleMask[this.#preamble];
+    }
   }
 
   /**
@@ -260,8 +283,8 @@ export class GenericExtrinsic<A extends AnyTuple = AnyTuple> extends ExtrinsicBa
 
   static LATEST_EXTRINSIC_VERSION = LATEST_EXTRINSIC_VERSION;
 
-  constructor (registry: Registry, value?: GenericExtrinsic | ExtrinsicValue | AnyU8a | Call, { version }: CreateOptions = {}) {
-    super(registry, decodeExtrinsic(registry, value, version));
+  constructor (registry: Registry, value?: GenericExtrinsic | ExtrinsicValue | AnyU8a | Call, { preamble, version }: CreateOptions = {}) {
+    super(registry, decodeExtrinsic(registry, value, version || registry.metadata.extrinsic.version?.toNumber(), preamble), undefined, preamble);
   }
 
   /**

packages/types/src/extrinsic/ExtrinsicPayload.ts

@@ -5,37 +5,49 @@ import type { Bytes } from '@polkadot/types-codec';
 import type { AnyJson, BareOpts, Registry } from '@polkadot/types-codec/types';
 import type { HexString } from '@polkadot/util/types';
 import type { BlockHash } from '../interfaces/chain/index.js';
-import type { ExtrinsicPayloadV4 } from '../interfaces/extrinsics/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 '@polkadot/types-codec';
 import { hexToU8a, isHex, u8aToHex } from '@polkadot/util';
 
-import { DEFAULT_VERSION } from './constants.js';
+import { DEFAULT_PREAMBLE, LATEST_EXTRINSIC_VERSION } from './constants.js';
 
 interface ExtrinsicPayloadOptions {
   version?: number;
+  pramble?: Preamble;
 }
 
 // all our known types that can be returned
-type ExtrinsicPayloadVx = ExtrinsicPayloadV4;
+type ExtrinsicPayloadVx = ExtrinsicPayloadV5;
 
 const VERSIONS = [
   'ExtrinsicPayloadUnknown', // v0 is unknown
   'ExtrinsicPayloadUnknown',
   'ExtrinsicPayloadUnknown',
   'ExtrinsicPayloadUnknown',
-  'ExtrinsicPayloadV4'
+  'ExtrinsicPayloadV4',
+  'ExtrinsicPayloadV5'
 ];
 
+const PREAMBLES = {
+  bare: 'ExtrinsicPayloadV5',
+  // Not supported yet
+  general: 'ExtrinsicPayloadV5',
+  signed: 'ExtrinsicPayloadV5'
+};
+
 /** @internal */
-function decodeExtrinsicPayload (registry: Registry, value?: GenericExtrinsicPayload | ExtrinsicPayloadValue | Uint8Array | string, version: number = DEFAULT_VERSION): ExtrinsicPayloadVx {
+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];
+
   /**
    * 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
@@ -51,10 +63,10 @@ function decodeExtrinsicPayload (registry: Registry, value?: GenericExtrinsicPay
       assetId: registry.createType('TAssetConversion', hexToU8a((value as ExtrinsicPayloadValue).assetId)).toJSON()
     };
 
-    return registry.createTypeUnsafe(VERSIONS[version] || VERSIONS[0], [adjustedPayload, { version }]);
+    return registry.createTypeUnsafe(extVersion, [adjustedPayload, { version }]);
   }
 
-  return registry.createTypeUnsafe(VERSIONS[version] || VERSIONS[0], [value, { version }]);
+  return registry.createTypeUnsafe(extVersion, [value, { version }]);
 }
 
 /**
@@ -64,8 +76,8 @@ function decodeExtrinsicPayload (registry: Registry, value?: GenericExtrinsicPay
  * on the contents included
  */
 export class GenericExtrinsicPayload extends AbstractBase<ExtrinsicPayloadVx> {
-  constructor (registry: Registry, value?: Partial<ExtrinsicPayloadValue> | Uint8Array | string, { version }: ExtrinsicPayloadOptions = {}) {
-    super(registry, decodeExtrinsicPayload(registry, value as ExtrinsicPayloadValue, version));
+  constructor (registry: Registry, value?: Partial<ExtrinsicPayloadValue> | Uint8Array | string, { pramble, version }: ExtrinsicPayloadOptions = {}) {
+    super(registry, decodeExtrinsicPayload(registry, value as ExtrinsicPayloadValue, version, pramble));
   }
 
   /**

packages/types/src/extrinsic/constants.ts

@@ -12,3 +12,20 @@ export const DEFAULT_VERSION = 4;
 export const IMMORTAL_ERA = new Uint8Array([0]);
 
 export const UNMASK_VERSION = 0b01111111;
+
+export const DEFAULT_PREAMBLE = 'signed';
+
+// Latest extrinsic version is v5, which has backwards compatibility for v4 signed extrinsics
+export const LATEST_EXTRINSIC_VERSION = 5;
+
+export const VERSION_MASK = 0b00111111;
+
+export const TYPE_MASK = 0b11000000;
+
+export const BARE_EXTRINSIC = 0b00000000;
+
+export const SIGNED_EXTRINSIC = 0b10000000;
+
+export const GENERAL_EXTRINSIC = 0b01000000;
+
+export const LOWEST_SUPPORTED_EXTRINSIC_FORMAT_VERSION = 4;

packages/types/src/extrinsic/index.ts

@@ -11,3 +11,4 @@ export { GenericSignerPayload } from './SignerPayload.js';
 
 // all starred
 export * from './v4/index.js';
+export * from './v5/index.js';

packages/types/src/extrinsic/types.ts

@@ -21,3 +21,5 @@ export interface ExtrinsicExtraValue {
   nonce?: AnyNumber;
   tip?: AnyNumber;
 }
+
+export type Preamble = 'signed' | 'bare' | 'general';

packages/types/src/extrinsic/util.ts

@@ -13,3 +13,10 @@ export function sign (registry: Registry, signerPair: IKeyringPair, u8a: Uint8Ar
 
   return signerPair.sign(encoded, options);
 }
+
+// a helper function for both types of payloads, Raw and metadata-known
+export function signV5 (registry: Registry, signerPair: IKeyringPair, u8a: Uint8Array, options?: SignOptions): Uint8Array {
+  const encoded = registry.hash(u8a);
+
+  return signerPair.sign(encoded, options);
+}

packages/types/src/extrinsic/v5/Extrinsic.spec.ts

@@ -0,0 +1,86 @@
+// Copyright 2017-2024 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { createTestPairs } from '@polkadot/keyring/testingPairs';
+import rpcMetadata from '@polkadot/types-support/metadata/static-substrate';
+import { BN } from '@polkadot/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('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
+      '84181ebef350cc212e70e042b6ebcd33ca955bf9497711a64aa7c64e2b8c2732' +
+      'ab837715364eab7be5cc76f74eefa36d3ba9ee698264ed28a286c8360fc9aa0c' +
+      '0004080000' + // era. nonce, tip, mode
+      '0600' +
+      '00' +
+      'd7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9' +
+      'e56c'
+    );
+  });
+});