@polkadot/types-codec 6.12.2-10

package/primitive/U8.js

@@ -0,0 +1,16 @@
+// Copyright 2017-2021 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { UInt } from "../base/UInt.js";
+/**
+ * @name u8
+ * @description
+ * An 8-bit unsigned integer
+ */
+
+export class u8 extends UInt.with(8) {
+  constructor(...args) {
+    super(...args);
+    this.__UIntType = 'u8';
+  }
+
+}

package/primitive/USize.cjs

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usize = void 0;
+
+var _U = require("./U32.cjs");
+
+// Copyright 2017-2021 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @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.
+ */
+class usize extends _U.u32 {
+  constructor(registry, value) {
+    super(registry, value);
+    throw new Error('The `usize` type should not be used. Since it is platform-specific, it creates incompatibilities between native (generally u64) and WASM (always u32) code. Use one of the `u32` or `u64` types explicitly.');
+  }
+
+}
+
+exports.usize = usize;

package/primitive/USize.d.ts

@@ -0,0 +1,12 @@
+import type { CodecRegistry } from '../types';
+import { u32 } from './U32';
+/**
+ * @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: CodecRegistry, value?: unknown);
+}

package/primitive/USize.js

@@ -0,0 +1,18 @@
+// Copyright 2017-2021 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+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 class usize extends u32 {
+  constructor(registry, value) {
+    super(registry, value);
+    throw new Error('The `usize` type should not be used. Since it is platform-specific, it creates incompatibilities between native (generally u64) and WASM (always u32) code. Use one of the `u32` or `u64` types explicitly.');
+  }
+
+}

package/primitive/index.cjs

@@ -0,0 +1,187 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "I128", {
+  enumerable: true,
+  get: function () {
+    return _I5.i128;
+  }
+});
+Object.defineProperty(exports, "I16", {
+  enumerable: true,
+  get: function () {
+    return _I2.i16;
+  }
+});
+Object.defineProperty(exports, "I256", {
+  enumerable: true,
+  get: function () {
+    return _I6.i256;
+  }
+});
+Object.defineProperty(exports, "I32", {
+  enumerable: true,
+  get: function () {
+    return _I3.i32;
+  }
+});
+Object.defineProperty(exports, "I64", {
+  enumerable: true,
+  get: function () {
+    return _I4.i64;
+  }
+});
+Object.defineProperty(exports, "I8", {
+  enumerable: true,
+  get: function () {
+    return _I.i8;
+  }
+});
+Object.defineProperty(exports, "U128", {
+  enumerable: true,
+  get: function () {
+    return _U5.u128;
+  }
+});
+Object.defineProperty(exports, "U16", {
+  enumerable: true,
+  get: function () {
+    return _U2.u16;
+  }
+});
+Object.defineProperty(exports, "U256", {
+  enumerable: true,
+  get: function () {
+    return _U6.u256;
+  }
+});
+Object.defineProperty(exports, "U32", {
+  enumerable: true,
+  get: function () {
+    return _U3.u32;
+  }
+});
+Object.defineProperty(exports, "U64", {
+  enumerable: true,
+  get: function () {
+    return _U4.u64;
+  }
+});
+Object.defineProperty(exports, "U8", {
+  enumerable: true,
+  get: function () {
+    return _U.u8;
+  }
+});
+Object.defineProperty(exports, "USize", {
+  enumerable: true,
+  get: function () {
+    return _USize.usize;
+  }
+});
+Object.defineProperty(exports, "i128", {
+  enumerable: true,
+  get: function () {
+    return _I5.i128;
+  }
+});
+Object.defineProperty(exports, "i16", {
+  enumerable: true,
+  get: function () {
+    return _I2.i16;
+  }
+});
+Object.defineProperty(exports, "i256", {
+  enumerable: true,
+  get: function () {
+    return _I6.i256;
+  }
+});
+Object.defineProperty(exports, "i32", {
+  enumerable: true,
+  get: function () {
+    return _I3.i32;
+  }
+});
+Object.defineProperty(exports, "i64", {
+  enumerable: true,
+  get: function () {
+    return _I4.i64;
+  }
+});
+Object.defineProperty(exports, "i8", {
+  enumerable: true,
+  get: function () {
+    return _I.i8;
+  }
+});
+Object.defineProperty(exports, "u128", {
+  enumerable: true,
+  get: function () {
+    return _U5.u128;
+  }
+});
+Object.defineProperty(exports, "u16", {
+  enumerable: true,
+  get: function () {
+    return _U2.u16;
+  }
+});
+Object.defineProperty(exports, "u256", {
+  enumerable: true,
+  get: function () {
+    return _U6.u256;
+  }
+});
+Object.defineProperty(exports, "u32", {
+  enumerable: true,
+  get: function () {
+    return _U3.u32;
+  }
+});
+Object.defineProperty(exports, "u64", {
+  enumerable: true,
+  get: function () {
+    return _U4.u64;
+  }
+});
+Object.defineProperty(exports, "u8", {
+  enumerable: true,
+  get: function () {
+    return _U.u8;
+  }
+});
+Object.defineProperty(exports, "usize", {
+  enumerable: true,
+  get: function () {
+    return _USize.usize;
+  }
+});
+
+var _I = require("./I8.cjs");
+
+var _I2 = require("./I16.cjs");
+
+var _I3 = require("./I32.cjs");
+
+var _I4 = require("./I64.cjs");
+
+var _I5 = require("./I128.cjs");
+
+var _I6 = require("./I256.cjs");
+
+var _U = require("./U8.cjs");
+
+var _U2 = require("./U16.cjs");
+
+var _U3 = require("./U32.cjs");
+
+var _U4 = require("./U64.cjs");
+
+var _U5 = require("./U128.cjs");
+
+var _U6 = require("./U256.cjs");
+
+var _USize = require("./USize.cjs");

package/primitive/index.d.ts

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

package/primitive/index.js

@@ -0,0 +1,15 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export { i8, i8 as I8 } from "./I8.js";
+export { i16, i16 as I16 } from "./I16.js";
+export { i32, i32 as I32 } from "./I32.js";
+export { i64, i64 as I64 } from "./I64.js";
+export { i128, i128 as I128 } from "./I128.js";
+export { i256, i256 as I256 } from "./I256.js";
+export { u8, u8 as U8 } from "./U8.js";
+export { u16, u16 as U16 } from "./U16.js";
+export { u32, u32 as U32 } from "./U32.js";
+export { u64, u64 as U64 } from "./U64.js";
+export { u128, u128 as U128 } from "./U128.js";
+export { u256, u256 as U256 } from "./U256.js";
+export { usize, usize as USize } from "./USize.js";

package/types/codec.cjs

@@ -0,0 +1 @@
+"use strict";

package/types/codec.d.ts

@@ -0,0 +1,77 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson } from './helpers';
+import type { IU8a } from './interfaces';
+import type { CodecRegistry } from './registry';
+export declare type BareOpts = boolean | Record<string, boolean>;
+/**
+ * @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 length of the value when encoded as a Uint8Array
+     */
+    readonly encodedLength: number;
+    /**
+     * @description Returns a hash of the value
+     */
+    readonly hash: IU8a;
+    /**
+     * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
+     */
+    readonly initialU8aLength?: number;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    readonly isEmpty: boolean;
+    /**
+     * @description The registry associated with this object
+     */
+    readonly registry: CodecRegistry;
+    /**
+     * @description The block at which this value was retrieved/created (set to non-empty when retrieved from storage)
+     */
+    createdAtHash?: IU8a;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @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
+     */
+    toHuman(isExtended?: boolean): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): 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)
+     */
+    toU8a(isBare?: BareOpts): Uint8Array;
+}
+export interface CodecClass<T = Codec> {
+    /**
+     * @description An internal fallback type (previous generation) if encoding fails
+     */
+    readonly __fallbackType?: string;
+    new (registry: CodecRegistry, ...args: any[]): T;
+}
+export declare type CodecClassDef<T = Codec> = Record<string, CodecClass<T>>;
+export declare type CodecTo = 'toHex' | 'toJSON' | 'toString' | 'toU8a';
+export declare type ArgsDef = Record<string, CodecClass | string>;

package/types/codec.js

@@ -0,0 +1 @@
+export {};

package/types/helpers.cjs

@@ -0,0 +1 @@
+"use strict";

package/types/helpers.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="bn.js" />
+import type { BN } from '@polkadot/util';
+import type { Codec } from './codec';
+export declare type AnyJson = string | number | boolean | null | undefined | AnyJson[] | {
+    [index: string]: AnyJson;
+};
+export declare type AnyFunction = (...args: any[]) => any;
+export declare type AnyNumber = BN | bigint | Uint8Array | number | string;
+export declare type AnyString = string | string;
+export declare type AnyTuple = Codec[];
+export declare type AnyU8a = Uint8Array | number[] | string;
+export declare type UIntBitLength = 8 | 16 | 32 | 64 | 128 | 256;
+export declare type U8aBitLength = 8 | 16 | 32 | 64 | 128 | 160 | 256 | 264 | 512 | 520 | 1024 | 2048;
+export declare type AnyTupleValue = AnyU8a | (Codec | AnyU8a | AnyNumber | AnyString | undefined | null)[];

package/types/helpers.js

@@ -0,0 +1 @@
+export {};

package/types/index.cjs

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _codec = require("./codec.cjs");
+
+Object.keys(_codec).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _codec[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _codec[key];
+    }
+  });
+});
+
+var _helpers = require("./helpers.cjs");
+
+Object.keys(_helpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _helpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _helpers[key];
+    }
+  });
+});
+
+var _interfaces = require("./interfaces.cjs");
+
+Object.keys(_interfaces).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _interfaces[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _interfaces[key];
+    }
+  });
+});
+
+var _registry = require("./registry.cjs");
+
+Object.keys(_registry).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _registry[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _registry[key];
+    }
+  });
+});

package/types/index.d.ts

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

package/types/index.js

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export * from "./codec.js";
+export * from "./helpers.js";
+export * from "./interfaces.js";
+export * from "./registry.js";

package/types/interfaces.cjs

@@ -0,0 +1 @@
+"use strict";

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/interfaces.js

@@ -0,0 +1 @@
+export {};

package/types/registry.cjs

@@ -0,0 +1 @@
+"use strict";

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/types/registry.js

@@ -0,0 +1 @@
+export {};

package/utils/compareArray.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareArray = compareArray;
+
+var _util = require("@polkadot/util");
+
+var _util2 = require("./util.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// NOTE These are used internally and when comparing objects, expects that
+// when the second is an Codec[] that the first has to be as well
+function compareArray(a, b) {
+  if (Array.isArray(b)) {
+    return a.length === b.length && (0, _util.isUndefined)(a.find((v, index) => (0, _util2.hasEq)(v) ? !v.eq(b[index]) : v !== b[index]));
+  }
+
+  return false;
+}

package/utils/compareArray.d.ts

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

package/utils/compareArray.js

@@ -0,0 +1,13 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { isUndefined } from '@polkadot/util';
+import { hasEq } from "./util.js"; // NOTE These are used internally and when comparing objects, expects that
+// when the second is an Codec[] that the first has to be as well
+
+export function compareArray(a, b) {
+  if (Array.isArray(b)) {
+    return a.length === b.length && isUndefined(a.find((v, index) => hasEq(v) ? !v.eq(b[index]) : v !== b[index]));
+  }
+
+  return false;
+}