@pezkuwi/types 16.5.5

package/src/metadata/v13/toV14.ts

@@ -0,0 +1,352 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Text, Type } from '@pezkuwi/types-codec';
+import type { ErrorMetadataV13, EventMetadataV13, ExtrinsicMetadataV13, ExtrinsicMetadataV14, FunctionMetadataV13, MetadataV13, MetadataV14, ModuleConstantMetadataV13, ModuleMetadataV13, PalletCallMetadataV14, PalletConstantMetadataV14, PalletErrorMetadataV14, PalletEventMetadataV14, PalletMetadataV14, PalletStorageMetadataV14, StorageEntryMetadataV14, StorageEntryTypeV14, StorageHasherV13, StorageMetadataV13 } from '../../interfaces/metadata/index.js';
+import type { SiVariant } from '../../interfaces/scaleInfo/index.js';
+import type { OverrideModuleType, Registry } from '../../types/index.js';
+
+import { stringCamelCase } from '@pezkuwi/util';
+
+import { getAliasTypes } from '../../interfaces/alias.js';
+import { knownOrigins } from '../../interfaces/runtime/definitions.js';
+
+interface MapDef {
+  hashers: StorageHasherV13[];
+  isLinked: boolean;
+  isOptional: boolean;
+  keys: Type[];
+  value: Type;
+}
+
+export interface TypeSpec {
+  def: {
+    HistoricMetaCompat?: string;
+    Tuple?: number[];
+    Variant?: {
+      variants: SiVariant[];
+    }
+  },
+  path?: string[];
+}
+
+const BOXES = [['<', '>'], ['<', ','], [',', '>'], ['(', ')'], ['(', ','], [',', ','], [',', ')']];
+
+/**
+ * Creates a compatible type mapping
+ * @internal
+ **/
+function compatType (specs: TypeSpec[], _type: Text | string): number {
+  const type = _type.toString();
+  const index = specs.findIndex(({ def }) =>
+    def.HistoricMetaCompat === type
+  );
+
+  if (index !== -1) {
+    return index;
+  }
+
+  return specs.push({
+    def: {
+      HistoricMetaCompat: type
+    }
+  }) - 1;
+}
+
+function compatTypes (specs: TypeSpec[], ...types: (Text | string)[]): void {
+  for (let i = 0, count = types.length; i < count; i++) {
+    compatType(specs, types[i]);
+  }
+}
+
+function makeTupleType (specs: TypeSpec[], entries: number[]): number {
+  return specs.push({
+    def: {
+      Tuple: entries
+    }
+  }) - 1;
+}
+
+function makeVariantType (modName: Text, variantType: string, specs: TypeSpec[], variants: SiVariant[]): number {
+  return specs.push({
+    def: {
+      Variant: { variants }
+    },
+    path: [`pallet_${modName.toString()}`, 'pallet', variantType]
+  }) - 1;
+}
+
+/**
+ * @internal
+ * generate & register the OriginCaller type
+ **/
+function registerOriginCaller (registry: Registry, modules: ModuleMetadataV13[], metaVersion: number): void {
+  registry.register({
+    OriginCaller: {
+      _enum: modules
+        .map((mod, index): [string, number] => [
+          mod.name.toString(),
+          metaVersion >= 12
+            ? mod.index.toNumber()
+            : index
+        ])
+        .sort((a, b) => a[1] - b[1])
+        .reduce((result: Record<string, string>, [name, index]): Record<string, string> => {
+          for (let i = Object.keys(result).length; i < index; i++) {
+            result[`Empty${i}`] = 'Null';
+          }
+
+          result[name] = knownOrigins[name] || 'Null';
+
+          return result;
+        }, {})
+    }
+  });
+}
+
+/**
+ * Find and apply the correct type override
+ * @internal
+ **/
+function setTypeOverride (sectionTypes: OverrideModuleType, types: Type[]): void {
+  types.forEach((type): void => {
+    const override = Object.keys(sectionTypes).find((aliased) => type.eq(aliased));
+
+    if (override) {
+      type.setOverride(sectionTypes[override]);
+    } else {
+      // FIXME: NOT happy with this approach, but gets over the initial hump cased by (Vec<Announcement>,BalanceOf)
+      const orig = type.toString();
+      const alias = Object
+        .entries(sectionTypes)
+        .reduce((result: string, [src, dst]) =>
+          BOXES.reduce((result, [a, z]) =>
+            result.replace(`${a}${src}${z}`, `${a}${dst}${z}`), result), orig);
+
+      if (orig !== alias) {
+        type.setOverride(alias);
+      }
+    }
+  });
+}
+
+/**
+ * Apply module-specific type overrides (always be done as part of toV14)
+ * @internal
+ **/
+function convertCalls (specs: TypeSpec[], registry: Registry, modName: Text, calls: FunctionMetadataV13[], sectionTypes: OverrideModuleType): PalletCallMetadataV14 {
+  const variants = calls.map(({ args, docs, name }, index): SiVariant => {
+    setTypeOverride(sectionTypes, args.map(({ type }) => type));
+
+    return registry.createTypeUnsafe('SiVariant', [{
+      docs,
+      fields: args.map(({ name, type }) =>
+        registry.createTypeUnsafe('SiField', [{ name, type: compatType(specs, type) }])
+      ),
+      index,
+      name
+    }]);
+  });
+
+  return registry.createTypeUnsafe('PalletCallMetadataV14', [{
+    type: makeVariantType(modName, 'Call', specs, variants)
+  }]);
+}
+
+/**
+ * Apply module-specific type overrides (always be done as part of toV14)
+ * @internal
+ */
+function convertConstants (specs: TypeSpec[], registry: Registry, constants: ModuleConstantMetadataV13[], sectionTypes: OverrideModuleType): PalletConstantMetadataV14[] {
+  return constants.map(({ docs, name, type, value }): PalletConstantMetadataV14 => {
+    setTypeOverride(sectionTypes, [type]);
+
+    return registry.createTypeUnsafe('PalletConstantMetadataV14', [{
+      docs,
+      name,
+      type: compatType(specs, type),
+      value
+    }]);
+  });
+}
+
+/**
+ * Apply module-specific type overrides (always be done as part of toV14)
+ * @internal
+ */
+function convertErrors (specs: TypeSpec[], registry: Registry, modName: Text, errors: ErrorMetadataV13[], _sectionTypes: OverrideModuleType): PalletErrorMetadataV14 {
+  const variants = errors.map(({ docs, name }, index): SiVariant =>
+    registry.createTypeUnsafe('SiVariant', [{
+      docs,
+      fields: [],
+      index,
+      name
+    }])
+  );
+
+  return registry.createTypeUnsafe('PalletErrorMetadataV14', [{
+    type: makeVariantType(modName, 'Error', specs, variants)
+  }]);
+}
+
+/**
+ * Apply module-specific type overrides (always be done as part of toV14)
+ * @internal
+ **/
+function convertEvents (specs: TypeSpec[], registry: Registry, modName: Text, events: EventMetadataV13[], sectionTypes: OverrideModuleType): PalletEventMetadataV14 {
+  const variants = events.map(({ args, docs, name }, index): SiVariant => {
+    setTypeOverride(sectionTypes, args);
+
+    return registry.createTypeUnsafe('SiVariant', [{
+      docs,
+      fields: args.map((t) =>
+        registry.createTypeUnsafe('SiField', [{ type: compatType(specs, t) }])
+      ),
+      index,
+      name
+    }]);
+  });
+
+  return registry.createTypeUnsafe('PalletEventMetadataV14', [{
+    type: makeVariantType(modName, 'Event', specs, variants)
+  }]);
+}
+
+function createMapEntry (specs: TypeSpec[], registry: Registry, sectionTypes: OverrideModuleType, { hashers, isLinked, isOptional, keys, value }: MapDef): StorageEntryTypeV14 {
+  setTypeOverride(sectionTypes, [value, ...(Array.isArray(keys) ? keys : [keys])]);
+
+  return registry.createTypeUnsafe('StorageEntryTypeV14', [{
+    Map: {
+      hashers,
+      key: hashers.length === 1
+        ? compatType(specs, keys[0])
+        : makeTupleType(specs, keys.map((t) => compatType(specs, t))),
+      value: isLinked
+        // For previous-generation linked-map support, the actual storage result
+        // is a Tuple with the value and the Linkage (Option appears in teh value-part only)
+        ? compatType(specs, `(${isOptional ? `Option<${value.toString()}>` : value.toString()}, Linkage<${keys[0].toString()}>)`)
+        : compatType(specs, value)
+    }
+  }]);
+}
+
+/**
+ * Apply module-specific storage type overrides (always part of toV14)
+ * @internal
+ **/
+function convertStorage (specs: TypeSpec[], registry: Registry, { items, prefix }: StorageMetadataV13, sectionTypes: OverrideModuleType): PalletStorageMetadataV14 {
+  return registry.createTypeUnsafe('PalletStorageMetadataV14', [{
+    items: items.map(({ docs, fallback, modifier, name, type }): StorageEntryMetadataV14 => {
+      let entryType: StorageEntryTypeV14;
+
+      if (type.isPlain) {
+        const plain = type.asPlain;
+
+        setTypeOverride(sectionTypes, [plain]);
+
+        entryType = registry.createTypeUnsafe('StorageEntryTypeV14', [{
+          Plain: compatType(specs, plain)
+        }]);
+      } else if (type.isMap) {
+        const map = type.asMap;
+
+        entryType = createMapEntry(specs, registry, sectionTypes, {
+          hashers: [map.hasher],
+          isLinked: map.linked.isTrue,
+          isOptional: modifier.isOptional,
+          keys: [map.key],
+          value: map.value
+        });
+      } else if (type.isDoubleMap) {
+        const dm = type.asDoubleMap;
+
+        entryType = createMapEntry(specs, registry, sectionTypes, {
+          hashers: [dm.hasher, dm.key2Hasher],
+          isLinked: false,
+          isOptional: modifier.isOptional,
+          keys: [dm.key1, dm.key2],
+          value: dm.value
+        });
+      } else {
+        const nm = type.asNMap;
+
+        entryType = createMapEntry(specs, registry, sectionTypes, {
+          hashers: nm.hashers,
+          isLinked: false,
+          isOptional: modifier.isOptional,
+          keys: nm.keyVec,
+          value: nm.value
+        });
+      }
+
+      return registry.createTypeUnsafe('StorageEntryMetadataV14', [{
+        docs,
+        fallback,
+        modifier,
+        name,
+        type: entryType
+      }]);
+    }),
+    prefix
+  }]);
+}
+
+/** @internal */
+function convertExtrinsic (registry: Registry, { signedExtensions, version }: ExtrinsicMetadataV13): ExtrinsicMetadataV14 {
+  return registry.createTypeUnsafe('ExtrinsicMetadataV14', [{
+    signedExtensions: signedExtensions.map((identifier) => ({
+      identifier,
+      type: 0 // we don't map the fields at all
+    })),
+    type: 0, // Map to extrinsic like in v14?
+    version
+  }]);
+}
+
+/** @internal */
+function createPallet (specs: TypeSpec[], registry: Registry, mod: ModuleMetadataV13, { calls, constants, errors, events, storage }: { calls: FunctionMetadataV13[] | null, constants: ModuleConstantMetadataV13[], errors: ErrorMetadataV13[] | null, events: EventMetadataV13[] | null, storage: StorageMetadataV13 | null }): PalletMetadataV14 {
+  const sectionTypes = getAliasTypes(registry, stringCamelCase(mod.name));
+
+  return registry.createTypeUnsafe('PalletMetadataV14', [{
+    calls: calls && convertCalls(specs, registry, mod.name, calls, sectionTypes),
+    constants: convertConstants(specs, registry, constants, sectionTypes),
+    errors: errors && convertErrors(specs, registry, mod.name, errors, sectionTypes),
+    events: events && convertEvents(specs, registry, mod.name, events, sectionTypes),
+    index: mod.index,
+    name: mod.name,
+    storage: storage && convertStorage(specs, registry, storage, sectionTypes)
+  }]);
+}
+
+/**
+ * Convert the Metadata to v14
+ * @internal
+ **/
+export function toV14 (registry: Registry, v13: MetadataV13, metaVersion: number): MetadataV14 {
+  const specs: TypeSpec[] = [];
+
+  // position 0 always has Null, additionally add internal defaults
+  compatTypes(specs, 'Null', 'u8', 'u16', 'u32', 'u64');
+  registerOriginCaller(registry, v13.modules, metaVersion);
+
+  const extrinsic = convertExtrinsic(registry, v13.extrinsic);
+  const pallets = v13.modules.map((mod) =>
+    createPallet(specs, registry, mod, {
+      calls: mod.calls.unwrapOr(null),
+      constants: mod.constants,
+      errors: mod.errors.length ? mod.errors : null,
+      events: mod.events.unwrapOr(null),
+      storage: mod.storage.unwrapOr(null)
+    })
+  );
+
+  return registry.createTypeUnsafe('MetadataV14', [{
+    extrinsic,
+    lookup: {
+      types: specs.map((type, id) =>
+        registry.createTypeUnsafe('PortableType', [{ id, type }])
+      )
+    },
+    pallets
+  }]);
+}

package/src/metadata/v14/Metadata.spec.ts

@@ -0,0 +1,20 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import kusamaData from '@pezkuwi/types-support/metadata/v14/kusama-hex';
+import polkadotData from '@pezkuwi/types-support/metadata/v14/polkadot-hex';
+import substrateData from '@pezkuwi/types-support/metadata/v14/substrate-hex';
+
+import { testMeta } from '../util/testUtil.js';
+
+testMeta(14, {
+  kusama: {
+    data: kusamaData
+  },
+  polkadot: {
+    data: polkadotData
+  },
+  substrate: {
+    data: substrateData
+  }
+});

package/src/metadata/v14/toV15.ts

@@ -0,0 +1,45 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { MetadataV14, MetadataV15 } from '../../interfaces/metadata/index.js';
+import type { Registry } from '../../types/index.js';
+
+import { objectSpread } from '@pezkuwi/util';
+
+/**
+ * Convert the Metadata to v15
+ * @internal
+ **/
+export function toV15 (registry: Registry, v14: MetadataV14, _: number): MetadataV15 {
+  // V15 is mostly equivalent to v14 however it does add
+  //
+  // 1. The top-level apis entry - it is assumed that in usage we would
+  //    just check for all-empty (like this would construct)
+  // 2. A docs param on the pallet itself
+  // 3. Additional extrinsic parameters
+  //
+  // A straight conversion with createTypeUndafe magic fills in details
+
+  // We need the UncheckedExtrinsic to extract the types, at least for v14
+  // which does have these details embedded (previous-gen won't populate)
+  const unchecked = v14.lookup.paramTypes.SpRuntimeUncheckedExtrinsic;
+
+  return registry.createTypeUnsafe('MetadataV15', [
+    objectSpread({}, v14, {
+      extrinsic: registry.createTypeUnsafe('ExtrinsicMetadataV15', [
+        objectSpread({}, v14.extrinsic, {
+          addressType: unchecked?.[0].type.unwrapOr(0),
+          callType: unchecked?.[1].type.unwrapOr(0),
+          extraType: unchecked?.[3].type.unwrapOr(0),
+          signatureType: unchecked?.[2].type.unwrapOr(0)
+        })
+      ]),
+      outerEnums: registry.createTypeUnsafe('OuterEnums15', [{
+        // FIXME We need to extract & add the errorType in here
+        // (these doesn't seem to be an esay way to detect & extract it)
+        callType: unchecked?.[1].type.unwrapOr(0),
+        eventType: v14.lookup.paramTypes.FrameSystemEventRecord?.[0].type.unwrapOr(0)
+      }])
+    })
+  ]);
+}

package/src/metadata/v15/Metadata.spec.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import assetHubKusamaData from '@pezkuwi/types-support/metadata/v15/asset-hub-kusama-hex';
+import assetHubPolkadotData from '@pezkuwi/types-support/metadata/v15/asset-hub-polkadot-hex';
+import kusamaData from '@pezkuwi/types-support/metadata/v15/kusama-hex';
+import polkadotData from '@pezkuwi/types-support/metadata/v15/polkadot-hex';
+import substrateData from '@pezkuwi/types-support/metadata/v15/substrate-hex';
+
+import { testMeta } from '../util/testUtil.js';
+
+testMeta(15, {
+  'asset-hub-kusama': {
+    data: assetHubKusamaData
+  },
+  'asset-hub-polkadot': {
+    data: assetHubPolkadotData
+  },
+  kusama: {
+    data: kusamaData
+  },
+  polkadot: {
+    data: polkadotData
+  },
+  substrate: {
+    data: substrateData
+  }
+});

package/src/metadata/v15/toV16.ts

@@ -0,0 +1,147 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ExtrinsicMetadataV15, ExtrinsicMetadataV16, ItemDeprecationInfoV16, MetadataV15, MetadataV16, PalletAssociatedTypeMetadataV16, PalletCallMetadataV14, PalletCallMetadataV16, PalletConstantMetadataV14, PalletConstantMetadataV16, PalletErrorMetadataV14, PalletErrorMetadataV16, PalletEventMetadataV14, PalletEventMetadataV16, PalletMetadataV15, PalletMetadataV16, PalletStorageMetadataV14, PalletStorageMetadataV16, RuntimeApiMetadataV15, RuntimeApiMetadataV16, StorageEntryMetadataV16, TransactionExtensionMetadataV16 } from '../../interfaces/metadata/index.js';
+import type { Registry } from '../../types/index.js';
+
+import { type Vec } from '@pezkuwi/types-codec';
+import { objectSpread } from '@pezkuwi/util';
+
+function palletsFromV15 (registry: Registry, palletV15: PalletMetadataV15): PalletMetadataV16 {
+  const deprecationInfo: ItemDeprecationInfoV16 = registry.createTypeUnsafe('ItemDeprecationInfoV16', ['NotDeprecated']);
+  const associatedTypes: Vec<PalletAssociatedTypeMetadataV16> = registry.createTypeUnsafe('Vec<PalletAssociatedTypeMetadataV16>', [[]]);
+  const viewFunctions: Vec<PalletAssociatedTypeMetadataV16> = registry.createTypeUnsafe('Vec<PalletViewFunctionMetadataV16>', [[]]);
+
+  return registry.createTypeUnsafe('PalletMetadataV16', [
+    objectSpread({}, palletV15, {
+      associatedTypes,
+      calls: palletV15.calls.isSome ? convertCalls(registry, palletV15.calls.unwrap()) : null,
+      constants: convertConstants(registry, palletV15.constants),
+      deprecationInfo,
+      errors: palletV15.errors.isSome ? converErrors(registry, palletV15.errors.unwrap()) : null,
+      events: palletV15.events.isSome ? convertEvents(registry, palletV15.events.unwrap()) : null,
+      storage: palletV15.storage.isSome ? convertStorage(registry, palletV15.storage.unwrap()) : null,
+      viewFunctions
+    })
+  ]);
+}
+
+function convertStorage (registry: Registry, storage: PalletStorageMetadataV14): PalletStorageMetadataV16 {
+  const deprecationInfo: ItemDeprecationInfoV16 = registry.createTypeUnsafe('ItemDeprecationInfoV16', ['NotDeprecated']);
+
+  const items: StorageEntryMetadataV16[] = storage.items.map((item) =>
+    registry.createTypeUnsafe('StorageEntryMetadataV16', [
+      objectSpread({}, item, { deprecationInfo })
+    ])
+  );
+
+  return registry.createTypeUnsafe('PalletStorageMetadataV16', [{
+    items: registry.createTypeUnsafe('Vec<StorageEntryMetadataV16>', [items]),
+    prefix: storage.prefix
+  }]);
+}
+
+function convertCalls (registry: Registry, calls: PalletCallMetadataV14): PalletCallMetadataV16 {
+  const deprecationInfo = registry.createTypeUnsafe('EnumDeprecationInfoV16', []);
+
+  return registry.createTypeUnsafe('PalletCallMetadataV16', [{
+    deprecationInfo,
+    type: calls.type
+  }]);
+}
+
+function convertEvents (registry: Registry, events: PalletEventMetadataV14): PalletEventMetadataV16 {
+  const deprecationInfo = registry.createTypeUnsafe('EnumDeprecationInfoV16', []);
+
+  return registry.createTypeUnsafe('PalletEventMetadataV16', [{
+    deprecationInfo,
+    type: events.type
+  }]);
+}
+
+function convertConstants (registry: Registry, constants: Vec<PalletConstantMetadataV14>): Vec<PalletConstantMetadataV16> {
+  const deprecationInfo: ItemDeprecationInfoV16 = registry.createTypeUnsafe('ItemDeprecationInfoV16', ['NotDeprecated']);
+
+  return registry.createTypeUnsafe('Vec<PalletConstantMetadataV16>', [
+    constants.map((constant) => registry.createTypeUnsafe('PalletConstantMetadataV16', [
+      objectSpread({}, constant, { deprecationInfo })
+    ]))]
+  );
+}
+
+function converErrors (registry: Registry, errors: PalletErrorMetadataV14): PalletErrorMetadataV16 {
+  const deprecationInfo = registry.createTypeUnsafe('EnumDeprecationInfoV16', []);
+
+  return registry.createTypeUnsafe('PalletErrorMetadataV16', [{
+    deprecationInfo,
+    type: errors.type
+  }]);
+}
+
+function extrinsicFromV15 (registry: Registry, extrinsicV15: ExtrinsicMetadataV15): ExtrinsicMetadataV16 {
+  const transactionExtensions: TransactionExtensionMetadataV16[] = extrinsicV15.signedExtensions.map(({ additionalSigned, identifier, type }) =>
+    registry.createTypeUnsafe('TransactionExtensionMetadataV16', [{
+      identifier,
+      implict: additionalSigned,
+      type
+    }])
+  );
+
+  const indexes = transactionExtensions.map((_, i) =>
+    registry.createTypeUnsafe('Compact<u32>', [i])
+  );
+
+  const transactionExtensionsByVersion = registry.createTypeUnsafe(
+    'BTreeMap<u8, Vec<Compact<u32>>>',
+    [new Map([[registry.createTypeUnsafe('u8', [extrinsicV15.version]), registry.createTypeUnsafe('Vec<Compact<u32>>', [indexes])]])]
+  );
+
+  return registry.createTypeUnsafe('ExtrinsicMetadataV16', [
+    {
+      addressType: extrinsicV15.addressType,
+      callType: extrinsicV15.callType,
+      signatureType: extrinsicV15.signatureType,
+      transactionExtensions,
+      transactionExtensionsByVersion,
+      versions: [extrinsicV15.version]
+    }
+  ]);
+}
+
+function apisFromV15 (registry: Registry, runtimeApiV15: RuntimeApiMetadataV15): RuntimeApiMetadataV16 {
+  const deprecationInfo = registry.createTypeUnsafe('ItemDeprecationInfoV16', ['NotDeprecated']);
+
+  const methods = runtimeApiV15.methods.map((method) =>
+    registry.createTypeUnsafe('RuntimeApiMethodMetadataV16',
+      [objectSpread({}, method, { deprecationInfo })]
+    )
+  );
+
+  return registry.createTypeUnsafe('RuntimeApiMetadataV16', [
+    objectSpread({}, runtimeApiV15, {
+      deprecationInfo,
+      methods,
+      version: registry.createTypeUnsafe('Compact<u32>', [0])
+    })
+  ]);
+}
+
+/**
+ * Convert the Metadata to v16
+ * @internal
+ **/
+export function toV16 (registry: Registry, v15: MetadataV15, _: number): MetadataV16 {
+  const pallets: PalletMetadataV16[] = v15.pallets.map((pallet) => {
+    return palletsFromV15(registry, pallet);
+  });
+  const extrinsic: ExtrinsicMetadataV16 = extrinsicFromV15(registry, v15.extrinsic);
+  const apis: RuntimeApiMetadataV16[] = v15.apis.map((runtimeApi) => apisFromV15(registry, runtimeApi));
+
+  return registry.createTypeUnsafe('MetadataV16', [
+    objectSpread({}, v15, {
+      apis,
+      extrinsic,
+      pallets
+    })
+  ]);
+}

package/src/metadata/v16/Metadata.spec.ts

@@ -0,0 +1,30 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/* import assetHubKusamaData from '@pezkuwi/types-support/metadata/v16/asset-hub-kusama-hex';
+import assetHubPolkadotData from '@pezkuwi/types-support/metadata/v16/asset-hub-polkadot-hex';
+import kusamaData from '@pezkuwi/types-support/metadata/v16/kusama-hex';
+import polkadotData from '@pezkuwi/types-support/metadata/v16/polkadot-hex';*/
+import substrateData from '@pezkuwi/types-support/metadata/v16/substrate-hex';
+
+import { testMeta } from '../util/testUtil.js';
+
+// TODO: Once MetadataV16 lands in an official release, pull the
+// latest metadata for each chain and update the tests
+testMeta(16, {
+/*   'asset-hub-kusama': {
+    data: assetHubKusamaData
+  },
+  'asset-hub-polkadot': {
+    data: assetHubPolkadotData
+  },
+  kusama: {
+    data: kusamaData
+  },
+  polkadot: {
+    data: polkadotData
+  },*/
+  substrate: {
+    data: substrateData
+  }
+});

package/src/metadata/v16/toLatest.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataLatest, MetadataV16 } from '../../interfaces/metadata/index.js';
+
+/**
+ * Convert the Metadata (which is an alias) to latest
+ * @internal
+ **/
+export function toLatest (_registry: Registry, v16: MetadataV16, _metaVersion: number): MetadataLatest {
+  return v16;
+}

package/src/metadata/v9/Metadata.spec.ts

@@ -0,0 +1,12 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import substrateData from '@pezkuwi/types-support/metadata/v9/substrate-hex';
+
+import { testMeta } from '../util/testUtil.js';
+
+testMeta(9, {
+  substrate: {
+    data: substrateData
+  }
+}, false);