@polkadot/types-codec 6.12.2-2

package/base/Tuple.js

@@ -0,0 +1,116 @@
+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 { isFunction, isHex, isString, isU8a, stringify, u8aConcat, u8aToU8a } from '@polkadot/util';
+import { AbstractArray } from "../abstract/AbstractArray.js";
+import { decodeU8a, mapToTypeMap, typeToConstructor } from "../utils/index.js";
+
+/** @internal */
+function decodeTuple(registry, Classes, value) {
+  if (isU8a(value) || isHex(value)) {
+    return decodeU8a(registry, u8aToU8a(value), Classes);
+  }
+
+  const Types = Array.isArray(Classes) ? Classes : Object.values(Classes);
+  return [Types.map((Type, index) => {
+    try {
+      const entry = value === null || value === void 0 ? void 0 : value[index];
+
+      if (entry instanceof Type) {
+        return entry;
+      }
+
+      return new Type(registry, entry);
+    } catch (error) {
+      throw new Error(`Tuple: failed on ${index}:: ${error.message}`);
+    }
+  }), 0];
+}
+/**
+ * @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.
+ */
+
+
+var _Types = /*#__PURE__*/_classPrivateFieldLooseKey("Types");
+
+export class Tuple extends AbstractArray {
+  constructor(registry, Types, value) {
+    const Classes = Array.isArray(Types) ? Types.map(t => typeToConstructor(registry, t)) : isFunction(Types) || isString(Types) ? [typeToConstructor(registry, Types)] : mapToTypeMap(registry, Types);
+    const [values, decodedLength] = isU8a(value) ? decodeU8a(registry, value, Classes) : decodeTuple(registry, Classes, value);
+    super(registry, values, decodedLength);
+    Object.defineProperty(this, _Types, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _Types)[_Types] = Classes;
+  }
+
+  static with(Types) {
+    return class extends Tuple {
+      constructor(registry, value) {
+        super(registry, Types, value);
+      }
+
+    };
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    let total = 0;
+
+    for (let i = 0; i < this.length; i++) {
+      total += this[i].encodedLength;
+    }
+
+    return total;
+  }
+  /**
+   * @description The types definition of the tuple
+   */
+
+
+  get Types() {
+    return Array.isArray(_classPrivateFieldLooseBase(this, _Types)[_Types]) ? _classPrivateFieldLooseBase(this, _Types)[_Types].map(T => new T(this.registry).toRawType()) : Object.keys(_classPrivateFieldLooseBase(this, _Types)[_Types]);
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    const types = (Array.isArray(_classPrivateFieldLooseBase(this, _Types)[_Types]) ? _classPrivateFieldLooseBase(this, _Types)[_Types] : Object.values(_classPrivateFieldLooseBase(this, _Types)[_Types])).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 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) {
+    const encoded = new Array(this.length);
+
+    for (let i = 0; i < this.length; i++) {
+      encoded[i] = this[i].toU8a(isBare);
+    }
+
+    return u8aConcat(...encoded);
+  }
+
+}

package/base/UInt.cjs

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UInt = void 0;
+
+var _AbstractInt = require("../abstract/AbstractInt.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name UInt
+ * @description
+ * A generic unsigned integer codec. For Substrate 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
+ */
+class UInt extends _AbstractInt.AbstractInt {
+  static with(bitLength, typeName) {
+    return class extends UInt {
+      constructor(registry, value) {
+        super(registry, value, bitLength);
+      }
+
+      toRawType() {
+        return typeName || super.toRawType();
+      }
+
+    };
+  }
+
+}
+
+exports.UInt = UInt;

package/base/UInt.d.ts

@@ -0,0 +1,15 @@
+import type { CodecClass, UIntBitLength } from '../types';
+import { AbstractInt } from '../abstract/AbstractInt';
+/**
+ * @name UInt
+ * @description
+ * A generic unsigned integer codec. For Substrate 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>;
+}

package/base/UInt.js

@@ -0,0 +1,29 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { AbstractInt } from "../abstract/AbstractInt.js";
+/**
+ * @name UInt
+ * @description
+ * A generic unsigned integer codec. For Substrate 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 class UInt extends AbstractInt {
+  static with(bitLength, typeName) {
+    return class extends UInt {
+      constructor(registry, value) {
+        super(registry, value, bitLength);
+      }
+
+      toRawType() {
+        return typeName || super.toRawType();
+      }
+
+    };
+  }
+
+}

package/base/Vec.cjs

@@ -0,0 +1,126 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Vec = void 0;
+exports.decodeVec = decodeVec;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+var _util = require("@polkadot/util");
+
+var _AbstractArray = require("../abstract/AbstractArray.cjs");
+
+var _index = require("../utils/index.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+const MAX_LENGTH = 64 * 1024;
+const l = (0, _util.logger)('Vec');
+
+function decodeVec(registry, Type, value) {
+  let length = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+
+  if (Array.isArray(value)) {
+    const result = new Array(value.length);
+
+    for (let i = 0; i < value.length; i++) {
+      const entry = value[i];
+
+      try {
+        result[i] = entry instanceof Type ? entry : new Type(registry, entry);
+      } catch (error) {
+        l.error(`Unable to decode on index ${i}`, error.message);
+        throw error;
+      }
+    }
+
+    return [result, 0, 0];
+  }
+
+  const u8a = (0, _util.u8aToU8a)(value);
+  let offset = 0;
+
+  if (length === -1) {
+    const [_offset, _length] = (0, _util.compactFromU8a)(u8a);
+    (0, _util.assert)(_length.lten(MAX_LENGTH), () => `Vec length ${_length.toString()} exceeds ${MAX_LENGTH}`);
+    length = _length.toNumber();
+    offset = _offset;
+  }
+
+  return (0, _index.decodeU8aVec)(registry, u8a, offset, Type, length);
+}
+/**
+ * @name Vec
+ * @description
+ * This manages codec arrays. Internally it keeps track of the length (as decoded) and allows
+ * construction with the passed `Type` in the constructor. It is an extension to Array, providing
+ * specific encoding/decoding on top of the base type.
+ */
+
+
+var _Type = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("Type");
+
+class Vec extends _AbstractArray.AbstractArray {
+  constructor(registry, Type) {
+    let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    const Clazz = (0, _index.typeToConstructor)(registry, Type);
+    const [values, decodedLength] = decodeVec(registry, Clazz, value);
+    super(registry, values, decodedLength);
+    Object.defineProperty(this, _Type, {
+      writable: true,
+      value: void 0
+    });
+    (0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type] = Clazz;
+  }
+
+  static with(Type) {
+    return class extends Vec {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+  /**
+   * @description The type for the items
+   */
+
+
+  get Type() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type].name;
+  }
+  /**
+   * @description Finds the index of the value in the array
+   */
+
+
+  indexOf(_other) {
+    // convert type first, this removes overhead from the eq
+    const other = _other instanceof (0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type] ? _other : new ((0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type])(this.registry, _other);
+
+    for (let i = 0; i < this.length; i++) {
+      if (other.eq(this[i])) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `Vec<${this.registry.getClassName((0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type]) || new ((0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type])(this.registry).toRawType()}>`;
+  }
+
+}
+
+exports.Vec = Vec;

package/base/Vec.d.ts

@@ -0,0 +1,28 @@
+import type { HexString } from '@polkadot/util/types';
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+import { AbstractArray } from '../abstract/AbstractArray';
+export declare function decodeVec<T extends Codec>(registry: CodecRegistry, Type: CodecClass<T>, value: Uint8Array | HexString | unknown[], length?: number): [T[], number, number];
+/**
+ * @name Vec
+ * @description
+ * This manages codec arrays. Internally it keeps track of the length (as decoded) and allows
+ * construction with the passed `Type` in the constructor. It is an extension to Array, providing
+ * specific encoding/decoding on top of the base type.
+ */
+export declare class Vec<T extends Codec> extends AbstractArray<T> {
+    #private;
+    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: Uint8Array | HexString | unknown[]);
+    static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Vec<O>>;
+    /**
+     * @description The type for the items
+     */
+    get Type(): string;
+    /**
+     * @description Finds the index of the value in the array
+     */
+    indexOf(_other?: unknown): number;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/base/Vec.js

@@ -0,0 +1,104 @@
+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 { assert, compactFromU8a, logger, u8aToU8a } from '@polkadot/util';
+import { AbstractArray } from "../abstract/AbstractArray.js";
+import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
+const MAX_LENGTH = 64 * 1024;
+const l = logger('Vec');
+export function decodeVec(registry, Type, value, length = -1) {
+  if (Array.isArray(value)) {
+    const result = new Array(value.length);
+
+    for (let i = 0; i < value.length; i++) {
+      const entry = value[i];
+
+      try {
+        result[i] = entry instanceof Type ? entry : new Type(registry, entry);
+      } catch (error) {
+        l.error(`Unable to decode on index ${i}`, error.message);
+        throw error;
+      }
+    }
+
+    return [result, 0, 0];
+  }
+
+  const u8a = u8aToU8a(value);
+  let offset = 0;
+
+  if (length === -1) {
+    const [_offset, _length] = compactFromU8a(u8a);
+    assert(_length.lten(MAX_LENGTH), () => `Vec length ${_length.toString()} exceeds ${MAX_LENGTH}`);
+    length = _length.toNumber();
+    offset = _offset;
+  }
+
+  return decodeU8aVec(registry, u8a, offset, Type, length);
+}
+/**
+ * @name Vec
+ * @description
+ * This manages codec arrays. Internally it keeps track of the length (as decoded) and allows
+ * construction with the passed `Type` in the constructor. It is an extension to Array, providing
+ * specific encoding/decoding on top of the base type.
+ */
+
+var _Type = /*#__PURE__*/_classPrivateFieldLooseKey("Type");
+
+export class Vec extends AbstractArray {
+  constructor(registry, Type, value = []) {
+    const Clazz = typeToConstructor(registry, Type);
+    const [values, decodedLength] = decodeVec(registry, Clazz, value);
+    super(registry, values, decodedLength);
+    Object.defineProperty(this, _Type, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _Type)[_Type] = Clazz;
+  }
+
+  static with(Type) {
+    return class extends Vec {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+  /**
+   * @description The type for the items
+   */
+
+
+  get Type() {
+    return _classPrivateFieldLooseBase(this, _Type)[_Type].name;
+  }
+  /**
+   * @description Finds the index of the value in the array
+   */
+
+
+  indexOf(_other) {
+    // convert type first, this removes overhead from the eq
+    const other = _other instanceof _classPrivateFieldLooseBase(this, _Type)[_Type] ? _other : new (_classPrivateFieldLooseBase(this, _Type)[_Type])(this.registry, _other);
+
+    for (let i = 0; i < this.length; i++) {
+      if (other.eq(this[i])) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `Vec<${this.registry.getClassName(_classPrivateFieldLooseBase(this, _Type)[_Type]) || new (_classPrivateFieldLooseBase(this, _Type)[_Type])(this.registry).toRawType()}>`;
+  }
+
+}

package/base/VecAny.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VecAny = void 0;
+
+var _AbstractArray = require("../abstract/AbstractArray.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name VecAny
+ * @description
+ * This manages codec arrays, assuming that the inputs are already of type Codec. Unlike
+ * a vector, this can be used to manage array-like structures with variable arguments of
+ * any types
+ */
+class VecAny extends _AbstractArray.AbstractArray {
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  toRawType() {
+    // FIXME This is basically an any type, cannot instantiate via createType
+    return 'Vec<Codec>';
+  }
+
+}
+
+exports.VecAny = VecAny;

package/base/VecAny.d.ts

@@ -0,0 +1,15 @@
+import type { Codec } from '../types';
+import { AbstractArray } from '../abstract/AbstractArray';
+/**
+ * @name VecAny
+ * @description
+ * This manages codec arrays, assuming that the inputs are already of type Codec. Unlike
+ * a vector, this can be used to manage array-like structures with variable arguments of
+ * any types
+ */
+export declare class VecAny<T extends Codec> extends AbstractArray<T> {
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/base/VecAny.js

@@ -0,0 +1,21 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { AbstractArray } from "../abstract/AbstractArray.js";
+/**
+ * @name VecAny
+ * @description
+ * This manages codec arrays, assuming that the inputs are already of type Codec. Unlike
+ * a vector, this can be used to manage array-like structures with variable arguments of
+ * any types
+ */
+
+export class VecAny extends AbstractArray {
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  toRawType() {
+    // FIXME This is basically an any type, cannot instantiate via createType
+    return 'Vec<Codec>';
+  }
+
+}

package/base/VecFixed.cjs

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VecFixed = void 0;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+var _util = require("@polkadot/util");
+
+var _AbstractArray = require("../abstract/AbstractArray.cjs");
+
+var _index = require("../utils/index.cjs");
+
+var _Vec = require("./Vec.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/** @internal */
+function decodeVecFixed(registry, value, Type, length) {
+  const [values, decodedLength, decodedLengthNoOffset] = (0, _Vec.decodeVec)(registry, Type, value, length);
+
+  while (values.length < length) {
+    values.push(new Type(registry));
+  }
+
+  (0, _util.assert)(values.length === length, () => `Expected a length of exactly ${length} entries`);
+  return [values, decodedLength, decodedLengthNoOffset];
+}
+/**
+ * @name VecFixed
+ * @description
+ * This manages codec arrays of a fixed length
+ */
+
+
+var _Type = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("Type");
+
+class VecFixed extends _AbstractArray.AbstractArray {
+  constructor(registry, Type, length) {
+    let value = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+    const Clazz = (0, _index.typeToConstructor)(registry, Type);
+    const [values,, decodedLengthNoOffset] = (0, _util.isU8a)(value) ? (0, _index.decodeU8aVec)(registry, value, 0, Clazz, length) : decodeVecFixed(registry, value, Clazz, length);
+    super(registry, values, decodedLengthNoOffset);
+    Object.defineProperty(this, _Type, {
+      writable: true,
+      value: void 0
+    });
+    (0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type] = Clazz;
+  }
+
+  static with(Type, length) {
+    return class extends VecFixed {
+      constructor(registry, value) {
+        super(registry, Type, length, value);
+      }
+
+    };
+  }
+  /**
+   * @description The type for the items
+   */
+
+
+  get Type() {
+    return new ((0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type])(this.registry).toRawType();
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    let total = 0;
+
+    for (let i = 0; i < this.length; i++) {
+      total += this[i].encodedLength;
+    }
+
+    return total;
+  }
+
+  toU8a() {
+    // we override, we don't add the length prefix for ourselves, and at the same time we
+    // ignore isBare on entries, since they should be properly encoded at all times
+    const encoded = new Array(this.length);
+
+    for (let i = 0; i < this.length; i++) {
+      encoded[i] = this[i].toU8a();
+    }
+
+    return encoded.length ? (0, _util.u8aConcat)(...encoded) : new Uint8Array([]);
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `[${this.Type};${this.length}]`;
+  }
+
+}
+
+exports.VecFixed = VecFixed;

package/base/VecFixed.d.ts

@@ -0,0 +1,26 @@
+import type { HexString } from '@polkadot/util/types';
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+import { AbstractArray } from '../abstract/AbstractArray';
+/**
+ * @name VecFixed
+ * @description
+ * This manages codec arrays of a fixed length
+ */
+export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
+    #private;
+    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, length: number, value?: Uint8Array | HexString | unknown[]);
+    static with<O extends Codec>(Type: CodecClass<O> | string, length: number): CodecClass<VecFixed<O>>;
+    /**
+     * @description The type for the items
+     */
+    get Type(): string;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    toU8a(): Uint8Array;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}