@dedot/codegen 0.0.1-alpha.30 → 0.0.1-alpha.32

package/generator/RuntimeApisGen.js

@@ -1,18 +1,19 @@
-import { getRuntimeApiNames, getRuntimeApiSpecs } from '@dedot/specs';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
+import { getRuntimeApiNames, getRuntimeApiSpecs } from '@dedot/runtime-specs';
 import { calcRuntimeApiHash, stringSnakeCase, stringCamelCase } from '@dedot/utils';
-import { RpcGen } from './RpcGen.js';
-export class RuntimeApisGen extends RpcGen {
+import { ApiGen } from './ApiGen.js';
+import { findKnownCodecType } from './known-codecs.js';
+import { beautifySourceCode, commentBlock, compileTemplate, isNativeType, TUPLE_TYPE_REGEX, WRAPPER_TYPE_REGEX, } from './utils.js';
+export class RuntimeApisGen extends ApiGen {
     typesGen;
     runtimeApis;
     constructor(typesGen, runtimeApis) {
-        super(typesGen, []);
+        super(typesGen);
         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) => {
@@ -21,7 +22,7 @@ export class RuntimeApisGen extends RpcGen {
                 runtimeCallsOut += `${stringCamelCase(runtimeApiName)}: {
             ${methods.map((method) => this.#generateMethodDef(runtimeApiName, method)).join('\n')} 
               
-            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
+            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
         }`;
             });
         }
@@ -38,11 +39,11 @@ export class RuntimeApisGen extends RpcGen {
                 }))
                     .join('\n')} 
               
-            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
+            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
           }`;
             });
         }
-        const importTypes = this.typesGen.typeImports.toImports();
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const template = compileTemplate('runtime.hbs');
         return beautifySourceCode(template({ importTypes, runtimeCallsOut }));
     }
@@ -56,25 +57,25 @@ export class RuntimeApisGen extends RpcGen {
         const { docs = [], params, type, runtimeApiName, methodName } = spec;
         const callName = `${runtimeApiName}_${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 }) => `${stringCamelCase(name)}${isOptional ? '?' : ''}: ${plainType}`)
             .join(', ');
-        const typeOut = this.getGeneratedTypeName(type, false);
-        return `${commentBlock(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
+        const typeOut = this.#getGeneratedTypeName(type, false);
+        return `${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}_${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,
@@ -84,14 +85,14 @@ export class RuntimeApisGen extends 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 }) => `${stringCamelCase(name)}${isOptional ? '?' : ''}: ${type}`)
             .join(', ');
-        return `${commentBlock(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${stringCamelCase(methodName)}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
+        return `${commentBlock(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${stringCamelCase(methodName)}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
     }
     #targetRuntimeApiSpecs() {
-        const specs = this.runtimeApis.map(([runtimeApiHash, version]) => {
+        const specs = Object.entries(this.runtimeApis).map(([runtimeApiHash, version]) => {
             const runtimeApiSpec = this.#findRuntimeApiSpec(runtimeApiHash, version);
             if (!runtimeApiSpec)
                 return;
@@ -111,4 +112,78 @@ export class RuntimeApisGen extends RpcGen {
         const runtimeApiName = getRuntimeApiNames().find((one) => calcRuntimeApiHash(one) === runtimeApiHash);
         return 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 (isNativeType(type)) {
+            return;
+        }
+        // Handle generic wrapper types
+        const matchArray = type.match(WRAPPER_TYPE_REGEX);
+        if (matchArray) {
+            const [_, $1, $2] = matchArray;
+            this.#addTypeImport($1, toTypeIn);
+            if ($2.match(WRAPPER_TYPE_REGEX) || $2.match(TUPLE_TYPE_REGEX)) {
+                this.#addTypeImport($2, toTypeIn);
+            }
+            else {
+                this.#addTypeImport($2.split(','), toTypeIn);
+            }
+            return;
+        }
+        // Check tuple type
+        if (type.match(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 (isNativeType(codecType))
+                return;
+            this.typesGen.typeImports.addCodecType(codecType);
+            return;
+        }
+        catch (e) { }
+        this.typesGen.addTypeImport(type);
+    }
+    #getGeneratedTypeName(type, toTypeIn = true) {
+        try {
+            const matchArray = type.match(WRAPPER_TYPE_REGEX);
+            if (matchArray) {
+                const [_, $1, $2] = matchArray;
+                const wrapperTypeName = this.#getCodecType($1, toTypeIn);
+                if ($2.match(WRAPPER_TYPE_REGEX) || $2.match(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(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 } = findKnownCodecType(type);
+        return toTypeIn ? typeIn : typeOut;
+    }
 }

package/generator/TxGen.d.ts

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

package/generator/TxGen.js

@@ -1,11 +1,11 @@
-import { ApiGen } from '../generator/index.js';
 import { stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { ApiGen } from '../generator/index.js';
 import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from './utils.js';
 export class TxGen extends 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);
@@ -41,20 +41,22 @@ export class TxGen extends ApiGen {
             txDefsOut += commentBlock(`Pallet \`${pallet.name}\`'s transaction calls`);
             txDefsOut += `${stringCamelCase(pallet.name)}: {
           ${typedTxs
-                .map(({ functionName, params, docs, callInput }) => `${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 }) => `${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')}
             
-          ${commentBlock('Generic pallet tx call')}[callName: string]: GenericTxCall<TxCall>,
+          ${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 = compileTemplate('tx.hbs');
         return beautifySourceCode(template({ importTypes, defTypes, txDefsOut }));

package/generator/TypeImports.d.ts

@@ -1,14 +1,21 @@
+type ImportConfig = {
+    excludeModules?: string[];
+    useSubPaths?: boolean;
+};
 export declare class TypeImports {
     #private;
     portableTypes: Set<string>;
     codecTypes: Set<string>;
     knownTypes: Set<string>;
+    knownJsonRpcTypes: Set<string>;
     outTypes: Set<string>;
     constructor();
     clear(): void;
-    toImports(...excludeModules: string[]): string;
+    toImports(config?: ImportConfig): string;
     addPortableType(...types: string[]): void;
     addCodecType(...types: string[]): void;
     addKnownType(...types: string[]): void;
+    addKnownJsonRpcType(...types: string[]): void;
     addOutType(...types: string[]): void;
 }
+export {};

package/generator/TypeImports.js

@@ -5,30 +5,37 @@ export class TypeImports {
     codecTypes;
     // Known types that're not codecs or chain/portable types defined in @dedot/types
     knownTypes;
+    knownJsonRpcTypes;
     // External types to define explicitly
     outTypes;
     constructor() {
         this.portableTypes = new Set();
         this.codecTypes = new Set();
         this.knownTypes = new Set();
+        this.knownJsonRpcTypes = new Set();
         this.outTypes = new Set();
     }
     clear() {
         this.portableTypes.clear();
         this.codecTypes.clear();
         this.knownTypes.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.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
             .filter(([_, module]) => !excludeModules.includes(module))
             .map(([types, module]) => this.#toImportLine(types, module))
+            .filter((line) => line.length > 0)
             .join('\n');
     }
     #toImportLine(types, module) {
@@ -46,6 +53,9 @@ export class TypeImports {
     addKnownType(...types) {
         types.forEach((one) => this.knownTypes.add(one));
     }
+    addKnownJsonRpcType(...types) {
+        types.forEach((one) => this.knownJsonRpcTypes.add(one));
+    }
     addOutType(...types) {
         types.forEach((one) => this.outTypes.add(one));
     }

package/generator/TypesGen.d.ts

@@ -1,4 +1,4 @@
-import { PortableRegistry, Field, MetadataLatest, PortableType, TypeId } from '@dedot/codecs';
+import { Field, MetadataLatest, PortableRegistry, PortableType, TypeId } from '@dedot/codecs';
 import { TypeImports } from './TypeImports.js';
 interface NamedType extends PortableType {
     name: string;
@@ -18,7 +18,7 @@ export declare class TypesGen {
     registry: PortableRegistry;
     typeImports: TypeImports;
     constructor(metadata: MetadataLatest);
-    generate(): Promise<string>;
+    generate(useSubPaths?: boolean): Promise<string>;
     typeCache: Record<string, string>;
     clearCache(): void;
     generateType(typeId: TypeId, nestedLevel?: number, typeOut?: boolean): string;

package/generator/TypesGen.js

@@ -1,9 +1,8 @@
 import { PortableRegistry } from '@dedot/codecs';
 import { normalizeName, stringPascalCase } from '@dedot/utils';
-import { isNativeType, beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
-import { knownTypes } from './known-types.js';
 import { TypeImports } from './TypeImports.js';
 import { findKnownCodec, findKnownCodecType, isKnownCodecType } from './known-codecs.js';
+import { beautifySourceCode, commentBlock, compileTemplate, isNativeType } from './utils.js';
 // Skip generate types for these
 // as we do have native types for them
 const SKIP_TYPES = [
@@ -41,7 +40,7 @@ export class TypesGen {
         this.includedTypes = this.#includedTypes();
         this.typeImports = new TypeImports();
     }
-    generate() {
+    generate(useSubPaths = false) {
         this.clearCache();
         let defTypeOut = '';
         Object.values(this.includedTypes)
@@ -52,7 +51,7 @@ export 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 = compileTemplate('types.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
@@ -422,11 +421,6 @@ export class TypesGen {
             this.typeImports.addCodecType(typeName);
             return;
         }
-        if (knownTypes.includes(typeName)) {
-            this.typeImports.addKnownType(typeName);
-        }
-        else {
-            this.typeImports.addOutType(typeName);
-        }
+        this.typeImports.addOutType(typeName);
     }
 }

package/generator/index.d.ts

@@ -2,7 +2,7 @@ export * from './TypesGen.js';
 export * from './ApiGen.js';
 export * from './ConstsGen.js';
 export * from './QueryGen.js';
-export * from './RpcGen.js';
+export * from './JsonRpcGen.js';
 export * from './IndexGen.js';
 export * from './ErrorsGen.js';
 export * from './EventsGen.js';

package/generator/index.js

@@ -2,7 +2,7 @@ export * from './TypesGen.js';
 export * from './ApiGen.js';
 export * from './ConstsGen.js';
 export * from './QueryGen.js';
-export * from './RpcGen.js';
+export * from './JsonRpcGen.js';
 export * from './IndexGen.js';
 export * from './ErrorsGen.js';
 export * from './EventsGen.js';

package/generator/known-codecs.d.ts

@@ -1,5 +1,5 @@
-import * as $ from '@dedot/shape';
 import { AnyShape } from '@dedot/shape';
+import * as $ from '@dedot/shape';
 export type CodecName = `$${string}`;
 export interface CodecType {
     name: CodecName;

package/generator/known-codecs.js

@@ -1,6 +1,6 @@
-import * as $ from '@dedot/shape';
 import * as Codecs from '@dedot/codecs';
 import { $AccountId20, $AccountId32, $Bytes, $ConsensusEngineId, $Era, $EthereumAddress, $MultiAddress, $OpaqueExtrinsic, $PrefixedStorageKey, $RawBytes, $StorageData, $StorageKey, $UncheckedExtrinsic, } from '@dedot/codecs';
+import * as $ from '@dedot/shape';
 import { assert } from '@dedot/utils';
 export const normalizeCodecName = (name) => {
     return name.startsWith('$') ? name : `$${name}`;

package/index.d.ts

@@ -1,3 +1,3 @@
 import { MetadataLatest } from '@dedot/codecs';
-export declare function generateTypesFromEndpoint(chain: string, endpoint: string, outDir?: string): Promise<void>;
-export declare function generateTypes(chain: string, metadata: MetadataLatest, rpcMethods: string[], runtimeApis: any[], outDir?: string): Promise<void>;
+export declare function generateTypesFromEndpoint(chain: string, endpoint: string, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<void>;
+export declare function generateTypes(chain: string, metadata: MetadataLatest, rpcMethods: string[], runtimeApis: Record<string, number>, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<void>;

package/index.js

@@ -1,48 +1,49 @@
-import { Dedot } from 'dedot';
+import { Dedot } from '@dedot/api';
+import { WsProvider } from '@dedot/providers';
+import { stringCamelCase } from '@dedot/utils';
 import * as fs from 'fs';
 import * as path from 'path';
-import { ConstsGen, ErrorsGen, EventsGen, IndexGen, QueryGen, RpcGen, RuntimeApisGen, TxGen, TypesGen, } from './generator/index.js';
-import { stringCamelCase } from '@dedot/utils';
-export async function generateTypesFromEndpoint(chain, endpoint, outDir) {
-    const api = await Dedot.new(endpoint);
-    const { methods } = await api.rpc.rpc.methods();
-    const apis = api.runtimeVersion?.apis || [];
+import { ConstsGen, ErrorsGen, EventsGen, IndexGen, JsonRpcGen, QueryGen, RuntimeApisGen, TxGen, TypesGen, } from './generator/index.js';
+export async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts', useSubPaths = false) {
+    const api = await Dedot.new(new WsProvider(endpoint));
+    const { methods } = await api.rpc.rpc_methods();
+    const apis = api.runtimeVersion.apis || {};
     if (!chain) {
-        chain = stringCamelCase(api.runtimeVersion?.specName || api.runtimeChain || 'local');
+        chain = stringCamelCase(api.runtimeVersion.specName || 'local');
     }
-    await generateTypes(chain, api.metadataLatest, methods, apis, outDir);
+    await generateTypes(chain, api.metadata.latest, methods, apis, outDir, extension, useSubPaths);
     await api.disconnect();
 }
-export async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir = '.') {
+export 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.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`);
+    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 TypesGen(metadata);
     const constsGen = new ConstsGen(typesGen);
     const queryGen = new QueryGen(typesGen);
-    const rpcGen = new RpcGen(typesGen, rpcMethods);
+    const jsonRpcGen = new JsonRpcGen(typesGen, rpcMethods);
     const indexGen = new IndexGen(chain);
     const errorsGen = new ErrorsGen(typesGen);
     const eventsGen = new EventsGen(typesGen);
     const runtimeApisGen = new RuntimeApisGen(typesGen, runtimeApis);
     const txGen = new 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));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.0.1-alpha.30",
+  "version": "0.0.1-alpha.32",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/codegen",
@@ -18,32 +18,30 @@
     "copy": "cp -R ./src/templates ./dist && cp -R ./src/templates ./dist/cjs"
   },
   "dependencies": {
-    "@dedot/codecs": "0.0.1-alpha.30",
-    "@dedot/shape": "0.0.1-alpha.30",
-    "@dedot/specs": "0.0.1-alpha.30",
-    "@dedot/utils": "0.0.1-alpha.30",
-    "dedot": "0.0.1-alpha.30",
-    "handlebars": "^4.7.8",
-    "prettier": "^3.0.3"
+    "@dedot/api": "0.0.1-alpha.32",
+    "@dedot/codecs": "0.0.1-alpha.32",
+    "@dedot/providers": "0.0.1-alpha.32",
+    "@dedot/runtime-specs": "0.0.1-alpha.32",
+    "@dedot/shape": "0.0.1-alpha.32",
+    "@dedot/types": "0.0.1-alpha.32",
+    "@dedot/utils": "0.0.1-alpha.32",
+    "handlebars": "^4.7.7",
+    "prettier": "^3.2.5"
   },
   "publishConfig": {
     "access": "public",
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "ebc78daa1c0786f16dbf3a1f2c7a385142860ebc",
+  "gitHead": "43501104eee360a19ae18a70fe506e16d9357835",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      },
-      "require": {
-        "types": "./index.d.ts",
-        "default": "./cjs/index.js"
-      }
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./cjs/index.js",
+      "default": "./index.js"
     }
   }
 }

package/templates/consts.hbs

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

package/templates/errors.hbs

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

package/templates/events.hbs

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

package/templates/index.hbs

@@ -1,9 +1,9 @@
 // Generated by @dedot/codegen
 
-import { GenericSubstrateApi } from '@dedot/types';
+{{{importTypes}}}
 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/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/templates/query.hbs

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

package/templates/runtime.hbs

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

package/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 }}}
 }