@dedot/codegen 0.0.1-next.41a5fa17.16 → 0.0.1-next.4f5df6a3.2

package/cjs/generator/ConstsGen.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstsGen = void 0;
 const utils_1 = require("@dedot/utils");
-const index_js_1 = require("../generator/index.js");
+const ApiGen_js_1 = require("./ApiGen.js");
 const utils_js_1 = require("./utils.js");
-class ConstsGen extends index_js_1.ApiGen {
+class ConstsGen extends ApiGen_js_1.ApiGen {
     generate() {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();

package/cjs/generator/IndexGen.js

@@ -4,13 +4,12 @@ exports.IndexGen = void 0;
 const utils_js_1 = require("./utils.js");
 const utils_1 = require("@dedot/utils");
 class IndexGen {
-    networkInfo;
-    constructor(networkInfo) {
-        this.networkInfo = networkInfo;
+    chain;
+    constructor(chain) {
+        this.chain = chain;
     }
     async generate() {
-        const { chain } = this.networkInfo;
-        const interfaceName = (0, utils_1.stringPascalCase)(chain);
+        const interfaceName = (0, utils_1.stringPascalCase)(this.chain);
         const template = (0, utils_js_1.compileTemplate)('index.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ interfaceName }));
     }

package/cjs/generator/JsonRpcGen.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRpcGen = void 0;
+const index_js_1 = require("../generator/index.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',
+];
+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',
+];
+class JsonRpcGen extends index_js_1.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() {
+        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();
+        const template = (0, utils_js_1.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 (0, utils_js_1.beautifySourceCode)(template({ importTypes, jsonRpcMethods }));
+    }
+}
+exports.JsonRpcGen = JsonRpcGen;

package/cjs/generator/QueryGen.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryGen = void 0;
 const utils_1 = require("@dedot/utils");
-const index_js_1 = require("../generator/index.js");
+const ApiGen_js_1 = require("./ApiGen.js");
 const utils_js_1 = require("./utils.js");
-class QueryGen extends index_js_1.ApiGen {
+class QueryGen extends ApiGen_js_1.ApiGen {
     generate() {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();

package/cjs/generator/RuntimeApisGen.js

@@ -4,12 +4,13 @@ exports.RuntimeApisGen = void 0;
 const specs_1 = require("@dedot/specs");
 const utils_js_1 = require("./utils.js");
 const utils_1 = require("@dedot/utils");
-const RpcGen_js_1 = require("./RpcGen.js");
-class RuntimeApisGen extends RpcGen_js_1.RpcGen {
+const ApiGen_js_1 = require("./ApiGen.js");
+const known_codecs_js_1 = require("./known-codecs.js");
+class RuntimeApisGen extends ApiGen_js_1.ApiGen {
     typesGen;
     runtimeApis;
     constructor(typesGen, runtimeApis) {
-        super(typesGen, []);
+        super(typesGen);
         this.typesGen = typesGen;
         this.runtimeApis = runtimeApis;
     }
@@ -59,17 +60,17 @@ class RuntimeApisGen extends RpcGen_js_1.RpcGen {
         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));
+        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),
+            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);
+        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}>>`;
     }
     #generateMethodDef(runtimeApiName, methodDef) {
@@ -77,7 +78,7 @@ class RuntimeApisGen extends RpcGen_js_1.RpcGen {
         const callName = `${runtimeApiName}_${(0, utils_1.stringSnakeCase)(methodName)}`;
         const defaultDocs = [`@callname: ${callName}`];
         const typeOut = this.typesGen.generateType(output, 1, true);
-        this.addTypeImport(typeOut, false);
+        this.#addTypeImport(typeOut, false);
         const typedInputs = inputs
             .map((input, idx) => ({
             ...input,
@@ -87,7 +88,7 @@ class RuntimeApisGen extends RpcGen_js_1.RpcGen {
             ...input,
             isOptional: this.#isOptionalParam(inputs, input.type, idx),
         }));
-        this.addTypeImport(typedInputs.map((t) => t.type));
+        this.#addTypeImport(typedInputs.map((t) => t.type));
         const paramsOut = typedInputs
             .map(({ name, type, isOptional }) => `${(0, utils_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${type}`)
             .join(', ');
@@ -114,5 +115,79 @@ class RuntimeApisGen extends RpcGen_js_1.RpcGen {
         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);
     };
+    // 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, known_codecs_js_1.findKnownCodecType)(type);
+        return toTypeIn ? typeIn : typeOut;
+    }
 }
 exports.RuntimeApisGen = RuntimeApisGen;

package/cjs/generator/TypeImports.js

@@ -8,30 +8,35 @@ class TypeImports {
     codecTypes;
     // Known types that're not codecs or chain/portable types defined in @dedot/types
     knownTypes;
+    specTypes;
     // External types to define explicitly
     outTypes;
     constructor() {
         this.portableTypes = new Set();
         this.codecTypes = new Set();
         this.knownTypes = new Set();
+        this.specTypes = new Set();
         this.outTypes = new Set();
     }
     clear() {
         this.portableTypes.clear();
         this.codecTypes.clear();
         this.knownTypes.clear();
+        this.specTypes.clear();
         this.outTypes.clear();
     }
     toImports(...excludeModules) {
         // TODO generate outTypes!
         const toImports = [
             [this.knownTypes, '@dedot/types'],
+            [this.specTypes, '@dedot/specs'],
             [this.codecTypes, '@dedot/codecs'],
             [this.portableTypes, './types'],
         ];
         return toImports
             .filter(([_, module]) => !excludeModules.includes(module))
             .map(([types, module]) => this.#toImportLine(types, module))
+            .filter((line) => line.length > 0)
             .join('\n');
     }
     #toImportLine(types, module) {
@@ -49,6 +54,9 @@ class TypeImports {
     addKnownType(...types) {
         types.forEach((one) => this.knownTypes.add(one));
     }
+    addSpecType(...types) {
+        types.forEach((one) => this.specTypes.add(one));
+    }
     addOutType(...types) {
         types.forEach((one) => this.outTypes.add(one));
     }

package/cjs/generator/TypesGen.js

@@ -4,7 +4,6 @@ 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 known_types_js_1 = require("./known-types.js");
 const TypeImports_js_1 = require("./TypeImports.js");
 const known_codecs_js_1 = require("./known-codecs.js");
 // Skip generate types for these
@@ -425,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/index.js

@@ -23,42 +23,42 @@ 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 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 generateTypesFromChain(network, endpoint, outDir) {
-    const api = await dedot_1.Dedot.create(endpoint);
-    const { methods } = await api.rpc.rpc.methods();
+async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts') {
+    const api = await dedot_1.Dedot.new(endpoint);
+    const { methods } = await api.rpc.rpc_methods();
     const apis = api.runtimeVersion?.apis || [];
-    if (!network.chain) {
-        network.chain = (0, utils_1.stringCamelCase)(api.runtimeVersion?.specName || api.runtimeChain || 'local');
+    if (!chain) {
+        chain = (0, utils_1.stringCamelCase)(api.runtimeVersion?.specName || api.runtimeChain || 'local');
     }
-    await generateTypes(network, api.metadataLatest, methods, apis, outDir);
+    await generateTypes(chain, api.metadataLatest, methods, apis, outDir, extension);
     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') {
+    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);
@@ -66,7 +66,7 @@ async function generateTypes(network, metadata, rpcMethods, runtimeApis, outDir
     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(jsonRpcFileName, await jsonRpcGen.generate());
     fs.writeFileSync(queryTypesFileName, await queryGen.generate());
     fs.writeFileSync(constsTypesFileName, await constsGen.generate());
     fs.writeFileSync(txFileName, await txGen.generate());

package/cjs/templates/index.hbs

@@ -3,7 +3,7 @@
 import { GenericSubstrateApi } 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';
@@ -12,7 +12,7 @@ import { ChainTx } from './tx';
 export * from './types';
 
 export interface {{{interfaceName}}}Api extends GenericSubstrateApi {
-  rpc: RpcCalls;
+  jsonrpc: ChainJsonRpcApis;
   consts: ChainConsts;
   query: ChainStorage;
   errors: ChainErrors;

package/cjs/templates/json-rpc.hbs

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

package/generator/ApiGen.d.ts

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

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>;
 }

package/generator/ConstsGen.js

@@ -1,5 +1,5 @@
 import { normalizeName, stringCamelCase } from '@dedot/utils';
-import { ApiGen } from '../generator/index.js';
+import { ApiGen } from './ApiGen.js';
 import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class ConstsGen extends ApiGen {
     generate() {

package/generator/IndexGen.d.ts

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

package/generator/IndexGen.js

@@ -1,13 +1,12 @@
 import { beautifySourceCode, compileTemplate } from './utils.js';
 import { stringPascalCase } from '@dedot/utils';
 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);
+        const interfaceName = stringPascalCase(this.chain);
         const template = compileTemplate('index.hbs');
         return beautifySourceCode(template({ interfaceName }));
     }

package/generator/{RpcGen.d.ts → JsonRpcGen.d.ts}

@@ -1,10 +1,7 @@
 import { ApiGen, TypesGen } from '../generator/index.js';
-export declare class RpcGen extends ApiGen {
-    #private;
+export declare class JsonRpcGen extends ApiGen {
     readonly typesGen: TypesGen;
     readonly rpcMethods: string[];
     constructor(typesGen: TypesGen, rpcMethods: string[]);
     generate(): Promise<string>;
-    addTypeImport(type: string | string[], toTypeIn?: boolean): void;
-    getGeneratedTypeName(type: string, toTypeIn?: boolean): string;
 }

package/generator/JsonRpcGen.js

@@ -0,0 +1,55 @@
+import { ApiGen } from '../generator/index.js';
+import { beautifySourceCode, compileTemplate } from './utils.js';
+import { subscriptionsInfo } from '@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',
+];
+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() {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericJsonRpcApis');
+        this.typesGen.typeImports.addSpecType('JsonRpcApis');
+        const toExclude = Object.values(subscriptionsInfo).flat();
+        const importTypes = this.typesGen.typeImports.toImports();
+        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,4 +1,4 @@
-import { ApiGen } from '../generator/index.js';
+import { ApiGen } from './ApiGen.js';
 export declare class QueryGen extends ApiGen {
     #private;
     generate(): Promise<string>;

package/generator/QueryGen.js

@@ -1,5 +1,5 @@
 import { normalizeName, stringCamelCase } from '@dedot/utils';
-import { ApiGen } from '../generator/index.js';
+import { ApiGen } from './ApiGen.js';
 import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class QueryGen extends ApiGen {
     generate() {

package/generator/RuntimeApisGen.d.ts

@@ -1,6 +1,6 @@
 import { TypesGen } from './TypesGen.js';
-import { RpcGen } from './RpcGen.js';
-export declare class RuntimeApisGen extends RpcGen {
+import { ApiGen } from './ApiGen.js';
+export declare class RuntimeApisGen extends ApiGen {
     #private;
     readonly typesGen: TypesGen;
     readonly runtimeApis: [string, number][];