@dedot/codegen 0.0.1-next.2d39ff2d.5 → 0.0.1-next.324f6c64.55

package/cjs/generator/TypesGen.js

@@ -1,13 +1,11 @@
 "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_js_1 = require("./utils.js");
-const known_types_js_1 = require("./known-types.js");
+const codecs_1 = require("dedot/codecs");
+const utils_1 = require("dedot/utils");
 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 = [
@@ -45,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)
@@ -56,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 }));
     }
@@ -151,12 +149,12 @@ class TypesGen {
                     return 'null';
                 }
                 else if (members.every((x) => x.fields.length === 0)) {
-                    return members.map(({ name, docs }) => `${(0, utils_js_1.commentBlock)(docs)}'${(0, util_1.stringPascalCase)(name)}'`).join(' | ');
+                    return members.map(({ name, docs }) => `${(0, utils_js_1.commentBlock)(docs)}'${(0, utils_1.stringPascalCase)(name)}'`).join(' | ');
                 }
                 else {
                     const membersType = [];
                     for (const { fields, name, docs } of members) {
-                        const keyName = (0, util_1.stringPascalCase)(name);
+                        const keyName = (0, utils_1.stringPascalCase)(name);
                         if (fields.length === 0) {
                             membersType.push([keyName, null, docs]);
                         }
@@ -315,7 +313,7 @@ class TypesGen {
      */
     #cleanPath(path) {
         return path
-            .map((one) => (0, util_1.stringPascalCase)(one))
+            .map((one) => (0, utils_1.stringPascalCase)(one))
             .filter((one, idx, currentPath) => idx === 0 || one !== currentPath[idx - 1])
             .join('');
     }
@@ -390,10 +388,10 @@ class TypesGen {
         if (diffParam?.typeId) {
             const diffType = types[diffParam.typeId];
             if (diffType.path.length > 0) {
-                return (0, util_1.stringPascalCase)(diffType.path.at(-1));
+                return (0, utils_1.stringPascalCase)(diffType.path.at(-1));
             }
             else if (diffType.type.tag === 'Primitive') {
-                return (0, util_1.stringPascalCase)(diffType.type.value.kind);
+                return (0, utils_1.stringPascalCase)(diffType.type.value.kind);
             }
         }
         // Last resort!
@@ -404,7 +402,7 @@ class TypesGen {
             typeName.forEach((one) => this.addTypeImport(one));
             return;
         }
-        if ((0, utils_1.isNativeType)(typeName)) {
+        if ((0, utils_js_1.isNativeType)(typeName)) {
             return;
         }
         for (let type of Object.values(this.includedTypes)) {
@@ -426,12 +424,7 @@ class TypesGen {
             this.typeImports.addCodecType(typeName);
             return;
         }
-        if (known_types_js_1.knownTypes.includes(typeName)) {
-            this.typeImports.addKnownType(typeName);
-        }
-        else {
-            this.typeImports.addOutType(typeName);
-        }
+        this.typeImports.addOutType(typeName);
     }
 }
 exports.TypesGen = TypesGen;

package/cjs/generator/index.js

@@ -18,7 +18,7 @@ __exportStar(require("./TypesGen.js"), exports);
 __exportStar(require("./ApiGen.js"), exports);
 __exportStar(require("./ConstsGen.js"), exports);
 __exportStar(require("./QueryGen.js"), exports);
-__exportStar(require("./RpcGen.js"), exports);
+__exportStar(require("./JsonRpcGen.js"), exports);
 __exportStar(require("./IndexGen.js"), exports);
 __exportStar(require("./ErrorsGen.js"), exports);
 __exportStar(require("./EventsGen.js"), exports);

package/cjs/generator/known-codecs.js

@@ -24,10 +24,10 @@ 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 utils_1 = require("@dedot/utils");
+const dedot_1 = require("dedot");
+const Codecs = __importStar(require("dedot/codecs"));
+const codecs_1 = require("dedot/codecs");
+const utils_1 = require("dedot/utils");
 const normalizeCodecName = (name) => {
     return name.startsWith('$') ? name : `$${name}`;
 };
@@ -96,7 +96,7 @@ function findKnownCodecType(name) {
         };
     }
     const $codec = findKnownCodec(name);
-    if ($codec.nativeType && $[name]) {
+    if ($codec.nativeType && dedot_1.$[name]) {
         return {
             name: normalizedName,
             $codec,
@@ -114,7 +114,7 @@ function findKnownCodecType(name) {
 exports.findKnownCodecType = findKnownCodecType;
 function findKnownCodec(typeName) {
     // @ts-ignore
-    const $codec = findKnownWrapperCodec(typeName) || Codecs[(0, exports.normalizeCodecName)(typeName)] || $[typeName];
+    const $codec = findKnownWrapperCodec(typeName) || Codecs[(0, exports.normalizeCodecName)(typeName)] || dedot_1.$[typeName];
     (0, utils_1.assert)($codec, `Known codec not found - ${typeName}`);
     return $codec;
 }
@@ -125,7 +125,7 @@ function findKnownWrapperCodec(typeName) {
         const [_, wrapper, inner] = matchNames;
         if (KNOWN_WRAPPER_TYPES.includes(wrapper)) {
             // @ts-ignore
-            const $Wrapper = $[wrapper];
+            const $Wrapper = dedot_1.$[wrapper];
             if (inner.match(TUPLE_TYPE_REGEX) || inner.match(WRAPPER_TYPE_REGEX)) {
                 return $Wrapper(findKnownWrapperCodec(inner));
             }
@@ -140,7 +140,7 @@ function findKnownWrapperCodec(typeName) {
             .split(',')
             .filter((x) => x)
             .map((one) => findKnownCodec(one.trim()));
-        return $.Tuple(...$inner);
+        return dedot_1.$.Tuple(...$inner);
     }
 }
 exports.findKnownWrapperCodec = findKnownWrapperCodec;

package/cjs/generator/utils.js

@@ -26,7 +26,7 @@ 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;
+exports.isNativeType = 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"));
@@ -66,3 +66,32 @@ const TS_RESERVED_WORDS = ['new', 'class'];
  */
 const isReservedWord = (word) => TS_RESERVED_WORDS.includes(word);
 exports.isReservedWord = isReservedWord;
+const TS_PRIMITIVE_TYPES = [
+    'void',
+    'undefined',
+    'null',
+    'number',
+    'boolean',
+    'bigint',
+    'Map',
+    'Set',
+    'string',
+    'any',
+    'Array',
+    'Record',
+];
+/**
+ * Check if a type is native JS/TS type
+ * @param type
+ */
+const isNativeType = (type) => {
+    return TS_PRIMITIVE_TYPES.some((one) => {
+        if (typeof one === 'string') {
+            return one === type;
+        }
+        else {
+            return type.match(one);
+        }
+    });
+};
+exports.isNativeType = isNativeType;

package/cjs/index.js

@@ -23,54 +23,54 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTypes = exports.generateTypesFromChain = void 0;
+exports.generateTypes = exports.generateTypesFromEndpoint = void 0;
 const dedot_1 = require("dedot");
+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 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');
+async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts', useSubPaths = false) {
+    const api = await dedot_1.Dedot.new(new dedot_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(network, api.metadataLatest, methods, apis, outDir);
+    await generateTypes(chain, api.metadata.latest, methods, apis, outDir, extension, useSubPaths);
     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.d.ts`);
-    const constsTypesFileName = path.join(dirPath, `consts.d.ts`);
-    const queryTypesFileName = path.join(dirPath, `query.d.ts`);
-    const rpcCallsFileName = path.join(dirPath, `rpc.d.ts`);
-    const indexFileName = path.join(dirPath, `index.d.ts`);
-    const errorsFileName = path.join(dirPath, `errors.d.ts`);
-    const eventsFileName = path.join(dirPath, `events.d.ts`);
-    const runtimeApisFileName = path.join(dirPath, `runtime.d.ts`);
-    const txFileName = path.join(dirPath, `tx.d.ts`);
+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 rpcGen = new index_js_1.RpcGen(typesGen, rpcMethods);
-    const indexGen = new index_js_1.IndexGen(network);
+    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());
-    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());
+    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,9 +1,9 @@
 // Generated by @dedot/codegen
 
-import { GenericSubstrateApi } from '@dedot/types';
+import { GenericSubstrateApi, RpcLegacy, RpcV2, RpcVersion } from '@dedot/types';
 import { ChainConsts } from './consts';
 import { ChainStorage } from './query';
-import { RpcCalls } from './rpc';
+import { ChainJsonRpcApis } from './json-rpc';
 import { ChainErrors } from './errors';
 import { ChainEvents } from './events';
 import { RuntimeApis } from './runtime';
@@ -11,12 +11,17 @@ 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;
+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

@@ -0,0 +1,5 @@
+// Generated by @dedot/codegen
+
+{{{ importTypes }}}
+
+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/ConstsGen.d.ts

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

package/generator/ConstsGen.js

@@ -1,12 +1,11 @@
-import { stringLowerFirst } from '@polkadot/util';
-import { normalizeName } from '@dedot/utils';
-import { ApiGen } from '../generator/index.js';
+import { normalizeName, stringCamelCase } from 'dedot/utils';
+import { ApiGen } from './ApiGen.js';
 import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class ConstsGen extends 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) => ({
@@ -15,13 +14,13 @@ export class ConstsGen extends ApiGen {
                 docs: one.docs,
             }));
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s constants`);
-            defTypeOut += `${stringLowerFirst(pallet.name)}: {
+            defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${typedConstants.map(({ name, type, docs }) => `${commentBlock(docs)}${name}: ${type}`).join(',\n')}
           
         ${commentBlock('Generic pallet constant')}[name: string]: any,
       },`;
         }
-        const importTypes = this.typesGen.typeImports.toImports();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const template = compileTemplate('consts.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }

package/generator/ErrorsGen.d.ts

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

package/generator/ErrorsGen.js

@@ -1,12 +1,11 @@
+import { assert, stringCamelCase, stringPascalCase } from 'dedot/utils';
 import { ApiGen } from './ApiGen.js';
 import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
-import { stringCamelCase, stringPascalCase } from '@polkadot/util';
-import { assert } from '@dedot/utils';
 export class ErrorsGen extends 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;
@@ -17,13 +16,13 @@ export class ErrorsGen extends ApiGen {
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s errors`);
             defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${errorDefs
-                .map(({ name, docs }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletError`)
+                .map(({ name, docs }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletError<Rv>`)
                 .join(',\n')}
           
-        ${commentBlock('Generic pallet error')}[error: string]: GenericPalletError,
+        ${commentBlock('Generic pallet error')}[error: string]: GenericPalletError<Rv>,
       },`;
         }
-        const importTypes = this.typesGen.typeImports.toImports();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const template = compileTemplate('errors.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }

package/generator/EventsGen.d.ts

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

package/generator/EventsGen.js

@@ -1,12 +1,11 @@
+import { assert, stringCamelCase, stringPascalCase } from 'dedot/utils';
 import { ApiGen } from './ApiGen.js';
 import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
-import { stringCamelCase, stringPascalCase } from '@polkadot/util';
-import { assert } from '@dedot/utils';
 export class EventsGen extends 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;
@@ -29,13 +28,13 @@ export class EventsGen extends ApiGen {
                 }
                 return { ...def, genericParts };
             })
-                .map(({ name, docs, fields, genericParts }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletEvent<${genericParts.join(', ')}>`)
+                .map(({ name, docs, fields, genericParts }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletEvent<Rv, ${genericParts.join(', ')}>`)
                 .join(',\n')}
           
-        ${commentBlock('Generic pallet event')}[prop: string]: GenericPalletEvent,
+        ${commentBlock('Generic pallet event')}[prop: string]: GenericPalletEvent<Rv>,
       },`;
         }
-        const importTypes = this.typesGen.typeImports.toImports();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const template = compileTemplate('events.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }

package/generator/IndexGen.d.ts

@@ -1,6 +1,5 @@
-import { NetworkInfo } from '../types.js';
 export declare class IndexGen {
-    readonly networkInfo: NetworkInfo;
-    constructor(networkInfo: NetworkInfo);
-    generate(): Promise<string>;
+    readonly chain: string;
+    constructor(chain: string);
+    generate(useSubPaths?: boolean): Promise<string>;
 }

package/generator/IndexGen.js

@@ -1,13 +1,12 @@
+import { stringPascalCase } from 'dedot/utils';
 import { beautifySourceCode, compileTemplate } from './utils.js';
-import { stringPascalCase } from '@polkadot/util';
 export class IndexGen {
-    networkInfo;
-    constructor(networkInfo) {
-        this.networkInfo = networkInfo;
+    chain;
+    constructor(chain) {
+        this.chain = chain;
     }
-    async generate() {
-        const { chain } = this.networkInfo;
-        const interfaceName = stringPascalCase(chain);
+    async generate(useSubPaths = false) {
+        const interfaceName = stringPascalCase(this.chain);
         const template = compileTemplate('index.hbs');
         return beautifySourceCode(template({ interfaceName }));
     }

package/generator/JsonRpcGen.d.ts

@@ -0,0 +1,7 @@
+import { ApiGen, TypesGen } from '../generator/index.js';
+export declare class JsonRpcGen extends ApiGen {
+    readonly typesGen: TypesGen;
+    readonly rpcMethods: string[];
+    constructor(typesGen: TypesGen, rpcMethods: string[]);
+    generate(useSubPaths?: boolean): Promise<string>;
+}

package/generator/JsonRpcGen.js

@@ -0,0 +1,55 @@
+import { subscriptionsInfo } from 'dedot';
+import { ApiGen } from '../generator/index.js';
+import { beautifySourceCode, compileTemplate } from './utils.js';
+const HIDDEN_RPCS = [
+    // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
+    'rpc_methods',
+];
+const ALIAS_RPCS = [
+    // TODO include these into the specs
+    'account_nextIndex',
+    'system_dryRunAt',
+    'state_callAt',
+    'state_getKeysPagedAt',
+    'state_getStorageAt',
+    'state_getStorageHashAt',
+    'state_getStorageSizeAt',
+    'chain_getRuntimeVersion',
+    'chain_getHead',
+    'chain_getFinalisedHead',
+    'childstate_getKeysPagedAt',
+    // Subscription pairs
+    'chain_subscribeRuntimeVersion',
+    'chain_unsubscribeRuntimeVersion',
+    'chain_unsubscribeNewHead',
+    'chain_subscribeNewHead',
+    'subscribe_newHead',
+    'unsubscribe_newHead',
+    'chain_subscribeFinalisedHeads',
+    'chain_unsubscribeFinalisedHeads',
+];
+export class JsonRpcGen extends ApiGen {
+    typesGen;
+    rpcMethods;
+    constructor(typesGen, rpcMethods) {
+        super(typesGen);
+        this.typesGen = typesGen;
+        this.rpcMethods = rpcMethods;
+        HIDDEN_RPCS.filter((one) => !rpcMethods.includes(one)).forEach((one) => rpcMethods.push(one));
+        rpcMethods.sort();
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericJsonRpcApis', 'RpcVersion');
+        this.typesGen.typeImports.addKnownJsonRpcType('JsonRpcApis');
+        const toExclude = Object.values(subscriptionsInfo).flat();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('json-rpc.hbs');
+        const jsonRpcMethods = this.rpcMethods
+            .filter((one) => !ALIAS_RPCS.includes(one)) // exclude alias rpcs
+            .filter((one) => !toExclude.includes(one)) // exclude unsubscribe methods
+            .map((one) => `'${one}'`)
+            .join(' | ');
+        return beautifySourceCode(template({ importTypes, jsonRpcMethods }));
+    }
+}

package/generator/QueryGen.d.ts

@@ -1,5 +1,5 @@
-import { ApiGen } from '../generator/index.js';
+import { ApiGen } from './ApiGen.js';
 export declare class QueryGen extends ApiGen {
     #private;
-    generate(): Promise<string>;
+    generate(useSubPaths?: boolean): Promise<string>;
 }