@pezkuwi/typegen 16.5.18 → 16.5.32

package/build-tsc-esm/util/derived.js

@@ -1,125 +0,0 @@
-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) {
-    return `${arr.map((c) => `'${c}'`).join(' | ')}`;
-}
-const voteConvictions = arrayToStrType(AllConvictions);
-/** @internal */
-export function getSimilarTypes(registry, definitions, _type, imports) {
-    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);
-        // 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.map(({ type }) => 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(registry);
-        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, 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(registry);
-        const obj = s.defKeys.map((key) => `${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);
-        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/augment.ts

@@ -1,5 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import '@pezkuwi/api-augment';
-import '@pezkuwi/rpc-augment';

package/src/bundle.ts

@@ -1,5 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { packageInfo } from './packageInfo.js';
-export { formatType } from './util/formatting.js';

package/src/extractChain.ts

@@ -1,54 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// Connects to the local chain and outputs a re-usable calls-only chain definition in  the form
-// export default { chain: 'Development', genesisHash: '0x27b6d5e0f4fdce1c4d20b82406f193acacce0c19e0d2c0e7ca47725c2572a06a', ss58Format: 42, tokenDecimals: 0, tokenSymbol: 'UNIT'; metaCalls: 'bWV0...4AAA==' };
-
-import process from 'node:process';
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
-
-import { ApiPromise, WsProvider } from '@pezkuwi/api';
-
-/** @internal */
-async function run (ws: string): Promise<void> {
-  const provider = new WsProvider(ws);
-  const api = await ApiPromise.create({ provider, throwOnConnect: true });
-  const [chain, props] = await Promise.all([
-    api.rpc.system.chain(),
-    api.rpc.system.properties()
-  ]);
-
-  // output the chain info, for easy re-use
-  console.error(`// Generated via 'yarn run chain:info ${ws}'\n\nexport default {\n  chain: '${chain.toString()}',\n  genesisHash: '${api.genesisHash.toHex()}',\n  specVersion: ${api.runtimeVersion.specVersion.toNumber()},\n  ss58Format: ${props.ss58Format.unwrapOr(42).toString()},\n  tokenDecimals: ${props.tokenDecimals.unwrapOr(0).toString()},\n  tokenSymbol: '${props.tokenSymbol.unwrapOr('UNIT').toString()}',\n  metaCalls: '${Buffer.from(api.runtimeMetadata.asCallsOnly.toU8a()).toString('base64')}'\n};`);
-
-  // show any missing types
-  api.runtimeMetadata.getUniqTypes(false);
-}
-
-interface ArgV { ws: string }
-
-export function main (): void {
-  // retrieve and parse arguments - we do this globally, since this is a single command
-  const { ws } = yargs(hideBin(process.argv))
-    .usage('Usage: [options]')
-    .wrap(120)
-    .strict()
-    .options({
-      ws: {
-        default: 'ws://127.0.0.1:9944',
-        description: 'The API endpoint to connect to, e.g. wss://dicle-rpc.pezkuwi.io',
-        required: true,
-        type: 'string'
-      }
-    }).argv as ArgV;
-
-  run(ws)
-    .then((): void => {
-      process.exit(0);
-    })
-    .catch((error: Error) => {
-      console.error('FATAL:', error.message);
-      process.exit(-1);
-    });
-}

package/src/fromChain.ts

@@ -1,123 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Definitions, DefinitionsTypes } from '@pezkuwi/types/types';
-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 { formatNumber, isHex } from '@pezkuwi/util';
-
-import { generateDefaultConsts, generateDefaultErrors, generateDefaultEvents, generateDefaultQuery, generateDefaultRpc, generateDefaultRuntime, generateDefaultTx } from './generate/index.js';
-import { assertDir, assertFile, getMetadataViaWs, HEADER, writeFile } from './util/index.js';
-
-async function generate (metaHex: HexString, pkg: string | undefined, output: string, isStrict?: boolean): Promise<void> {
-  console.log(`Generating from metadata, ${formatNumber((metaHex.length - 2) / 2)} bytes`);
-
-  const outputPath = assertDir(path.join(process.cwd(), output));
-  let extraTypes: Record<string, any> = {};
-  let customLookupDefinitions: Definitions = { rpc: {}, types: {} };
-
-  if (pkg) {
-    try {
-      const defCont = await import(
-        assertFile(path.join(outputPath, 'definitions.ts'))
-      ) as Record<string, any>;
-
-      extraTypes = {
-        [pkg]: defCont
-      };
-    } catch (error) {
-      console.error('ERROR: No custom definitions found:', (error as Error).message);
-    }
-  }
-
-  try {
-    const lookCont = await import(
-      assertFile(path.join(outputPath, 'lookup.ts'))
-    ) as { default: DefinitionsTypes };
-
-    customLookupDefinitions = {
-      rpc: {},
-      types: lookCont.default
-    };
-  } catch (error) {
-    console.error('ERROR: No lookup definitions found:', (error as Error).message);
-  }
-
-  generateDefaultConsts(path.join(outputPath, 'augment-api-consts.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
-  generateDefaultErrors(path.join(outputPath, 'augment-api-errors.ts'), metaHex, extraTypes, isStrict);
-  generateDefaultEvents(path.join(outputPath, 'augment-api-events.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
-  generateDefaultQuery(path.join(outputPath, 'augment-api-query.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
-  generateDefaultRpc(path.join(outputPath, 'augment-api-rpc.ts'), extraTypes);
-  generateDefaultRuntime(path.join(outputPath, 'augment-api-runtime.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
-  generateDefaultTx(path.join(outputPath, 'augment-api-tx.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
-
-  writeFile(path.join(outputPath, 'augment-api.ts'), (): string =>
-    [
-      HEADER('chain'),
-      ...[
-        ...['consts', 'errors', 'events', 'query', 'tx', 'rpc', 'runtime']
-          .filter((key) => !!key)
-          .map((key) => `./augment-api-${key}.js`)
-      ].map((path) => `import '${path}';\n`)
-    ].join('')
-  );
-
-  process.exit(0);
-}
-
-interface ArgV { endpoint: string; output: string; package?: string; strict?: boolean }
-
-async function mainPromise (): Promise<void> {
-  const { endpoint, output, package: pkg, strict: isStrict } = yargs(hideBin(process.argv)).strict().options({
-    endpoint: {
-      description: 'The endpoint to connect to (e.g. wss://dicle-rpc.pezkuwi.io) or relative path to a file containing the JSON output of an RPC state_getMetadata call',
-      required: true,
-      type: 'string'
-    },
-    output: {
-      description: 'The target directory to write the data to',
-      required: true,
-      type: 'string'
-    },
-    package: {
-      description: 'Optional package in output location (for extra definitions)',
-      type: 'string'
-    },
-    strict: {
-      description: 'Turns on strict mode, no output of catch-all generic versions',
-      type: 'boolean'
-    }
-  }).argv as ArgV;
-
-  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');
-    }
-  }
-
-  await generate(metaHex, pkg, output, isStrict);
-}
-
-export function main (): void {
-  mainPromise().catch((error) => {
-    console.error();
-    console.error(error);
-    console.error();
-    process.exit(1);
-  });
-}

package/src/fromDefs.ts

@@ -1,106 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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 bizinikiwiDefs 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://dicle-rpc.pezkuwi.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(bizinikiwiDefs as Record<string, unknown>)
-    .filter(([key]) => {
-      if (userKeys.includes(key)) {
-        console.warn(`Override found for ${key} in user types, ignoring in @pezkuwi/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

@@ -1,112 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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, rebrandTypeName, 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 = rebrandTypeName(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

@@ -1,75 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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);
-}