@pezkuwi/types 16.5.5

package/src/generic/Call.ts

@@ -0,0 +1,244 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyJson, AnyTuple, AnyU8a, ArgsDef, Codec, IMethod, Registry } from '@pezkuwi/types-codec/types';
+import type { FunctionMetadataLatest } from '../interfaces/metadata/index.js';
+import type { CallBase, CallFunction, InterfaceTypes } from '../types/index.js';
+
+import { Struct, U8aFixed } from '@pezkuwi/types-codec';
+import { isHex, isObject, isU8a, objectSpread, u8aToU8a } from '@pezkuwi/util';
+
+interface DecodeMethodInput {
+  args: unknown;
+  // eslint-disable-next-line no-use-before-define
+  callIndex: GenericCallIndex | Uint8Array;
+}
+
+interface DecodedMethod extends DecodeMethodInput {
+  argsDef: ArgsDef;
+  meta: FunctionMetadataLatest;
+}
+
+/**
+ * Get a mapping of `argument name -> argument type` for the function, from
+ * its metadata.
+ *
+ * @param meta - The function metadata used to get the definition.
+ * @internal
+ */
+function getArgsDef (registry: Registry, meta: FunctionMetadataLatest): ArgsDef {
+  return meta.fields.reduce((result, { name, type }, index): ArgsDef => {
+    result[name.unwrapOr(`param${index}`).toString()] = registry.createLookupType(type) as keyof InterfaceTypes;
+
+    return result;
+  }, {} as ArgsDef);
+}
+
+/** @internal */
+function decodeCallViaObject (registry: Registry, value: DecodedMethod, _meta?: FunctionMetadataLatest): DecodedMethod {
+  // we only pass args/methodsIndex out
+  const { args, callIndex } = value;
+
+  // Get the correct lookupIndex
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  const lookupIndex = callIndex instanceof GenericCallIndex
+    ? callIndex.toU8a()
+    : callIndex;
+
+  // Find metadata with callIndex
+  const meta = _meta || registry.findMetaCall(lookupIndex).meta;
+
+  return {
+    args,
+    argsDef: getArgsDef(registry, meta),
+    callIndex,
+    meta
+  };
+}
+
+/** @internal */
+function decodeCallViaU8a (registry: Registry, value: Uint8Array, _meta?: FunctionMetadataLatest): DecodedMethod {
+  // We need 2 bytes for the callIndex
+  const callIndex = registry.firstCallIndex.slice();
+
+  callIndex.set(value.subarray(0, 2), 0);
+
+  // Find metadata with callIndex
+  const meta = _meta || registry.findMetaCall(callIndex).meta;
+
+  return {
+    args: value.subarray(2),
+    argsDef: getArgsDef(registry, meta),
+    callIndex,
+    meta
+  };
+}
+
+/**
+ * Decode input to pass into constructor.
+ *
+ * @param value - Value to decode, one of:
+ * - hex
+ * - Uint8Array
+ * - {@see DecodeMethodInput}
+ * @param _meta - Metadata to use, so that `injectMethods` lookup is not
+ * necessary.
+ * @internal
+ */
+function decodeCall (registry: Registry, value: unknown = new Uint8Array(), _meta?: FunctionMetadataLatest): DecodedMethod {
+  if (isU8a(value) || isHex(value)) {
+    return decodeCallViaU8a(registry, u8aToU8a(value), _meta);
+  } else if (isObject<DecodedMethod>(value) && value.callIndex && value.args) {
+    return decodeCallViaObject(registry, value, _meta);
+  }
+
+  throw new Error(`Call: Cannot decode value '${value as string}' of type ${typeof value}`);
+}
+
+/**
+ * @name GenericCallIndex
+ * @description
+ * A wrapper around the `[sectionIndex, methodIndex]` value that uniquely identifies a method
+ */
+export class GenericCallIndex extends U8aFixed {
+  constructor (registry: Registry, value?: AnyU8a) {
+    super(registry, value, 16);
+  }
+
+  /**
+   * @description Converts the value in a best-fit primitive form
+   */
+  public override toPrimitive (): string {
+    return this.toHex();
+  }
+}
+
+/**
+ * @name GenericCall
+ * @description
+ * Extrinsic function descriptor
+ */
+export class GenericCall<A extends AnyTuple = AnyTuple> extends Struct implements CallBase<A> {
+  protected _meta: FunctionMetadataLatest;
+
+  constructor (registry: Registry, value: unknown, meta?: FunctionMetadataLatest) {
+    const decoded = decodeCall(registry, value, meta);
+
+    try {
+      super(registry, {
+        callIndex: GenericCallIndex,
+        // eslint-disable-next-line sort-keys
+        args: Struct.with(decoded.argsDef)
+      }, decoded);
+    } catch (error) {
+      let method = 'unknown.unknown';
+
+      try {
+        const c = registry.findMetaCall(decoded.callIndex);
+
+        method = `${c.section}.${c.method}`;
+      } catch {
+        // ignore
+      }
+
+      throw new Error(`Call: failed decoding ${method}:: ${(error as Error).message}`);
+    }
+
+    this._meta = decoded.meta;
+  }
+
+  /**
+   * @description The arguments for the function call
+   */
+  public get args (): A {
+    return [...this.getT<Struct>('args').values()] as A;
+  }
+
+  /**
+   * @description The argument definitions
+   */
+  public get argsDef (): ArgsDef {
+    return getArgsDef(this.registry, this.meta);
+  }
+
+  /**
+   * @description The argument entries
+   */
+  public get argsEntries (): [string, Codec][] {
+    return [...this.getT<Struct>('args').entries()];
+  }
+
+  /**
+   * @description The encoded `[sectionIndex, methodIndex]` identifier
+   */
+  public get callIndex (): Uint8Array {
+    return this.getT<GenericCallIndex>('callIndex').toU8a();
+  }
+
+  /**
+   * @description The encoded data
+   */
+  public get data (): Uint8Array {
+    return this.getT<Struct>('args').toU8a();
+  }
+
+  /**
+   * @description The [[FunctionMetadata]]
+   */
+  public get meta (): FunctionMetadataLatest {
+    return this._meta;
+  }
+
+  /**
+   * @description Returns the name of the method
+   */
+  public get method (): string {
+    return this.registry.findMetaCall(this.callIndex).method;
+  }
+
+  /**
+   * @description Returns the module containing the method
+   */
+  public get section (): string {
+    return this.registry.findMetaCall(this.callIndex).section;
+  }
+
+  /**
+   * @description Checks if the source matches this in type
+   */
+  public is (other: IMethod<AnyTuple>): other is IMethod<A> {
+    return other.callIndex[0] === this.callIndex[0] && other.callIndex[1] === this.callIndex[1];
+  }
+
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  public override toHuman (isExpanded?: boolean, disableAscii?: boolean): Record<string, AnyJson> {
+    let call: CallFunction | undefined;
+
+    try {
+      call = this.registry.findMetaCall(this.callIndex);
+    } catch {
+      // swallow
+    }
+
+    return objectSpread(
+      {
+        args: this.argsEntries.reduce<Record<string, AnyJson>>((args, [n, a]) =>
+          objectSpread(args, { [n]: a.toHuman(isExpanded, disableAscii) }), {}),
+        method: call?.method,
+        section: call?.section
+      },
+      isExpanded && call
+        ? { docs: call.meta.docs.map((d) => d.toString()) }
+        : null
+    );
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    return 'Call';
+  }
+}

package/src/generic/ChainProperties.spec.ts

@@ -0,0 +1,95 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '../create/index.js';
+
+describe('ChainProperties', (): void => {
+  const registry = new TypeRegistry();
+
+  it('decodes from a null value (setting defaults)', (): void => {
+    expect(
+      [...registry.createType('ChainProperties', null).keys()]
+    ).toEqual(['isEthereum', 'ss58Format', 'tokenDecimals', 'tokenSymbol']);
+  });
+
+  it('decodes from an actual JSON', (): void => {
+    const { isEthereum, ss58Format, tokenDecimals, tokenSymbol } = registry.createType('ChainProperties', JSON.parse('{"isEthereum":false,"ss58Format":2,"tokenDecimals":12,"tokenSymbol":"KSM"}'));
+
+    expect(ss58Format.unwrap().eq(2)).toBe(true);
+    expect(tokenDecimals.unwrap().eq([12])).toBe(true);
+    expect(tokenSymbol.unwrap().eq(['KSM'])).toBe(true);
+    expect(isEthereum.isFalse).toBe(true);
+  });
+
+  it('decodes from an actual object (multiple tokens)', (): void => {
+    const { isEthereum, ss58Format, tokenDecimals, tokenSymbol } = registry.createType('ChainProperties', {
+      isEthereum: undefined,
+      ss58Format: undefined,
+      tokenDecimals: [10, 12],
+      tokenSymbol: ['pDOT', 'pKSM']
+    });
+
+    expect(isEthereum.isFalse).toBe(true);
+    expect(ss58Format.isNone).toBe(true);
+    expect(tokenDecimals.unwrap().eq([10, 12])).toBe(true);
+    expect(tokenSymbol.unwrap().eq(['pDOT', 'pKSM'])).toBe(true);
+  });
+
+  it('decodes from an object, flagged for non-existent ss58Format', (): void => {
+    const { isEthereum, ss58Format, tokenDecimals, tokenSymbol } = registry.createType('ChainProperties', { tokenSymbol: 'DEV' });
+
+    expect(isEthereum.isFalse).toBe(true);
+    expect(ss58Format.isNone).toBe(true);
+    expect(tokenDecimals.isNone).toBe(true);
+    expect(tokenSymbol.isSome).toBe(true);
+  });
+
+  it('decodes from a ChainProperties object', (): void => {
+    const original = registry.createType('ChainProperties', {
+      isEthereum: true,
+      ss58Format: 2,
+      tokenDecimals: 15,
+      tokenSymbol: 'KSM'
+    });
+    const { isEthereum, ss58Format, tokenDecimals, tokenSymbol } = registry.createType('ChainProperties', original);
+
+    expect(isEthereum.isTrue).toBe(true);
+    expect(ss58Format.unwrap().eq(2)).toBe(true);
+    expect(tokenDecimals.unwrap().eq([15])).toBe(true);
+    expect(tokenSymbol.unwrap().eq(['KSM'])).toBe(true);
+  });
+
+  it('has a sane toHuman (single tokenDecimals)', (): void => {
+    expect(
+      registry.createType('ChainProperties', {
+        isEthereum: false,
+        ss58Format: 42,
+        tokenDecimals: registry.createType('u32', 9),
+        tokenSymbol: ['Unit', 'Aux1']
+      }).toHuman()
+    ).toEqual({
+      isEthereum: false,
+      ss58Format: '42',
+      tokenDecimals: ['9'],
+      tokenSymbol: ['Unit', 'Aux1']
+    });
+  });
+
+  it('has a sane toHuman (multiple tokenDecimals)', (): void => {
+    expect(
+      registry.createType('ChainProperties', {
+        isEthereum: false,
+        ss58Format: 2,
+        tokenDecimals: [registry.createType('u32', 12), 8],
+        tokenSymbol: ['KSM', 'BTC']
+      }).toHuman()
+    ).toEqual({
+      isEthereum: false,
+      ss58Format: '2',
+      tokenDecimals: ['12', '8'],
+      tokenSymbol: ['KSM', 'BTC']
+    });
+  });
+});

package/src/generic/ChainProperties.ts

@@ -0,0 +1,93 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { bool as Bool, Option, Text, u32, Vec } from '@pezkuwi/types-codec';
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { Codec } from '../types/index.js';
+
+import { Json } from '@pezkuwi/types-codec';
+import { isFunction, isNull, isUndefined } from '@pezkuwi/util';
+
+function createValue (registry: Registry, type: string, value: unknown, asArray = true): Option<Codec> {
+  // We detect codec here as well - when found, generally this is constructed from itself
+  if (value && isFunction((value as Option<Codec>).unwrapOrDefault)) {
+    return value as Option<Codec>;
+  }
+
+  return registry.createTypeUnsafe<Option<u32>>(
+    type,
+    [
+      asArray
+        ? isNull(value) || isUndefined(value)
+          ? null
+          : Array.isArray(value)
+            ? value
+            : [value]
+        : value
+    ]
+  );
+}
+
+function decodeValue (registry: Registry, key: string, value: unknown): unknown {
+  return key === 'ss58Format'
+    ? createValue(registry, 'Option<u32>', value, false)
+    : key === 'tokenDecimals'
+      ? createValue(registry, 'Option<Vec<u32>>' as 'Vec<u32>', value)
+      : key === 'tokenSymbol'
+        ? createValue(registry, 'Option<Vec<Text>>' as 'Vec<Text>', value)
+        : key === 'isEthereum'
+          ? createValue(registry, 'Bool', value, false)
+          : value;
+}
+
+function decode (registry: Registry, value?: Map<string, unknown> | Record<string, unknown> | null): Record<string, unknown> {
+  return (
+    // allow decoding from a map as well (ourselves)
+    value && isFunction((value as Map<string, unknown>).entries)
+      ? [...(value as Map<string, unknown>).entries()]
+      : Object.entries(value || {})
+  ).reduce((all: Record<string, unknown>, [key, value]) => {
+    all[key] = decodeValue(registry, key, value);
+
+    return all;
+  }, {
+    isEthereum: registry.createTypeUnsafe('Bool', []),
+    ss58Format: registry.createTypeUnsafe('Option<u32>', []),
+    tokenDecimals: registry.createTypeUnsafe('Option<Vec<u32>>', []),
+    tokenSymbol: registry.createTypeUnsafe('Option<Vec<Text>>', [])
+  });
+}
+
+export class GenericChainProperties extends Json {
+  constructor (registry: Registry, value?: Map<string, unknown> | Record<string, unknown> | null) {
+    super(registry, decode(registry, value));
+  }
+
+  /**
+   * @description The chain uses Ethereum addresses
+   */
+  public get isEthereum (): Bool {
+    return this.getT('isEthereum');
+  }
+
+  /**
+   * @description The chain ss58Format
+   */
+  public get ss58Format (): Option<u32> {
+    return this.getT('ss58Format');
+  }
+
+  /**
+   * @description The decimals for each of the tokens
+   */
+  public get tokenDecimals (): Option<Vec<u32>> {
+    return this.getT('tokenDecimals');
+  }
+
+  /**
+   * @description The symbols for the tokens
+   */
+  public get tokenSymbol (): Option<Vec<Text>> {
+    return this.getT('tokenSymbol');
+  }
+}

package/src/generic/ConsensusEngineId.spec.ts

@@ -0,0 +1,23 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '../create/index.js';
+import { CID_AURA, CID_NMBS, GenericConsensusEngineId as ConsensusEngineId } from './ConsensusEngineId.js';
+
+describe('ConsensusEngineId', (): void => {
+  const registry = new TypeRegistry();
+
+  it('creates a valid id for aura', (): void => {
+    expect(new ConsensusEngineId(registry, 'aura').toU8a()).toEqual(CID_AURA);
+  });
+
+  it('reverses an id to string for babe', (): void => {
+    expect(new ConsensusEngineId(registry, 'BABE').toString()).toEqual('BABE');
+  });
+
+  it('creates a valid id for nimbus', (): void => {
+    expect(new ConsensusEngineId(registry, 'nmbs').toU8a()).toEqual(CID_NMBS);
+  });
+});

package/src/generic/ConsensusEngineId.ts

@@ -0,0 +1,131 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Bytes, u32 } from '@pezkuwi/types-codec';
+import type { AnyU8a, Registry } from '@pezkuwi/types-codec/types';
+import type { AccountId, RawAuraPreDigest, RawBabePreDigestCompat } from '../interfaces/index.js';
+
+import { U8aFixed } from '@pezkuwi/types-codec';
+import { BN, bnToU8a, isNumber, stringToU8a, u8aToHex, u8aToString } from '@pezkuwi/util';
+
+export const CID_AURA = /*#__PURE__*/ stringToU8a('aura');
+export const CID_BABE = /*#__PURE__*/ stringToU8a('BABE');
+export const CID_GRPA = /*#__PURE__*/ stringToU8a('FRNK');
+export const CID_POW = /*#__PURE__*/ stringToU8a('pow_');
+export const CID_NMBS = /*#__PURE__*/ stringToU8a('nmbs');
+
+function getAuraAuthor (registry: Registry, bytes: Bytes, sessionValidators: AccountId[]): AccountId {
+  return sessionValidators[
+    registry.createTypeUnsafe<RawAuraPreDigest>('RawAuraPreDigest', [bytes.toU8a(true)])
+      .slotNumber
+      .mod(new BN(sessionValidators.length))
+      .toNumber()
+  ];
+}
+
+function getBabeAuthor (registry: Registry, bytes: Bytes, sessionValidators: AccountId[]): AccountId {
+  const digest = registry.createTypeUnsafe<RawBabePreDigestCompat>('RawBabePreDigestCompat', [bytes.toU8a(true)]);
+
+  return sessionValidators[
+    (digest.value as u32).toNumber()
+  ];
+}
+
+function getBytesAsAuthor (registry: Registry, bytes: Bytes): AccountId {
+  return registry.createTypeUnsafe('AccountId', [bytes]);
+}
+
+/**
+ * @name GenericConsensusEngineId
+ * @description
+ * A 4-byte identifier identifying the engine
+ */
+export class GenericConsensusEngineId extends U8aFixed {
+  constructor (registry: Registry, value?: AnyU8a) {
+    super(
+      registry,
+      isNumber(value)
+        ? bnToU8a(value, { isLe: false })
+        : value,
+      32
+    );
+  }
+
+  /**
+   * @description `true` if the engine matches aura
+   */
+  public get isAura (): boolean {
+    return this.eq(CID_AURA);
+  }
+
+  /**
+   * @description `true` is the engine matches babe
+   */
+  public get isBabe (): boolean {
+    return this.eq(CID_BABE);
+  }
+
+  /**
+   * @description `true` is the engine matches grandpa
+   */
+  public get isGrandpa (): boolean {
+    return this.eq(CID_GRPA);
+  }
+
+  /**
+   * @description `true` is the engine matches pow
+   */
+  public get isPow (): boolean {
+    return this.eq(CID_POW);
+  }
+
+  /**
+   * @description `true` is the engine matches nimbus
+   */
+  public get isNimbus (): boolean {
+    return this.eq(CID_NMBS);
+  }
+
+  /**
+   * @description From the input bytes, decode into an author
+   */
+  public extractAuthor (bytes: Bytes, sessionValidators: AccountId[]): AccountId | undefined {
+    if (sessionValidators?.length) {
+      if (this.isAura) {
+        return getAuraAuthor(this.registry, bytes, sessionValidators);
+      } else if (this.isBabe) {
+        return getBabeAuthor(this.registry, bytes, sessionValidators);
+      }
+    }
+
+    // For pow & Nimbus, the bytes are the actual author
+    if (this.isPow || this.isNimbus) {
+      return getBytesAsAuthor(this.registry, bytes);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  public override toHuman (): string {
+    return this.toString();
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    return 'ConsensusEngineId';
+  }
+
+  /**
+   * @description Override the default toString to return a 4-byte string
+   */
+  public override toString (): string {
+    return this.isAscii
+      ? u8aToString(this)
+      : u8aToHex(this);
+  }
+}