@polkadot/types-codec 6.12.2-10

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;
+}

package/base/VecFixed.js

@@ -0,0 +1,93 @@
+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, isU8a, u8aConcat } from '@polkadot/util';
+import { AbstractArray } from "../abstract/AbstractArray.js";
+import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
+import { decodeVec } from "./Vec.js";
+/** @internal */
+
+function decodeVecFixed(registry, value, Type, length) {
+  const [values, decodedLength, decodedLengthNoOffset] = decodeVec(registry, Type, value, length);
+
+  while (values.length < length) {
+    values.push(new Type(registry));
+  }
+
+  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__*/_classPrivateFieldLooseKey("Type");
+
+export class VecFixed extends AbstractArray {
+  constructor(registry, Type, length, value = []) {
+    const Clazz = typeToConstructor(registry, Type);
+    const [values,, decodedLengthNoOffset] = isU8a(value) ? decodeU8aVec(registry, value, 0, Clazz, length) : decodeVecFixed(registry, value, Clazz, length);
+    super(registry, values, decodedLengthNoOffset);
+    Object.defineProperty(this, _Type, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(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 (_classPrivateFieldLooseBase(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 ? u8aConcat(...encoded) : new Uint8Array([]);
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `[${this.Type};${this.length}]`;
+  }
+
+}

package/base/index.cjs

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Base", {
+  enumerable: true,
+  get: function () {
+    return _Base.Base;
+  }
+});
+Object.defineProperty(exports, "Compact", {
+  enumerable: true,
+  get: function () {
+    return _Compact.Compact;
+  }
+});
+Object.defineProperty(exports, "DoNotConstruct", {
+  enumerable: true,
+  get: function () {
+    return _DoNotConstruct.DoNotConstruct;
+  }
+});
+Object.defineProperty(exports, "Enum", {
+  enumerable: true,
+  get: function () {
+    return _Enum.Enum;
+  }
+});
+Object.defineProperty(exports, "Int", {
+  enumerable: true,
+  get: function () {
+    return _Int.Int;
+  }
+});
+Object.defineProperty(exports, "Null", {
+  enumerable: true,
+  get: function () {
+    return _Null.Null;
+  }
+});
+Object.defineProperty(exports, "Option", {
+  enumerable: true,
+  get: function () {
+    return _Option.Option;
+  }
+});
+Object.defineProperty(exports, "Result", {
+  enumerable: true,
+  get: function () {
+    return _Result.Result;
+  }
+});
+Object.defineProperty(exports, "Tuple", {
+  enumerable: true,
+  get: function () {
+    return _Tuple.Tuple;
+  }
+});
+Object.defineProperty(exports, "UInt", {
+  enumerable: true,
+  get: function () {
+    return _UInt.UInt;
+  }
+});
+Object.defineProperty(exports, "Vec", {
+  enumerable: true,
+  get: function () {
+    return _Vec.Vec;
+  }
+});
+Object.defineProperty(exports, "VecAny", {
+  enumerable: true,
+  get: function () {
+    return _VecAny.VecAny;
+  }
+});
+Object.defineProperty(exports, "VecFixed", {
+  enumerable: true,
+  get: function () {
+    return _VecFixed.VecFixed;
+  }
+});
+
+var _Base = require("./Base.cjs");
+
+var _Compact = require("./Compact.cjs");
+
+var _DoNotConstruct = require("./DoNotConstruct.cjs");
+
+var _Enum = require("./Enum.cjs");
+
+var _Int = require("./Int.cjs");
+
+var _Null = require("./Null.cjs");
+
+var _Option = require("./Option.cjs");
+
+var _Result = require("./Result.cjs");
+
+var _Tuple = require("./Tuple.cjs");
+
+var _UInt = require("./UInt.cjs");
+
+var _Vec = require("./Vec.cjs");
+
+var _VecAny = require("./VecAny.cjs");
+
+var _VecFixed = require("./VecFixed.cjs");

package/base/index.d.ts

@@ -0,0 +1,13 @@
+export { Base } from './Base';
+export { Compact } from './Compact';
+export { DoNotConstruct } from './DoNotConstruct';
+export { Enum } from './Enum';
+export { Int } from './Int';
+export { Null } from './Null';
+export { Option } from './Option';
+export { Result } from './Result';
+export { Tuple } from './Tuple';
+export { UInt } from './UInt';
+export { Vec } from './Vec';
+export { VecAny } from './VecAny';
+export { VecFixed } from './VecFixed';