@pezkuwi/types-codec 16.5.5 → 16.5.6

package/cjs/base/Null.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Null = void 0;
+const util_1 = require("@pezkuwi/util");
+/**
+ * @name Null
+ * @description
+ * Implements a type that does not contain anything (apart from `null`)
+ */
+class Null {
+    encodedLength = 0;
+    isEmpty = true;
+    registry;
+    createdAtHash;
+    initialU8aLength = 0;
+    isStorageFallback;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash() {
+        throw new Error('.hash is not implemented on Null');
+    }
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other) {
+        return other instanceof Null || (0, util_1.isNull)(other);
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {};
+    }
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex() {
+        return '0x';
+    }
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman() {
+        return this.toJSON();
+    }
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON() {
+        return null;
+    }
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive() {
+        return null;
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return 'Null';
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        return '';
+    }
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     */
+    toU8a(_isBare) {
+        return new Uint8Array();
+    }
+}
+exports.Null = Null;

package/cjs/base/Option.d.ts

@@ -0,0 +1,94 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, Codec, CodecClass, DefinitionSetter, Inspect, IOption, IU8a, Registry } from '../types/index.js';
+/**
+ * @name Option
+ * @description
+ * An Option is an optional field. Basically the first byte indicates that there is
+ * is value to follow. If the byte is `1` there is an actual value. So the Option
+ * implements that - decodes, checks for optionality and wraps the required structure
+ * with a value if/as required/found.
+ */
+export declare class Option<T extends Codec> implements IOption<T> {
+    #private;
+    readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
+    constructor(registry: Registry, typeName: CodecClass<T> | string, value?: unknown, { definition, setDefinition }?: DefinitionSetter<CodecClass<T>>);
+    static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Option<O>>;
+    /**
+     * @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 Option has no value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Checks if the Option has no value
+     */
+    get isNone(): boolean;
+    /**
+     * @description Checks if the Option has a value
+     */
+    get isSome(): boolean;
+    /**
+     * @description The actual value for the Option
+     */
+    get value(): T;
+    /**
+     * @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 Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii?: boolean): AnyJson;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(isBare?: boolean): 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;
+    /**
+     * @description Returns the value that the Option represents (if available), throws if null
+     */
+    unwrap(): T;
+    /**
+     * @description Returns the value that the Option represents (if available) or defaultValue if none
+     * @param defaultValue The value to return if the option isNone
+     */
+    unwrapOr<O>(defaultValue: O): T | O;
+    /**
+     * @description Returns the value that the Option represents (if available) or defaultValue if none
+     * @param defaultValue The value to return if the option isNone
+     */
+    unwrapOrDefault(): T;
+}

package/cjs/base/Option.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Option = void 0;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../utils/index.js");
+const Null_js_1 = require("./Null.js");
+class None extends Null_js_1.Null {
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return 'None';
+    }
+}
+/** @internal */
+function decodeOption(registry, Type, value) {
+    if (value instanceof Type) {
+        // don't re-create, use as it (which also caters for derived types)
+        return value;
+    }
+    else if (value instanceof Option) {
+        if (value.value instanceof Type) {
+            // same instance, return it
+            return value.value;
+        }
+        else if (value.isNone) {
+            // internal is None, we are also none
+            return new None(registry);
+        }
+        // convert the actual value into known
+        return new Type(registry, value.value);
+    }
+    else if ((0, util_1.isNull)(value) || (0, util_1.isUndefined)(value) || value === '0x' || value instanceof None) {
+        // anything empty we pass as-is
+        return new None(registry);
+    }
+    else if ((0, util_1.isU8a)(value)) {
+        // the isU8a check happens last in the if-tree - since the wrapped value
+        // may be an instance of it, so Type and Option checks go in first
+        return !value.length || value[0] === 0
+            ? new None(registry)
+            : new Type(registry, value.subarray(1));
+    }
+    return new Type(registry, value);
+}
+/**
+ * @name Option
+ * @description
+ * An Option is an optional field. Basically the first byte indicates that there is
+ * is value to follow. If the byte is `1` there is an actual value. So the Option
+ * implements that - decodes, checks for optionality and wraps the required structure
+ * with a value if/as required/found.
+ */
+class Option {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    #Type;
+    #raw;
+    constructor(registry, typeName, value, { definition, setDefinition = util_1.identity } = {}) {
+        const Type = definition || setDefinition((0, index_js_1.typeToConstructor)(registry, typeName));
+        const decoded = (0, util_1.isU8a)(value) && value.length && !(0, util_1.isCodec)(value)
+            ? value[0] === 0
+                ? new None(registry)
+                : new Type(registry, value.subarray(1))
+            : decodeOption(registry, Type, value);
+        this.registry = registry;
+        this.#Type = Type;
+        this.#raw = decoded;
+        if (decoded?.initialU8aLength) {
+            this.initialU8aLength = 1 + decoded.initialU8aLength;
+        }
+    }
+    static with(Type) {
+        let definition;
+        const setDefinition = (d) => {
+            definition = d;
+            return d;
+        };
+        return class extends Option {
+            constructor(registry, value) {
+                super(registry, Type, value, { definition, setDefinition });
+            }
+        };
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        // boolean byte (has value, doesn't have) along with wrapped length
+        return 1 + this.#raw.encodedLength;
+    }
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash() {
+        return this.registry.hash(this.toU8a());
+    }
+    /**
+     * @description Checks if the Option has no value
+     */
+    get isEmpty() {
+        return this.isNone;
+    }
+    /**
+     * @description Checks if the Option has no value
+     */
+    get isNone() {
+        return this.#raw instanceof None;
+    }
+    /**
+     * @description Checks if the Option has a value
+     */
+    get isSome() {
+        return !this.isNone;
+    }
+    /**
+     * @description The actual value for the Option
+     */
+    get value() {
+        return this.#raw;
+    }
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other) {
+        if (other instanceof Option) {
+            return (this.isSome === other.isSome) && this.value.eq(other.value);
+        }
+        return this.value.eq(other);
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        if (this.isNone) {
+            return { outer: [new Uint8Array([0])] };
+        }
+        const { inner, outer = [] } = this.#raw.inspect();
+        return {
+            inner,
+            outer: [new Uint8Array([1]), ...outer]
+        };
+    }
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex() {
+        // This attempts to align with the JSON encoding - actually in this case
+        // the isSome value is correct, however the `isNone` may be problematic
+        return this.isNone
+            ? '0x'
+            : (0, util_1.u8aToHex)(this.toU8a().subarray(1));
+    }
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended, disableAscii) {
+        return this.#raw.toHuman(isExtended, disableAscii);
+    }
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON() {
+        return this.isNone
+            ? null
+            : this.#raw.toJSON();
+    }
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii) {
+        return this.isNone
+            ? null
+            : this.#raw.toPrimitive(disableAscii);
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(isBare) {
+        const wrapped = this.registry.getClassName(this.#Type) || new this.#Type(this.registry).toRawType();
+        return isBare
+            ? wrapped
+            : `Option<${wrapped}>`;
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        return this.#raw.toString();
+    }
+    /**
+     * @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) {
+        if (isBare) {
+            return this.#raw.toU8a(true);
+        }
+        const u8a = new Uint8Array(this.encodedLength);
+        if (this.isSome) {
+            u8a.set([1]);
+            u8a.set(this.#raw.toU8a(), 1);
+        }
+        return u8a;
+    }
+    /**
+     * @description Returns the value that the Option represents (if available), throws if null
+     */
+    unwrap() {
+        if (this.isNone) {
+            throw new Error('Option: unwrapping a None value');
+        }
+        return this.#raw;
+    }
+    /**
+     * @description Returns the value that the Option represents (if available) or defaultValue if none
+     * @param defaultValue The value to return if the option isNone
+     */
+    unwrapOr(defaultValue) {
+        return this.isSome
+            ? this.unwrap()
+            : defaultValue;
+    }
+    /**
+     * @description Returns the value that the Option represents (if available) or defaultValue if none
+     * @param defaultValue The value to return if the option isNone
+     */
+    unwrapOrDefault() {
+        return this.isSome
+            ? this.unwrap()
+            : new this.#Type(this.registry);
+    }
+}
+exports.Option = Option;

package/cjs/base/Result.d.ts

@@ -0,0 +1,38 @@
+import type { Codec, CodecClass, IResult, Registry } from '../types/index.js';
+import { Enum } from './Enum.js';
+/**
+ * @name Result
+ * @description
+ * A Result maps to the Rust Result type, that can either wrap a success or error value
+ */
+export declare class Result<O extends Codec, E extends Codec> extends Enum implements IResult<O, E> {
+    constructor(registry: Registry, Ok: CodecClass<O> | string, Err: CodecClass<E> | string, value?: unknown);
+    static with<O extends Codec, E extends Codec>(Types: {
+        Ok: CodecClass<O> | string;
+        Err: CodecClass<E> | string;
+    }): CodecClass<Result<O, E>>;
+    /**
+     * @description Returns the wrapper Err value (if isErr)
+     */
+    get asErr(): E;
+    /**
+     * @description Returns the wrapper Ok value (if isOk)
+     */
+    get asOk(): O;
+    /**
+     * @description Checks if the Result has no value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Checks if the Result wraps an Err value
+     */
+    get isErr(): boolean;
+    /**
+     * @description Checks if the Result wraps an Ok value
+     */
+    get isOk(): boolean;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/cjs/base/Result.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Result = void 0;
+const Enum_js_1 = require("./Enum.js");
+/**
+ * @name Result
+ * @description
+ * A Result maps to the Rust Result type, that can either wrap a success or error value
+ */
+class Result extends Enum_js_1.Enum {
+    constructor(registry, Ok, Err, value) {
+        // NOTE This is order-dependent, Ok (with index 0) needs to be first
+        // eslint-disable-next-line sort-keys
+        super(registry, { Ok, Err }, value);
+    }
+    static with(Types) {
+        return class extends Result {
+            constructor(registry, value) {
+                super(registry, Types.Ok, Types.Err, value);
+            }
+        };
+    }
+    /**
+     * @description Returns the wrapper Err value (if isErr)
+     */
+    get asErr() {
+        if (!this.isErr) {
+            throw new Error('Cannot extract Err value from Ok result, check isErr first');
+        }
+        return this.value;
+    }
+    /**
+     * @description Returns the wrapper Ok value (if isOk)
+     */
+    get asOk() {
+        if (!this.isOk) {
+            throw new Error('Cannot extract Ok value from Err result, check isOk first');
+        }
+        return this.value;
+    }
+    /**
+     * @description Checks if the Result has no value
+     */
+    get isEmpty() {
+        return this.isOk && this.value.isEmpty;
+    }
+    /**
+     * @description Checks if the Result wraps an Err value
+     */
+    get isErr() {
+        return !this.isOk;
+    }
+    /**
+     * @description Checks if the Result wraps an Ok value
+     */
+    get isOk() {
+        return this.index === 0;
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        const Types = this._toRawStruct();
+        return `Result<${Types.Ok},${Types.Err}>`;
+    }
+}
+exports.Result = Result;

package/cjs/base/Tuple.d.ts

@@ -0,0 +1,42 @@
+import type { AnyTupleValue, Codec, CodecClass, DefinitionSetter, Inspect, ITuple, Registry } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
+type TupleType = (CodecClass | string);
+type TupleTypes = TupleType[] | Record<string, CodecClass | string>;
+type Definition = [CodecClass[], string[]];
+/**
+ * @name Tuple
+ * @description
+ * A Tuple defines an anonymous fixed-length array, where each element has its
+ * own type. It extends the base JS `Array` object.
+ */
+export declare class Tuple extends AbstractArray<Codec> implements ITuple<Codec[]> {
+    #private;
+    constructor(registry: Registry, Types: TupleTypes | TupleType, value?: AnyTupleValue, { definition, setDefinition }?: DefinitionSetter<Definition>);
+    static with(Types: TupleTypes | TupleType): CodecClass<Tuple>;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description The types definition of the tuple
+     */
+    get Types(): string[];
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @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/cjs/base/Tuple.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tuple = void 0;
+const util_1 = require("@pezkuwi/util");
+const Array_js_1 = require("../abstract/Array.js");
+const index_js_1 = require("../utils/index.js");
+/** @internal */
+function decodeTuple(registry, result, value, Classes) {
+    if (Array.isArray(value)) {
+        const Types = Classes[0];
+        for (let i = 0, count = Types.length; i < count; i++) {
+            try {
+                const entry = value?.[i];
+                result[i] = entry instanceof Types[i]
+                    ? entry
+                    : new Types[i](registry, entry);
+            }
+            catch (error) {
+                throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
+            }
+        }
+        return [result, 0];
+    }
+    else if ((0, util_1.isHex)(value)) {
+        return (0, index_js_1.decodeU8a)(registry, result, (0, util_1.u8aToU8a)(value), Classes);
+    }
+    else if (!value || !result.length) {
+        const Types = Classes[0];
+        for (let i = 0, count = Types.length; i < count; i++) {
+            result[i] = new Types[i](registry);
+        }
+        return [result, 0];
+    }
+    throw new Error(`Expected array input to Tuple decoding, found ${typeof value}: ${(0, util_1.stringify)(value)}`);
+}
+/**
+ * @name Tuple
+ * @description
+ * A Tuple defines an anonymous fixed-length array, where each element has its
+ * own type. It extends the base JS `Array` object.
+ */
+class Tuple extends Array_js_1.AbstractArray {
+    #Types;
+    constructor(registry, Types, value, { definition, setDefinition = util_1.identity } = {}) {
+        const Classes = definition || setDefinition(Array.isArray(Types)
+            ? [(0, index_js_1.typesToConstructors)(registry, Types), []]
+            : (0, util_1.isFunction)(Types) || (0, util_1.isString)(Types)
+                ? [[(0, index_js_1.typeToConstructor)(registry, Types)], []]
+                : (0, index_js_1.mapToTypeMap)(registry, Types));
+        super(registry, Classes[0].length);
+        this.initialU8aLength = ((0, util_1.isU8a)(value)
+            ? (0, index_js_1.decodeU8a)(registry, this, value, Classes)
+            : decodeTuple(registry, this, value, Classes))[1];
+        this.#Types = Classes;
+    }
+    static with(Types) {
+        let definition;
+        // eslint-disable-next-line no-return-assign
+        const setDefinition = (d) => definition = d;
+        return class extends Tuple {
+            constructor(registry, value) {
+                super(registry, Types, value, { definition, setDefinition });
+            }
+        };
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        let total = 0;
+        for (let i = 0, count = this.length; i < count; i++) {
+            total += this[i].encodedLength;
+        }
+        return total;
+    }
+    /**
+     * @description The types definition of the tuple
+     */
+    get Types() {
+        return this.#Types[1].length
+            ? this.#Types[1]
+            : this.#Types[0].map((T) => new T(this.registry).toRawType());
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {
+            inner: this.inspectInner()
+        };
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        const types = this.#Types[0].map((T) => this.registry.getClassName(T) || new T(this.registry).toRawType());
+        return `(${types.join(',')})`;
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        // Overwrite the default toString representation of Array.
+        return (0, util_1.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 (0, util_1.u8aConcatStrict)(this.toU8aInner(isBare));
+    }
+}
+exports.Tuple = Tuple;

package/cjs/base/UInt.d.ts

@@ -0,0 +1,15 @@
+import type { CodecClass, UIntBitLength } from '../types/index.js';
+import { AbstractInt } from '../abstract/Int.js';
+/**
+ * @name UInt
+ * @description
+ * A generic unsigned 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 UInt extends AbstractInt {
+    static with(bitLength: UIntBitLength, typeName?: string): CodecClass<UInt>;
+}