@pezkuwi/types 16.5.8 → 16.5.9

package/src/generic/Call.ts

@@ -1,244 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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

@@ -1,95 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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

@@ -1,93 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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

@@ -1,23 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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

@@ -1,131 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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);
-  }
-}