@pezkuwi/typegen 16.5.5

package/src/fromDefs.ts

@@ -0,0 +1,106 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { HexString } from '@pezkuwi/util/types';
+
+import fs from 'node:fs';
+import path from 'node:path';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+import * as substrateDefs from '@pezkuwi/types/interfaces/definitions';
+import { isHex } from '@pezkuwi/util';
+
+import { generateDefaultLookup } from './generate/index.js';
+import { generateInterfaceTypes } from './generate/interfaceRegistry.js';
+import { generateTsDef } from './generate/tsDef.js';
+import { assertDir, assertFile, getMetadataViaWs } from './util/index.js';
+
+interface ArgV { input: string; package: string; endpoint?: string; }
+
+async function mainPromise (): Promise<void> {
+  const { endpoint, input, package: pkg } = yargs(hideBin(process.argv)).strict().options({
+    endpoint: {
+      description: 'The endpoint to connect to (e.g. wss://kusama-rpc.polkadot.io) or relative path to a file containing the JSON output of an RPC state_getMetadata call',
+      type: 'string'
+    },
+    input: {
+      description: 'The directory to use for the user definitions',
+      required: true,
+      type: 'string'
+    },
+    package: {
+      description: 'The package name & path to use for the user types',
+      required: true,
+      type: 'string'
+    }
+  }).argv as ArgV;
+
+  const inputPath = assertDir(path.join(process.cwd(), input));
+  let userDefs: Record<string, any> = {};
+
+  try {
+    const defCont = await import(
+      assertFile(path.join(inputPath, 'definitions.ts'))
+    ) as Record<string, any>;
+
+    userDefs = defCont;
+  } catch (error) {
+    console.error('ERROR: Unable to load user definitions:', (error as Error).message);
+  }
+
+  const userKeys = Object.keys(userDefs);
+  const filteredBase = Object
+    .entries(substrateDefs as Record<string, unknown>)
+    .filter(([key]) => {
+      if (userKeys.includes(key)) {
+        console.warn(`Override found for ${key} in user types, ignoring in @polkadot/types`);
+
+        return false;
+      }
+
+      return true;
+    })
+    .reduce((defs: Record<string, any>, [key, value]) => {
+      defs[key] = value;
+
+      return defs;
+    }, {});
+
+  const allDefs = {
+    '@pezkuwi/types/interfaces': filteredBase,
+    [pkg]: userDefs
+  };
+
+  generateTsDef(allDefs, inputPath, pkg);
+  generateInterfaceTypes(allDefs, path.join(inputPath, 'augment-types.ts'));
+
+  if (endpoint) {
+    let metaHex: HexString;
+
+    if (endpoint.startsWith('wss://') || endpoint.startsWith('ws://')) {
+      metaHex = await getMetadataViaWs(endpoint);
+    } else {
+      metaHex = (
+        JSON.parse(
+          fs.readFileSync(assertFile(path.join(process.cwd(), endpoint)), 'utf-8')
+        ) as { result: HexString }
+      ).result;
+
+      if (!isHex(metaHex)) {
+        throw new Error('Invalid metadata file');
+      }
+    }
+
+    generateDefaultLookup(inputPath, metaHex);
+  }
+}
+
+export function main (): void {
+  mainPromise().catch((error) => {
+    console.error();
+    console.error(error);
+    console.error();
+    process.exit(1);
+  });
+}

package/src/generate/consts.ts

@@ -0,0 +1,112 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
+import type { Definitions } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+
+import Handlebars from 'handlebars';
+
+import * as defaultDefs from '@pezkuwi/types/interfaces/definitions';
+import lookupDefinitions from '@pezkuwi/types-augment/lookup/definitions';
+import { stringCamelCase } from '@pezkuwi/util';
+
+import { compareName, createImports, formatType, initMeta, readTemplate, setImports, writeFile } from '../util/index.js';
+import { ignoreUnusedLookups } from './lookup.js';
+import { type ExtraTypes, getDeprecationNotice } from './types.js';
+
+const generateForMetaTemplate = Handlebars.compile(readTemplate('consts'));
+
+/** @internal */
+function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {
+  writeFile(dest, (): string => {
+    const allTypes = {
+      '@pezkuwi/types-augment': {
+        lookup: {
+          ...lookupDefinitions,
+          ...customLookupDefinitions
+        }
+      },
+      '@pezkuwi/types/interfaces': defaultDefs,
+      ...extraTypes
+    };
+    const imports = createImports(allTypes);
+    const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
+      return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
+    }, {});
+    const { lookup, pallets, registry } = meta.asLatest;
+    const usedTypes = new Set<string>([]);
+
+    const modules = pallets
+      .filter(({ constants }) => constants.length > 0)
+      .map(({ constants, name }) => {
+        if (!isStrict) {
+          setImports(allDefs, imports, ['Codec']);
+        }
+
+        const items = constants
+          .map(({ deprecationInfo, docs, name, type }) => {
+            const typeDef = lookup.getTypeDef(type);
+            const returnType = typeDef.lookupName || formatType(registry, allDefs, typeDef, imports);
+
+            if (!deprecationInfo.isNotDeprecated) {
+              const deprecationNotice = getDeprecationNotice(deprecationInfo, stringCamelCase(name), 'Constant');
+
+              const items = docs.length
+                ? ['', deprecationNotice]
+                : [deprecationNotice];
+
+              docs.push(...items.map((text) => registry.createType('Text', text)));
+            }
+
+            // Add the type to the list of used types
+            if (!(imports.primitiveTypes[returnType])) {
+              usedTypes.add(returnType);
+            }
+
+            setImports(allDefs, imports, [returnType]);
+
+            return {
+              docs,
+              name: stringCamelCase(name),
+              type: returnType
+            };
+          })
+          .sort(compareName);
+
+        return {
+          items,
+          name: stringCamelCase(name)
+        };
+      })
+      .sort(compareName);
+
+    // filter out the unused lookup types from imports
+    ignoreUnusedLookups([...usedTypes], imports);
+
+    return generateForMetaTemplate({
+      headerType: 'chain',
+      imports,
+      isStrict,
+      modules,
+      types: [
+        ...Object.keys(imports.localTypes).sort().map<{ file: string; types: string[] }>((packagePath) => ({
+          file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
+          types: Object.keys(imports.localTypes[packagePath])
+        })),
+        {
+          file: '@pezkuwi/api-base/types',
+          types: ['ApiTypes', 'AugmentedConst']
+        }
+      ]
+    });
+  });
+}
+
+// Call `generateForMeta()` with current static metadata
+/** @internal */
+export function generateDefaultConsts (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void {
+  const { metadata } = initMeta(data, extraTypes);
+
+  return generateForMeta(metadata, dest, extraTypes, isStrict, customLookupDefinitions);
+}

package/src/generate/errors.ts

@@ -0,0 +1,75 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { VariantDeprecationInfoV16 } from '@pezkuwi/types/interfaces';
+import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
+import type { HexString } from '@pezkuwi/util/types';
+
+import Handlebars from 'handlebars';
+
+import { stringCamelCase } from '@pezkuwi/util';
+
+import { compareName, createImports, initMeta, readTemplate, writeFile } from '../util/index.js';
+import { type ExtraTypes, getDeprecationNotice } from './types.js';
+
+const generateForMetaTemplate = Handlebars.compile(readTemplate('errors'));
+
+/** @internal */
+function generateForMeta (meta: Metadata, dest: string, isStrict: boolean): void {
+  writeFile(dest, (): string => {
+    const imports = createImports({});
+    const { lookup, pallets } = meta.asLatest;
+    const modules = pallets
+      .filter(({ errors }) => errors.isSome)
+      .map((data) => {
+        const name = data.name;
+        const errors = data.errors.unwrap();
+        const deprecationInfo = errors.deprecationInfo.toJSON();
+
+        return {
+          items: lookup.getSiType(errors.type).def.asVariant.variants
+            .map(({ docs, index, name }) => {
+              const rawStatus = deprecationInfo?.[index.toNumber()];
+
+              if (rawStatus) {
+                const deprecationVariantInfo: VariantDeprecationInfoV16 = meta.registry.createTypeUnsafe('VariantDeprecationInfoV16', [rawStatus]);
+
+                const deprecationNotice = getDeprecationNotice(deprecationVariantInfo, name.toString());
+                const notice = docs.length ? ['', deprecationNotice] : [deprecationNotice];
+
+                docs.push(...notice.map((text) => meta.registry.createType('Text', text)));
+              }
+
+              return {
+                docs,
+                name: name.toString()
+              };
+            })
+            .sort(compareName),
+          name: stringCamelCase(name)
+        };
+      })
+      .sort(compareName);
+
+    return generateForMetaTemplate({
+      headerType: 'chain',
+      imports,
+      isStrict,
+      modules,
+      types: [
+        {
+          file: '@pezkuwi/api-base/types',
+          types: ['ApiTypes', 'AugmentedError']
+        }
+      ]
+    });
+  });
+}
+
+// Call `generateForMeta()` with current static metadata
+/** @internal */
+export function generateDefaultErrors (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false): void {
+  const { metadata } = initMeta(data, extraTypes);
+
+  return generateForMeta(metadata, dest, isStrict);
+}

package/src/generate/events.ts

@@ -0,0 +1,165 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { VariantDeprecationInfoV16 } from '@pezkuwi/types/interfaces';
+import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
+import type { Definitions } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+
+import Handlebars from 'handlebars';
+
+import * as defaultDefs from '@pezkuwi/types/interfaces/definitions';
+import lookupDefinitions from '@pezkuwi/types-augment/lookup/definitions';
+import { stringCamelCase } from '@pezkuwi/util';
+
+import { compareName, createImports, formatType, initMeta, readTemplate, setImports, writeFile } from '../util/index.js';
+import { ignoreUnusedLookups } from './lookup.js';
+import { type ExtraTypes, getDeprecationNotice } from './types.js';
+
+const generateForMetaTemplate = Handlebars.compile(readTemplate('events'));
+
+// For babel itself we need some extra aliasing
+// Also avoid reserved words to prevent generating invalid TS
+// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#reserved_words
+const ALIAS = [
+  'symbol',
+  'break',
+  'case',
+  'catch',
+  'class',
+  'const',
+  'continue',
+  'debugger',
+  'default',
+  'delete',
+  'do',
+  'else',
+  'export',
+  'extends',
+  'false',
+  'finally',
+  'for',
+  'function',
+  'if',
+  'import',
+  'in',
+  'instanceof',
+  'new',
+  'null',
+  'return',
+  'static',
+  'super',
+  'switch',
+  'this',
+  'throw',
+  'true',
+  'try',
+  'typeof',
+  'var',
+  'void',
+  'while',
+  'with',
+  'yield'
+];
+
+/** @internal */
+function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {
+  writeFile(dest, (): string => {
+    const allTypes = {
+      '@pezkuwi/types-augment': {
+        lookup: {
+          ...lookupDefinitions,
+          ...customLookupDefinitions
+        }
+      },
+      '@pezkuwi/types/interfaces': defaultDefs,
+      ...extraTypes
+    };
+    const imports = createImports(allTypes);
+    const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
+      return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
+    }, {});
+    const { lookup, pallets, registry } = meta.asLatest;
+    const usedTypes = new Set<string>([]);
+    const modules = pallets
+      .filter(({ events }) => events.isSome)
+      .map((data) => {
+        const name = data.name;
+        const events = data.events.unwrap();
+        const deprecationInfo = events.deprecationInfo.toJSON();
+
+        return {
+          items: lookup.getSiType(events.type).def.asVariant.variants
+            .map(({ docs, fields, index, name }) => {
+              const rawStatus = deprecationInfo?.[index.toNumber()];
+
+              if (rawStatus) {
+                const deprecationVariantInfo: VariantDeprecationInfoV16 = meta.registry.createTypeUnsafe('VariantDeprecationInfoV16', [rawStatus]);
+                const deprecationNotice = getDeprecationNotice(deprecationVariantInfo, name.toString());
+                const notice = docs.length ? ['', deprecationNotice] : [deprecationNotice];
+
+                docs.push(...notice.map((text) => meta.registry.createType('Text', text)));
+              }
+
+              const args = fields
+                .map(({ type }) => lookup.getTypeDef(type))
+                .map((typeDef) => {
+                  const arg = typeDef.lookupName || formatType(registry, allDefs, typeDef, imports);
+
+                  // Add the type to the list of used types
+                  if (!(imports.primitiveTypes[arg])) {
+                    usedTypes.add(arg);
+                  }
+
+                  return arg;
+                });
+
+              const names = fields
+                .map(({ name }) => registry.lookup.sanitizeField(name)[0])
+                .filter((n): n is string => !!n);
+
+              setImports(allDefs, imports, args);
+
+              return {
+                docs,
+                name: name.toString(),
+                type: names.length !== 0 && names.length === args.length
+                  ? `[${names.map((n, i) => `${ALIAS.includes(n) ? `${n}_` : n}: ${args[i]}`).join(', ')}], { ${names.map((n, i) => `${n}: ${args[i]}`).join(', ')} }`
+                  : `[${args.join(', ')}]`
+              };
+            })
+            .sort(compareName),
+          name: stringCamelCase(name)
+        };
+      })
+      .sort(compareName);
+
+    // filter out the unused lookup types from imports
+    ignoreUnusedLookups([...usedTypes], imports);
+
+    return generateForMetaTemplate({
+      headerType: 'chain',
+      imports,
+      isStrict,
+      modules,
+      types: [
+        ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
+          file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
+          types: Object.keys(imports.localTypes[packagePath])
+        })),
+        {
+          file: '@pezkuwi/api-base/types',
+          types: ['ApiTypes', 'AugmentedEvent']
+        }
+      ]
+    });
+  });
+}
+
+// Call `generateForMeta()` with current static metadata
+/** @internal */
+export function generateDefaultEvents (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void {
+  const { metadata } = initMeta(data, extraTypes);
+
+  return generateForMeta(metadata, dest, extraTypes, isStrict, customLookupDefinitions);
+}

package/src/generate/index.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { generateDefaultConsts } from './consts.js';
+export { generateDefaultErrors } from './errors.js';
+export { generateDefaultEvents } from './events.js';
+export { generateDefaultInterface } from './interfaceRegistry.js';
+export { generateDefaultLookup } from './lookup.js';
+export { generateDefaultQuery } from './query.js';
+export { generateDefaultRpc } from './rpc.js';
+export { generateDefaultRuntime } from './runtime.js';
+export { generateDefaultTsDef } from './tsDef.js';
+export { generateDefaultTx } from './tx.js';

package/src/generate/interfaceRegistry.ts

@@ -0,0 +1,85 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ModuleTypes } from '../util/imports.js';
+
+import Handlebars from 'handlebars';
+
+import { Json, Raw } from '@pezkuwi/types/codec';
+import { TypeRegistry } from '@pezkuwi/types/create';
+import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
+import * as defaultPrimitives from '@pezkuwi/types/primitive';
+
+import { createImports, readTemplate, setImports, writeFile } from '../util/index.js';
+
+const primitiveClasses = {
+  ...defaultPrimitives,
+  Json,
+  Raw
+};
+
+const generateInterfaceTypesTemplate = Handlebars.compile(readTemplate('interfaceRegistry'));
+
+/** @internal */
+export function generateInterfaceTypes (importDefinitions: Record<string, Record<string, ModuleTypes>>, dest: string): void {
+  const registry = new TypeRegistry();
+
+  writeFile(dest, (): string => {
+    Object.entries(importDefinitions).reduce((acc, def) => Object.assign(acc, def), {});
+
+    const imports = createImports(importDefinitions);
+    const definitions = imports.definitions;
+    const items: string[] = [];
+
+    // first we create imports for our known classes from the API
+    Object
+      .keys(primitiveClasses)
+      .filter((name) => !name.includes('Generic'))
+      .forEach((primitiveName): void => {
+        setImports(definitions, imports, [primitiveName]);
+
+        items.push(primitiveName);
+      });
+
+    const existingTypes: Record<string, boolean> = {};
+
+    // ensure we have everything registered since we will get the definition
+    // form the available types (so any unknown should show after this)
+    Object.values(definitions).forEach(({ types }) => {
+      registry.register(types as Record<string, string>);
+    });
+
+    // create imports for everything that we have available
+    Object.values(definitions).forEach(({ types }) => {
+      setImports(definitions, imports, Object.keys(types));
+
+      const uniqueTypes = Object.keys(types).filter((type) => !existingTypes[type]);
+
+      uniqueTypes.forEach((type): void => {
+        existingTypes[type] = true;
+
+        items.push(type);
+      });
+    });
+
+    return generateInterfaceTypesTemplate({
+      headerType: 'defs',
+      imports,
+      items: items.sort((a, b) => a.localeCompare(b)),
+      types: [
+        ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
+          file: packagePath,
+          types: Object.keys(imports.localTypes[packagePath])
+        }))
+      ]
+    });
+  });
+}
+
+// Generate `packages/types/src/interfaceRegistry.ts`, the registry of all interfaces
+export function generateDefaultInterface (): void {
+  generateInterfaceTypes(
+    { '@pezkuwi/types/interfaces': defaultDefinitions },
+    'packages/types-augment/src/registry/interfaces.ts'
+  );
+}