@pezkuwi/types-codec 16.5.6 → 16.5.8

package/build/base/DoNotConstruct.d.ts

@@ -0,0 +1,63 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, Codec, CodecClass, Inspect, IU8a, Registry } from '../types/index.js';
+/**
+ * @name DoNotConstruct
+ * @description
+ * An unknown type that fails on construction with the type info
+ */
+export declare class DoNotConstruct implements Codec {
+    #private;
+    readonly registry: Registry;
+    createdAtHash?: IU8a;
+    isStorageFallback?: boolean;
+    constructor(registry: Registry, typeName?: string);
+    static with(typeName?: string): CodecClass;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the value is an empty value (always true)
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Unimplemented
+     */
+    eq(): boolean;
+    /**
+     * @description Unimplemented
+     */
+    inspect(): Inspect;
+    /**
+     * @description Unimplemented
+     */
+    toHex(): HexString;
+    /**
+     * @description Unimplemented
+     */
+    toHuman(): AnyJson;
+    /**
+     * @description Unimplemented
+     */
+    toJSON(): AnyJson;
+    /**
+     * @description Unimplemented
+     */
+    toPrimitive(): AnyJson;
+    /**
+     * @description Unimplemented
+     */
+    toRawType(): string;
+    /**
+     * @description Unimplemented
+     */
+    toString(): string;
+    /**
+     * @description Unimplemented
+     */
+    toU8a(): Uint8Array;
+}

package/build/base/DoNotConstruct.js

@@ -0,0 +1,95 @@
+/**
+ * @name DoNotConstruct
+ * @description
+ * An unknown type that fails on construction with the type info
+ */
+export class DoNotConstruct {
+    registry;
+    createdAtHash;
+    isStorageFallback;
+    #neverError;
+    constructor(registry, typeName = 'DoNotConstruct') {
+        this.registry = registry;
+        this.#neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);
+        throw this.#neverError;
+    }
+    static with(typeName) {
+        return class extends DoNotConstruct {
+            constructor(registry) {
+                super(registry, typeName);
+            }
+        };
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        throw this.#neverError;
+    }
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Checks if the value is an empty value (always true)
+     */
+    get isEmpty() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    eq() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    inspect() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toHex() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toHuman() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toJSON() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toPrimitive() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toRawType() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toString() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toU8a() {
+        throw this.#neverError;
+    }
+}

package/build/base/Enum.d.ts

@@ -0,0 +1,118 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, Codec, CodecClass, DefinitionSetter, IEnum, Inspect, IU8a, Registry } from '../types/index.js';
+export type EnumCodecClass<T = Codec> = new (registry: Registry, value?: any, index?: number) => T;
+interface Definition {
+    def: TypesDef;
+    isBasic: boolean;
+    isIndexed: boolean;
+}
+interface EntryDef {
+    Type: CodecClass;
+    index: number;
+}
+type TypesDef = Record<string, EntryDef>;
+/**
+ * @name Enum
+ * @description
+ * This implements an enum, that based on the value wraps a different type. It is effectively
+ * an extension to enum where the value type is determined by the actual index.
+ */
+export declare class Enum implements IEnum {
+    #private;
+    readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
+    constructor(registry: Registry, Types: Record<string, string | CodecClass> | Record<string, number> | string[], value?: unknown, index?: number, { definition, setDefinition }?: DefinitionSetter<Definition>);
+    static with(Types: Record<string, string | CodecClass> | Record<string, number> | string[]): EnumCodecClass<Enum>;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash(): IU8a;
+    /**
+     * @description The index of the enum value
+     */
+    get index(): number;
+    /**
+     * @description The value of the enum
+     */
+    get inner(): Codec;
+    /**
+     * @description true if this is a basic enum (no values)
+     */
+    get isBasic(): boolean;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Checks if the Enum points to a [[Null]] type
+     */
+    get isNone(): boolean;
+    /**
+     * @description The available keys for this enum
+     */
+    get defIndexes(): number[];
+    /**
+     * @description The available keys for this enum
+     */
+    get defKeys(): string[];
+    /**
+     * @description The name of the type this enum value represents
+     */
+    get type(): string;
+    /**
+     * @description The value of the enum
+     */
+    get value(): Codec;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex(): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended?: boolean, disableAscii?: boolean): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): AnyJson;
+    /**
+     * @description Returns the number representation for the value
+     */
+    toNumber(): number;
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii?: boolean): AnyJson;
+    /**
+     * @description Returns a raw struct representation of the enum types
+     */
+    protected _toRawStruct(): string[] | Record<string, string | number>;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString(): string;
+    /**
+     * @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)
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}
+export {};

package/build/base/Enum.js

@@ -0,0 +1,369 @@
+import { identity, isHex, isNumber, isObject, isString, isU8a, objectProperties, stringCamelCase, stringify, stringPascalCase, u8aConcatStrict, u8aToHex, u8aToU8a } from '@pezkuwi/util';
+import { mapToTypeMap, typesToMap } from '../utils/index.js';
+import { Null } from './Null.js';
+function isRustEnum(def) {
+    const defValues = Object.values(def);
+    if (defValues.some((v) => isNumber(v))) {
+        if (!defValues.every((v) => isNumber(v) && v >= 0 && v <= 255)) {
+            throw new Error('Invalid number-indexed enum definition');
+        }
+        return false;
+    }
+    return true;
+}
+function extractDef(registry, _def) {
+    const def = {};
+    let isBasic;
+    let isIndexed;
+    if (Array.isArray(_def)) {
+        for (let i = 0, count = _def.length; i < count; i++) {
+            def[_def[i]] = { Type: Null, index: i };
+        }
+        isBasic = true;
+        isIndexed = false;
+    }
+    else if (isRustEnum(_def)) {
+        const [Types, keys] = mapToTypeMap(registry, _def);
+        for (let i = 0, count = keys.length; i < count; i++) {
+            def[keys[i]] = { Type: Types[i], index: i };
+        }
+        isBasic = !Object.values(def).some(({ Type }) => Type !== Null);
+        isIndexed = false;
+    }
+    else {
+        const entries = Object.entries(_def);
+        for (let i = 0, count = entries.length; i < count; i++) {
+            const [key, index] = entries[i];
+            def[key] = { Type: Null, index };
+        }
+        isBasic = true;
+        isIndexed = true;
+    }
+    return {
+        def,
+        isBasic,
+        isIndexed
+    };
+}
+function getEntryType(def, checkIdx) {
+    const values = Object.values(def);
+    for (let i = 0, count = values.length; i < count; i++) {
+        const { Type, index } = values[i];
+        if (index === checkIdx) {
+            return Type;
+        }
+    }
+    throw new Error(`Unable to create Enum via index ${checkIdx}, in ${Object.keys(def).join(', ')}`);
+}
+function createFromU8a(registry, def, index, value) {
+    const Type = getEntryType(def, index);
+    return {
+        index,
+        value: new Type(registry, value)
+    };
+}
+function createFromValue(registry, def, index = 0, value) {
+    const Type = getEntryType(def, index);
+    return {
+        index,
+        value: value instanceof Type
+            ? value
+            : new Type(registry, value)
+    };
+}
+function decodeFromJSON(registry, def, key, value) {
+    // JSON comes in the form of { "<type (camelCase)>": "<value for type>" }, here we
+    // additionally force to lower to ensure forward compat
+    const keys = Object.keys(def).map((k) => k.toLowerCase());
+    const keyLower = key.toLowerCase();
+    const index = keys.indexOf(keyLower);
+    if (index === -1) {
+        throw new Error(`Cannot map Enum JSON, unable to find '${key}' in ${keys.join(', ')}`);
+    }
+    try {
+        return createFromValue(registry, def, Object.values(def)[index].index, value);
+    }
+    catch (error) {
+        throw new Error(`Enum(${key}):: ${error.message}`);
+    }
+}
+function decodeEnum(registry, def, value, index) {
+    // NOTE We check the index path first, before looking at values - this allows treating
+    // the optional indexes before anything else, more-specific > less-specific
+    if (isNumber(index)) {
+        return createFromValue(registry, def, index, value);
+    }
+    else if (isU8a(value) || isHex(value)) {
+        const u8a = u8aToU8a(value);
+        // nested, we don't want to match isObject below
+        if (u8a.length) {
+            return createFromU8a(registry, def, u8a[0], u8a.subarray(1));
+        }
+    }
+    else if (value instanceof Enum) {
+        return createFromValue(registry, def, value.index, value.value);
+    }
+    else if (isNumber(value)) {
+        return createFromValue(registry, def, value);
+    }
+    else if (isString(value)) {
+        return decodeFromJSON(registry, def, value.toString());
+    }
+    else if (isObject(value)) {
+        const key = Object.keys(value)[0];
+        return decodeFromJSON(registry, def, key, value[key]);
+    }
+    // Worst-case scenario, return the first with default
+    return createFromValue(registry, def, Object.values(def)[0].index);
+}
+/**
+ * @name Enum
+ * @description
+ * This implements an enum, that based on the value wraps a different type. It is effectively
+ * an extension to enum where the value type is determined by the actual index.
+ */
+export class Enum {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    #def;
+    #entryIndex;
+    #indexes;
+    #isBasic;
+    #isIndexed;
+    #raw;
+    constructor(registry, Types, value, index, { definition, setDefinition = identity } = {}) {
+        const { def, isBasic, isIndexed } = definition || setDefinition(extractDef(registry, Types));
+        // shortcut isU8a as used in SCALE decoding
+        const decoded = isU8a(value) && value.length && !isNumber(index)
+            ? createFromU8a(registry, def, value[0], value.subarray(1))
+            : decodeEnum(registry, def, value, index);
+        this.registry = registry;
+        this.#def = def;
+        this.#isBasic = isBasic;
+        this.#isIndexed = isIndexed;
+        this.#indexes = Object.values(def).map(({ index }) => index);
+        this.#entryIndex = this.#indexes.indexOf(decoded.index);
+        this.#raw = decoded.value;
+        if (this.#raw.initialU8aLength) {
+            this.initialU8aLength = 1 + this.#raw.initialU8aLength;
+        }
+    }
+    static with(Types) {
+        let definition;
+        // eslint-disable-next-line no-return-assign
+        const setDefinition = (d) => definition = d;
+        return class extends Enum {
+            static {
+                const keys = Array.isArray(Types)
+                    ? Types
+                    : Object.keys(Types);
+                const count = keys.length;
+                const asKeys = new Array(count);
+                const isKeys = new Array(count);
+                for (let i = 0; i < count; i++) {
+                    const name = stringPascalCase(keys[i]);
+                    asKeys[i] = `as${name}`;
+                    isKeys[i] = `is${name}`;
+                }
+                objectProperties(this.prototype, isKeys, (_, i, self) => self.type === keys[i]);
+                objectProperties(this.prototype, asKeys, (k, i, self) => {
+                    if (self.type !== keys[i]) {
+                        throw new Error(`Cannot convert '${self.type}' via ${k}`);
+                    }
+                    return self.value;
+                });
+            }
+            constructor(registry, value, index) {
+                super(registry, Types, value, index, { definition, setDefinition });
+            }
+        };
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        return 1 + this.#raw.encodedLength;
+    }
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash() {
+        return this.registry.hash(this.toU8a());
+    }
+    /**
+     * @description The index of the enum value
+     */
+    get index() {
+        return this.#indexes[this.#entryIndex];
+    }
+    /**
+     * @description The value of the enum
+     */
+    get inner() {
+        return this.#raw;
+    }
+    /**
+     * @description true if this is a basic enum (no values)
+     */
+    get isBasic() {
+        return this.#isBasic;
+    }
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty() {
+        return this.#raw.isEmpty;
+    }
+    /**
+     * @description Checks if the Enum points to a [[Null]] type
+     */
+    get isNone() {
+        return this.#raw instanceof Null;
+    }
+    /**
+     * @description The available keys for this enum
+     */
+    get defIndexes() {
+        return this.#indexes;
+    }
+    /**
+     * @description The available keys for this enum
+     */
+    get defKeys() {
+        return Object.keys(this.#def);
+    }
+    /**
+     * @description The name of the type this enum value represents
+     */
+    get type() {
+        return this.defKeys[this.#entryIndex];
+    }
+    /**
+     * @description The value of the enum
+     */
+    get value() {
+        return this.#raw;
+    }
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other) {
+        // cater for the case where we only pass the enum index
+        if (isU8a(other)) {
+            return !this.toU8a().some((entry, index) => entry !== other[index]);
+        }
+        else if (isNumber(other)) {
+            return this.toNumber() === other;
+        }
+        else if (this.#isBasic && isString(other)) {
+            return this.type === other;
+        }
+        else if (isHex(other)) {
+            return this.toHex() === other;
+        }
+        else if (other instanceof Enum) {
+            return this.index === other.index && this.value.eq(other.value);
+        }
+        else if (isObject(other)) {
+            return this.value.eq(other[this.type]);
+        }
+        // compare the actual wrapper value
+        return this.value.eq(other);
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        if (this.#isBasic) {
+            return { outer: [new Uint8Array([this.index])] };
+        }
+        const { inner, outer = [] } = this.#raw.inspect();
+        return {
+            inner,
+            outer: [new Uint8Array([this.index]), ...outer]
+        };
+    }
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex() {
+        return u8aToHex(this.toU8a());
+    }
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended, disableAscii) {
+        return this.#isBasic || this.isNone
+            ? this.type
+            : { [this.type]: this.#raw.toHuman(isExtended, disableAscii) };
+    }
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON() {
+        return this.#isBasic
+            ? this.type
+            : { [stringCamelCase(this.type)]: this.#raw.toJSON() };
+    }
+    /**
+     * @description Returns the number representation for the value
+     */
+    toNumber() {
+        return this.index;
+    }
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii) {
+        return this.#isBasic
+            ? this.type
+            : { [stringCamelCase(this.type)]: this.#raw.toPrimitive(disableAscii) };
+    }
+    /**
+     * @description Returns a raw struct representation of the enum types
+     */
+    _toRawStruct() {
+        if (this.#isBasic) {
+            return this.#isIndexed
+                ? this.defKeys.reduce((out, key, index) => {
+                    out[key] = this.#indexes[index];
+                    return out;
+                }, {})
+                : this.defKeys;
+        }
+        const entries = Object.entries(this.#def);
+        return typesToMap(this.registry, entries.reduce((out, [key, { Type }], i) => {
+            out[0][i] = Type;
+            out[1][i] = key;
+            return out;
+        }, [new Array(entries.length), new Array(entries.length)]));
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return stringify({ _enum: this._toRawStruct() });
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        return this.isNone
+            ? this.type
+            : stringify(this.toJSON());
+    }
+    /**
+     * @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)
+     */
+    toU8a(isBare) {
+        return isBare
+            ? this.#raw.toU8a(isBare)
+            : u8aConcatStrict([
+                new Uint8Array([this.index]),
+                this.#raw.toU8a(isBare)
+            ]);
+    }
+}

package/build/base/Int.d.ts

@@ -0,0 +1,16 @@
+import type { AnyNumber, CodecClass, Registry, UIntBitLength } from '../types/index.js';
+import { AbstractInt } from '../abstract/Int.js';
+/**
+ * @name Int
+ * @description
+ * A generic signed integer codec. For Bizinikiwi all numbers are Little Endian encoded,
+ * this handles the encoding and decoding of those numbers. Upon construction
+ * the bitLength is provided and any additional use keeps the number to this
+ * length. This extends `BN`, so all methods available on a normal `BN` object
+ * is available here.
+ * @noInheritDoc
+ */
+export declare class Int extends AbstractInt {
+    constructor(registry: Registry, value?: AnyNumber | null, bitLength?: UIntBitLength);
+    static with(bitLength: UIntBitLength, typeName?: string): CodecClass<Int>;
+}

package/build/base/Int.js

@@ -0,0 +1,26 @@
+import { AbstractInt } from '../abstract/Int.js';
+/**
+ * @name Int
+ * @description
+ * A generic signed integer codec. For Bizinikiwi all numbers are Little Endian encoded,
+ * this handles the encoding and decoding of those numbers. Upon construction
+ * the bitLength is provided and any additional use keeps the number to this
+ * length. This extends `BN`, so all methods available on a normal `BN` object
+ * is available here.
+ * @noInheritDoc
+ */
+export class Int extends AbstractInt {
+    constructor(registry, value = 0, bitLength) {
+        super(registry, value, bitLength, true);
+    }
+    static with(bitLength, typeName) {
+        return class extends Int {
+            constructor(registry, value) {
+                super(registry, value, bitLength);
+            }
+            toRawType() {
+                return typeName || super.toRawType();
+            }
+        };
+    }
+}