@pezkuwi/types-codec 16.5.5 → 16.5.6

package/src/extended/Range.ts

@@ -1,56 +0,0 @@
-// Copyright 2017-2025 @polkadot/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

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @polkadot/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

@@ -1,118 +0,0 @@
-// Copyright 2017-2025 @polkadot/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

@@ -1,29 +0,0 @@
-// Copyright 2017-2025 @polkadot/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

@@ -1,117 +0,0 @@
-// Copyright 2017-2025 @polkadot/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

@@ -1,57 +0,0 @@
-// Copyright 2017-2025 @polkadot/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

@@ -1,101 +0,0 @@
-// Copyright 2017-2025 @polkadot/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

@@ -1,128 +0,0 @@
-// Copyright 2017-2025 @polkadot/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

@@ -1,58 +0,0 @@
-// Copyright 2017-2025 @polkadot/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])]
-    });
-  });
-});