@pezkuwi/typegen 16.5.16 → 16.5.18

package/build/util/formatting.js

@@ -0,0 +1,230 @@
+import Handlebars from 'handlebars';
+import * as typesCodec from '@pezkuwi/types-codec';
+import { getTypeDef, paramsNotation, TypeDefInfo } from '@pezkuwi/types-create';
+import { isString, stringify } from '@pezkuwi/util';
+import { readTemplate } from './file.js';
+import { setImports } from './imports.js';
+function rebrandTypeName(typeName) {
+    return typeName
+        // Main projects
+        .replace(/Polkadot/g, 'Pezkuwi')
+        .replace(/Substrate/g, 'Bizinikiwi')
+        .replace(/Cumulus/g, 'Pezcumulus')
+        // Networks
+        .replace(/Kusama/g, 'Dicle')
+        .replace(/Westend/g, 'Zagros')
+        .replace(/Rococo/g, 'Pezkuwichain')
+        // Chain types
+        .replace(/Parachain/g, 'Teyrchain')
+        // Module prefixes (in PascalCase type names)
+        .replace(/Frame(?=[A-Z])/g, 'Pezframe')
+        .replace(/Pallet(?=[A-Z])/g, 'Pezpallet')
+        // Primitives prefixes (sp_ becomes Sp in type names)
+        .replace(/^Sp(?=[A-Z])/g, 'Pezsp')
+        .replace(/([^a-zA-Z])Sp(?=[A-Z])/g, '$1Pezsp')
+        // Client prefixes (sc_ becomes Sc in type names)
+        .replace(/^Sc(?=[A-Z])/g, 'Pezsc')
+        .replace(/([^a-zA-Z])Sc(?=[A-Z])/g, '$1Pezsc');
+}
+const NO_CODEC = ['Tuple', 'VecFixed'];
+const ON_CODEC = Object.keys(typesCodec);
+const ON_CODEC_TYPES = ['Codec', 'AnyJson', 'AnyFunction', 'AnyNumber', 'AnyString', 'AnyTuple', 'AnyU8a', 'ICompact', 'IEnum', 'IMap', 'INumber', 'IOption', 'IResult', 'ISet', 'IStruct', 'ITuple', 'IU8a', 'IVec', 'IMethod'];
+export const HEADER = (type) => `// Auto-generated via \`yarn pezkuwi-types-from-${type}\`, do not edit\n/* eslint-disable */\n\n`;
+function extractImports({ imports, types }) {
+    const toplevel = [
+        ...Object.keys(imports.codecTypes),
+        ...Object.keys(imports.extrinsicTypes),
+        ...Object.keys(imports.genericTypes),
+        ...Object.keys(imports.metadataTypes),
+        ...Object.keys(imports.primitiveTypes)
+    ];
+    return [
+        {
+            file: '@pezkuwi/types',
+            types: toplevel.filter((n) => !NO_CODEC.includes(n) && !ON_CODEC.includes(n))
+        },
+        {
+            file: '@pezkuwi/types/lookup',
+            types: Object.keys(imports.lookupTypes)
+        },
+        {
+            file: '@pezkuwi/types/types',
+            types: Object.keys(imports.typesTypes).filter((n) => !ON_CODEC_TYPES.includes(n))
+        },
+        {
+            file: '@pezkuwi/types-codec',
+            types: toplevel.filter((n) => !NO_CODEC.includes(n) && ON_CODEC.includes(n))
+        },
+        {
+            file: '@pezkuwi/types-codec/types',
+            types: Object.keys(imports.typesTypes).filter((n) => ON_CODEC_TYPES.includes(n))
+        },
+        ...types
+    ]
+        .filter(({ types }) => types.length)
+        .sort(({ file }, b) => file.localeCompare(b.file))
+        .map(({ file, types }) => `import type { ${types.sort().join(', ')} } from '${file}';`);
+}
+Handlebars.registerPartial({
+    header: Handlebars.compile(readTemplate('header'))
+});
+Handlebars.registerHelper({
+    importsAll() {
+        return extractImports(this)
+            .join('\n');
+    },
+    importsPackage() {
+        return extractImports(this)
+            .filter((l) => !l.includes("from '."))
+            .join('\n  ');
+    },
+    importsRelative() {
+        return extractImports(this)
+            .filter((l) => l.includes("from '."))
+            .join('\n');
+    },
+    trim(options) {
+        return options.fn(this).trim();
+    },
+    upper(options) {
+        return options.fn(this).toUpperCase();
+    }
+});
+/** @internal */
+export function exportInterface(lookupIndex = -1, name = '', base, body = '', withShortcut = false) {
+    // * @description extends [[${base}]]
+    const doc = withShortcut
+        ? ''
+        : `/** @name ${name}${lookupIndex !== -1 ? ` (${lookupIndex})` : ''} */\n`;
+    return `${doc}${withShortcut ? '' : `export interface ${name} extends ${base} `}{${body.length ? '\n' : ''}${body}${withShortcut ? '  ' : ''}}`;
+}
+function singleParamNotation(registry, wrapper, typeDef, definitions, imports, withShortcut) {
+    const sub = typeDef.sub;
+    const lookupName = rebrandTypeName(sub.lookupName || '');
+    setImports(definitions, imports, [wrapper, lookupName]);
+    return paramsNotation(wrapper, lookupName || formatType(registry, definitions, sub.type, imports, withShortcut));
+}
+function dualParamsNotation(registry, wrapper, typeDef, definitions, imports, withShortcut) {
+    const [a, b] = typeDef.sub;
+    const aLookupName = rebrandTypeName(a.lookupName || '');
+    const bLookupName = rebrandTypeName(b.lookupName || '');
+    setImports(definitions, imports, [wrapper, aLookupName, bLookupName]);
+    return paramsNotation(wrapper, [
+        aLookupName || formatType(registry, definitions, a.type, imports, withShortcut),
+        bLookupName || formatType(registry, definitions, b.type, imports, withShortcut)
+    ]);
+}
+const formatters = {
+    [TypeDefInfo.Compact]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'Compact', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.DoNotConstruct]: (_registry, _typeDef, definitions, imports, _withShortcut) => {
+        setImports(definitions, imports, ['DoNotConstruct']);
+        return 'DoNotConstruct';
+    },
+    [TypeDefInfo.Enum]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
+        if (typeDef.lookupName) {
+            return rebrandTypeName(typeDef.lookupName);
+        }
+        throw new Error(`TypeDefInfo.Enum: Parameter formatting not implemented on ${stringify(typeDef)}`);
+    },
+    [TypeDefInfo.Int]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
+        throw new Error(`TypeDefInfo.Int: Parameter formatting not implemented on ${stringify(typeDef)}`);
+    },
+    [TypeDefInfo.UInt]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
+        throw new Error(`TypeDefInfo.UInt: Parameter formatting not implemented on ${stringify(typeDef)}`);
+    },
+    [TypeDefInfo.Null]: (_registry, _typeDef, definitions, imports, _withShortcut) => {
+        setImports(definitions, imports, ['Null']);
+        return 'Null';
+    },
+    [TypeDefInfo.Option]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'Option', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.Plain]: (_registry, typeDef, definitions, imports, _withShortcut) => {
+        setImports(definitions, imports, [rebrandTypeName(typeDef.type)]);
+        return rebrandTypeName(typeDef.type);
+    },
+    [TypeDefInfo.Range]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'Range', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.RangeInclusive]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'RangeInclusive', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.Set]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
+        throw new Error(`TypeDefInfo.Set: Parameter formatting not implemented on ${stringify(typeDef)}`);
+    },
+    [TypeDefInfo.Si]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return formatType(registry, definitions, registry.lookup.getTypeDef(typeDef.type), imports, withShortcut);
+    },
+    [TypeDefInfo.Struct]: (registry, typeDef, definitions, imports, withShortcut) => {
+        if (typeDef.lookupName) {
+            return rebrandTypeName(typeDef.lookupName);
+        }
+        const sub = typeDef.sub;
+        setImports(definitions, imports, ['Struct', ...sub.map(({ lookupName }) => rebrandTypeName(lookupName || ''))]);
+        return `{${withShortcut ? ' ' : '\n'}${sub.map(({ lookupName, name, type }, index) => [
+            name || `unknown${index}`,
+            rebrandTypeName(lookupName || '') || formatType(registry, definitions, type, imports, withShortcut)
+        ]).map(([k, t]) => `${withShortcut ? '' : '    readonly '}${k}: ${t};`).join(withShortcut ? ' ' : '\n')}${withShortcut ? ' ' : '\n  '}} & Struct`;
+    },
+    [TypeDefInfo.Tuple]: (registry, typeDef, definitions, imports, withShortcut) => {
+        const sub = typeDef.sub;
+        setImports(definitions, imports, ['ITuple', ...sub.map(({ lookupName }) => rebrandTypeName(lookupName || ''))]);
+        // `(a,b)` gets transformed into `ITuple<[a, b]>`
+        return paramsNotation('ITuple', `[${sub.map(({ lookupName, type }) => rebrandTypeName(lookupName || '') || formatType(registry, definitions, type, imports, withShortcut)).join(', ')}]`);
+    },
+    [TypeDefInfo.Vec]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'Vec', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.VecFixed]: (registry, typeDef, definitions, imports, withShortcut) => {
+        const sub = typeDef.sub;
+        if (sub.type === 'u8') {
+            setImports(definitions, imports, ['U8aFixed']);
+            return 'U8aFixed';
+        }
+        return singleParamNotation(registry, 'Vec', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.BTreeMap]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return dualParamsNotation(registry, 'BTreeMap', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.BTreeSet]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'BTreeSet', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.HashMap]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return dualParamsNotation(registry, 'HashMap', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.Linkage]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'Linkage', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.Result]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return dualParamsNotation(registry, 'Result', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.WrapperKeepOpaque]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'WrapperKeepOpaque', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.WrapperOpaque]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'WrapperOpaque', typeDef, definitions, imports, withShortcut);
+    }
+};
+/**
+ * Correctly format a given type
+ */
+/** @internal */
+export function formatType(registry, definitions, type, imports, withShortcut = false) {
+    let typeDef;
+    if (isString(type)) {
+        const _type = type.toString();
+        // If type is "unorthodox" (i.e. `{ something: any }` for an Enum input or `[a | b | c, d | e | f]` for a Tuple's similar types),
+        // we return it as-is
+        if (withShortcut && /(^{.+:.+})|^\([^,]+\)|^\(.+\)\[\]|^\[.+\]/.exec(_type) && !/\[\w+;\w+\]/.exec(_type)) {
+            return rebrandTypeName(_type);
+        }
+        typeDef = getTypeDef(type);
+    }
+    else {
+        typeDef = type;
+    }
+    setImports(definitions, imports, [rebrandTypeName(typeDef.lookupName || typeDef.type)]);
+    return rebrandTypeName(formatters[typeDef.info](registry, typeDef, definitions, imports, withShortcut));
+}

package/build/util/imports.d.ts

@@ -0,0 +1,23 @@
+export interface ModuleTypes {
+    types: Record<string, unknown>;
+}
+type TypeExist = Record<string, boolean>;
+type TypeExistMap = Record<string, TypeExist>;
+export interface TypeImports {
+    codecTypes: TypeExist;
+    extrinsicTypes: TypeExist;
+    genericTypes: TypeExist;
+    ignoredTypes: string[];
+    localTypes: TypeExistMap;
+    lookupTypes: TypeExistMap;
+    primitiveTypes: TypeExist;
+    metadataTypes: TypeExist;
+    typesTypes: TypeExist;
+    definitions: Record<string, ModuleTypes>;
+    typeToModule: Record<string, string>;
+}
+/** @internal */
+export declare function setImports(allDefs: Record<string, ModuleTypes>, imports: TypeImports, types: (string | null | undefined)[]): void;
+/** @internal */
+export declare function createImports(importDefinitions: Record<string, Record<string, ModuleTypes>>, { types }?: ModuleTypes): TypeImports;
+export {};

package/build/util/imports.js

@@ -0,0 +1,121 @@
+import * as codecClasses from '@pezkuwi/types/codec';
+import * as extrinsicClasses from '@pezkuwi/types/extrinsic';
+import * as genericClasses from '@pezkuwi/types/generic';
+import * as primitiveClasses from '@pezkuwi/types/primitive';
+import { getTypeDef, TypeDefInfo } from '@pezkuwi/types-create';
+function splitAlternatives(type) {
+    const alternatives = [];
+    let beginOfAlternative = 1;
+    let level = 0;
+    // we assume that the string starts with '['
+    for (let i = 1, count = type.length; i < count; i++) {
+        if (level === 0) {
+            switch (type[i]) {
+                case ']':
+                case ',':
+                case '|':
+                    alternatives.push(type.substring(beginOfAlternative, i).trim());
+                    beginOfAlternative = i + 1;
+                    break;
+            }
+        }
+        switch (type[i]) {
+            case '[':
+            case '(':
+            case '<':
+                level++;
+                break;
+            case ']':
+            case ')':
+            case '>':
+                level--;
+                break;
+        }
+    }
+    return alternatives;
+}
+/** @internal */
+export function setImports(allDefs, imports, types) {
+    const { codecTypes, extrinsicTypes, genericTypes, ignoredTypes, localTypes, metadataTypes, primitiveTypes, typesTypes } = imports;
+    types.filter((t) => !!t).forEach((type) => {
+        if (ignoredTypes.includes(type)) {
+            // do nothing
+        }
+        else if (['AnyNumber', 'CallFunction', 'Codec', 'IExtrinsic', 'IMethod', 'ITuple'].includes(type)) {
+            typesTypes[type] = true;
+        }
+        else if (['Metadata', 'PortableRegistry'].includes(type)) {
+            metadataTypes[type] = true;
+        }
+        else if (codecClasses[type]) {
+            codecTypes[type] = true;
+        }
+        else if (extrinsicClasses[type]) {
+            extrinsicTypes[type] = true;
+        }
+        else if (genericClasses[type]) {
+            genericTypes[type] = true;
+        }
+        else if (primitiveClasses[type]) {
+            primitiveTypes[type] = true;
+        }
+        else if (type.startsWith('[') && type.includes('|')) {
+            const splitTypes = splitAlternatives(type);
+            setImports(allDefs, imports, splitTypes);
+        }
+        else if (type.includes('<') || type.includes('(') || type.includes('[')) {
+            // If the type is a bit special (tuple, fixed u8, nested type...), then we
+            // need to parse it with `getTypeDef`.
+            const typeDef = getTypeDef(type);
+            setImports(allDefs, imports, [TypeDefInfo[typeDef.info]]);
+            // TypeDef.sub is a `TypeDef | TypeDef[]`
+            if (Array.isArray(typeDef.sub)) {
+                typeDef.sub.forEach((subType) => setImports(allDefs, imports, [subType.lookupName || subType.type]));
+            }
+            else if (typeDef.sub && (typeDef.info !== TypeDefInfo.VecFixed || typeDef.sub.type !== 'u8')) {
+                // typeDef.sub is a TypeDef in this case
+                setImports(allDefs, imports, [typeDef.sub.lookupName || typeDef.sub.type]);
+            }
+        }
+        else {
+            // find this module inside the exports from the rest
+            const [moduleName] = Object.entries(allDefs).find(([, { types }]) => Object.keys(types).includes(type)) || [null];
+            if (moduleName) {
+                localTypes[moduleName][type] = true;
+            }
+        }
+    });
+}
+/** @internal */
+export function createImports(importDefinitions, { types } = { types: {} }) {
+    const definitions = {};
+    const typeToModule = {};
+    Object.entries(importDefinitions).forEach(([packagePath, packageDef]) => {
+        Object.entries(packageDef).forEach(([name, moduleDef]) => {
+            const fullName = `${packagePath}/${name}`;
+            definitions[fullName] = moduleDef;
+            Object.keys(moduleDef.types).forEach((type) => {
+                if (typeToModule[type]) {
+                    console.warn(`\t\tWARN: Overwriting duplicated type '${type}' ${typeToModule[type]} -> ${fullName}`);
+                }
+                typeToModule[type] = fullName;
+            });
+        });
+    });
+    return {
+        codecTypes: {},
+        definitions,
+        extrinsicTypes: {},
+        genericTypes: {},
+        ignoredTypes: Object.keys(types),
+        localTypes: Object.keys(definitions).reduce((local, mod) => {
+            local[mod] = {};
+            return local;
+        }, {}),
+        lookupTypes: {},
+        metadataTypes: {},
+        primitiveTypes: {},
+        typeToModule,
+        typesTypes: {}
+    };
+}

package/build/util/index.d.ts

@@ -0,0 +1,16 @@
+export * from './assert.js';
+export * from './derived.js';
+export * from './docs.js';
+export * from './file.js';
+export * from './formatting.js';
+export * from './imports.js';
+export * from './initMeta.js';
+export * from './register.js';
+export * from './wsMeta.js';
+interface Cmp {
+    name: {
+        toString(): string;
+    };
+}
+export declare function compareName(a: Cmp, b: Cmp): number;
+export declare function rebrandTypeName(typeName: string): string;

package/build/util/index.js

@@ -0,0 +1,34 @@
+export * from './assert.js';
+export * from './derived.js';
+export * from './docs.js';
+export * from './file.js';
+export * from './formatting.js';
+export * from './imports.js';
+export * from './initMeta.js';
+export * from './register.js';
+export * from './wsMeta.js';
+export function compareName(a, b) {
+    return a.name.toString().localeCompare(b.name.toString());
+}
+export function rebrandTypeName(typeName) {
+    return typeName
+        // Main projects
+        .replace(/Polkadot/g, 'Pezkuwi')
+        .replace(/Substrate/g, 'Bizinikiwi')
+        .replace(/Cumulus/g, 'Pezcumulus')
+        // Networks
+        .replace(/Kusama/g, 'Dicle')
+        .replace(/Westend/g, 'Zagros')
+        .replace(/Rococo/g, 'Pezkuwichain')
+        // Chain types
+        .replace(/Parachain/g, 'Teyrchain')
+        // Module prefixes (in PascalCase type names)
+        .replace(/Frame(?=[A-Z])/g, 'Pezframe')
+        .replace(/Pallet(?=[A-Z])/g, 'Pezpallet')
+        // Primitives prefixes (sp_ becomes Sp in type names)
+        .replace(/^Sp(?=[A-Z])/g, 'Pezsp')
+        .replace(/([^a-zA-Z])Sp(?=[A-Z])/g, '$1Pezsp')
+        // Client prefixes (sc_ becomes Sc in type names)
+        .replace(/^Sc(?=[A-Z])/g, 'Pezsc')
+        .replace(/([^a-zA-Z])Sc(?=[A-Z])/g, '$1Pezsc');
+}

package/build/util/initMeta.d.ts

@@ -0,0 +1,12 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { ExtraTypes } from '../generate/types.js';
+import { Metadata, TypeRegistry } from '@pezkuwi/types';
+interface Result {
+    metadata: Metadata;
+    registry: TypeRegistry;
+}
+/**
+ * This helper method has been transitioned to work with V14, V15 and up.
+ */
+export declare function initMeta(staticMeta: HexString, extraTypes?: ExtraTypes): Result;
+export {};

package/build/util/initMeta.js

@@ -0,0 +1,19 @@
+import { Metadata, TypeRegistry } from '@pezkuwi/types';
+import { registerDefinitions } from './register.js';
+/**
+ * This helper method has been transitioned to work with V14, V15 and up.
+ */
+export function initMeta(staticMeta, extraTypes = {}) {
+    const registry = new TypeRegistry();
+    registerDefinitions(registry, extraTypes);
+    let metadata;
+    try {
+        const opaqueMetadata = registry.createType('Option<OpaqueMetadata>', registry.createType('Raw', staticMeta).toU8a()).unwrap();
+        metadata = new Metadata(registry, opaqueMetadata.toHex());
+    }
+    catch {
+        metadata = new Metadata(registry, staticMeta);
+    }
+    registry.setMetadata(metadata);
+    return { metadata, registry };
+}

package/build/util/register.d.ts

@@ -0,0 +1,4 @@
+import type { TypeRegistry } from '@pezkuwi/types/create';
+export declare function registerDefinitions(registry: TypeRegistry, extras: Record<string, Record<string, {
+    types: Record<string, any>;
+}>>): void;

package/build/util/register.js

@@ -0,0 +1,7 @@
+export function registerDefinitions(registry, extras) {
+    Object.values(extras).forEach((def) => {
+        Object.values(def).forEach(({ types }) => {
+            registry.register(types);
+        });
+    });
+}

package/build/util/wsMeta.d.ts

@@ -0,0 +1,4 @@
+import type { HexString } from '@pezkuwi/util/types';
+export declare function getMetadataViaWs(endpoint: string, metadataVer?: number): Promise<HexString>;
+export declare function getRpcMethodsViaWs(endpoint: string): Promise<string[]>;
+export declare function getRuntimeVersionViaWs(endpoint: string): Promise<[apiHash: string, apiVersion: number][]>;

package/build/util/wsMeta.js

@@ -0,0 +1,55 @@
+import { promiseTracker } from '@pezkuwi/api/promise/decorateMethod';
+import { TypeRegistry } from '@pezkuwi/types';
+import { stringify, u8aToHex } from '@pezkuwi/util';
+import { WebSocket } from '@pezkuwi/x-ws';
+async function getWsData(endpoint, method, params) {
+    return new Promise((resolve, reject) => {
+        const tracker = promiseTracker(resolve, reject);
+        try {
+            const websocket = new WebSocket(endpoint);
+            websocket.onclose = (event) => {
+                if (event.code !== 1000) {
+                    tracker.reject(new Error(`disconnected, code: '${event.code}' reason: '${event.reason}'`));
+                }
+            };
+            websocket.onerror = (event) => {
+                tracker.reject(new Error(`WebSocket error:: ${stringify(event)}`));
+            };
+            websocket.onopen = () => {
+                console.log('connected');
+                params
+                    ? websocket.send(`{"id":"1","jsonrpc":"2.0","method":"${method}","params":[${params.map((param) => `"${param}"`).join(',')}]}`)
+                    : websocket.send(`{"id":"1","jsonrpc":"2.0","method":"${method}","params":[]}`);
+            };
+            websocket.onmessage = (message) => {
+                try {
+                    tracker.resolve(JSON.parse(message.data).result);
+                }
+                catch (error) {
+                    tracker.reject(error);
+                }
+                websocket.close();
+            };
+        }
+        catch (error) {
+            tracker.reject(error);
+        }
+    });
+}
+export async function getMetadataViaWs(endpoint, metadataVer) {
+    const registry = new TypeRegistry();
+    if (metadataVer) {
+        return await getWsData(endpoint, 'state_call', ['Metadata_metadata_at_version', u8aToHex(registry.createType('u32', metadataVer).toU8a())]);
+    }
+    else {
+        return await getWsData(endpoint, 'state_getMetadata');
+    }
+}
+export async function getRpcMethodsViaWs(endpoint) {
+    const result = await getWsData(endpoint, 'rpc_methods');
+    return result.methods;
+}
+export async function getRuntimeVersionViaWs(endpoint) {
+    const result = await getWsData(endpoint, 'state_getRuntimeVersion');
+    return result.apis;
+}

package/build-tsc-cjs/packageDetect.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packageInfo_1 = require("@pezkuwi/api/packageInfo");
+const packageInfo_2 = require("@pezkuwi/rpc-provider/packageInfo");
+const packageInfo_3 = require("@pezkuwi/types/packageInfo");
+const util_1 = require("@pezkuwi/util");
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_1.packageInfo, packageInfo_2.packageInfo, packageInfo_3.packageInfo]);

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

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.packageInfo = void 0;
-exports.packageInfo = { name: '@pezkuwi/typegen', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '16.5.16' };
+exports.packageInfo = { name: '@pezkuwi/typegen', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '16.5.18' };

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

@@ -0,0 +1,87 @@
+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 { getDeprecationNotice } from './types.js';
+const generateForMetaTemplate = Handlebars.compile(readTemplate('consts'));
+/** @internal */
+function generateForMeta(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, registry } = meta.asLatest;
+        const usedTypes = new Set([]);
+        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((packagePath) => ({
+                    file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
+                    types: Object.keys(imports.localTypes[packagePath])
+                })),
+                {
+                    file: '@pezkuwi/api-base/types',
+                    types: ['ApiTypes', 'AugmentedConst']
+                }
+            ]
+        });
+    });
+}
+/** @internal */
+export function generateDefaultConsts(dest, data, extraTypes = {}, isStrict = false, customLookupDefinitions) {
+    const { metadata } = initMeta(data, extraTypes);
+    return generateForMeta(metadata, dest, extraTypes, isStrict, customLookupDefinitions);
+}