@pezkuwi/typegen 16.5.5

package/src/generate/lookup.ts

@@ -0,0 +1,294 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { PortableType, SiLookupTypeId, SiPath, SiTypeParameter } from '@pezkuwi/types/interfaces';
+import type { PortableRegistry } from '@pezkuwi/types/metadata';
+import type { Registry } from '@pezkuwi/types/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { HexString } from '@pezkuwi/util/types';
+
+import Handlebars from 'handlebars';
+import path from 'node:path';
+
+import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
+import staticAhKusama from '@pezkuwi/types-support/metadata/v15/asset-hub-kusama-hex';
+import staticAhPolkadot from '@pezkuwi/types-support/metadata/v15/asset-hub-polkadot-hex';
+import staticKusama from '@pezkuwi/types-support/metadata/v15/kusama-hex';
+import staticPolkadot from '@pezkuwi/types-support/metadata/v15/polkadot-hex';
+import staticSubstrate from '@pezkuwi/types-support/metadata/v15/substrate-hex';
+import { isString, stringify } from '@pezkuwi/util';
+
+import { createImports, exportInterface, initMeta, readTemplate, type TypeImports, writeFile } from '../util/index.js';
+import { typeEncoders } from './tsDef.js';
+
+// Record<string, >
+interface ParsedDef {
+  _set: Record<string, number>;
+
+  [key: string]: string | Record<string, string> | Record<string, number>;
+}
+
+const WITH_TYPEDEF = false;
+
+const generateLookupDefsTmpl = Handlebars.compile(readTemplate('lookup/defs'));
+const generateLookupDefsNamedTmpl = Handlebars.compile(readTemplate('lookup/defs-named'));
+const generateLookupIndexTmpl = Handlebars.compile(readTemplate('lookup/index'));
+const generateLookupTypesTmpl = Handlebars.compile(readTemplate('lookup/types'));
+const generateRegistryTmpl = Handlebars.compile(readTemplate('interfaceRegistry'));
+
+function generateParamType (registry: Registry, { name, type }: SiTypeParameter): string {
+  if (type.isSome) {
+    const link = registry.lookup.types[type.unwrap().toNumber()];
+
+    if (link.type.path.length) {
+      return generateTypeDocs(registry, null, link.type.path, link.type.params);
+    }
+  }
+
+  return name.toString();
+}
+
+function generateTypeDocs (registry: Registry, id: SiLookupTypeId | null, path: SiPath, params: SiTypeParameter[]): string {
+  return `${id ? `${registry.createLookupType(id)}${path.length ? ': ' : ''}` : ''}${path.map((p) => p.toString()).join('::')}${params.length ? `<${params.map((p) => generateParamType(registry, p)).join(', ')}>` : ''}`;
+}
+
+function formatObject (lines: string[]): string[] {
+  const max = lines.length - 1;
+
+  return [
+    '{',
+    ...lines.map((l, index) =>
+      (l.endsWith(',') || l.endsWith('{') || index === max || lines[index + 1].endsWith('}') || lines[index + 1].endsWith('}'))
+        ? l
+        : `${l},`
+    ),
+    '}'
+  ];
+}
+
+function expandSet (parsed: Record<string, number>): string[] {
+  return formatObject(
+    Object.entries(parsed).reduce<string[]>((all, [k, v]) => {
+      all.push(`${k}: ${v}`);
+
+      return all;
+    }, [])
+  );
+}
+
+function expandObject (parsed: ParsedDef): string[] {
+  if (parsed._set) {
+    return expandSet(parsed._set);
+  }
+
+  return formatObject(
+    Object.entries(parsed).reduce<string[]>((all, [k, v]) => {
+      const inner = isString(v)
+        ? expandType(v)
+        : Array.isArray(v)
+          ? [`[${(v as string[]).map((e) => `'${e}'`).join(', ')}]`]
+          : expandObject(v as ParsedDef);
+
+      inner.forEach((l, index): void => {
+        all.push(`${
+          index === 0
+            ? `${k}: ${l}`
+            : `${l}`
+        }`);
+      });
+
+      return all;
+    }, [])
+  );
+}
+
+function expandType (encoded: string): string[] {
+  if (!encoded.startsWith('{')) {
+    return [`'${encoded}'`];
+  }
+
+  return expandObject(JSON.parse(encoded) as ParsedDef);
+}
+
+function expandDefToString ({ lookupNameRoot, type }: TypeDef, indent: number): string {
+  if (lookupNameRoot) {
+    return `'${lookupNameRoot}'`;
+  }
+
+  const lines = expandType(type);
+  let inc = 0;
+
+  return lines.map((l, index) => {
+    let r: string;
+
+    if (l.endsWith('{')) {
+      r = index === 0
+        ? l
+        : `${' '.padStart(indent + inc)}${l}`;
+      inc += 2;
+    } else {
+      if (l.endsWith('},') || l.endsWith('}')) {
+        inc -= 2;
+      }
+
+      r = index === 0
+        ? l
+        : `${' '.padStart(indent + inc)}${l}`;
+    }
+
+    return r;
+  }).join('\n');
+}
+
+function getFilteredTypes (lookup: PortableRegistry, exclude: string[] = []): [PortableType, TypeDef][] {
+  const named = lookup.types.filter(({ id }) => !!lookup.getTypeDef(id).lookupName);
+  const names = named.map(({ id }) => lookup.getName(id));
+
+  return named
+    .filter((_, index) =>
+      !names.some((n, iindex) =>
+        index > iindex &&
+        n === names[index]
+      )
+    )
+    .map((p): [PortableType, TypeDef] => [p, lookup.getTypeDef(p.id)])
+    .filter(([, typeDef]) => !exclude.includes(typeDef.lookupName || '<invalid>'));
+}
+
+function generateLookupDefs (registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath?: string): void {
+  writeFile(path.join(destDir, `${subPath || 'definitions'}.ts`), (): string => {
+    const all = filtered.map(([{ id, type: { params, path } }, typeDef]) => {
+      const typeLookup = registry.createLookupType(id);
+      const def = expandDefToString(typeDef, subPath ? 2 : 4);
+
+      return {
+        docs: [
+          generateTypeDocs(registry, id, path, params),
+          WITH_TYPEDEF
+            ? `@typeDef ${stringify(typeDef)}`
+            : null
+        ].filter((d): d is string => !!d),
+        type: { def, typeLookup, typeName: typeDef.lookupName }
+      };
+    });
+    const max = all.length - 1;
+
+    return (subPath ? generateLookupDefsNamedTmpl : generateLookupDefsTmpl)({
+      defs: all.map(({ docs, type }, i) => {
+        const { def, typeLookup, typeName } = type;
+
+        return {
+          defs: [
+            [typeName || typeLookup, `${def}${i !== max ? ',' : ''}`]
+          ].map(([n, t]) => `${n}: ${t}`),
+          docs
+        };
+      }),
+      headerType: 'defs'
+    });
+  });
+}
+
+function generateLookupTypes (registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath?: string): void {
+  const imports = {
+    ...createImports(
+      { '@pezkuwi/types/interfaces': defaultDefinitions },
+      { types: {} }
+    ),
+    interfaces: []
+  };
+  const items = filtered
+    .map(([, typeDef]) => {
+      typeDef.name = typeDef.lookupName;
+
+      return typeDef.lookupNameRoot && typeDef.lookupName
+        ? exportInterface(typeDef.lookupIndex, typeDef.lookupName, typeDef.lookupNameRoot)
+        : typeEncoders[typeDef.info](registry, imports.definitions, typeDef, imports);
+    })
+    .filter((t): t is string => !!t)
+    .map((t) => t.replace(/\nexport /, '\n'));
+
+  writeFile(path.join(destDir, `types${subPath ? `-${subPath}` : ''}.ts`), () => generateLookupTypesTmpl({
+    headerType: 'defs',
+    imports,
+    items: items.map((l) =>
+      l
+        .split('\n')
+        .map((l) => l.length ? `  ${l}` : '')
+        .join('\n')
+    ),
+    types: [
+      ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
+        file: packagePath,
+        types: Object.keys(imports.localTypes[packagePath])
+      }))
+    ]
+  }), true);
+  writeFile(path.join(destDir, 'index.ts'), () => generateLookupIndexTmpl({ headerType: 'defs' }), true);
+}
+
+function generateRegistry (_registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath: string): void {
+  writeFile(path.join(destDir, `${subPath}.ts`), (): string => {
+    const items = filtered
+      .map(([, { lookupName }]) => lookupName)
+      .filter((n): n is string => !!n)
+      .sort()
+      .reduce((all: string[], n) => all.includes(n) ? all : all.concat(n), []);
+    const imports = createImports({}, { types: {} });
+
+    imports.lookupTypes = items.reduce((all, n) => ({ ...all, [n]: true }), {});
+
+    return generateRegistryTmpl({
+      headerType: 'defs',
+      imports,
+      items,
+      types: []
+    });
+  }, true);
+}
+
+function generateLookup (destDir: string, entries: [string, HexString][]): void {
+  entries.reduce<string[]>((exclude, [subPath, staticMeta]): string[] => {
+    const { lookup, registry } = initMeta(staticMeta).metadata.asLatest;
+    const filtered = getFilteredTypes(lookup, exclude);
+
+    generateLookupDefs(registry, filtered, destDir, subPath);
+    generateLookupTypes(registry, filtered, destDir, subPath);
+    generateRegistry(registry, filtered, destDir, subPath === 'lookup' ? 'registry' : `../registry/${subPath}`);
+
+    return exclude.concat(
+      ...filtered
+        .map(([, typeDef]) => typeDef.lookupName)
+        .filter((n): n is string => !!n)
+    );
+  }, []);
+}
+
+// Generate `packages/types/src/lookup/*s`, the registry of all lookup types
+export function generateDefaultLookup (destDir = 'packages/types-augment/src/lookup', staticData?: HexString): void {
+  generateLookup(
+    destDir,
+    staticData
+      ? [['lookup', staticData]]
+      : [
+        ['substrate', staticSubstrate],
+        ['polkadot', staticPolkadot],
+        ['kusama', staticKusama],
+        ['assetHubPolkadot', staticAhPolkadot],
+        ['assetHubKusama', staticAhKusama]
+      ]
+  );
+}
+
+// Based on a list of types, it filters out the lookup types that are not needed.
+export function ignoreUnusedLookups (usedTypes: string[], imports: TypeImports) {
+  const usedStringified = usedTypes.toString();
+
+  const [lookupKey, typeDefinitions] = Object.entries(imports.localTypes).find(([typeModule, _]) => typeModule.includes('/lookup')) || ['', {}];
+
+  Object.keys(typeDefinitions).forEach((typeDef) => {
+    if (!(usedStringified.includes(typeDef))) {
+      delete (imports.localTypes[lookupKey])[typeDef];
+    }
+  });
+}

package/src/generate/query.ts

@@ -0,0 +1,169 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { StorageEntryMetadataLatest } from '@pezkuwi/types/interfaces';
+import type { Metadata, PortableRegistry } from '@pezkuwi/types/metadata';
+import type { Definitions, Registry } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { ModuleTypes, TypeImports } from '../util/imports.js';
+
+import Handlebars from 'handlebars';
+
+import * as defaultDefs from '@pezkuwi/types/interfaces/definitions';
+import { unwrapStorageSi } from '@pezkuwi/types/util';
+import lookupDefinitions from '@pezkuwi/types-augment/lookup/definitions';
+import { stringCamelCase } from '@pezkuwi/util';
+
+import { compareName, createImports, formatType, getSimilarTypes, 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('query'));
+
+// From a storage entry metadata, we return [args, returnType]
+/** @internal */
+function entrySignature (lookup: PortableRegistry, allDefs: Record<string, ModuleTypes>, registry: Registry, section: string, storageEntry: StorageEntryMetadataLatest, imports: TypeImports): [boolean, string, string, string] {
+  try {
+    const outputType = lookup.getTypeDef(unwrapStorageSi(storageEntry.type));
+
+    if (storageEntry.type.isPlain) {
+      const typeDef = lookup.getTypeDef(storageEntry.type.asPlain);
+
+      setImports(allDefs, imports, [
+        typeDef.lookupName || typeDef.type,
+        storageEntry.modifier.isOptional
+          ? 'Option'
+          : null
+      ]);
+
+      return [storageEntry.modifier.isOptional, '', '', formatType(registry, allDefs, outputType, imports)];
+    } else if (storageEntry.type.isMap) {
+      const { hashers, key, value } = storageEntry.type.asMap;
+      const keyDefs = hashers.length === 1
+        ? [lookup.getTypeDef(key)]
+        : lookup.getSiType(key).def.asTuple.map((k) => lookup.getTypeDef(k));
+      const similarTypes = keyDefs.map((k) => getSimilarTypes(registry, allDefs, k.lookupName || k.type, imports));
+      const keyTypes = similarTypes.map((t) => t.join(' | '));
+      const defValue = lookup.getTypeDef(value);
+
+      setImports(allDefs, imports, [
+        ...similarTypes.reduce<string[]>((all, t) => all.concat(t), []),
+        storageEntry.modifier.isOptional
+          ? 'Option'
+          : null,
+        defValue.lookupName || defValue.type
+      ]);
+
+      return [
+        storageEntry.modifier.isOptional,
+        keyDefs.map((k) => formatType(registry, allDefs, k.lookupName || k.type, imports)).join(', '),
+        keyTypes.map((t, i) => `arg${keyTypes.length === 1 ? '' : (i + 1)}: ${t}`).join(', '),
+        outputType.lookupName || formatType(registry, allDefs, outputType, imports)
+      ];
+    }
+
+    throw new Error(`Expected Plain or Map type, found ${storageEntry.type.type}`);
+  } catch (error) {
+    throw new Error(`entrySignature: Cannot create signature for query ${section}.${storageEntry.name.toString()}:: ${(error as Error).message}`);
+  }
+}
+
+/** @internal */
+function generateForMeta (registry: Registry, meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {
+  writeFile(dest, (): string => {
+    const allTypes: ExtraTypes = {
+      '@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 } = meta.asLatest;
+    const usedTypes = new Set<string>([]);
+    const modules = pallets
+      .filter(({ storage }) => storage.isSome)
+      .map(({ name, storage }) => {
+        const items = storage.unwrap().items
+          .map((storageEntry) => {
+            const { deprecationInfo, docs, name } = storageEntry;
+            const [isOptional, args, params, _returnType] = entrySignature(lookup, allDefs, registry, name.toString(), storageEntry, imports);
+
+            if (!deprecationInfo.isNotDeprecated) {
+              const deprecationNotice = getDeprecationNotice(deprecationInfo, stringCamelCase(name));
+              const items = docs.length
+                ? ['', deprecationNotice]
+                : [deprecationNotice];
+
+              docs.push(...items.map((text) => registry.createType('Text', text)));
+            }
+
+            // Add the type and args to the list of used types
+            if (!(imports.primitiveTypes[_returnType])) {
+              usedTypes.add(_returnType);
+            }
+
+            if (!(imports.primitiveTypes[args])) {
+              usedTypes.add(args);
+            }
+
+            const returnType = isOptional
+              ? `Option<${_returnType}>`
+              : _returnType;
+
+            return {
+              args,
+              docs,
+              entryType: 'AugmentedQuery',
+              name: stringCamelCase(storageEntry.name),
+              params,
+              returnType
+            };
+          })
+          .sort(compareName);
+
+        return {
+          items,
+          name: stringCamelCase(name)
+        };
+      })
+      .sort(compareName);
+
+    imports.typesTypes['Observable'] = true;
+
+    // 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', 'AugmentedQuery', 'QueryableStorageEntry']
+        }
+      ]
+    });
+  });
+}
+
+// Call `generateForMeta()` with current static metadata
+/** @internal */
+export function generateDefaultQuery (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void {
+  const { metadata, registry } = initMeta(data, extraTypes);
+
+  return generateForMeta(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions);
+}

package/src/generate/rpc.ts

@@ -0,0 +1,158 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { TypeRegistry } from '@pezkuwi/types/create';
+import type { Definitions } from '@pezkuwi/types/types';
+import type { ExtraTypes } from './types.js';
+
+import Handlebars from 'handlebars';
+
+import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
+import staticSubstrate from '@pezkuwi/types-support/metadata/static-substrate';
+
+import { createImports, formatType, getSimilarTypes, initMeta, readTemplate, setImports, writeFile } from '../util/index.js';
+
+interface ItemDef {
+  args: string;
+  docs: string[];
+  generic: string | undefined;
+  name: string;
+  type: string | undefined;
+}
+
+interface ModuleDef {
+  items: ItemDef[];
+  name: string;
+}
+
+const StorageKeyType = 'StorageKey | string | Uint8Array | any';
+
+const generateRpcTypesTemplate = Handlebars.compile(readTemplate('rpc'));
+
+/** @internal */
+export function generateRpcTypes (registry: TypeRegistry, importDefinitions: Record<string, Definitions>, dest: string, extraTypes: ExtraTypes): void {
+  writeFile(dest, (): string => {
+    const allTypes: ExtraTypes = { '@pezkuwi/types/interfaces': importDefinitions, ...extraTypes };
+    const imports = createImports(allTypes);
+    const definitions = imports.definitions as Record<string, Definitions>;
+    const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
+      return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
+    }, {});
+
+    const rpcKeys = Object
+      .keys(definitions)
+      .filter((key) => Object.keys(definitions[key].rpc || {}).length !== 0)
+      .sort();
+
+    const additional: Record<string, ModuleDef> = {};
+    const modules = rpcKeys.map((sectionFullName) => {
+      const rpc = definitions[sectionFullName].rpc || {};
+      const section = sectionFullName.split('/').pop();
+
+      const allMethods = Object.keys(rpc).sort().map((methodName) => {
+        const def = rpc[methodName];
+
+        let args;
+        let type;
+        let generic;
+
+        // These are too hard to type with generics, do manual overrides
+        if (section === 'state') {
+          setImports(allDefs, imports, ['Codec', 'Hash', 'StorageKey', 'Vec']);
+
+          if (methodName === 'getStorage') {
+            generic = 'T = Codec';
+            args = [`key: ${StorageKeyType}, block?: Hash | Uint8Array | string`];
+            type = 'T';
+          } else if (methodName === 'queryStorage') {
+            generic = 'T = Codec[]';
+            args = [`keys: Vec<StorageKey> | (${StorageKeyType})[], fromBlock?: Hash | Uint8Array | string, toBlock?: Hash | Uint8Array | string`];
+            type = '[Hash, T][]';
+          } else if (methodName === 'queryStorageAt') {
+            generic = 'T = Codec[]';
+            args = [`keys: Vec<StorageKey> | (${StorageKeyType})[], at?: Hash | Uint8Array | string`];
+            type = 'T';
+          } else if (methodName === 'subscribeStorage') {
+            generic = 'T = Codec[]';
+            args = [`keys?: Vec<StorageKey> | (${StorageKeyType})[]`];
+            type = 'T';
+          }
+        }
+
+        if (args === undefined) {
+          setImports(allDefs, imports, [def.type]);
+
+          args = def.params.map((param) => {
+            const similarTypes = getSimilarTypes(registry, definitions, param.type, imports);
+
+            setImports(allDefs, imports, [param.type, ...similarTypes]);
+
+            return `${param.name}${param.isOptional ? '?' : ''}: ${similarTypes.join(' | ')}`;
+          });
+
+          type = formatType(registry, allDefs, def.type, imports);
+          generic = '';
+        }
+
+        const item = {
+          args: args.join(', '),
+          docs: def.deprecated
+            ? [`@deprecated ${def.deprecated}`, def.description]
+            : [def.description],
+          generic,
+          name: methodName,
+          type
+        };
+
+        if (def.aliasSection) {
+          if (!additional[def.aliasSection]) {
+            additional[def.aliasSection] = {
+              items: [],
+              name: def.aliasSection
+            };
+          }
+
+          additional[def.aliasSection].items.push(item);
+
+          return null;
+        }
+
+        return item;
+      }).filter((item): item is ItemDef => !!item);
+
+      return {
+        items: allMethods,
+        name: section || 'unknown'
+      };
+    }).concat(...Object.values(additional)).sort((a, b) => a.name.localeCompare(b.name));
+
+    imports.typesTypes['Observable'] = true;
+
+    return generateRpcTypesTemplate({
+      headerType: 'chain',
+      imports,
+      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/rpc-core/types',
+          types: ['AugmentedRpc']
+        }
+      ]
+    });
+  });
+}
+
+export function generateDefaultRpc (dest = 'packages/rpc-augment/src/augment/jsonrpc.ts', extraTypes: ExtraTypes = {}): void {
+  const { registry } = initMeta(staticSubstrate, extraTypes);
+
+  generateRpcTypes(
+    registry,
+    defaultDefinitions,
+    dest,
+    extraTypes
+  );
+}