@polkadot/types-codec 8.5.2-6 → 8.5.2-7

package/abstract/AbstractArray.d.ts

@@ -10,8 +10,7 @@ import type { AnyJson, Codec, Inspect, IU8a, IVec, Registry } from '../types';
 export declare abstract class AbstractArray<T extends Codec> extends Array<T> implements IVec<T> {
     readonly registry: Registry;
     createdAtHash?: IU8a;
-    readonly initialU8aLength?: number;
-    protected constructor(registry: Registry, values: T[], initialU8aLength?: number);
+    protected constructor(registry: Registry, length: number);
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/abstract/AbstractArray.js

@@ -11,15 +11,9 @@ import { compareArray } from "../utils/compareArray.js";
  */
 
 export class AbstractArray extends Array {
-  constructor(registry, values, initialU8aLength) {
-    super(values.length); // explicitly set the values here - this removes the need for any extra allocations
-
-    for (let i = 0; i < values.length; i++) {
-      this[i] = values[i];
-    }
-
+  constructor(registry, length) {
+    super(length);
     this.registry = registry;
-    this.initialU8aLength = initialU8aLength;
   }
   /**
    * @description The length of the value when encoded as a Uint8Array

package/base/Enum.js

@@ -35,12 +35,11 @@ function extractDef(registry, _def) {
     isBasic = true;
     isIndexed = false;
   } else if (isRustEnum(_def)) {
-    const entries = Object.entries(mapToTypeMap(registry, _def));
+    const [Types, keys] = mapToTypeMap(registry, _def);
 
-    for (let i = 0; i < entries.length; i++) {
-      const [key, Type] = entries[i];
-      def[key] = {
-        Type,
+    for (let i = 0; i < keys.length; i++) {
+      def[keys[i]] = {
+        Type: Types[i],
         index: i
       };
     }
@@ -383,13 +382,14 @@ export class Enum {
       }, {}) : this.defKeys;
     }
 
-    const typeMap = Object.entries(this.#def).reduce((out, [key, {
+    const entries = Object.entries(this.#def);
+    return typesToMap(this.registry, entries.reduce((out, [key, {
       Type
-    }]) => {
-      out[key] = Type;
+    }], i) => {
+      out[0][i] = Type;
+      out[1][i] = key;
       return out;
-    }, {});
-    return typesToMap(this.registry, typeMap);
+    }, [new Array(entries.length), new Array(entries.length)]));
   }
   /**
    * @description Returns the base runtime type name for this instance

package/base/Tuple.d.ts

@@ -1,15 +1,13 @@
 import type { AnyTupleValue, Codec, CodecClass, Inspect, ITuple, Registry } from '../types';
 import { AbstractArray } from '../abstract/AbstractArray';
-declare type TupleCodecClass = CodecClass[] | {
-    [index: string]: CodecClass;
-};
 declare type TupleType = (CodecClass | string);
 declare type TupleTypes = TupleType[] | {
     [index: string]: CodecClass | string;
 };
+declare type Definition = [CodecClass[], string[]];
 interface Options {
-    definition?: TupleCodecClass;
-    setDefinition?: (d: TupleCodecClass) => TupleCodecClass;
+    definition?: Definition;
+    setDefinition?: (d: Definition) => Definition;
 }
 /**
  * @name Tuple
@@ -19,6 +17,7 @@ interface Options {
  */
 export declare class Tuple extends AbstractArray<Codec> implements ITuple<Codec[]> {
     #private;
+    readonly initialU8aLength?: number;
     constructor(registry: Registry, Types: TupleTypes | TupleType, value?: AnyTupleValue, { definition, setDefinition }?: Options);
     static with(Types: TupleTypes | TupleType): CodecClass<Tuple>;
     /**

package/base/Tuple.js

@@ -10,25 +10,23 @@ function noopSetDefinition(d) {
 /** @internal */
 
 
-function decodeTuple(registry, Classes, value) {
+function decodeTuple(registry, result, Classes, value) {
   if (isU8a(value) || isHex(value)) {
-    return decodeU8a(registry, u8aToU8a(value), Classes);
+    return decodeU8a(registry, result, 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;
-      }
+  const Types = Classes[0];
 
-      return new Type(registry, entry);
+  for (let i = 0; i < Types.length; i++) {
+    try {
+      const entry = value === null || value === void 0 ? void 0 : value[i];
+      result[i] = entry instanceof Types[i] ? entry : new Types[i](registry, entry);
     } catch (error) {
-      throw new Error(`Tuple: failed on ${index}:: ${error.message}`);
+      throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
     }
-  }), 0];
+  }
+
+  return [result, 0];
 }
 /**
  * @name Tuple
@@ -45,9 +43,10 @@ export class Tuple extends AbstractArray {
     definition,
     setDefinition = noopSetDefinition
   } = {}) {
-    const Classes = definition || setDefinition(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);
+    const Classes = definition || setDefinition(Array.isArray(Types) ? [Types.map(t => typeToConstructor(registry, t)), []] : isFunction(Types) || isString(Types) ? [[typeToConstructor(registry, Types)], []] : mapToTypeMap(registry, Types));
+    super(registry, Classes[0].length);
+    const [, decodedLength] = isU8a(value) ? decodeU8a(registry, this, value, Classes, false) : decodeTuple(registry, this, Classes, value);
+    this.initialU8aLength = decodedLength;
     this.#Types = Classes;
   }
 
@@ -86,7 +85,7 @@ export class Tuple extends AbstractArray {
 
 
   get Types() {
-    return Array.isArray(this.#Types) ? this.#Types.map(T => new T(this.registry).toRawType()) : Object.keys(this.#Types);
+    return this.#Types[1].length ? this.#Types[1] : this.#Types[0].map(T => new T(this.registry).toRawType());
   }
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
@@ -104,7 +103,7 @@ export class Tuple extends AbstractArray {
 
 
   toRawType() {
-    const types = (Array.isArray(this.#Types) ? this.#Types : Object.values(this.#Types)).map(T => this.registry.getClassName(T) || new T(this.registry).toRawType());
+    const types = this.#Types[0].map(T => this.registry.getClassName(T) || new T(this.registry).toRawType());
     return `(${types.join(',')})`;
   }
   /**

package/base/Vec.d.ts

@@ -5,7 +5,7 @@ interface Options<T> {
     definition?: CodecClass<T>;
     setDefinition?: (d: CodecClass<T>) => CodecClass<T>;
 }
-export declare function decodeVec<T extends Codec>(registry: Registry, Type: CodecClass<T>, value: Uint8Array | HexString | unknown[], length?: number): [T[], number, number];
+export declare function decodeVec<T extends Codec>(registry: Registry, result: T[], value: Uint8Array | HexString | unknown[], startAt: number, Type: CodecClass<T>): [number, number];
 /**
  * @name Vec
  * @description
@@ -15,6 +15,7 @@ export declare function decodeVec<T extends Codec>(registry: Registry, Type: Cod
  */
 export declare class Vec<T extends Codec> extends AbstractArray<T> {
     #private;
+    readonly initialU8aLength?: number;
     constructor(registry: Registry, Type: CodecClass<T> | string, value?: Uint8Array | HexString | unknown[], { definition, setDefinition }?: Options<T>);
     static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Vec<O>>;
     /**

package/base/Vec.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactFromU8a, logger, u8aToU8a } from '@polkadot/util';
+import { assert, compactFromU8a, isU8a, logger, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from "../abstract/AbstractArray.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 const MAX_LENGTH = 64 * 1024;
@@ -10,11 +10,22 @@ function noopSetDefinition(d) {
   return d;
 }
 
-export function decodeVec(registry, Type, value, length = -1) {
+function decodeVecLength(value) {
   if (Array.isArray(value)) {
-    const result = new Array(value.length);
+    return [value, value.length, 0];
+  }
+
+  const u8a = u8aToU8a(value);
+  const [startAt, length] = compactFromU8a(u8a);
+  assert(length.lten(MAX_LENGTH), () => `Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  return [u8a, length.toNumber(), startAt];
+}
+
+export function decodeVec(registry, result, value, startAt, Type) {
+  if (Array.isArray(value)) {
+    const count = result.length;
 
-    for (let i = 0; i < value.length; i++) {
+    for (let i = 0; i < count; i++) {
       const entry = value[i];
 
       try {
@@ -25,20 +36,10 @@ export function decodeVec(registry, Type, value, length = -1) {
       }
     }
 
-    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 [0, 0];
   }
 
-  return decodeU8aVec(registry, u8a, offset, Type, length);
+  return decodeU8aVec(registry, result, u8aToU8a(value), startAt, Type);
 }
 /**
  * @name Vec
@@ -55,10 +56,11 @@ export class Vec extends AbstractArray {
     definition,
     setDefinition = noopSetDefinition
   } = {}) {
-    const Clazz = definition || setDefinition(typeToConstructor(registry, Type));
-    const [values, decodedLength] = decodeVec(registry, Clazz, value);
-    super(registry, values, decodedLength);
-    this.#Type = Clazz;
+    const [decodeFrom, length, startAt] = decodeVecLength(value);
+    super(registry, length);
+    this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
+    const [decodedLength] = isU8a(decodeFrom) ? decodeU8aVec(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type);
+    this.initialU8aLength = decodedLength;
   }
 
   static with(Type) {

package/base/VecFixed.d.ts

@@ -12,6 +12,7 @@ interface Options<T> {
  */
 export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
     #private;
+    readonly initialU8aLength?: number;
     constructor(registry: Registry, Type: CodecClass<T> | string, length: number, value?: Uint8Array | HexString | unknown[], { definition, setDefinition }?: Options<T>);
     static with<O extends Codec>(Type: CodecClass<O> | string, length: number): CodecClass<VecFixed<O>>;
     /**

package/base/VecFixed.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isU8a, u8aConcat } from '@polkadot/util';
+import { isU8a, u8aConcat } from '@polkadot/util';
 import { AbstractArray } from "../abstract/AbstractArray.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 import { decodeVec } from "./Vec.js";
@@ -8,19 +8,6 @@ import { decodeVec } from "./Vec.js";
 function noopSetDefinition(d) {
   return d;
 }
-/** @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
@@ -35,10 +22,10 @@ export class VecFixed extends AbstractArray {
     definition,
     setDefinition = noopSetDefinition
   } = {}) {
-    const Clazz = definition || setDefinition(typeToConstructor(registry, Type));
-    const [values,, decodedLengthNoOffset] = isU8a(value) ? decodeU8aVec(registry, value, 0, Clazz, length) : decodeVecFixed(registry, value, Clazz, length);
-    super(registry, values, decodedLengthNoOffset);
-    this.#Type = Clazz;
+    super(registry, length);
+    this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
+    const [, decodedLengthNoOffset] = isU8a(value) ? decodeU8aVec(registry, this, value, 0, this.#Type) : decodeVec(registry, this, value, 0, this.#Type);
+    this.initialU8aLength = decodedLengthNoOffset;
   }
 
   static with(Type, length) {

package/cjs/abstract/AbstractArray.js

@@ -20,15 +20,9 @@ var _compareArray = require("../utils/compareArray");
  * @noInheritDoc
  */
 class AbstractArray extends Array {
-  constructor(registry, values, initialU8aLength) {
-    super(values.length); // explicitly set the values here - this removes the need for any extra allocations
-
-    for (let i = 0; i < values.length; i++) {
-      this[i] = values[i];
-    }
-
+  constructor(registry, length) {
+    super(length);
     this.registry = registry;
-    this.initialU8aLength = initialU8aLength;
   }
   /**
    * @description The length of the value when encoded as a Uint8Array

package/cjs/base/Enum.js

@@ -44,12 +44,11 @@ function extractDef(registry, _def) {
     isBasic = true;
     isIndexed = false;
   } else if (isRustEnum(_def)) {
-    const entries = Object.entries((0, _utils.mapToTypeMap)(registry, _def));
+    const [Types, keys] = (0, _utils.mapToTypeMap)(registry, _def);
 
-    for (let i = 0; i < entries.length; i++) {
-      const [key, Type] = entries[i];
-      def[key] = {
-        Type,
+    for (let i = 0; i < keys.length; i++) {
+      def[keys[i]] = {
+        Type: Types[i],
         index: i
       };
     }
@@ -401,14 +400,15 @@ class Enum {
       }, {}) : this.defKeys;
     }
 
-    const typeMap = Object.entries(this.#def).reduce((out, _ref3) => {
+    const entries = Object.entries(this.#def);
+    return (0, _utils.typesToMap)(this.registry, entries.reduce((out, _ref3, i) => {
       let [key, {
         Type
       }] = _ref3;
-      out[key] = Type;
+      out[0][i] = Type;
+      out[1][i] = key;
       return out;
-    }, {});
-    return (0, _utils.typesToMap)(this.registry, typeMap);
+    }, [new Array(entries.length), new Array(entries.length)]));
   }
   /**
    * @description Returns the base runtime type name for this instance

package/cjs/base/Tuple.js

@@ -19,25 +19,23 @@ function noopSetDefinition(d) {
 /** @internal */
 
 
-function decodeTuple(registry, Classes, value) {
+function decodeTuple(registry, result, Classes, value) {
   if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
-    return (0, _utils.decodeU8a)(registry, (0, _util.u8aToU8a)(value), Classes);
+    return (0, _utils.decodeU8a)(registry, result, (0, _util.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;
-      }
+  const Types = Classes[0];
 
-      return new Type(registry, entry);
+  for (let i = 0; i < Types.length; i++) {
+    try {
+      const entry = value === null || value === void 0 ? void 0 : value[i];
+      result[i] = entry instanceof Types[i] ? entry : new Types[i](registry, entry);
     } catch (error) {
-      throw new Error(`Tuple: failed on ${index}:: ${error.message}`);
+      throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
     }
-  }), 0];
+  }
+
+  return [result, 0];
 }
 /**
  * @name Tuple
@@ -55,9 +53,10 @@ class Tuple extends _AbstractArray.AbstractArray {
       definition,
       setDefinition = noopSetDefinition
     } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    const Classes = definition || setDefinition(Array.isArray(Types) ? Types.map(t => (0, _utils.typeToConstructor)(registry, t)) : (0, _util.isFunction)(Types) || (0, _util.isString)(Types) ? [(0, _utils.typeToConstructor)(registry, Types)] : (0, _utils.mapToTypeMap)(registry, Types));
-    const [values, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, value, Classes) : decodeTuple(registry, Classes, value);
-    super(registry, values, decodedLength);
+    const Classes = definition || setDefinition(Array.isArray(Types) ? [Types.map(t => (0, _utils.typeToConstructor)(registry, t)), []] : (0, _util.isFunction)(Types) || (0, _util.isString)(Types) ? [[(0, _utils.typeToConstructor)(registry, Types)], []] : (0, _utils.mapToTypeMap)(registry, Types));
+    super(registry, Classes[0].length);
+    const [, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, this, value, Classes, false) : decodeTuple(registry, this, Classes, value);
+    this.initialU8aLength = decodedLength;
     this.#Types = Classes;
   }
 
@@ -96,7 +95,7 @@ class Tuple extends _AbstractArray.AbstractArray {
 
 
   get Types() {
-    return Array.isArray(this.#Types) ? this.#Types.map(T => new T(this.registry).toRawType()) : Object.keys(this.#Types);
+    return this.#Types[1].length ? this.#Types[1] : this.#Types[0].map(T => new T(this.registry).toRawType());
   }
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
@@ -114,7 +113,7 @@ class Tuple extends _AbstractArray.AbstractArray {
 
 
   toRawType() {
-    const types = (Array.isArray(this.#Types) ? this.#Types : Object.values(this.#Types)).map(T => this.registry.getClassName(T) || new T(this.registry).toRawType());
+    const types = this.#Types[0].map(T => this.registry.getClassName(T) || new T(this.registry).toRawType());
     return `(${types.join(',')})`;
   }
   /**

package/cjs/base/Vec.js

@@ -21,13 +21,22 @@ function noopSetDefinition(d) {
   return d;
 }
 
-function decodeVec(registry, Type, value) {
-  let length = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+function decodeVecLength(value) {
+  if (Array.isArray(value)) {
+    return [value, value.length, 0];
+  }
+
+  const u8a = (0, _util.u8aToU8a)(value);
+  const [startAt, length] = (0, _util.compactFromU8a)(u8a);
+  (0, _util.assert)(length.lten(MAX_LENGTH), () => `Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  return [u8a, length.toNumber(), startAt];
+}
 
+function decodeVec(registry, result, value, startAt, Type) {
   if (Array.isArray(value)) {
-    const result = new Array(value.length);
+    const count = result.length;
 
-    for (let i = 0; i < value.length; i++) {
+    for (let i = 0; i < count; i++) {
       const entry = value[i];
 
       try {
@@ -38,20 +47,10 @@ function decodeVec(registry, Type, value) {
       }
     }
 
-    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, 0];
   }
 
-  return (0, _utils.decodeU8aVec)(registry, u8a, offset, Type, length);
+  return (0, _utils.decodeU8aVec)(registry, result, (0, _util.u8aToU8a)(value), startAt, Type);
 }
 /**
  * @name Vec
@@ -71,10 +70,11 @@ class Vec extends _AbstractArray.AbstractArray {
       definition,
       setDefinition = noopSetDefinition
     } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    const Clazz = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
-    const [values, decodedLength] = decodeVec(registry, Clazz, value);
-    super(registry, values, decodedLength);
-    this.#Type = Clazz;
+    const [decodeFrom, length, startAt] = decodeVecLength(value);
+    super(registry, length);
+    this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
+    const [decodedLength] = (0, _util.isU8a)(decodeFrom) ? (0, _utils.decodeU8aVec)(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type);
+    this.initialU8aLength = decodedLength;
   }
 
   static with(Type) {

package/cjs/base/VecFixed.js

@@ -18,19 +18,6 @@ var _Vec = require("./Vec");
 function noopSetDefinition(d) {
   return d;
 }
-/** @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
@@ -47,10 +34,10 @@ class VecFixed extends _AbstractArray.AbstractArray {
       definition,
       setDefinition = noopSetDefinition
     } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
-    const Clazz = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
-    const [values,, decodedLengthNoOffset] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8aVec)(registry, value, 0, Clazz, length) : decodeVecFixed(registry, value, Clazz, length);
-    super(registry, values, decodedLengthNoOffset);
-    this.#Type = Clazz;
+    super(registry, length);
+    this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
+    const [, decodedLengthNoOffset] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8aVec)(registry, this, value, 0, this.#Type) : (0, _Vec.decodeVec)(registry, this, value, 0, this.#Type);
+    this.initialU8aLength = decodedLengthNoOffset;
   }
 
   static with(Type, length) {

package/cjs/extended/BTreeSet.js

@@ -17,10 +17,12 @@ const l = (0, _util.logger)('BTreeSet');
 function decodeSetFromU8a(registry, ValClass, u8a) {
   const output = new Set();
   const [offset, length] = (0, _util.compactFromU8a)(u8a);
-  const [values, decodedLength] = (0, _utils.decodeU8aVec)(registry, u8a, offset, ValClass, length.toNumber());
+  const count = length.toNumber();
+  const result = new Array(count);
+  const [decodedLength] = (0, _utils.decodeU8aVec)(registry, result, u8a, offset, ValClass);
 
-  for (let i = 0; i < values.length; i++) {
-    output.add(values[i]);
+  for (let i = 0; i < count; i++) {
+    output.add(result[i]);
   }
 
   return [ValClass, output, decodedLength];

package/cjs/extended/Map.js

@@ -30,7 +30,7 @@ function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
     types.push(KeyClass, ValClass);
   }
 
-  const [values, decodedLength] = (0, _utils.decodeU8a)(registry, u8a.subarray(offset), types);
+  const [values, decodedLength] = (0, _utils.decodeU8a)(registry, new Array(types.length), u8a.subarray(offset), [types, []]);
 
   for (let i = 0; i < values.length; i += 2) {
     output.set(values[i], values[i + 1]);

package/cjs/native/Struct.js

@@ -17,19 +17,19 @@ function noopSetDefinition(d) {
 /** @internal */
 
 
-function decodeStructFromObject(registry, Types, value, jsonMap) {
+function decodeStructFromObject(registry, _ref, value, jsonMap) {
+  let [Types, keys] = _ref;
   let jsonObj;
-  const inputKeys = Object.keys(Types);
   const typeofArray = Array.isArray(value);
   const typeofMap = value instanceof Map;
   (0, _util.assert)(typeofArray || typeofMap || (0, _util.isObject)(value), () => `Struct: Cannot decode value ${(0, _util.stringify)(value)} (typeof ${typeof value}), expected an input object, map or array`);
-  (0, _util.assert)(!typeofArray || value.length === inputKeys.length, () => `Struct: Unable to map ${(0, _util.stringify)(value)} array to object with known keys ${inputKeys.join(', ')}`);
-  const raw = new Array(inputKeys.length);
+  (0, _util.assert)(!typeofArray || value.length === keys.length, () => `Struct: Unable to map ${(0, _util.stringify)(value)} array to object with known keys ${keys.join(', ')}`);
+  const raw = new Array(keys.length);
 
-  for (let i = 0; i < inputKeys.length; i++) {
-    const key = inputKeys[i];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
     const jsonKey = jsonMap.get(key) || key;
-    const Type = Types[key];
+    const Type = Types[i];
     let assign;
 
     try {
@@ -93,7 +93,7 @@ class Struct extends Map {
       setDefinition = noopSetDefinition
     } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     const typeMap = definition || setDefinition((0, _utils.mapToTypeMap)(registry, Types));
-    const [decoded, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, value, typeMap, true) : (0, _util.isHex)(value) ? (0, _utils.decodeU8a)(registry, (0, _util.u8aToU8a)(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
+    const [decoded, decodedLength] = (0, _util.isU8a)(value) || (0, _util.isHex)(value) ? (0, _utils.decodeU8a)(registry, new Array(typeMap[0].length), (0, _util.u8aToU8a)(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
     super(decoded);
     this.#registry = registry;
     this.initialU8aLength = decodedLength;
@@ -124,7 +124,7 @@ class Struct extends Map {
 
 
   get defKeys() {
-    return Object.keys(this.#Types);
+    return this.#Types[1];
   }
 
   getT(key) {
@@ -151,11 +151,10 @@ class Struct extends Map {
 
   get Type() {
     const result = {};
-    const defs = Object.entries(this.#Types);
+    const [Types, keys] = this.#Types;
 
-    for (let i = 0; i < defs.length; i++) {
-      const [key, Type] = defs[i];
-      result[key] = new Type(this.registry).toRawType();
+    for (let i = 0; i < keys.length; i++) {
+      result[keys[i]] = new Types[i](this.registry).toRawType();
     }
 
     return result;

package/cjs/packageInfo.js

@@ -11,6 +11,6 @@ const packageInfo = {
   name: '@polkadot/types-codec',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '8.5.2-6'
+  version: '8.5.2-7'
 };
 exports.packageInfo = packageInfo;

package/cjs/utils/decodeU8a.js

@@ -31,12 +31,12 @@ function getRawType(registry, Type) {
  */
 
 
-function decodeU8a(registry, u8a, types, withZip) {
-  const [Types, keys] = Array.isArray(types) ? [types, []] : [Object.values(types), Object.keys(types)];
-  const result = new Array(Types.length);
+function decodeU8a(registry, result, u8a, _ref, withZip) {
+  let [Types, keys] = _ref;
+  const count = result.length;
   let offset = 0;
 
-  for (let i = 0; i < Types.length; i++) {
+  for (let i = 0; i < count; i++) {
     try {
       const value = new Types[i](registry, u8a.subarray(offset));
       offset += value.initialU8aLength || value.encodedLength;
@@ -51,9 +51,9 @@ function decodeU8a(registry, u8a, types, withZip) {
 // since we have to do less checks (and these are intensive anyway), much faster
 
 
-function decodeU8aVec(registry, u8a, start, Type, count) {
-  const result = new Array(count);
-  let offset = start;
+function decodeU8aVec(registry, result, u8a, startAt, Type) {
+  const count = result.length;
+  let offset = startAt;
 
   for (let i = 0; i < count; i++) {
     try {
@@ -65,5 +65,5 @@ function decodeU8aVec(registry, u8a, start, Type, count) {
     }
   }
 
-  return [result, offset, offset - start];
+  return [offset, offset - startAt];
 }

package/cjs/utils/mapToTypeMap.js

@@ -15,10 +15,12 @@ var _typeToConstructor = require("./typeToConstructor");
  */
 function mapToTypeMap(registry, input) {
   const entries = Object.entries(input);
-  const output = {};
+  const count = entries.length;
+  const output = [new Array(count), new Array(count)];
 
   for (let i = 0; i < entries.length; i++) {
-    output[entries[i][0]] = (0, _typeToConstructor.typeToConstructor)(registry, entries[i][1]);
+    output[1][i] = entries[i][0];
+    output[0][i] = (0, _typeToConstructor.typeToConstructor)(registry, entries[i][1]);
   }
 
   return output;

package/cjs/utils/typesToMap.js

@@ -7,13 +7,12 @@ exports.typesToMap = typesToMap;
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-function typesToMap(registry, Types) {
-  const entries = Object.entries(Types);
+function typesToMap(registry, _ref) {
+  let [Types, keys] = _ref;
   const result = {};
 
-  for (let i = 0; i < entries.length; i++) {
-    const [key, Type] = entries[i];
-    result[key] = registry.getClassName(Type) || new Type(registry).toRawType();
+  for (let i = 0; i < keys.length; i++) {
+    result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
   }
 
   return result;

package/extended/BTreeSet.js

@@ -8,10 +8,12 @@ const l = logger('BTreeSet');
 function decodeSetFromU8a(registry, ValClass, u8a) {
   const output = new Set();
   const [offset, length] = compactFromU8a(u8a);
-  const [values, decodedLength] = decodeU8aVec(registry, u8a, offset, ValClass, length.toNumber());
+  const count = length.toNumber();
+  const result = new Array(count);
+  const [decodedLength] = decodeU8aVec(registry, result, u8a, offset, ValClass);
 
-  for (let i = 0; i < values.length; i++) {
-    output.add(values[i]);
+  for (let i = 0; i < count; i++) {
+    output.add(result[i]);
   }
 
   return [ValClass, output, decodedLength];

package/extended/Map.js

@@ -18,7 +18,7 @@ function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
     types.push(KeyClass, ValClass);
   }
 
-  const [values, decodedLength] = decodeU8a(registry, u8a.subarray(offset), types);
+  const [values, decodedLength] = decodeU8a(registry, new Array(types.length), u8a.subarray(offset), [types, []]);
 
   for (let i = 0; i < values.length; i += 2) {
     output.set(values[i], values[i + 1]);

package/native/Struct.d.ts

@@ -1,9 +1,10 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, BareOpts, Codec, CodecClass, CodecClassDef, Inspect, IStruct, IU8a, Registry } from '../types';
+import type { AnyJson, BareOpts, Codec, CodecClass, Inspect, IStruct, IU8a, Registry } from '../types';
 declare type TypesDef<T = Codec> = Record<string, string | CodecClass<T>>;
+declare type Definition = [CodecClass[], string[]];
 interface Options {
-    definition?: CodecClassDef;
-    setDefinition?: (d: CodecClassDef) => CodecClassDef;
+    definition?: Definition;
+    setDefinition?: (d: Definition) => Definition;
 }
 /**
  * @name Struct

package/native/Struct.js

@@ -9,19 +9,18 @@ function noopSetDefinition(d) {
 /** @internal */
 
 
-function decodeStructFromObject(registry, Types, value, jsonMap) {
+function decodeStructFromObject(registry, [Types, keys], value, jsonMap) {
   let jsonObj;
-  const inputKeys = Object.keys(Types);
   const typeofArray = Array.isArray(value);
   const typeofMap = value instanceof Map;
   assert(typeofArray || typeofMap || isObject(value), () => `Struct: Cannot decode value ${stringify(value)} (typeof ${typeof value}), expected an input object, map or array`);
-  assert(!typeofArray || value.length === inputKeys.length, () => `Struct: Unable to map ${stringify(value)} array to object with known keys ${inputKeys.join(', ')}`);
-  const raw = new Array(inputKeys.length);
+  assert(!typeofArray || value.length === keys.length, () => `Struct: Unable to map ${stringify(value)} array to object with known keys ${keys.join(', ')}`);
+  const raw = new Array(keys.length);
 
-  for (let i = 0; i < inputKeys.length; i++) {
-    const key = inputKeys[i];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
     const jsonKey = jsonMap.get(key) || key;
-    const Type = Types[key];
+    const Type = Types[i];
     let assign;
 
     try {
@@ -83,7 +82,7 @@ export class Struct extends Map {
     setDefinition = noopSetDefinition
   } = {}) {
     const typeMap = definition || setDefinition(mapToTypeMap(registry, Types));
-    const [decoded, decodedLength] = isU8a(value) ? decodeU8a(registry, value, typeMap, true) : isHex(value) ? decodeU8a(registry, u8aToU8a(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
+    const [decoded, decodedLength] = isU8a(value) || isHex(value) ? decodeU8a(registry, new Array(typeMap[0].length), u8aToU8a(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
     super(decoded);
     this.#registry = registry;
     this.initialU8aLength = decodedLength;
@@ -114,7 +113,7 @@ export class Struct extends Map {
 
 
   get defKeys() {
-    return Object.keys(this.#Types);
+    return this.#Types[1];
   }
 
   getT(key) {
@@ -141,11 +140,10 @@ export class Struct extends Map {
 
   get Type() {
     const result = {};
-    const defs = Object.entries(this.#Types);
+    const [Types, keys] = this.#Types;
 
-    for (let i = 0; i < defs.length; i++) {
-      const [key, Type] = defs[i];
-      result[key] = new Type(this.registry).toRawType();
+    for (let i = 0; i < keys.length; i++) {
+      result[keys[i]] = new Types[i](this.registry).toRawType();
     }
 
     return result;

package/package.json

@@ -20,7 +20,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "8.5.2-6",
+  "version": "8.5.2-7",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",

package/packageInfo.js

@@ -5,5 +5,5 @@ export const packageInfo = {
   name: '@polkadot/types-codec',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '8.5.2-6'
+  version: '8.5.2-7'
 };

package/types/codec.d.ts

@@ -81,6 +81,5 @@ export interface CodecClass<T = Codec> {
     readonly __fallbackType?: string;
     new (registry: Registry, ...args: any[]): T;
 }
-export declare type CodecClassDef<T = Codec> = Record<string, CodecClass<T>>;
 export declare type CodecTo = 'toHex' | 'toJSON' | 'toString' | 'toU8a';
 export declare type ArgsDef = Record<string, CodecClass | string>;

package/utils/decodeU8a.d.ts

@@ -7,7 +7,5 @@ import type { Codec, CodecClass, Registry } from '../types';
  * @param result - The result array (will be returned with values pushed)
  * @param types - The array of CodecClass to decode the U8a against.
  */
-export declare function decodeU8a<T extends Codec = Codec, E = T>(registry: Registry, u8a: Uint8Array, types: CodecClass[] | {
-    [index: string]: CodecClass;
-}, withZip?: boolean): [E[], number];
-export declare function decodeU8aVec<T extends Codec = Codec>(registry: Registry, u8a: Uint8Array, start: number, Type: CodecClass<T>, count: number): [T[], number, number];
+export declare function decodeU8a<T extends Codec = Codec, E = T>(registry: Registry, result: unknown[], u8a: Uint8Array, [Types, keys]: [CodecClass[], string[]], withZip?: boolean): [E[], number];
+export declare function decodeU8aVec<T extends Codec = Codec>(registry: Registry, result: unknown[], u8a: Uint8Array, startAt: number, Type: CodecClass<T>): [number, number];

package/utils/decodeU8a.js

@@ -23,12 +23,11 @@ function getRawType(registry, Type) {
  */
 
 
-export function decodeU8a(registry, u8a, types, withZip) {
-  const [Types, keys] = Array.isArray(types) ? [types, []] : [Object.values(types), Object.keys(types)];
-  const result = new Array(Types.length);
+export function decodeU8a(registry, result, u8a, [Types, keys], withZip) {
+  const count = result.length;
   let offset = 0;
 
-  for (let i = 0; i < Types.length; i++) {
+  for (let i = 0; i < count; i++) {
     try {
       const value = new Types[i](registry, u8a.subarray(offset));
       offset += value.initialU8aLength || value.encodedLength;
@@ -42,9 +41,9 @@ export function decodeU8a(registry, u8a, types, withZip) {
 } // Split from decodeU8a since this is specialized to 1 instance ... yes duplication, but
 // since we have to do less checks (and these are intensive anyway), much faster
 
-export function decodeU8aVec(registry, u8a, start, Type, count) {
-  const result = new Array(count);
-  let offset = start;
+export function decodeU8aVec(registry, result, u8a, startAt, Type) {
+  const count = result.length;
+  let offset = startAt;
 
   for (let i = 0; i < count; i++) {
     try {
@@ -56,5 +55,5 @@ export function decodeU8aVec(registry, u8a, start, Type, count) {
     }
   }
 
-  return [result, offset, offset - start];
+  return [offset, offset - startAt];
 }

package/utils/mapToTypeMap.d.ts

@@ -2,4 +2,4 @@ import type { CodecClass, Registry } from '../types';
 /**
  * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
  */
-export declare function mapToTypeMap(registry: Registry, input: Record<string, string | CodecClass>): Record<string, CodecClass>;
+export declare function mapToTypeMap(registry: Registry, input: Record<string, string | CodecClass>): [CodecClass[], string[]];

package/utils/mapToTypeMap.js

@@ -7,10 +7,12 @@ import { typeToConstructor } from "./typeToConstructor.js";
 
 export function mapToTypeMap(registry, input) {
   const entries = Object.entries(input);
-  const output = {};
+  const count = entries.length;
+  const output = [new Array(count), new Array(count)];
 
   for (let i = 0; i < entries.length; i++) {
-    output[entries[i][0]] = typeToConstructor(registry, entries[i][1]);
+    output[1][i] = entries[i][0];
+    output[0][i] = typeToConstructor(registry, entries[i][1]);
   }
 
   return output;

package/utils/typesToMap.d.ts

@@ -1,2 +1,2 @@
 import type { CodecClass, Registry } from '../types';
-export declare function typesToMap(registry: Registry, Types: Record<string, CodecClass>): Record<string, string>;
+export declare function typesToMap(registry: Registry, [Types, keys]: [CodecClass[], string[]]): Record<string, string>;

package/utils/typesToMap.js

@@ -1,12 +1,10 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-export function typesToMap(registry, Types) {
-  const entries = Object.entries(Types);
+export function typesToMap(registry, [Types, keys]) {
   const result = {};
 
-  for (let i = 0; i < entries.length; i++) {
-    const [key, Type] = entries[i];
-    result[key] = registry.getClassName(Type) || new Type(registry).toRawType();
+  for (let i = 0; i < keys.length; i++) {
+    result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
   }
 
   return result;