@polkadot/types-codec 6.12.2-2

package/extended/Map.js

@@ -0,0 +1,225 @@
+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, isHex, isObject, isU8a, logger, stringify, u8aConcat, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { AbstractArray } from "../abstract/AbstractArray.js";
+import { Enum } from "../base/Enum.js";
+import { Struct } from "../native/Struct.js";
+import { compareMap, decodeU8a, sortMap, typeToConstructor } from "../utils/index.js";
+const l = logger('Map');
+/** @internal */
+
+function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
+  const output = new Map();
+  const [offset, length] = compactFromU8a(u8a);
+  const count = length.toNumber();
+  const types = [];
+
+  for (let i = 0; i < count; i++) {
+    types.push(KeyClass, ValClass);
+  }
+
+  const [values, decodedLength] = decodeU8a(registry, u8a.subarray(offset), types);
+
+  for (let i = 0; i < values.length; i += 2) {
+    output.set(values[i], values[i + 1]);
+  }
+
+  return [output, offset + decodedLength];
+}
+/** @internal */
+
+
+function decodeMapFromMap(registry, KeyClass, ValClass, value) {
+  const output = new Map();
+
+  for (const [key, val] of value.entries()) {
+    const isComplex = KeyClass.prototype instanceof AbstractArray || KeyClass.prototype instanceof Struct || KeyClass.prototype instanceof Enum;
+
+    try {
+      output.set(key instanceof KeyClass ? key : new KeyClass(registry, isComplex ? JSON.parse(key) : key), val instanceof ValClass ? val : new ValClass(registry, val));
+    } catch (error) {
+      l.error('Failed to decode key or value:', error.message);
+      throw error;
+    }
+  }
+
+  return [output, 0];
+}
+/**
+ * Decode input to pass into constructor.
+ *
+ * @param KeyClass - Type of the map key
+ * @param ValClass - Type of the map value
+ * @param value - Value to decode, one of:
+ * - null
+ * - undefined
+ * - hex
+ * - Uint8Array
+ * - Map<any, any>, where both key and value types are either
+ *   constructors or decodeable values for their types.
+ * @param jsonMap
+ * @internal
+ */
+
+
+function decodeMap(registry, keyType, valType, value) {
+  const KeyClass = typeToConstructor(registry, keyType);
+  const ValClass = typeToConstructor(registry, valType);
+
+  if (!value) {
+    return [new Map(), 0];
+  } else if (isU8a(value) || isHex(value)) {
+    return decodeMapFromU8a(registry, KeyClass, ValClass, u8aToU8a(value));
+  } else if (value instanceof Map) {
+    return decodeMapFromMap(registry, KeyClass, ValClass, value);
+  } else if (isObject(value)) {
+    return decodeMapFromMap(registry, KeyClass, ValClass, new Map(Object.entries(value)));
+  }
+
+  throw new Error('Map: cannot decode type');
+}
+
+var _KeyClass = /*#__PURE__*/_classPrivateFieldLooseKey("KeyClass");
+
+var _ValClass = /*#__PURE__*/_classPrivateFieldLooseKey("ValClass");
+
+var _type = /*#__PURE__*/_classPrivateFieldLooseKey("type");
+
+export class CodecMap extends Map {
+  constructor(registry, keyType, valType, rawValue, type = 'HashMap') {
+    const [decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
+    super(type === 'BTreeMap' ? sortMap(decoded) : decoded);
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    Object.defineProperty(this, _KeyClass, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _ValClass, {
+      writable: true,
+      value: void 0
+    });
+    this.initialU8aLength = void 0;
+    Object.defineProperty(this, _type, {
+      writable: true,
+      value: void 0
+    });
+    this.registry = registry;
+    this.initialU8aLength = decodedLength;
+    _classPrivateFieldLooseBase(this, _KeyClass)[_KeyClass] = typeToConstructor(registry, keyType);
+    _classPrivateFieldLooseBase(this, _ValClass)[_ValClass] = typeToConstructor(registry, valType);
+    _classPrivateFieldLooseBase(this, _type)[_type] = type;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    let len = compactToU8a(this.size).length;
+
+    for (const [k, v] of this.entries()) {
+      len += v.encodedLength + k.encodedLength;
+    }
+
+    return len;
+  }
+  /**
+   * @description Returns a hash of the value
+   */
+
+
+  get hash() {
+    return this.registry.hash(this.toU8a());
+  }
+  /**
+   * @description Checks if the value is an empty value
+   */
+
+
+  get isEmpty() {
+    return this.size === 0;
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return compareMap(this, other);
+  }
+  /**
+   * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+   */
+
+
+  toHex() {
+    return u8aToHex(this.toU8a());
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+
+
+  toHuman(isExtended) {
+    const json = {};
+
+    for (const [k, v] of this.entries()) {
+      json[k.toString()] = v.toHuman(isExtended);
+    }
+
+    return json;
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    const json = {};
+
+    for (const [k, v] of this.entries()) {
+      json[k.toString()] = v.toJSON();
+    }
+
+    return json;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `${_classPrivateFieldLooseBase(this, _type)[_type]}<${this.registry.getClassName(_classPrivateFieldLooseBase(this, _KeyClass)[_KeyClass]) || new (_classPrivateFieldLooseBase(this, _KeyClass)[_KeyClass])(this.registry).toRawType()},${this.registry.getClassName(_classPrivateFieldLooseBase(this, _ValClass)[_ValClass]) || new (_classPrivateFieldLooseBase(this, _ValClass)[_ValClass])(this.registry).toRawType()}>`;
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+
+
+  toString() {
+    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();
+
+    if (!isBare) {
+      encoded.push(compactToU8a(this.size));
+    }
+
+    for (const [k, v] of this.entries()) {
+      encoded.push(k.toU8a(isBare), v.toU8a(isBare));
+    }
+
+    return u8aConcat(...encoded);
+  }
+
+}

package/extended/Range.cjs

@@ -0,0 +1,92 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RangeInclusive = exports.Range = void 0;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+var _Tuple = require("../base/Tuple.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+var _rangeName = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("rangeName");
+
+/**
+ * @name Range
+ * @description
+ * Rust `Range<T>` representation
+ */
+class Range extends _Tuple.Tuple {
+  constructor(registry, Type, value) {
+    let rangeName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'Range';
+    super(registry, {
+      end: Type,
+      start: Type
+    }, value);
+    Object.defineProperty(this, _rangeName, {
+      writable: true,
+      value: void 0
+    });
+    (0, _classPrivateFieldLooseBase2.default)(this, _rangeName)[_rangeName] = rangeName;
+  }
+
+  static with(Types) {
+    return class extends Range {
+      constructor(registry, value) {
+        super(registry, Types, value);
+      }
+
+    };
+  }
+  /**
+   * @description Returns the starting range value
+   */
+
+
+  get start() {
+    return this[0];
+  }
+  /**
+   * @description Returns the ending range value
+   */
+
+
+  get end() {
+    return this[1];
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `${(0, _classPrivateFieldLooseBase2.default)(this, _rangeName)[_rangeName]}<${this.start.toRawType()}>`;
+  }
+
+}
+
+exports.Range = Range;
+
+class RangeInclusive extends Range {
+  constructor(registry, type, value) {
+    super(registry, type, value, 'RangeInclusive');
+  }
+
+  static with(Types) {
+    return class extends RangeInclusive {
+      constructor(registry, value) {
+        super(registry, Types, value);
+      }
+
+    };
+  }
+
+}
+
+exports.RangeInclusive = RangeInclusive;

package/extended/Range.d.ts

@@ -0,0 +1,30 @@
+import type { AnyTuple, CodecClass, CodecRegistry, INumber } from '../types';
+import { Tuple } from '../base/Tuple';
+declare type RangeType = 'Range' | 'RangeInclusive';
+/**
+ * @name Range
+ * @description
+ * Rust `Range<T>` representation
+ */
+export declare class Range<T extends INumber> extends Tuple {
+    #private;
+    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: AnyTuple, rangeName?: RangeType);
+    static with<T extends INumber>(Types: CodecClass<T> | string): CodecClass<Range<T>>;
+    /**
+     * @description Returns the starting range value
+     */
+    get start(): T;
+    /**
+     * @description Returns the ending range value
+     */
+    get end(): T;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}
+export declare class RangeInclusive<T extends INumber = INumber> extends Range<T> {
+    constructor(registry: CodecRegistry, type: CodecClass<T> | string, value?: AnyTuple);
+    static with<T extends INumber>(Types: CodecClass<T> | string): CodecClass<RangeInclusive<T>>;
+}
+export {};

package/extended/Range.js

@@ -0,0 +1,75 @@
+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 { Tuple } from "../base/Tuple.js";
+
+var _rangeName = /*#__PURE__*/_classPrivateFieldLooseKey("rangeName");
+
+/**
+ * @name Range
+ * @description
+ * Rust `Range<T>` representation
+ */
+export class Range extends Tuple {
+  constructor(registry, Type, value, rangeName = 'Range') {
+    super(registry, {
+      end: Type,
+      start: Type
+    }, value);
+    Object.defineProperty(this, _rangeName, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _rangeName)[_rangeName] = rangeName;
+  }
+
+  static with(Types) {
+    return class extends Range {
+      constructor(registry, value) {
+        super(registry, Types, value);
+      }
+
+    };
+  }
+  /**
+   * @description Returns the starting range value
+   */
+
+
+  get start() {
+    return this[0];
+  }
+  /**
+   * @description Returns the ending range value
+   */
+
+
+  get end() {
+    return this[1];
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `${_classPrivateFieldLooseBase(this, _rangeName)[_rangeName]}<${this.start.toRawType()}>`;
+  }
+
+}
+export class RangeInclusive extends Range {
+  constructor(registry, type, value) {
+    super(registry, type, value, 'RangeInclusive');
+  }
+
+  static with(Types) {
+    return class extends RangeInclusive {
+      constructor(registry, value) {
+        super(registry, Types, value);
+      }
+
+    };
+  }
+
+}

package/extended/Type.cjs

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Type = void 0;
+
+var _Text = require("../native/Text.cjs");
+
+var _index = require("../utils/index.cjs");
+
+// Copyright 2017-2021 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name Type
+ * @description
+ * This is a extended version of Text, specifically to handle types. Here we rely fully
+ * on what Text provides us, however we also adjust the types received from the runtime,
+ * i.e. we remove the `T::` prefixes found in some types for consistency across implementation.
+ */
+class Type extends _Text.Text {
+  constructor(registry) {
+    let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    super(registry, value);
+    this.setOverride((0, _index.sanitize)(this.toString()));
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'Type';
+  }
+
+}
+
+exports.Type = Type;

package/extended/Type.d.ts

@@ -0,0 +1,16 @@
+import type { CodecRegistry } from '../types';
+import { Text } from '../native/Text';
+/**
+ * @name Type
+ * @description
+ * This is a extended version of Text, specifically to handle types. Here we rely fully
+ * on what Text provides us, however we also adjust the types received from the runtime,
+ * i.e. we remove the `T::` prefixes found in some types for consistency across implementation.
+ */
+export declare class Type extends Text {
+    constructor(registry: CodecRegistry, value?: Text | Uint8Array | string);
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/extended/Type.js

@@ -0,0 +1,27 @@
+// Copyright 2017-2021 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Text } from "../native/Text.js";
+import { sanitize } from "../utils/index.js";
+/**
+ * @name Type
+ * @description
+ * This is a extended version of Text, specifically to handle types. Here we rely fully
+ * on what Text provides us, however we also adjust the types received from the runtime,
+ * i.e. we remove the `T::` prefixes found in some types for consistency across implementation.
+ */
+
+export class Type extends Text {
+  constructor(registry, value = '') {
+    super(registry, value);
+    this.setOverride(sanitize(this.toString()));
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'Type';
+  }
+
+}

package/extended/U8aFixed.cjs

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.U8aFixed = void 0;
+
+var _util = require("@polkadot/util");
+
+var _Raw = require("../native/Raw.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/** @internal */
+function decodeU8aFixed(value, bitLength) {
+  const u8a = (0, _util.u8aToU8a)(value);
+  const byteLength = bitLength / 8;
+
+  if (!u8a.length) {
+    return [new Uint8Array(byteLength), 0];
+  }
+
+  (0, _util.assert)(u8a.length >= byteLength, () => `Expected at least ${byteLength} bytes (${bitLength} bits), found ${u8a.length} bytes`);
+  return [u8a.subarray(0, byteLength), byteLength];
+}
+/**
+ * @name U8aFixed
+ * @description
+ * A U8a that manages a a sequence of bytes up to the specified bitLength. Not meant
+ * to be used directly, rather is should be subclassed with the specific lengths.
+ */
+
+
+class U8aFixed extends _Raw.Raw {
+  constructor(registry) {
+    let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Uint8Array();
+    let bitLength = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 256;
+    const [u8a, decodedLength] = decodeU8aFixed(value, bitLength);
+    super(registry, u8a, decodedLength);
+  }
+
+  static with(bitLength, typeName) {
+    return class extends U8aFixed {
+      constructor(registry, value) {
+        super(registry, value, bitLength);
+      }
+
+      toRawType() {
+        return typeName || super.toRawType();
+      }
+
+    };
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `[u8;${this.length}]`;
+  }
+
+}
+
+exports.U8aFixed = U8aFixed;

package/extended/U8aFixed.d.ts

@@ -0,0 +1,16 @@
+import type { AnyU8a, CodecClass, CodecRegistry, U8aBitLength } from '../types';
+import { Raw } from '../native/Raw';
+/**
+ * @name U8aFixed
+ * @description
+ * A U8a that manages a a sequence of bytes up to the specified bitLength. Not meant
+ * to be used directly, rather is should be subclassed with the specific lengths.
+ */
+export declare class U8aFixed extends Raw {
+    constructor(registry: CodecRegistry, value?: AnyU8a, bitLength?: U8aBitLength);
+    static with(bitLength: U8aBitLength, typeName?: string): CodecClass<U8aFixed>;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/extended/U8aFixed.js

@@ -0,0 +1,53 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { assert, u8aToU8a } from '@polkadot/util';
+import { Raw } from "../native/Raw.js";
+/** @internal */
+
+function decodeU8aFixed(value, bitLength) {
+  const u8a = u8aToU8a(value);
+  const byteLength = bitLength / 8;
+
+  if (!u8a.length) {
+    return [new Uint8Array(byteLength), 0];
+  }
+
+  assert(u8a.length >= byteLength, () => `Expected at least ${byteLength} bytes (${bitLength} bits), found ${u8a.length} bytes`);
+  return [u8a.subarray(0, byteLength), byteLength];
+}
+/**
+ * @name U8aFixed
+ * @description
+ * A U8a that manages a a sequence of bytes up to the specified bitLength. Not meant
+ * to be used directly, rather is should be subclassed with the specific lengths.
+ */
+
+
+export class U8aFixed extends Raw {
+  constructor(registry, value = new Uint8Array(), bitLength = 256) {
+    const [u8a, decodedLength] = decodeU8aFixed(value, bitLength);
+    super(registry, u8a, decodedLength);
+  }
+
+  static with(bitLength, typeName) {
+    return class extends U8aFixed {
+      constructor(registry, value) {
+        super(registry, value, bitLength);
+      }
+
+      toRawType() {
+        return typeName || super.toRawType();
+      }
+
+    };
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `[u8;${this.length}]`;
+  }
+
+}