@polkadot/types-codec 9.11.3 → 9.13.1

package/base/Vec.js

@@ -1,7 +1,7 @@
 // Copyright 2017-2023 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { compactFromU8aLim, isU8a, logger, u8aToU8a } from '@polkadot/util';
+import { compactFromU8aLim, isHex, isU8a, logger, stringify, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from "../abstract/Array.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 const MAX_LENGTH = 64 * 1024;
@@ -12,13 +12,17 @@ function noopSetDefinition(d) {
 function decodeVecLength(value) {
   if (Array.isArray(value)) {
     return [value, value.length, 0];
+  } else if (isU8a(value) || isHex(value)) {
+    const u8a = u8aToU8a(value);
+    const [startAt, length] = compactFromU8aLim(u8a);
+    if (length > MAX_LENGTH) {
+      throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+    }
+    return [u8a, length, startAt];
+  } else if (!value) {
+    return [null, 0, 0];
   }
-  const u8a = u8aToU8a(value);
-  const [startAt, length] = compactFromU8aLim(u8a);
-  if (length > MAX_LENGTH) {
-    throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
-  }
-  return [u8a, length, startAt];
+  throw new Error(`Expected array/hex input to Vec<*> decoding, found ${typeof value}: ${stringify(value)}`);
 }
 export function decodeVec(registry, result, value, startAt, Type) {
   if (Array.isArray(value)) {
@@ -35,7 +39,11 @@ export function decodeVec(registry, result, value, startAt, Type) {
       }
     }
     return [0, 0];
+  } else if (!value) {
+    return [0, 0];
   }
+
+  // we don't need more checks, we already limited it via the length decoding
   return decodeU8aVec(registry, result, u8aToU8a(value), startAt, Type);
 }
 
@@ -55,7 +63,12 @@ export class Vec extends AbstractArray {
     const [decodeFrom, length, startAt] = decodeVecLength(value);
     super(registry, length);
     this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
-    this.initialU8aLength = (isU8a(decodeFrom) ? decodeU8aVec(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type))[0];
+    try {
+      this.initialU8aLength = (isU8a(decodeFrom) ? decodeU8aVec(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type))[0];
+    } catch (e) {
+      console.error(decodeFrom, length, startAt);
+      throw e;
+    }
   }
   static with(Type) {
     let definition;

package/base/VecFixed.d.ts

@@ -12,7 +12,6 @@ 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/cjs/abstract/Base.js

@@ -14,8 +14,8 @@ exports.AbstractBase = void 0;
 class AbstractBase {
   #raw;
   constructor(registry, value, initialU8aLength) {
-    this.#raw = value;
     this.initialU8aLength = initialU8aLength;
+    this.#raw = value;
     this.registry = registry;
   }
 
@@ -32,6 +32,10 @@ class AbstractBase {
   get hash() {
     return this.registry.hash(this.toU8a());
   }
+
+  /**
+   * @description returns the inner (wrapped value)
+   */
   get inner() {
     return this.#raw;
   }
@@ -103,11 +107,19 @@ class AbstractBase {
   /**
    * @description Returns the base runtime type name for this instance
    */
-  toRawType() {
-    return 'Base';
-  }
+
+  /**
+   * @description Returns the inner wrapped value (equivalent to valueOf)
+   */
   unwrap() {
     return this.#raw;
   }
+
+  /**
+   * @description Returns the inner wrapped value
+   */
+  valueOf() {
+    return this.#raw;
+  }
 }
 exports.AbstractBase = AbstractBase;

package/cjs/abstract/Int.js

@@ -16,6 +16,9 @@ exports.DEFAULT_UINT_BITS = DEFAULT_UINT_BITS;
 const MAX_NUMBER_BITS = 52;
 const MUL_P = new _util.BN(10000);
 const FORMATTERS = [['Perquintill', _util.BN_QUINTILL], ['Perbill', _util.BN_BILLION], ['Permill', _util.BN_MILLION], ['Percent', _util.BN_HUNDRED]];
+function isToBn(value) {
+  return (0, _util.isFunction)(value.toBn);
+}
 function toPercentage(value, divisor) {
   return `${(value.mul(MUL_P).div(divisor).toNumber() / 100).toFixed(2)}%`;
 }
@@ -38,9 +41,13 @@ function decodeAbstractInt(value, isNegative) {
       throw new Error('String should not contain decimal points or scientific notation');
     }
     return value;
-  } else if ((0, _util.isBn)(value)) {
+  } else if ((0, _util.isBn)(value) || (0, _util.isBigInt)(value)) {
     return value.toString();
-  } else if ((0, _util.isObject)(value) && !(0, _util.isFunction)(value.toBn)) {
+  } else if ((0, _util.isObject)(value)) {
+    if (isToBn(value)) {
+      return value.toBn().toString();
+    }
+
     // Allow the construction from an object with a single top-level key. This means that
     // single key objects can be treated equivalently to numbers, assuming they meet the
     // specific requirements. (This is useful in Weights 1.5 where Objects are compact)
@@ -48,13 +55,9 @@ function decodeAbstractInt(value, isNegative) {
     if (keys.length !== 1) {
       throw new Error('Unable to construct number from multi-key object');
     }
-    const inner = value[keys[0]];
-    if (!(0, _util.isString)(inner) && !(0, _util.isNumber)(inner)) {
-      throw new Error('Unable to construct from object with non-string/non-number value');
-    }
-    return decodeAbstractInt(inner, isNegative);
+    return decodeAbstractInt(value[keys[0]], isNegative);
   }
-  return (0, _util.bnToBn)(value).toString();
+  throw new Error(`Unable to create BN from unknown type ${typeof value}`);
 }
 
 /**
@@ -82,6 +85,7 @@ class AbstractInt extends _util.BN {
     this.registry = registry;
     this.#bitLength = bitLength;
     this.encodedLength = this.#bitLength / 8;
+    this.initialU8aLength = this.#bitLength / 8;
     this.isUnsigned = !isSigned;
     const isNegative = this.isNeg();
     const maxBits = bitLength - (isSigned && !isNegative ? 1 : 0);

package/cjs/abstract/Object.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbstractObject = void 0;
+// Copyright 2017-2023 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name Object
+ * @description A type extends the Base class, when it holds a value
+ */
+class AbstractObject {
+  constructor(registry, value, initialU8aLength) {
+    this.$ = value;
+    this.initialU8aLength = initialU8aLength;
+    this.registry = registry;
+  }
+
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+  get encodedLength() {
+    return this.toU8a().length;
+  }
+
+  /**
+   * @description returns a hash of the contents
+   */
+  get hash() {
+    return this.registry.hash(this.toU8a());
+  }
+
+  /**
+   * @description Checks if the value is an empty value
+   */
+
+  /**
+   * @description Returns the string representation of the value
+   */
+  toString() {
+    return this.$.toString();
+  }
+
+  /**
+   * @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)
+   */
+
+  /**
+   * @description Return the internal value (JS-aligned, same result as $)
+   */
+  valueOf() {
+    return this.$;
+  }
+}
+exports.AbstractObject = AbstractObject;

package/cjs/base/Null.js

@@ -16,7 +16,6 @@ var _util = require("@polkadot/util");
 class Null {
   encodedLength = 0;
   isEmpty = true;
-  // Added for compatibility reasons, e.g. see Option
   initialU8aLength = 0;
   constructor(registry) {
     this.registry = registry;

package/cjs/base/Option.js

@@ -70,7 +70,7 @@ class Option {
     this.registry = registry;
     this.#Type = Type;
     this.#raw = decoded;
-    if (decoded && decoded.initialU8aLength) {
+    if (decoded != null && decoded.initialU8aLength) {
       this.initialU8aLength = 1 + decoded.initialU8aLength;
     }
   }

package/cjs/base/Tuple.js

@@ -16,19 +16,27 @@ function noopSetDefinition(d) {
 
 /** @internal */
 function decodeTuple(registry, result, value, Classes) {
-  if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
+  if (Array.isArray(value)) {
+    const Types = Classes[0];
+    for (let i = 0; i < Types.length; i++) {
+      try {
+        const entry = value == null ? void 0 : value[i];
+        result[i] = entry instanceof Types[i] ? entry : new Types[i](registry, entry);
+      } catch (error) {
+        throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
+      }
+    }
+    return [result, 0];
+  } else if ((0, _util.isHex)(value)) {
     return (0, _utils.decodeU8a)(registry, result, (0, _util.u8aToU8a)(value), Classes);
-  }
-  const Types = Classes[0];
-  for (let i = 0; i < Types.length; i++) {
-    try {
-      const entry = value == null ? void 0 : value[i];
-      result[i] = entry instanceof Types[i] ? entry : new Types[i](registry, entry);
-    } catch (error) {
-      throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
+  } else if (!value || !result.length) {
+    const Types = Classes[0];
+    for (let i = 0; i < Types.length; i++) {
+      result[i] = new Types[i](registry);
     }
+    return [result, 0];
   }
-  return [result, 0];
+  throw new Error(`Expected array input to Tuple decoding, found ${typeof value}: ${(0, _util.stringify)(value)}`);
 }
 
 /**

package/cjs/base/Vec.js

@@ -19,13 +19,17 @@ function noopSetDefinition(d) {
 function decodeVecLength(value) {
   if (Array.isArray(value)) {
     return [value, value.length, 0];
+  } else if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
+    const u8a = (0, _util.u8aToU8a)(value);
+    const [startAt, length] = (0, _util.compactFromU8aLim)(u8a);
+    if (length > MAX_LENGTH) {
+      throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+    }
+    return [u8a, length, startAt];
+  } else if (!value) {
+    return [null, 0, 0];
   }
-  const u8a = (0, _util.u8aToU8a)(value);
-  const [startAt, length] = (0, _util.compactFromU8aLim)(u8a);
-  if (length > MAX_LENGTH) {
-    throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
-  }
-  return [u8a, length, startAt];
+  throw new Error(`Expected array/hex input to Vec<*> decoding, found ${typeof value}: ${(0, _util.stringify)(value)}`);
 }
 function decodeVec(registry, result, value, startAt, Type) {
   if (Array.isArray(value)) {
@@ -42,7 +46,11 @@ function decodeVec(registry, result, value, startAt, Type) {
       }
     }
     return [0, 0];
+  } else if (!value) {
+    return [0, 0];
   }
+
+  // we don't need more checks, we already limited it via the length decoding
   return (0, _utils.decodeU8aVec)(registry, result, (0, _util.u8aToU8a)(value), startAt, Type);
 }
 
@@ -64,7 +72,12 @@ class Vec extends _Array.AbstractArray {
     const [decodeFrom, length, startAt] = decodeVecLength(value);
     super(registry, length);
     this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
-    this.initialU8aLength = ((0, _util.isU8a)(decodeFrom) ? (0, _utils.decodeU8aVec)(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type))[0];
+    try {
+      this.initialU8aLength = ((0, _util.isU8a)(decodeFrom) ? (0, _utils.decodeU8aVec)(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type))[0];
+    } catch (e) {
+      console.error(decodeFrom, length, startAt);
+      throw e;
+    }
   }
   static with(Type) {
     let definition;

package/cjs/native/Bool.js

@@ -15,6 +15,7 @@ var _util = require("@polkadot/util");
  * @noInheritDoc
  */
 class bool extends Boolean {
+  initialU8aLength = 1;
   constructor(registry) {
     let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     super((0, _util.isU8a)(value) ? value[0] === 1 : value instanceof Boolean ? value.valueOf() : !!value);

package/cjs/native/Date.js

@@ -35,6 +35,7 @@ function decodeDate(value) {
  * @noInheritDoc
  */
 class CodecDate extends Date {
+  initialU8aLength = BITLENGTH / 8;
   constructor(registry) {
     let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
     super(decodeDate(value));

package/cjs/native/Struct.js

@@ -222,7 +222,7 @@ class Struct extends Map {
   toHuman(isExtended) {
     const json = {};
     for (const [k, v] of this.entries()) {
-      json[k] = v && v.toHuman(isExtended);
+      json[k] = v.toHuman(isExtended);
     }
     return json;
   }
@@ -233,11 +233,9 @@ class Struct extends Map {
   toJSON() {
     const json = {};
     for (const [k, v] of this.entries()) {
-      const jsonKey = this.#jsonMap.get(k) || k;
-
-      // We actually log inside the U8a decoding and use JSON.stringify(...), which
-      // means that the Vec may be partially populated (same applies to toHuman, same check)
-      json[jsonKey] = v && v.toJSON();
+      // Here we pull out the entry against the JSON mapping (if supplied)
+      // since this representation goes over RPC and needs to be correct
+      json[this.#jsonMap.get(k) || k] = v.toJSON();
     }
     return json;
   }
@@ -248,11 +246,7 @@ class Struct extends Map {
   toPrimitive() {
     const json = {};
     for (const [k, v] of this.entries()) {
-      const jsonKey = this.#jsonMap.get(k) || k;
-
-      // We actually log inside the U8a decoding and use JSON.stringify(...), which
-      // means that the Vec may be partially populated (same applies to toHuman, same check)
-      json[jsonKey] = v && v.toPrimitive();
+      json[k] = v.toPrimitive();
     }
     return json;
   }
@@ -278,9 +272,7 @@ class Struct extends Map {
   toU8a(isBare) {
     const encoded = [];
     for (const [k, v] of this.entries()) {
-      if (v && (0, _util.isFunction)(v.toU8a)) {
-        encoded.push(v.toU8a(!isBare || (0, _util.isBoolean)(isBare) ? isBare : isBare[k]));
-      }
+      encoded.push(v.toU8a(!isBare || (0, _util.isBoolean)(isBare) ? isBare : isBare[k]));
     }
     return (0, _util.u8aConcatStrict)(encoded);
   }

package/cjs/packageInfo.js

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

package/extended/BTreeSet.d.ts

@@ -4,7 +4,8 @@ export declare class BTreeSet<V extends Codec = Codec> extends Set<V> implements
     #private;
     readonly registry: Registry;
     createdAtHash?: IU8a;
-    readonly initialU8aLength?: number;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
     constructor(registry: Registry, valType: CodecClass<V> | string, rawValue?: Uint8Array | string | string[] | Set<any>);
     static with<V extends Codec>(valType: CodecClass<V> | string): CodecClass<BTreeSet<V>>;
     /**

package/extended/Map.d.ts

@@ -4,7 +4,8 @@ export declare class CodecMap<K extends Codec = Codec, V extends Codec = Codec>
     #private;
     readonly registry: Registry;
     createdAtHash?: IU8a;
-    readonly initialU8aLength?: number;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
     constructor(registry: Registry, keyType: CodecClass<K> | string, valType: CodecClass<V> | string, rawValue: Uint8Array | string | Map<any, any> | undefined, type?: 'BTreeMap' | 'HashMap');
     /**
      * @description The length of the value when encoded as a Uint8Array

package/native/Bool.d.ts

@@ -9,6 +9,8 @@ import type { AnyBool, Codec, Inspect, IU8a, Registry } from '../types';
 export declare class bool extends Boolean implements Codec {
     readonly registry: Registry;
     createdAtHash?: IU8a;
+    initialU8aLength: number;
+    isStorageFallback?: boolean;
     constructor(registry: Registry, value?: bool | AnyBool | Uint8Array | number);
     /**
      * @description The length of the value when encoded as a Uint8Array

package/native/Bool.js

@@ -10,6 +10,7 @@ import { isU8a, u8aToHex } from '@polkadot/util';
  * @noInheritDoc
  */
 export class bool extends Boolean {
+  initialU8aLength = 1;
   constructor(registry, value = false) {
     super(isU8a(value) ? value[0] === 1 : value instanceof Boolean ? value.valueOf() : !!value);
     this.registry = registry;

package/native/Date.d.ts

@@ -15,6 +15,8 @@ import { BN } from '@polkadot/util';
 export declare class CodecDate extends Date implements INumber {
     readonly registry: Registry;
     createdAtHash?: IU8a;
+    initialU8aLength: number;
+    isStorageFallback?: boolean;
     constructor(registry: Registry, value?: CodecDate | Date | AnyNumber);
     /**
      * @description The length of the value when encoded as a Uint8Array

package/native/Date.js

@@ -29,6 +29,7 @@ function decodeDate(value) {
  * @noInheritDoc
  */
 export class CodecDate extends Date {
+  initialU8aLength = BITLENGTH / 8;
   constructor(registry, value = 0) {
     super(decodeDate(value));
     this.registry = registry;

package/native/Float.d.ts

@@ -13,10 +13,11 @@ interface Options {
  */
 export declare class Float extends Number implements IFloat {
     #private;
-    createdAtHash?: IU8a;
     readonly encodedLength: number;
-    readonly initialU8aLength?: number;
     readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
     constructor(registry: Registry, value?: AnyFloat, { bitLength }?: Options);
     static with(bitLength: 32 | 64): CodecClass<Float>;
     /**

package/native/Json.d.ts

@@ -11,6 +11,8 @@ import type { AnyJson, Codec, Inspect, IU8a, Registry } from '../types';
 export declare class Json extends Map<string, any> implements Codec {
     readonly registry: Registry;
     createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
     constructor(registry: Registry, value?: Record<string, unknown> | null);
     /**
      * @description Always 0, never encodes as a Uint8Array

package/native/Raw.d.ts

@@ -10,9 +10,10 @@ import type { AnyJson, AnyU8a, Inspect, IU8a, Registry } from '../types';
  * @noInheritDoc
  */
 export declare class Raw extends Uint8Array implements IU8a {
-    createdAtHash?: IU8a;
-    readonly initialU8aLength?: number;
     readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
     /**
      * @description This ensures that operators such as clice, filter, map, etc. return
      * new Array instances (without this we need to apply overrides)

package/native/Set.d.ts

@@ -13,6 +13,8 @@ export declare class CodecSet extends Set<string> implements ISet<string> {
     #private;
     readonly registry: Registry;
     createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
     constructor(registry: Registry, setValues: SetValues, value?: string[] | Set<string> | Uint8Array | BN | number | string, bitLength?: number);
     static with(values: SetValues, bitLength?: number): CodecClass<CodecSet>;
     /**

package/native/Struct.d.ts

@@ -26,9 +26,10 @@ export declare class Struct<S extends TypesDef = TypesDef, V extends {
     [K in keyof S]: string;
 }> extends Map<keyof S, Codec> implements IStruct<keyof S> {
     #private;
-    createdAtHash?: IU8a;
-    readonly initialU8aLength?: number;
     readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
     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>>;
     /**

package/native/Struct.js

@@ -1,7 +1,7 @@
 // Copyright 2017-2023 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { isBoolean, isFunction, isHex, isObject, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { isBoolean, isHex, isObject, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { compareMap, decodeU8aStruct, mapToTypeMap, typesToMap } from "../utils/index.js";
 function noopSetDefinition(d) {
   return d;
@@ -213,7 +213,7 @@ export class Struct extends Map {
   toHuman(isExtended) {
     const json = {};
     for (const [k, v] of this.entries()) {
-      json[k] = v && v.toHuman(isExtended);
+      json[k] = v.toHuman(isExtended);
     }
     return json;
   }
@@ -224,11 +224,9 @@ export class Struct extends Map {
   toJSON() {
     const json = {};
     for (const [k, v] of this.entries()) {
-      const jsonKey = this.#jsonMap.get(k) || k;
-
-      // We actually log inside the U8a decoding and use JSON.stringify(...), which
-      // means that the Vec may be partially populated (same applies to toHuman, same check)
-      json[jsonKey] = v && v.toJSON();
+      // Here we pull out the entry against the JSON mapping (if supplied)
+      // since this representation goes over RPC and needs to be correct
+      json[this.#jsonMap.get(k) || k] = v.toJSON();
     }
     return json;
   }
@@ -239,11 +237,7 @@ export class Struct extends Map {
   toPrimitive() {
     const json = {};
     for (const [k, v] of this.entries()) {
-      const jsonKey = this.#jsonMap.get(k) || k;
-
-      // We actually log inside the U8a decoding and use JSON.stringify(...), which
-      // means that the Vec may be partially populated (same applies to toHuman, same check)
-      json[jsonKey] = v && v.toPrimitive();
+      json[k] = v.toPrimitive();
     }
     return json;
   }
@@ -269,9 +263,7 @@ export class Struct extends Map {
   toU8a(isBare) {
     const encoded = [];
     for (const [k, v] of this.entries()) {
-      if (v && isFunction(v.toU8a)) {
-        encoded.push(v.toU8a(!isBare || isBoolean(isBare) ? isBare : isBare[k]));
-      }
+      encoded.push(v.toU8a(!isBare || isBoolean(isBare) ? isBare : isBare[k]));
     }
     return u8aConcatStrict(encoded);
   }

package/native/Text.d.ts

@@ -10,9 +10,10 @@ import type { AnyString, AnyU8a, Inspect, IText, IU8a, Registry } from '../types
  */
 export declare class Text extends String implements IText {
     #private;
-    createdAtHash?: IU8a;
-    readonly initialU8aLength?: number;
     readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
     constructor(registry: Registry, value?: null | AnyString | AnyU8a | {
         toString: () => string;
     });

package/package.json

@@ -20,7 +20,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "9.11.3",
+  "version": "9.13.1",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -47,16 +47,16 @@
       "require": "./cjs/abstract/Base.js",
       "default": "./abstract/Base.js"
     },
-    "./abstract/BigInt": {
-      "types": "./abstract/BigInt.d.ts",
-      "require": "./cjs/abstract/BigInt.js",
-      "default": "./abstract/BigInt.js"
-    },
     "./abstract/Int": {
       "types": "./abstract/Int.d.ts",
       "require": "./cjs/abstract/Int.js",
       "default": "./abstract/Int.js"
     },
+    "./abstract/Object": {
+      "types": "./abstract/Object.d.ts",
+      "require": "./cjs/abstract/Object.js",
+      "default": "./abstract/Object.js"
+    },
     "./base": {
       "types": "./base/index.d.ts",
       "require": "./cjs/base/index.js",
@@ -434,8 +434,8 @@
     }
   },
   "dependencies": {
-    "@babel/runtime": "^7.20.7",
-    "@polkadot/util": "^10.2.6",
-    "@polkadot/x-bigint": "^10.2.6"
+    "@babel/runtime": "^7.20.13",
+    "@polkadot/util": "^10.3.1",
+    "@polkadot/x-bigint": "^10.3.1"
   }
 }

package/packageInfo.js

@@ -7,5 +7,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: '9.11.3'
+  version: '9.13.1'
 };