@pezkuwi/typegen 16.5.16 → 16.5.18

package/build-tsc-esm/generate/tx.js

@@ -0,0 +1,117 @@
+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, getSimilarTypes, initMeta, readTemplate, rebrandTypeName, setImports, writeFile } from '../util/index.js';
+import { ignoreUnusedLookups } from './lookup.js';
+import { getDeprecationNotice } from './types.js';
+const MAPPED_NAMES = {
+    class: 'clazz',
+    new: 'updated'
+};
+const generateForMetaTemplate = Handlebars.compile(readTemplate('tx'));
+function mapName(_name) {
+    const name = stringCamelCase(_name);
+    return MAPPED_NAMES[name] || name;
+}
+/** @internal */
+function generateForMeta(registry, meta, dest, extraTypes, isStrict, customLookupDefinitions) {
+    writeFile(dest, () => {
+        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 } = meta.asLatest;
+        const usedTypes = new Set([]);
+        const modules = pallets
+            .sort(compareName)
+            .filter(({ calls }) => calls.isSome)
+            .map((data) => {
+            const name = data.name;
+            const calls = data.calls.unwrap();
+            const deprecationInfo = calls.deprecationInfo.toJSON();
+            setImports(allDefs, imports, ['SubmittableExtrinsic']);
+            const sectionName = stringCamelCase(name);
+            const items = lookup.getSiType(calls.type).def.asVariant.variants
+                .map(({ docs, fields, index, name }) => {
+                const rawStatus = deprecationInfo?.[index.toNumber()];
+                if (rawStatus) {
+                    const deprecationVariantInfo = meta.registry.createTypeUnsafe('VariantDeprecationInfoV16', [rawStatus]);
+                    const deprecationNotice = getDeprecationNotice(deprecationVariantInfo, name.toString(), 'Call');
+                    const notice = docs.length ? ['', deprecationNotice] : [deprecationNotice];
+                    docs.push(...notice.map((text) => meta.registry.createType('Text', text)));
+                }
+                const typesInfo = fields.map(({ name, type, typeName }, index) => {
+                    const typeDef = registry.lookup.getTypeDef(type);
+                    return [
+                        name.isSome
+                            ? mapName(name.unwrap())
+                            : `param${index}`,
+                        rebrandTypeName(typeName.isSome
+                            ? typeName.toString()
+                            : typeDef.type),
+                        rebrandTypeName(typeDef.isFromSi
+                            ? typeDef.type
+                            : typeDef.lookupName || typeDef.type)
+                    ];
+                });
+                const params = typesInfo
+                    .map(([name, , typeStr]) => {
+                    const similarTypes = getSimilarTypes(registry, allDefs, typeStr, imports);
+                    setImports(allDefs, imports, [typeStr, ...similarTypes]);
+                    // Add the type to the list of used types
+                    if (!(imports.primitiveTypes[typeStr])) {
+                        usedTypes.add(typeStr);
+                    }
+                    return `${name}: ${similarTypes.join(' | ')}`;
+                })
+                    .join(', ');
+                return {
+                    args: typesInfo.map(([, , typeStr]) => formatType(registry, allDefs, typeStr, imports)).join(', '),
+                    docs,
+                    name: stringCamelCase(name),
+                    params
+                };
+            })
+                .sort(compareName);
+            return {
+                items,
+                name: sectionName
+            };
+        })
+            .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: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
+                    types: Object.keys(imports.localTypes[packagePath])
+                })),
+                {
+                    file: '@pezkuwi/api-base/types',
+                    types: ['ApiTypes', 'AugmentedSubmittable', 'SubmittableExtrinsic', 'SubmittableExtrinsicFunction']
+                }
+            ]
+        });
+    });
+}
+/** @internal */
+export function generateDefaultTx(dest, data, extraTypes = {}, isStrict = false, customLookupDefinitions) {
+    const { metadata, registry } = initMeta(data, extraTypes);
+    return generateForMeta(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions);
+}

package/build-tsc-esm/generate/types.js

@@ -0,0 +1,13 @@
+export function getDeprecationNotice(deprecationInfo, name, label) {
+    let deprecationNotice = '@deprecated';
+    if (deprecationInfo.isDeprecated) {
+        const { note, since } = deprecationInfo.asDeprecated;
+        const sinceText = since.isSome ? ` Since ${since.unwrap().toString()}.` : '';
+        deprecationNotice += ` ${note.toString()}${sinceText}`;
+    }
+    else {
+        const labelText = label ? `${label} ` : '';
+        deprecationNotice += ` ${labelText}${name} has been deprecated`;
+    }
+    return deprecationNotice;
+}

package/{packageInfo.js → build-tsc-esm/packageInfo.js}

@@ -1 +1 @@
-export const packageInfo = { name: '@pezkuwi/typegen', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '16.5.16' };
+export const packageInfo = { name: '@pezkuwi/typegen', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '16.5.18' };

package/package.json

@@ -1,5 +1,5 @@
 {
-  "author": "Dijital Kurdistan Tech Institute <dev@pezkuwichain.io>",
+  "author": "Jaco Greeff <jacogr@gmail.com>",
   "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues",
   "description": "Type generation scripts",
   "engines": {
@@ -18,7 +18,10 @@
     "./cjs/packageDetect.js"
   ],
   "type": "module",
-  "version": "16.5.16",
+  "types": "./index.d.ts",
+  "version": "16.5.18",
+  "main": "./cjs/index.js",
+  "module": "./index.js",
   "bin": {
     "pezkuwi-types-chain-info": "./scripts/pezkuwi-types-chain-info.mjs",
     "pezkuwi-types-from-chain": "./scripts/pezkuwi-types-from-chain.mjs",
@@ -26,12 +29,7 @@
     "pezkuwi-types-internal-interfaces": "./scripts/pezkuwi-types-internal-interfaces.mjs",
     "pezkuwi-types-internal-metadata": "./scripts/pezkuwi-types-internal-metadata.mjs"
   },
-  "main": "./cjs/index.js",
-  "module": "./cjs/index.js",
-  "types": "./cjs/index.d.ts",
   "exports": {
-    "./cjs/package.json": "./cjs/package.json",
-    "./cjs/*": "./cjs/*.js",
     ".": {
       "module": {
         "types": "./index.d.ts",
@@ -74,6 +72,8 @@
         "default": "./bundle.js"
       }
     },
+    "./cjs/*": "./cjs/*.js",
+    "./cjs/package.json": "./cjs/package.json",
     "./extractChain": {
       "module": {
         "types": "./extractChain.d.ts",
@@ -330,7 +330,7 @@
         "default": "./packageDetect.js"
       }
     },
-    "./packageInfo.js": {
+    "./packageInfo": {
       "module": {
         "types": "./packageInfo.d.ts",
         "default": "./packageInfo.js"
@@ -344,7 +344,7 @@
         "default": "./packageInfo.js"
       }
     },
-    "./packageInfo": {
+    "./packageInfo.js": {
       "module": {
         "types": "./packageInfo.d.ts",
         "default": "./packageInfo.js"
@@ -358,16 +358,16 @@
         "default": "./packageInfo.js"
       }
     },
-    "./scripts/pezkuwi-types-chain-info.mjs": "./scripts/pezkuwi-types-chain-info.mjs",
     "./scripts/pezkuwi-types-chain-info": "./scripts/pezkuwi-types-chain-info.mjs",
-    "./scripts/pezkuwi-types-from-chain.mjs": "./scripts/pezkuwi-types-from-chain.mjs",
+    "./scripts/pezkuwi-types-chain-info.mjs": "./scripts/pezkuwi-types-chain-info.mjs",
     "./scripts/pezkuwi-types-from-chain": "./scripts/pezkuwi-types-from-chain.mjs",
-    "./scripts/pezkuwi-types-from-defs.mjs": "./scripts/pezkuwi-types-from-defs.mjs",
+    "./scripts/pezkuwi-types-from-chain.mjs": "./scripts/pezkuwi-types-from-chain.mjs",
     "./scripts/pezkuwi-types-from-defs": "./scripts/pezkuwi-types-from-defs.mjs",
-    "./scripts/pezkuwi-types-internal-interfaces.mjs": "./scripts/pezkuwi-types-internal-interfaces.mjs",
+    "./scripts/pezkuwi-types-from-defs.mjs": "./scripts/pezkuwi-types-from-defs.mjs",
     "./scripts/pezkuwi-types-internal-interfaces": "./scripts/pezkuwi-types-internal-interfaces.mjs",
-    "./scripts/pezkuwi-types-internal-metadata.mjs": "./scripts/pezkuwi-types-internal-metadata.mjs",
+    "./scripts/pezkuwi-types-internal-interfaces.mjs": "./scripts/pezkuwi-types-internal-interfaces.mjs",
     "./scripts/pezkuwi-types-internal-metadata": "./scripts/pezkuwi-types-internal-metadata.mjs",
+    "./scripts/pezkuwi-types-internal-metadata.mjs": "./scripts/pezkuwi-types-internal-metadata.mjs",
     "./templates/calls.hbs": "./templates/calls.hbs",
     "./templates/consts.hbs": "./templates/consts.hbs",
     "./templates/docs.hbs": "./templates/docs.hbs",
@@ -527,19 +527,19 @@
     }
   },
   "dependencies": {
-    "@pezkuwi/api": "16.5.15",
-    "@pezkuwi/api-augment": "16.5.15",
-    "@pezkuwi/api-derive": "16.5.15",
-    "@pezkuwi/rpc-augment": "16.5.15",
-    "@pezkuwi/rpc-provider": "16.5.15",
-    "@pezkuwi/types": "16.5.15",
-    "@pezkuwi/types-augment": "16.5.15",
-    "@pezkuwi/types-codec": "16.5.15",
-    "@pezkuwi/types-create": "16.5.15",
-    "@pezkuwi/types-support": "16.5.15",
-    "@pezkuwi/util": "14.0.12",
-    "@pezkuwi/util-crypto": "14.0.12",
-    "@pezkuwi/x-ws": "14.0.12",
+    "@pezkuwi/api": "16.5.9",
+    "@pezkuwi/api-augment": "16.5.9",
+    "@pezkuwi/api-derive": "16.5.9",
+    "@pezkuwi/rpc-augment": "16.5.9",
+    "@pezkuwi/rpc-provider": "16.5.9",
+    "@pezkuwi/types": "16.5.9",
+    "@pezkuwi/types-augment": "16.5.9",
+    "@pezkuwi/types-codec": "16.5.9",
+    "@pezkuwi/types-create": "16.5.9",
+    "@pezkuwi/types-support": "16.5.9",
+    "@pezkuwi/util": "14.0.11",
+    "@pezkuwi/util-crypto": "14.0.11",
+    "@pezkuwi/x-ws": "14.0.11",
     "comment-parser": "^1.4.1",
     "handlebars": "^4.7.8",
     "tslib": "^2.8.1",

package/src/augment.ts

@@ -0,0 +1,5 @@
+// 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

@@ -0,0 +1,5 @@
+// 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

@@ -0,0 +1,54 @@
+// 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

@@ -0,0 +1,123 @@
+// 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

@@ -0,0 +1,106 @@
+// 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

@@ -0,0 +1,112 @@
+// 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);
+}