@polkadot/types-codec 6.12.2-2

package/extended/BTreeSet.d.ts

@@ -0,0 +1,55 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson, Codec, CodecClass, CodecRegistry, ISet, IU8a } from '../types';
+export declare class BTreeSet<V extends Codec = Codec> extends Set<V> implements ISet<V> {
+    #private;
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    readonly initialU8aLength?: number;
+    constructor(registry: CodecRegistry, valType: CodecClass<V> | string, rawValue?: Uint8Array | string | string[] | Set<any>);
+    static with<V extends Codec>(valType: CodecClass<V> | string): CodecClass<BTreeSet<V>>;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description Returns a hash of the value
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description The actual set values as a string[]
+     */
+    get strings(): string[];
+    /**
+     * @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(): 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?: boolean): Uint8Array;
+}

package/extended/BTreeSet.js

@@ -0,0 +1,212 @@
+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, isU8a, logger, stringify, u8aConcat, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { compareSet, decodeU8aVec, sortSet, typeToConstructor } from "../utils/index.js";
+const l = logger('BTreeSet');
+/** @internal */
+
+function decodeSetFromU8a(registry, ValClass, u8a) {
+  const output = new Set();
+  const [offset, length] = compactFromU8a(u8a);
+  const [values, decodedLength] = decodeU8aVec(registry, u8a, offset, ValClass, length.toNumber());
+
+  for (let i = 0; i < values.length; i++) {
+    output.add(values[i]);
+  }
+
+  return [output, decodedLength + offset];
+}
+/** @internal */
+
+
+function decodeSetFromSet(registry, ValClass, value) {
+  const output = new Set();
+  value.forEach(val => {
+    try {
+      output.add(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 ValClass - Type of the map value
+ * @param value - Value to decode, one of:
+ * - null
+ * - undefined
+ * - hex
+ * - Uint8Array
+ * - Set<any>, where both key and value types are either
+ *   constructors or decodeable values for their types.
+ * @param jsonSet
+ * @internal
+ */
+
+
+function decodeSet(registry, valType, value) {
+  if (!value) {
+    return [new Set(), 0];
+  }
+
+  const ValClass = typeToConstructor(registry, valType);
+
+  if (isU8a(value) || isHex(value)) {
+    return decodeSetFromU8a(registry, ValClass, u8aToU8a(value));
+  } else if (Array.isArray(value) || value instanceof Set) {
+    return decodeSetFromSet(registry, ValClass, value);
+  }
+
+  throw new Error('BTreeSet: cannot decode type');
+}
+
+var _ValClass = /*#__PURE__*/_classPrivateFieldLooseKey("ValClass");
+
+export class BTreeSet extends Set {
+  constructor(registry, valType, rawValue) {
+    const [values, decodedLength] = decodeSet(registry, valType, rawValue);
+    super(sortSet(values));
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.initialU8aLength = void 0;
+    Object.defineProperty(this, _ValClass, {
+      writable: true,
+      value: void 0
+    });
+    this.registry = registry;
+    this.initialU8aLength = decodedLength;
+    _classPrivateFieldLooseBase(this, _ValClass)[_ValClass] = typeToConstructor(registry, valType);
+  }
+
+  static with(valType) {
+    return class extends BTreeSet {
+      constructor(registry, value) {
+        super(registry, valType, value);
+      }
+
+    };
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    let len = compactToU8a(this.size).length;
+
+    for (const v of this.values()) {
+      len += v.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 The actual set values as a string[]
+   */
+
+
+  get strings() {
+    return [...super.values()].map(v => v.toString());
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return compareSet(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 v of this.values()) {
+      json.push(v.toHuman(isExtended));
+    }
+
+    return json;
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    const json = [];
+
+    for (const v of this.values()) {
+      json.push(v.toJSON());
+    }
+
+    return json;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `BTreeSet<${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 v of this.values()) {
+      encoded.push(v.toU8a(isBare));
+    }
+
+    return u8aConcat(...encoded);
+  }
+
+}

package/extended/BitVec.cjs

@@ -0,0 +1,97 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BitVec = void 0;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+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 decodeBitVecU8a(value) {
+  if (!value || !value.length) {
+    return [0, new Uint8Array()];
+  } // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
+
+
+  const [offset, length] = (0, _util.compactFromU8a)(value);
+  const total = offset + Math.ceil(length.toNumber() / 8);
+  (0, _util.assert)(total <= value.length, () => `BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
+  return [length.toNumber(), value.subarray(offset, total)];
+}
+/** @internal */
+
+
+function decodeBitVec(value) {
+  if (Array.isArray(value) || (0, _util.isString)(value)) {
+    const u8a = (0, _util.u8aToU8a)(value);
+    return [u8a.length / 8, u8a];
+  }
+
+  return decodeBitVecU8a(value);
+}
+/**
+ * @name BitVec
+ * @description
+ * A BitVec that represents an array of bits. The bits are however stored encoded. The difference between this
+ * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
+ */
+
+
+var _decodedLength = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("decodedLength");
+
+class BitVec extends _Raw.Raw {
+  constructor(registry, value) {
+    const [decodedLength, u8a] = decodeBitVec(value);
+    super(registry, u8a);
+    Object.defineProperty(this, _decodedLength, {
+      writable: true,
+      value: void 0
+    });
+    (0, _classPrivateFieldLooseBase2.default)(this, _decodedLength)[_decodedLength] = decodedLength;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return this.length + (0, _util.compactToU8a)((0, _classPrivateFieldLooseBase2.default)(this, _decodedLength)[_decodedLength]).length;
+  }
+
+  toHuman() {
+    return `0b${[...this.toU8a(true)].map(d => `00000000${d.toString(2)}`.slice(-8)).join('_')}`;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'BitVec';
+  }
+  /**
+   * @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 bitVec = super.toU8a();
+    return isBare ? bitVec : (0, _util.u8aConcat)((0, _util.compactToU8a)((0, _classPrivateFieldLooseBase2.default)(this, _decodedLength)[_decodedLength]), bitVec);
+  }
+
+}
+
+exports.BitVec = BitVec;

package/extended/BitVec.d.ts

@@ -0,0 +1,26 @@
+import type { AnyU8a, CodecRegistry } from '../types';
+import { Raw } from '../native/Raw';
+/**
+ * @name BitVec
+ * @description
+ * A BitVec that represents an array of bits. The bits are however stored encoded. The difference between this
+ * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
+ */
+export declare class BitVec extends Raw {
+    #private;
+    constructor(registry: CodecRegistry, value?: AnyU8a);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    toHuman(): string;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): 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;
+}

package/extended/BitVec.js

@@ -0,0 +1,82 @@
+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, compactToU8a, isString, u8aConcat, u8aToU8a } from '@polkadot/util';
+import { Raw } from "../native/Raw.js";
+/** @internal */
+
+function decodeBitVecU8a(value) {
+  if (!value || !value.length) {
+    return [0, new Uint8Array()];
+  } // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
+
+
+  const [offset, length] = compactFromU8a(value);
+  const total = offset + Math.ceil(length.toNumber() / 8);
+  assert(total <= value.length, () => `BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
+  return [length.toNumber(), value.subarray(offset, total)];
+}
+/** @internal */
+
+
+function decodeBitVec(value) {
+  if (Array.isArray(value) || isString(value)) {
+    const u8a = u8aToU8a(value);
+    return [u8a.length / 8, u8a];
+  }
+
+  return decodeBitVecU8a(value);
+}
+/**
+ * @name BitVec
+ * @description
+ * A BitVec that represents an array of bits. The bits are however stored encoded. The difference between this
+ * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
+ */
+
+
+var _decodedLength = /*#__PURE__*/_classPrivateFieldLooseKey("decodedLength");
+
+export class BitVec extends Raw {
+  constructor(registry, value) {
+    const [decodedLength, u8a] = decodeBitVec(value);
+    super(registry, u8a);
+    Object.defineProperty(this, _decodedLength, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _decodedLength)[_decodedLength] = decodedLength;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return this.length + compactToU8a(_classPrivateFieldLooseBase(this, _decodedLength)[_decodedLength]).length;
+  }
+
+  toHuman() {
+    return `0b${[...this.toU8a(true)].map(d => `00000000${d.toString(2)}`.slice(-8)).join('_')}`;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'BitVec';
+  }
+  /**
+   * @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 bitVec = super.toU8a();
+    return isBare ? bitVec : u8aConcat(compactToU8a(_classPrivateFieldLooseBase(this, _decodedLength)[_decodedLength]), bitVec);
+  }
+
+}

package/extended/Bytes.cjs

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Bytes = 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
+// Bytes are used for things like on-chain code, so it has a healthy limit
+const MAX_LENGTH = 10 * 1024 * 1024;
+/** @internal */
+
+function decodeBytesU8a(value) {
+  if (!value.length) {
+    return [new Uint8Array(), 0];
+  } // handle all other Uint8Array inputs, these do have a length prefix
+
+
+  const [offset, length] = (0, _util.compactFromU8a)(value);
+  const total = offset + length.toNumber();
+  (0, _util.assert)(length.lten(MAX_LENGTH), () => `Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  (0, _util.assert)(total <= value.length, () => `Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
+  return [value.subarray(offset, total), total];
+}
+/** @internal */
+
+
+function decodeBytes(value) {
+  if (Array.isArray(value) || (0, _util.isString)(value)) {
+    return [(0, _util.u8aToU8a)(value), 0];
+  } else if (!(value instanceof _Raw.Raw) && (0, _util.isU8a)(value)) {
+    // We are ensuring we are not a Raw instance. In the case of a Raw we already have gotten
+    // rid of the length, i.e. new Bytes(new Bytes(...)) will work as expected
+    return decodeBytesU8a(value);
+  }
+
+  return [value, 0];
+}
+/**
+ * @name Bytes
+ * @description
+ * A Bytes wrapper for Vec<u8>. The significant difference between this and a normal Uint8Array
+ * is that this version allows for length-encoding. (i.e. it is a variable-item codec, the same
+ * as what is found in [[Text]] and [[Vec]])
+ */
+
+
+class Bytes extends _Raw.Raw {
+  constructor(registry, value) {
+    const [u8a, decodedLength] = decodeBytes(value);
+    super(registry, u8a, decodedLength);
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return this.length + (0, _util.compactToU8a)(this.length).length;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'Bytes';
+  }
+  /**
+   * @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 isBare ? super.toU8a(isBare) : (0, _util.compactAddLength)(this);
+  }
+
+}
+
+exports.Bytes = Bytes;

package/extended/Bytes.d.ts

@@ -0,0 +1,25 @@
+import type { AnyU8a, CodecRegistry } from '../types';
+import { Raw } from '../native/Raw';
+/**
+ * @name Bytes
+ * @description
+ * A Bytes wrapper for Vec<u8>. The significant difference between this and a normal Uint8Array
+ * is that this version allows for length-encoding. (i.e. it is a variable-item codec, the same
+ * as what is found in [[Text]] and [[Vec]])
+ */
+export declare class Bytes extends Raw {
+    constructor(registry: CodecRegistry, value?: AnyU8a);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): 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;
+}

package/extended/Bytes.js

@@ -0,0 +1,75 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { assert, compactAddLength, compactFromU8a, compactToU8a, isString, isU8a, u8aToU8a } from '@polkadot/util';
+import { Raw } from "../native/Raw.js"; // Bytes are used for things like on-chain code, so it has a healthy limit
+
+const MAX_LENGTH = 10 * 1024 * 1024;
+/** @internal */
+
+function decodeBytesU8a(value) {
+  if (!value.length) {
+    return [new Uint8Array(), 0];
+  } // handle all other Uint8Array inputs, these do have a length prefix
+
+
+  const [offset, length] = compactFromU8a(value);
+  const total = offset + length.toNumber();
+  assert(length.lten(MAX_LENGTH), () => `Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  assert(total <= value.length, () => `Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
+  return [value.subarray(offset, total), total];
+}
+/** @internal */
+
+
+function decodeBytes(value) {
+  if (Array.isArray(value) || isString(value)) {
+    return [u8aToU8a(value), 0];
+  } else if (!(value instanceof Raw) && isU8a(value)) {
+    // We are ensuring we are not a Raw instance. In the case of a Raw we already have gotten
+    // rid of the length, i.e. new Bytes(new Bytes(...)) will work as expected
+    return decodeBytesU8a(value);
+  }
+
+  return [value, 0];
+}
+/**
+ * @name Bytes
+ * @description
+ * A Bytes wrapper for Vec<u8>. The significant difference between this and a normal Uint8Array
+ * is that this version allows for length-encoding. (i.e. it is a variable-item codec, the same
+ * as what is found in [[Text]] and [[Vec]])
+ */
+
+
+export class Bytes extends Raw {
+  constructor(registry, value) {
+    const [u8a, decodedLength] = decodeBytes(value);
+    super(registry, u8a, decodedLength);
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return this.length + compactToU8a(this.length).length;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'Bytes';
+  }
+  /**
+   * @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 isBare ? super.toU8a(isBare) : compactAddLength(this);
+  }
+
+}

package/extended/HashMap.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HashMap = void 0;
+
+var _Map = require("./Map.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+class HashMap extends _Map.CodecMap {
+  static with(keyType, valType) {
+    return class extends HashMap {
+      constructor(registry, value) {
+        super(registry, keyType, valType, value);
+      }
+
+    };
+  }
+
+}
+
+exports.HashMap = HashMap;

package/extended/HashMap.d.ts

@@ -0,0 +1,5 @@
+import type { Codec, CodecClass } from '../types';
+import { CodecMap } from './Map';
+export declare class HashMap<K extends Codec = Codec, V extends Codec = Codec> extends CodecMap<K, V> {
+    static with<K extends Codec, V extends Codec>(keyType: CodecClass<K> | string, valType: CodecClass<V> | string): CodecClass<CodecMap<K, V>>;
+}