@pezkuwi/typegen 16.5.5

package/src/packageDetect.ts

@@ -0,0 +1,14 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+// (packageInfo imports will be kept as-is, user-editable)
+
+import { packageInfo as apiInfo } from '@pezkuwi/api/packageInfo';
+import { packageInfo as providerInfo } from '@pezkuwi/rpc-provider/packageInfo';
+import { packageInfo as typesInfo } from '@pezkuwi/types/packageInfo';
+import { detectPackage } from '@pezkuwi/util';
+
+import { packageInfo } from './packageInfo.js';
+
+detectPackage(packageInfo, null, [apiInfo, providerInfo, typesInfo]);

package/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+export const packageInfo = { name: '@pezkuwi/typegen', path: 'auto', type: 'auto', version: '16.5.5' };

package/src/templates/calls.hbs

@@ -0,0 +1,30 @@
+{{> header }}
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/api-base/types/calls';
+
+{{{ importsAll }}}
+
+export type __AugmentedCall<ApiType extends ApiTypes> = AugmentedCall<ApiType>;
+export type __DecoratedCallBase<ApiType extends ApiTypes> = DecoratedCallBase<ApiType>;
+
+declare module '@polkadot/api-base/types/calls' {
+  interface AugmentedCalls<ApiType extends ApiTypes> {
+    {{#each modules}}
+    /** {{{sectionHash}}}/{{{sectionVersion}}} */
+    {{{name}}}: {
+      {{#each items}}
+      {{> docs}}
+      {{{name}}}: AugmentedCall<ApiType, ({{{args}}}) => Observable<{{{type}}}>>;
+      {{/each}}
+      {{#unless @root.isStrict}}
+      /**
+       * Generic call
+       **/
+      [key: string]: DecoratedCallBase<ApiType>;
+      {{/unless}}
+    };
+    {{/each}}
+  } // AugmentedCalls
+} // declare module

package/src/templates/consts.hbs

@@ -0,0 +1,28 @@
+{{> header }}
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/api-base/types/consts';
+
+{{{ importsAll }}}
+
+export type __AugmentedConst<ApiType extends ApiTypes> = AugmentedConst<ApiType>;
+
+declare module '@polkadot/api-base/types/consts' {
+  interface AugmentedConsts<ApiType extends ApiTypes> {
+    {{#each modules}}
+    {{{name}}}: {
+      {{#each items}}
+      {{> docs}}
+      {{{name}}}: {{{type}}} & AugmentedConst<ApiType>;
+      {{/each}}
+      {{#unless @root.isStrict}}
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+      {{/unless}}
+    };
+    {{/each}}
+  } // AugmentedConsts
+} // declare module

package/src/templates/docs.hbs

@@ -0,0 +1,7 @@
+{{#if docs.length}}
+/**
+{{#each docs}}
+ * {{#trim}}{{{this}}}{{/trim}}
+{{/each}}
+ **/
+{{/if}}

package/src/templates/errors.hbs

@@ -0,0 +1,28 @@
+{{> header }}
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/api-base/types/errors';
+
+{{{ importsAll }}}
+
+export type __AugmentedError<ApiType extends ApiTypes> = AugmentedError<ApiType>;
+
+declare module '@polkadot/api-base/types/errors' {
+  interface AugmentedErrors<ApiType extends ApiTypes> {
+    {{#each modules}}
+    {{{name}}}: {
+      {{#each items}}
+      {{> docs}}
+      {{{name}}}: AugmentedError<ApiType>;
+      {{/each}}
+      {{#unless @root.isStrict}}
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+      {{/unless}}
+    };
+    {{/each}}
+  } // AugmentedErrors
+} // declare module

package/src/templates/events.hbs

@@ -0,0 +1,28 @@
+{{> header }}
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/api-base/types/events';
+
+{{{ importsAll }}}
+
+export type __AugmentedEvent<ApiType extends ApiTypes> = AugmentedEvent<ApiType>;
+
+declare module '@polkadot/api-base/types/events' {
+  interface AugmentedEvents<ApiType extends ApiTypes> {
+    {{#each modules}}
+    {{{name}}}: {
+      {{#each items}}
+      {{> docs}}
+      {{{name}}}: AugmentedEvent<ApiType, {{{type}}}>;
+      {{/each}}
+      {{#unless @root.isStrict}}
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+      {{/unless}}
+    };
+    {{/each}}
+  } // AugmentedEvents
+} // declare module

package/src/templates/header.hbs

@@ -0,0 +1,2 @@
+// Auto-generated via `yarn polkadot-types-from-{{headerType}}`, do not edit
+/* eslint-disable */

package/src/templates/interfaceRegistry.hbs

@@ -0,0 +1,15 @@
+{{> header }}
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/types/types/registry';
+
+{{{ importsAll }}}
+
+declare module '@polkadot/types/types/registry' {
+  interface InterfaceTypes {
+    {{#each items}}
+    {{{this}}}: {{{this}}};
+    {{/each}}
+  } // InterfaceTypes
+} // declare module

package/src/templates/lookup/defs-named.hbs

@@ -0,0 +1,12 @@
+{{> header }}
+
+/* eslint-disable sort-keys */
+
+export default {
+  {{#each defs}}
+  {{> docs}}
+  {{#each defs}}
+  {{{this}}}
+  {{/each}}
+  {{/each}}
+};

package/src/templates/lookup/defs.hbs

@@ -0,0 +1,15 @@
+{{> header }}
+
+/* eslint-disable sort-keys */
+
+export default {
+  rpc: {},
+  types: {
+    {{#each defs}}
+    {{> docs}}
+    {{#each defs}}
+    {{{this}}}
+    {{/each}}
+    {{/each}}
+  }
+};

package/src/templates/lookup/index.hbs

@@ -0,0 +1,3 @@
+{{> header }}
+
+export * from './types.js';

package/src/templates/lookup/types.hbs

@@ -0,0 +1,14 @@
+{{> header }}
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/types/lookup';
+
+{{{ importsAll }}}
+
+declare module '@polkadot/types/lookup' {
+  {{#each items}}
+{{{this}}}
+
+  {{/each}}
+} // declare module

package/src/templates/query.hbs

@@ -0,0 +1,29 @@
+{{> header }}
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/api-base/types/storage';
+
+{{{ importsAll }}}
+
+export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;
+export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;
+
+declare module '@polkadot/api-base/types/storage' {
+  interface AugmentedQueries<ApiType extends ApiTypes> {
+    {{#each modules}}
+    {{{name}}}: {
+      {{#each items}}
+      {{> docs}}
+      {{{name}}}: {{{entryType}}}<ApiType, ({{{params}}}) => Observable<{{{returnType}}}>, [{{{args}}}]>{{#unless @root.isStrict}} & QueryableStorageEntry<ApiType, [{{{args}}}]>{{/unless}};
+      {{/each}}
+      {{#unless @root.isStrict}}
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+      {{/unless}}
+    };
+    {{/each}}
+  } // AugmentedQueries
+} // declare module

package/src/templates/rpc.hbs

@@ -0,0 +1,22 @@
+{{> header }}
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/rpc-core/types/jsonrpc';
+
+{{{ importsAll }}}
+
+export type __AugmentedRpc = AugmentedRpc<() => unknown>;
+
+declare module '@polkadot/rpc-core/types/jsonrpc' {
+  interface RpcInterface {
+    {{#each modules}}
+    {{{name}}}: {
+      {{#each items}}
+      {{> docs}}
+      {{{name}}}: AugmentedRpc<{{#if generic}}<{{{generic}}}>{{/if}}({{{args}}}) => Observable<{{{type}}}>>;
+      {{/each}}
+    };
+    {{/each}}
+  } // RpcInterface
+} // declare module

package/src/templates/tsDef/index.hbs

@@ -0,0 +1,3 @@
+{{> header }}
+
+export * from './types.js';

package/src/templates/tsDef/moduleTypes.hbs

@@ -0,0 +1,10 @@
+{{> header }}
+
+{{{ importsAll }}}
+
+{{#each items}}
+{{{this}}}
+
+{{/each}}
+
+export type PHANTOM_{{#upper}}{{{name}}}{{/upper}} = '{{{name}}}';

package/src/templates/tsDef/types.hbs

@@ -0,0 +1,7 @@
+{{> header }}
+
+{{#each items}}
+export * from './{{{this}}}/types.js';
+{{/each}}
+
+export type PHANTOM_GENERATED = 'generated';

package/src/templates/tx.hbs

@@ -0,0 +1,30 @@
+{{> header }}
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/api-base/types/submittable';
+
+{{{ importsAll }}}
+
+export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;
+export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;
+export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;
+
+declare module '@polkadot/api-base/types/submittable' {
+  interface AugmentedSubmittables<ApiType extends ApiTypes> {
+    {{#each modules}}
+    {{{name}}}: {
+      {{#each items}}
+      {{> docs}}
+      {{{name}}}: AugmentedSubmittable<({{{params}}}) => SubmittableExtrinsic<ApiType>, [{{{args}}}]>;
+      {{/each}}
+      {{#unless @root.isStrict}}
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
+      {{/unless}}
+    };
+    {{/each}}
+  } // AugmentedSubmittables
+} // declare module

package/src/util/assert.ts

@@ -0,0 +1,18 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import fs from 'node:fs';
+
+import { assert } from '@pezkuwi/util';
+
+export function assertDir (path: string): string {
+  assert(fs.existsSync(path) && fs.lstatSync(path).isDirectory(), `${path} is not a directory`);
+
+  return path;
+}
+
+export function assertFile (path: string): string {
+  assert(fs.existsSync(path) && fs.lstatSync(path).isFile(), `${path} is not a file`);
+
+  return path;
+}

package/src/util/derived.spec.ts

@@ -0,0 +1,58 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '@pezkuwi/types/create';
+
+import { getSimilarTypes } from './derived.js';
+
+describe('getSimilarTypes', (): void => {
+  const registry = new TypeRegistry();
+  const mockImports = {
+    codecTypes: {},
+    definitions: {},
+    extrinsicTypes: {},
+    genericTypes: {},
+    ignoredTypes: [],
+    localTypes: {},
+    lookupTypes: {},
+    metadataTypes: {},
+    primitiveTypes: {},
+    typeToModule: {},
+    typesTypes: {}
+  };
+
+  it('handles nested Tuples', (): void => {
+    expect(getSimilarTypes(registry, {}, '(AccountId, (Balance, u32), u64)', mockImports)).toEqual([
+      'ITuple<[AccountId, ITuple<[Balance, u32]>, u64]>',
+      '[AccountId | string | Uint8Array, ITuple<[Balance, u32]> | [Balance | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], u64 | AnyNumber | Uint8Array]'
+    ]);
+  });
+
+  it('handles vectors of slices', (): void => {
+    expect(getSimilarTypes(registry, {}, 'Vec<[u8;4]>', mockImports)).toEqual([
+      'Vec<U8aFixed>'
+    ]);
+    expect(getSimilarTypes(registry, {}, 'Vec<[Balance;8]>', mockImports)).toEqual([
+      'Vec<Vec<Balance>>'
+    ]);
+  });
+
+  it('handles structs', (): void => {
+    expect(getSimilarTypes(registry, {}, '{ "a": "u8", "b": "Vec<u8>" }', mockImports)).toEqual([
+      `{
+    readonly a: u8;
+    readonly b: Bytes;
+  } & Struct`, '{ a?: any; b?: any }', 'string', 'Uint8Array'
+    ]);
+  });
+  it('handles vectors of structs', (): void => {
+    expect(getSimilarTypes(registry, {}, 'Vec<{ "a": "H256", "b": "Vec<H256>" }>', mockImports)).toEqual([
+      `Vec<{
+    readonly a: H256;
+    readonly b: Vec<H256>;
+  } & Struct>`
+    ]);
+  });
+});

package/src/util/derived.ts

@@ -0,0 +1,133 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { CodecClass, Registry } from '@pezkuwi/types/types';
+import type { UInt } from '@pezkuwi/types-codec';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { ModuleTypes, TypeImports } from './imports.js';
+
+import { GenericAccountId, GenericCall, GenericLookupSource, GenericVote } from '@pezkuwi/types/generic';
+import { AllConvictions } from '@pezkuwi/types/interfaces/democracy/definitions';
+import { AbstractInt, bool, Compact, Enum, Null, Option, Struct, Tuple, Vec, WrapperKeepOpaque, WrapperOpaque } from '@pezkuwi/types-codec';
+import { getTypeDef, TypeDefInfo } from '@pezkuwi/types-create';
+import { isChildClass, stringify } from '@pezkuwi/util';
+
+import { formatType } from './formatting.js';
+import { setImports } from './imports.js';
+
+function arrayToStrType (arr: string[]): string {
+  return `${arr.map((c) => `'${c}'`).join(' | ')}`;
+}
+
+const voteConvictions = arrayToStrType(AllConvictions);
+
+// Make types a little bit more flexible
+// - if param instanceof AbstractInt, then param: u64 | Uint8array | AnyNumber
+// etc
+/** @internal */
+export function getSimilarTypes (registry: Registry, definitions: Record<string, ModuleTypes>, _type: string, imports: TypeImports): string[] {
+  const typeParts = _type.split('::');
+  const type = typeParts[typeParts.length - 1];
+  const possibleTypes = [formatType(registry, definitions, type, imports)];
+
+  if (type === 'Extrinsic') {
+    setImports(definitions, imports, ['IExtrinsic']);
+
+    return ['Extrinsic', 'IExtrinsic', 'string', 'Uint8Array'];
+  } else if (type === 'Keys') {
+    // This one is weird... surely it should popup as a Tuple? (but either way better as defined hex)
+    return ['Keys', 'string', 'Uint8Array'];
+  } else if (type === 'StorageKey') {
+    // TODO We can do better
+    return ['StorageKey', 'string', 'Uint8Array', 'any'];
+  } else if (type === '()') {
+    return ['null'];
+  }
+
+  const Clazz = registry.createClass(type);
+
+  if (isChildClass(Vec, Clazz)) {
+    const vecDef = getTypeDef(type);
+    const subDef = (vecDef.sub) as TypeDef;
+
+    // this could be that we define a Vec type and refer to it by name
+    if (subDef) {
+      if (subDef.info === TypeDefInfo.Plain) {
+        possibleTypes.push(`(${getSimilarTypes(registry, definitions, subDef.type, imports).join(' | ')})[]`);
+      } else if (subDef.info === TypeDefInfo.Tuple) {
+        const subs = (subDef.sub as TypeDef[]).map(({ type }): string =>
+          getSimilarTypes(registry, definitions, type, imports).join(' | ')
+        );
+
+        possibleTypes.push(`([${subs.join(', ')}])[]`);
+      } else if (subDef.info === TypeDefInfo.Option || subDef.info === TypeDefInfo.Vec || subDef.info === TypeDefInfo.VecFixed) {
+        // TODO: Add possibleTypes so imports work
+      } else if (subDef.info === TypeDefInfo.Struct) {
+        // TODO: Add possibleTypes so imports work
+      } else {
+        throw new Error(`Unhandled subtype in Vec, ${stringify(subDef)}`);
+      }
+    }
+  } else if (isChildClass(Enum, Clazz)) {
+    const { defKeys, isBasic } = new (Clazz as CodecClass)(registry) as Enum;
+    const keys = defKeys.filter((v) => !v.startsWith('__Unused'));
+
+    if (isBasic) {
+      possibleTypes.push(arrayToStrType(keys), 'number');
+    } else {
+      // TODO We don't really want any here, these should be expanded
+      possibleTypes.push(...keys.map((k) => `{ ${k}: any }`), 'string');
+    }
+
+    possibleTypes.push('Uint8Array');
+  } else if (isChildClass(AbstractInt as unknown as CodecClass<UInt>, Clazz) || isChildClass(Compact, Clazz)) {
+    possibleTypes.push('AnyNumber', 'Uint8Array');
+  } else if (isChildClass(GenericLookupSource, Clazz)) {
+    possibleTypes.push('Address', 'AccountId', 'AccountIndex', 'LookupSource', 'string', 'Uint8Array');
+  } else if (isChildClass(GenericAccountId, Clazz)) {
+    possibleTypes.push('string', 'Uint8Array');
+  } else if (isChildClass(GenericCall, Clazz)) {
+    possibleTypes.push('IMethod', 'string', 'Uint8Array');
+  } else if (isChildClass(bool, Clazz)) {
+    possibleTypes.push('boolean', 'Uint8Array');
+  } else if (isChildClass(Null, Clazz)) {
+    possibleTypes.push('null');
+  } else if (isChildClass(Struct, Clazz)) {
+    const s = new (Clazz as CodecClass)(registry) as Struct;
+    const obj = s.defKeys.map((key): string => `${key}?: any`).join('; ');
+
+    possibleTypes.push(`{ ${obj} }`, 'string', 'Uint8Array');
+  } else if (isChildClass(Option, Clazz)) {
+    possibleTypes.push('null', 'Uint8Array');
+
+    const optDef = getTypeDef(type);
+    const subDef = (optDef.sub) as TypeDef;
+
+    if (subDef) {
+      possibleTypes.push(...getSimilarTypes(registry, definitions, subDef.type, imports));
+    } else {
+      possibleTypes.push('object', 'string');
+    }
+  } else if (isChildClass(GenericVote, Clazz)) {
+    possibleTypes.push(`{ aye: boolean; conviction?: ${voteConvictions} | number }`, 'boolean', 'string', 'Uint8Array');
+  } else if (isChildClass(WrapperKeepOpaque, Clazz) || isChildClass(WrapperOpaque, Clazz)) {
+    // TODO inspect container
+    possibleTypes.push('object', 'string', 'Uint8Array');
+  } else if (isChildClass(Uint8Array, Clazz)) {
+    possibleTypes.push('string', 'Uint8Array');
+  } else if (isChildClass(String, Clazz)) {
+    possibleTypes.push('string');
+  } else if (isChildClass(Tuple, Clazz)) {
+    const tupDef = getTypeDef(type);
+    const subDef = tupDef.sub;
+
+    // this could be that we define a Tuple type and refer to it by name
+    if (Array.isArray(subDef)) {
+      const subs = subDef.map(({ type }) => getSimilarTypes(registry, definitions, type, imports).join(' | '));
+
+      possibleTypes.push(`[${subs.join(', ')}]`);
+    }
+  }
+
+  return [...new Set(possibleTypes)];
+}

package/src/util/docs.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import Handlebars from 'handlebars';
+
+import { readTemplate } from './file.js';
+
+Handlebars.registerPartial({
+  docs: Handlebars.compile(readTemplate('docs'))
+});
+
+// empty export
+export const __TYPEGEN_DUMMY_DOCS = 'DUMMY_DOCS';

package/src/util/file.ts

@@ -0,0 +1,42 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+import { packageInfo } from '../packageInfo.js';
+
+export function writeFile (dest: string, generator: () => string, noLog?: boolean): void {
+  !noLog && console.log(`${dest}\n\tGenerating`);
+
+  let generated = generator();
+
+  while (generated.includes('\n\n\n')) {
+    generated = generated.replace(/\n\n\n/g, '\n\n');
+  }
+
+  !noLog && console.log('\tWriting');
+
+  fs.writeFileSync(dest, generated, { flag: 'w' });
+
+  !noLog && console.log('');
+}
+
+export function readTemplate (template: string): string {
+  // Inside the api repo itself, it will be 'auto'
+  const rootDir = packageInfo.path === 'auto'
+    ? path.join(process.cwd(), 'packages/typegen/src')
+    : packageInfo.path;
+
+  // NOTE With cjs in a subdir, search one lower as well
+  const file = ['./templates', '../templates']
+    .map((p) => path.join(rootDir, p, `${template}.hbs`))
+    .find((p) => fs.existsSync(p));
+
+  if (!file) {
+    throw new Error(`Unable to locate ${template}.hbs from ${rootDir}`);
+  }
+
+  return fs.readFileSync(file).toString();
+}

package/src/util/formatting.spec.ts

@@ -0,0 +1,30 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '@pezkuwi/types';
+
+import { formatType } from './formatting.js';
+
+describe('formatType', (): void => {
+  const registry = new TypeRegistry();
+
+  it('handles nested Tuples', (): void => {
+    expect(
+      formatType(registry, {}, '(AccountId, (Balance, u32), u64)', {
+        codecTypes: {},
+        definitions: {},
+        extrinsicTypes: {},
+        genericTypes: {},
+        ignoredTypes: [],
+        localTypes: {},
+        lookupTypes: {},
+        metadataTypes: {},
+        primitiveTypes: {},
+        typeToModule: {},
+        typesTypes: {}
+      })
+    ).toEqual('ITuple<[AccountId, ITuple<[Balance, u32]>, u64]>');
+  });
+});