@polkadot/types-codec 6.12.2-2

package/primitive/index.d.ts

@@ -0,0 +1,13 @@
+export { i8, i8 as I8 } from './I8';
+export { i16, i16 as I16 } from './I16';
+export { i32, i32 as I32 } from './I32';
+export { i64, i64 as I64 } from './I64';
+export { i128, i128 as I128 } from './I128';
+export { i256, i256 as I256 } from './I256';
+export { u8, u8 as U8 } from './U8';
+export { u16, u16 as U16 } from './U16';
+export { u32, u32 as U32 } from './U32';
+export { u64, u64 as U64 } from './U64';
+export { u128, u128 as U128 } from './U128';
+export { u256, u256 as U256 } from './U256';
+export { usize, usize as USize } from './USize';

package/primitive/index.js

@@ -0,0 +1,15 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export { i8, i8 as I8 } from "./I8.js";
+export { i16, i16 as I16 } from "./I16.js";
+export { i32, i32 as I32 } from "./I32.js";
+export { i64, i64 as I64 } from "./I64.js";
+export { i128, i128 as I128 } from "./I128.js";
+export { i256, i256 as I256 } from "./I256.js";
+export { u8, u8 as U8 } from "./U8.js";
+export { u16, u16 as U16 } from "./U16.js";
+export { u32, u32 as U32 } from "./U32.js";
+export { u64, u64 as U64 } from "./U64.js";
+export { u128, u128 as U128 } from "./U128.js";
+export { u256, u256 as U256 } from "./U256.js";
+export { usize, usize as USize } from "./USize.js";

package/types/codec.cjs

@@ -0,0 +1 @@
+"use strict";

package/types/codec.d.ts

@@ -0,0 +1,77 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson } from './helpers';
+import type { IU8a } from './interfaces';
+import type { CodecRegistry } from './registry';
+export declare type BareOpts = boolean | Record<string, boolean>;
+/**
+ * @name Codec
+ * @description
+ * The base Codec interface. All types implement the interface provided here. Additionally
+ * implementors can add their own specific interfaces and helpers with getters and functions.
+ * The Codec Base is however required for operating as an encoding/decoding layer
+ */
+export interface Codec {
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    readonly encodedLength: number;
+    /**
+     * @description Returns a hash of the value
+     */
+    readonly hash: IU8a;
+    /**
+     * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
+     */
+    readonly initialU8aLength?: number;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    readonly isEmpty: boolean;
+    /**
+     * @description The registry associated with this object
+     */
+    readonly registry: CodecRegistry;
+    /**
+     * @description The block at which this value was retrieved/created (set to non-empty when retrieved from storage)
+     */
+    createdAtHash?: IU8a;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    toHex(isLe?: boolean): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended?: boolean): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): AnyJson;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @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)
+     */
+    toU8a(isBare?: BareOpts): Uint8Array;
+}
+export interface CodecClass<T = Codec> {
+    /**
+     * @description An internal fallback type (previous generation) if encoding fails
+     */
+    readonly __fallbackType?: string;
+    new (registry: CodecRegistry, ...args: any[]): T;
+}
+export declare type CodecClassDef<T = Codec> = Record<string, CodecClass<T>>;
+export declare type CodecTo = 'toHex' | 'toJSON' | 'toString' | 'toU8a';
+export declare type ArgsDef = Record<string, CodecClass | string>;

package/types/codec.js

@@ -0,0 +1 @@
+export {};

package/types/helpers.cjs

@@ -0,0 +1 @@
+"use strict";

package/types/helpers.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="bn.js" />
+import type { BN } from '@polkadot/util';
+import type { Codec } from './codec';
+export declare type AnyJson = string | number | boolean | null | undefined | AnyJson[] | {
+    [index: string]: AnyJson;
+};
+export declare type AnyFunction = (...args: any[]) => any;
+export declare type AnyNumber = BN | bigint | Uint8Array | number | string;
+export declare type AnyString = string | string;
+export declare type AnyTuple = Codec[];
+export declare type AnyU8a = Uint8Array | number[] | string;
+export declare type UIntBitLength = 8 | 16 | 32 | 64 | 128 | 256;
+export declare type U8aBitLength = 8 | 16 | 32 | 64 | 128 | 160 | 256 | 264 | 512 | 520 | 1024 | 2048;
+export declare type AnyTupleValue = AnyU8a | (Codec | AnyU8a | AnyNumber | AnyString | undefined | null)[];

package/types/helpers.js

@@ -0,0 +1 @@
+export {};

package/types/index.cjs

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _codec = require("./codec.cjs");
+
+Object.keys(_codec).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _codec[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _codec[key];
+    }
+  });
+});
+
+var _helpers = require("./helpers.cjs");
+
+Object.keys(_helpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _helpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _helpers[key];
+    }
+  });
+});
+
+var _interfaces = require("./interfaces.cjs");
+
+Object.keys(_interfaces).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _interfaces[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _interfaces[key];
+    }
+  });
+});
+
+var _registry = require("./registry.cjs");
+
+Object.keys(_registry).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _registry[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _registry[key];
+    }
+  });
+});

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './codec';
+export * from './helpers';
+export * from './interfaces';
+export * from './registry';

package/types/index.js

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export * from "./codec.js";
+export * from "./helpers.js";
+export * from "./interfaces.js";
+export * from "./registry.js";

package/types/interfaces.cjs

@@ -0,0 +1 @@
+"use strict";

package/types/interfaces.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="bn.js" />
+import type { BN } from '@polkadot/util';
+import type { ArgsDef, Codec } from './codec';
+import type { AnyTuple } from './helpers';
+export interface ICompact<T extends INumber = INumber> extends Codec {
+    toBigInt(): bigint;
+    toBn(): BN;
+    toNumber(): number;
+    unwrap(): T;
+}
+export interface IEnum extends Codec {
+    readonly defIndexes: number[];
+    readonly defKeys: string[];
+    readonly index: number;
+    readonly isBasic: boolean;
+    readonly type: string;
+    readonly value: Codec;
+    toNumber(): number;
+}
+export interface IMap<K extends Codec = Codec, V extends Codec = Codec> extends Map<K, V>, Codec {
+}
+export interface INumber extends Codec {
+    bitLength(): number;
+    toBigInt(): bigint;
+    toBn(): BN;
+    toNumber(): number;
+}
+export interface IOption<T extends Codec = Codec> extends Codec {
+    readonly isNone: boolean;
+    readonly isSome: boolean;
+    readonly value: Codec;
+    unwrap(): T;
+    unwrapOr<O>(other: O): T | O;
+    unwrapOrDefault(): T;
+}
+export interface IResult<O extends Codec = Codec, E extends Codec = Codec> extends IEnum {
+    readonly asErr: E;
+    readonly asOk: O;
+    readonly isErr: boolean;
+    readonly isOk: boolean;
+}
+export interface ISet<K = string> extends Set<K>, Codec {
+    readonly strings: string[];
+}
+export interface IStruct<K = string, V extends Codec = Codec> extends Map<K, V>, Codec {
+    readonly defKeys: string[];
+    getAtIndex(index: number): Codec;
+    toArray(): Codec[];
+}
+export declare type ITuple<T extends AnyTuple = Codec[]> = T & Codec;
+export interface IU8a extends Uint8Array, Codec {
+    readonly isAscii: boolean;
+    readonly isUtf8: boolean;
+    bitLength(): number;
+    toHuman(isExtended?: boolean): any;
+    toJSON(): any;
+    toUtf8(): string;
+}
+export interface IVec<T extends Codec = Codec> extends Array<T>, Codec {
+    toArray(): T[];
+}
+export interface IMethod<A extends AnyTuple = AnyTuple> extends Codec {
+    readonly args: A;
+    readonly argsDef: ArgsDef;
+    readonly callIndex: Uint8Array;
+    readonly data: Uint8Array;
+    is: (tx: IMethod<AnyTuple>) => tx is IMethod<A>;
+}

package/types/interfaces.js

@@ -0,0 +1 @@
+export {};

package/types/registry.cjs

@@ -0,0 +1 @@
+"use strict";

package/types/registry.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="bn.js" />
+import type { BN } from '@polkadot/util';
+import type { Codec, CodecClass } from './codec';
+import type { ICompact, IEnum, IMap, IMethod, INumber, IOption, IResult, ISet, IStruct, ITuple, IU8a, IVec } from './interfaces';
+export declare 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 declare type RegistryTypes = Record<string, CodecClass | string | Record<string, string> | {
+    _enum: string[] | Record<string, number> | Record<string, string | null>;
+} | {
+    _set: Record<string, number>;
+}>;
+export interface CodecCreateOptions {
+    blockHash?: Uint8Array | string | null;
+    isOptional?: boolean;
+    isPedantic?: boolean;
+}
+export interface CodecRegistry {
+    readonly chainDecimals: number[];
+    readonly chainSS58: number | undefined;
+    readonly chainTokens: string[];
+    createdAtHash?: IU8a;
+    findMetaCall(callIndex: Uint8Array): unknown;
+    findMetaError(errorIndex: Uint8Array | {
+        error: BN;
+        index: BN;
+    }): unknown;
+    findMetaEvent(eventIndex: Uint8Array): CodecClass<any>;
+    isLookupType(value: string): boolean;
+    createLookupType(lookupId: ICompact<INumber> | number): string;
+    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;
+    getOrThrow<T extends Codec = Codec, K extends string = string>(name: K, msg?: string): CodecClass<T>;
+    getOrUnknown<T extends Codec = Codec, K extends string = string>(name: K): CodecClass<T>;
+    getSignedExtensionExtra(): Record<string, string>;
+    getSignedExtensionTypes(): Record<string, string>;
+    hasClass(name: string): boolean;
+    hasDef(name: string): boolean;
+    hasType(name: string): boolean;
+    hash(data: Uint8Array): IU8a;
+    register(type: CodecClass | RegistryTypes): void;
+    register(name: string, type: CodecClass): void;
+    register(arg1: string | CodecClass | RegistryTypes, arg2?: CodecClass): void;
+    setMetadata(metadata: unknown, signedExtensions?: string[], userExtensions?: unknown): void;
+}

package/types/registry.js

@@ -0,0 +1 @@
+export {};

package/utils/compareArray.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareArray = compareArray;
+
+var _util = require("@polkadot/util");
+
+var _util2 = require("./util.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// NOTE These are used internally and when comparing objects, expects that
+// when the second is an Codec[] that the first has to be as well
+function compareArray(a, b) {
+  if (Array.isArray(b)) {
+    return a.length === b.length && (0, _util.isUndefined)(a.find((v, index) => (0, _util2.hasEq)(v) ? !v.eq(b[index]) : v !== b[index]));
+  }
+
+  return false;
+}

package/utils/compareArray.d.ts

@@ -0,0 +1 @@
+export declare function compareArray(a: unknown[], b?: unknown): boolean;

package/utils/compareArray.js

@@ -0,0 +1,13 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { isUndefined } from '@polkadot/util';
+import { hasEq } from "./util.js"; // NOTE These are used internally and when comparing objects, expects that
+// when the second is an Codec[] that the first has to be as well
+
+export function compareArray(a, b) {
+  if (Array.isArray(b)) {
+    return a.length === b.length && isUndefined(a.find((v, index) => hasEq(v) ? !v.eq(b[index]) : v !== b[index]));
+  }
+
+  return false;
+}

package/utils/compareMap.cjs

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareMap = compareMap;
+
+var _util = require("@polkadot/util");
+
+var _util2 = require("./util.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function hasMismatch(a, b) {
+  return (0, _util.isUndefined)(a) || ((0, _util2.hasEq)(a) ? !a.eq(b) : a !== b);
+}
+
+function notEntry(value) {
+  return !Array.isArray(value) || value.length !== 2;
+}
+
+function compareMapArray(a, b) {
+  // equal number of entries and each entry in the array should match
+  return a.size === b.length && !b.some(e => notEntry(e) || hasMismatch(a.get(e[0]), e[1]));
+} // NOTE These are used internally and when comparing objects, expects that
+// when the second is an Map<string, Codec> that the first has to be as well
+
+
+function compareMap(a, b) {
+  if (Array.isArray(b)) {
+    return compareMapArray(a, b);
+  } else if (b instanceof Map) {
+    return compareMapArray(a, [...b.entries()]);
+  } else if ((0, _util.isObject)(b)) {
+    return compareMapArray(a, Object.entries(b));
+  }
+
+  return false;
+}

package/utils/compareMap.d.ts

@@ -0,0 +1 @@
+export declare function compareMap(a: Map<unknown, unknown>, b?: unknown): boolean;

package/utils/compareMap.js

@@ -0,0 +1,31 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { isObject, isUndefined } from '@polkadot/util';
+import { hasEq } from "./util.js";
+
+function hasMismatch(a, b) {
+  return isUndefined(a) || (hasEq(a) ? !a.eq(b) : a !== b);
+}
+
+function notEntry(value) {
+  return !Array.isArray(value) || value.length !== 2;
+}
+
+function compareMapArray(a, b) {
+  // equal number of entries and each entry in the array should match
+  return a.size === b.length && !b.some(e => notEntry(e) || hasMismatch(a.get(e[0]), e[1]));
+} // NOTE These are used internally and when comparing objects, expects that
+// when the second is an Map<string, Codec> that the first has to be as well
+
+
+export function compareMap(a, b) {
+  if (Array.isArray(b)) {
+    return compareMapArray(a, b);
+  } else if (b instanceof Map) {
+    return compareMapArray(a, [...b.entries()]);
+  } else if (isObject(b)) {
+    return compareMapArray(a, Object.entries(b));
+  }
+
+  return false;
+}

package/utils/compareSet.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareSet = compareSet;
+
+var _util = require("@polkadot/util");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function compareSetArray(a, b) {
+  // equal number of entries and each entry in the array should match
+  return a.size === b.length && !b.some(e => !a.has(e));
+} // NOTE These are used internally and when comparing objects, expects that
+// when the second is an Set<string, Codec> that the first has to be as well
+
+
+function compareSet(a, b) {
+  if (Array.isArray(b)) {
+    return compareSetArray(a, b);
+  } else if (b instanceof Set) {
+    return compareSetArray(a, [...b.values()]);
+  } else if ((0, _util.isObject)(b)) {
+    return compareSetArray(a, Object.values(b));
+  }
+
+  return false;
+}

package/utils/compareSet.d.ts

@@ -0,0 +1 @@
+export declare function compareSet(a: Set<unknown>, b?: unknown): boolean;

package/utils/compareSet.js

@@ -0,0 +1,22 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { isObject } from '@polkadot/util';
+
+function compareSetArray(a, b) {
+  // equal number of entries and each entry in the array should match
+  return a.size === b.length && !b.some(e => !a.has(e));
+} // NOTE These are used internally and when comparing objects, expects that
+// when the second is an Set<string, Codec> that the first has to be as well
+
+
+export function compareSet(a, b) {
+  if (Array.isArray(b)) {
+    return compareSetArray(a, b);
+  } else if (b instanceof Set) {
+    return compareSetArray(a, [...b.values()]);
+  } else if (isObject(b)) {
+    return compareSetArray(a, Object.values(b));
+  }
+
+  return false;
+}

package/utils/decodeU8a.cjs

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decodeU8a = decodeU8a;
+exports.decodeU8aVec = decodeU8aVec;
+
+var _util = require("@polkadot/util");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function formatFailure(error, type, u8a, key) {
+  return `decodeU8a: failed at ${(0, _util.u8aToHex)(u8a)}…${key ? ` on ${key}` : ''}${type ? `: ${type}` : ''}:: ${error.message}`;
+}
+
+function getRawType(registry, Type) {
+  try {
+    return new Type(registry).toRawType();
+  } catch {
+    return null;
+  }
+}
+/**
+ * Given an u8a, and an array of Type constructors, decode the u8a against the
+ * types, and return an array of decoded values.
+ *
+ * @param u8a - The u8a to decode.
+ * @param result - The result array (will be returned with values pushed)
+ * @param types - The array of CodecClass to decode the U8a against.
+ */
+
+
+function decodeU8a(registry, u8a, types, withZip) {
+  const [Types, keys] = Array.isArray(types) ? [types, []] : [Object.values(types), Object.keys(types)];
+  const result = new Array(Types.length);
+  let offset = 0;
+
+  for (let i = 0; i < Types.length; i++) {
+    try {
+      const value = new Types[i](registry, u8a.subarray(offset));
+      offset += value.initialU8aLength || value.encodedLength;
+      result[i] = withZip ? [keys[i], value] : value;
+    } catch (error) {
+      throw new Error(formatFailure(error, getRawType(registry, Types[i]), u8a.subarray(offset, offset + 16), keys[i]));
+    }
+  }
+
+  return [result, offset];
+} // Split from decodeU8a since this is specialized to 1 instance ... yes duplication, but
+// since we have to do less checks (and these are intensive anyway), much faster
+
+
+function decodeU8aVec(registry, u8a, start, Type, count) {
+  const result = new Array(count);
+  let offset = start;
+
+  for (let i = 0; i < count; i++) {
+    try {
+      const value = new Type(registry, u8a.subarray(offset));
+      offset += value.initialU8aLength || value.encodedLength;
+      result[i] = value;
+    } catch (error) {
+      throw new Error(formatFailure(error, getRawType(registry, Type), u8a.subarray(offset, offset + 16)));
+    }
+  }
+
+  return [result, offset, offset - start];
+}

package/utils/decodeU8a.d.ts

@@ -0,0 +1,13 @@
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+/**
+ * Given an u8a, and an array of Type constructors, decode the u8a against the
+ * types, and return an array of decoded values.
+ *
+ * @param u8a - The u8a to decode.
+ * @param result - The result array (will be returned with values pushed)
+ * @param types - The array of CodecClass to decode the U8a against.
+ */
+export declare function decodeU8a<T extends Codec = Codec, E = T>(registry: CodecRegistry, u8a: Uint8Array, types: CodecClass[] | {
+    [index: string]: CodecClass;
+}, withZip?: boolean): [E[], number];
+export declare function decodeU8aVec<T extends Codec = Codec>(registry: CodecRegistry, u8a: Uint8Array, start: number, Type: CodecClass<T>, count: number): [T[], number, number];

package/utils/decodeU8a.js

@@ -0,0 +1,60 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { u8aToHex } from '@polkadot/util';
+
+function formatFailure(error, type, u8a, key) {
+  return `decodeU8a: failed at ${u8aToHex(u8a)}…${key ? ` on ${key}` : ''}${type ? `: ${type}` : ''}:: ${error.message}`;
+}
+
+function getRawType(registry, Type) {
+  try {
+    return new Type(registry).toRawType();
+  } catch {
+    return null;
+  }
+}
+/**
+ * Given an u8a, and an array of Type constructors, decode the u8a against the
+ * types, and return an array of decoded values.
+ *
+ * @param u8a - The u8a to decode.
+ * @param result - The result array (will be returned with values pushed)
+ * @param types - The array of CodecClass to decode the U8a against.
+ */
+
+
+export function decodeU8a(registry, u8a, types, withZip) {
+  const [Types, keys] = Array.isArray(types) ? [types, []] : [Object.values(types), Object.keys(types)];
+  const result = new Array(Types.length);
+  let offset = 0;
+
+  for (let i = 0; i < Types.length; i++) {
+    try {
+      const value = new Types[i](registry, u8a.subarray(offset));
+      offset += value.initialU8aLength || value.encodedLength;
+      result[i] = withZip ? [keys[i], value] : value;
+    } catch (error) {
+      throw new Error(formatFailure(error, getRawType(registry, Types[i]), u8a.subarray(offset, offset + 16), keys[i]));
+    }
+  }
+
+  return [result, offset];
+} // Split from decodeU8a since this is specialized to 1 instance ... yes duplication, but
+// since we have to do less checks (and these are intensive anyway), much faster
+
+export function decodeU8aVec(registry, u8a, start, Type, count) {
+  const result = new Array(count);
+  let offset = start;
+
+  for (let i = 0; i < count; i++) {
+    try {
+      const value = new Type(registry, u8a.subarray(offset));
+      offset += value.initialU8aLength || value.encodedLength;
+      result[i] = value;
+    } catch (error) {
+      throw new Error(formatFailure(error, getRawType(registry, Type), u8a.subarray(offset, offset + 16)));
+    }
+  }
+
+  return [result, offset, offset - start];
+}