@pezkuwi/types-codec 16.5.5 → 16.5.6

package/src/native/Set.ts

@@ -1,269 +0,0 @@
-// Copyright 2017-2025 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from '@pezkuwi/util/types';
-import type { CodecClass, Inspect, ISet, IU8a, Registry } from '../types/index.js';
-
-import { BN, bnToBn, bnToU8a, isBn, isNumber, isString, isU8a, isUndefined, objectProperties, stringify, stringPascalCase, u8aToBn, u8aToHex, u8aToU8a } from '@pezkuwi/util';
-
-import { compareArray } from '../utils/index.js';
-
-type SetValues = Record<string, number | BN>;
-
-function encodeSet (setValues: SetValues, values: string[]): BN {
-  const encoded = new BN(0);
-
-  for (let i = 0, count = values.length; i < count; i++) {
-    encoded.ior(bnToBn(setValues[values[i]] || 0));
-  }
-
-  return encoded;
-}
-
-/** @internal */
-function decodeSetArray (setValues: SetValues, values: string[]): string[] {
-  const count = values.length;
-  const result = new Array<string>(count);
-
-  for (let i = 0; i < count; i++) {
-    const key = values[i];
-
-    if (isUndefined(setValues[key])) {
-      throw new Error(`Set: Invalid key '${key}' passed to Set, allowed ${Object.keys(setValues).join(', ')}`);
-    }
-
-    result[i] = key;
-  }
-
-  return result;
-}
-
-/** @internal */
-function decodeSetNumber (setValues: SetValues, _value: BN | number): string[] {
-  const bn = bnToBn(_value);
-  const keys = Object.keys(setValues);
-  const result: string[] = [];
-
-  for (let i = 0, count = keys.length; i < count; i++) {
-    const key = keys[i];
-
-    if (bn.and(bnToBn(setValues[key])).eq(bnToBn(setValues[key]))) {
-      result.push(key);
-    }
-  }
-
-  const computed = encodeSet(setValues, result);
-
-  if (!bn.eq(computed)) {
-    throw new Error(`Set: Mismatch decoding '${bn.toString()}', computed as '${computed.toString()}' with ${result.join(', ')}`);
-  }
-
-  return result;
-}
-
-/** @internal */
-function decodeSet (setValues: SetValues, value: string[] | Set<string> | Uint8Array | BN | number | string = 0, bitLength: number): string[] {
-  if (bitLength % 8 !== 0) {
-    throw new Error(`Expected valid bitLength, power of 8, found ${bitLength}`);
-  }
-
-  const byteLength = bitLength / 8;
-
-  if (isU8a(value)) {
-    return value.length === 0
-      ? []
-      : decodeSetNumber(setValues, u8aToBn(value.subarray(0, byteLength), { isLe: true }));
-  } else if (isString(value)) {
-    return decodeSet(setValues, u8aToU8a(value), byteLength);
-  } else if (value instanceof Set || Array.isArray(value)) {
-    const input = Array.isArray(value)
-      ? value
-      : [...value.values()];
-
-    return decodeSetArray(setValues, input);
-  }
-
-  return decodeSetNumber(setValues, value);
-}
-
-/**
- * @name Set
- * @description
- * An Set is an array of string values, represented an an encoded type by
- * a bitwise representation of the values.
- */
-export class CodecSet extends Set<string> implements ISet<string> {
-  readonly registry: Registry;
-
-  public createdAtHash?: IU8a;
-  public initialU8aLength?: number;
-  public isStorageFallback?: boolean;
-
-  readonly #allowed: SetValues;
-  readonly #byteLength: number;
-
-  constructor (registry: Registry, setValues: SetValues, value?: string[] | Set<string> | Uint8Array | BN | number | string, bitLength = 8) {
-    super(decodeSet(setValues, value, bitLength));
-
-    this.registry = registry;
-    this.#allowed = setValues;
-    this.#byteLength = bitLength / 8;
-  }
-
-  public static with (values: SetValues, bitLength?: number): CodecClass<CodecSet> {
-    return class extends CodecSet {
-      static {
-        const keys = Object.keys(values);
-        const count = keys.length;
-        const isKeys = new Array<string>(count);
-
-        for (let i = 0; i < count; i++) {
-          isKeys[i] = `is${stringPascalCase(keys[i])}`;
-        }
-
-        objectProperties(this.prototype, isKeys, (_: string, i: number, self: CodecSet) =>
-          self.strings.includes(keys[i])
-        );
-      }
-
-      constructor (registry: Registry, value?: string[] | Set<string> | Uint8Array | BN | number | string) {
-        super(registry, values, value, bitLength);
-      }
-    };
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  public get encodedLength (): number {
-    return this.#byteLength;
-  }
-
-  /**
-   * @description returns a hash of the contents
-   */
-  public get hash (): IU8a {
-    return this.registry.hash(this.toU8a());
-  }
-
-  /**
-   * @description true is the Set contains no values
-   */
-  public get isEmpty (): boolean {
-    return this.size === 0;
-  }
-
-  /**
-   * @description The actual set values as a string[]
-   */
-  public get strings (): string[] {
-    return [...super.values()];
-  }
-
-  /**
-   * @description The encoded value for the set members
-   */
-  public get valueEncoded (): BN {
-    return encodeSet(this.#allowed, this.strings);
-  }
-
-  /**
-   * @description adds a value to the Set (extended to allow for validity checking)
-   */
-  public override add = (key: string): this => {
-    // ^^^ add = () property done to assign this instance's this, otherwise Set.add creates "some" chaos
-    // we have the isUndefined(this._setValues) in here as well, add is used internally
-    // in the Set constructor (so it is undefined at this point, and should allow)
-    if (this.#allowed && isUndefined(this.#allowed[key])) {
-      throw new Error(`Set: Invalid key '${key}' on add`);
-    }
-
-    super.add(key);
-
-    return this;
-  };
-
-  /**
-   * @description Compares the value of the input to see if there is a match
-   */
-  public eq (other?: unknown): boolean {
-    if (Array.isArray(other)) {
-      // we don't actually care about the order, sort the values
-      return compareArray(this.strings.sort(), other.sort());
-    } else if (other instanceof Set) {
-      return this.eq([...other.values()]);
-    } else if (isNumber(other) || isBn(other as string)) {
-      return this.valueEncoded.eq(bnToBn(other as string));
-    }
-
-    return false;
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  public inspect (): Inspect {
-    return {
-      outer: [this.toU8a()]
-    };
-  }
-
-  /**
-   * @description Returns a hex string representation of the value
-   */
-  public toHex (): HexString {
-    return u8aToHex(this.toU8a());
-  }
-
-  /**
-   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-   */
-  public toHuman (): string[] {
-    return this.toJSON();
-  }
-
-  /**
-   * @description Converts the Object to JSON, typically used for RPC transfers
-   */
-  public toJSON (): string[] {
-    return this.strings;
-  }
-
-  /**
-   * @description The encoded value for the set members
-   */
-  public toNumber (): number {
-    return this.valueEncoded.toNumber();
-  }
-
-  /**
-   * @description Converts the value in a best-fit primitive form
-   */
-  public toPrimitive (): string[] {
-    return this.toJSON();
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  public toRawType (): string {
-    return stringify({ _set: this.#allowed });
-  }
-
-  /**
-   * @description Returns the string representation of the value
-   */
-  public override toString (): string {
-    return `[${this.strings.join(', ')}]`;
-  }
-
-  /**
-   * @description Encodes the value as a Uint8Array as per the SCALE specifications
-   */
-  public toU8a (_isBare?: boolean): Uint8Array {
-    return bnToU8a(this.valueEncoded, {
-      bitLength: this.#byteLength * 8,
-      isLe: true
-    });
-  }
-}

package/src/native/Struct.spec.ts

@@ -1,411 +0,0 @@
-// Copyright 2017-2025 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-/* eslint-disable sort-keys */
-
-import type { Bool, Option } from '@pezkuwi/types-codec';
-import type { CodecTo } from '@pezkuwi/types-codec/types';
-
-import { TypeRegistry } from '@pezkuwi/types';
-import { Enum, Struct, Text, U32, Vec } from '@pezkuwi/types-codec';
-import { stringify } from '@pezkuwi/util';
-
-import { TEST_A } from './Struct.data.js';
-
-describe('Struct', (): void => {
-  const registry = new TypeRegistry();
-
-  describe('decoding', (): void => {
-    const testDecode = (type: string, input: any): void =>
-      it(`can decode from ${type}`, (): void => {
-        const s = new Struct(registry, {
-          foo: Text,
-          bar: U32
-        }, input);
-
-        expect([...s.keys()]).toEqual(['foo', 'bar']);
-        expect(
-          [...s.values()].map((v): string =>
-            v.toString()
-          )
-        ).toEqual(['bazzing', '69']);
-      });
-
-    testDecode('array', ['bazzing', 69]);
-    testDecode('hex', '0x1c62617a7a696e6745000000');
-    testDecode('object', { foo: 'bazzing', bar: 69 });
-    testDecode('Uint8Array', Uint8Array.from([28, 98, 97, 122, 122, 105, 110, 103, 69, 0, 0, 0]));
-    testDecode('Struct.with', new (Struct.with({ foo: 'Text', bar: 'U32' }))(registry, { foo: 'bazzing', bar: 69 }));
-
-    it('decodes null/undefined/empty correctly (& equivalent)', (): void => {
-      const Clazz = Struct.with({
-        txt: Text,
-        u32: U32
-      });
-      const expected = { txt: '', u32: '0' };
-
-      expect(new Clazz(registry, {}).toHuman()).toEqual(expected);
-      expect(new Clazz(registry, null).toHuman()).toEqual(expected);
-      expect(new Clazz(registry, undefined).toHuman()).toEqual(expected);
-    });
-
-    it('decodes with Optionals', (): void => {
-      const Clazz = Struct.with({
-        a: 'Option<Bool>',
-        b: 'Option<Bool>'
-      });
-
-      const c = new Clazz(registry, { a: false }) as unknown as { a: Option<Bool>, b: Option<Bool> };
-
-      expect(c.a.isSome).toEqual(true);
-      expect(c.a.unwrap().isTrue).toEqual(false);
-      expect(c.b.isSome).toEqual(false);
-    });
-
-    it('decodes reusing instantiated inputs', (): void => {
-      const foo = new Text(registry, 'bar');
-
-      expect(
-        (new Struct(
-          registry,
-          { foo: Text },
-          { foo }
-        )).get('foo')
-      ).toBe(foo);
-    });
-
-    it('decodes a more complicated type', (): void => {
-      const s = new Struct(registry, {
-        foo: Vec.with(Struct.with({
-          bar: Text
-        }))
-      }, { foo: [{ bar: 1 }, { bar: 2 }] });
-
-      expect(s.toString()).toBe('{"foo":[{"bar":"1"},{"bar":"2"}]}');
-    });
-
-    it('decodes a previously problematic input', (): void => {
-      let data;
-
-      try {
-        data = new Struct(registry, {
-          a: 'u32',
-          b: 'H256',
-          c: 'H256',
-          swap: Enum.with({
-            A: 'u256',
-            B: 'u256'
-          }),
-          d: Vec.with('u8'),
-          e: 'u8'
-        }, TEST_A);
-      } catch (error) {
-        console.error(error);
-
-        throw error;
-      }
-
-      expect(data.get('d')).toHaveLength(50000);
-    });
-
-    it('decodes from a Map input', (): void => {
-      const s = new Struct(registry, {
-        txt: Text,
-        foo: U32,
-        bar: U32
-      }, new Map<string, unknown>([['a', 42], ['txt', 'fubar']]));
-
-      expect(s.toString()).toEqual('{"txt":"fubar","foo":0,"bar":0}');
-    });
-
-    it('decodes from a snake_case input', (): void => {
-      const input = new Struct(registry, {
-        snakeCaseA: U32,
-        snakeCaseB: Text,
-        other: U32
-      }, { snake_case_a: 42, snake_case_b: 'fubar', other: 69 } as any);
-
-      expect(input.toString()).toEqual('{"snakeCaseA":42,"snakeCaseB":"fubar","other":69}');
-    });
-
-    it('throws when it cannot decode', (): void => {
-      expect(
-        (): Struct<any> => new (
-          Struct.with({
-            txt: Text,
-            u32: U32
-          })
-        )(registry, 'ABC')
-      ).toThrow(/Cannot decode value/);
-    });
-
-    it('throws a sensical error on incorrect array values passed to structs', (): void => {
-      expect(
-        () => new Struct(registry, {
-          _: 'Vec<u32>'
-        }, [123, 456])
-      ).toThrow(/array to object with known keys/);
-    });
-  });
-
-  describe('encoding', (): void => {
-    const testEncode = (to: CodecTo, expected: any): void =>
-      it(`can encode ${to}`, (): void => {
-        const s = new Struct(registry, {
-          foo: Text,
-          bar: U32
-        }, { foo: 'bazzing', bar: 69 });
-
-        expect(s[to]()).toEqual(expected);
-      });
-
-    testEncode('toHex', '0x1c62617a7a696e6745000000');
-    testEncode('toJSON', { foo: 'bazzing', bar: 69 });
-    testEncode('toU8a', Uint8Array.from([28, 98, 97, 122, 122, 105, 110, 103, 69, 0, 0, 0]));
-    testEncode('toString', '{"foo":"bazzing","bar":69}');
-  });
-
-  it('provides a clean toString()', (): void => {
-    expect(
-      new (
-        Struct.with({
-          txt: Text,
-          u32: U32
-        })
-      )(registry, { txt: 'foo', u32: 0x123456 }).toString()
-    ).toEqual('{"txt":"foo","u32":1193046}');
-  });
-
-  it('provides a clean toString() (string types)', (): void => {
-    expect(
-      new (
-        Struct.with({
-          txt: 'Text',
-          num: 'u32',
-          cls: U32
-        })
-      )(registry, { txt: 'foo', num: 0x123456, cls: 123 }).toString()
-    ).toEqual('{"txt":"foo","num":1193046,"cls":123}');
-  });
-
-  it('exposes the properties on the object', (): void => {
-    const struct = new (
-      Struct.with({
-        txt: Text,
-        u32: U32
-      })
-    )(registry, { txt: 'foo', u32: 0x123456 });
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
-    expect((struct as any).txt.toString()).toEqual('foo');
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
-    expect((struct as any).u32.toNumber()).toEqual(0x123456);
-  });
-
-  it('correctly encodes length', (): void => {
-    expect(
-      new (
-        Struct.with({
-          txt: Text,
-          u32: U32
-        })
-      )(registry, { foo: 'bazzing', bar: 69 }).encodedLength
-    ).toEqual(5);
-  });
-
-  it('exposes the types', (): void => {
-    expect(
-      new Struct(registry, {
-        foo: Text,
-        bar: Text,
-        baz: U32
-      }, {
-        foo: 'foo',
-        bar: 'bar',
-        baz: 3
-      }).Type
-    ).toEqual({
-      foo: 'Text',
-      bar: 'Text',
-      baz: 'u32'
-    });
-  });
-
-  it('gets the value at a particular index', (): void => {
-    expect(
-      new (
-        Struct.with({
-          txt: Text,
-          u32: U32
-        })
-      )(registry, { txt: 'foo', u32: 1234 })
-        .getAtIndex(1)
-        .toString()
-    ).toEqual('1234');
-  });
-
-  describe('utils', (): void => {
-    it('compares against other objects', (): void => {
-      const test = {
-        foo: 'foo',
-        bar: 'bar',
-        baz: 3
-      };
-
-      expect(
-        new Struct(registry, {
-          foo: Text,
-          bar: Text,
-          baz: U32
-        }, test).eq(test)
-      ).toBe(true);
-    });
-
-    it('has a sane toPrimitive', (): void => {
-      const S = Struct.with({
-        name: 'Text',
-        description: 'Vec<Text>',
-        fooA: 'Bytes',
-        fooB: 'Bytes',
-        fooC: Struct.with({
-          a: 'u32',
-          b: 'u128',
-          c: 'Compact<u128>',
-          d: 'bool'
-        })
-      });
-
-      expect(
-        new S(registry, {
-          name: 'Something',
-          description: ['One line', 'Another line'],
-          fooA: 'hello world!',
-          fooB: '0x123456',
-          fooC: {
-            a: 1234,
-            b: BigInt('1234567890111213141516'),
-            c: 123456,
-            d: true
-          }
-        }).toPrimitive()
-      ).toEqual({
-        name: 'Something',
-        description: ['One line', 'Another line'],
-        fooA: 'hello world!',
-        fooB: '0x123456',
-        fooC: {
-          a: 1234,
-          b: '1234567890111213141516',
-          c: 123456,
-          d: true
-        }
-      });
-    });
-
-    it('generates sane toRawType', (): void => {
-      expect(
-        new Struct(registry, {
-          accountId: 'AccountId',
-          balanceCompact: registry.createClass('Compact<Balance>'),
-          blockNumber: registry.createClass('BlockNumber'),
-          compactNumber: registry.createClass('Compact<BlockNumber>'),
-          optionNumber: registry.createClass('Option<BlockNumber>'),
-          counter: U32,
-          vector: Vec.with('AccountId')
-        }).toRawType()
-      ).toEqual(stringify({
-        accountId: 'AccountId',
-        balanceCompact: 'Compact<Balance>', // Override in Uint
-        blockNumber: 'BlockNumber',
-        compactNumber: 'Compact<BlockNumber>',
-        optionNumber: 'Option<BlockNumber>',
-        counter: 'u32',
-        vector: 'Vec<AccountId>'
-      }));
-    });
-
-    it('generates sane toRawType (via with)', (): void => {
-      const Type = Struct.with({
-        accountId: 'AccountId',
-        balance: registry.createClass('Balance')
-      });
-
-      expect(
-        new Type(registry).toRawType()
-      ).toEqual(stringify({
-        accountId: 'AccountId',
-        balance: 'Balance' // Override in Uint
-      }));
-    });
-  });
-
-  it('allows toString with large numbers', (): void => {
-    // replicate https://github.com/polkadot-js/api/issues/640
-    expect(
-      new Struct(registry, {
-        blockNumber: registry.createClass('Option<BlockNumber>')
-      }, { blockNumber: '0x0000000010abcdef' }).toString()
-    ).toEqual('{"blockNumber":279694831}');
-  });
-
-  describe('toU8a', (): void => {
-    const def: Record<string, any> = {
-      foo: 'Bytes',
-      method: 'Bytes',
-      bar: 'Option<u32>',
-      baz: 'bool'
-    };
-    const val = {
-      foo: '0x4269',
-      method: '0x99',
-      bar: 1,
-      baz: true
-    };
-
-    it('generates toU8a with undefined', (): void => {
-      expect(
-        new Struct(registry, def, val).toU8a()
-      ).toEqual(new Uint8Array([2 << 2, 0x42, 0x69, 1 << 2, 0x99, 1, 1, 0, 0, 0, 1]));
-    });
-
-    it('generates toU8a with true', (): void => {
-      expect(
-        new Struct(registry, def, val).toU8a(true)
-      ).toEqual(new Uint8Array([0x42, 0x69, 0x99, 1, 0, 0, 0, 1]));
-    });
-
-    it('generates toU8a with { method: true }', (): void => {
-      expect(
-        new Struct(registry, def, val).toU8a({ method: true })
-      ).toEqual(new Uint8Array([2 << 2, 0x42, 0x69, 0x99, 1, 1, 0, 0, 0, 1]));
-    });
-
-    it('has a sane inspect', (): void => {
-      expect(
-        new Struct(registry, def, val).inspect()
-      ).toEqual({
-        inner: [
-          {
-            name: 'foo',
-            outer: [new Uint8Array([2 << 2]), new Uint8Array([0x42, 0x69])]
-          },
-          {
-            name: 'method',
-            outer: [new Uint8Array([1 << 2]), new Uint8Array([0x99])]
-          },
-          {
-            inner: undefined,
-            name: 'bar',
-            outer: [new Uint8Array([1]), new Uint8Array([1, 0, 0, 0])]
-          },
-          {
-            name: 'baz',
-            outer: [new Uint8Array([1])]
-          }
-        ]
-      });
-    });
-  });
-});