@dedot/codegen 0.0.1-next.c3d95ac1.3 → 0.0.1-next.d9aff57d.57

package/cjs/generator/ConstsGen.js

@@ -5,10 +5,10 @@ const utils_1 = require("@dedot/utils");
 const ApiGen_js_1 = require("./ApiGen.js");
 const utils_js_1 = require("./utils.js");
 class ConstsGen extends ApiGen_js_1.ApiGen {
-    generate() {
+    generate(useSubPaths = false) {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainConsts');
+        this.typesGen.typeImports.addKnownType('GenericChainConsts', 'RpcVersion');
         let defTypeOut = '';
         for (let pallet of pallets) {
             const typedConstants = pallet.constants.map((one) => ({
@@ -23,7 +23,7 @@ class ConstsGen extends ApiGen_js_1.ApiGen {
         ${(0, utils_js_1.commentBlock)('Generic pallet constant')}[name: string]: any,
       },`;
         }
-        const importTypes = this.typesGen.typeImports.toImports();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const template = (0, utils_js_1.compileTemplate)('consts.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }

package/cjs/generator/ErrorsGen.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorsGen = void 0;
+const utils_1 = require("@dedot/utils");
 const ApiGen_js_1 = require("./ApiGen.js");
 const utils_js_1 = require("./utils.js");
-const utils_1 = require("@dedot/utils");
 class ErrorsGen extends ApiGen_js_1.ApiGen {
-    generate() {
+    generate(useSubPaths = false) {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainErrors', 'GenericPalletError');
+        this.typesGen.typeImports.addKnownType('GenericChainErrors', 'GenericPalletError', 'RpcVersion');
         let defTypeOut = '';
         for (let pallet of pallets) {
             const errorTypeId = pallet.error;
@@ -19,13 +19,13 @@ class ErrorsGen extends ApiGen_js_1.ApiGen {
             defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s errors`);
             defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
         ${errorDefs
-                .map(({ name, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletError`)
+                .map(({ name, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletError<Rv>`)
                 .join(',\n')}
           
-        ${(0, utils_js_1.commentBlock)('Generic pallet error')}[error: string]: GenericPalletError,
+        ${(0, utils_js_1.commentBlock)('Generic pallet error')}[error: string]: GenericPalletError<Rv>,
       },`;
         }
-        const importTypes = this.typesGen.typeImports.toImports();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const template = (0, utils_js_1.compileTemplate)('errors.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }

package/cjs/generator/EventsGen.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventsGen = void 0;
+const utils_1 = require("@dedot/utils");
 const ApiGen_js_1 = require("./ApiGen.js");
 const utils_js_1 = require("./utils.js");
-const utils_1 = require("@dedot/utils");
 class EventsGen extends ApiGen_js_1.ApiGen {
-    generate() {
+    generate(useSubPaths = false) {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainEvents', 'GenericPalletEvent');
+        this.typesGen.typeImports.addKnownType('GenericChainEvents', 'GenericPalletEvent', 'RpcVersion');
         let defTypeOut = '';
         for (let pallet of pallets) {
             const eventTypeId = pallet.event;
@@ -31,13 +31,13 @@ class EventsGen extends ApiGen_js_1.ApiGen {
                 }
                 return { ...def, genericParts };
             })
-                .map(({ name, docs, fields, genericParts }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletEvent<${genericParts.join(', ')}>`)
+                .map(({ name, docs, fields, genericParts }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletEvent<Rv, ${genericParts.join(', ')}>`)
                 .join(',\n')}
           
-        ${(0, utils_js_1.commentBlock)('Generic pallet event')}[prop: string]: GenericPalletEvent,
+        ${(0, utils_js_1.commentBlock)('Generic pallet event')}[prop: string]: GenericPalletEvent<Rv>,
       },`;
         }
-        const importTypes = this.typesGen.typeImports.toImports();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const template = (0, utils_js_1.compileTemplate)('events.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }

package/cjs/generator/IndexGen.js

@@ -1,17 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexGen = void 0;
-const utils_js_1 = require("./utils.js");
 const utils_1 = require("@dedot/utils");
+const TypeImports_js_1 = require("./TypeImports.js");
+const utils_js_1 = require("./utils.js");
 class IndexGen {
     chain;
     constructor(chain) {
         this.chain = chain;
     }
-    async generate() {
+    async generate(useSubPaths = false) {
         const interfaceName = (0, utils_1.stringPascalCase)(this.chain);
+        const typeImports = new TypeImports_js_1.TypeImports();
+        typeImports.addKnownType('GenericSubstrateApi', 'RpcLegacy', 'RpcV2', 'RpcVersion');
+        const importTypes = typeImports.toImports({ useSubPaths });
         const template = (0, utils_js_1.compileTemplate)('index.hbs');
-        return (0, utils_js_1.beautifySourceCode)(template({ interfaceName }));
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, interfaceName }));
     }
 }
 exports.IndexGen = IndexGen;

package/cjs/generator/JsonRpcGen.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonRpcGen = void 0;
-const index_js_1 = require("../generator/index.js");
+const api_1 = require("@dedot/api");
+const ApiGen_js_1 = require("./ApiGen.js");
 const utils_js_1 = require("./utils.js");
-const specs_1 = require("@dedot/specs");
 const HIDDEN_RPCS = [
     // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
     'rpc_methods',
@@ -31,7 +31,7 @@ const ALIAS_RPCS = [
     'chain_subscribeFinalisedHeads',
     'chain_unsubscribeFinalisedHeads',
 ];
-class JsonRpcGen extends index_js_1.ApiGen {
+class JsonRpcGen extends ApiGen_js_1.ApiGen {
     typesGen;
     rpcMethods;
     constructor(typesGen, rpcMethods) {
@@ -41,12 +41,12 @@ class JsonRpcGen extends index_js_1.ApiGen {
         HIDDEN_RPCS.filter((one) => !rpcMethods.includes(one)).forEach((one) => rpcMethods.push(one));
         rpcMethods.sort();
     }
-    generate() {
+    generate(useSubPaths = false) {
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericJsonRpcApis');
-        this.typesGen.typeImports.addSpecType('JsonRpcApis');
-        const toExclude = Object.values(specs_1.subscriptionsInfo).flat();
-        const importTypes = this.typesGen.typeImports.toImports();
+        this.typesGen.typeImports.addKnownType('GenericJsonRpcApis', 'RpcVersion');
+        this.typesGen.typeImports.addKnownJsonRpcType('JsonRpcApis');
+        const toExclude = Object.values(api_1.subscriptionsInfo).flat();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const template = (0, utils_js_1.compileTemplate)('json-rpc.hbs');
         const jsonRpcMethods = this.rpcMethods
             .filter((one) => !ALIAS_RPCS.includes(one)) // exclude alias rpcs

package/cjs/generator/QueryGen.js

@@ -5,37 +5,45 @@ const utils_1 = require("@dedot/utils");
 const ApiGen_js_1 = require("./ApiGen.js");
 const utils_js_1 = require("./utils.js");
 class QueryGen extends ApiGen_js_1.ApiGen {
-    generate() {
+    generate(useSubPaths = false) {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainStorage', 'GenericStorageQuery', 'Callback');
+        this.typesGen.typeImports.addKnownType('GenericChainStorage', 'GenericStorageQuery', 'Callback', 'RpcVersion');
         let defTypeOut = '';
         for (let pallet of pallets) {
             const storage = pallet.storage;
             if (!storage)
                 continue;
             const queries = storage.entries.map((one) => this.#generateEntry(one));
-            const queryDefs = queries.map(({ name, valueType, keyType, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`);
+            const queryDefs = queries.map(({ name, valueType, keyType, docs, keyTypeOut }) => {
+                if (keyTypeOut) {
+                    return `${(0, utils_js_1.commentBlock)(docs)}${name}: GenericStorageQuery<Rv, (${keyType}) => ${valueType}, ${keyTypeOut}>`;
+                }
+                else {
+                    return `${(0, utils_js_1.commentBlock)(docs)}${name}: GenericStorageQuery<Rv, (${keyType}) => ${valueType}>`;
+                }
+            });
             defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s storage queries`);
             defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
         ${queryDefs.join(',\n')}
         
-        ${(0, utils_js_1.commentBlock)('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
+        ${(0, utils_js_1.commentBlock)('Generic pallet storage query')}[storage: string]: GenericStorageQuery<Rv>;
       },`;
         }
-        const importTypes = this.typesGen.typeImports.toImports();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const template = (0, utils_js_1.compileTemplate)('query.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
     #generateEntry(entry) {
         const { name, type, docs, modifier } = entry;
-        let valueType, keyType;
+        let valueType, keyTypeOut, keyTypeIn;
         if (type.tag === 'Plain') {
             valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
         }
         else if (type.tag === 'Map') {
             valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
-            keyType = this.typesGen.generateType(type.value.keyTypeId, 1);
+            keyTypeOut = this.typesGen.generateType(type.value.keyTypeId, 1, true);
+            keyTypeIn = this.typesGen.generateType(type.value.keyTypeId, 1);
         }
         else {
             throw Error('Invalid entry type!');
@@ -43,14 +51,15 @@ class QueryGen extends ApiGen_js_1.ApiGen {
         const isOptional = modifier === 'Optional';
         valueType = `${valueType}${isOptional ? ' | undefined' : ''}`;
         docs.push('\n');
-        if (keyType) {
-            docs.push(`@param {${keyType}} arg`);
+        if (keyTypeIn) {
+            docs.push(`@param {${keyTypeIn}} arg`);
         }
         docs.push(`@param {Callback<${valueType}> =} callback`);
         return {
             name: (0, utils_1.normalizeName)(name),
             valueType,
-            keyType: keyType ? `arg: ${keyType}` : '',
+            keyType: keyTypeIn ? `arg: ${keyTypeIn}` : '',
+            keyTypeOut,
             docs,
         };
     }

package/cjs/generator/RuntimeApisGen.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeApisGen = void 0;
-const specs_1 = require("@dedot/specs");
-const utils_js_1 = require("./utils.js");
+const runtime_specs_1 = require("@dedot/runtime-specs");
 const utils_1 = require("@dedot/utils");
 const ApiGen_js_1 = require("./ApiGen.js");
 const known_codecs_js_1 = require("./known-codecs.js");
+const utils_js_1 = require("./utils.js");
 class RuntimeApisGen extends ApiGen_js_1.ApiGen {
     typesGen;
     runtimeApis;
@@ -14,9 +14,9 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
         this.typesGen = typesGen;
         this.runtimeApis = runtimeApis;
     }
-    generate() {
+    generate(useSubPaths = false) {
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericRuntimeApis', 'GenericRuntimeApiMethod');
+        this.typesGen.typeImports.addKnownType('GenericRuntimeApis', 'GenericRuntimeApiMethod', 'RpcVersion');
         let runtimeCallsOut = '';
         if (this.metadata.apis.length > 0) {
             this.metadata.apis.forEach((runtimeApi) => {
@@ -25,7 +25,7 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
                 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
+            ${(0, utils_js_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
         }`;
             });
         }
@@ -42,11 +42,11 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
                 }))
                     .join('\n')} 
               
-            ${(0, utils_js_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
+            ${(0, utils_js_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
           }`;
             });
         }
-        const importTypes = this.typesGen.typeImports.toImports();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const template = (0, utils_js_1.compileTemplate)('runtime.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, runtimeCallsOut }));
     }
@@ -71,7 +71,7 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
             .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<(${paramsOut}) => Promise<${typeOut}>>`;
+        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;
@@ -92,7 +92,7 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
         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<(${paramsOut}) => Promise<${typeOut}>>`;
+        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]) => {
@@ -112,8 +112,8 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
         }, []);
     }
     #findRuntimeApiSpec = (runtimeApiHash, version) => {
-        const runtimeApiName = (0, specs_1.getRuntimeApiNames)().find((one) => (0, utils_1.calcRuntimeApiHash)(one) === runtimeApiHash);
-        return (0, specs_1.getRuntimeApiSpecs)().find((one) => one.runtimeApiName === runtimeApiName && one.version === 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) {

package/cjs/generator/TxGen.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxGen = void 0;
-const index_js_1 = require("../generator/index.js");
 const utils_1 = require("@dedot/utils");
+const index_js_1 = require("../generator/index.js");
 const utils_js_1 = require("./utils.js");
 class TxGen extends index_js_1.ApiGen {
-    generate() {
+    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', 'TransactionStatusLegacy', 'TransactionStatusV2');
         const { callTypeId, addressTypeId, signatureTypeId } = this.metadata.extrinsic;
         const callTypeIn = this.typesGen.generateType(callTypeId, 1);
         const addressTypeIn = this.typesGen.generateType(addressTypeId, 1);
@@ -44,20 +44,22 @@ class TxGen extends index_js_1.ApiGen {
             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_js_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_js_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, TransactionStatusV2>>
+          : ISubmittableExtrinsicLegacy<ISubmittableResult<FrameSystemEventRecord, TransactionStatusLegacy>>)
         
-    export type TxCall = (...args: any[]) => ChainSubmittableExtrinsic;    
+    export type TxCall<Rv extends RpcVersion> = (...args: any[]) => ChainSubmittableExtrinsic<Rv>;    
 `;
         const template = (0, utils_js_1.compileTemplate)('tx.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypes, txDefsOut }));

package/cjs/generator/TypeImports.js

@@ -8,29 +8,31 @@ class TypeImports {
     codecTypes;
     // Known types that're not codecs or chain/portable types defined in @dedot/types
     knownTypes;
-    specTypes;
+    knownJsonRpcTypes;
     // External types to define explicitly
     outTypes;
     constructor() {
         this.portableTypes = new Set();
         this.codecTypes = new Set();
         this.knownTypes = new Set();
-        this.specTypes = new Set();
+        this.knownJsonRpcTypes = new Set();
         this.outTypes = new Set();
     }
     clear() {
         this.portableTypes.clear();
         this.codecTypes.clear();
         this.knownTypes.clear();
-        this.specTypes.clear();
+        this.knownJsonRpcTypes.clear();
         this.outTypes.clear();
     }
-    toImports(...excludeModules) {
+    toImports(config) {
+        const { excludeModules = [], useSubPaths = false } = config || {};
         // TODO generate outTypes!
+        const prefix = useSubPaths ? '' : '@';
         const toImports = [
-            [this.knownTypes, '@dedot/types'],
-            [this.specTypes, '@dedot/specs'],
-            [this.codecTypes, '@dedot/codecs'],
+            [this.knownTypes, `${prefix}dedot/types`],
+            [this.knownJsonRpcTypes, `${prefix}dedot/types/json-rpc`],
+            [this.codecTypes, `${prefix}dedot/codecs`],
             [this.portableTypes, './types'],
         ];
         return toImports
@@ -54,8 +56,8 @@ class TypeImports {
     addKnownType(...types) {
         types.forEach((one) => this.knownTypes.add(one));
     }
-    addSpecType(...types) {
-        types.forEach((one) => this.specTypes.add(one));
+    addKnownJsonRpcType(...types) {
+        types.forEach((one) => this.knownJsonRpcTypes.add(one));
     }
     addOutType(...types) {
         types.forEach((one) => this.outTypes.add(one));

package/cjs/generator/TypesGen.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypesGen = exports.BASIC_KNOWN_TYPES = void 0;
 const codecs_1 = require("@dedot/codecs");
 const utils_1 = require("@dedot/utils");
-const utils_js_1 = require("./utils.js");
 const TypeImports_js_1 = require("./TypeImports.js");
 const known_codecs_js_1 = require("./known-codecs.js");
+const utils_js_1 = require("./utils.js");
 // Skip generate types for these
 // as we do have native types for them
 const SKIP_TYPES = [
@@ -43,7 +43,7 @@ class TypesGen {
         this.includedTypes = this.#includedTypes();
         this.typeImports = new TypeImports_js_1.TypeImports();
     }
-    generate() {
+    generate(useSubPaths = false) {
         this.clearCache();
         let defTypeOut = '';
         Object.values(this.includedTypes)
@@ -54,7 +54,7 @@ class TypesGen {
                 defTypeOut += `export type ${name} = ${this.generateType(id)};\n\n`;
             }
         });
-        const importTypes = this.typeImports.toImports('./types');
+        const importTypes = this.typeImports.toImports({ useSubPaths, excludeModules: ['./types'] });
         const template = (0, utils_js_1.compileTemplate)('types.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }

package/cjs/generator/known-codecs.js

@@ -24,9 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isKnownCodecType = exports.findKnownWrapperCodec = exports.findKnownCodec = exports.findKnownCodecType = exports.looseTypeCodecs = exports.normalizeCodecName = void 0;
-const $ = __importStar(require("@dedot/shape"));
 const Codecs = __importStar(require("@dedot/codecs"));
 const codecs_1 = require("@dedot/codecs");
+const $ = __importStar(require("@dedot/shape"));
 const utils_1 = require("@dedot/utils");
 const normalizeCodecName = (name) => {
     return name.startsWith('$') ? name : `$${name}`;

package/cjs/index.js

@@ -24,23 +24,24 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTypes = exports.generateTypesFromEndpoint = void 0;
-const dedot_1 = require("dedot");
+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");
-const utils_1 = require("@dedot/utils");
-async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts') {
-    const api = await dedot_1.Dedot.new(endpoint);
+async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts', useSubPaths = false) {
+    const api = await api_1.Dedot.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 || api.runtimeChain || 'local');
+        chain = (0, utils_1.stringCamelCase)(api.runtimeVersion.specName || 'local');
     }
-    await generateTypes(chain, api.metadata.latest, methods, apis, outDir, extension);
+    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') {
+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}`);
@@ -63,14 +64,14 @@ async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir =
     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());
-    fs.writeFileSync(errorsFileName, await errorsGen.generate());
-    fs.writeFileSync(eventsFileName, await eventsGen.generate());
-    fs.writeFileSync(jsonRpcFileName, await jsonRpcGen.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());
+    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/templates/consts.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ChainConsts extends GenericChainConsts {
+export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<Rv> {
   {{{ defTypeOut }}}
 }

package/cjs/templates/errors.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ChainErrors extends GenericChainErrors {
+export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<Rv> {
   {{{ defTypeOut }}}
 }

package/cjs/templates/events.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ChainEvents extends GenericChainEvents {
+export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<Rv> {
   {{{ defTypeOut }}}
 }

package/cjs/templates/index.hbs

@@ -1,6 +1,6 @@
 // Generated by @dedot/codegen
 
-import { GenericSubstrateApi } from '@dedot/types';
+{{{importTypes}}}
 import { ChainConsts } from './consts';
 import { ChainStorage } from './query';
 import { ChainJsonRpcApis } from './json-rpc';
@@ -11,12 +11,17 @@ import { ChainTx } from './tx';
 
 export * from './types';
 
-export interface {{{interfaceName}}}Api extends GenericSubstrateApi {
-  rpc: ChainJsonRpcApis;
-  consts: ChainConsts;
-  query: ChainStorage;
-  errors: ChainErrors;
-  events: ChainEvents;
-  call: RuntimeApis;
-  tx: ChainTx;
+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/templates/json-rpc.hbs

@@ -2,4 +2,4 @@
 
 {{{ importTypes }}}
 
-export type ChainJsonRpcApis = Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis;
+export type ChainJsonRpcApis<Rv extends RpcVersion> = Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis<Rv>;

package/cjs/templates/query.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ChainStorage extends GenericChainStorage {
+export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage<Rv> {
   {{{ defTypeOut }}}
 }

package/cjs/templates/runtime.hbs

@@ -2,7 +2,7 @@
 
 {{{ importTypes }}}
 
-export interface RuntimeApis extends GenericRuntimeApis {
+export interface RuntimeApis<Rv extends RpcVersion> extends GenericRuntimeApis<Rv> {
 {{{ runtimeCallsOut }}}
 }
 

package/cjs/templates/tx.hbs

@@ -4,6 +4,6 @@
 
 {{{ defTypes }}}
 
-export interface ChainTx extends GenericChainTx<TxCall> {
+export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCall<Rv>> {
   {{{ txDefsOut }}}
 }

package/generator/ApiGen.d.ts

@@ -1,4 +1,4 @@
-import { TypesGen } from '../generator/index.js';
+import { TypesGen } from './TypesGen.js';
 export declare abstract class ApiGen {
     readonly typesGen: TypesGen;
     constructor(typesGen: TypesGen);
@@ -13,14 +13,14 @@ export declare abstract class ApiGen {
             type: {
                 tag: "Struct";
                 value: {
-                    fields: import("dedot").Field[];
+                    fields: import("@dedot/codecs").Field[];
                 };
             } | {
                 tag: "Enum";
                 value: {
                     members: {
                         name: string;
-                        fields: import("dedot").Field[];
+                        fields: import("@dedot/codecs").Field[];
                         index: number;
                         docs: string[];
                     }[];
@@ -134,5 +134,5 @@ export declare abstract class ApiGen {
             }>;
         };
     };
-    get registry(): import("dedot").PortableRegistry;
+    get registry(): import("@dedot/codecs").PortableRegistry;
 }

package/generator/ConstsGen.d.ts

@@ -1,4 +1,4 @@
 import { ApiGen } from './ApiGen.js';
 export declare class ConstsGen extends ApiGen {
-    generate(): Promise<string>;
+    generate(useSubPaths?: boolean): Promise<string>;
 }