@dedot/codegen 0.0.1-alpha.4 → 0.0.1-alpha.40

package/cjs/chaintypes/generator/RuntimeApisGen.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeApisGen = void 0;
+const runtime_specs_1 = require("@dedot/runtime-specs");
+const utils_1 = require("@dedot/utils");
+const index_js_1 = require("../../shared/index.js");
+const utils_js_1 = require("../../utils.js");
+const ApiGen_js_1 = require("./ApiGen.js");
+class RuntimeApisGen extends ApiGen_js_1.ApiGen {
+    typesGen;
+    runtimeApis;
+    constructor(typesGen, runtimeApis) {
+        super(typesGen);
+        this.typesGen = typesGen;
+        this.runtimeApis = runtimeApis;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericRuntimeApis', 'GenericRuntimeApiMethod', 'RpcVersion');
+        let runtimeCallsOut = '';
+        if (this.metadata.apis.length > 0) {
+            this.metadata.apis.forEach((runtimeApi) => {
+                const { name: runtimeApiName, methods } = runtimeApi;
+                runtimeCallsOut += (0, utils_js_1.commentBlock)(`@runtimeapi: ${runtimeApiName} - ${(0, utils_1.calcRuntimeApiHash)(runtimeApiName)}`);
+                runtimeCallsOut += `${(0, utils_1.stringCamelCase)(runtimeApiName)}: {
+            ${methods.map((method) => this.#generateMethodDef(runtimeApiName, method)).join('\n')} 
+              
+            ${(0, utils_js_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
+        }`;
+            });
+        }
+        else {
+            const specs = this.#targetRuntimeApiSpecs();
+            specs.forEach(({ methods, runtimeApiName, runtimeApiHash, version }) => {
+                runtimeCallsOut += (0, utils_js_1.commentBlock)(`@runtimeapi: ${runtimeApiName} - ${runtimeApiHash}`, `@version: ${version}`);
+                runtimeCallsOut += `${(0, utils_1.stringCamelCase)(runtimeApiName)}: {
+            ${Object.keys(methods)
+                    .map((methodName) => this.#generateMethodDefFromSpec({
+                    ...methods[methodName],
+                    runtimeApiName,
+                    methodName,
+                }))
+                    .join('\n')} 
+              
+            ${(0, utils_js_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
+          }`;
+            });
+        }
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('chaintypes/templates/runtime.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, runtimeCallsOut }));
+    }
+    #isOptionalType(type) {
+        return type.startsWith('Option<') || type.endsWith('| undefined');
+    }
+    #isOptionalParam(params, type, idx) {
+        return this.#isOptionalType(type) && params.slice(idx + 1).every(({ type }) => this.#isOptionalType(type));
+    }
+    #generateMethodDefFromSpec(spec) {
+        const { docs = [], params, type, runtimeApiName, methodName } = spec;
+        const callName = `${runtimeApiName}_${(0, utils_1.stringSnakeCase)(methodName)}`;
+        const defaultDocs = [`@callname: ${callName}`];
+        this.#addTypeImport(type, false);
+        params.forEach(({ type }) => this.#addTypeImport(type));
+        const typedParams = params.map((param, idx) => ({
+            ...param,
+            isOptional: this.#isOptionalParam(params, param.type, idx),
+            plainType: this.#getGeneratedTypeName(param.type),
+        }));
+        const paramsOut = typedParams
+            .map(({ name, isOptional, plainType }) => `${(0, utils_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${plainType}`)
+            .join(', ');
+        const typeOut = this.#getGeneratedTypeName(type, false);
+        return `${(0, utils_js_1.commentBlock)(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
+    }
+    #generateMethodDef(runtimeApiName, methodDef) {
+        const { name: methodName, inputs, output, docs } = methodDef;
+        const callName = `${runtimeApiName}_${(0, utils_1.stringSnakeCase)(methodName)}`;
+        const defaultDocs = [`@callname: ${callName}`];
+        const typeOut = this.typesGen.generateType(output, 1, true);
+        this.#addTypeImport(typeOut, false);
+        const typedInputs = inputs
+            .map((input, idx) => ({
+            ...input,
+            type: this.typesGen.generateType(input.typeId, 1),
+        }))
+            .map((input, idx, inputs) => ({
+            ...input,
+            isOptional: this.#isOptionalParam(inputs, input.type, idx),
+        }));
+        this.#addTypeImport(typedInputs.map((t) => t.type));
+        const paramsOut = typedInputs
+            .map(({ name, type, isOptional }) => `${(0, utils_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${type}`)
+            .join(', ');
+        return `${(0, utils_js_1.commentBlock)(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${(0, utils_1.stringCamelCase)(methodName)}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
+    }
+    #targetRuntimeApiSpecs() {
+        const specs = Object.entries(this.runtimeApis).map(([runtimeApiHash, version]) => {
+            const runtimeApiSpec = this.#findRuntimeApiSpec(runtimeApiHash, version);
+            if (!runtimeApiSpec)
+                return;
+            return {
+                ...runtimeApiSpec,
+                runtimeApiHash,
+            };
+        });
+        return specs.reduce((o, spec) => {
+            if (!spec) {
+                return o;
+            }
+            return [...o, spec];
+        }, []);
+    }
+    #findRuntimeApiSpec = (runtimeApiHash, version) => {
+        const runtimeApiName = (0, runtime_specs_1.getRuntimeApiNames)().find((one) => (0, utils_1.calcRuntimeApiHash)(one) === runtimeApiHash);
+        return (0, runtime_specs_1.getRuntimeApiSpecs)().find((one) => one.runtimeApiName === runtimeApiName && one.version === version);
+    };
+    // TODO check typeIn, typeOut if param type, or rpc type isScale
+    #addTypeImport(type, toTypeIn = true) {
+        if (Array.isArray(type)) {
+            type.forEach((one) => this.#addTypeImport(one, toTypeIn));
+            return;
+        }
+        type = type.trim();
+        if ((0, utils_js_1.isNativeType)(type)) {
+            return;
+        }
+        // Handle generic wrapper types
+        const matchArray = type.match(utils_js_1.WRAPPER_TYPE_REGEX);
+        if (matchArray) {
+            const [_, $1, $2] = matchArray;
+            this.#addTypeImport($1, toTypeIn);
+            if ($2.match(utils_js_1.WRAPPER_TYPE_REGEX) || $2.match(utils_js_1.TUPLE_TYPE_REGEX)) {
+                this.#addTypeImport($2, toTypeIn);
+            }
+            else {
+                this.#addTypeImport($2.split(','), toTypeIn);
+            }
+            return;
+        }
+        // Check tuple type
+        if (type.match(utils_js_1.TUPLE_TYPE_REGEX)) {
+            this.#addTypeImport(type.slice(1, -1).split(','), toTypeIn);
+            return;
+        }
+        if (type.includes(' | ')) {
+            this.#addTypeImport(type.split(' | ').map((one) => one.trim()), toTypeIn);
+            return;
+        }
+        try {
+            const codecType = this.#getCodecType(type, toTypeIn);
+            if ((0, utils_js_1.isNativeType)(codecType))
+                return;
+            this.typesGen.typeImports.addCodecType(codecType);
+            return;
+        }
+        catch (e) { }
+        this.typesGen.addTypeImport(type);
+    }
+    #getGeneratedTypeName(type, toTypeIn = true) {
+        try {
+            const matchArray = type.match(utils_js_1.WRAPPER_TYPE_REGEX);
+            if (matchArray) {
+                const [_, $1, $2] = matchArray;
+                const wrapperTypeName = this.#getCodecType($1, toTypeIn);
+                if ($2.match(utils_js_1.WRAPPER_TYPE_REGEX) || $2.match(utils_js_1.TUPLE_TYPE_REGEX)) {
+                    return `${wrapperTypeName}<${this.#getGeneratedTypeName($2, toTypeIn)}>`;
+                }
+                const innerTypeNames = $2
+                    .split(',')
+                    .map((one) => this.#getGeneratedTypeName(one.trim(), toTypeIn))
+                    .join(', ');
+                return `${wrapperTypeName}<${innerTypeNames}>`;
+            }
+            else if (type.match(utils_js_1.TUPLE_TYPE_REGEX)) {
+                const innerTypeNames = type
+                    .slice(1, -1)
+                    .split(',')
+                    .map((one) => this.#getGeneratedTypeName(one.trim(), toTypeIn))
+                    .join(', ');
+                return `[${innerTypeNames}]`;
+            }
+            return this.#getCodecType(type, toTypeIn);
+        }
+        catch (e) { }
+        return type;
+    }
+    #getCodecType(type, toTypeIn = true) {
+        const { typeIn, typeOut } = (0, index_js_1.findKnownCodecType)(type);
+        return toTypeIn ? typeIn : typeOut;
+    }
+}
+exports.RuntimeApisGen = RuntimeApisGen;

package/cjs/{generator → chaintypes/generator}/TxGen.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxGen = void 0;
-const generator_1 = require("../generator");
-const util_1 = require("@polkadot/util");
-const utils_1 = require("./utils");
-class TxGen extends generator_1.ApiGen {
-    generate() {
+const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("../../utils.js");
+const index_js_1 = require("../generator/index.js");
+class TxGen extends index_js_1.ApiGen {
+    generate(useSubPaths = false) {
         const { pallets, types } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainTx', 'GenericTxCall', 'ISubmittableExtrinsic', 'ISubmittableResult', 'IRuntimeTxCall');
+        this.typesGen.typeImports.addKnownType('GenericChainTx', 'GenericTxCall', 'ISubmittableExtrinsic', 'ISubmittableResult', 'IRuntimeTxCall', 'RpcVersion', 'RpcV2', 'ISubmittableExtrinsicLegacy', 'TransactionEvent');
         const { callTypeId, addressTypeId, signatureTypeId } = this.metadata.extrinsic;
         const callTypeIn = this.typesGen.generateType(callTypeId, 1);
         const addressTypeIn = this.typesGen.generateType(addressTypeId, 1);
@@ -20,15 +20,15 @@ class TxGen extends generator_1.ApiGen {
         for (let pallet of pallets) {
             if (pallet.calls === undefined)
                 continue;
-            const { type } = types[pallet.calls];
-            if (type.tag !== 'Enum')
+            const { typeDef } = types[pallet.calls];
+            if (typeDef.type !== 'Enum')
                 continue;
-            const isFlatEnum = type.value.members.every((m) => m.fields.length === 0);
-            const typedTxs = type.value.members
+            const isFlatEnum = typeDef.value.members.every((m) => m.fields.length === 0);
+            const typedTxs = typeDef.value.members
                 .map((one) => ({
-                functionName: (0, util_1.stringCamelCase)(one.name),
+                functionName: (0, utils_1.stringCamelCase)(one.name),
                 params: one.fields.map((f) => ({
-                    name: (0, util_1.stringCamelCase)(f.name),
+                    name: (0, utils_1.stringCamelCase)(f.name),
                     normalizedName: this.#normalizeParamName(f.name),
                     type: this.typesGen.generateType(f.typeId, 1),
                     docs: f.docs,
@@ -38,33 +38,35 @@ class TxGen extends generator_1.ApiGen {
                 .map((f) => {
                 return {
                     ...f,
-                    callInput: this.#generateCallInput((0, util_1.stringPascalCase)(pallet.name), (0, util_1.stringPascalCase)(f.functionName), !isFlatEnum ? f.params.map((p) => `${p.name}: ${p.type}`) : undefined),
+                    callInput: this.#generateCallInput((0, utils_1.stringPascalCase)(pallet.name), (0, utils_1.stringPascalCase)(f.functionName), !isFlatEnum ? f.params.map((p) => `${p.name}: ${p.type}`) : undefined),
                 };
             });
-            txDefsOut += (0, utils_1.commentBlock)(`Pallet \`${pallet.name}\`'s transaction calls`);
-            txDefsOut += `${(0, util_1.stringCamelCase)(pallet.name)}: {
+            txDefsOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s transaction calls`);
+            txDefsOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
           ${typedTxs
-                .map(({ functionName, params, docs, callInput }) => `${(0, utils_1.commentBlock)(docs, '\n', params.map((p) => `@param {${p.type}} ${p.normalizedName} ${p.docs}`))}${functionName}: GenericTxCall<(${params.map((p) => `${p.normalizedName}: ${p.type}`).join(', ')}) => ChainSubmittableExtrinsic<${callInput}>>`)
+                .map(({ functionName, params, docs, callInput }) => `${(0, utils_js_1.commentBlock)(docs, '\n', params.map((p) => `@param {${p.type}} ${p.normalizedName} ${p.docs}`))}${functionName}: GenericTxCall<Rv, (${params.map((p) => `${p.normalizedName}: ${p.type}`).join(', ')}) => ChainSubmittableExtrinsic<Rv, ${callInput}>>`)
                 .join(',\n')}
             
-          ${(0, utils_1.commentBlock)('Generic pallet tx call')}[callName: string]: GenericTxCall<TxCall>,
+          ${(0, utils_js_1.commentBlock)('Generic pallet tx call')}[callName: string]: GenericTxCall<Rv, TxCall<Rv>>,
         },`;
         }
-        const importTypes = this.typesGen.typeImports.toImports();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         // TODO make explicit separate type for Extra
         const defTypes = `
-    export type ChainSubmittableExtrinsic<T extends IRuntimeTxCall = ${callTypeIn}> = 
+    export type ChainSubmittableExtrinsic<Rv extends RpcVersion, T extends IRuntimeTxCall = ${callTypeIn}> = 
         Extrinsic<${addressTypeIn}, T, ${signatureTypeIn}, any[]> &
-        ISubmittableExtrinsic<ISubmittableResult<FrameSystemEventRecord>>
+        (Rv extends RpcV2
+          ? ISubmittableExtrinsic<ISubmittableResult<FrameSystemEventRecord, TransactionEvent>>
+          : ISubmittableExtrinsicLegacy<ISubmittableResult<FrameSystemEventRecord, TransactionEvent>>)
         
-    export type TxCall = (...args: any[]) => ChainSubmittableExtrinsic;    
+    export type TxCall<Rv extends RpcVersion> = (...args: any[]) => ChainSubmittableExtrinsic<Rv>;    
 `;
-        const template = (0, utils_1.compileTemplate)('tx.hbs');
-        return (0, utils_1.beautifySourceCode)(template({ importTypes, defTypes, txDefsOut }));
+        const template = (0, utils_js_1.compileTemplate)('chaintypes/templates/tx.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypes, txDefsOut }));
     }
     #normalizeParamName(name) {
-        name = (0, util_1.stringCamelCase)(name);
-        return (0, utils_1.isReservedWord)(name) ? `${name}_` : name;
+        name = (0, utils_1.stringCamelCase)(name);
+        return (0, utils_js_1.isReservedWord)(name) ? `${name}_` : name;
     }
     #generateCallInput(palletName, callName, params) {
         if (!params) {

package/cjs/chaintypes/generator/TypesGen.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypesGen = void 0;
+const codecs_1 = require("@dedot/codecs");
+const index_js_1 = require("../../shared/index.js");
+const utils_js_1 = require("../../utils.js");
+// 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',
+];
+class TypesGen extends index_js_1.BaseTypesGen {
+    metadata;
+    registry;
+    constructor(metadata) {
+        super(metadata.types);
+        this.metadata = metadata;
+        this.skipTypes = SKIP_TYPES;
+        this.registry = new codecs_1.PortableRegistry(this.metadata);
+        this.includedTypes = this.includeTypes();
+    }
+    generate(useSubPaths = false) {
+        this.clearCache();
+        let defTypeOut = '';
+        Object.values(this.includedTypes)
+            .filter(({ skip, knownType }) => !(skip || knownType))
+            .forEach(({ name, nameOut, id, docs }) => {
+            defTypeOut += `${(0, utils_js_1.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({ excludeModules: ['./types'], useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('chaintypes/templates/types.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
+    }
+    shouldGenerateTypeIn(id) {
+        const { callTypeId } = this.metadata.extrinsic;
+        const palletCallTypeIds = this.registry.getFieldTypeIdsFromEnum(callTypeId);
+        return callTypeId === id || palletCallTypeIds.includes(id);
+    }
+    getEnumOptions(typeId) {
+        return this.registry.getEnumOptions(typeId);
+    }
+}
+exports.TypesGen = TypesGen;

package/cjs/chaintypes/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.js"), exports);
+__exportStar(require("./ApiGen.js"), exports);
+__exportStar(require("./ConstsGen.js"), exports);
+__exportStar(require("./QueryGen.js"), exports);
+__exportStar(require("./JsonRpcGen.js"), exports);
+__exportStar(require("./IndexGen.js"), exports);
+__exportStar(require("./ErrorsGen.js"), exports);
+__exportStar(require("./EventsGen.js"), exports);
+__exportStar(require("./TxGen.js"), exports);
+__exportStar(require("./RuntimeApisGen.js"), exports);

package/cjs/chaintypes/index.js

@@ -0,0 +1,77 @@
+"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.generateTypesFromEndpoint = void 0;
+const api_1 = require("@dedot/api");
+const providers_1 = require("@dedot/providers");
+const utils_1 = require("@dedot/utils");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const index_js_1 = require("./generator/index.js");
+async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts', useSubPaths = false) {
+    const api = await api_1.LegacyClient.new(new providers_1.WsProvider(endpoint));
+    const { methods } = await api.rpc.rpc_methods();
+    const apis = api.runtimeVersion.apis || {};
+    if (!chain) {
+        chain = (0, utils_1.stringCamelCase)(api.runtimeVersion.specName || 'local');
+    }
+    await generateTypes(chain, api.metadata.latest, methods, apis, outDir, extension, useSubPaths);
+    await api.disconnect();
+}
+exports.generateTypesFromEndpoint = generateTypesFromEndpoint;
+async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir = '.', extension = 'd.ts', useSubPaths = false) {
+    const dirPath = path.resolve(outDir, chain);
+    const defTypesFileName = path.join(dirPath, `types.${extension}`);
+    const constsTypesFileName = path.join(dirPath, `consts.${extension}`);
+    const queryTypesFileName = path.join(dirPath, `query.${extension}`);
+    const jsonRpcFileName = path.join(dirPath, `json-rpc.${extension}`);
+    const indexFileName = path.join(dirPath, `index.${extension}`);
+    const errorsFileName = path.join(dirPath, `errors.${extension}`);
+    const eventsFileName = path.join(dirPath, `events.${extension}`);
+    const runtimeApisFileName = path.join(dirPath, `runtime.${extension}`);
+    const txFileName = path.join(dirPath, `tx.${extension}`);
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+    const typesGen = new index_js_1.TypesGen(metadata);
+    const constsGen = new index_js_1.ConstsGen(typesGen);
+    const queryGen = new index_js_1.QueryGen(typesGen);
+    const jsonRpcGen = new index_js_1.JsonRpcGen(typesGen, rpcMethods);
+    const indexGen = new index_js_1.IndexGen(chain);
+    const errorsGen = new index_js_1.ErrorsGen(typesGen);
+    const eventsGen = new index_js_1.EventsGen(typesGen);
+    const runtimeApisGen = new index_js_1.RuntimeApisGen(typesGen, runtimeApis);
+    const txGen = new index_js_1.TxGen(typesGen);
+    fs.writeFileSync(defTypesFileName, await typesGen.generate(useSubPaths));
+    fs.writeFileSync(errorsFileName, await errorsGen.generate(useSubPaths));
+    fs.writeFileSync(eventsFileName, await eventsGen.generate(useSubPaths));
+    fs.writeFileSync(jsonRpcFileName, await jsonRpcGen.generate(useSubPaths));
+    fs.writeFileSync(queryTypesFileName, await queryGen.generate(useSubPaths));
+    fs.writeFileSync(constsTypesFileName, await constsGen.generate(useSubPaths));
+    fs.writeFileSync(txFileName, await txGen.generate(useSubPaths));
+    fs.writeFileSync(indexFileName, await indexGen.generate(useSubPaths));
+    fs.writeFileSync(runtimeApisFileName, await runtimeApisGen.generate(useSubPaths));
+}
+exports.generateTypes = generateTypes;

package/cjs/chaintypes/templates/consts.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<Rv> {
+  {{{ defTypeOut }}}
+}

package/cjs/chaintypes/templates/errors.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<Rv> {
+  {{{ defTypeOut }}}
+}

package/cjs/chaintypes/templates/events.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<Rv> {
+  {{{ defTypeOut }}}
+}

package/cjs/chaintypes/templates/index.hbs

@@ -0,0 +1,27 @@
+// Generated by dedot cli
+
+{{{importTypes}}}
+import { ChainConsts } from './consts';
+import { ChainStorage } from './query';
+import { ChainJsonRpcApis } from './json-rpc';
+import { ChainErrors } from './errors';
+import { ChainEvents } from './events';
+import { RuntimeApis } from './runtime';
+import { ChainTx } from './tx';
+
+export * from './types';
+
+export interface Versioned{{{interfaceName}}}Api<Rv extends RpcVersion> extends GenericSubstrateApi<Rv> {
+  rpc: ChainJsonRpcApis<Rv>;
+  consts: ChainConsts<Rv>;
+  query: ChainStorage<Rv>;
+  errors: ChainErrors<Rv>;
+  events: ChainEvents<Rv>;
+  call: RuntimeApis<Rv>;
+  tx: ChainTx<Rv>;
+}
+
+export interface {{{interfaceName}}}Api {
+  legacy: Versioned{{{interfaceName}}}Api<RpcLegacy>;
+  v2: Versioned{{{interfaceName}}}Api<RpcV2>;
+}

package/cjs/chaintypes/templates/json-rpc.hbs

@@ -0,0 +1,5 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export type ChainJsonRpcApis<Rv extends RpcVersion> = Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis<Rv>;

package/cjs/chaintypes/templates/query.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage<Rv> {
+  {{{ defTypeOut }}}
+}

package/cjs/chaintypes/templates/runtime.hbs

@@ -0,0 +1,8 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface RuntimeApis<Rv extends RpcVersion> extends GenericRuntimeApis<Rv> {
+{{{ runtimeCallsOut }}}
+}
+

package/cjs/chaintypes/templates/tx.hbs

@@ -0,0 +1,9 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+{{{ defTypes }}}
+
+export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCall<Rv>> {
+  {{{ txDefsOut }}}
+}

package/cjs/chaintypes/templates/types.hbs

@@ -0,0 +1,5 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+{{{ defTypeOut }}}

package/cjs/{types.js → dirname.js}

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

package/cjs/index.js

@@ -10,67 +10,9 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     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 __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 });
-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;
+__exportStar(require("./chaintypes/index.js"), exports);
+__exportStar(require("./typink/index.js"), exports);