@pezkuwi/types-codec 16.5.17 → 16.5.19

package/src/extended/Range.ts

@@ -0,0 +1,56 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyTuple, CodecClass, INumber, Registry } from '../types/index.js';
+
+import { Tuple } from '../base/Tuple.js';
+
+type RangeType = 'Range' | 'RangeInclusive';
+
+interface Options {
+  rangeName?: RangeType;
+}
+
+/**
+ * @name Range
+ * @description
+ * Rust `Range<T>` representation
+ */
+export class Range<T extends INumber> extends Tuple {
+  #rangeName: RangeType;
+
+  constructor (registry: Registry, Type: CodecClass<T> | string, value?: AnyTuple, { rangeName = 'Range' }: Options = {}) {
+    super(registry, [Type, Type], value);
+
+    this.#rangeName = rangeName;
+  }
+
+  public static override with <T extends INumber> (Type: CodecClass<T> | string): CodecClass<Range<T>> {
+    return class extends Range<T> {
+      constructor (registry: Registry, value?: AnyTuple) {
+        super(registry, Type, value);
+      }
+    };
+  }
+
+  /**
+   * @description Returns the starting range value
+   */
+  public get start (): T {
+    return this[0] as T;
+  }
+
+  /**
+   * @description Returns the ending range value
+   */
+  public get end (): T {
+    return this[1] as T;
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    return `${this.#rangeName}<${this.start.toRawType()}>`;
+  }
+}

package/src/extended/RangeInclusive.ts

@@ -0,0 +1,20 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyTuple, CodecClass, INumber, Registry } from '../types/index.js';
+
+import { Range } from './Range.js';
+
+export class RangeInclusive<T extends INumber = INumber> extends Range<T> {
+  constructor (registry: Registry, Type: CodecClass<T> | string, value?: AnyTuple) {
+    super(registry, Type, value, { rangeName: 'RangeInclusive' });
+  }
+
+  public static override with <T extends INumber> (Type: CodecClass<T> | string): CodecClass<RangeInclusive<T>> {
+    return class extends RangeInclusive<T> {
+      constructor (registry: Registry, value?: AnyTuple) {
+        super(registry, Type, value);
+      }
+    };
+  }
+}

package/src/extended/Type.spec.ts

@@ -0,0 +1,118 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '@pezkuwi/types';
+import { Text, Type } from '@pezkuwi/types-codec';
+import { stringToU8a, u8aConcat } from '@pezkuwi/util';
+
+describe('Type', (): void => {
+  const registry = new TypeRegistry();
+
+  it('fails to cleanup invalid boxes', (): void => {
+    expect(
+      (): Type => new Type(registry, 'Box<Proposal')
+    ).toThrow(/find closing matching/);
+  });
+
+  it('cleans up tuples with a single value', (): void => {
+    expect(
+      new Type(registry, '(AccountId)').toString()
+    ).toEqual('AccountId');
+  });
+
+  it('does not touch tuples with multiple values', (): void => {
+    expect(
+      new Type(registry, '(AccountId, Balance)').toString()
+    ).toEqual('(AccountId,Balance)');
+  });
+
+  it('handles nested types', (): void => {
+    expect(
+      new Type(registry, 'Box<Vec<AccountId>>').toString()
+    ).toEqual('Vec<AccountId>');
+  });
+
+  it('handles nested types (embedded)', (): void => {
+    expect(
+      new Type(registry, '(u32, Box<Vec<AccountId>>)').toString()
+    ).toEqual('(u32,Vec<AccountId>)');
+  });
+
+  it('handles aliasses, multiples per line', (): void => {
+    expect(
+      new Type(registry, '(Vec<u8>, AccountId, Vec<u8>)').toString()
+    ).toEqual('(Bytes,AccountId,Bytes)');
+  });
+
+  it('removes whitespaces', (): void => {
+    expect(
+      new Type(registry, 'T :: AccountId').toString()
+    ).toEqual('AccountId');
+  });
+
+  it('changes PairOf<T> -> (T, T)', (): void => {
+    expect(
+      new Type(registry, 'PairOf<T::Balance>').toString()
+    ).toEqual('(Balance,Balance)');
+  });
+
+  it('changes PairOf<T> (embedded) -> (T, T)', (): void => {
+    expect(
+      new Type(registry, '(Vec<u8>, PairOf<T::Balance>, Vec<AccountId>)').toString()
+    ).toEqual('(Bytes,(Balance,Balance),Vec<AccountId>)');
+  });
+
+  it('changes () -> ()', (): void => {
+    expect(
+      new Type(registry, '()').toString()
+    ).toEqual('()');
+  });
+
+  it('has the sanitized', (): void => {
+    expect(
+      new Type(
+        registry,
+        new Text(registry, ' Box<Proposal> ')
+      ).toString()
+    ).toEqual('Proposal'); // eslint-disable-line
+  });
+
+  it('unwraps compact', (): void => {
+    expect(
+      new Type(registry, '<T::Balance as HasCompact>::Type').toString()
+    ).toEqual('Compact<Balance>');
+  });
+
+  it('handles InherentOfflineReport', (): void => {
+    expect(
+      new Type(registry, '<T::InherentOfflineReport as InherentOfflineReport>::Inherent').toString()
+    ).toEqual('InherentOfflineReport');
+  });
+
+  it('encodes correctly via toU8a()', (): void => {
+    const type = 'Compact<Balance>';
+
+    expect(new Text(registry, type).toU8a()).toEqual(
+      u8aConcat(
+        new Uint8Array([type.length << 2]),
+        stringToU8a(type)
+      )
+    );
+  });
+
+  it('creates a decodable U8a for sanitized types', (): void => {
+    const original = '<T::InherentOfflineReport as InherentOfflineReport>::Inherent';
+    const expected = 'InherentOfflineReport';
+    const u8a = new Type(registry, original).toU8a();
+    const decoded = new Type(registry, u8a);
+
+    expect(decoded.encodedLength).toEqual(original.length + 1); // extra byte for length
+    expect(decoded.toString()).toEqual(expected);
+  });
+
+  it('has the correct raw', (): void => {
+    expect(new Type(registry).toRawType()).toEqual('Type');
+  });
+});

package/src/extended/Type.ts

@@ -0,0 +1,29 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '../types/index.js';
+
+import { Text } from '../native/Text.js';
+import { sanitize } from '../utils/index.js';
+
+/**
+ * @name Type
+ * @description
+ * This is a extended version of Text, specifically to handle types. Here we rely fully
+ * on what Text provides us, however we also adjust the types received from the runtime,
+ * i.e. we remove the `T::` prefixes found in some types for consistency across implementation.
+ */
+export class Type extends Text {
+  constructor (registry: Registry, value: Text | Uint8Array | string = '') {
+    super(registry, value);
+
+    this.setOverride(sanitize(this.toString()));
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    return 'Type';
+  }
+}

package/src/extended/U8aFixed.spec.ts

@@ -0,0 +1,117 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '@pezkuwi/types';
+import { U8aFixed } from '@pezkuwi/types-codec';
+
+describe('U8aFixed', (): void => {
+  const registry = new TypeRegistry();
+
+  describe('construction', (): void => {
+    it('allows empty values', (): void => {
+      expect(
+        new U8aFixed(registry).toHex()
+      ).toEqual('0x0000000000000000000000000000000000000000000000000000000000000000');
+    });
+
+    it('allows construction via with', (): void => {
+      expect(
+        new (U8aFixed.with(64))(registry).bitLength()
+      ).toEqual(64);
+    });
+
+    it('constructs from hex', (): void => {
+      expect(
+        new (U8aFixed.with(32))(registry, '0x01020304').toU8a()
+      ).toEqual(
+        new Uint8Array([0x01, 0x02, 0x03, 0x04])
+      );
+    });
+
+    it('constructs from number[]', (): void => {
+      expect(
+        new (U8aFixed.with(32))(registry, [0x02, 0x03, 0x00, 0x00]).toU8a()
+      ).toEqual(
+        new Uint8Array([0x02, 0x03, 0x00, 0x00])
+      );
+    });
+
+    it('constructs when passed Uint8Array is >= length', (): void => {
+      expect(
+        new (U8aFixed.with(32))(registry, new Uint8Array([0x00, 0x01, 0x02, 0x03])).toU8a()
+      ).toEqual(
+        new Uint8Array([0x00, 0x01, 0x02, 0x03])
+      );
+      expect(
+        new (U8aFixed.with(32))(registry, new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x04, 0x05])).toU8a()
+      ).toEqual(
+        new Uint8Array([0x00, 0x01, 0x02, 0x03])
+      );
+    });
+
+    it('constructs when passed string is === length', (): void => {
+      expect(
+        new (U8aFixed.with(32))(registry, '1234').toU8a()
+      ).toEqual(
+        new Uint8Array([49, 50, 51, 52])
+      );
+    });
+
+    it('fails construction when passed string is > length', (): void => {
+      expect(
+        () => new (U8aFixed.with(32))(registry, '0x000102030405').toU8a()
+      ).toThrow(/Expected input with 4 bytes/);
+      expect(
+        () => new (U8aFixed.with(256))(registry, '1363HWTPzDrzAQ6ChFiMU6mP4b6jmQid2ae55JQcKtZnpLGv')
+      ).toThrow(/Expected input with 32 bytes/);
+    });
+  });
+
+  describe('utils', (): void => {
+    let u8a: U8aFixed;
+
+    beforeEach((): void => {
+      u8a = new U8aFixed(registry, [1, 2, 3, 4], 32);
+    });
+
+    it('limits the length', (): void => {
+      expect(u8a.length).toEqual(4);
+    });
+
+    it('exposes the correct bitLength', (): void => {
+      expect(u8a.bitLength()).toEqual(32);
+    });
+
+    it('allows wrapping of a pre-existing instance', (): void => {
+      expect(
+        u8a.toU8a()
+      ).toEqual(new Uint8Array([1, 2, 3, 4]));
+    });
+
+    it('has a sane toRawType', (): void => {
+      expect(u8a.toRawType()).toEqual('[u8;4]');
+    });
+
+    it('has a sane inspect', (): void => {
+      expect(u8a.inspect()).toEqual({
+        outer: [new Uint8Array([1, 2, 3, 4])]
+      });
+    });
+  });
+
+  describe('static with', (): void => {
+    it('allows default toRawType', (): void => {
+      expect(
+        new (U8aFixed.with(64))(registry).toRawType()
+      ).toEqual('[u8;8]');
+    });
+
+    it('allows toRawType override', (): void => {
+      expect(
+        new (U8aFixed.with(64, 'SomethingElse'))(registry).toRawType()
+      ).toEqual('SomethingElse');
+    });
+  });
+});

package/src/extended/U8aFixed.ts

@@ -0,0 +1,57 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyU8a, CodecClass, Registry, U8aBitLength } from '../types/index.js';
+
+import { isU8a, u8aToU8a } from '@pezkuwi/util';
+
+import { Raw } from '../native/Raw.js';
+
+/** @internal */
+function decodeU8aFixed (value: AnyU8a, bitLength: U8aBitLength): [AnyU8a, number] {
+  const u8a = u8aToU8a(value);
+  const byteLength = bitLength / 8;
+
+  if (!u8a.length) {
+    return [new Uint8Array(byteLength), 0];
+  }
+
+  if (isU8a(value) ? u8a.length < byteLength : u8a.length !== byteLength) {
+    throw new Error(`Expected input with ${byteLength} bytes (${bitLength} bits), found ${u8a.length} bytes`);
+  }
+
+  return [u8a.subarray(0, byteLength), byteLength];
+}
+
+/**
+ * @name U8aFixed
+ * @description
+ * A U8a that manages a a sequence of bytes up to the specified bitLength. Not meant
+ * to be used directly, rather is should be subclassed with the specific lengths.
+ */
+export class U8aFixed extends Raw {
+  constructor (registry: Registry, value: AnyU8a = new Uint8Array(), bitLength: U8aBitLength = 256) {
+    const [u8a, decodedLength] = decodeU8aFixed(value, bitLength);
+
+    super(registry, u8a, decodedLength);
+  }
+
+  public static with (bitLength: U8aBitLength, typeName?: string): CodecClass<U8aFixed> {
+    return class extends U8aFixed {
+      constructor (registry: Registry, value?: AnyU8a) {
+        super(registry, value, bitLength);
+      }
+
+      public override toRawType (): string {
+        return typeName || super.toRawType();
+      }
+    };
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    return `[u8;${this.length}]`;
+  }
+}

package/src/extended/WrapperKeepOpaque.spec.ts

@@ -0,0 +1,101 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '@pezkuwi/types';
+import { Bytes, Raw, u32, WrapperKeepOpaque } from '@pezkuwi/types-codec';
+
+describe('WrapperKeepOpaque', (): void => {
+  const registry = new TypeRegistry();
+  const u8au32 = new Uint8Array([4 << 2, 135, 214, 18, 0]);
+  const ClazzUSize = WrapperKeepOpaque.with('usize');
+  const ClazzU32 = WrapperKeepOpaque.with(u32);
+
+  it('has handles non-decodable values', (): void => {
+    const usize = new ClazzUSize(registry, u8au32);
+
+    expect(usize.isDecoded).toEqual(false);
+    expect(() => usize.unwrap()).toThrow(/undecodable value/);
+
+    expect(usize.toHex()).toEqual('0x87d61200');
+    expect(usize.toHuman()).toEqual('0x87d61200');
+    expect(usize.toJSON()).toEqual('0x87d61200');
+    expect(usize.toRawType()).toEqual('WrapperKeepOpaque<usize>');
+    expect(usize.toString()).toEqual('0x87d61200');
+    expect(usize.toU8a()).toEqual(u8au32);
+  });
+
+  it('has handles decodable values', (): void => {
+    const u32 = new ClazzU32(registry, u8au32);
+
+    expect(u32.isDecoded).toEqual(true);
+    expect(u32.unwrap().toNumber()).toEqual(1234567);
+
+    expect(u32.toHex()).toEqual('0x87d61200');
+    expect(u32.toHuman()).toEqual('1,234,567');
+    expect(u32.toJSON()).toEqual('0x87d61200');
+    expect(u32.toRawType()).toEqual('WrapperKeepOpaque<u32>');
+    expect(u32.toString()).toEqual('1234567');
+    expect(u32.toU8a()).toEqual(u8au32);
+  });
+
+  it('handles values from Raw', (): void => {
+    const u32 = new ClazzU32(registry, new Raw(registry, u8au32.slice(1)));
+
+    expect(u32.unwrap().toNumber()).toEqual(1234567);
+  });
+
+  it('handles values from Bytes', (): void => {
+    const u32 = new ClazzU32(registry, new Bytes(registry, u8au32));
+
+    expect(u32.unwrap().toNumber()).toEqual(1234567);
+  });
+
+  it('has a sane inspect (non-decodable)', (): void => {
+    expect(
+      new ClazzUSize(registry, u8au32).inspect()
+    ).toEqual({
+      outer: [new Uint8Array([4 << 2]), new Uint8Array([0x87, 0xd6, 0x12, 0x00])]
+    });
+  });
+
+  it('has a sane inspect (decodable)', (): void => {
+    expect(
+      new ClazzU32(registry, u8au32).inspect()
+    ).toEqual({
+      inner: [{ outer: [new Uint8Array([0x87, 0xd6, 0x12, 0x00])] }],
+      outer: [new Uint8Array([4 << 2])]
+    });
+  });
+
+  it('has a sane in-wrapper representation', (): void => {
+    const set = registry.createType(
+      'BTreeSet<OpaquePeerId>',
+      // prefix
+      '0x' +
+      // 4 items, 16 >> 2
+      '10' +
+      // opaque length
+      '9c' +
+      // bytes length
+      '98' + '0024080112201ce5f00ef6e89374afb625f1ae4c1546d31234e87e3c3f51a62b91dd6bfa57df' +
+      // repeat the same for the next 3...
+      '9c98002408011220876a7b4984f98006dc8d666e28b60de307309835d775e7755cc770328cdacf2e9c98002408011220c81bc1d7057a1511eb9496f056f6f53cdfe0e14c8bd5ffca47c70a8d76c1326d9c98002408011220dacde7714d8551f674b8bb4b54239383c76a2b286fa436e93b2b7eb226bf4de7'
+    );
+    const val = [...set.values()];
+
+    expect(val.map((v) => v.toHex())).toEqual([
+      '0x980024080112201ce5f00ef6e89374afb625f1ae4c1546d31234e87e3c3f51a62b91dd6bfa57df',
+      '0x98002408011220876a7b4984f98006dc8d666e28b60de307309835d775e7755cc770328cdacf2e',
+      '0x98002408011220c81bc1d7057a1511eb9496f056f6f53cdfe0e14c8bd5ffca47c70a8d76c1326d',
+      '0x98002408011220dacde7714d8551f674b8bb4b54239383c76a2b286fa436e93b2b7eb226bf4de7'
+    ]);
+    expect(val.map((v) => v.toHuman())).toEqual([
+      '0x0024080112201ce5f00ef6e89374afb625f1ae4c1546d31234e87e3c3f51a62b91dd6bfa57df',
+      '0x002408011220876a7b4984f98006dc8d666e28b60de307309835d775e7755cc770328cdacf2e',
+      '0x002408011220c81bc1d7057a1511eb9496f056f6f53cdfe0e14c8bd5ffca47c70a8d76c1326d',
+      '0x002408011220dacde7714d8551f674b8bb4b54239383c76a2b286fa436e93b2b7eb226bf4de7'
+    ]);
+  });
+});

package/src/extended/WrapperKeepOpaque.ts

@@ -0,0 +1,128 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyJson, AnyU8a, Codec, CodecClass, Inspect, Registry } from '../types/index.js';
+
+import { compactAddLength, compactStripLength, compactToU8a, isHex, isU8a, u8aToU8a } from '@pezkuwi/util';
+
+import { Raw } from '../native/Raw.js';
+import { typeToConstructor } from '../utils/index.js';
+import { Bytes } from './Bytes.js';
+
+type OpaqueName = 'WrapperKeepOpaque' | 'WrapperOpaque';
+
+interface Options {
+  opaqueName?: OpaqueName;
+}
+
+function decodeRaw<T extends Codec> (registry: Registry, typeName: CodecClass<T> | string, value?: unknown): [CodecClass<T>, T | null, AnyU8a] {
+  const Type = typeToConstructor(registry, typeName);
+
+  if (isU8a(value) || isHex(value)) {
+    try {
+      const [, u8a] = isHex(value)
+        ? [0, u8aToU8a(value)]
+        : (value instanceof Raw)
+          ? [0, value.subarray()]
+          : compactStripLength(value);
+
+      return [Type, new Type(registry, u8a), value];
+    } catch {
+      return [Type, null, value];
+    }
+  }
+
+  const instance = new Type(registry, value);
+
+  return [Type, instance, compactAddLength(instance.toU8a())];
+}
+
+export class WrapperKeepOpaque<T extends Codec> extends Bytes {
+  readonly #Type: CodecClass<T>;
+  readonly #decoded: T | null;
+  readonly #opaqueName: OpaqueName;
+
+  constructor (registry: Registry, typeName: CodecClass<T> | string, value?: unknown, { opaqueName = 'WrapperKeepOpaque' }: Options = {}) {
+    const [Type, decoded, u8a] = decodeRaw(registry, typeName, value);
+
+    super(registry, u8a);
+
+    this.#Type = Type;
+    this.#decoded = decoded;
+    this.#opaqueName = opaqueName;
+  }
+
+  public static with<T extends Codec> (Type: CodecClass<T> | string): CodecClass<WrapperKeepOpaque<T>> {
+    return class extends WrapperKeepOpaque<T> {
+      constructor (registry: Registry, value?: AnyU8a | T) {
+        super(registry, Type, value);
+      }
+    };
+  }
+
+  /**
+   * @description Checks if the wrapper is decodable
+   */
+  public get isDecoded (): boolean {
+    return !!this.#decoded;
+  }
+
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+  public override inspect (): Inspect {
+    return this.#decoded
+      ? {
+        inner: [this.#decoded.inspect()],
+        outer: [compactToU8a(this.length)]
+      }
+      : {
+        outer: [compactToU8a(this.length), this.toU8a(true)]
+      };
+  }
+
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  public override toHuman (isExtended?: boolean, disableAscii?: boolean): AnyJson {
+    return this.#decoded
+      ? this.#decoded.toHuman(isExtended, disableAscii)
+      : super.toHuman(isExtended, disableAscii);
+  }
+
+  /**
+   * @description Converts the value in a best-fit primitive form
+   */
+  public override toPrimitive (disableAscii?: boolean): any {
+    return this.#decoded
+      ? this.#decoded.toPrimitive(disableAscii)
+      : super.toPrimitive(disableAscii);
+  }
+
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  public override toRawType (): string {
+    return `${this.#opaqueName}<${this.registry.getClassName(this.#Type) || (this.#decoded ? this.#decoded.toRawType() : new this.#Type(this.registry).toRawType())}>`;
+  }
+
+  /**
+   * @description Converts the Object to to a string (either decoded or bytes)
+   */
+  public override toString (): string {
+    return this.#decoded
+      ? this.#decoded.toString()
+      : super.toString();
+  }
+
+  /**
+   * @description Returns the decoded that the WrapperKeepOpaque represents (if available), throws if non-decodable
+   */
+  public unwrap (): T {
+    if (!this.#decoded) {
+      throw new Error(`${this.#opaqueName}: unwrapping an undecodable value`);
+    }
+
+    return this.#decoded;
+  }
+}

package/src/extended/WrapperOpaque.spec.ts

@@ -0,0 +1,58 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '@pezkuwi/types';
+import { WrapperOpaque } from '@pezkuwi/types-codec';
+import { u8aConcat } from '@pezkuwi/util';
+
+describe('WrapperOpaque', (): void => {
+  const registry = new TypeRegistry();
+  const u8au32 = new Uint8Array([4 << 2, 135, 214, 18, 0]);
+
+  it('u8a encodes a wrapped u32 correctly', (): void => {
+    expect(
+      new WrapperOpaque(registry, 'u32', 1234567).toU8a()
+    ).toEqual(u8au32);
+  });
+
+  it('u8a decodes a wrapped u32 correctly', (): void => {
+    expect(
+      new WrapperOpaque(registry, 'u32', u8au32).toU8a()
+    ).toEqual(u8au32);
+  });
+
+  it('u8a encodes a wrapped option correctly', (): void => {
+    expect(
+      new WrapperOpaque(registry, 'Option<u32>', 1234567).toU8a()
+    ).toEqual(u8aConcat([5 << 2, 1], u8au32.slice(1)));
+  });
+
+  it('hex encodes a wrapped u32 correctly', (): void => {
+    expect(
+      new WrapperOpaque(registry, 'u32', '0x12345678').toHex()
+    ).toEqual('0x12345678');
+  });
+
+  it('has the correct unwrap', (): void => {
+    expect(
+      new WrapperOpaque(registry, 'u32', '0x12345678').unwrap().toHex()
+    ).toEqual('0x78563412');
+  });
+
+  it('has the correct toRawType', (): void => {
+    expect(
+      new WrapperOpaque(registry, 'u32').toRawType()
+    ).toEqual('WrapperOpaque<u32>');
+  });
+
+  it('has a sane inspect', (): void => {
+    expect(
+      new WrapperOpaque(registry, 'u32', '0x78563412').inspect()
+    ).toEqual({
+      inner: [{ outer: [new Uint8Array([0x78, 0x56, 0x34, 0x12])] }],
+      outer: [new Uint8Array([4 << 2])]
+    });
+  });
+});