@polkadot/types-codec 6.12.2-2

package/base/Base.d.ts

@@ -0,0 +1,54 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson, BareOpts, Codec, CodecRegistry, IU8a } from '../types';
+/**
+ * @name Base
+ * @description A type extends the Base class, when it holds a value
+ */
+export declare abstract class Base<T extends Codec> implements Codec {
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    readonly initialU8aLength?: number;
+    protected readonly _raw: T;
+    protected constructor(registry: CodecRegistry, value: T, initialU8aLength?: number);
+    /**
+     * @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
+     */
+    get isEmpty(): boolean;
+    /**
+     * @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 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;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/base/Base.js

@@ -0,0 +1,100 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name Base
+ * @description A type extends the Base class, when it holds a value
+ */
+export class Base {
+  constructor(registry, value, initialU8aLength) {
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.initialU8aLength = void 0;
+    this._raw = void 0;
+    this.registry = registry;
+    this._raw = value;
+    this.initialU8aLength = initialU8aLength;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return this.toU8a().length;
+  }
+  /**
+   * @description returns a hash of the contents
+   */
+
+
+  get hash() {
+    return this.registry.hash(this.toU8a());
+  }
+  /**
+   * @description Checks if the value is an empty value
+   */
+
+
+  get isEmpty() {
+    return this._raw.isEmpty;
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return this._raw.eq(other);
+  }
+  /**
+   * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+   */
+
+
+  toHex(isLe) {
+    return this._raw.toHex(isLe);
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+
+
+  toHuman(isExtended) {
+    return this._raw.toHuman(isExtended);
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    return this._raw.toJSON();
+  }
+  /**
+   * @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) {
+    return this._raw.toU8a(isBare);
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'Base';
+  }
+
+}

package/base/Compact.cjs

@@ -0,0 +1,201 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Compact = void 0;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+var _util = require("@polkadot/util");
+
+var _index = require("../utils/index.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+var _Type = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("Type");
+
+var _raw = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("raw");
+
+/**
+ * @name Compact
+ * @description
+ * A compact length-encoding codec wrapper. It performs the same function as Length, however
+ * differs in that it uses a variable number of bytes to do the actual encoding. This is mostly
+ * used by other types to add length-prefixed encoding, or in the case of wrapped types, taking
+ * a number and making the compact representation thereof
+ */
+class Compact {
+  constructor(registry, Type) {
+    let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.initialU8aLength = void 0;
+    Object.defineProperty(this, _Type, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _raw, {
+      writable: true,
+      value: void 0
+    });
+    this.registry = registry;
+    (0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type] = (0, _index.typeToConstructor)(registry, Type);
+    const [raw, decodedLength] = Compact.decodeCompact(registry, (0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type], value);
+    this.initialU8aLength = decodedLength;
+    (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw] = raw;
+  }
+
+  static with(Type) {
+    return class extends Compact {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+  /** @internal */
+
+
+  static decodeCompact(registry, Type, value) {
+    if (value instanceof Compact) {
+      return [new Type(registry, (0, _classPrivateFieldLooseBase2.default)(value, _raw)[_raw]), 0];
+    } else if (value instanceof Type) {
+      return [value, 0];
+    } else if ((0, _util.isString)(value) || (0, _util.isNumber)(value) || (0, _util.isBn)(value) || (0, _util.isBigInt)(value)) {
+      return [new Type(registry, value), 0];
+    }
+
+    const [decodedLength, bn] = (0, _util.compactFromU8a)(value);
+    return [new Type(registry, bn), decodedLength];
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return this.toU8a().length;
+  }
+  /**
+   * @description returns a hash of the contents
+   */
+
+
+  get hash() {
+    return this.registry.hash(this.toU8a());
+  }
+  /**
+   * @description Checks if the value is an empty value
+   */
+
+
+  get isEmpty() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].isEmpty;
+  }
+  /**
+   * @description Returns the number of bits in the value
+   */
+
+
+  bitLength() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].bitLength();
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].eq(other instanceof Compact ? (0, _classPrivateFieldLooseBase2.default)(other, _raw)[_raw] : other);
+  }
+  /**
+   * @description Returns a BigInt representation of the number
+   */
+
+
+  toBigInt() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toBigInt();
+  }
+  /**
+   * @description Returns the BN representation of the number
+   */
+
+
+  toBn() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toBn();
+  }
+  /**
+   * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+   */
+
+
+  toHex(isLe) {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toHex(isLe);
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+
+
+  toHuman(isExtended) {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toHuman(isExtended);
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toJSON();
+  }
+  /**
+   * @description Returns the number representation for the value
+   */
+
+
+  toNumber() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toNumber();
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `Compact<${this.registry.getClassName((0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type]) || (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toRawType()}>`;
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+
+
+  toString() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_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)
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+  toU8a(isBare) {
+    return (0, _util.compactToU8a)((0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toBn());
+  }
+  /**
+   * @description Returns the embedded [[UInt]] or [[Moment]] value
+   */
+
+
+  unwrap() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw];
+  }
+
+}
+
+exports.Compact = Compact;

package/base/Compact.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="bn.js" />
+import type { BN } from '@polkadot/util';
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson, AnyNumber, CodecClass, CodecRegistry, ICompact, INumber, IU8a } from '../types';
+/**
+ * @name Compact
+ * @description
+ * A compact length-encoding codec wrapper. It performs the same function as Length, however
+ * differs in that it uses a variable number of bytes to do the actual encoding. This is mostly
+ * used by other types to add length-prefixed encoding, or in the case of wrapped types, taking
+ * a number and making the compact representation thereof
+ */
+export declare class Compact<T extends INumber> implements ICompact<T> {
+    #private;
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    readonly initialU8aLength?: number;
+    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: Compact<T> | AnyNumber);
+    static with<T extends INumber>(Type: CodecClass<T> | string): CodecClass<Compact<T>>;
+    /** @internal */
+    static decodeCompact<T extends INumber>(registry: CodecRegistry, Type: CodecClass<T>, value: Compact<T> | AnyNumber): [T, number];
+    /**
+     * @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
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Returns the number of bits in the value
+     */
+    bitLength(): number;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Returns a BigInt representation of the number
+     */
+    toBigInt(): bigint;
+    /**
+     * @description Returns the BN representation of the number
+     */
+    toBn(): BN;
+    /**
+     * @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 number representation for the value
+     */
+    toNumber(): 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;
+    /**
+     * @description Returns the embedded [[UInt]] or [[Moment]] value
+     */
+    unwrap(): T;
+}

package/base/Compact.js

@@ -0,0 +1,186 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/esm/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/esm/classPrivateFieldLooseKey";
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { compactFromU8a, compactToU8a, isBigInt, isBn, isNumber, isString } from '@polkadot/util';
+import { typeToConstructor } from "../utils/index.js";
+/**
+ * @name Compact
+ * @description
+ * A compact length-encoding codec wrapper. It performs the same function as Length, however
+ * differs in that it uses a variable number of bytes to do the actual encoding. This is mostly
+ * used by other types to add length-prefixed encoding, or in the case of wrapped types, taking
+ * a number and making the compact representation thereof
+ */
+
+var _Type = /*#__PURE__*/_classPrivateFieldLooseKey("Type");
+
+var _raw = /*#__PURE__*/_classPrivateFieldLooseKey("raw");
+
+export class Compact {
+  constructor(registry, Type, value = 0) {
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.initialU8aLength = void 0;
+    Object.defineProperty(this, _Type, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _raw, {
+      writable: true,
+      value: void 0
+    });
+    this.registry = registry;
+    _classPrivateFieldLooseBase(this, _Type)[_Type] = typeToConstructor(registry, Type);
+    const [raw, decodedLength] = Compact.decodeCompact(registry, _classPrivateFieldLooseBase(this, _Type)[_Type], value);
+    this.initialU8aLength = decodedLength;
+    _classPrivateFieldLooseBase(this, _raw)[_raw] = raw;
+  }
+
+  static with(Type) {
+    return class extends Compact {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+  /** @internal */
+
+
+  static decodeCompact(registry, Type, value) {
+    if (value instanceof Compact) {
+      return [new Type(registry, _classPrivateFieldLooseBase(value, _raw)[_raw]), 0];
+    } else if (value instanceof Type) {
+      return [value, 0];
+    } else if (isString(value) || isNumber(value) || isBn(value) || isBigInt(value)) {
+      return [new Type(registry, value), 0];
+    }
+
+    const [decodedLength, bn] = compactFromU8a(value);
+    return [new Type(registry, bn), decodedLength];
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return this.toU8a().length;
+  }
+  /**
+   * @description returns a hash of the contents
+   */
+
+
+  get hash() {
+    return this.registry.hash(this.toU8a());
+  }
+  /**
+   * @description Checks if the value is an empty value
+   */
+
+
+  get isEmpty() {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw].isEmpty;
+  }
+  /**
+   * @description Returns the number of bits in the value
+   */
+
+
+  bitLength() {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw].bitLength();
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw].eq(other instanceof Compact ? _classPrivateFieldLooseBase(other, _raw)[_raw] : other);
+  }
+  /**
+   * @description Returns a BigInt representation of the number
+   */
+
+
+  toBigInt() {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw].toBigInt();
+  }
+  /**
+   * @description Returns the BN representation of the number
+   */
+
+
+  toBn() {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw].toBn();
+  }
+  /**
+   * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+   */
+
+
+  toHex(isLe) {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw].toHex(isLe);
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+
+
+  toHuman(isExtended) {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw].toHuman(isExtended);
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw].toJSON();
+  }
+  /**
+   * @description Returns the number representation for the value
+   */
+
+
+  toNumber() {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw].toNumber();
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `Compact<${this.registry.getClassName(_classPrivateFieldLooseBase(this, _Type)[_Type]) || _classPrivateFieldLooseBase(this, _raw)[_raw].toRawType()}>`;
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+
+
+  toString() {
+    return _classPrivateFieldLooseBase(this, _raw)[_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)
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+  toU8a(isBare) {
+    return compactToU8a(_classPrivateFieldLooseBase(this, _raw)[_raw].toBn());
+  }
+  /**
+   * @description Returns the embedded [[UInt]] or [[Moment]] value
+   */
+
+
+  unwrap() {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw];
+  }
+
+}