@pezkuwi/types-codec 16.5.5 → 16.5.8

package/build-tsc/primitive/F64.d.ts

@@ -0,0 +1,11 @@
+import { Float } from '../native/Float.js';
+declare const f64_base: import("../types/codec.js").CodecClass<Float, any[]>;
+/**
+ * @name f64
+ * @description
+ * A 64-bit float
+ */
+export declare class f64 extends f64_base {
+    readonly __FloatType = "f64";
+}
+export {};

package/build-tsc/primitive/I128.d.ts

@@ -0,0 +1,11 @@
+import { Int } from '../base/Int.js';
+declare const i128_base: import("../types/codec.js").CodecClass<Int, any[]>;
+/**
+ * @name i128
+ * @description
+ * A 128-bit signed integer
+ */
+export declare class i128 extends i128_base {
+    readonly __IntType = "i128";
+}
+export {};

package/build-tsc/primitive/I16.d.ts

@@ -0,0 +1,11 @@
+import { Int } from '../base/Int.js';
+declare const i16_base: import("../types/codec.js").CodecClass<Int, any[]>;
+/**
+ * @name i16
+ * @description
+ * A 16-bit signed integer
+ */
+export declare class i16 extends i16_base {
+    readonly __IntType = "i16";
+}
+export {};

package/build-tsc/primitive/I256.d.ts

@@ -0,0 +1,11 @@
+import { Int } from '../base/Int.js';
+declare const i256_base: import("../types/codec.js").CodecClass<Int, any[]>;
+/**
+ * @name i256
+ * @description
+ * A 256-bit signed integer
+ */
+export declare class i256 extends i256_base {
+    readonly __IntType = "i256";
+}
+export {};

package/build-tsc/primitive/I32.d.ts

@@ -0,0 +1,11 @@
+import { Int } from '../base/Int.js';
+declare const i32_base: import("../types/codec.js").CodecClass<Int, any[]>;
+/**
+ * @name i32
+ * @description
+ * A 32-bit signed integer
+ */
+export declare class i32 extends i32_base {
+    readonly __IntType = "i32";
+}
+export {};

package/build-tsc/primitive/I64.d.ts

@@ -0,0 +1,11 @@
+import { Int } from '../base/Int.js';
+declare const i64_base: import("../types/codec.js").CodecClass<Int, any[]>;
+/**
+ * @name i64
+ * @description
+ * A 64-bit signed integer
+ */
+export declare class i64 extends i64_base {
+    readonly __IntType = "i64";
+}
+export {};

package/build-tsc/primitive/I8.d.ts

@@ -0,0 +1,11 @@
+import { Int } from '../base/Int.js';
+declare const i8_base: import("../types/codec.js").CodecClass<Int, any[]>;
+/**
+ * @name i8
+ * @description
+ * An 8-bit signed integer
+ */
+export declare class i8 extends i8_base {
+    readonly __IntType = "i8";
+}
+export {};

package/build-tsc/primitive/ISize.d.ts

@@ -0,0 +1,12 @@
+import type { Registry } from '../types/index.js';
+import { i32 } from './I32.js';
+/**
+ * @name ISize
+ * @description
+ * A System default signed number, typically used in RPC to report non-consensus
+ * data. It is a wrapper for [[I32]] as a WASM default (as generated by Rust bindings).
+ * It is not to be used, since it creates consensus mismatches.
+ */
+export declare class isize extends i32 {
+    constructor(registry: Registry, value?: unknown);
+}

package/build-tsc/primitive/U128.d.ts

@@ -0,0 +1,11 @@
+import { UInt } from '../base/UInt.js';
+declare const u128_base: import("../types/codec.js").CodecClass<UInt, any[]>;
+/**
+ * @name u128
+ * @description
+ * A 128-bit unsigned integer
+ */
+export declare class u128 extends u128_base {
+    readonly __UIntType = "u128";
+}
+export {};

package/build-tsc/primitive/U16.d.ts

@@ -0,0 +1,11 @@
+import { UInt } from '../base/UInt.js';
+declare const u16_base: import("../types/codec.js").CodecClass<UInt, any[]>;
+/**
+ * @name u16
+ * @description
+ * A 16-bit unsigned integer
+ */
+export declare class u16 extends u16_base {
+    readonly __UIntType = "u16";
+}
+export {};

package/build-tsc/primitive/U256.d.ts

@@ -0,0 +1,11 @@
+import { UInt } from '../base/UInt.js';
+declare const u256_base: import("../types/codec.js").CodecClass<UInt, any[]>;
+/**
+ * @name u256
+ * @description
+ * A 256-bit unsigned integer
+ */
+export declare class u256 extends u256_base {
+    readonly __UIntType = "u256";
+}
+export {};

package/build-tsc/primitive/U32.d.ts

@@ -0,0 +1,11 @@
+import { UInt } from '../base/UInt.js';
+declare const u32_base: import("../types/codec.js").CodecClass<UInt, any[]>;
+/**
+ * @name u32
+ * @description
+ * A 32-bit unsigned integer
+ */
+export declare class u32 extends u32_base {
+    readonly __UIntType = "u32";
+}
+export {};

package/build-tsc/primitive/U64.d.ts

@@ -0,0 +1,11 @@
+import { UInt } from '../base/UInt.js';
+declare const u64_base: import("../types/codec.js").CodecClass<UInt, any[]>;
+/**
+ * @name u64
+ * @description
+ * A 64-bit unsigned integer
+ */
+export declare class u64 extends u64_base {
+    readonly __UIntType = "u64";
+}
+export {};

package/build-tsc/primitive/U8.d.ts

@@ -0,0 +1,11 @@
+import { UInt } from '../base/UInt.js';
+declare const u8_base: import("../types/codec.js").CodecClass<UInt, any[]>;
+/**
+ * @name u8
+ * @description
+ * An 8-bit unsigned integer
+ */
+export declare class u8 extends u8_base {
+    readonly __UIntType = "u8";
+}
+export {};

package/build-tsc/primitive/USize.d.ts

@@ -0,0 +1,12 @@
+import type { Registry } from '../types/index.js';
+import { u32 } from './U32.js';
+/**
+ * @name USize
+ * @description
+ * A System default unsigned number, typically used in RPC to report non-consensus
+ * data. It is a wrapper for [[U32]] as a WASM default (as generated by Rust bindings).
+ * It is not to be used, since it created consensus mismatches.
+ */
+export declare class usize extends u32 {
+    constructor(registry: Registry, value?: unknown);
+}

package/build-tsc/primitive/index.d.ts

@@ -0,0 +1,16 @@
+export { f32 as F32, f32 } from './F32.js';
+export { f64 as F64, f64 } from './F64.js';
+export { i8 as I8, i8 } from './I8.js';
+export { i16 as I16, i16 } from './I16.js';
+export { i32 as I32, i32 } from './I32.js';
+export { i64 as I64, i64 } from './I64.js';
+export { i128 as I128, i128 } from './I128.js';
+export { i256 as I256, i256 } from './I256.js';
+export { isize as ISize, isize } from './ISize.js';
+export { u8 as U8, u8 } from './U8.js';
+export { u16 as U16, u16 } from './U16.js';
+export { u32 as U32, u32 } from './U32.js';
+export { u64 as U64, u64 } from './U64.js';
+export { u128 as U128, u128 } from './U128.js';
+export { u256 as U256, u256 } from './U256.js';
+export { usize as USize, usize } from './USize.js';

package/build-tsc/types/codec.d.ts

@@ -0,0 +1,113 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, ToString } from './helpers.js';
+import type { IU8a } from './interfaces.js';
+import type { Registry } from './registry.js';
+export type BareOpts = boolean | Record<string, boolean>;
+export interface Inspect {
+    inner?: Inspect[] | undefined;
+    name?: string;
+    outer?: Uint8Array[];
+}
+/**
+ * @name Codec
+ * @description
+ * The base Codec interface. All types implement the interface provided here.
+ * Additionally implementors can add their own specific interfaces and helpers
+ * with getters and functions. The Codec Base is however required for operating
+ * as an encoding/decoding layer
+ */
+export interface Codec {
+    /**
+     * @description
+     * The block at which this value was retrieved/created (set to non-empty when
+     * retrieved from storage)
+     */
+    createdAtHash?: IU8a | undefined;
+    /**
+     * @description
+     * The length of the initial encoded value (Only available when the value was
+     * constructed from a Uint8Array input)
+     */
+    initialU8aLength?: number | undefined;
+    /**
+     * @description
+     * (internal usage) Indicates that the value was created via a fallback. This
+     * is used when with data specified in the metadata when the storage entry is
+     * empty.
+     *
+     * With metadata fallback values (available as defaults on most storage entries)
+     * any empty storage item should erturn the default. (This is the same as the
+     * implementation on the Bizinikiwi runtime)
+     */
+    isStorageFallback?: boolean;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    readonly encodedLength: number;
+    /**
+     * @description Returns a hash of the value
+     */
+    readonly hash: IU8a;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    readonly isEmpty: boolean;
+    /**
+     * @description The registry associated with this object
+     */
+    readonly registry: Registry;
+    /**
+     * @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(isBare?: BareOpts): Inspect;
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    toHex(isLe?: boolean): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     * @param isExtended When set, for some (e.g. call) it can add more info, e.g. metadata documentation. (Generally not needed in all cases, but can be useful in Events, Calls, ...)
+     * @param disableAscii When set, for some (e.g. `Raw` types) it will disable converting the value to ascii.
+     */
+    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
+     * @param disableAscii
+     */
+    toPrimitive(disableAscii?: boolean): AnyJson;
+    /**
+     * @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 use, only available on
+     * some Codec types, specifically those that add encodings such as length of indexes)
+     */
+    toU8a(isBare?: BareOpts): Uint8Array;
+}
+export interface CodecClass<T = Codec, A extends unknown[] = any[]> {
+    /**
+     * @description An internal fallback type (previous generation) if encoding fails
+     */
+    readonly __fallbackType?: string;
+    new (registry: Registry, ...args: A): T;
+}
+export interface CodecObject<T extends ToString> extends Codec {
+    readonly $: T;
+    valueOf(): T;
+}
+export type CodecTo = 'toHex' | 'toJSON' | 'toPrimitive' | 'toString' | 'toU8a';
+export type ArgsDef = Record<string, CodecClass | string>;

package/build-tsc/types/helpers.d.ts

@@ -0,0 +1,27 @@
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+import type { Codec } from './codec.js';
+export type AnyJson = string | number | boolean | null | undefined | AnyJson[] | {
+    [index: string]: AnyJson;
+};
+export type AnyFunction = (...args: any[]) => any;
+export type AnyNumber = BN | bigint | Uint8Array | number | string;
+export type AnyFloat = Number | number | Uint8Array | string;
+export type AnyString = String | string;
+export type AnyBool = Boolean | boolean;
+export type AnyTuple = Codec[];
+export type AnyU8a = Uint8Array | number[] | string;
+export type UIntBitLength = 8 | 16 | 32 | 64 | 128 | 256;
+export type U8aBitLength = 8 | 16 | 32 | 64 | 128 | 160 | 256 | 264 | 512 | 520 | 1024 | 2048;
+export type AnyTupleValue = Exclude<AnyU8a, string> | HexString | (Codec | AnyU8a | AnyNumber | AnyString | undefined | null)[];
+export interface ToString {
+    toString: () => string;
+}
+export interface ToBn {
+    toBn: () => BN;
+}
+export interface DefinitionSetter<T> {
+    definition?: T | undefined;
+    setDefinition?: (d: T) => T;
+}
+export type LookupString = `Lookup${number}`;

package/build-tsc/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './codec.js';
+export * from './helpers.js';
+export * from './interfaces.js';
+export * from './registry.js';

package/build-tsc/types/interfaces.d.ts

@@ -0,0 +1,74 @@
+import type { BN } from '@pezkuwi/util';
+import type { ArgsDef, Codec } from './codec.js';
+import type { AnyTuple } from './helpers.js';
+export interface ICompact<T extends INumber = INumber> extends Codec {
+    toBigInt(): bigint;
+    toBn(): BN;
+    toNumber(): number;
+    unwrap(): T;
+}
+export interface IEnum extends Codec {
+    readonly defIndexes: number[];
+    readonly defKeys: string[];
+    readonly index: number;
+    readonly isBasic: boolean;
+    readonly type: string;
+    readonly value: Codec;
+    toNumber(): number;
+}
+export interface IMap<K extends Codec = Codec, V extends Codec = Codec> extends Map<K, V>, Codec {
+}
+export interface INumber extends Codec {
+    bitLength(): number;
+    toBigInt(): bigint;
+    toBn(): BN;
+    toNumber(): number;
+    toPrimitive(disableAscii?: boolean): string | number;
+}
+export interface IFloat extends Codec {
+    toNumber(): number;
+}
+export interface IOption<T extends Codec = Codec> extends Codec {
+    readonly isNone: boolean;
+    readonly isSome: boolean;
+    readonly value: Codec;
+    unwrap(): T;
+    unwrapOr<O>(other: O): T | O;
+    unwrapOrDefault(): T;
+}
+export interface IResult<O extends Codec = Codec, E extends Codec = Codec> extends IEnum {
+    readonly asErr: E;
+    readonly asOk: O;
+    readonly isErr: boolean;
+    readonly isOk: boolean;
+}
+export interface ISet<K = string> extends Set<K>, Codec {
+    readonly strings: string[];
+}
+export interface IStruct<K = string, V extends Codec = Codec> extends Map<K, V>, Codec {
+    readonly defKeys: string[];
+    getAtIndex(index: number): Codec;
+    toArray(): Codec[];
+}
+export interface IText extends String, Codec {
+}
+export type ITuple<T extends AnyTuple = Codec[]> = T & Codec;
+export interface IU8a extends Uint8Array, Codec {
+    readonly isAscii: boolean;
+    readonly isUtf8: boolean;
+    bitLength(): number;
+    toHuman(isExtended?: boolean, disableAscii?: boolean): any;
+    toJSON(): any;
+    toUtf8(): string;
+}
+export interface IVec<T extends Codec = Codec> extends Array<T>, Codec {
+    toArray(): T[];
+}
+export interface IMethod<A extends AnyTuple = AnyTuple, M = any> extends Codec {
+    readonly args: A;
+    readonly argsDef: ArgsDef;
+    readonly callIndex: Uint8Array;
+    readonly data: Uint8Array;
+    readonly meta: M;
+    is: (tx: IMethod<AnyTuple>) => tx is IMethod<A>;
+}

package/build-tsc/types/registry.d.ts

@@ -0,0 +1,67 @@
+import type { BN } from '@pezkuwi/util';
+import type { Codec, CodecClass } from './codec.js';
+import type { AnyTuple, LookupString } from './helpers.js';
+import type { ICompact, IEnum, IMap, IMethod, INumber, IOption, IResult, ISet, IStruct, ITuple, IU8a, IVec } from './interfaces.js';
+export type OnlyCodec<K, T, Types> = K extends keyof Types ? Types[K] : T extends ICompact | IEnum | IMap | IMethod | INumber | IOption | IResult | ISet | IStruct | ITuple | IU8a | IVec ? T : T extends Codec ? T : never;
+export interface RegistryError {
+    args: string[];
+    docs: string[];
+    index: number;
+    method: string;
+    name: string;
+    section: string;
+}
+export type RegistryTypes = Record<string, CodecClass | string | Record<string, string> | {
+    _enum: string[] | Record<string, number> | Record<string, string | null>;
+} | {
+    _set: Record<string, number>;
+}>;
+export interface CodecCreateOptions {
+    blockHash?: Uint8Array | string | null | undefined;
+    isFallback?: boolean;
+    isOptional?: boolean;
+    isPedantic?: boolean;
+}
+export interface CallBase<A extends AnyTuple, M = any> extends IMethod<A, M> {
+    readonly method: string;
+    readonly section: string;
+    toJSON: () => any;
+}
+export interface CallFunction<A extends AnyTuple = AnyTuple, M = any> extends CallBase<A, M> {
+    (...args: any[]): IMethod<A, M>;
+}
+export interface Registry {
+    readonly chainDecimals: number[];
+    readonly chainIsEthereum: boolean;
+    readonly chainSS58: number | undefined;
+    readonly chainTokens: string[];
+    createdAtHash?: IU8a;
+    findMetaCall(callIndex: Uint8Array): CallFunction;
+    findMetaError(errorIndex: Uint8Array | {
+        error: BN;
+        index: BN;
+    } | {
+        error: BN | Uint8Array;
+        index: BN;
+    }): RegistryError;
+    findMetaEvent(eventIndex: Uint8Array): CodecClass<any>;
+    isLookupType(value: string): value is LookupString;
+    createLookupType(lookupId: ICompact<INumber> | number): LookupString;
+    createClassUnsafe<T extends Codec = Codec, K extends string = string>(type: K): CodecClass<T>;
+    createTypeUnsafe<T extends Codec = Codec, K extends string = string>(type: K, params: unknown[], options?: CodecCreateOptions): T;
+    get(...params: never[]): any;
+    getClassName(clazz: CodecClass): string | undefined;
+    getOrThrow<T extends Codec = Codec, K extends string = string>(name: K, msg?: string): CodecClass<T>;
+    getOrUnknown<T extends Codec = Codec, K extends string = string>(name: K): CodecClass<T>;
+    getTransactionExtensionVersion(): number;
+    getSignedExtensionExtra(): Record<string, string>;
+    getSignedExtensionTypes(): Record<string, string>;
+    hasClass(name: string): boolean;
+    hasDef(name: string): boolean;
+    hasType(name: string): boolean;
+    hash(data: Uint8Array): IU8a;
+    register(type: CodecClass | RegistryTypes): void;
+    register(name: string, type: CodecClass): void;
+    register(arg1: string | CodecClass | RegistryTypes, arg2?: CodecClass): void;
+    setMetadata(metadata: unknown, signedExtensions?: string[], userExtensions?: unknown, noInitWarn?: boolean): void;
+}

package/build-tsc/utils/compareArray.d.ts

@@ -0,0 +1 @@
+export declare function compareArray(a: unknown[], b?: unknown): boolean;

package/build-tsc/utils/compareMap.d.ts

@@ -0,0 +1 @@
+export declare function compareMap(a: Map<unknown, unknown>, b?: unknown): boolean;

package/build-tsc/utils/compareSet.d.ts

@@ -0,0 +1 @@
+export declare function compareSet(a: Set<unknown>, b?: unknown): boolean;

package/build-tsc/utils/decodeU8a.d.ts

@@ -0,0 +1,26 @@
+import type { Codec, CodecClass, Registry } from '../types/index.js';
+/**
+ * @internal
+ *
+ * Given an u8a, and an array of Type constructors, decode the u8a against the
+ * types, and return an array of decoded values.
+ *
+ * @param u8a - The u8a to decode.
+ * @param result - The result array (will be returned with values pushed)
+ * @param types - The array of CodecClass to decode the U8a against.
+ */
+export declare function decodeU8a<T extends Codec = Codec>(registry: Registry, result: T[], u8a: Uint8Array, [Types, keys]: [CodecClass<T>[], string[]]): [T[], number];
+/**
+ * @internal
+ *
+ * Split from decodeU8a since this is specialized to zip returns ... while we duplicate, this
+ * is all on the hot-path, so it is not great, however there is (some) method behind the madness
+ */
+export declare function decodeU8aStruct(registry: Registry, result: [string, Codec][], u8a: Uint8Array, [Types, keys]: [CodecClass[], string[]]): [[string, Codec][], number];
+/**
+ * @internal
+ *
+ * Split from decodeU8a since this is specialized to 1 instance ... while we duplicate, this
+ * is all on the hot-path, so it is not great, however there is (some) method behind the madness
+ */
+export declare function decodeU8aVec<T extends Codec = Codec>(registry: Registry, result: unknown[], u8a: Uint8Array, startAt: number, Type: CodecClass<T>): [number, number];

package/build-tsc/utils/index.d.ts

@@ -0,0 +1,8 @@
+export { compareArray } from './compareArray.js';
+export { compareMap } from './compareMap.js';
+export { compareSet } from './compareSet.js';
+export { decodeU8a, decodeU8aStruct, decodeU8aVec } from './decodeU8a.js';
+export { sanitize } from './sanitize.js';
+export { sortAsc, sortMap, sortSet } from './sortValues.js';
+export { mapToTypeMap, typesToConstructors, typeToConstructor } from './toConstructors.js';
+export { typesToMap } from './typesToMap.js';

package/build-tsc/utils/sanitize.d.ts

@@ -0,0 +1,15 @@
+import type { AnyString } from '../types/index.js';
+type Mapper = (value: string) => string;
+export declare function trim(): Mapper;
+export declare function findClosing(value: string, start: number): number;
+export declare function alias(src: string, dest: string, withChecks?: boolean): Mapper;
+export declare function cleanupCompact(): Mapper;
+export declare function flattenSingleTuple(): Mapper;
+export declare function removeExtensions(type: string, isSized: boolean): Mapper;
+export declare function removeColons(): Mapper;
+export declare function removeGenerics(): Mapper;
+export declare function removePairOf(): Mapper;
+export declare function removeTraits(): Mapper;
+export declare function removeWrap(check: string): Mapper;
+export declare function sanitize(value: AnyString): string;
+export {};

package/build-tsc/utils/sortValues.d.ts

@@ -0,0 +1,12 @@
+import type { BN } from '@pezkuwi/util';
+import type { Codec } from '../types/index.js';
+type SortArg = Codec | Codec[] | number[] | BN | bigint | number | Uint8Array;
+/**
+* Sort keys/values of BTreeSet/BTreeMap in ascending order for encoding compatibility with Rust's BTreeSet/BTreeMap
+* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeSet.html)
+* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html)
+*/
+export declare function sortAsc<V extends SortArg = Codec>(a: V, b: V): number;
+export declare function sortSet<V extends Codec = Codec>(set: Set<V>): Set<V>;
+export declare function sortMap<K extends Codec = Codec, V extends Codec = Codec>(map: Map<K, V>): Map<K, V>;
+export {};

package/build-tsc/utils/toConstructors.d.ts

@@ -0,0 +1,16 @@
+import type { Codec, CodecClass, Registry } from '../types/index.js';
+/**
+ * @internal
+ * From a type string or class, return the associated type class
+ */
+export declare function typeToConstructor<T extends Codec = Codec>(registry: Registry, type: string | CodecClass<T>): CodecClass<T>;
+/**
+ * @internal
+ * Takes an input array of types and returns the associated classes for it
+*/
+export declare function typesToConstructors<T extends Codec = Codec>(registry: Registry, types: (string | CodecClass<T>)[]): CodecClass<T>[];
+/**
+ * @internal
+ * Takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
+ */
+export declare function mapToTypeMap(registry: Registry, input: Record<string, string | CodecClass>): [CodecClass[], string[]];

package/build-tsc/utils/typesToMap.d.ts

@@ -0,0 +1,2 @@
+import type { CodecClass, Registry } from '../types/index.js';
+export declare function typesToMap(registry: Registry, [Types, keys]: [CodecClass[], string[]]): Record<string, string>;

package/build-tsc/utils/util.d.ts

@@ -0,0 +1,3 @@
+export declare function hasEq(o: unknown): o is {
+    eq: (other: unknown) => boolean;
+};