@polkadot/types-codec 6.12.2-21 → 6.12.2-25

package/types/interfaces.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="bn.js" />
+import type { BN } from '@polkadot/util';
+import type { ArgsDef, Codec } from './codec';
+import type { AnyTuple } from './helpers';
+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;
+}
+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 declare 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): 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/types/registry.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="bn.js" />
+import type { BN } from '@polkadot/util';
+import type { Codec, CodecClass } from './codec';
+import type { AnyTuple } from './helpers';
+import type { ICompact, IEnum, IMap, IMethod, INumber, IOption, IResult, ISet, IStruct, ITuple, IU8a, IVec } from './interfaces';
+export declare 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 declare 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;
+    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 CodecRegistry {
+    readonly chainDecimals: number[];
+    readonly chainSS58: number | undefined;
+    readonly chainTokens: string[];
+    createdAtHash?: IU8a;
+    findMetaCall(callIndex: Uint8Array): CallFunction;
+    findMetaError(errorIndex: Uint8Array | {
+        error: BN;
+        index: BN;
+    }): RegistryError;
+    findMetaEvent(eventIndex: Uint8Array): CodecClass<any>;
+    isLookupType(value: string): boolean;
+    createLookupType(lookupId: ICompact<INumber> | number): string;
+    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;
+    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>;
+    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): void;
+}

package/utils/compareArray.d.ts

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

package/utils/compareMap.d.ts

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

package/utils/compareSet.d.ts

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

package/utils/decodeU8a.d.ts

@@ -0,0 +1,13 @@
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+/**
+ * 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, E = T>(registry: CodecRegistry, u8a: Uint8Array, types: CodecClass[] | {
+    [index: string]: CodecClass;
+}, withZip?: boolean): [E[], number];
+export declare function decodeU8aVec<T extends Codec = Codec>(registry: CodecRegistry, u8a: Uint8Array, start: number, Type: CodecClass<T>, count: number): [T[], number, number];

package/utils/index.d.ts

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

package/utils/mapToTypeMap.d.ts

@@ -0,0 +1,5 @@
+import type { CodecClass, CodecRegistry } from '../types';
+/**
+ * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
+ */
+export declare function mapToTypeMap(registry: CodecRegistry, input: Record<string, string | CodecClass>): Record<string, CodecClass>;

package/utils/sanitize.d.ts

@@ -0,0 +1,16 @@
+interface SanitizeOptions {
+    allowNamespaces?: boolean;
+}
+declare type Mapper = (value: string, options?: SanitizeOptions) => string;
+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: String | string, options?: SanitizeOptions): string;
+export {};

package/utils/sortValues.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="bn.js" />
+import type { BN } from '@polkadot/util';
+import type { Codec } from '../types';
+declare 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/utils/typeToConstructor.d.ts

@@ -0,0 +1,2 @@
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+export declare function typeToConstructor<T extends Codec = Codec>(registry: CodecRegistry, type: string | CodecClass<T>): CodecClass<T>;

package/utils/typesToMap.d.ts

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

package/utils/util.d.ts

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