@polkadot/types-codec 8.5.2-5 → 8.5.2-8

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-5'
+  version: '8.5.2-8'
 };
 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

@@ -1,17 +1,18 @@
 // Copyright 2017-2022 @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 { compactFromU8aLim, compactToU8a, isHex, isU8a, logger, stringify, u8aConcatStrict, 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());
+  const [offset, count] = compactFromU8aLim(u8a);
+  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];
@@ -212,7 +213,7 @@ export class BTreeSet extends Set {
       encoded.push(v.toU8a(isBare));
     }
 
-    return u8aConcat(...encoded);
+    return u8aConcatStrict(encoded);
   }
 
 }

package/extended/BitVec.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactFromU8a, compactToU8a, isString, u8aConcat, u8aToU8a } from '@polkadot/util';
+import { assert, compactFromU8aLim, compactToU8a, isString, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
 import { Raw } from "../native/Raw.js";
 /** @internal */
 
@@ -10,10 +10,10 @@ function decodeBitVecU8a(value) {
   } // 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);
+  const [offset, length] = compactFromU8aLim(value);
+  const total = offset + Math.ceil(length / 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)];
+  return [length, value.subarray(offset, total)];
 }
 /** @internal */
 
@@ -84,7 +84,7 @@ export class BitVec extends Raw {
 
   toU8a(isBare) {
     const bitVec = super.toU8a();
-    return isBare ? bitVec : u8aConcat(compactToU8a(this.#decodedLength), bitVec);
+    return isBare ? bitVec : u8aConcatStrict([compactToU8a(this.#decodedLength), bitVec]);
   }
 
 }

package/extended/Bytes.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactAddLength, compactFromU8a, compactToU8a, isCodec, isString, isU8a, u8aToU8a } from '@polkadot/util';
+import { assert, compactAddLength, compactFromU8aLim, compactToU8a, isCodec, 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;
@@ -12,9 +12,9 @@ function decodeBytesU8a(value) {
   } // 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}`);
+  const [offset, length] = compactFromU8aLim(value);
+  const total = offset + length;
+  assert(length <= 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];
 }

package/extended/Map.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @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 { compactFromU8aLim, compactToU8a, isHex, isObject, isU8a, logger, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from "../abstract/AbstractArray.js";
 import { Enum } from "../base/Enum.js";
 import { Struct } from "../native/Struct.js";
@@ -10,15 +10,14 @@ const l = logger('Map');
 
 function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
   const output = new Map();
-  const [offset, length] = compactFromU8a(u8a);
-  const count = length.toNumber();
+  const [offset, count] = compactFromU8aLim(u8a);
   const types = [];
 
   for (let i = 0; i < count; i++) {
     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]);
@@ -218,7 +217,7 @@ export class CodecMap extends Map {
       encoded.push(k.toU8a(isBare), v.toU8a(isBare));
     }
 
-    return u8aConcat(...encoded);
+    return u8aConcatStrict(encoded);
   }
 
 }

package/native/Struct.d.ts

@@ -1,6 +1,11 @@
 import type { HexString } from '@polkadot/util/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?: Definition;
+    setDefinition?: (d: Definition) => Definition;
+}
 /**
  * @name Struct
  * @description
@@ -23,7 +28,7 @@ export declare class Struct<S extends TypesDef = TypesDef, V extends {
     #private;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: Registry, Types: S, value?: V | Map<unknown, unknown> | unknown[] | HexString | null, jsonMap?: Map<string, string>);
+    constructor(registry: Registry, Types: S, value?: V | Map<unknown, unknown> | unknown[] | HexString | null, jsonMap?: Map<string, string>, { definition, setDefinition }?: Options);
     static with<S extends TypesDef>(Types: S, jsonMap?: Map<string, string>): CodecClass<Struct<S>>;
     /**
      * @description The available keys for this struct

package/native/Struct.js

@@ -1,22 +1,26 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isBoolean, isFunction, isHex, isObject, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, u8aConcat, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { assert, isBoolean, isFunction, isHex, isObject, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { compareMap, decodeU8a, mapToTypeMap, typesToMap } from "../utils/index.js";
 
+function noopSetDefinition(d) {
+  return 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 {
@@ -73,9 +77,12 @@ export class Struct extends Map {
   #jsonMap;
   #Types;
 
-  constructor(registry, Types, value, jsonMap = new Map()) {
-    const typeMap = 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);
+  constructor(registry, Types, value, jsonMap = new Map(), {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
+    const typeMap = definition || setDefinition(mapToTypeMap(registry, Types));
+    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;
@@ -85,9 +92,16 @@ export class Struct extends Map {
 
   static with(Types, jsonMap) {
     const keys = Object.keys(Types);
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Struct {
       constructor(registry, value) {
-        super(registry, Types, value, jsonMap);
+        super(registry, Types, value, jsonMap, {
+          definition,
+          setDefinition
+        });
         objectProperties(this, keys, k => this.get(k));
       }
 
@@ -99,7 +113,7 @@ export class Struct extends Map {
 
 
   get defKeys() {
-    return Object.keys(this.#Types);
+    return this.#Types[1];
   }
 
   getT(key) {
@@ -126,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;
@@ -280,7 +293,7 @@ export class Struct extends Map {
       }
     }
 
-    return u8aConcat(...encoded);
+    return u8aConcatStrict(encoded);
   }
 
 }

package/native/Text.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactAddLength, compactFromU8a, compactToU8a, hexToU8a, isHex, isString, isU8a, stringToU8a, u8aToHex, u8aToString } from '@polkadot/util';
+import { assert, compactAddLength, compactFromU8aLim, compactToU8a, hexToU8a, isHex, isString, isU8a, stringToU8a, u8aToHex, u8aToString } from '@polkadot/util';
 import { Raw } from "./Raw.js";
 const MAX_LENGTH = 128 * 1024;
 /** @internal */
@@ -17,9 +17,9 @@ function decodeText(value) {
       return [u8aToString(value), 0];
     }
 
-    const [offset, length] = compactFromU8a(value);
-    const total = offset + length.toNumber();
-    assert(length.lten(MAX_LENGTH), () => `Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
+    const [offset, length] = compactFromU8aLim(value);
+    const total = offset + length;
+    assert(length <= MAX_LENGTH, () => `Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
     assert(total <= value.length, () => `Text: required length less than remainder, expected at least ${total}, found ${value.length}`);
     return [u8aToString(value.subarray(offset, total)), total];
   } else if (isHex(value)) {

package/package.json

@@ -20,7 +20,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "8.5.2-5",
+  "version": "8.5.2-8",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -415,6 +415,6 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.18.0",
-    "@polkadot/util": "^9.2.1"
+    "@polkadot/util": "^9.2.2-15"
   }
 }

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-5'
+  version: '8.5.2-8'
 };

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;