@dedot/codegen 0.0.1-alpha.11

package/generator/TypesGen.js

@@ -0,0 +1,432 @@
+import { stringPascalCase } from '@polkadot/util';
+import { CodecRegistry } from '@dedot/codecs';
+import { isNativeType, normalizeName } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { registry } from '@dedot/types';
+import { TypeImports } from './TypeImports';
+// Skip generate types for these
+// as we do have native types for them
+const SKIP_TYPES = [
+    'BoundedBTreeMap',
+    'BoundedBTreeSet',
+    'BoundedVec',
+    'Box',
+    'BTreeMap',
+    'BTreeSet',
+    'Cow',
+    'Option',
+    'Range',
+    'RangeInclusive',
+    'Result',
+    'WeakBoundedVec',
+    'WrapperKeepOpaque',
+    'WrapperOpaque',
+];
+// These are common & generic types, so we'll remove these from all paths at index 1
+// This helps make the type name shorter
+const PATH_RM_INDEX_1 = ['generic', 'misc', 'pallet', 'traits', 'types'];
+export const BASIC_KNOWN_TYPES = ['BitSequence', 'Bytes', 'BytesLike', 'FixedBytes', 'FixedArray', 'Result'];
+const WRAPPER_TYPE_REGEX = /^(\w+)(<.*>)$/g;
+export class TypesGen {
+    metadata;
+    /**
+     * Types will be generated its definition out.
+     */
+    includedTypes;
+    registry;
+    typeImports;
+    constructor(metadata) {
+        this.metadata = metadata;
+        this.registry = new CodecRegistry(this.metadata);
+        this.includedTypes = this.#includedTypes();
+        this.typeImports = new TypeImports();
+    }
+    generate() {
+        this.clearCache();
+        let defTypeOut = '';
+        Object.values(this.includedTypes)
+            .filter(({ skip, knownType }) => !(skip || knownType))
+            .forEach(({ name, nameOut, id, docs }) => {
+            defTypeOut += `${commentBlock(docs)}export type ${nameOut} = ${this.generateType(id, 0, true)};\n\n`;
+            if (this.#shouldGenerateTypeIn(id)) {
+                defTypeOut += `export type ${name} = ${this.generateType(id)};\n\n`;
+            }
+        });
+        const importTypes = this.typeImports.toImports('./types');
+        const template = compileTemplate('types.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+    typeCache = {};
+    clearCache() {
+        this.typeCache = {};
+        this.typeImports.clear();
+    }
+    generateType(typeId, nestedLevel = 0, typeOut = false) {
+        if (nestedLevel > 0) {
+            const includedDef = this.includedTypes[typeId];
+            // If current typeId has its definition generated,
+            // we can just use its name, no need to generate its type again
+            if (includedDef) {
+                const { name, nameOut } = includedDef;
+                if (typeOut) {
+                    this.addTypeImport(nameOut);
+                    return nameOut;
+                }
+                else {
+                    this.addTypeImport(name);
+                    return name;
+                }
+            }
+        }
+        const typeCacheKey = `${typeId}/${typeOut ? 'typeOut' : 'typeIn'}`;
+        if (this.typeCache[typeCacheKey]) {
+            return this.typeCache[typeCacheKey];
+        }
+        const type = this.#generateType(typeId, nestedLevel, typeOut);
+        this.typeCache[typeCacheKey] = type;
+        const baseType = this.#removeGenericPart(type);
+        if (BASIC_KNOWN_TYPES.includes(baseType)) {
+            this.addTypeImport(baseType);
+        }
+        return type;
+    }
+    #generateType(typeId, nestedLevel = 0, typeOut = false) {
+        const def = this.metadata.types[typeId];
+        if (!def) {
+            throw new Error(`Type def not found ${JSON.stringify(def)}`);
+        }
+        const { type, path, docs } = def;
+        const { tag, value } = type;
+        switch (tag) {
+            case 'Primitive':
+                const $codec = this.registry.findCodec(value.kind);
+                if ($codec.nativeType) {
+                    return $codec.nativeType;
+                }
+                else if (value.kind === 'char') {
+                    return 'string';
+                }
+                else {
+                    throw new Error(`Invalid primitive type: ${value.kind}`);
+                }
+            case 'Struct': {
+                const { fields } = value;
+                if (fields.length === 0) {
+                    return '{}';
+                }
+                else if (!fields[0].name) {
+                    if (fields.length === 1) {
+                        return this.generateType(fields[0].typeId, nestedLevel + 1, typeOut);
+                    }
+                    else {
+                        return `[${fields.map((f) => this.generateType(f.typeId, nestedLevel + 1, typeOut)).join(', ')}]`;
+                    }
+                }
+                else {
+                    return this.generateObjectType(fields, nestedLevel + 1, typeOut);
+                }
+            }
+            case 'Enum': {
+                const { members } = value;
+                if (path.join('::') === 'Option') {
+                    const some = members.find((one) => one.name === 'Some');
+                    if (some) {
+                        return `${this.generateType(some.fields[0].typeId, nestedLevel + 1, typeOut)} | undefined`;
+                    }
+                }
+                else if (path.join('::') === 'Result') {
+                    const ok = members.find((one) => one.name === 'Ok');
+                    const err = members.find((one) => one.name === 'Err');
+                    if (ok && err) {
+                        const OkType = this.generateType(ok.fields[0].typeId, nestedLevel + 1, typeOut);
+                        const ErrType = this.generateType(err.fields[0].typeId, nestedLevel + 1, typeOut);
+                        return `Result<${OkType}, ${ErrType}>`;
+                    }
+                }
+                if (members.length === 0) {
+                    return 'null';
+                }
+                else if (members.every((x) => x.fields.length === 0)) {
+                    return members.map(({ name, docs }) => `${commentBlock(docs)}'${stringPascalCase(name)}'`).join(' | ');
+                }
+                else {
+                    const membersType = [];
+                    for (const { fields, name, docs } of members) {
+                        const keyName = stringPascalCase(name);
+                        if (fields.length === 0) {
+                            membersType.push([keyName, null, docs]);
+                        }
+                        else if (fields[0].name === undefined) {
+                            const valueType = fields.length === 1
+                                ? this.generateType(fields[0].typeId, nestedLevel + 1, typeOut)
+                                : `[${fields
+                                    .map(({ typeId, docs }) => `${commentBlock(docs)}${this.generateType(typeId, nestedLevel + 1, typeOut)}`)
+                                    .join(', ')}]`;
+                            membersType.push([keyName, valueType, docs]);
+                        }
+                        else {
+                            membersType.push([keyName, this.generateObjectType(fields, nestedLevel + 1, typeOut), docs]);
+                        }
+                    }
+                    const { tagKey, valueKey } = this.registry.portableRegistry.getEnumOptions(typeId);
+                    return membersType
+                        .map(([keyName, valueType, docs]) => ({
+                        tag: `${tagKey}: '${keyName}'`,
+                        value: valueType ? `, ${valueKey}${this.#isOptionalType(valueType) ? '?' : ''}: ${valueType} ` : '',
+                        docs,
+                    }))
+                        .map(({ tag, value, docs }) => `${commentBlock(docs)}{ ${tag}${value} }`)
+                        .join(' | ');
+                }
+            }
+            case 'Tuple': {
+                const { fields } = value;
+                if (fields.length === 0) {
+                    return '[]';
+                }
+                else if (fields.length === 1) {
+                    return this.generateType(fields[0], nestedLevel + 1, typeOut);
+                }
+                else {
+                    return `[${fields.map((x) => this.generateType(x, nestedLevel + 1, typeOut)).join(', ')}]`;
+                }
+            }
+            case 'BitSequence':
+                return 'BitSequence';
+            case 'Compact':
+                return this.generateType(value.typeParam, nestedLevel + 1, typeOut);
+            case 'Sequence':
+            case 'SizedVec': {
+                const fixedSize = tag === 'SizedVec' ? `${value.len}` : null;
+                const $innerType = this.metadata.types[value.typeParam].type;
+                if ($innerType.tag === 'Primitive' && $innerType.value.kind === 'u8') {
+                    return fixedSize ? `FixedBytes<${fixedSize}>` : typeOut ? 'Bytes' : 'BytesLike';
+                }
+                else {
+                    const innerType = this.generateType(value.typeParam, nestedLevel + 1, typeOut);
+                    return fixedSize ? `FixedArray<${innerType}, ${fixedSize}>` : `Array<${innerType}>`;
+                }
+            }
+            default:
+                throw new Error(`Invalid type! ${tag}`);
+        }
+    }
+    generateObjectType(fields, nestedLevel = 0, typeOut = false) {
+        const props = fields.map(({ typeId, name, docs }) => {
+            const type = this.generateType(typeId, nestedLevel + 1, typeOut);
+            return {
+                name: normalizeName(name),
+                type,
+                optional: this.#isOptionalType(type),
+                docs,
+            };
+        });
+        return `{${props
+            .map(({ name, type, optional, docs }) => `${commentBlock(docs)}${name}${optional ? '?' : ''}: ${type}`)
+            .join(',\n')}}`;
+    }
+    #isOptionalType(type) {
+        return type.endsWith('| undefined');
+    }
+    #includedTypes() {
+        const { types } = this.metadata;
+        const pathsCount = new Map();
+        const typesWithPath = types.filter((one) => one.path.length > 0);
+        const skipIds = [];
+        const typeSuffixes = new Map();
+        typesWithPath.forEach(({ path, id }) => {
+            const joinedPath = path.join('::');
+            if (pathsCount.has(joinedPath)) {
+                // We compare 2 types with the same path here,
+                //  if they are the same type -> skip the current one, keep the first occurrence
+                //  if they are not the same type but has the same path -> we'll try to calculate & add a suffix for the current type name
+                const firstOccurrenceTypeId = pathsCount.get(joinedPath)[0];
+                const sameType = this.typeEql(firstOccurrenceTypeId, id);
+                if (sameType) {
+                    skipIds.push(id);
+                }
+                else {
+                    pathsCount.get(joinedPath).push(id);
+                    typeSuffixes.set(id, this.#extractDupTypeSuffix(id, firstOccurrenceTypeId, pathsCount.get(joinedPath).length));
+                }
+            }
+            else {
+                pathsCount.set(joinedPath, [id]);
+            }
+        });
+        return typesWithPath.reduce((o, type) => {
+            const { path, id } = type;
+            const joinedPath = path.join('::');
+            if (SKIP_TYPES.includes(joinedPath) || SKIP_TYPES.includes(path.at(-1))) {
+                return o;
+            }
+            const suffix = typeSuffixes.get(id) || '';
+            let knownType = false;
+            let name, nameOut;
+            if (this.registry.isKnownType(joinedPath)) {
+                const codecType = this.registry.findCodecType(path.at(-1));
+                name = codecType.typeIn;
+                nameOut = codecType.typeOut;
+                knownType = true;
+            }
+            else if (PATH_RM_INDEX_1.includes(path[1])) {
+                const newPath = path.slice();
+                newPath.splice(1, 1);
+                name = this.#cleanPath(newPath);
+            }
+            else {
+                name = this.#cleanPath(path);
+            }
+            if (this.#shouldGenerateTypeIn(id)) {
+                nameOut = name;
+                name = name.endsWith('Like') ? name : `${name}Like`;
+            }
+            o[id] = {
+                name: `${name}${suffix}`,
+                nameOut: nameOut ? `${nameOut}${suffix}` : `${name}${suffix}`,
+                knownType,
+                skip: skipIds.includes(id),
+                ...type,
+            };
+            return o;
+        }, {});
+    }
+    #removeGenericPart(typeName) {
+        if (typeName.match(WRAPPER_TYPE_REGEX)) {
+            return typeName.replace(WRAPPER_TYPE_REGEX, (_, $1) => $1);
+        }
+        else {
+            return typeName;
+        }
+    }
+    /**
+     * @description Remove duplicated part of the path
+     *
+     * Example:
+     * ["pallet_staking", "pallet", "pallet", "Event"]
+     * => ["pallet_staking", "pallet", "Event"]
+     *
+     * @param path
+     * @private
+     */
+    #cleanPath(path) {
+        return path
+            .map((one) => stringPascalCase(one))
+            .filter((one, idx, currentPath) => idx === 0 || one !== currentPath[idx - 1])
+            .join('');
+    }
+    #shouldGenerateTypeIn(id) {
+        const { callTypeId } = this.metadata.extrinsic;
+        const palletCallTypeIds = this.registry.portableRegistry.getPalletCallTypeIds();
+        return callTypeId === id || palletCallTypeIds.includes(id);
+    }
+    eqlCache = new Map();
+    typeEql(idA, idB, level = 0) {
+        const cacheKey = `${idA}==${idB}`;
+        if (!this.eqlCache.has(cacheKey)) {
+            this.eqlCache.set(cacheKey, true);
+            this.eqlCache.set(cacheKey, this.#typeEql(idA, idB, level));
+        }
+        return this.eqlCache.get(cacheKey);
+    }
+    #typeEql(idA, idB, lvl = 0) {
+        if (idA === idB)
+            return true;
+        const { types } = this.metadata;
+        const typeA = types[idA];
+        const typeB = types[idB];
+        if (typeA.path.join('::') !== typeB.path.join('::'))
+            return false;
+        const { type: defA, params: paramsA } = typeA;
+        const { type: defB, params: paramsB } = typeB;
+        if (!this.#eqlArray(paramsA, paramsB, (valA, valB) => this.#eqlTypeParam(valA, valB))) {
+            return false;
+        }
+        if (defA.tag !== defB.tag)
+            return false;
+        if (defA.tag === 'BitSequence')
+            return true;
+        if (defA.tag === 'Primitive' && defB.tag === 'Primitive') {
+            return defA.value.kind === defB.value.kind;
+        }
+        if ((defA.tag === 'Compact' && defB.tag === 'Compact') || (defA.tag === 'Sequence' && defB.tag === 'Sequence')) {
+            return this.typeEql(defA.value.typeParam, defB.value.typeParam, lvl + 1);
+        }
+        if (defA.tag === 'SizedVec' && defB.tag === 'SizedVec') {
+            return defA.value.len === defB.value.len && this.typeEql(defA.value.typeParam, defB.value.typeParam, lvl + 1);
+        }
+        if (defA.tag === 'Tuple' && defB.tag === 'Tuple') {
+            return this.#eqlArray(defA.value.fields, defB.value.fields, (val1, val2) => this.typeEql(val1, val2, lvl + 1));
+        }
+        if (defA.tag === 'Struct' && defB.tag === 'Struct') {
+            return this.#eqlFields(defA.value.fields, defB.value.fields, lvl);
+        }
+        if (defA.tag === 'Enum' && defB.tag === 'Enum') {
+            return this.#eqlArray(defA.value.members, defB.value.members, (val1, val2) => val1.name === val2.name && val1.index === val2.index && this.#eqlFields(val1.fields, val2.fields, lvl));
+        }
+        return false;
+    }
+    #eqlArray(arr1, arr2, eqlVal) {
+        return arr1.length === arr2.length && arr1.every((e1, idx) => eqlVal(e1, arr2[idx]));
+    }
+    #eqlFields(arr1, arr2, lvl) {
+        return this.#eqlArray(arr1, arr2, (val1, val2) => val1.name === val2.name && val1.typeName === val2.typeName && this.#typeEql(val1.typeId, val2.typeId));
+    }
+    #eqlTypeParam(param1, param2) {
+        return (param1.name === param2.name &&
+            (param1.typeId === undefined) === (param2.typeId === undefined) &&
+            (param1.typeId === undefined || this.#typeEql(param1.typeId, param2.typeId)));
+    }
+    #extractDupTypeSuffix(dupTypeId, originalTypeId, dupCount) {
+        const { types } = this.metadata;
+        const originalTypeParams = types[originalTypeId].params;
+        const dupTypeParams = types[dupTypeId].params;
+        const diffParam = dupTypeParams.find((one, idx) => !this.#eqlTypeParam(one, originalTypeParams[idx]));
+        // TODO make sure these suffix is unique if a type is duplicated more than 2 times
+        if (diffParam?.typeId) {
+            const diffType = types[diffParam.typeId];
+            if (diffType.path.length > 0) {
+                return stringPascalCase(diffType.path.at(-1));
+            }
+            else if (diffType.type.tag === 'Primitive') {
+                return stringPascalCase(diffType.type.value.kind);
+            }
+        }
+        // Last resort!
+        return dupCount.toString().padStart(3, '0');
+    }
+    addTypeImport(typeName) {
+        if (Array.isArray(typeName)) {
+            typeName.forEach((one) => this.addTypeImport(one));
+            return;
+        }
+        if (isNativeType(typeName)) {
+            return;
+        }
+        for (let type of Object.values(this.includedTypes)) {
+            if (type.skip) {
+                continue;
+            }
+            const { name, nameOut, knownType } = type;
+            if (name === typeName || nameOut === typeName) {
+                if (knownType) {
+                    this.typeImports.addCodecType(typeName);
+                }
+                else {
+                    this.typeImports.addPortableType(typeName);
+                }
+                return;
+            }
+        }
+        if (BASIC_KNOWN_TYPES.includes(typeName)) {
+            this.typeImports.addCodecType(typeName);
+            return;
+        }
+        if (registry.has(typeName)) {
+            this.typeImports.addKnownType(typeName);
+        }
+        else {
+            this.typeImports.addOutType(typeName);
+        }
+    }
+}

package/generator/dirname.d.ts

@@ -0,0 +1 @@
+export function currentDirname(): string;

package/generator/dirname.js

@@ -0,0 +1,6 @@
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+export const currentDirname = () => {
+    const __filename = fileURLToPath(import.meta.url);
+    return dirname(__filename);
+};

package/generator/index.d.ts

@@ -0,0 +1,10 @@
+export * from './TypesGen';
+export * from './ApiGen';
+export * from './ConstsGen';
+export * from './QueryGen';
+export * from './RpcGen';
+export * from './IndexGen';
+export * from './ErrorsGen';
+export * from './EventsGen';
+export * from './TxGen';
+export * from './RuntimeApisGen';

package/generator/index.js

@@ -0,0 +1,10 @@
+export * from './TypesGen';
+export * from './ApiGen';
+export * from './ConstsGen';
+export * from './QueryGen';
+export * from './RpcGen';
+export * from './IndexGen';
+export * from './ErrorsGen';
+export * from './EventsGen';
+export * from './TxGen';
+export * from './RuntimeApisGen';

package/generator/utils.d.ts

@@ -0,0 +1,10 @@
+export declare const WRAPPER_TYPE_REGEX: RegExp;
+export declare const TUPLE_TYPE_REGEX: RegExp;
+export declare const commentBlock: (...docs: (string | string[])[]) => string;
+export declare const beautifySourceCode: (source: string) => Promise<string>;
+export declare const compileTemplate: (templateFileName: string) => HandlebarsTemplateDelegate<any>;
+/**
+ * Check if a word is TypeScript/JavaScript reserved
+ * @param word
+ */
+export declare const isReservedWord: (word: string) => boolean;

package/generator/utils.js

@@ -0,0 +1,35 @@
+import * as fs from 'fs';
+import handlebars from 'handlebars';
+import * as path from 'path';
+import * as prettier from 'prettier';
+import { currentDirname } from './dirname';
+export const WRAPPER_TYPE_REGEX = /^(\w+)<(.*)>$/;
+export const TUPLE_TYPE_REGEX = /^\[(.*)]$/;
+export const commentBlock = (...docs) => {
+    const flatLines = docs.flat();
+    if (flatLines.length === 0) {
+        return '';
+    }
+    else {
+        return `
+/**
+${flatLines.map((line) => `* ${line.replaceAll(/\s+/g, ' ').trim()}`).join('\n')}
+ **/
+      `;
+    }
+};
+export const beautifySourceCode = async (source) => {
+    const prettierOptions = await prettier.resolveConfig(path.resolve(currentDirname(), '../../../../.prettierrc.js'));
+    return prettier.format(source, { parser: 'babel-ts', ...prettierOptions });
+};
+export const compileTemplate = (templateFileName) => {
+    const templateFilePath = path.resolve(currentDirname(), `../templates/${templateFileName}`);
+    return handlebars.compile(fs.readFileSync(templateFilePath, 'utf8'));
+};
+// TODO add more reserved words
+const TS_RESERVED_WORDS = ['new', 'class'];
+/**
+ * Check if a word is TypeScript/JavaScript reserved
+ * @param word
+ */
+export const isReservedWord = (word) => TS_RESERVED_WORDS.includes(word);

package/index.d.ts

@@ -0,0 +1,4 @@
+import { MetadataLatest } from '@dedot/codecs';
+import { NetworkInfo } from './types';
+export declare function generateTypesFromChain(network: NetworkInfo, endpoint: string, outDir: string): Promise<void>;
+export declare function generateTypes(network: NetworkInfo, metadata: MetadataLatest, rpcMethods: string[], runtimeApis: any[], outDir?: string): Promise<void>;

package/index.js

@@ -0,0 +1,48 @@
+import { Dedot } from 'dedot';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ConstsGen, ErrorsGen, EventsGen, IndexGen, QueryGen, RpcGen, RuntimeApisGen, TxGen, TypesGen, } from './generator';
+import { stringCamelCase } from '@polkadot/util';
+export async function generateTypesFromChain(network, endpoint, outDir) {
+    const api = await Dedot.create(endpoint);
+    const { methods } = await api.rpc.rpc.methods();
+    const apis = api.runtimeVersion?.apis || [];
+    if (!network.chain) {
+        network.chain = stringCamelCase(api.runtimeVersion?.specName || api.runtimeChain || 'local');
+    }
+    await generateTypes(network, api.metadataLatest, methods, apis, outDir);
+    await api.disconnect();
+}
+export async function generateTypes(network, metadata, rpcMethods, runtimeApis, outDir = '.') {
+    const dirPath = path.resolve(outDir, network.chain);
+    const defTypesFileName = path.join(dirPath, `types.ts`);
+    const constsTypesFileName = path.join(dirPath, `consts.ts`);
+    const queryTypesFileName = path.join(dirPath, `query.ts`);
+    const rpcCallsFileName = path.join(dirPath, `rpc.ts`);
+    const indexFileName = path.join(dirPath, `index.ts`);
+    const errorsFileName = path.join(dirPath, `errors.ts`);
+    const eventsFileName = path.join(dirPath, `events.ts`);
+    const runtimeApisFileName = path.join(dirPath, `runtime.ts`);
+    const txFileName = path.join(dirPath, `tx.ts`);
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+    const typesGen = new TypesGen(metadata);
+    const constsGen = new ConstsGen(typesGen);
+    const queryGen = new QueryGen(typesGen);
+    const rpcGen = new RpcGen(typesGen, rpcMethods);
+    const indexGen = new IndexGen(network);
+    const errorsGen = new ErrorsGen(typesGen);
+    const eventsGen = new EventsGen(typesGen);
+    const runtimeApisGen = new RuntimeApisGen(typesGen, runtimeApis);
+    const txGen = new TxGen(typesGen);
+    fs.writeFileSync(defTypesFileName, await typesGen.generate());
+    fs.writeFileSync(errorsFileName, await errorsGen.generate());
+    fs.writeFileSync(eventsFileName, await eventsGen.generate());
+    fs.writeFileSync(rpcCallsFileName, await rpcGen.generate());
+    fs.writeFileSync(queryTypesFileName, await queryGen.generate());
+    fs.writeFileSync(constsTypesFileName, await constsGen.generate());
+    fs.writeFileSync(txFileName, await txGen.generate());
+    fs.writeFileSync(indexFileName, await indexGen.generate());
+    fs.writeFileSync(runtimeApisFileName, await runtimeApisGen.generate());
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@dedot/codegen",
+  "version": "0.0.1-alpha.11+b5ca298",
+  "description": "Generate types",
+  "author": "Thang X. Vu <thang@coongcrafts.io>",
+  "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/codegen",
+  "repository": {
+    "directory": "packages/codegen",
+    "type": "git",
+    "url": "https://github.com/dedotdev/dedot.git"
+  },
+  "main": "./cjs/index.js",
+  "type": "module",
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json && yarn copy",
+    "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo",
+    "copy": "cp -R ./src/templates ./dist && cp -R ./src/templates ./dist/cjs"
+  },
+  "dependencies": {
+    "@dedot/codecs": "0.0.1-alpha.11+b5ca298",
+    "@dedot/shape": "0.0.1-alpha.11+b5ca298",
+    "@dedot/specs": "0.0.1-alpha.11+b5ca298",
+    "@dedot/utils": "0.0.1-alpha.11+b5ca298",
+    "@polkadot/util": "^12.6.2",
+    "dedot": "0.0.1-alpha.11+b5ca298",
+    "handlebars": "^4.7.8",
+    "prettier": "^3.0.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "license": "Apache-2.0",
+  "gitHead": "b5ca298916c21e2e490bb121275eb49b4b247fd9",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./cjs/index.js"
+      }
+    }
+  }
+}

package/packageInfo.d.ts

@@ -0,0 +1,4 @@
+export declare const packageInfo: {
+    name: string;
+    version: string;
+};

package/packageInfo.js

@@ -0,0 +1,2 @@
+// THIS FILE IS AUTO-GENERATED, DO NOT EDIT!
+export const packageInfo = { name: '@dedot/codegen', version: '0.0.1-alpha.24' };

package/templates/consts.hbs

@@ -0,0 +1,7 @@
+// Generated by @dedot/codegen
+
+{{{ importTypes }}}
+
+export interface ChainConsts extends GenericChainConsts {
+  {{{ defTypeOut }}}
+}

package/templates/errors.hbs

@@ -0,0 +1,7 @@
+// Generated by @dedot/codegen
+
+{{{ importTypes }}}
+
+export interface ChainErrors extends GenericChainErrors {
+  {{{ defTypeOut }}}
+}

package/templates/events.hbs

@@ -0,0 +1,7 @@
+// Generated by @dedot/codegen
+
+{{{ importTypes }}}
+
+export interface ChainEvents extends GenericChainEvents {
+  {{{ defTypeOut }}}
+}

package/templates/index.hbs

@@ -0,0 +1,22 @@
+// Generated by @dedot/codegen
+
+import { GenericSubstrateApi } from '@dedot/types';
+import { ChainConsts } from './consts';
+import { ChainStorage } from './query';
+import { RpcCalls } from './rpc';
+import { ChainErrors } from './errors';
+import { ChainEvents } from './events';
+import { RuntimeApis } from './runtime';
+import { ChainTx } from './tx';
+
+export * from './types';
+
+export interface {{{interfaceName}}}Api extends GenericSubstrateApi {
+  rpc: RpcCalls;
+  consts: ChainConsts;
+  query: ChainStorage;
+  errors: ChainErrors;
+  events: ChainEvents;
+  call: RuntimeApis;
+  tx: ChainTx;
+}