@pezkuwi/types 16.5.5

package/src/generic/Event.ts

@@ -0,0 +1,200 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyJson, Codec, CodecClass } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { EventMetadataLatest } from '../interfaces/metadata/index.js';
+import type { EventId } from '../interfaces/system/index.js';
+import type { IEvent, IEventData, InterfaceTypes, Registry } from '../types/index.js';
+
+import { Null, Struct, Tuple } from '@pezkuwi/types-codec';
+import { objectProperties, objectSpread } from '@pezkuwi/util';
+
+interface Decoded {
+  DataType: CodecClass<Null> | CodecClass<GenericEventData>;
+  value?: {
+    index: Uint8Array;
+    data: Uint8Array;
+  }
+}
+
+/** @internal */
+function decodeEvent (registry: Registry, value?: Uint8Array): Decoded {
+  if (!value?.length) {
+    return { DataType: Null };
+  }
+
+  const index = value.subarray(0, 2);
+
+  return {
+    DataType: registry.findMetaEvent(index),
+    value: {
+      data: value.subarray(2),
+      index
+    }
+  };
+}
+
+/**
+ * @name GenericEventData
+ * @description
+ * Wrapper for the actual data that forms part of an [[Event]]
+ */
+export class GenericEventData extends Tuple implements IEventData {
+  readonly #meta: EventMetadataLatest;
+  readonly #method: string;
+  readonly #names: string[] | null = null;
+  readonly #section: string;
+  readonly #typeDef: TypeDef[];
+
+  constructor (registry: Registry, value: Uint8Array, meta: EventMetadataLatest, section = '<unknown>', method = '<unknown>') {
+    const fields = meta?.fields || [];
+
+    super(registry, fields.map(({ type }) => registry.createLookupType(type) as keyof InterfaceTypes), value);
+
+    this.#meta = meta;
+    this.#method = method;
+    this.#section = section;
+    this.#typeDef = fields.map(({ type }) => registry.lookup.getTypeDef(type));
+
+    const names = fields
+      .map(({ name }) => registry.lookup.sanitizeField(name)[0])
+      .filter((n): n is string => !!n);
+
+    if (names.length === fields.length) {
+      this.#names = names;
+
+      objectProperties(this, names, (_, i) => this[i]);
+    }
+  }
+
+  /**
+   * @description The wrapped [[EventMetadata]]
+   */
+  public get meta (): EventMetadataLatest {
+    return this.#meta;
+  }
+
+  /**
+   * @description The method as a string
+   */
+  public get method (): string {
+    return this.#method;
+  }
+
+  /**
+   * @description The field names (as available)
+   */
+  public get names (): string[] | null {
+    return this.#names;
+  }
+
+  /**
+   * @description The section as a string
+   */
+  public get section (): string {
+    return this.#section;
+  }
+
+  /**
+   * @description The [[TypeDef]] for this event
+   */
+  public get typeDef (): TypeDef[] {
+    return this.#typeDef;
+  }
+
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  public override toHuman (isExtended?: boolean, disableAscii?: boolean): AnyJson {
+    if (this.#names !== null) {
+      const json: Record<string, AnyJson> = {};
+
+      for (let i = 0, count = this.#names.length; i < count; i++) {
+        json[this.#names[i]] = this[i].toHuman(isExtended, disableAscii);
+      }
+
+      return json;
+    }
+
+    return super.toHuman(isExtended);
+  }
+}
+
+/**
+ * @name GenericEvent
+ * @description
+ * A representation of a system event. These are generated via the [[Metadata]] interfaces and
+ * specific to a specific Substrate runtime
+ */
+export class GenericEvent extends Struct implements IEvent<Codec[]> {
+  // Currently we _only_ decode from Uint8Array, since we expect it to
+  // be used via EventRecord
+  constructor (registry: Registry, _value?: Uint8Array) {
+    const { DataType, value } = decodeEvent(registry, _value);
+
+    super(registry, {
+      index: 'EventId',
+      // eslint-disable-next-line sort-keys
+      data: DataType
+    }, value);
+  }
+
+  /**
+   * @description The wrapped [[EventData]]
+   */
+  public get data (): IEvent<Codec[]>['data'] {
+    return this.getT('data');
+  }
+
+  /**
+   * @description The [[EventId]], identifying the raw event
+   */
+  public get index (): EventId {
+    return this.getT('index');
+  }
+
+  /**
+   * @description The [[EventMetadata]] with the documentation
+   */
+  public get meta (): EventMetadataLatest {
+    return this.data.meta;
+  }
+
+  /**
+   * @description The method string identifying the event
+   */
+  public get method (): string {
+    return this.data.method;
+  }
+
+  /**
+   * @description The section string identifying the event
+   */
+  public get section (): string {
+    return this.data.section;
+  }
+
+  /**
+   * @description The [[TypeDef]] for the event
+   */
+  public get typeDef (): TypeDef[] {
+    return this.data.typeDef;
+  }
+
+  /**
+   * @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> {
+    return objectSpread(
+      {
+        method: this.method,
+        section: this.section
+      },
+      isExpanded
+        ? { docs: this.meta.docs.map((d) => d.toString()) }
+        : null,
+      super.toHuman(isExpanded, disableAscii)
+    );
+  }
+}

package/src/generic/LookupSource.spec.ts

@@ -0,0 +1,123 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import type { GenericAccountId as AccountId, GenericAccountIndex as AccountIndex, GenericLookupSource as LookupSource } from './index.js';
+
+import { TypeRegistry } from '../create/index.js';
+
+describe('LookupSource', (): void => {
+  const registry = new TypeRegistry();
+
+  const testDecode = (type: string, input: LookupSource | AccountId | AccountIndex | number[] | Uint8Array, expected: string): void =>
+    it(`can decode from ${type}`, (): void => {
+      const a = registry.createType('IndicesLookupSource', input);
+
+      expect(a.toString()).toBe(expected);
+    });
+
+  describe('utility', (): void => {
+    it('equals on AccountId', (): void => {
+      const addr = '5DkQbYAExs3M2sZgT1Ec3mKfZnAQCL4Dt9beTCknkCUn5jzo';
+
+      expect(registry.createType('IndicesLookupSource', addr).eq(addr)).toBe(true);
+    });
+
+    it('equals on AccountIndex', (): void => {
+      // see the test below - these are equivalent (with different prefix encoding)
+      expect(registry.createType('IndicesLookupSource', '118r').eq('25GUyv')).toBe(true);
+    });
+  });
+
+  describe('decoding', (): void => {
+    testDecode(
+      'Address',
+      registry.createType('IndicesLookupSource', '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF'),
+      '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF'
+    );
+    testDecode(
+      'AccountId',
+      registry.createType('AccountId', '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF'),
+      '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF'
+    );
+    testDecode(
+      'AccountIndex (mixed prefixes)',
+      registry.createType('IndicesLookupSource', '118r'),
+      // NOTE Expected address here is encoded with prefix 42, input above with 1
+      '25GUyv'
+    );
+    testDecode(
+      'AccountIndex (hex)',
+      registry.createType('AccountIndex', '0x0100'),
+      '25GUyv'
+    );
+    testDecode(
+      'Array',
+      [
+        255,
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8,
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8
+      ],
+      '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF'
+    );
+    testDecode(
+      'Uint8Array (with prefix 255)',
+      Uint8Array.from([
+        255,
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8,
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8
+      ]),
+      '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF'
+    );
+    testDecode(
+      'Uint8Array (with prefix 1 byte)',
+      Uint8Array.from([1]),
+      'F7NZ'
+    );
+    testDecode(
+      'Uint8Array (with prefix 2 bytes)',
+      Uint8Array.from([0xfc, 0, 1]),
+      '25GUyv'
+    );
+    testDecode(
+      'Uint8Array (with prefix 4 bytes)',
+      Uint8Array.from([0xfd, 17, 18, 19, 20]),
+      'Mwz15xP2'
+    );
+    // FIXME The specification allows for 8 byte addresses, however since AccountIndex is u32 internally
+    // (and defined that way in the default Substrate),this does not actually work since it is 8 bytes,
+    // instead of 4 bytes max u32 length
+    // testDecode(
+    //   'Uint8Array (with prefix 8 bytes)',
+    //   Uint8Array.from([0xfe, 17, 18, 19, 20, 21, 22, 23, 24]),
+    //   '3N5RJXxM5fLd4h'
+    // );
+  });
+
+  describe('encoding', (): void => {
+    const testEncode = (to: 'toHex' | 'toString' | 'toU8a', expected: string | Uint8Array): void =>
+      it(`can encode ${to}`, (): void => {
+        const a = registry.createType('IndicesLookupSource', '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF');
+
+        expect(a[to]()).toEqual(expected);
+      });
+
+    testEncode(
+      'toHex',
+      '0xff0102030405060708010203040506070801020304050607080102030405060708'
+    );
+    testEncode(
+      'toString',
+      '5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF'
+    );
+    testEncode(
+      'toU8a',
+      Uint8Array.from([
+        255,
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8,
+        1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8
+      ])
+    );
+  });
+});

package/src/generic/LookupSource.ts

@@ -0,0 +1,141 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Inspect, Registry } from '@pezkuwi/types-codec/types';
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+
+import { AbstractBase } from '@pezkuwi/types-codec';
+import { isBigInt, isBn, isHex, isNumber, isU8a, u8aConcat, u8aToBn, u8aToHex, u8aToU8a } from '@pezkuwi/util';
+import { decodeAddress } from '@pezkuwi/util-crypto';
+
+import { GenericAccountId } from './AccountId.js';
+import { GenericAccountIndex } from './AccountIndex.js';
+
+// eslint-disable-next-line no-use-before-define
+type AnyAddress = bigint | BN | GenericLookupSource | GenericAccountId | GenericAccountIndex | number[] | Uint8Array | number | string;
+
+export const ACCOUNT_ID_PREFIX = new Uint8Array([0xff]);
+
+/** @internal */
+function decodeString (registry: Registry, value: string): GenericAccountId | GenericAccountIndex {
+  const decoded = decodeAddress(value);
+
+  return decoded.length === 32
+    ? registry.createTypeUnsafe('AccountId', [decoded])
+    : registry.createTypeUnsafe('AccountIndex', [u8aToBn(decoded)]);
+}
+
+/** @internal */
+function decodeU8a (registry: Registry, value: Uint8Array): GenericAccountId | GenericAccountIndex {
+  // This allows us to instantiate an address with a raw publicKey. Do this first before
+  // we checking the first byte, otherwise we may split an already-existent valid address
+  if (value.length === 32) {
+    return registry.createTypeUnsafe('AccountId', [value]);
+  } else if (value[0] === 0xff) {
+    return registry.createTypeUnsafe('AccountId', [value.subarray(1)]);
+  }
+
+  const [offset, length] = GenericAccountIndex.readLength(value);
+
+  return registry.createTypeUnsafe('AccountIndex', [u8aToBn(value.subarray(offset, offset + length))]);
+}
+
+/** @internal */
+function decodeAddressOrIndex (registry: Registry, value: AnyAddress): GenericAccountId | GenericAccountIndex {
+  return value instanceof GenericLookupSource
+    ? value.inner
+    : value instanceof GenericAccountId || value instanceof GenericAccountIndex
+      ? value
+      : isBn(value) || isNumber(value) || isBigInt(value)
+        ? registry.createTypeUnsafe('AccountIndex', [value])
+        : Array.isArray(value) || isHex(value) || isU8a(value)
+          ? decodeU8a(registry, u8aToU8a(value))
+          : decodeString(registry, value);
+}
+
+/**
+ * @name LookupSource
+ * @description
+ * A wrapper around an AccountId and/or AccountIndex that is encoded with a prefix.
+ * Since we are dealing with underlying publicKeys (or shorter encoded addresses),
+ * we extend from Base with an AccountId/AccountIndex wrapper. Basically the Address
+ * is encoded as `[ <prefix-byte>, ...publicKey/...bytes ]` as per spec
+ */
+export class GenericLookupSource extends AbstractBase<GenericAccountId | GenericAccountIndex> {
+  constructor (registry: Registry, value: AnyAddress = new Uint8Array()) {
+    super(registry, decodeAddressOrIndex(registry, value));
+  }
+
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+  public override get encodedLength (): number {
+    const rawLength = this._rawLength;
+
+    return rawLength + (
+      // for 1 byte AccountIndexes, we are not adding a specific prefix
+      rawLength > 1
+        ? 1
+        : 0
+    );
+  }
+
+  /**
+   * @description The length of the raw value, either AccountIndex or AccountId
+   */
+  protected get _rawLength (): number {
+    return this.inner instanceof GenericAccountIndex
+      ? GenericAccountIndex.calcLength(this.inner)
+      : this.inner.encodedLength;
+  }
+
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+  override inspect (): Inspect {
+    const value = this.inner.toU8a().subarray(0, this._rawLength);
+
+    return {
+      outer: [
+        new Uint8Array(
+          this.inner instanceof GenericAccountIndex
+            ? GenericAccountIndex.writeLength(value)
+            : ACCOUNT_ID_PREFIX
+        ),
+        value
+      ]
+    };
+  }
+
+  /**
+   * @description Returns a hex string representation of the value
+   */
+  public override toHex (): HexString {
+    return u8aToHex(this.toU8a());
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    return 'Address';
+  }
+
+  /**
+   * @description Encodes the value as a Uint8Array as per the SCALE specifications
+   * @param isBare true when the value has none of the type-specific prefixes (internal)
+   */
+  public override toU8a (isBare?: boolean): Uint8Array {
+    const encoded = this.inner.toU8a().subarray(0, this._rawLength);
+
+    return isBare
+      ? encoded
+      : u8aConcat(
+        this.inner instanceof GenericAccountIndex
+          ? GenericAccountIndex.writeLength(encoded)
+          : ACCOUNT_ID_PREFIX,
+        encoded
+      );
+  }
+}

package/src/generic/MultiAddress.spec.ts

@@ -0,0 +1,52 @@
+// 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('MultiAddress', (): void => {
+  const registry = new TypeRegistry();
+
+  it('decodes from an empty value', (): void => {
+    const a = registry.createType('MultiAddress');
+
+    expect(a.index).toEqual(0);
+    expect(a.toHex()).toEqual('0x000000000000000000000000000000000000000000000000000000000000000000');
+  });
+
+  it('correctly decodes a stream with Address20', (): void => {
+    const a = registry.createType('MultiAddress', '0x0467f89207abe6e1b093befd84a48f03313765929207009e292608');
+
+    expect(a.index).toEqual(4);
+    expect(a.toString()).toEqual('0x67f89207abe6e1b093befd84a48f033137659292');
+  });
+
+  it('correctly decodes an AccountId', (): void => {
+    const a = registry.createType('MultiAddress', '0x0102030405060708010203040506070801020304050607080102030405060708');
+
+    expect(a.index).toEqual(0);
+    expect(a.toString()).toEqual('5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF');
+  });
+
+  it('correctly decodes an AccountIndex', (): void => {
+    const a = registry.createType('MultiAddress', '25GUyv');
+
+    expect(a.index).toEqual(1);
+    expect(a.toString()).toEqual('25GUyv');
+  });
+
+  it('correctly decodes an AccountIndex (AccountIndex input)', (): void => {
+    const a = registry.createType('MultiAddress', registry.createType('AccountIndex', '25GUyv'));
+
+    expect(a.index).toEqual(1);
+    expect(a.toString()).toEqual('25GUyv');
+  });
+
+  it('correctly decodes an Address20', (): void => {
+    const a = registry.createType('MultiAddress', '0x67f89207abe6e1b093befd84a48f033137659292');
+
+    expect(a.index).toEqual(4);
+    expect(a.toString()).toEqual('0x67f89207abe6e1b093befd84a48f033137659292');
+  });
+});

package/src/generic/MultiAddress.ts

@@ -0,0 +1,73 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Inspect, Registry } from '@pezkuwi/types-codec/types';
+
+import { Enum } from '@pezkuwi/types-codec';
+import { isBn, isNumber, isString, isU8a } from '@pezkuwi/util';
+import { decodeAddress } from '@pezkuwi/util-crypto';
+
+import { GenericAccountId } from './AccountId.js';
+import { GenericAccountIndex } from './AccountIndex.js';
+
+function decodeU8a (registry: Registry, u8a: Uint8Array): unknown {
+  if ([0, 32].includes(u8a.length)) {
+    return { Id: u8a };
+  } else if (u8a.length === 20) {
+    return { Address20: u8a };
+  } else if (u8a.length <= 8) {
+    return { Index: registry.createTypeUnsafe<GenericAccountIndex>('AccountIndex', [u8a]).toNumber() };
+  }
+
+  return u8a;
+}
+
+function decodeMultiAny (registry: Registry, value?: unknown): unknown {
+  if (value instanceof GenericAccountId) {
+    return { Id: value };
+  } else if (isU8a(value)) {
+    // NOTE This is after the AccountId check (which is U8a)
+    return decodeU8a(registry, value);
+  } else if (value instanceof GenericMultiAddress) {
+    return value;
+  } else if (value instanceof GenericAccountIndex || isBn(value) || isNumber(value)) {
+    return { Index: isNumber(value) ? value : value.toNumber() };
+  } else if (isString(value)) {
+    return decodeU8a(registry, decodeAddress(value.toString()));
+  }
+
+  return value;
+}
+
+export class GenericMultiAddress extends Enum {
+  constructor (registry: Registry, value?: unknown) {
+    super(registry, {
+      Id: 'AccountId',
+      Index: 'Compact<AccountIndex>',
+      Raw: 'Bytes',
+      // eslint-disable-next-line sort-keys
+      Address32: 'H256',
+      // eslint-disable-next-line sort-keys
+      Address20: 'H160'
+    }, decodeMultiAny(registry, value));
+  }
+
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+  override inspect (): Inspect {
+    const { inner, outer = [] } = this.inner.inspect();
+
+    return {
+      inner,
+      outer: [new Uint8Array([this.index]), ...outer]
+    };
+  }
+
+  /**
+   * @description Returns the string representation of the value
+   */
+  public override toString (): string {
+    return this.value.toString();
+  }
+}