@polkadot/types-codec 7.7.2-0 → 7.7.2-12

package/abstract/AbstractArray.cjs

@@ -83,6 +83,27 @@ class AbstractArray extends Array {
   eq(other) {
     return (0, _compareArray.compareArray)(this, other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      inner: this.inspectInner(),
+      outer: [(0, _util.compactToU8a)(this.length)]
+    };
+  }
+
+  inspectInner() {
+    const inner = new Array(this.length);
+
+    for (let i = 0; i < this.length; i++) {
+      inner[i] = this[i].inspect();
+    }
+
+    return inner;
+  }
   /**
    * @description Converts the Object to an standard JavaScript Array
    */
@@ -151,13 +172,18 @@ class AbstractArray extends Array {
 
 
   toU8a(isBare) {
+    const encoded = this.toU8aInner();
+    return isBare ? (0, _util.u8aConcat)(...encoded) : (0, _util.u8aConcat)((0, _util.compactToU8a)(this.length), ...encoded);
+  }
+
+  toU8aInner(isBare) {
     const encoded = new Array(this.length);
 
     for (let i = 0; i < this.length; i++) {
       encoded[i] = this[i].toU8a(isBare);
     }
 
-    return isBare ? (0, _util.u8aConcat)(...encoded) : (0, _util.u8aConcat)((0, _util.compactToU8a)(this.length), ...encoded);
+    return encoded;
   } // Below are methods that we override. When we do a `new Vec(...).map()`,
   // we want it to return an Array. We only override the methods that return a
   // new instance.

package/abstract/AbstractArray.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, IU8a, IVec, Registry } from '../types';
+import type { AnyJson, Codec, Inspect, IU8a, IVec, Registry } from '../types';
 /**
  * @name AbstractArray
  * @description
@@ -32,6 +32,11 @@ export declare abstract class AbstractArray<T extends Codec> extends Array<T> im
      * @description Compares the value of the input to see if there is a match
      */
     eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    inspectInner(): Inspect[];
     /**
      * @description Converts the Object to an standard JavaScript Array
      */
@@ -61,6 +66,7 @@ export declare abstract class AbstractArray<T extends Codec> extends Array<T> im
      * @param isBare true when the value has none of the type-specific prefixes (internal)
      */
     toU8a(isBare?: boolean): Uint8Array;
+    toU8aInner(isBare?: boolean): Uint8Array[];
     /**
      * @description Concatenates two arrays
      */

package/abstract/AbstractArray.js

@@ -70,6 +70,27 @@ export class AbstractArray extends Array {
   eq(other) {
     return compareArray(this, other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      inner: this.inspectInner(),
+      outer: [compactToU8a(this.length)]
+    };
+  }
+
+  inspectInner() {
+    const inner = new Array(this.length);
+
+    for (let i = 0; i < this.length; i++) {
+      inner[i] = this[i].inspect();
+    }
+
+    return inner;
+  }
   /**
    * @description Converts the Object to an standard JavaScript Array
    */
@@ -138,13 +159,18 @@ export class AbstractArray extends Array {
 
 
   toU8a(isBare) {
+    const encoded = this.toU8aInner();
+    return isBare ? u8aConcat(...encoded) : u8aConcat(compactToU8a(this.length), ...encoded);
+  }
+
+  toU8aInner(isBare) {
     const encoded = new Array(this.length);
 
     for (let i = 0; i < this.length; i++) {
       encoded[i] = this[i].toU8a(isBare);
     }
 
-    return isBare ? u8aConcat(...encoded) : u8aConcat(compactToU8a(this.length), ...encoded);
+    return encoded;
   } // Below are methods that we override. When we do a `new Vec(...).map()`,
   // we want it to return an Array. We only override the methods that return a
   // new instance.

package/abstract/AbstractInt.cjs

@@ -140,6 +140,16 @@ class AbstractInt extends _util.BN {
       isNegative: (0, _classPrivateFieldLooseBase2.default)(this, _isSigned)[_isSigned]
     }) : (0, _util.bnToBn)(other));
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      outer: [this.toU8a()]
+    };
+  }
   /**
    * @description True if this value is the max of the type
    */

package/abstract/AbstractInt.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import type { HexString } from '@polkadot/util/types';
-import type { AnyNumber, INumber, IU8a, Registry, UIntBitLength } from '../types';
+import type { AnyNumber, Inspect, INumber, IU8a, Registry, UIntBitLength } from '../types';
 import { BN } from '@polkadot/util';
 export declare const DEFAULT_UINT_BITS = 64;
 /**
@@ -34,6 +34,10 @@ export declare abstract class AbstractInt extends BN implements INumber {
      * @description Compares the value of the input to see if there is a match
      */
     eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
     /**
      * @description True if this value is the max of the type
      */

package/abstract/AbstractInt.js

@@ -110,6 +110,16 @@ export class AbstractInt extends BN {
       isNegative: this.#isSigned
     }) : bnToBn(other));
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      outer: [this.toU8a()]
+    };
+  }
   /**
    * @description True if this value is the max of the type
    */

package/base/Base.cjs

@@ -78,6 +78,14 @@ class Base {
   eq(other) {
     return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].eq(other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].inspect();
+  }
   /**
    * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
    */

package/base/Base.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, BareOpts, Codec, IU8a, Registry } from '../types';
+import type { AnyJson, BareOpts, Codec, Inspect, IU8a, Registry } from '../types';
 /**
  * @name Base
  * @description A type extends the Base class, when it holds a value
@@ -27,6 +27,10 @@ export declare abstract class Base<T extends Codec> implements Codec {
      * @description Compares the value of the input to see if there is a match
      */
     eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
     /**
      * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
      */

package/base/Base.js

@@ -54,6 +54,14 @@ export class Base {
   eq(other) {
     return this.#raw.eq(other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return this.#raw.inspect();
+  }
   /**
    * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
    */

package/base/Compact.cjs

@@ -113,6 +113,16 @@ class Compact {
   eq(other) {
     return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].eq(other instanceof Compact ? (0, _classPrivateFieldLooseBase2.default)(other, _raw)[_raw] : other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      outer: [this.toU8a()]
+    };
+  }
   /**
    * @description Returns a BigInt representation of the number
    */

package/base/Compact.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import type { BN } from '@polkadot/util';
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, AnyNumber, CodecClass, ICompact, INumber, IU8a, Registry } from '../types';
+import type { AnyJson, AnyNumber, CodecClass, ICompact, Inspect, INumber, IU8a, Registry } from '../types';
 /**
  * @name Compact
  * @description
@@ -39,6 +39,10 @@ export declare class Compact<T extends INumber> implements ICompact<T> {
      * @description Compares the value of the input to see if there is a match
      */
     eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
     /**
      * @description Returns a BigInt representation of the number
      */

package/base/Compact.js

@@ -86,6 +86,16 @@ export class Compact {
   eq(other) {
     return this.#raw.eq(other instanceof Compact ? other.#raw : other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      outer: [this.toU8a()]
+    };
+  }
   /**
    * @description Returns a BigInt representation of the number
    */

package/base/DoNotConstruct.cjs

@@ -72,6 +72,10 @@ class DoNotConstruct {
     throw (0, _classPrivateFieldLooseBase2.default)(this, _neverError)[_neverError];
   }
 
+  inspect() {
+    throw (0, _classPrivateFieldLooseBase2.default)(this, _neverError)[_neverError];
+  }
+
   toHex() {
     throw (0, _classPrivateFieldLooseBase2.default)(this, _neverError)[_neverError];
   }

package/base/DoNotConstruct.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, IU8a, Registry } from '../types';
+import type { AnyJson, Codec, CodecClass, Inspect, IU8a, Registry } from '../types';
 /**
  * @name DoNotConstruct
  * @description
@@ -24,6 +24,7 @@ export declare class DoNotConstruct implements Codec {
      */
     get isEmpty(): boolean;
     eq(): boolean;
+    inspect(): Inspect;
     toHex(): HexString;
     toHuman(): AnyJson;
     toJSON(): AnyJson;

package/base/DoNotConstruct.js

@@ -52,6 +52,10 @@ export class DoNotConstruct {
     throw this.#neverError;
   }
 
+  inspect() {
+    throw this.#neverError;
+  }
+
   toHex() {
     throw this.#neverError;
   }

package/base/Enum.cjs

@@ -354,6 +354,28 @@ class Enum {
 
     return this.value.eq(other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    if (this.isBasic) {
+      return {
+        outer: [new Uint8Array([this.index])]
+      };
+    }
+
+    const {
+      inner,
+      outer = []
+    } = (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].inspect();
+
+    return {
+      inner,
+      outer: [new Uint8Array([this.index]), ...outer]
+    };
+  }
   /**
    * @description Returns a hex string representation of the value
    */

package/base/Enum.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, IEnum, IU8a, Registry } from '../types';
+import type { AnyJson, Codec, CodecClass, IEnum, Inspect, IU8a, Registry } from '../types';
 export interface EnumCodecClass<T = Codec> {
     new (registry: Registry, value?: any, index?: number): T;
 }
@@ -69,6 +69,10 @@ export declare class Enum implements IEnum {
      * @description Compares the value of the input to see if there is a match
      */
     eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
     /**
      * @description Returns a hex string representation of the value
      */

package/base/Enum.js

@@ -299,6 +299,27 @@ export class Enum {
 
     return this.value.eq(other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    if (this.isBasic) {
+      return {
+        outer: [new Uint8Array([this.index])]
+      };
+    }
+
+    const {
+      inner,
+      outer = []
+    } = this.#raw.inspect();
+    return {
+      inner,
+      outer: [new Uint8Array([this.index]), ...outer]
+    };
+  }
   /**
    * @description Returns a hex string representation of the value
    */

package/base/Null.cjs

@@ -55,6 +55,14 @@ class Null {
   eq(other) {
     return other instanceof Null || (0, _util.isNull)(other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {};
+  }
   /**
    * @description Returns a hex string representation of the value
    */

package/base/Null.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { Codec, IU8a, Registry } from '../types';
+import type { Codec, Inspect, IU8a, Registry } from '../types';
 /**
  * @name Null
  * @description
@@ -26,6 +26,10 @@ export declare class Null implements Codec {
      * @description Compares the value of the input to see if there is a match
      */
     eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
     /**
      * @description Returns a hex string representation of the value
      */

package/base/Null.js

@@ -46,6 +46,14 @@ export class Null {
   eq(other) {
     return other instanceof Null || isNull(other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {};
+  }
   /**
    * @description Returns a hex string representation of the value
    */

package/base/Option.cjs

@@ -160,6 +160,28 @@ class Option {
 
     return this.value.eq(other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    if (this.isNone) {
+      return {
+        outer: [new Uint8Array([0])]
+      };
+    }
+
+    const {
+      inner,
+      outer = []
+    } = (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].inspect();
+
+    return {
+      inner,
+      outer: [new Uint8Array([1]), ...outer]
+    };
+  }
   /**
    * @description Returns a hex string representation of the value
    */

package/base/Option.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, IOption, IU8a, Registry } from '../types';
+import type { AnyJson, Codec, CodecClass, Inspect, IOption, IU8a, Registry } from '../types';
 /**
  * @name Option
  * @description
@@ -46,6 +46,10 @@ export declare class Option<T extends Codec> implements IOption<T> {
      * @description Compares the value of the input to see if there is a match
      */
     eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
     /**
      * @description Returns a hex string representation of the value
      */

package/base/Option.js

@@ -128,6 +128,27 @@ export class Option {
 
     return this.value.eq(other);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    if (this.isNone) {
+      return {
+        outer: [new Uint8Array([0])]
+      };
+    }
+
+    const {
+      inner,
+      outer = []
+    } = this.#raw.inspect();
+    return {
+      inner,
+      outer: [new Uint8Array([1]), ...outer]
+    };
+  }
   /**
    * @description Returns a hex string representation of the value
    */

package/base/Tuple.cjs

@@ -93,6 +93,16 @@ class Tuple extends _AbstractArray.AbstractArray {
   get Types() {
     return Array.isArray((0, _classPrivateFieldLooseBase2.default)(this, _Types)[_Types]) ? (0, _classPrivateFieldLooseBase2.default)(this, _Types)[_Types].map(T => new T(this.registry).toRawType()) : Object.keys((0, _classPrivateFieldLooseBase2.default)(this, _Types)[_Types]);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      inner: this.inspectInner()
+    };
+  }
   /**
    * @description Returns the base runtime type name for this instance
    */
@@ -118,13 +128,7 @@ class Tuple extends _AbstractArray.AbstractArray {
 
 
   toU8a(isBare) {
-    const encoded = new Array(this.length);
-
-    for (let i = 0; i < this.length; i++) {
-      encoded[i] = this[i].toU8a(isBare);
-    }
-
-    return (0, _util.u8aConcat)(...encoded);
+    return (0, _util.u8aConcat)(...this.toU8aInner(isBare));
   }
 
 }

package/base/Tuple.d.ts

@@ -1,4 +1,4 @@
-import type { AnyTupleValue, Codec, CodecClass, ITuple, Registry } from '../types';
+import type { AnyTupleValue, Codec, CodecClass, Inspect, ITuple, Registry } from '../types';
 import { AbstractArray } from '../abstract/AbstractArray';
 declare type TupleType = (CodecClass | string);
 declare type TupleTypes = TupleType[] | {
@@ -22,6 +22,10 @@ export declare class Tuple extends AbstractArray<Codec> implements ITuple<Codec[
      * @description The types definition of the tuple
      */
     get Types(): string[];
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
     /**
      * @description Returns the base runtime type name for this instance
      */

package/base/Tuple.js

@@ -73,6 +73,16 @@ 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);
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      inner: this.inspectInner()
+    };
+  }
   /**
    * @description Returns the base runtime type name for this instance
    */
@@ -98,13 +108,7 @@ export class Tuple extends AbstractArray {
 
 
   toU8a(isBare) {
-    const encoded = new Array(this.length);
-
-    for (let i = 0; i < this.length; i++) {
-      encoded[i] = this[i].toU8a(isBare);
-    }
-
-    return u8aConcat(...encoded);
+    return u8aConcat(...this.toU8aInner(isBare));
   }
 
 }

package/base/VecFixed.cjs

@@ -85,16 +85,21 @@ class VecFixed extends _AbstractArray.AbstractArray {
 
     return total;
   }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      inner: this.inspectInner()
+    };
+  }
 
   toU8a() {
     // we override, we don't add the length prefix for ourselves, and at the same time we
     // ignore isBare on entries, since they should be properly encoded at all times
-    const encoded = new Array(this.length);
-
-    for (let i = 0; i < this.length; i++) {
-      encoded[i] = this[i].toU8a();
-    }
-
+    const encoded = this.toU8aInner();
     return encoded.length ? (0, _util.u8aConcat)(...encoded) : new Uint8Array([]);
   }
   /**

package/base/VecFixed.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { Codec, CodecClass, Registry } from '../types';
+import type { Codec, CodecClass, Inspect, Registry } from '../types';
 import { AbstractArray } from '../abstract/AbstractArray';
 /**
  * @name VecFixed
@@ -18,6 +18,10 @@ export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength(): number;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
     toU8a(): Uint8Array;
     /**
      * @description Returns the base runtime type name for this instance