@pezkuwi/typegen 16.5.5 → 16.5.6

package/generate/runtime.js

@@ -0,0 +1,228 @@
+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 { getDeprecationNotice } from './types.js';
+const generateCallsTypesTemplate = Handlebars.compile(readTemplate('calls'));
+const aliases = {
+    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, id) => {
+    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, methods) {
+    const result = {};
+    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) {
+    const result = {};
+    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, defs, registry) {
+    const named = {};
+    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, meta, dest, extraTypes, isStrict, customLookupDefinitions) {
+    writeFile(dest, () => {
+        const allTypes = {
+            '@pezkuwi/types-augment': {
+                lookup: {
+                    ...lookupDefinitions,
+                    ...customLookupDefinitions
+                }
+            },
+            '@pezkuwi/types/interfaces': defaultDefs,
+            ...extraTypes
+        };
+        const imports = createImports(allTypes);
+        // find the system.Version in metadata
+        let apis = 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]) => [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, 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: 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, data, extraTypes = {}, isStrict = false, customLookupDefinitions) {
+    const { metadata, registry } = initMeta(data, extraTypes);
+    generateCallTypes(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions);
+}

package/generate/tsDef.d.ts

@@ -0,0 +1,16 @@
+import type { Registry } from '@pezkuwi/types/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { ModuleTypes } from '../util/imports.js';
+import type { TypeImports } from '../util/index.js';
+import { TypeDefInfo } from '@pezkuwi/types-create';
+/** @internal */
+export declare function createGetter(definitions: Record<string, ModuleTypes>, name: string | undefined, type: string, imports: TypeImports): string;
+export declare const typeEncoders: Record<TypeDefInfo, (registry: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports) => string>;
+/** @internal */
+export declare function generateTsDefFor(registry: Registry, importDefinitions: Record<string, Record<string, ModuleTypes>>, defName: string, { types }: {
+    types: Record<string, any>;
+}, outputDir: string): void;
+/** @internal */
+export declare function generateTsDef(importDefinitions: Record<string, Record<string, ModuleTypes>>, outputDir: string, generatingPackage: string): void;
+/** @internal */
+export declare function generateDefaultTsDef(): void;

package/generate/tsDef.js

@@ -0,0 +1,246 @@
+import Handlebars from 'handlebars';
+import path from 'node:path';
+import { TypeRegistry } from '@pezkuwi/types/create';
+import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
+import { getTypeDef, TypeDefInfo } from '@pezkuwi/types-create';
+import { assert, isString, stringify, stringPascalCase } from '@pezkuwi/util';
+import { createImports, exportInterface, formatType, readTemplate, setImports, writeFile } from '../util/index.js';
+const generateTsDefIndexTemplate = Handlebars.compile(readTemplate('tsDef/index'));
+const generateTsDefModuleTypesTemplate = Handlebars.compile(readTemplate('tsDef/moduleTypes'));
+const generateTsDefTypesTemplate = Handlebars.compile(readTemplate('tsDef/types'));
+/** @internal */
+export function createGetter(definitions, name = '', type, imports) {
+    setImports(definitions, imports, [type]);
+    return `  readonly ${name}: ${type};\n`;
+}
+/** @internal */
+function errorUnhandled(_, _definitions, def, _imports) {
+    throw new Error(`Generate: ${def.name || ''}: Unhandled type ${TypeDefInfo[def.info]}`);
+}
+/** @internal */
+function tsExport(registry, definitions, def, imports) {
+    return exportInterface(def.lookupIndex, def.name, formatType(registry, definitions, def, imports, false));
+}
+/** @internal */
+function tsEnum(registry, definitions, { lookupIndex, name: enumName, sub }, imports, withShortcut = false) {
+    setImports(definitions, imports, ['Enum']);
+    const indent = withShortcut ? '  ' : '';
+    const named = sub.filter(({ name }) => !!name && !name.startsWith('__Unused'));
+    const keys = named.map((def) => {
+        const { info, lookupName, name = '', sub, type } = def;
+        const getter = stringPascalCase(name.replace(' ', '_'));
+        const isComplex = [TypeDefInfo.Option, TypeDefInfo.Range, TypeDefInfo.RangeInclusive, TypeDefInfo.Result, TypeDefInfo.Struct, TypeDefInfo.Tuple, TypeDefInfo.Vec, TypeDefInfo.VecFixed].includes(info);
+        let extractedLookupName;
+        // When the parent type does not have a lookupName, and the sub type is the same
+        // type as the parent we can take the lookupName from the sub.
+        // This is specific to `StagingXcmV4Junction`.
+        // see: https://github.com/pezkuwichain/pezkuwi-api/pull/5812
+        if (sub && !Array.isArray(sub) && type.includes(`${sub.type};`)) {
+            if (sub.lookupName === 'StagingXcmV4Junction') {
+                extractedLookupName = sub.lookupName;
+            }
+            else if (sub.lookupName === 'StagingXcmV5Junction') {
+                extractedLookupName = `Vec<${sub.lookupName}>`;
+            }
+        }
+        const asGetter = type === 'Null' || info === TypeDefInfo.DoNotConstruct
+            ? ''
+            : createGetter(definitions, `as${getter}`, lookupName || extractedLookupName || (isComplex ? formatType(registry, definitions, info === TypeDefInfo.Struct ? def : type, imports, withShortcut) : type), imports);
+        const isGetter = info === TypeDefInfo.DoNotConstruct
+            ? ''
+            : createGetter(definitions, `is${getter}`, 'boolean', imports);
+        switch (info) {
+            case TypeDefInfo.Compact:
+            case TypeDefInfo.Plain:
+            case TypeDefInfo.Range:
+            case TypeDefInfo.RangeInclusive:
+            case TypeDefInfo.Result:
+            case TypeDefInfo.Si:
+            case TypeDefInfo.Struct:
+            case TypeDefInfo.Tuple:
+            case TypeDefInfo.Vec:
+            case TypeDefInfo.BTreeMap:
+            case TypeDefInfo.BTreeSet:
+            case TypeDefInfo.Option:
+            case TypeDefInfo.VecFixed:
+            case TypeDefInfo.WrapperKeepOpaque:
+            case TypeDefInfo.WrapperOpaque:
+                return `${indent}${isGetter}${indent}${asGetter}`;
+            case TypeDefInfo.DoNotConstruct:
+            case TypeDefInfo.Null:
+                return `${indent}${isGetter}`;
+            default:
+                throw new Error(`Enum: ${enumName || 'undefined'}: Unhandled type ${TypeDefInfo[info]}, ${stringify(def)}`);
+        }
+    });
+    return exportInterface(lookupIndex, enumName, 'Enum', `${keys.join('')}  ${indent}readonly type: ${named.map(({ name = '' }) => `'${stringPascalCase(name.replace(' ', '_'))}'`).join(' | ')};\n`, withShortcut);
+}
+function tsInt(_, definitions, def, imports, type = 'Int') {
+    setImports(definitions, imports, [type]);
+    return exportInterface(def.lookupIndex, def.name, type);
+}
+/** @internal */
+function tsNull(_registry, definitions, { lookupIndex = -1, name }, imports) {
+    setImports(definitions, imports, ['Null']);
+    // * @description extends [[${base}]]
+    const doc = `/** @name ${name || ''}${lookupIndex !== -1 ? ` (${lookupIndex})` : ''} */\n`;
+    return `${doc}export type ${name || ''} = Null;`;
+}
+/** @internal */
+function tsResultGetter(registry, definitions, resultName = '', getter, def, imports) {
+    const { info, lookupName, type } = def;
+    const asGetter = type === 'Null'
+        ? ''
+        : createGetter(definitions, `as${getter}`, lookupName || (info === TypeDefInfo.Tuple ? formatType(registry, definitions, def, imports, false) : type), imports);
+    const isGetter = createGetter(definitions, `is${getter}`, 'boolean', imports);
+    switch (info) {
+        case TypeDefInfo.Option:
+        case TypeDefInfo.Plain:
+        case TypeDefInfo.Si:
+        case TypeDefInfo.Tuple:
+        case TypeDefInfo.Vec:
+        case TypeDefInfo.BTreeMap:
+        case TypeDefInfo.BTreeSet:
+        case TypeDefInfo.WrapperKeepOpaque:
+        case TypeDefInfo.WrapperOpaque:
+            return `${isGetter}${asGetter}`;
+        case TypeDefInfo.Null:
+            return `${isGetter}`;
+        default:
+            throw new Error(`Result: ${resultName}: Unhandled type ${TypeDefInfo[info]}, ${stringify(def)}`);
+    }
+}
+/** @internal */
+function tsResult(registry, definitions, def, imports) {
+    const [okDef, errorDef] = def.sub;
+    const inner = [
+        tsResultGetter(registry, definitions, def.name, 'Err', errorDef, imports),
+        tsResultGetter(registry, definitions, def.name, 'Ok', okDef, imports)
+    ].join('');
+    setImports(definitions, imports, [def.type]);
+    const fmtType = def.lookupName && def.name !== def.lookupName
+        ? def.lookupName
+        : formatType(registry, definitions, def, imports, false);
+    return exportInterface(def.lookupIndex, def.name, fmtType, inner);
+}
+/** @internal */
+function tsSi(_registry, _definitions, typeDef, _imports) {
+    // FIXME
+    return `// SI: ${stringify(typeDef)}`;
+}
+/** @internal */
+function tsSet(_, definitions, { lookupIndex, name: setName, sub }, imports) {
+    setImports(definitions, imports, ['Set']);
+    const types = sub.map(({ name }) => {
+        assert(name, 'Invalid TypeDef found, no name specified');
+        return createGetter(definitions, `is${name}`, 'boolean', imports);
+    });
+    return exportInterface(lookupIndex, setName, 'Set', types.join(''));
+}
+/** @internal */
+function tsStruct(registry, definitions, { lookupIndex, name: structName, sub }, imports) {
+    setImports(definitions, imports, ['Struct']);
+    const keys = sub.map((def) => {
+        const fmtType = def.lookupName && def.name !== def.lookupName
+            ? def.lookupName
+            : def.info === TypeDefInfo.Enum
+                ? `${tsEnum(registry, definitions, def, imports, true)} & Enum`
+                : formatType(registry, definitions, def, imports, false);
+        return createGetter(definitions, def.name, fmtType, imports);
+    });
+    return exportInterface(lookupIndex, structName, 'Struct', keys.join(''));
+}
+/** @internal */
+function tsUInt(registry, definitions, def, imports) {
+    return tsInt(registry, definitions, def, imports, 'UInt');
+}
+/** @internal */
+function tsVec(registry, definitions, def, imports) {
+    const type = def.sub.type;
+    if (type === 'u8') {
+        if (def.info === TypeDefInfo.VecFixed) {
+            setImports(definitions, imports, ['U8aFixed']);
+            return exportInterface(def.lookupIndex, def.name, 'U8aFixed');
+        }
+        else {
+            setImports(definitions, imports, ['Bytes']);
+            return exportInterface(def.lookupIndex, def.name, 'Bytes');
+        }
+    }
+    const fmtType = def.lookupName && def.name !== def.lookupName
+        ? def.lookupName
+        : formatType(registry, definitions, def, imports, false);
+    return exportInterface(def.lookupIndex, def.name, fmtType);
+}
+export const typeEncoders = {
+    [TypeDefInfo.BTreeMap]: tsExport,
+    [TypeDefInfo.BTreeSet]: tsExport,
+    [TypeDefInfo.Compact]: tsExport,
+    [TypeDefInfo.DoNotConstruct]: tsExport,
+    [TypeDefInfo.Enum]: tsEnum,
+    [TypeDefInfo.HashMap]: tsExport,
+    [TypeDefInfo.Int]: tsInt,
+    [TypeDefInfo.Linkage]: errorUnhandled,
+    [TypeDefInfo.Null]: tsNull,
+    [TypeDefInfo.Option]: tsExport,
+    [TypeDefInfo.Plain]: tsExport,
+    [TypeDefInfo.Range]: tsExport,
+    [TypeDefInfo.RangeInclusive]: tsExport,
+    [TypeDefInfo.Result]: tsResult,
+    [TypeDefInfo.Set]: tsSet,
+    [TypeDefInfo.Si]: tsSi,
+    [TypeDefInfo.Struct]: tsStruct,
+    [TypeDefInfo.Tuple]: tsExport,
+    [TypeDefInfo.UInt]: tsUInt,
+    [TypeDefInfo.Vec]: tsVec,
+    [TypeDefInfo.VecFixed]: tsVec,
+    [TypeDefInfo.WrapperKeepOpaque]: tsExport,
+    [TypeDefInfo.WrapperOpaque]: tsExport
+};
+/** @internal */
+function generateInterfaces(registry, definitions, { types }, imports) {
+    return Object.entries(types).map(([name, type]) => {
+        const def = getTypeDef(isString(type) ? type : stringify(type), { name });
+        return [name, typeEncoders[def.info](registry, definitions, def, imports)];
+    });
+}
+/** @internal */
+export function generateTsDefFor(registry, importDefinitions, defName, { types }, outputDir) {
+    const imports = { ...createImports(importDefinitions, { types }), interfaces: [] };
+    const definitions = imports.definitions;
+    const interfaces = generateInterfaces(registry, definitions, { types }, imports);
+    const items = interfaces.sort((a, b) => a[0].localeCompare(b[0])).map(([, definition]) => definition);
+    writeFile(path.join(outputDir, defName, 'types.ts'), () => generateTsDefModuleTypesTemplate({
+        headerType: 'defs',
+        imports,
+        items,
+        name: defName,
+        types: [
+            ...Object.keys(imports.localTypes).sort().map((packagePath) => ({
+                file: packagePath.replace('@pezkuwi/types/augment', '@pezkuwi/types'),
+                types: Object.keys(imports.localTypes[packagePath])
+            }))
+        ]
+    }), true);
+    writeFile(path.join(outputDir, defName, 'index.ts'), () => generateTsDefIndexTemplate({ headerType: 'defs' }), true);
+}
+/** @internal */
+export function generateTsDef(importDefinitions, outputDir, generatingPackage) {
+    const registry = new TypeRegistry();
+    writeFile(path.join(outputDir, 'types.ts'), () => {
+        const definitions = importDefinitions[generatingPackage];
+        Object.entries(definitions).forEach(([defName, obj]) => {
+            console.log(`\tExtracting interfaces for ${defName}`);
+            generateTsDefFor(registry, importDefinitions, defName, obj, outputDir);
+        });
+        return generateTsDefTypesTemplate({
+            headerType: 'defs',
+            items: Object.keys(definitions)
+        });
+    });
+    writeFile(path.join(outputDir, 'index.ts'), () => generateTsDefIndexTemplate({ headerType: 'defs' }), true);
+}
+/** @internal */
+export function generateDefaultTsDef() {
+    generateTsDef({ '@pezkuwi/types/interfaces': defaultDefinitions }, 'packages/types/src/interfaces', '@pezkuwi/types/interfaces');
+}

package/generate/tx.d.ts

@@ -0,0 +1,5 @@
+import type { Definitions } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import { type ExtraTypes } from './types.js';
+/** @internal */
+export declare function generateDefaultTx(dest: string, data: HexString, extraTypes?: ExtraTypes, isStrict?: boolean, customLookupDefinitions?: Definitions): void;

package/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/generate/types.d.ts

@@ -0,0 +1,12 @@
+import type { Option, Text } from '@pezkuwi/types-codec';
+export type ExtraTypes = Record<string, Record<string, {
+    runtime?: Record<string, any>;
+    types: Record<string, any>;
+}>>;
+export declare function getDeprecationNotice<T extends {
+    isDeprecated: boolean;
+    asDeprecated: {
+        note: Text;
+        since: Option<Text>;
+    };
+}>(deprecationInfo: T, name: string, label?: string): string;

package/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/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/index.js

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/interfacesTs.d.ts

@@ -0,0 +1 @@
+export declare function main(): void;