@pezkuwi/types 16.5.5

package/src/metadata/util/testUtil.ts

@@ -0,0 +1,217 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+/* global describe, it, expect */
+
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { MetaVersionAll } from '../versions.js';
+import type { Check } from './types.js';
+
+import fs from 'node:fs';
+
+import { hexToU8a, stringCamelCase, stringify, u8aToHex } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../../create/index.js';
+import { unwrapStorageSi, unwrapStorageType } from '../../util/index.js';
+import { Metadata } from '../Metadata.js';
+import { getUniqTypes } from './getUniqTypes.js';
+
+interface MetadataJsonDef {
+  lookup: unknown;
+
+  [key: string]: unknown;
+}
+
+interface MetadataJson {
+  metadata: {
+    v9: MetadataJsonDef;
+    v10: MetadataJsonDef;
+    v11: MetadataJsonDef;
+    v12: MetadataJsonDef;
+    v13: MetadataJsonDef;
+    v14: MetadataJsonDef;
+    v15: MetadataJsonDef;
+    v16: MetadataJsonDef;
+  }
+}
+
+function getJsonName (version: number, type: string, sub: 'json' | 'types'): URL {
+  return new URL(`../../../../types-support/src/metadata/v${version}/${type}-${sub}.json`, import.meta.url);
+}
+
+function writeJson (json: unknown, version: number, type: string, sub: 'json' | 'types'): void {
+  fs.writeFileSync(getJsonName(version, type, sub), stringify(json, 2), { flag: 'w' });
+}
+
+function readJson <T = unknown> (version: number, type: string, sub: 'json' | 'types'): T {
+  return JSON.parse(
+    fs.readFileSync(getJsonName(version, type, sub), 'utf-8')
+  ) as unknown as T;
+}
+
+function handleMetadata (registry: Registry, version: MetaVersionAll, data: HexString): Metadata {
+  let metadata: Metadata;
+
+  if (version > 15) {
+    const opaqueMetadata = registry.createType('Option<OpaqueMetadata>', registry.createType('Raw', data).toU8a()).unwrap();
+
+    metadata = new Metadata(registry, opaqueMetadata.toHex());
+  } else {
+    try {
+      metadata = new Metadata(registry, data);
+    } catch {
+      const opaqueMetadata = registry.createType('Option<OpaqueMetadata>', registry.createType('Raw', data).toU8a()).unwrap();
+
+      metadata = new Metadata(registry, opaqueMetadata.toHex());
+    }
+  }
+
+  return metadata;
+}
+
+/** @internal */
+export function decodeLatestMeta (registry: Registry, type: string, version: MetaVersionAll, { data }: Check): void {
+  const metadata = handleMetadata(registry, version, data);
+
+  registry.setMetadata(metadata);
+
+  it('decodes latest substrate properly', (): void => {
+    const json = metadata.toJSON() as unknown as MetadataJson;
+
+    delete json.metadata[`v${metadata.version}`].lookup;
+
+    expect(metadata.version).toBe(version);
+
+    try {
+      expect(json).toEqual(readJson(version, type, 'json'));
+    } catch (error) {
+      if (process.env['GITHUB_REPOSITORY']) {
+        throw error;
+      }
+
+      console.error(error);
+      writeJson(json, version, type, 'json');
+    }
+  });
+
+  if (version >= 14) {
+    it('decodes latest types correctly', (): void => {
+      const json = metadata.asLatest.lookup.types.toJSON();
+
+      try {
+        expect(json).toEqual(readJson(version, type, 'types'));
+      } catch (error) {
+        if (process.env['GITHUB_REPOSITORY']) {
+          throw error;
+        }
+
+        console.error(error);
+        writeJson(json, version, type, 'types');
+      }
+    });
+  }
+}
+
+/** @internal */
+export function toLatest (registry: Registry, version: MetaVersionAll, { data }: Check, withThrow = true): void {
+  it(`converts v${version} to latest`, (): void => {
+    const metadata = handleMetadata(registry, version, data);
+
+    registry.setMetadata(metadata);
+
+    const latest = metadata.asLatest;
+
+    if (metadata.version < 14) {
+      getUniqTypes(registry, latest, withThrow);
+    }
+  });
+}
+
+/** @internal */
+export function defaultValues (registry: Registry, { data, fails = [] }: Check, withThrow = true, withFallbackCheck = false, version: MetaVersionAll): void {
+  describe('storage with default values', (): void => {
+    const metadata = handleMetadata(registry, version, data);
+    const { pallets } = metadata.asLatest;
+
+    pallets.filter(({ storage }) => storage.isSome).forEach(({ name, storage }): void => {
+      const sectionName = stringCamelCase(name);
+
+      storage.unwrap().items.forEach(({ fallback, modifier, name, type }): void => {
+        const inner = unwrapStorageType(registry, type, modifier.isOptional);
+        const location = `${sectionName}.${stringCamelCase(name)}: ${inner}`;
+
+        it(location, (): void => {
+          expect((): void => {
+            try {
+              const instance = registry.createTypeUnsafe(
+                registry.createLookupType(unwrapStorageSi(type)),
+                [hexToU8a(fallback.toHex())],
+                { isOptional: modifier.isOptional }
+              );
+
+              if (withFallbackCheck) {
+                const [hexType, hexOrig] = [u8aToHex(instance.toU8a()), u8aToHex(fallback.toU8a(true))];
+
+                if (hexType !== hexOrig) {
+                  throw new Error(`Fallback does not match (${((hexOrig.length - 2) / 2) - ((hexType.length - 2) / 2)} bytes missing): ${hexType} !== ${hexOrig}`);
+                }
+              }
+            } catch (error) {
+              const message = `${location}:: ${(error as Error).message}`;
+
+              if (withThrow && !fails.some((f) => location.includes(f))) {
+                throw new Error(message);
+              } else {
+                console.warn(message);
+              }
+            }
+          }).not.toThrow();
+        });
+      });
+    });
+  });
+}
+
+function serialize (registry: Registry, { data }: Check, version: MetaVersionAll): void {
+  const metadata = handleMetadata(registry, version, data);
+
+  if (version < 15) {
+    it('serializes to hex in the same form as retrieved', (): void => {
+      expect(metadata.toHex()).toEqual(data);
+    });
+
+    // NOTE Assuming the first passes this is actually something that doesn't test
+    // anything new. If the first line in this function passed and the above values
+    // are equivalent, this would be as well.
+    it.skip('can construct from a re-serialized form', (): void => {
+      expect(
+        () => new Metadata(registry, metadata.toHex())
+      ).not.toThrow();
+    });
+
+    // as used in the extension
+    it('can construct from asCallsOnly.toHex()', (): void => {
+      expect(
+        () => new Metadata(registry, metadata.asCallsOnly.toHex())
+      ).not.toThrow();
+    });
+  }
+}
+
+export function testMeta (version: MetaVersionAll, matchers: Record<string, Check>, withFallback = true): void {
+  describe(`MetadataV${version}`, (): void => {
+    for (const [type, matcher] of Object.entries(matchers)) {
+      const registry = new TypeRegistry();
+
+      describe(type, (): void => {
+        serialize(registry, matcher, version);
+        decodeLatestMeta(registry, type, version, matcher);
+        toLatest(registry, version, matcher);
+        defaultValues(registry, matcher, true, withFallback, version);
+      });
+    }
+  });
+}

package/src/metadata/util/toCallsOnly.spec.ts

@@ -0,0 +1,46 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import staticLatest from '@pezkuwi/types-support/metadata/static-substrate';
+import staticV13 from '@pezkuwi/types-support/metadata/v13/substrate-hex';
+import { stringify } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../../create/index.js';
+import { Metadata } from '../Metadata.js';
+
+describe('toCallsOnly', (): void => {
+  const registry = new TypeRegistry();
+
+  it('creates a calls-only version of the latest', (): void => {
+    const stripped = new Metadata(registry, staticLatest).asCallsOnly;
+
+    try {
+      expect(stripped).toBeDefined();
+    } catch (error) {
+      console.error(stringify(stripped));
+
+      throw error;
+    }
+  });
+
+  it('creates a calls-only version of V13', (): void => {
+    const stripped = new Metadata(registry, staticV13).asCallsOnly;
+
+    try {
+      expect(stripped).toBeDefined();
+    } catch (error) {
+      console.error(stringify(stripped));
+
+      throw error;
+    }
+  });
+
+  it('can serialize from the input', (): void => {
+    const s1 = new Metadata(registry, staticLatest).asCallsOnly.toU8a();
+    const s2 = new Metadata(registry, s1).asCallsOnly.toU8a();
+
+    expect(s1).toEqual(s2);
+  });
+});

package/src/metadata/util/toCallsOnly.ts

@@ -0,0 +1,43 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Option, Text, u8 } from '@pezkuwi/types-codec';
+import type { AnyJson, Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataLatest, PalletCallMetadataLatest } from '../../interfaces/metadata/index.js';
+
+import { objectSpread } from '@pezkuwi/util';
+
+interface ModuleMetadataTrimmed {
+  calls: Option<PalletCallMetadataLatest>;
+  index: u8;
+  name: Text;
+}
+
+function trimDocs (docs: Text[]): string[] {
+  const strings = docs.map((d) => d.toString().trim());
+  const firstEmpty = strings.findIndex((d) => !d.length);
+
+  return firstEmpty === -1
+    ? strings
+    : strings.slice(0, firstEmpty);
+}
+
+/** @internal */
+export function toCallsOnly (registry: Registry, { extrinsic, lookup, pallets }: MetadataLatest): AnyJson {
+  return registry.createTypeUnsafe('MetadataLatest', [{
+    extrinsic,
+    lookup: {
+      types: lookup.types.map(({ id, type }) =>
+        registry.createTypeUnsafe('PortableType', [{
+          id,
+          type: objectSpread({}, type, { docs: trimDocs(type.docs) })
+        }])
+      )
+    },
+    pallets: pallets.map(({ calls, index, name }): ModuleMetadataTrimmed => ({
+      calls: registry.createTypeUnsafe('Option<PalletCallMetadataLatest>', [calls.unwrapOr(null)]),
+      index,
+      name
+    }))
+  }]).toJSON();
+}

package/src/metadata/util/types.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { HexString } from '@pezkuwi/util/types';
+
+export interface Check {
+  data: HexString;
+  fails?: string[];
+}

package/src/metadata/util/validateTypes.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '@pezkuwi/types-codec/types';
+
+import { logger } from '@pezkuwi/util';
+
+import { extractTypes } from './extractTypes.js';
+import { flattenUniq } from './flattenUniq.js';
+
+const l = logger('metadata');
+
+/** @internal */
+export function validateTypes (registry: Registry, throwError: boolean, types: string[]): string[] {
+  const missing = flattenUniq(extractTypes(types))
+    .filter((type) =>
+      !registry.hasType(type) &&
+      !registry.isLookupType(type)
+    )
+    .sort();
+
+  if (missing.length !== 0) {
+    const message = `Unknown types found, no types for ${missing.join(', ')}`;
+
+    if (throwError) {
+      throw new Error(message);
+    } else {
+      l.warn(message);
+    }
+  }
+
+  return types;
+}

package/src/metadata/v10/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/v10/substrate-hex';
+
+import { testMeta } from '../util/testUtil.js';
+
+testMeta(10, {
+  substrate: {
+    data: substrateData
+  }
+}, false);

package/src/metadata/v10/toV11.ts

@@ -0,0 +1,18 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataV10, MetadataV11 } from '../../interfaces/metadata/index.js';
+
+/** @internal */
+export function toV11 (registry: Registry, { modules }: MetadataV10): MetadataV11 {
+  return registry.createTypeUnsafe('MetadataV11', [{
+    // This is new in V11, pass V0 here - something non-existing, telling the API to use
+    // the fallback for this information (on-chain detection)
+    extrinsic: {
+      signedExtensions: [],
+      version: 0
+    },
+    modules
+  }]);
+}

package/src/metadata/v11/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/v11/substrate-hex';
+
+import { testMeta } from '../util/testUtil.js';
+
+testMeta(11, {
+  substrate: {
+    data: substrateData
+  }
+}, false);

package/src/metadata/v11/toV12.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataV11, MetadataV12, ModuleMetadataV12 } from '../../interfaces/metadata/index.js';
+
+import { objectSpread } from '@pezkuwi/util';
+
+/**
+ * @internal
+ **/
+export function toV12 (registry: Registry, { extrinsic, modules }: MetadataV11): MetadataV12 {
+  return registry.createTypeUnsafe('MetadataV12', [{
+    extrinsic,
+    modules: modules.map((mod): ModuleMetadataV12 =>
+      registry.createTypeUnsafe('ModuleMetadataV12', [objectSpread({}, mod, { index: 255 })])
+    )
+  }]);
+}

package/src/metadata/v12/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/v12/substrate-hex';
+
+import { testMeta } from '../util/testUtil.js';
+
+testMeta(12, {
+  substrate: {
+    data: substrateData
+  }
+});

package/src/metadata/v12/toV13.ts

@@ -0,0 +1,12 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataV12, MetadataV13 } from '../../interfaces/metadata/index.js';
+
+/**
+ * @internal
+ **/
+export function toV13 (registry: Registry, v12: MetadataV12): MetadataV13 {
+  return registry.createTypeUnsafe('MetadataV13', [v12]);
+}

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

@@ -0,0 +1,24 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import kusamaData from '@pezkuwi/types-support/metadata/v13/kusama-hex';
+import polkadotData from '@pezkuwi/types-support/metadata/v13/polkadot-hex';
+import substrateData from '@pezkuwi/types-support/metadata/v13/substrate-hex';
+
+import { testMeta } from '../util/testUtil.js';
+
+testMeta(13, {
+  kusama: {
+    data: kusamaData,
+    fails: [
+      // RawSolution has 24 entries
+      'SignedSubmissionOf'
+    ]
+  },
+  polkadot: {
+    data: polkadotData
+  },
+  substrate: {
+    data: substrateData
+  }
+});