@dedot/codegen 0.0.1-next.9dacef43.1 → 0.0.1-next.a5b1d2fb.22

package/{generator → chaintypes/generator}/ApiGen.d.ts

@@ -1,4 +1,4 @@
-import { TypesGen } from '../generator';
+import { TypesGen } from './TypesGen.js';
 export declare abstract class ApiGen {
     readonly typesGen: TypesGen;
     constructor(typesGen: TypesGen);
@@ -134,5 +134,5 @@ export declare abstract class ApiGen {
             }>;
         };
     };
-    get registry(): import("@dedot/codecs").CodecRegistry;
+    get registry(): import("@dedot/codecs").PortableRegistry;
 }

package/chaintypes/generator/ConstsGen.d.ts

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

package/{generator → chaintypes/generator}/ConstsGen.js

@@ -1,12 +1,11 @@
-import { stringLowerFirst } from '@polkadot/util';
-import { normalizeName } from '@dedot/utils';
-import { ApiGen } from '../generator';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { normalizeName, stringCamelCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+import { ApiGen } from './ApiGen.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,14 +14,14 @@ 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 template = compileTemplate('consts.hbs');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('chaintypes/templates/consts.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
 }

package/chaintypes/generator/ErrorsGen.d.ts

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

package/{generator → chaintypes/generator}/ErrorsGen.js

@@ -1,12 +1,11 @@
-import { ApiGen } from './ApiGen';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
-import { stringCamelCase, stringPascalCase } from '@polkadot/util';
-import { assert } from '@dedot/utils';
+import { assert, stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+import { ApiGen } from './ApiGen.js';
 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,14 +16,14 @@ 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 template = compileTemplate('errors.hbs');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('chaintypes/templates/errors.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
     #getErrorDefs(errorTypeId) {

package/chaintypes/generator/EventsGen.d.ts

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

package/{generator → chaintypes/generator}/EventsGen.js

@@ -1,12 +1,11 @@
-import { ApiGen } from './ApiGen';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
-import { stringCamelCase, stringPascalCase } from '@polkadot/util';
-import { assert } from '@dedot/utils';
+import { assert, stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+import { ApiGen } from './ApiGen.js';
 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,14 +28,14 @@ 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 template = compileTemplate('events.hbs');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('chaintypes/templates/events.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
     #getEventDefs(typeId) {

package/chaintypes/generator/IndexGen.d.ts

@@ -0,0 +1,5 @@
+export declare class IndexGen {
+    readonly chain: string;
+    constructor(chain: string);
+    generate(useSubPaths?: boolean): Promise<string>;
+}

package/chaintypes/generator/IndexGen.js

@@ -0,0 +1,17 @@
+import { stringPascalCase } from '@dedot/utils';
+import { TypeImports } from '../../shared/index.js';
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+export class IndexGen {
+    chain;
+    constructor(chain) {
+        this.chain = chain;
+    }
+    async generate(useSubPaths = false) {
+        const interfaceName = stringPascalCase(this.chain);
+        const typeImports = new TypeImports();
+        typeImports.addKnownType('GenericSubstrateApi', 'RpcLegacy', 'RpcV2', 'RpcVersion');
+        const importTypes = typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('chaintypes/templates/index.hbs');
+        return beautifySourceCode(template({ importTypes, interfaceName }));
+    }
+}

package/chaintypes/generator/JsonRpcGen.d.ts

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

package/chaintypes/generator/JsonRpcGen.js

@@ -0,0 +1,55 @@
+import { subscriptionsInfo } from '@dedot/api';
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+import { ApiGen } from './ApiGen.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('chaintypes/templates/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/chaintypes/generator/QueryGen.d.ts

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

package/{generator → chaintypes/generator}/QueryGen.js

@@ -1,39 +1,46 @@
-import { stringLowerFirst } from '@polkadot/util';
-import { normalizeName } from '@dedot/utils';
-import { ApiGen } from '../generator';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { normalizeName, stringCamelCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+import { ApiGen } from './ApiGen.js';
 export class QueryGen extends 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 }) => `${commentBlock(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`);
+            const queryDefs = queries.map(({ name, valueType, keyType, docs, keyTypeOut }) => {
+                if (keyTypeOut) {
+                    return `${commentBlock(docs)}${name}: GenericStorageQuery<Rv, (${keyType}) => ${valueType}, ${keyTypeOut}>`;
+                }
+                else {
+                    return `${commentBlock(docs)}${name}: GenericStorageQuery<Rv, (${keyType}) => ${valueType}>`;
+                }
+            });
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s storage queries`);
-            defTypeOut += `${stringLowerFirst(pallet.name)}: {
+            defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${queryDefs.join(',\n')}
         
-        ${commentBlock('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
+        ${commentBlock('Generic pallet storage query')}[storage: string]: GenericStorageQuery<Rv>;
       },`;
         }
-        const importTypes = this.typesGen.typeImports.toImports();
-        const template = compileTemplate('query.hbs');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('chaintypes/templates/query.hbs');
         return 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!');
@@ -41,14 +48,15 @@ export class QueryGen extends 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: normalizeName(name),
             valueType,
-            keyType: keyType ? `arg: ${keyType}` : '',
+            keyType: keyTypeIn ? `arg: ${keyTypeIn}` : '',
+            keyTypeOut,
             docs,
         };
     }

package/chaintypes/generator/RuntimeApisGen.d.ts

@@ -0,0 +1,9 @@
+import { ApiGen } from './ApiGen.js';
+import { TypesGen } from './TypesGen.js';
+export declare class RuntimeApisGen extends ApiGen {
+    #private;
+    readonly typesGen: TypesGen;
+    readonly runtimeApis: Record<string, number>;
+    constructor(typesGen: TypesGen, runtimeApis: Record<string, number>);
+    generate(useSubPaths?: boolean): Promise<string>;
+}

package/chaintypes/generator/RuntimeApisGen.js

@@ -0,0 +1,189 @@
+import { getRuntimeApiNames, getRuntimeApiSpecs } from '@dedot/runtime-specs';
+import { calcRuntimeApiHash, stringSnakeCase, stringCamelCase } from '@dedot/utils';
+import { findKnownCodecType } from '../../shared/index.js';
+import { beautifySourceCode, commentBlock, compileTemplate, isNativeType, TUPLE_TYPE_REGEX, WRAPPER_TYPE_REGEX, } from '../../utils.js';
+import { ApiGen } from './ApiGen.js';
+export class RuntimeApisGen extends ApiGen {
+    typesGen;
+    runtimeApis;
+    constructor(typesGen, runtimeApis) {
+        super(typesGen);
+        this.typesGen = typesGen;
+        this.runtimeApis = runtimeApis;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericRuntimeApis', 'GenericRuntimeApiMethod', 'RpcVersion');
+        let runtimeCallsOut = '';
+        if (this.metadata.apis.length > 0) {
+            this.metadata.apis.forEach((runtimeApi) => {
+                const { name: runtimeApiName, methods } = runtimeApi;
+                runtimeCallsOut += commentBlock(`@runtimeapi: ${runtimeApiName} - ${calcRuntimeApiHash(runtimeApiName)}`);
+                runtimeCallsOut += `${stringCamelCase(runtimeApiName)}: {
+            ${methods.map((method) => this.#generateMethodDef(runtimeApiName, method)).join('\n')} 
+              
+            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
+        }`;
+            });
+        }
+        else {
+            const specs = this.#targetRuntimeApiSpecs();
+            specs.forEach(({ methods, runtimeApiName, runtimeApiHash, version }) => {
+                runtimeCallsOut += commentBlock(`@runtimeapi: ${runtimeApiName} - ${runtimeApiHash}`, `@version: ${version}`);
+                runtimeCallsOut += `${stringCamelCase(runtimeApiName)}: {
+            ${Object.keys(methods)
+                    .map((methodName) => this.#generateMethodDefFromSpec({
+                    ...methods[methodName],
+                    runtimeApiName,
+                    methodName,
+                }))
+                    .join('\n')} 
+              
+            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
+          }`;
+            });
+        }
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('chaintypes/templates/runtime.hbs');
+        return beautifySourceCode(template({ importTypes, runtimeCallsOut }));
+    }
+    #isOptionalType(type) {
+        return type.startsWith('Option<') || type.endsWith('| undefined');
+    }
+    #isOptionalParam(params, type, idx) {
+        return this.#isOptionalType(type) && params.slice(idx + 1).every(({ type }) => this.#isOptionalType(type));
+    }
+    #generateMethodDefFromSpec(spec) {
+        const { docs = [], params, type, runtimeApiName, methodName } = spec;
+        const callName = `${runtimeApiName}_${stringSnakeCase(methodName)}`;
+        const defaultDocs = [`@callname: ${callName}`];
+        this.#addTypeImport(type, false);
+        params.forEach(({ type }) => this.#addTypeImport(type));
+        const typedParams = params.map((param, idx) => ({
+            ...param,
+            isOptional: this.#isOptionalParam(params, param.type, idx),
+            plainType: this.#getGeneratedTypeName(param.type),
+        }));
+        const paramsOut = typedParams
+            .map(({ name, isOptional, plainType }) => `${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<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);
+        const typedInputs = inputs
+            .map((input, idx) => ({
+            ...input,
+            type: this.typesGen.generateType(input.typeId, 1),
+        }))
+            .map((input, idx, inputs) => ({
+            ...input,
+            isOptional: this.#isOptionalParam(inputs, input.type, idx),
+        }));
+        this.#addTypeImport(typedInputs.map((t) => t.type));
+        const paramsOut = typedInputs
+            .map(({ name, type, isOptional }) => `${stringCamelCase(name)}${isOptional ? '?' : ''}: ${type}`)
+            .join(', ');
+        return `${commentBlock(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${stringCamelCase(methodName)}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
+    }
+    #targetRuntimeApiSpecs() {
+        const specs = Object.entries(this.runtimeApis).map(([runtimeApiHash, version]) => {
+            const runtimeApiSpec = this.#findRuntimeApiSpec(runtimeApiHash, version);
+            if (!runtimeApiSpec)
+                return;
+            return {
+                ...runtimeApiSpec,
+                runtimeApiHash,
+            };
+        });
+        return specs.reduce((o, spec) => {
+            if (!spec) {
+                return o;
+            }
+            return [...o, spec];
+        }, []);
+    }
+    #findRuntimeApiSpec = (runtimeApiHash, version) => {
+        const runtimeApiName = 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/chaintypes/generator/TxGen.d.ts

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

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

@@ -1,11 +1,11 @@
-import { ApiGen } from '../generator';
-import { stringCamelCase, stringPascalCase } from '@polkadot/util';
-import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from './utils';
+import { stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from '../../utils.js';
+import { ApiGen } from '../generator/index.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,22 +41,24 @@ 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');
+        const template = compileTemplate('chaintypes/templates/tx.hbs');
         return beautifySourceCode(template({ importTypes, defTypes, txDefsOut }));
     }
     #normalizeParamName(name) {

package/chaintypes/generator/TypesGen.d.ts

@@ -0,0 +1,11 @@
+import { MetadataLatest, PortableRegistry, TypeId } from '@dedot/codecs';
+import { EnumOptions } from '@dedot/shape';
+import { BaseTypesGen } from '../../shared/index.js';
+export declare class TypesGen extends BaseTypesGen {
+    metadata: MetadataLatest;
+    registry: PortableRegistry;
+    constructor(metadata: MetadataLatest);
+    generate(useSubPaths?: boolean): Promise<string>;
+    shouldGenerateTypeIn(id: TypeId): boolean;
+    getEnumOptions(typeId: TypeId): EnumOptions;
+}

package/chaintypes/generator/TypesGen.js

@@ -0,0 +1,55 @@
+import { PortableRegistry } from '@dedot/codecs';
+import { BaseTypesGen } from '../../shared/index.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+// Skip generate types for these
+// as we do have native types for them
+const SKIP_TYPES = [
+    'BoundedBTreeMap',
+    'BoundedBTreeSet',
+    'BoundedVec',
+    'Box',
+    'BTreeMap',
+    'BTreeSet',
+    'Cow',
+    'Option',
+    'Range',
+    'RangeInclusive',
+    'Result',
+    'WeakBoundedVec',
+    'WrapperKeepOpaque',
+    'WrapperOpaque',
+];
+export class TypesGen extends BaseTypesGen {
+    metadata;
+    registry;
+    constructor(metadata) {
+        super(metadata.types);
+        this.metadata = metadata;
+        this.skipTypes = SKIP_TYPES;
+        this.registry = new PortableRegistry(this.metadata);
+        this.includedTypes = this.includeTypes();
+    }
+    generate(useSubPaths = false) {
+        this.clearCache();
+        let defTypeOut = '';
+        Object.values(this.includedTypes)
+            .filter(({ skip, knownType }) => !(skip || knownType))
+            .forEach(({ name, nameOut, id, docs }) => {
+            defTypeOut += `${commentBlock(docs)}export type ${nameOut} = ${this.generateType(id, 0, true)};\n\n`;
+            if (this.shouldGenerateTypeIn(id)) {
+                defTypeOut += `export type ${name} = ${this.generateType(id)};\n\n`;
+            }
+        });
+        const importTypes = this.typeImports.toImports({ excludeModules: ['./types'], useSubPaths });
+        const template = compileTemplate('chaintypes/templates/types.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+    shouldGenerateTypeIn(id) {
+        const { callTypeId } = this.metadata.extrinsic;
+        const palletCallTypeIds = this.registry.getPalletCallTypeIds();
+        return callTypeId === id || palletCallTypeIds.includes(id);
+    }
+    getEnumOptions(typeId) {
+        return this.registry.getEnumOptions(typeId);
+    }
+}