@polkadot/types-codec 9.12.1 → 9.13.2

package/abstract/Base.d.ts

@@ -19,6 +19,9 @@ export declare abstract class AbstractBase<T extends Codec> implements Codec {
      * @description returns a hash of the contents
      */
     get hash(): IU8a;
+    /**
+     * @description returns the inner (wrapped value)
+     */
     get inner(): T;
     /**
      * @description Checks if the value is an empty value
@@ -60,6 +63,13 @@ export declare abstract class AbstractBase<T extends Codec> implements Codec {
     /**
      * @description Returns the base runtime type name for this instance
      */
-    toRawType(): string;
+    abstract toRawType(): string;
+    /**
+     * @description Returns the inner wrapped value (equivalent to valueOf)
+     */
     unwrap(): T;
+    /**
+     * @description Returns the inner wrapped value
+     */
+    valueOf(): T;
 }

package/abstract/Base.js

@@ -26,6 +26,10 @@ export class AbstractBase {
   get hash() {
     return this.registry.hash(this.toU8a());
   }
+
+  /**
+   * @description returns the inner (wrapped value)
+   */
   get inner() {
     return this.#raw;
   }
@@ -97,10 +101,18 @@ export 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;
+  }
 }

package/abstract/Int.d.ts

@@ -16,7 +16,7 @@ export declare abstract class AbstractInt extends BN implements INumber {
     createdAtHash?: IU8a;
     initialU8aLength?: number;
     isStorageFallback?: boolean;
-    constructor(registry: Registry, value?: AnyNumber, bitLength?: UIntBitLength, isSigned?: boolean);
+    constructor(registry: Registry, value?: AnyNumber | null, bitLength?: UIntBitLength, isSigned?: boolean);
     /**
      * @description returns a hash of the contents
      */

package/abstract/Int.js

@@ -1,7 +1,7 @@
 // Copyright 2017-2023 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_QUINTILL, bnToBn, bnToHex, bnToU8a, formatBalance, formatNumber, hexToBn, isBn, isFunction, isHex, isNumber, isObject, isString, isU8a, u8aToBn, u8aToNumber } from '@polkadot/util';
+import { BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_QUINTILL, bnToBn, bnToHex, bnToU8a, formatBalance, formatNumber, hexToBn, isBigInt, isBn, isFunction, isHex, isNumber, isObject, isString, isU8a, u8aToBn, u8aToNumber } from '@polkadot/util';
 export const DEFAULT_UINT_BITS = 64;
 
 // Maximum allowed integer for JS is 2^53 - 1, set limit at 52
@@ -9,6 +9,9 @@ export const DEFAULT_UINT_BITS = 64;
 const MAX_NUMBER_BITS = 52;
 const MUL_P = new BN(10000);
 const FORMATTERS = [['Perquintill', BN_QUINTILL], ['Perbill', BN_BILLION], ['Permill', BN_MILLION], ['Percent', BN_HUNDRED]];
+function isToBn(value) {
+  return isFunction(value.toBn);
+}
 function toPercentage(value, divisor) {
   return `${(value.mul(MUL_P).div(divisor).toNumber() / 100).toFixed(2)}%`;
 }
@@ -31,9 +34,13 @@ function decodeAbstractInt(value, isNegative) {
       throw new Error('String should not contain decimal points or scientific notation');
     }
     return value;
-  } else if (isBn(value)) {
+  } else if (isBn(value) || isBigInt(value)) {
     return value.toString();
-  } else if (isObject(value) && !isFunction(value.toBn)) {
+  } else if (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)
@@ -41,13 +48,11 @@ 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 (!isString(inner) && !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);
+  } else if (!value) {
+    return 0;
   }
-  return bnToBn(value).toString();
+  throw new Error(`Unable to create BN from unknown type ${typeof value}`);
 }
 
 /**

package/abstract/Object.d.ts

@@ -0,0 +1,67 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson, BareOpts, CodecObject, Inspect, IU8a, Registry, ToString } from '../types';
+/**
+ * @name Object
+ * @description A type extends the Base class, when it holds a value
+ */
+export declare abstract class AbstractObject<T extends ToString> implements CodecObject<T> {
+    readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
+    readonly $: T;
+    protected constructor(registry: Registry, value: T, initialU8aLength?: number);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    abstract get isEmpty(): boolean;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    abstract eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    abstract inspect(): Inspect;
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    abstract toHex(isLe?: boolean): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    abstract toHuman(isExtended?: boolean): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    abstract toJSON(): AnyJson;
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    abstract toPrimitive(): AnyJson;
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString(): string;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    abstract toU8a(isBare?: BareOpts): Uint8Array;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    abstract toRawType(): string;
+    /**
+     * @description Return the internal value (JS-aligned, same result as $)
+     */
+    valueOf(): T;
+}

package/abstract/Object.js

@@ -0,0 +1,51 @@
+// 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
+ */
+export 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.$;
+  }
+}

package/base/Int.d.ts

@@ -11,6 +11,6 @@ import { AbstractInt } from '../abstract/Int';
  * @noInheritDoc
  */
 export declare class Int extends AbstractInt {
-    constructor(registry: Registry, value?: AnyNumber, bitLength?: UIntBitLength);
+    constructor(registry: Registry, value?: AnyNumber | null, bitLength?: UIntBitLength);
     static with(bitLength: UIntBitLength, typeName?: string): CodecClass<Int>;
 }

package/cjs/abstract/Base.js

@@ -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,11 @@ 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);
+  } else if (!value) {
+    return 0;
   }
-  return (0, _util.bnToBn)(value).toString();
+  throw new Error(`Unable to create BN from unknown type ${typeof value}`);
 }
 
 /**

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/packageInfo.js

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

package/package.json

@@ -20,7 +20,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "9.12.1",
+  "version": "9.13.2",
   "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",
@@ -435,7 +435,7 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.20.13",
-    "@polkadot/util": "^10.2.6",
-    "@polkadot/x-bigint": "^10.2.6"
+    "@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.12.1'
+  version: '9.13.2'
 };

package/types/codec.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson } from './helpers';
+import type { AnyJson, ToString } from './helpers';
 import type { IU8a } from './interfaces';
 import type { Registry } from './registry';
 export type BareOpts = boolean | Record<string, boolean>;
@@ -101,5 +101,9 @@ export interface CodecClass<T = Codec> {
     readonly __fallbackType?: string;
     new (registry: Registry, ...args: any[]): T;
 }
+export interface CodecObject<T extends ToString> extends Codec {
+    readonly $: T;
+    valueOf(): T;
+}
 export type CodecTo = 'toHex' | 'toJSON' | 'toPrimitive' | 'toString' | 'toU8a';
 export type ArgsDef = Record<string, CodecClass | string>;

package/types/helpers.d.ts

@@ -15,3 +15,10 @@ export type AnyU8a = Uint8Array | number[] | string;
 export type UIntBitLength = 8 | 16 | 32 | 64 | 128 | 256;
 export type U8aBitLength = 8 | 16 | 32 | 64 | 128 | 160 | 256 | 264 | 512 | 520 | 1024 | 2048;
 export type AnyTupleValue = Exclude<AnyU8a, string> | HexString | (Codec | AnyU8a | AnyNumber | AnyString | undefined | null)[];
+export interface ToString {
+    toString: () => string;
+}
+export interface ToBn {
+    toBn: () => BN;
+}
+export type LookupString = `Lookup${number}`;

package/types/registry.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import type { BN } from '@polkadot/util';
 import type { Codec, CodecClass } from './codec';
-import type { AnyTuple } from './helpers';
+import type { AnyTuple, LookupString } from './helpers';
 import type { ICompact, IEnum, IMap, IMethod, INumber, IOption, IResult, ISet, IStruct, ITuple, IU8a, IVec } from './interfaces';
 export type OnlyCodec<K, T, Types> = K extends keyof Types ? Types[K] : T extends ICompact | IEnum | IMap | IMethod | INumber | IOption | IResult | ISet | IStruct | ITuple | IU8a | IVec ? T : T extends Codec ? T : never;
 export interface RegistryError {
@@ -45,8 +45,8 @@ export interface Registry {
         index: BN;
     }): RegistryError;
     findMetaEvent(eventIndex: Uint8Array): CodecClass<any>;
-    isLookupType(value: string): boolean;
-    createLookupType(lookupId: ICompact<INumber> | number): string;
+    isLookupType(value: string): value is LookupString;
+    createLookupType(lookupId: ICompact<INumber> | number): LookupString;
     createClassUnsafe<T extends Codec = Codec, K extends string = string>(type: K): CodecClass<T>;
     createTypeUnsafe<T extends Codec = Codec, K extends string = string>(type: K, params: unknown[], options?: CodecCreateOptions): T;
     getClassName(clazz: CodecClass): string | undefined;

package/abstract/BigInt.d.ts

@@ -1,4 +0,0 @@
-import { BigInt } from '@polkadot/x-bigint';
-export declare abstract class AbstractBigInt extends BigInt {
-    constructor(value: string | number | bigint | boolean);
-}

package/abstract/BigInt.js

@@ -1,14 +0,0 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { BigInt } from '@polkadot/x-bigint';
-
-// @ts-expect-error not extensible, we make it extensible here
-export class AbstractBigInt extends BigInt {
-  // @ts-expect-error super() not required, the self magic does that
-  constructor(value) {
-    const self = Object(BigInt(value));
-    Object.setPrototypeOf(self, AbstractBigInt.prototype);
-    return self;
-  }
-}

package/cjs/abstract/BigInt.js

@@ -1,20 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.AbstractBigInt = void 0;
-var _xBigint = require("@polkadot/x-bigint");
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// @ts-expect-error not extensible, we make it extensible here
-class AbstractBigInt extends _xBigint.BigInt {
-  // @ts-expect-error super() not required, the self magic does that
-  constructor(value) {
-    const self = Object((0, _xBigint.BigInt)(value));
-    Object.setPrototypeOf(self, AbstractBigInt.prototype);
-    return self;
-  }
-}
-exports.AbstractBigInt = AbstractBigInt;