@pezkuwi/types 16.5.5

package/src/generic/AccountId.ts

@@ -0,0 +1,100 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyString, AnyU8a, Registry, U8aBitLength } from '@pezkuwi/types-codec/types';
+
+import { U8aFixed } from '@pezkuwi/types-codec';
+import { hexToU8a, isHex, isString, isU8a, u8aToU8a } from '@pezkuwi/util';
+import { decodeAddress, encodeAddress } from '@pezkuwi/util-crypto';
+
+/** @internal */
+function decodeAccountId (value?: AnyU8a | AnyString): Uint8Array {
+  if (isU8a(value) || Array.isArray(value)) {
+    return u8aToU8a(value);
+  } else if (!value) {
+    return new Uint8Array();
+  } else if (isHex(value)) {
+    return hexToU8a(value);
+  } else if (isString(value)) {
+    return decodeAddress(value.toString());
+  }
+
+  throw new Error(`Unknown type passed to AccountId constructor, found typeof ${typeof value}`);
+}
+
+class BaseAccountId extends U8aFixed {
+  constructor (registry: Registry, allowedBits = 256 | 264, value?: AnyU8a) {
+    const decoded = decodeAccountId(value);
+    const decodedBits = decoded.length * 8;
+
+    // Part of stream containing >= 32 bytes or a all empty (defaults)
+    if (decodedBits < allowedBits && decoded.some((b) => b)) {
+      throw new Error(`Invalid AccountId provided, expected ${allowedBits >> 3} bytes, found ${decoded.length}`);
+    }
+
+    super(registry, decoded, allowedBits as U8aBitLength);
+  }
+
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+  public override eq (other?: unknown): boolean {
+    return super.eq(decodeAccountId(other as AnyU8a));
+  }
+
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  public override toHuman (): string {
+    return this.toJSON();
+  }
+
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+  public override toJSON (): string {
+    return this.toString();
+  }
+
+  /**
+   * @description Converts the value in a best-fit primitive form
+   */
+  public override toPrimitive (): string {
+    return this.toJSON();
+  }
+
+  /**
+   * @description Returns the string representation of the value
+   */
+  public override toString (): string {
+    return encodeAddress(this, this.registry.chainSS58);
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    return 'AccountId';
+  }
+}
+
+/**
+ * @name GenericAccountId
+ * @description
+ * A wrapper around an AccountId/PublicKey representation. Since we are dealing with
+ * underlying PublicKeys (32 bytes in length), we extend from U8aFixed which is
+ * just a Uint8Array wrapper with a fixed length.
+ * If constructed with an empty value ([], "", undefined) it will result in
+ * the zero account 0x000...000.
+ */
+export class GenericAccountId extends BaseAccountId {
+  constructor (registry: Registry, value?: AnyU8a) {
+    super(registry, 256, value);
+  }
+}
+
+export class GenericAccountId33 extends BaseAccountId {
+  constructor (registry: Registry, value?: AnyU8a) {
+    super(registry, 264, value);
+  }
+}

package/src/generic/AccountIndex.spec.ts

@@ -0,0 +1,75 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable jest/expect-expect */
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { BN } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../create/index.js';
+import { GenericAccountIndex as AccountIndex } from './index.js';
+
+describe('AccountIndex', (): void => {
+  const registry = new TypeRegistry();
+
+  it('creates a BN representation', (): void => {
+    expect(
+      registry.createType('AccountIndex', new Uint8Array([17, 18, 19, 20])).toNumber()
+    ).toEqual(336794129);
+  });
+
+  it('creates from BigInt', (): void => {
+    expect(
+      registry.createType('AccountIndex', 336794129n).toNumber()
+    ).toEqual(336794129);
+  });
+
+  it('creates a BN representation (from ss-58)', (): void => {
+    expect(
+      registry.createType('AccountIndex', 'Mwz15xP2').toNumber()
+    ).toEqual(336794129);
+  });
+
+  it('constructs 2-byte from number', (): void => {
+    expect(
+      registry.createType('AccountIndex', 256 * 1).toString()
+    ).toEqual('25GUyv');
+  });
+
+  it('constructs from number', (): void => {
+    expect(
+      registry.createType('AccountIndex', new BN(336794129)).toString()
+    ).toEqual('Mwz15xP2');
+  });
+
+  it('compares ss-58 values', (): void => {
+    expect(registry.createType('AccountIndex', 256 * 1).eq('25GUyv')).toBe(true);
+  });
+
+  it('compares numbers', (): void => {
+    expect(registry.createType('AccountIndex', '118r').eq(256 * 1)).toBe(true);
+  });
+
+  describe('calcLength', (): void => {
+    const testLength = (value: number, length: number): void => {
+      expect(AccountIndex.calcLength(value)).toEqual(length);
+    };
+
+    it('returns 1 for <= 0xef', (): void => {
+      testLength(0xef, 1);
+    });
+
+    it('returns 2 for > 0xef', (): void => {
+      testLength(0xf0, 2);
+    });
+
+    it('returns 4 bytes for 32-bit inputs', (): void => {
+      testLength(0xffeeddcc, 4);
+    });
+
+    it('returns 8 bytes for larger inputs', (): void => {
+      testLength(0x122334455, 8);
+    });
+  });
+});

package/src/generic/AccountIndex.ts

@@ -0,0 +1,129 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyNumber, Registry } from '@pezkuwi/types-codec/types';
+
+import { u32 } from '@pezkuwi/types-codec';
+import { BN, bnToBn, isBigInt, isBn, isHex, isNumber, isU8a } from '@pezkuwi/util';
+import { decodeAddress, encodeAddress } from '@pezkuwi/util-crypto';
+
+const PREFIX_1BYTE = 0xef;
+const PREFIX_2BYTE = 0xfc;
+const PREFIX_4BYTE = 0xfd;
+const PREFIX_8BYTE = 0xfe;
+const MAX_1BYTE = new BN(PREFIX_1BYTE);
+const MAX_2BYTE = new BN(1).shln(16);
+const MAX_4BYTE = new BN(1).shln(32);
+
+/** @internal */
+function decodeAccountIndex (value: AnyNumber): BN | bigint | Uint8Array | number | string {
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  if (value instanceof GenericAccountIndex) {
+    // `value.toBn()` on AccountIndex returns a pure BN (i.e. not an
+    // AccountIndex), which has the initial `toString()` implementation.
+    return value.toBn();
+  } else if (isBn(value) || isNumber(value) || isHex(value) || isU8a(value) || isBigInt(value)) {
+    return value;
+  }
+
+  return decodeAccountIndex(decodeAddress(value));
+}
+
+/**
+ * @name GenericAccountIndex
+ * @description
+ * A wrapper around an AccountIndex, which is a shortened, variable-length encoding
+ * for an Account. We extends from [[U32]] to provide the number-like properties.
+ */
+export class GenericAccountIndex extends u32 {
+  constructor (registry: Registry, value: AnyNumber = new BN(0)) {
+    super(registry, decodeAccountIndex(value));
+  }
+
+  public static calcLength (_value: BN | number): number {
+    const value = bnToBn(_value);
+
+    if (value.lte(MAX_1BYTE)) {
+      return 1;
+    } else if (value.lt(MAX_2BYTE)) {
+      return 2;
+    } else if (value.lt(MAX_4BYTE)) {
+      return 4;
+    }
+
+    return 8;
+  }
+
+  public static readLength (input: Uint8Array): [number, number] {
+    const first = input[0];
+
+    if (first === PREFIX_2BYTE) {
+      return [1, 2];
+    } else if (first === PREFIX_4BYTE) {
+      return [1, 4];
+    } else if (first === PREFIX_8BYTE) {
+      return [1, 8];
+    }
+
+    return [0, 1];
+  }
+
+  public static writeLength (input: Uint8Array): Uint8Array {
+    switch (input.length) {
+      case 2: return new Uint8Array([PREFIX_2BYTE]);
+      case 4: return new Uint8Array([PREFIX_4BYTE]);
+      case 8: return new Uint8Array([PREFIX_8BYTE]);
+      default: return new Uint8Array([]);
+    }
+  }
+
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+  public override eq (other?: unknown): boolean {
+    // shortcut for BN or Number, don't create an object
+    if (isBn(other as string) || isNumber(other)) {
+      return super.eq(other);
+    }
+
+    // convert and compare
+    return super.eq(this.registry.createTypeUnsafe('AccountIndex', [other]));
+  }
+
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  public override toHuman (): string {
+    return this.toJSON();
+  }
+
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+  public override toJSON (): string {
+    return this.toString();
+  }
+
+  /**
+   * @description Converts the value in a best-fit primitive form
+   */
+  public override toPrimitive (): string {
+    return this.toJSON();
+  }
+
+  /**
+   * @description Returns the string representation of the value
+   */
+  public override toString (): string {
+    const length = GenericAccountIndex.calcLength(this);
+
+    return encodeAddress(this.toU8a().subarray(0, length), this.registry.chainSS58);
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    return 'AccountIndex';
+  }
+}

package/src/generic/Block.spec.ts

@@ -0,0 +1,49 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+/* eslint-disable sort-keys */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
+import type { BlockValue } from './Block.js';
+
+import block00300 from '@pezkuwi/types-support/json/SignedBlock.003.00.json' assert { type: 'json' };
+import metadataStatic from '@pezkuwi/types-support/metadata/static-substrate';
+import { stringify } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../create/index.js';
+import { Metadata } from '../metadata/index.js';
+import { GenericBlock as Block } from './Block.js';
+
+interface BlockJson {
+  result: {
+    block: BlockValue;
+  };
+}
+
+const registry = new TypeRegistry();
+const metadata = new Metadata(registry, metadataStatic);
+
+registry.setMetadata(metadata);
+
+describe('Block', (): void => {
+  it('has a valid toRawType', (): void => {
+    expect(
+      new Block(registry).toRawType()
+    ).toEqual(
+      // each of the containing structures have been stringified on their own
+      stringify({
+        header: 'Header',
+        extrinsics: 'Vec<Extrinsic>'
+      })
+    );
+  });
+
+  it('re-encodes digest items correctly', (): void => {
+    const digest = new Block(registry, (block00300 as BlockJson).result.block).header.digest;
+
+    expect(digest.logs[0].toHex()).toEqual((block00300 as BlockJson).result.block.header?.digest?.logs[0]);
+    expect(digest.logs[1].toHex()).toEqual((block00300 as BlockJson).result.block.header?.digest?.logs[1]);
+  });
+});

package/src/generic/Block.ts

@@ -0,0 +1,65 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Vec } from '@pezkuwi/types-codec';
+import type { AnyNumber, AnyU8a, IU8a, Registry } from '@pezkuwi/types-codec/types';
+import type { GenericExtrinsic } from '../extrinsic/Extrinsic.js';
+import type { Digest, DigestItem, Header } from '../interfaces/runtime/index.js';
+
+import { Struct } from '@pezkuwi/types-codec';
+
+export interface HeaderValue {
+  digest?: Digest | { logs: DigestItem[] | string[] };
+  extrinsicsRoot?: AnyU8a;
+  number?: AnyNumber;
+  parentHash?: AnyU8a;
+  stateRoot?: AnyU8a;
+}
+
+export interface BlockValue {
+  extrinsics?: AnyU8a[];
+  header?: HeaderValue;
+}
+
+/**
+ * @name GenericBlock
+ * @description
+ * A block encoded with header and extrinsics
+ */
+export class GenericBlock extends Struct {
+  constructor (registry: Registry, value?: BlockValue | Uint8Array) {
+    super(registry, {
+      header: 'Header',
+      // eslint-disable-next-line sort-keys
+      extrinsics: 'Vec<Extrinsic>'
+    }, value);
+  }
+
+  /**
+   * @description Encodes a content [[Hash]] for the block
+   */
+  public get contentHash (): IU8a {
+    return this.registry.hash(this.toU8a());
+  }
+
+  /**
+   * @description The [[Extrinsic]] contained in the block
+   */
+  public get extrinsics (): Vec<GenericExtrinsic> {
+    return this.getT('extrinsics');
+  }
+
+  /**
+   * @description Block/header [[Hash]]
+   */
+  public override get hash (): IU8a {
+    return this.header.hash;
+  }
+
+  /**
+   * @description The [[Header]] of the block
+   */
+  public get header (): Header {
+    return this.getT('header');
+  }
+}

package/src/generic/Call.spec.ts

@@ -0,0 +1,47 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import metadataStatic from '@pezkuwi/types-support/metadata/static-substrate';
+
+import { TypeRegistry } from '../create/index.js';
+import { Metadata } from '../metadata/index.js';
+import { GenericCall as Call } from './index.js';
+
+const registry = new TypeRegistry();
+const metadata = new Metadata(registry, metadataStatic);
+
+registry.setMetadata(metadata);
+
+describe('Call', (): void => {
+  // balances.forceSetBalance(0x, 0)
+  const FSBU8 = new Uint8Array([
+    // index
+    6, 8,
+    // id lookup
+    0,
+    // public
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    // value
+    0
+  ]);
+
+  it('handles decoding correctly (bare)', (): void => {
+    expect(
+      new Call(registry, {
+        args: ['0x0000000000000000000000000000000000000000000000000000000000000000', 0],
+        callIndex: [6, 8]
+      }).toU8a()
+    ).toEqual(FSBU8);
+  });
+
+  it('handles creation from a hex value properly', (): void => {
+    expect(
+      new Call(registry, '0x0608000000000000000000000000000000000000000000000000000000000000000000').toU8a()
+    ).toEqual(FSBU8);
+  });
+});