@pezkuwi/typegen 16.5.16 → 16.5.18

package/src/generate/query.ts

@@ -0,0 +1,169 @@
+// Copyright 2017-2025 @pezkuwi/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, rebrandTypeName, 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, [
+        rebrandTypeName(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,
+        rebrandTypeName(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(', '),
+        rebrandTypeName(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 @pezkuwi/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 staticBizinikiwi from '@pezkuwi/types-support/metadata/static-bizinikiwi';
+
+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(staticBizinikiwi, extraTypes);
+
+  generateRpcTypes(
+    registry,
+    defaultDefinitions,
+    dest,
+    extraTypes
+  );
+}

package/src/generate/runtime.ts

@@ -0,0 +1,293 @@
+// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { RuntimeApiMethodMetadataV16, SiLookupTypeId } from '@pezkuwi/types/interfaces';
+import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
+import type { DefinitionCall, DefinitionCallNamed, Definitions, DefinitionsCall, Registry } from '@pezkuwi/types/types';
+import type { Vec } from '@pezkuwi/types-codec';
+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 { objectSpread, stringCamelCase } from '@pezkuwi/util';
+import { blake2AsHex } from '@pezkuwi/util-crypto';
+
+import { createImports, formatType, getSimilarTypes, initMeta, readTemplate, rebrandTypeName, setImports, writeFile } from '../util/index.js';
+import { type ExtraTypes, getDeprecationNotice } from './types.js';
+
+type Apis = [HexString, number][];
+
+const generateCallsTypesTemplate = Handlebars.compile(readTemplate('calls'));
+
+// This works similar to the PATHS_ALIAS set from the PortableRegistry
+const aliases: Record<string, string> = {
+  AssetHubZagrosRuntimeRuntimeCall: 'RuntimeCall',
+  AssetHubPezkuwiRuntimeRuntimeCall: 'RuntimeCall',
+  AssetHubDicleRuntimeOriginCaller: 'OriginCaller',
+  AssetHubDicleRuntimeRuntimeCall: 'RuntimeCall',
+  DicleRuntimeConstantsProxyProxyType: 'ProxyType',
+  KitchensinkRuntimeRuntimeCall: 'RuntimeCall',
+  KitchensinkRuntimeRuntimeParametersKey: 'RuntimeParametersKey',
+  OpaqueValue: 'Bytes',
+  PezkuwiTeyrchainPrimitivesPrimitivesId: 'ParaId',
+  PezkuwiTeyrchainPrimitivesPrimitivesValidationCodeHash: 'ValidationCodeHash',
+  PezkuwiPrimitivesV7SlashingOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
+  PezkuwiPrimitivesV8SlashingOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
+  PezkuwiRuntimeRuntimeCall: 'RuntimeCall',
+  PrimitiveTypesH160: 'H160',
+  PrimitiveTypesH256: 'H256',
+  PrimitiveTypesU256: 'U256',
+  PezspConsensusBabeOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
+  PezspConsensusSlotsSlot: 'Slot',
+  PezspConsensusSlotsSlotDuration: 'SlotDuration',
+  PezspCoreCryptoAccountId32: 'AccountId32',
+  PezspCoreOpaqueMetadata: 'OpaqueMetadata',
+  PezspRuntimeOpaqueValue: 'Bytes',
+  PezspRuntimeUncheckedExtrinsic: 'Extrinsic',
+  StagingDicleRuntimeOriginCaller: 'OriginCaller',
+  StagingDicleRuntimeRuntimeCall: 'RuntimeCall',
+  StagingDicleRuntimeRuntimeParameters: 'RuntimeParameters',
+  StagingDicleRuntimeRuntimeParametersKey: 'RuntimeParametersKey',
+  StagingZagrosRuntimeRuntimeCall: 'RuntimeCall'
+};
+
+const getTypesViaAlias = (registry: Registry, id: SiLookupTypeId) => {
+  const rawTypeName = registry.lookup.getName(id) || registry.lookup.getTypeDef(id).type;
+  const typeName = rebrandTypeName(rawTypeName);
+
+  if (aliases[typeName]) {
+    return aliases[typeName];
+  }
+
+  return typeName;
+};
+
+/** @internal */
+function getMethods (registry: Registry, methods: Vec<RuntimeApiMethodMetadataV16>) {
+  const result: Record<string, DefinitionCall> = {};
+
+  methods.forEach((m) => {
+    const { deprecationInfo, docs, inputs, name, output } = m;
+    let description = docs.map((d) => d.toString()).join();
+
+    if (!deprecationInfo.isNotDeprecated) {
+      const deprecationNotice = getDeprecationNotice(deprecationInfo, stringCamelCase(name));
+      const notice = description.length ? `\n * ${deprecationNotice}` : ` * ${deprecationNotice}`;
+
+      description += notice;
+    }
+
+    result[name.toString()] = {
+      description,
+      params: inputs.map(({ name, type }) => {
+        return { name: name.toString(), type: getTypesViaAlias(registry, type) };
+      }),
+      type: getTypesViaAlias(registry, output)
+    };
+  });
+
+  return result;
+}
+
+/** @internal */
+function getRuntimeDefViaMetadata (registry: Registry) {
+  const result: DefinitionsCall = {};
+  const { apis } = registry.metadata;
+
+  for (let i = 0, count = apis.length; i < count; i++) {
+    const { methods, name } = apis[i];
+
+    result[name.toString()] = [{
+      methods: getMethods(registry, methods),
+      // We set the version to 0 here since it will not be relevant when we are grabbing the runtime apis
+      // from the Metadata.
+      version: 0
+    }];
+  }
+
+  return Object.entries(result);
+}
+
+/** @internal */
+function getDefs (apis: Apis | null, defs: Record<string, Definitions>, registry: Registry): Record<string, Record<string, DefinitionCallNamed>> {
+  const named: Record<string, Record<string, DefinitionCallNamed>> = {};
+  const all = Object.values(defs);
+  const isApiInMetadata = registry.metadata.apis.length > 0;
+
+  if (isApiInMetadata) {
+    const sections = getRuntimeDefViaMetadata(registry);
+
+    for (let j = 0, jcount = sections.length; j < jcount; j++) {
+      const [_section, secs] = sections[j];
+      const sec = secs[0];
+      const sectionHash = blake2AsHex(_section, 64);
+
+      const section = stringCamelCase(_section);
+      const methods = Object.entries(sec.methods);
+
+      if (!named[section]) {
+        named[section] = {};
+      }
+
+      for (let m = 0, mcount = methods.length; m < mcount; m++) {
+        const [_method, def] = methods[m];
+        const method = stringCamelCase(_method);
+
+        named[section][method] = objectSpread({ method, name: `${_section}_${_method}`, section, sectionHash }, def);
+      }
+    }
+  } else {
+    for (let j = 0, jcount = all.length; j < jcount; j++) {
+      const set = all[j].runtime;
+
+      if (set) {
+        const sections = Object.entries(set);
+
+        for (let i = 0, scount = sections.length; i < scount; i++) {
+          const [_section, sec] = sections[i];
+          const sectionHash = blake2AsHex(_section, 64);
+          const api = apis?.find(([h]) => h === sectionHash);
+
+          if (api) {
+            const ver = sec.find(({ version }) => version === api[1]);
+
+            if (ver) {
+              const methods = Object.entries(ver.methods);
+              const mcount = methods.length;
+
+              if (mcount) {
+                const section = stringCamelCase(_section);
+
+                if (!named[section]) {
+                  named[section] = {};
+                }
+
+                for (let m = 0; m < mcount; m++) {
+                  const [_method, def] = methods[m];
+                  const method = stringCamelCase(_method);
+
+                  named[section][method] = objectSpread({ method, name: `${_section}_${method}`, section, sectionHash, version: ver.version }, def);
+                }
+              }
+            } else {
+              console.warn(`Unable to find matching version for runtime ${_section}, expected ${api[1]}`);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return named;
+}
+
+/** @internal */
+export function generateCallTypes (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);
+
+    // find the system.Version in metadata
+    let apis: Apis | null = null;
+    const sysp = meta.asLatest.pallets.find(({ name }) => name.eq('System'));
+
+    if (sysp) {
+      const verc = sysp.constants.find(({ name }) => name.eq('Version'));
+
+      if (verc) {
+        apis = registry.createType('RuntimeVersion', verc.value).apis.map(([k, v]): [HexString, number] => [k.toHex(), v.toNumber()]);
+      } else {
+        console.error('Unable to find System.Version pallet, skipping API extraction');
+      }
+    } else {
+      console.error('Unable to find System pallet, skipping API extraction');
+    }
+
+    const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
+      return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
+    }, {});
+    const definitions = getDefs(apis, imports.definitions as Record<string, Definitions>, registry);
+    const callKeys = Object.keys(definitions);
+
+    const modules = callKeys.map((section) => {
+      const calls = definitions[section];
+
+      const allMethods = Object.keys(calls).sort().map((methodName) => {
+        const def = calls[methodName];
+
+        setImports(allDefs, imports, [def.type]);
+
+        const args = def.params.map((param) => {
+          const similarTypes = getSimilarTypes(registry, imports.definitions, param.type, imports);
+
+          setImports(allDefs, imports, [param.type, ...similarTypes]);
+
+          return `${param.name}: ${similarTypes.join(' | ')}`;
+        });
+
+        return {
+          args: args.join(', '),
+          docs: [def.description],
+          name: methodName,
+          sectionHash: def.sectionHash,
+          sectionName: def.section,
+          sectionVersion: def.version,
+          type: formatType(registry, allDefs, def.type, imports)
+        };
+      }).sort((a, b) => a.name.localeCompare(b.name));
+
+      return {
+        items: allMethods,
+        name: section || 'unknown',
+        sectionHash: allMethods.length && allMethods[0].sectionHash,
+        sectionName: allMethods.length && allMethods[0].sectionName,
+        sectionVersion: allMethods.length && allMethods[0].sectionVersion
+      };
+    }).filter(({ items }) => items.length).sort((a, b) => a.name.localeCompare(b.name));
+
+    if (modules.length) {
+      imports.typesTypes['Observable'] = true;
+    }
+
+    return generateCallsTypesTemplate({
+      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', 'AugmentedCall', 'DecoratedCallBase']
+        }
+      ]
+    });
+  });
+}
+
+export function generateDefaultRuntime (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void {
+  const { metadata, registry } = initMeta(data, extraTypes);
+
+  generateCallTypes(
+    registry,
+    metadata,
+    dest,
+    extraTypes,
+    isStrict,
+    customLookupDefinitions
+  );
+}