@pezkuwi/types 16.5.5

package/src/extrinsic/SignerPayload.spec.ts

@@ -0,0 +1,189 @@
+// 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 { u8aToHex } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../create/index.js';
+import { Metadata } from '../metadata/index.js';
+import { GenericSignerPayload as SignerPayload } from './index.js';
+
+const registry = new TypeRegistry();
+const metadata = new Metadata(registry, rpcMetadata);
+
+registry.setMetadata(metadata);
+
+describe('SignerPayload', (): void => {
+  const TEST = {
+    address: '5DTestUPts3kjeXSTMyerHihn1uwMfLj8vU8sqF7qYrFabHE',
+    // eslint-disable-next-line sort-keys
+    assetId: '0x0002043205ed01',
+    blockHash: '0xde8f69eeb5e065e18c6950ff708d7e551f68dc9bf59a07c52367c0280f805ec7',
+    blockNumber: '0x00231d30',
+    era: '0x0703',
+    genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
+    metadataHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
+    method: '0x060000d7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9e56c',
+    mode: 1,
+    nonce: '0x00001234',
+    signedExtensions: ['CheckNonce', 'CheckWeight'],
+    specVersion: '0x00000006',
+    tip: '0x00000000000000000000000000005678',
+    transactionVersion: '0x00000007',
+    version: 4,
+    withSignedTransaction: false
+  };
+
+  const TEST_WITH_ASSETID_HEX = {
+    ...TEST,
+    assetId: '0x010002043205ed01'
+  };
+
+  it('creates a valid JSON output', (): void => {
+    expect(
+      new SignerPayload(registry, {
+        address: '5DTestUPts3kjeXSTMyerHihn1uwMfLj8vU8sqF7qYrFabHE',
+        // eslint-disable-next-line sort-keys
+        assetId: { parents: 0, interior: { x2: [{ palletInstance: 50 }, { generalIndex: 123 }] } },
+        blockHash: '0xde8f69eeb5e065e18c6950ff708d7e551f68dc9bf59a07c52367c0280f805ec7',
+        blockNumber: '0x231d30',
+        era: registry.createType('ExtrinsicEra', { current: 2301232, period: 200 }),
+        genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
+        metadataHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
+        method: registry.createType('Call', '0x060000d7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9e56c'),
+        mode: 1,
+        nonce: 0x1234,
+        signedExtensions: ['CheckNonce'],
+        tip: 0x5678,
+        version: 4,
+        withSignedTransaction: true
+      }).toPayload()
+    ).toEqual({
+      address: '5DTestUPts3kjeXSTMyerHihn1uwMfLj8vU8sqF7qYrFabHE',
+      // eslint-disable-next-line sort-keys
+      assetId: '0x010002043205ed01',
+      blockHash: '0xde8f69eeb5e065e18c6950ff708d7e551f68dc9bf59a07c52367c0280f805ec7',
+      blockNumber: '0x00231d30',
+      era: '0x0703',
+      genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
+      metadataHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
+      method: '0x060000d7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9e56c',
+      mode: 1,
+      nonce: '0x00001234',
+      signedExtensions: ['CheckNonce'],
+      specVersion: '0x00000000',
+      tip: '0x00000000000000000000000000005678',
+      transactionVersion: '0x00000000',
+      version: 4,
+      withSignedTransaction: true
+    });
+  });
+
+  it('handles Option<AssetId> correctly', (): void => {
+    const test = new SignerPayload(registry, {
+      // eslint-disable-next-line sort-keys
+      assetId: { parents: 0, interior: { x2: [{ palletInstance: 50 }, { generalIndex: 123 }] } }
+    });
+
+    expect(
+      [...test.keys()].includes('assetId')
+    ).toEqual(true);
+
+    expect(
+      test.toPayload().assetId
+      // eslint-disable-next-line sort-keys
+    ).toEqual('0x010002043205ed01');
+
+    expect(
+      new SignerPayload(registry, { assetId: 0 }).toPayload().assetId
+      // eslint-disable-next-line sort-keys
+    ).toEqual('0x010000');
+  });
+
+  it('re-constructs from JSON', (): void => {
+    expect(
+      new SignerPayload(registry, {
+        ...TEST,
+        runtimeVersion: { specVersion: 0x06, transactionVersion: 0x07 }
+      }).toPayload()
+    ).toEqual(TEST_WITH_ASSETID_HEX);
+  });
+
+  it('re-constructs from itself', (): void => {
+    expect(
+      new SignerPayload(
+        registry,
+        new SignerPayload(registry, {
+          ...TEST,
+          runtimeVersion: { specVersion: 0x06, transactionVersion: 0x07 }
+        })
+      ).toPayload()
+    ).toEqual(TEST_WITH_ASSETID_HEX);
+  });
+
+  it('can be used as a feed to ExtrinsicPayload', (): void => {
+    const signer = new SignerPayload(registry, {
+      ...TEST
+    }).toPayload();
+    const payload = registry.createType('ExtrinsicPayload', signer, { version: signer.version });
+
+    expect(payload.era.toHex()).toEqual(TEST.era);
+    expect(payload.method.toHex()).toEqual(TEST.method);
+    expect(payload.blockHash.toHex()).toEqual(TEST.blockHash);
+    expect(payload.nonce.eq(TEST.nonce)).toBe(true);
+    expect(payload.tip.eq(TEST.tip)).toBe(true);
+    expect(u8aToHex(payload.assetId?.toU8a()))
+      .toEqual(u8aToHex(registry.createType('Option<MultiLocation>', {
+        // eslint-disable-next-line sort-keys
+        parents: 0, interior: { X2: [{ palletInstance: 50 }, { generalIndex: 123 }] }
+      }).toU8a()));
+  });
+
+  const TEST_WITHOUT_CHECK = {
+    address: '5DTestUPts3kjeXSTMyerHihn1uwMfLj8vU8sqF7qYrFabHE',
+    blockHash: '0xde8f69eeb5e065e18c6950ff708d7e551f68dc9bf59a07c52367c0280f805ec7',
+    blockNumber: '0x00231d30',
+    era: '0x0703',
+    genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
+    method: '0x060000d7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9e56c',
+    nonce: '0x00001234',
+    signedExtensions: [],
+    specVersion: '0x00000006',
+    tip: '0x00000000000000000000000000005678',
+    transactionVersion: '0x00000007',
+    version: 4
+  };
+
+  const PAYLOAD_WITHOUT_CHECK = {
+    address: '5DTestUPts3kjeXSTMyerHihn1uwMfLj8vU8sqF7qYrFabHE',
+    assetId: null,
+    blockHash: '0xde8f69eeb5e065e18c6950ff708d7e551f68dc9bf59a07c52367c0280f805ec7',
+    blockNumber: '0x00231d30',
+    era: '0x0703',
+    genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
+    metadataHash: null,
+    method: '0x060000d7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9e56c',
+    mode: 0,
+    nonce: '0x00001234',
+    signedExtensions: [],
+    specVersion: '0x00000006',
+    tip: '0x00000000000000000000000000005678',
+    transactionVersion: '0x00000007',
+    version: 4,
+    withSignedTransaction: false
+  };
+
+  it('can build SignerPayload without additional SignedExtensions', (): void => {
+    expect(
+      new SignerPayload(
+        registry,
+        {
+          ...TEST_WITHOUT_CHECK,
+          runtimeVersion: { specVersion: 0x06, transactionVersion: 0x07 }
+        }
+      ).toPayload()
+    ).toEqual(PAYLOAD_WITHOUT_CHECK);
+  });
+});

package/src/extrinsic/SignerPayload.ts

@@ -0,0 +1,198 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { bool, Text, Vec } from '@pezkuwi/types-codec';
+import type { AnyJson, Registry } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { Address, BlockHash, Call, ExtrinsicEra, Hash, MultiLocation } from '../interfaces/index.js';
+import type { Codec, ICompact, INumber, IOption, IRuntimeVersion, ISignerPayload, SignerPayloadJSON, SignerPayloadRaw } from '../types/index.js';
+
+import { Option, Struct } from '@pezkuwi/types-codec';
+import { objectProperty, objectSpread, u8aToHex } from '@pezkuwi/util';
+
+export interface SignerPayloadType extends Codec {
+  address: Address;
+  assetId: IOption<INumber | MultiLocation>;
+  blockHash: Hash;
+  blockNumber: INumber;
+  era: ExtrinsicEra;
+  genesisHash: Hash;
+  metadataHash: IOption<Hash>;
+  method: Call;
+  mode: INumber;
+  nonce: ICompact<INumber>;
+  runtimeVersion: IRuntimeVersion;
+  signedExtensions: Vec<Text>;
+  tip: ICompact<INumber>;
+  version: INumber;
+}
+
+const knownTypes: Record<string, string> = {
+  address: 'Address',
+  assetId: 'Option<TAssetConversion>',
+  blockHash: 'Hash',
+  blockNumber: 'BlockNumber',
+  era: 'ExtrinsicEra',
+  genesisHash: 'Hash',
+  metadataHash: 'Option<[u8;32]>',
+  method: 'Call',
+  mode: 'u8',
+  nonce: 'Compact<Index>',
+  runtimeVersion: 'RuntimeVersion',
+  signedExtensions: 'Vec<Text>',
+  tip: 'Compact<Balance>',
+  version: 'u8'
+};
+
+/**
+ * @name GenericSignerPayload
+ * @description
+ * A generic signer payload that can be used for serialization between API and signer
+ */
+export class GenericSignerPayload extends Struct implements ISignerPayload, SignerPayloadType {
+  readonly #extraTypes: Record<string, string>;
+
+  constructor (registry: Registry, value?: HexString | Record<string, unknown> | Map<unknown, unknown> | unknown[]) {
+    const extensionTypes = objectSpread<Record<string, string>>({}, registry.getSignedExtensionTypes(), registry.getSignedExtensionExtra());
+
+    super(registry, objectSpread<Record<string, string>>({}, extensionTypes, knownTypes, { withSignedTransaction: 'bool' }), value);
+
+    this.#extraTypes = {};
+    const getter = (key: string) => this.get(key);
+
+    // add all extras that are not in the base types
+    for (const [key, type] of Object.entries(extensionTypes)) {
+      if (!knownTypes[key]) {
+        this.#extraTypes[key] = type;
+      }
+
+      objectProperty(this, key, getter);
+    }
+  }
+
+  get address (): Address {
+    return this.getT('address');
+  }
+
+  get blockHash (): BlockHash {
+    return this.getT('blockHash');
+  }
+
+  get blockNumber (): INumber {
+    return this.getT('blockNumber');
+  }
+
+  get era (): ExtrinsicEra {
+    return this.getT('era');
+  }
+
+  get genesisHash (): BlockHash {
+    return this.getT('genesisHash');
+  }
+
+  get method (): Call {
+    return this.getT('method');
+  }
+
+  get nonce (): ICompact<INumber> {
+    return this.getT('nonce');
+  }
+
+  get runtimeVersion (): IRuntimeVersion {
+    return this.getT('runtimeVersion');
+  }
+
+  get signedExtensions (): Vec<Text> {
+    return this.getT('signedExtensions');
+  }
+
+  get tip (): ICompact<INumber> {
+    return this.getT('tip');
+  }
+
+  get assetId (): IOption<INumber | MultiLocation> {
+    return this.getT('assetId');
+  }
+
+  get version (): INumber {
+    return this.getT('version');
+  }
+
+  get mode (): INumber {
+    return this.getT('mode');
+  }
+
+  get metadataHash (): IOption<Hash> {
+    return this.getT('metadataHash');
+  }
+
+  get withSignedTransaction (): boolean {
+    const val: bool = this.getT('withSignedTransaction');
+
+    return val.isTrue;
+  }
+
+  /**
+   * @description Creates an representation of the structure as an ISignerPayload JSON
+   */
+  public toPayload (): SignerPayloadJSON {
+    const result: Record<string, AnyJson> = {};
+    const keys = Object.keys(this.#extraTypes);
+
+    // add any explicit overrides we may have
+    for (let i = 0, count = keys.length; i < count; i++) {
+      const key = keys[i];
+      const value = this.getT(key);
+
+      // Don't include Option.isNone
+      if (!(value instanceof Option) || value.isSome) {
+        // NOTE In the spread below we convert (mostly) to Hex to align
+        // with the typings. In the case of "unknown" fields, we use the
+        // primitive toJSON conversion (which is serializable). Technically
+        // we can include isNone in here as well ("null" is allowed), however
+        // for empty fields we just skip it completely (historical compat)
+        result[key] = value.toJSON();
+      }
+    }
+
+    return objectSpread(result, {
+      // the known defaults as managed explicitly and has different
+      // formatting in cases, e.g. we mostly expose a hex format here
+      address: this.address.toString(),
+      assetId: this.assetId && this.assetId.isSome ? this.assetId.toHex() : null,
+      blockHash: this.blockHash.toHex(),
+      blockNumber: this.blockNumber.toHex(),
+      era: this.era.toHex(),
+      genesisHash: this.genesisHash.toHex(),
+      metadataHash: this.metadataHash.isSome ? this.metadataHash.toHex() : null,
+      method: this.method.toHex(),
+      mode: this.mode.toNumber(),
+      nonce: this.nonce.toHex(),
+      signedExtensions: this.signedExtensions.map((e) => e.toString()),
+      specVersion: this.runtimeVersion.specVersion.toHex(),
+      tip: this.tip.toHex(),
+      transactionVersion: this.runtimeVersion.transactionVersion.toHex(),
+      version: this.version.toNumber(),
+      withSignedTransaction: this.withSignedTransaction
+    });
+  }
+
+  /**
+   * @description Creates a representation of the payload in raw Exrinsic form
+   */
+  public toRaw (): SignerPayloadRaw {
+    const payload = this.toPayload();
+    const data = u8aToHex(
+      this.registry
+        .createTypeUnsafe('ExtrinsicPayload', [payload, { version: payload.version }])
+        // NOTE Explicitly pass the bare flag so the method is encoded un-prefixed (non-decodable, for signing only)
+        .toU8a({ method: true })
+    );
+
+    return {
+      address: payload.address,
+      data,
+      type: 'payload'
+    };
+  }
+}

package/src/extrinsic/constants.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const BIT_SIGNED = 0b10000000;
+
+export const BIT_UNSIGNED = 0;
+
+export const EMPTY_U8A = new Uint8Array();
+
+export const IMMORTAL_ERA = new Uint8Array([0]);
+
+export const UNMASK_VERSION = 0b01111111;
+
+export const DEFAULT_PREAMBLE = 'bare';
+
+// Latest extrinsic version is v5, which has backwards compatibility for v4 signed extrinsics
+// However is not fully supported so LATEST_EXTRINSIC_VERSION is configured as 4 in the meantime.
+export const LATEST_EXTRINSIC_VERSION = 4;
+
+export const VERSION_MASK = 0b00111111;
+
+export const TYPE_MASK = 0b11000000;
+
+export const BARE_EXTRINSIC = 0b00000000;
+
+export const GENERAL_EXTRINSIC = 0b01000000;
+
+export const LOWEST_SUPPORTED_EXTRINSIC_FORMAT_VERSION = 4;

package/src/extrinsic/index.ts

@@ -0,0 +1,14 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// all named
+export { GenericExtrinsic } from './Extrinsic.js';
+export { GenericExtrinsicEra, ImmortalEra as GenericImmortalEra, MortalEra as GenericMortalEra } from './ExtrinsicEra.js';
+export { GenericExtrinsicPayload } from './ExtrinsicPayload.js';
+export { GenericExtrinsicPayloadUnknown } from './ExtrinsicPayloadUnknown.js';
+export { GenericExtrinsicUnknown } from './ExtrinsicUnknown.js';
+export { GenericSignerPayload } from './SignerPayload.js';
+
+// all starred
+export * from './v4/index.js';
+export * from './v5/index.js';

package/src/extrinsic/signedExtensions/emptyCheck.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ExtInfo } from './types.js';
+
+export const emptyCheck: ExtInfo = {
+  extrinsic: {},
+  payload: {}
+};

package/src/extrinsic/signedExtensions/index.ts

@@ -0,0 +1,46 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ExtDef, ExtInfo, ExtTypes } from './types.js';
+
+import { objectSpread } from '@pezkuwi/util';
+
+import { polkadot } from './polkadot.js';
+import { shell } from './shell.js';
+import { statemint } from './statemint.js';
+import { substrate } from './substrate.js';
+
+// A mapping of the known signed extensions to the extra fields that they
+// contain. Unlike in the actual extensions, we define the extra fields not
+// as a Tuple, but rather as a struct so they can be named. These will be
+// expanded into the various fields when added to the payload (we only
+// support V4 onwards with these, V3 and earlier are deemed fixed))
+export const allExtensions: ExtDef = objectSpread({}, substrate, polkadot, shell, statemint);
+
+// the v4 signed extensions prior to the point of exposing these to the
+// metadata. This may not match 100% with the current defaults and are used
+// when not specified in the metadata (which is for very old chains). The
+// order is important here, as applied by default
+export const fallbackExtensions = [
+  'CheckVersion',
+  'CheckGenesis',
+  'CheckEra',
+  'CheckNonce',
+  'CheckWeight',
+  'ChargeTransactionPayment',
+  'CheckBlockGasLimit'
+];
+
+export function findUnknownExtensions (extensions: string[], userExtensions: ExtDef = {}): string[] {
+  const names = [...Object.keys(allExtensions), ...Object.keys(userExtensions)];
+
+  return extensions.filter((k) => !names.includes(k));
+}
+
+export function expandExtensionTypes (extensions: string[], type: keyof ExtInfo, userExtensions: ExtDef = {}): ExtTypes {
+  return extensions
+    // Always allow user extensions first - these should provide overrides
+    .map((k) => userExtensions[k] || allExtensions[k])
+    .filter((info): info is ExtInfo => !!info)
+    .reduce((result, info): ExtTypes => objectSpread(result, info[type]), {});
+}

package/src/extrinsic/signedExtensions/polkadot.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ExtDef } from './types.js';
+
+import { emptyCheck } from './emptyCheck.js';
+
+export const polkadot: ExtDef = {
+  LimitParathreadCommits: emptyCheck,
+  OnlyStakingAndClaims: emptyCheck,
+  PrevalidateAttests: emptyCheck,
+  RestrictFunctionality: emptyCheck,
+  TransactionCallFilter: emptyCheck,
+  ValidateDoubleVoteReports: emptyCheck
+};

package/src/extrinsic/signedExtensions/shell.ts

@@ -0,0 +1,10 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ExtDef } from './types.js';
+
+import { emptyCheck } from './emptyCheck.js';
+
+export const shell: ExtDef = {
+  DisallowSigned: emptyCheck
+};

package/src/extrinsic/signedExtensions/statemint.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ExtDef } from './types.js';
+
+export const statemint: ExtDef = {
+  ChargeAssetTxPayment: {
+    extrinsic: {
+      tip: 'Compact<Balance>',
+      // eslint-disable-next-line sort-keys
+      assetId: 'TAssetConversion'
+    },
+    payload: {}
+  }
+};

package/src/extrinsic/signedExtensions/substrate.ts

@@ -0,0 +1,75 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ExtDef, ExtInfo } from './types.js';
+
+import { emptyCheck } from './emptyCheck.js';
+
+const CheckMetadataHash: ExtInfo = {
+  extrinsic: {
+    mode: 'u8'
+  },
+  payload: {
+    metadataHash: 'Option<[u8;32]>'
+  }
+};
+
+const CheckMortality: ExtInfo = {
+  extrinsic: {
+    era: 'ExtrinsicEra'
+  },
+  payload: {
+    blockHash: 'Hash'
+  }
+};
+
+const ChargeTransactionPayment: ExtInfo = {
+  extrinsic: {
+    tip: 'Compact<Balance>'
+  },
+  payload: {}
+};
+
+export const substrate: ExtDef = {
+  ChargeTransactionPayment,
+  CheckBlockGasLimit: emptyCheck,
+  CheckEra: CheckMortality,
+  CheckGenesis: {
+    extrinsic: {},
+    payload: {
+      genesisHash: 'Hash'
+    }
+  },
+  CheckMetadataHash,
+  CheckMortality,
+  CheckNonZeroSender: emptyCheck,
+  CheckNonce: {
+    extrinsic: {
+      nonce: 'Compact<Index>'
+    },
+    payload: {}
+  },
+  CheckSpecVersion: {
+    extrinsic: {},
+    payload: {
+      specVersion: 'u32'
+    }
+  },
+  CheckTxVersion: {
+    extrinsic: {},
+    payload: {
+      transactionVersion: 'u32'
+    }
+  },
+  CheckVersion: {
+    extrinsic: {},
+    payload: {
+      specVersion: 'u32'
+    }
+  },
+  CheckWeight: emptyCheck,
+  LockStakingStatus: emptyCheck,
+  SkipCheckIfFeeless: ChargeTransactionPayment,
+  ValidateEquivocationReport: emptyCheck,
+  WeightReclaim: emptyCheck
+};

package/src/extrinsic/signedExtensions/types.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export type ExtTypes = Record<string, string>;
+
+export interface ExtInfo {
+  extrinsic: ExtTypes;
+  payload: ExtTypes;
+}
+
+export type ExtDef = Record<string, ExtInfo>;

package/src/extrinsic/types.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyNumber } from '@pezkuwi/types-codec/types';
+
+export interface ExtrinsicOptions {
+  isSigned: boolean;
+  version: number;
+}
+
+export interface ExtrinsicPayloadOptions {
+  version: number;
+}
+
+export interface ExtrinsicSignatureOptions {
+  isSigned?: boolean;
+}
+
+export interface ExtrinsicExtraValue {
+  era?: Uint8Array;
+  nonce?: AnyNumber;
+  tip?: AnyNumber;
+}
+
+export type Preamble = 'bare' | 'general';

package/src/extrinsic/util.ts

@@ -0,0 +1,23 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { SignOptions } from '@pezkuwi/keyring/types';
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { IKeyringPair } from '../types/index.js';
+
+import { blake2AsU8a } from '@pezkuwi/util-crypto';
+
+// a helper function for both types of payloads, Raw and metadata-known
+export function sign (_registry: Registry, signerPair: IKeyringPair, u8a: Uint8Array, options?: SignOptions): Uint8Array {
+  const encoded = u8a.length > 256
+    ? blake2AsU8a(u8a)
+    : u8a;
+
+  return signerPair.sign(encoded, options);
+}
+
+export function signGeneral (registry: Registry, u8a: Uint8Array): Uint8Array {
+  const encoded = registry.hash(u8a);
+
+  return encoded;
+}