@dedot/codegen 0.0.1-alpha.11

package/cjs/generator/TypesGen.js

@@ -0,0 +1,436 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypesGen = exports.BASIC_KNOWN_TYPES = void 0;
+const util_1 = require("@polkadot/util");
+const codecs_1 = require("@dedot/codecs");
+const utils_1 = require("@dedot/utils");
+const utils_2 = require("./utils");
+const types_1 = require("@dedot/types");
+const TypeImports_1 = require("./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'];
+exports.BASIC_KNOWN_TYPES = ['BitSequence', 'Bytes', 'BytesLike', 'FixedBytes', 'FixedArray', 'Result'];
+const WRAPPER_TYPE_REGEX = /^(\w+)(<.*>)$/g;
+class TypesGen {
+    metadata;
+    /**
+     * Types will be generated its definition out.
+     */
+    includedTypes;
+    registry;
+    typeImports;
+    constructor(metadata) {
+        this.metadata = metadata;
+        this.registry = new codecs_1.CodecRegistry(this.metadata);
+        this.includedTypes = this.#includedTypes();
+        this.typeImports = new TypeImports_1.TypeImports();
+    }
+    generate() {
+        this.clearCache();
+        let defTypeOut = '';
+        Object.values(this.includedTypes)
+            .filter(({ skip, knownType }) => !(skip || knownType))
+            .forEach(({ name, nameOut, id, docs }) => {
+            defTypeOut += `${(0, utils_2.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 = (0, utils_2.compileTemplate)('types.hbs');
+        return (0, utils_2.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 (exports.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 }) => `${(0, utils_2.commentBlock)(docs)}'${(0, util_1.stringPascalCase)(name)}'`).join(' | ');
+                }
+                else {
+                    const membersType = [];
+                    for (const { fields, name, docs } of members) {
+                        const keyName = (0, util_1.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 }) => `${(0, utils_2.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 }) => `${(0, utils_2.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: (0, utils_1.normalizeName)(name),
+                type,
+                optional: this.#isOptionalType(type),
+                docs,
+            };
+        });
+        return `{${props
+            .map(({ name, type, optional, docs }) => `${(0, utils_2.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) => (0, util_1.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 (0, util_1.stringPascalCase)(diffType.path.at(-1));
+            }
+            else if (diffType.type.tag === 'Primitive') {
+                return (0, util_1.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 ((0, utils_1.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 (exports.BASIC_KNOWN_TYPES.includes(typeName)) {
+            this.typeImports.addCodecType(typeName);
+            return;
+        }
+        if (types_1.registry.has(typeName)) {
+            this.typeImports.addKnownType(typeName);
+        }
+        else {
+            this.typeImports.addOutType(typeName);
+        }
+    }
+}
+exports.TypesGen = TypesGen;

package/cjs/generator/dirname.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentDirname = () => {
+    return __dirname;
+};

package/cjs/generator/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./TypesGen"), exports);
+__exportStar(require("./ApiGen"), exports);
+__exportStar(require("./ConstsGen"), exports);
+__exportStar(require("./QueryGen"), exports);
+__exportStar(require("./RpcGen"), exports);
+__exportStar(require("./IndexGen"), exports);
+__exportStar(require("./ErrorsGen"), exports);
+__exportStar(require("./EventsGen"), exports);
+__exportStar(require("./TxGen"), exports);
+__exportStar(require("./RuntimeApisGen"), exports);

package/cjs/generator/utils.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReservedWord = exports.compileTemplate = exports.beautifySourceCode = exports.commentBlock = exports.TUPLE_TYPE_REGEX = exports.WRAPPER_TYPE_REGEX = void 0;
+const fs = __importStar(require("fs"));
+const handlebars_1 = __importDefault(require("handlebars"));
+const path = __importStar(require("path"));
+const prettier = __importStar(require("prettier"));
+const dirname_1 = require("./dirname");
+exports.WRAPPER_TYPE_REGEX = /^(\w+)<(.*)>$/;
+exports.TUPLE_TYPE_REGEX = /^\[(.*)]$/;
+const commentBlock = (...docs) => {
+    const flatLines = docs.flat();
+    if (flatLines.length === 0) {
+        return '';
+    }
+    else {
+        return `
+/**
+${flatLines.map((line) => `* ${line.replaceAll(/\s+/g, ' ').trim()}`).join('\n')}
+ **/
+      `;
+    }
+};
+exports.commentBlock = commentBlock;
+const beautifySourceCode = async (source) => {
+    const prettierOptions = await prettier.resolveConfig(path.resolve((0, dirname_1.currentDirname)(), '../../../../.prettierrc.js'));
+    return prettier.format(source, { parser: 'babel-ts', ...prettierOptions });
+};
+exports.beautifySourceCode = beautifySourceCode;
+const compileTemplate = (templateFileName) => {
+    const templateFilePath = path.resolve((0, dirname_1.currentDirname)(), `../templates/${templateFileName}`);
+    return handlebars_1.default.compile(fs.readFileSync(templateFilePath, 'utf8'));
+};
+exports.compileTemplate = compileTemplate;
+// TODO add more reserved words
+const TS_RESERVED_WORDS = ['new', 'class'];
+/**
+ * Check if a word is TypeScript/JavaScript reserved
+ * @param word
+ */
+const isReservedWord = (word) => TS_RESERVED_WORDS.includes(word);
+exports.isReservedWord = isReservedWord;

package/cjs/index.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypes = exports.generateTypesFromChain = void 0;
+const dedot_1 = require("dedot");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const generator_1 = require("./generator");
+const util_1 = require("@polkadot/util");
+async function generateTypesFromChain(network, endpoint, outDir) {
+    const api = await dedot_1.Dedot.create(endpoint);
+    const { methods } = await api.rpc.rpc.methods();
+    const apis = api.runtimeVersion?.apis || [];
+    if (!network.chain) {
+        network.chain = (0, util_1.stringCamelCase)(api.runtimeVersion?.specName || api.runtimeChain || 'local');
+    }
+    await generateTypes(network, api.metadataLatest, methods, apis, outDir);
+    await api.disconnect();
+}
+exports.generateTypesFromChain = generateTypesFromChain;
+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 generator_1.TypesGen(metadata);
+    const constsGen = new generator_1.ConstsGen(typesGen);
+    const queryGen = new generator_1.QueryGen(typesGen);
+    const rpcGen = new generator_1.RpcGen(typesGen, rpcMethods);
+    const indexGen = new generator_1.IndexGen(network);
+    const errorsGen = new generator_1.ErrorsGen(typesGen);
+    const eventsGen = new generator_1.EventsGen(typesGen);
+    const runtimeApisGen = new generator_1.RuntimeApisGen(typesGen, runtimeApis);
+    const txGen = new generator_1.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());
+}
+exports.generateTypes = generateTypes;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/cjs/packageInfo.js

@@ -0,0 +1,5 @@
+"use strict";
+// THIS FILE IS AUTO-GENERATED, DO NOT EDIT!
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+exports.packageInfo = { name: '@dedot/codegen', version: '0.0.1-alpha.24' };

package/cjs/templates/consts.hbs

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

package/cjs/templates/errors.hbs

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

package/cjs/templates/events.hbs

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

package/cjs/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;
+}

package/cjs/templates/query.hbs

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