@polkadot/types-codec 9.14.2 → 10.0.1

package/extended/BTreeMap.js

@@ -1,13 +1,10 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { CodecMap } from "./Map.js";
+import { CodecMap } from './Map.js';
 export class BTreeMap extends CodecMap {
-  static with(keyType, valType) {
-    return class extends BTreeMap {
-      constructor(registry, value) {
-        super(registry, keyType, valType, value, 'BTreeMap');
-      }
-    };
-  }
+    static with(keyType, valType) {
+        return class extends BTreeMap {
+            constructor(registry, value) {
+                super(registry, keyType, valType, value, 'BTreeMap');
+            }
+        };
+    }
 }

package/extended/BTreeSet.js

@@ -1,36 +1,31 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { compactFromU8aLim, compactToU8a, isHex, isU8a, logger, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
-import { compareSet, decodeU8aVec, sortSet, typeToConstructor } from "../utils/index.js";
+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, count] = compactFromU8aLim(u8a);
-  const result = new Array(count);
-  const [decodedLength] = decodeU8aVec(registry, result, u8a, offset, ValClass);
-  for (let i = 0; i < count; i++) {
-    output.add(result[i]);
-  }
-  return [ValClass, output, decodedLength];
+    const output = new Set();
+    const [offset, count] = compactFromU8aLim(u8a);
+    const result = new Array(count);
+    const [decodedLength] = decodeU8aVec(registry, result, u8a, offset, ValClass);
+    for (let i = 0; i < count; i++) {
+        output.add(result[i]);
+    }
+    return [ValClass, output, decodedLength];
 }
-
 /** @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 [ValClass, output, 0];
+    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 [ValClass, output, 0];
 }
-
 /**
  * Decode input to pass into constructor.
  *
@@ -46,152 +41,145 @@ function decodeSetFromSet(registry, ValClass, value) {
  * @internal
  */
 function decodeSet(registry, valType, value) {
-  const ValClass = typeToConstructor(registry, valType);
-  if (!value) {
-    return [ValClass, new Set(), 0];
-  } else 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');
+    const ValClass = typeToConstructor(registry, valType);
+    if (!value) {
+        return [ValClass, new Set(), 0];
+    }
+    else 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');
 }
 export class BTreeSet extends Set {
-  #ValClass;
-  constructor(registry, valType, rawValue) {
-    const [ValClass, values, decodedLength] = decodeSet(registry, valType, rawValue);
-    super(sortSet(values));
-    this.registry = registry;
-    this.initialU8aLength = decodedLength;
-    this.#ValClass = ValClass;
-  }
-  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 breakdown of the hex encoding for this Codec
-   */
-  inspect() {
-    const inner = new Array();
-    for (const v of this.values()) {
-      inner.push(v.inspect());
-    }
-    return {
-      inner,
-      outer: [compactToU8a(this.size)]
-    };
-  }
-
-  /**
-   * @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(this.#ValClass) || new this.#ValClass(this.registry).toRawType()}>`;
-  }
-
-  /**
-   * @description Converts the value in a best-fit primitive form
-   */
-  toPrimitive() {
-    const json = [];
-    for (const v of this.values()) {
-      json.push(v.toPrimitive());
-    }
-    return json;
-  }
-
-  /**
-   * @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 u8aConcatStrict(encoded);
-  }
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    #ValClass;
+    constructor(registry, valType, rawValue) {
+        const [ValClass, values, decodedLength] = decodeSet(registry, valType, rawValue);
+        super(sortSet(values));
+        this.registry = registry;
+        this.initialU8aLength = decodedLength;
+        this.#ValClass = ValClass;
+    }
+    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 breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        const inner = new Array();
+        for (const v of this.values()) {
+            inner.push(v.inspect());
+        }
+        return {
+            inner,
+            outer: [compactToU8a(this.size)]
+        };
+    }
+    /**
+     * @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(this.#ValClass) || new this.#ValClass(this.registry).toRawType()}>`;
+    }
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive() {
+        const json = [];
+        for (const v of this.values()) {
+            json.push(v.toPrimitive());
+        }
+        return json;
+    }
+    /**
+     * @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 u8aConcatStrict(encoded);
+    }
 }

package/extended/BitVec.js

@@ -1,33 +1,26 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { compactFromU8aLim, compactToU8a, isString, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
-import { Raw } from "../native/Raw.js";
-
+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] = compactFromU8aLim(value);
-  const total = offset + Math.ceil(length / 8);
-  if (total > value.length) {
-    throw new Error(`BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
-  }
-  return [length, value.subarray(offset, total)];
+    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] = compactFromU8aLim(value);
+    const total = offset + Math.ceil(length / 8);
+    if (total > value.length) {
+        throw new Error(`BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
+    }
+    return [length, 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);
+    if (Array.isArray(value) || isString(value)) {
+        const u8a = u8aToU8a(value);
+        return [u8a.length / 8, u8a];
+    }
+    return decodeBitVecU8a(value);
 }
-
 /**
  * @name BitVec
  * @description
@@ -35,51 +28,51 @@ function decodeBitVec(value) {
  * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
  */
 export class BitVec extends Raw {
-  #decodedLength;
-  #isMsb;
-
-  // In lieu of having the Msb/Lsb identifiers passed through, we default to assuming
-  // we are dealing with Lsb, which is the default (as of writing) BitVec format used
-  // in the Polkadot code (this only affects the toHuman displays)
-  constructor(registry, value, isMsb = false) {
-    const [decodedLength, u8a] = decodeBitVec(value);
-    super(registry, u8a);
-    this.#decodedLength = decodedLength;
-    this.#isMsb = isMsb;
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  get encodedLength() {
-    return this.length + compactToU8a(this.#decodedLength).length;
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  inspect() {
-    return {
-      outer: [compactToU8a(this.#decodedLength), super.toU8a()]
-    };
-  }
-  toHuman() {
-    return `0b${[...this.toU8a(true)].map(d => `00000000${d.toString(2)}`.slice(-8)).map(s => this.#isMsb ? s : s.split('').reverse().join('')).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 : u8aConcatStrict([compactToU8a(this.#decodedLength), bitVec]);
-  }
+    #decodedLength;
+    #isMsb;
+    // In lieu of having the Msb/Lsb identifiers passed through, we default to assuming
+    // we are dealing with Lsb, which is the default (as of writing) BitVec format used
+    // in the Polkadot code (this only affects the toHuman displays)
+    constructor(registry, value, isMsb = false) {
+        const [decodedLength, u8a] = decodeBitVec(value);
+        super(registry, u8a);
+        this.#decodedLength = decodedLength;
+        this.#isMsb = isMsb;
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        return this.length + compactToU8a(this.#decodedLength).length;
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {
+            outer: [compactToU8a(this.#decodedLength), super.toU8a()]
+        };
+    }
+    toHuman() {
+        return `0b${[...this.toU8a(true)]
+            .map((d) => `00000000${d.toString(2)}`.slice(-8))
+            .map((s) => this.#isMsb ? s : s.split('').reverse().join(''))
+            .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
+            : u8aConcatStrict([compactToU8a(this.#decodedLength), bitVec]);
+    }
 }

package/extended/Bytes.js

@@ -1,29 +1,22 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { compactAddLength, compactFromU8aLim, 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
+import { Raw } from '../native/Raw.js';
 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] = compactFromU8aLim(value);
-  const total = offset + length;
-  if (length > MAX_LENGTH) {
-    throw new Error(`Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
-  } else if (total > value.length) {
-    throw new Error(`Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
-  }
-  return [value.subarray(offset, total), total];
+    if (!value.length) {
+        return [new Uint8Array(), 0];
+    }
+    // handle all other Uint8Array inputs, these do have a length prefix
+    const [offset, length] = compactFromU8aLim(value);
+    const total = offset + length;
+    if (length > MAX_LENGTH) {
+        throw new Error(`Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
+    }
+    else if (total > value.length) {
+        throw new Error(`Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
+    }
+    return [value.subarray(offset, total), total];
 }
-
 /**
  * @name Bytes
  * @description
@@ -32,40 +25,46 @@ function decodeBytesU8a(value) {
  * as what is found in [[Text]] and [[Vec]])
  */
 export class Bytes extends Raw {
-  constructor(registry, value) {
-    const [u8a, decodedLength] = isU8a(value) && !(value instanceof Raw) ? decodeBytesU8a(value) : Array.isArray(value) || isString(value) ? [u8aToU8a(value), 0] : [value, 0];
-    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 a breakdown of the hex encoding for this Codec
-   */
-  inspect(isBare) {
-    const clength = compactToU8a(this.length);
-    return {
-      outer: isBare ? [super.toU8a()] : this.length ? [clength, super.toU8a()] : [clength]
-    };
-  }
-
-  /**
-   * @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);
-  }
+    constructor(registry, value) {
+        const [u8a, decodedLength] = isU8a(value) && !(value instanceof Raw)
+            ? decodeBytesU8a(value)
+            : Array.isArray(value) || isString(value)
+                ? [u8aToU8a(value), 0]
+                : [value, 0];
+        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 a breakdown of the hex encoding for this Codec
+     */
+    inspect(isBare) {
+        const clength = compactToU8a(this.length);
+        return {
+            outer: isBare
+                ? [super.toU8a()]
+                : this.length
+                    ? [clength, super.toU8a()]
+                    : [clength]
+        };
+    }
+    /**
+     * @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);
+    }
 }