@dedot/codegen 0.4.1 → 0.5.0

package/chaintypes/generator/IndexGen.d.ts

@@ -1,5 +1,7 @@
+import { SubstrateRuntimeVersion } from '@dedot/api';
 export declare class IndexGen {
     readonly interfaceName: string;
-    constructor(interfaceName: string);
+    readonly runtimeVersion: SubstrateRuntimeVersion;
+    constructor(interfaceName: string, runtimeVersion: SubstrateRuntimeVersion);
     generate(useSubPaths?: boolean): Promise<string>;
 }

package/chaintypes/generator/IndexGen.js

@@ -1,16 +1,22 @@
 import { TypeImports } from '../../shared/index.js';
-import { beautifySourceCode, compileTemplate } from '../../utils.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
 export class IndexGen {
     interfaceName;
-    constructor(interfaceName) {
+    runtimeVersion;
+    constructor(interfaceName, runtimeVersion) {
         this.interfaceName = interfaceName;
+        this.runtimeVersion = runtimeVersion;
     }
     async generate(useSubPaths = false) {
         const interfaceName = this.interfaceName;
         const typeImports = new TypeImports();
         typeImports.addKnownType('GenericSubstrateApi', 'RpcLegacy', 'RpcV2', 'RpcVersion');
         const importTypes = typeImports.toImports({ useSubPaths });
+        const interfaceDocs = commentBlock([
+            `@name: ${interfaceName}`, // prettier-end-here
+            `@specVersion: ${this.runtimeVersion.specVersion}`,
+        ]);
         const template = compileTemplate('chaintypes/templates/index.hbs');
-        return beautifySourceCode(template({ importTypes, interfaceName }));
+        return beautifySourceCode(template({ interfaceName, interfaceDocs, importTypes }));
     }
 }

package/chaintypes/generator/JsonRpcGen.js

@@ -35,8 +35,10 @@ export class JsonRpcGen extends ApiGen {
         super(typesGen);
         this.typesGen = typesGen;
         this.rpcMethods = rpcMethods;
-        HIDDEN_RPCS.filter((one) => !rpcMethods.includes(one)).forEach((one) => rpcMethods.push(one));
-        rpcMethods.sort();
+        if (rpcMethods.length > 0) {
+            HIDDEN_RPCS.filter((one) => !rpcMethods.includes(one)).forEach((one) => rpcMethods.push(one));
+            rpcMethods.sort();
+        }
     }
     generate(useSubPaths = false) {
         this.typesGen.clearCache();

package/chaintypes/generator/TypesGen.js

@@ -23,11 +23,10 @@ export class TypesGen extends BaseTypesGen {
     metadata;
     registry;
     constructor(metadata) {
-        super(metadata.types);
+        super(metadata.types, SKIP_TYPES);
         this.metadata = metadata;
-        this.skipTypes = SKIP_TYPES;
         this.registry = new PortableRegistry(this.metadata);
-        this.includedTypes = this.includeTypes();
+        this.includedTypes = this.calculateIncludedTypes();
     }
     generate(useSubPaths = false) {
         this.clearCache();

package/chaintypes/index.d.ts

@@ -1,4 +1,5 @@
+import { SubstrateRuntimeVersion } from '@dedot/api';
 import { MetadataLatest } from '@dedot/codecs';
 import { GeneratedResult } from '../types.js';
 export declare function generateTypesFromEndpoint(chain: string, endpoint: string, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<GeneratedResult>;
-export declare function generateTypes(chain: string, metadata: MetadataLatest, rpcMethods: string[], runtimeApis: Record<string, number>, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<GeneratedResult>;
+export declare function generateTypes(chain: string, metadata: MetadataLatest, rpcMethods: string[], runtimeVersion: SubstrateRuntimeVersion, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<GeneratedResult>;

package/chaintypes/index.js

@@ -6,15 +6,14 @@ import * as path from 'path';
 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) {
     // Immediately throw error if cannot connect to provider for the first time.
-    const api = await LegacyClient.new(new WsProvider({ endpoint, retryDelayMs: 0, timeout: 0 }));
-    const { methods } = await api.rpc.rpc_methods();
-    const apis = api.runtimeVersion.apis || {};
-    chain = chain || api.runtimeVersion.specName || 'local';
-    const result = await generateTypes(chain, api.metadata.latest, methods, apis, outDir, extension, useSubPaths);
-    await api.disconnect();
+    const client = await LegacyClient.new(new WsProvider({ endpoint, retryDelayMs: 0, timeout: 0 }));
+    const { methods } = await client.rpc.rpc_methods();
+    chain = chain || client.runtimeVersion.specName || 'local';
+    const result = await generateTypes(chain, client.metadata.latest, methods, client.runtimeVersion, outDir, extension, useSubPaths);
+    await client.disconnect();
     return result;
 }
-export async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir = '.', extension = 'd.ts', useSubPaths = false) {
+export async function generateTypes(chain, metadata, rpcMethods, runtimeVersion, outDir = '.', extension = 'd.ts', useSubPaths = false) {
     const dirPath = path.resolve(outDir, stringDashCase(chain));
     const defTypesFileName = path.join(dirPath, `types.${extension}`);
     const constsTypesFileName = path.join(dirPath, `consts.${extension}`);
@@ -33,10 +32,10 @@ export async function generateTypes(chain, metadata, rpcMethods, runtimeApis, ou
     const constsGen = new ConstsGen(typesGen);
     const queryGen = new QueryGen(typesGen);
     const jsonRpcGen = new JsonRpcGen(typesGen, rpcMethods);
-    const indexGen = new IndexGen(interfaceName);
+    const indexGen = new IndexGen(interfaceName, runtimeVersion);
     const errorsGen = new ErrorsGen(typesGen);
     const eventsGen = new EventsGen(typesGen);
-    const runtimeApisGen = new RuntimeApisGen(typesGen, runtimeApis);
+    const runtimeApisGen = new RuntimeApisGen(typesGen, runtimeVersion.apis);
     const txGen = new TxGen(typesGen);
     fs.writeFileSync(defTypesFileName, await typesGen.generate(useSubPaths));
     fs.writeFileSync(errorsFileName, await errorsGen.generate(useSubPaths));
@@ -47,5 +46,5 @@ export async function generateTypes(chain, metadata, rpcMethods, runtimeApis, ou
     fs.writeFileSync(txFileName, await txGen.generate(useSubPaths));
     fs.writeFileSync(indexFileName, await indexGen.generate(useSubPaths));
     fs.writeFileSync(runtimeApisFileName, await runtimeApisGen.generate(useSubPaths));
-    return { interfaceName };
+    return { interfaceName, outputFolder: dirPath };
 }

package/chaintypes/templates/index.hbs

@@ -21,7 +21,7 @@ export interface Versioned{{{interfaceName}}}<Rv extends RpcVersion> extends Gen
   tx: ChainTx<Rv>;
 }
 
-export interface {{{interfaceName}}} {
+{{interfaceDocs}}export interface {{{interfaceName}}} {
   legacy: Versioned{{{interfaceName}}}<RpcLegacy>;
   v2: Versioned{{{interfaceName}}}<RpcV2>;
 }

package/chaintypes/templates/json-rpc.hbs

@@ -2,4 +2,9 @@
 
 {{{ importTypes }}}
 
-export type ChainJsonRpcApis<Rv extends RpcVersion> = Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis<Rv>;
+export type ChainJsonRpcApis<Rv extends RpcVersion> =
+  {{#if jsonRpcMethods.length}}
+    Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis<Rv>;
+  {{else}}
+    JsonRpcApis & GenericJsonRpcApis<Rv>;
+  {{/if}}

package/cjs/chaintypes/generator/IndexGen.js

@@ -5,16 +5,22 @@ const index_js_1 = require("../../shared/index.js");
 const utils_js_1 = require("../../utils.js");
 class IndexGen {
     interfaceName;
-    constructor(interfaceName) {
+    runtimeVersion;
+    constructor(interfaceName, runtimeVersion) {
         this.interfaceName = interfaceName;
+        this.runtimeVersion = runtimeVersion;
     }
     async generate(useSubPaths = false) {
         const interfaceName = this.interfaceName;
         const typeImports = new index_js_1.TypeImports();
         typeImports.addKnownType('GenericSubstrateApi', 'RpcLegacy', 'RpcV2', 'RpcVersion');
         const importTypes = typeImports.toImports({ useSubPaths });
+        const interfaceDocs = (0, utils_js_1.commentBlock)([
+            `@name: ${interfaceName}`, // prettier-end-here
+            `@specVersion: ${this.runtimeVersion.specVersion}`,
+        ]);
         const template = (0, utils_js_1.compileTemplate)('chaintypes/templates/index.hbs');
-        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, interfaceName }));
+        return (0, utils_js_1.beautifySourceCode)(template({ interfaceName, interfaceDocs, importTypes }));
     }
 }
 exports.IndexGen = IndexGen;

package/cjs/chaintypes/generator/JsonRpcGen.js

@@ -38,8 +38,10 @@ class JsonRpcGen extends ApiGen_js_1.ApiGen {
         super(typesGen);
         this.typesGen = typesGen;
         this.rpcMethods = rpcMethods;
-        HIDDEN_RPCS.filter((one) => !rpcMethods.includes(one)).forEach((one) => rpcMethods.push(one));
-        rpcMethods.sort();
+        if (rpcMethods.length > 0) {
+            HIDDEN_RPCS.filter((one) => !rpcMethods.includes(one)).forEach((one) => rpcMethods.push(one));
+            rpcMethods.sort();
+        }
     }
     generate(useSubPaths = false) {
         this.typesGen.clearCache();

package/cjs/chaintypes/generator/TypesGen.js

@@ -26,11 +26,10 @@ class TypesGen extends index_js_1.BaseTypesGen {
     metadata;
     registry;
     constructor(metadata) {
-        super(metadata.types);
+        super(metadata.types, SKIP_TYPES);
         this.metadata = metadata;
-        this.skipTypes = SKIP_TYPES;
         this.registry = new codecs_1.PortableRegistry(this.metadata);
-        this.includedTypes = this.includeTypes();
+        this.includedTypes = this.calculateIncludedTypes();
     }
     generate(useSubPaths = false) {
         this.clearCache();

package/cjs/chaintypes/index.js

@@ -32,16 +32,15 @@ const path = __importStar(require("path"));
 const index_js_1 = require("./generator/index.js");
 async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts', useSubPaths = false) {
     // Immediately throw error if cannot connect to provider for the first time.
-    const api = await api_1.LegacyClient.new(new providers_1.WsProvider({ endpoint, retryDelayMs: 0, timeout: 0 }));
-    const { methods } = await api.rpc.rpc_methods();
-    const apis = api.runtimeVersion.apis || {};
-    chain = chain || api.runtimeVersion.specName || 'local';
-    const result = await generateTypes(chain, api.metadata.latest, methods, apis, outDir, extension, useSubPaths);
-    await api.disconnect();
+    const client = await api_1.LegacyClient.new(new providers_1.WsProvider({ endpoint, retryDelayMs: 0, timeout: 0 }));
+    const { methods } = await client.rpc.rpc_methods();
+    chain = chain || client.runtimeVersion.specName || 'local';
+    const result = await generateTypes(chain, client.metadata.latest, methods, client.runtimeVersion, outDir, extension, useSubPaths);
+    await client.disconnect();
     return result;
 }
 exports.generateTypesFromEndpoint = generateTypesFromEndpoint;
-async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir = '.', extension = 'd.ts', useSubPaths = false) {
+async function generateTypes(chain, metadata, rpcMethods, runtimeVersion, outDir = '.', extension = 'd.ts', useSubPaths = false) {
     const dirPath = path.resolve(outDir, (0, utils_1.stringDashCase)(chain));
     const defTypesFileName = path.join(dirPath, `types.${extension}`);
     const constsTypesFileName = path.join(dirPath, `consts.${extension}`);
@@ -60,10 +59,10 @@ async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir =
     const constsGen = new index_js_1.ConstsGen(typesGen);
     const queryGen = new index_js_1.QueryGen(typesGen);
     const jsonRpcGen = new index_js_1.JsonRpcGen(typesGen, rpcMethods);
-    const indexGen = new index_js_1.IndexGen(interfaceName);
+    const indexGen = new index_js_1.IndexGen(interfaceName, runtimeVersion);
     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 runtimeApisGen = new index_js_1.RuntimeApisGen(typesGen, runtimeVersion.apis);
     const txGen = new index_js_1.TxGen(typesGen);
     fs.writeFileSync(defTypesFileName, await typesGen.generate(useSubPaths));
     fs.writeFileSync(errorsFileName, await errorsGen.generate(useSubPaths));
@@ -74,6 +73,6 @@ async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir =
     fs.writeFileSync(txFileName, await txGen.generate(useSubPaths));
     fs.writeFileSync(indexFileName, await indexGen.generate(useSubPaths));
     fs.writeFileSync(runtimeApisFileName, await runtimeApisGen.generate(useSubPaths));
-    return { interfaceName };
+    return { interfaceName, outputFolder: dirPath };
 }
 exports.generateTypes = generateTypes;

package/cjs/chaintypes/templates/index.hbs

@@ -21,7 +21,7 @@ export interface Versioned{{{interfaceName}}}<Rv extends RpcVersion> extends Gen
   tx: ChainTx<Rv>;
 }
 
-export interface {{{interfaceName}}} {
+{{interfaceDocs}}export interface {{{interfaceName}}} {
   legacy: Versioned{{{interfaceName}}}<RpcLegacy>;
   v2: Versioned{{{interfaceName}}}<RpcV2>;
 }

package/cjs/chaintypes/templates/json-rpc.hbs

@@ -2,4 +2,9 @@
 
 {{{ importTypes }}}
 
-export type ChainJsonRpcApis<Rv extends RpcVersion> = Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis<Rv>;
+export type ChainJsonRpcApis<Rv extends RpcVersion> =
+  {{#if jsonRpcMethods.length}}
+    Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis<Rv>;
+  {{else}}
+    JsonRpcApis & GenericJsonRpcApis<Rv>;
+  {{/if}}

package/cjs/shared/BaseTypesGen.js

@@ -14,11 +14,13 @@ class BaseTypesGen {
     includedTypes;
     typeImports;
     skipTypes;
-    constructor(types) {
+    knownTypes;
+    constructor(types, skipTypes = []) {
         this.types = types;
-        this.includedTypes = {};
+        this.skipTypes = skipTypes;
         this.typeImports = new TypeImports_js_1.TypeImports();
-        this.skipTypes = [];
+        this.knownTypes = this.calculateKnownTypes();
+        this.includedTypes = {};
     }
     shouldGenerateTypeIn(_id) {
         return false;
@@ -28,7 +30,17 @@ class BaseTypesGen {
         this.typeCache = {};
         this.typeImports.clear();
     }
-    includeTypes() {
+    calculateKnownTypes() {
+        const typesWithPath = this.types.filter((one) => one.path.length > 0);
+        return typesWithPath.reduce((o, type) => {
+            const { path, id } = type;
+            const [knownType, codecName] = (0, known_codecs_js_1.checkKnownCodecType)(path.join('::'));
+            if (!knownType)
+                return o;
+            return { ...o, [id]: codecName };
+        }, {});
+    }
+    calculateIncludedTypes() {
         const pathsCount = new Map();
         const typesWithPath = this.types.filter((one) => one.path.length > 0);
         const skipIds = [];
@@ -60,14 +72,13 @@ class BaseTypesGen {
                 return o;
             }
             const suffix = typeSuffixes.get(id) || '';
-            let knownType = false;
             let name, nameOut;
-            const [isKnownCodecType, codecName] = (0, known_codecs_js_1.checkKnownCodecType)(joinedPath);
-            if (isKnownCodecType) {
-                const codecType = (0, known_codecs_js_1.findKnownCodecType)(codecName);
+            const knownCodecName = this.knownTypes[id];
+            const knownType = !!knownCodecName;
+            if (knownType) {
+                const codecType = (0, known_codecs_js_1.findKnownCodecType)(knownCodecName);
                 name = codecType.typeIn;
                 nameOut = codecType.typeOut;
-                knownType = true;
             }
             else if (PATH_RM_INDEX_1.includes(path[1])) {
                 const newPath = path.slice();
@@ -77,7 +88,7 @@ class BaseTypesGen {
             else {
                 name = this.cleanPath(path);
             }
-            if (this.shouldGenerateTypeIn(id)) {
+            if (!knownType && this.shouldGenerateTypeIn(id)) {
                 nameOut = name;
                 name = name.endsWith('Like') ? name : `${name}Like`;
             }

package/cjs/typink/generator/ConstructorQueryGen.js

@@ -14,14 +14,13 @@ class ConstructorQueryGen extends QueryGen_js_1.QueryGen {
         const template = (0, utils_js_1.compileTemplate)('typink/templates/constructor-query.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, constructorsOut }));
     }
-    generateMethodDef(def) {
+    generateMethodDef(def, optionsParamName = 'options') {
         const { args, returnType } = def;
-        args.forEach(({ type: { type } }) => this.importType(type));
         const paramsOut = this.generateParamsOut(args);
         const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
         // Unwrap langError result
         const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
-        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult<ChainApi>>>>`;
+        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult<ChainApi>>>>`;
     }
 }
 exports.ConstructorQueryGen = ConstructorQueryGen;

package/cjs/typink/generator/ConstructorTxGen.js

@@ -14,11 +14,9 @@ class ConstructorTxGen extends QueryGen_js_1.QueryGen {
         const template = (0, utils_js_1.compileTemplate)('typink/templates/constructor-tx.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, constructorsOut }));
     }
-    generateMethodDef(def) {
-        const { args } = def;
-        args.forEach(({ type: { type } }) => this.importType(type));
-        const paramsOut = this.generateParamsOut(args);
-        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi>>`;
+    generateMethodDef(def, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(def.args);
+        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi>>`;
     }
 }
 exports.ConstructorTxGen = ConstructorTxGen;

package/cjs/typink/generator/EventsGen.js

@@ -23,7 +23,6 @@ class EventsGen extends QueryGen_js_1.QueryGen {
     }
     #generateEventDef(event) {
         const { args, label } = event;
-        args.forEach(({ type: { type } }) => this.importType(type));
         const paramsOut = this.generateParamsOut(args);
         return `GenericContractEvent<'${(0, utils_1.stringPascalCase)(label)}', {${paramsOut}}>`;
     }

package/cjs/typink/generator/IndexGen.js

@@ -21,9 +21,17 @@ class IndexGen {
         typeImports.addContractType('GenericContractApi');
         typeImports.addChainType('SubstrateApi');
         typeImports.addPortableType(langErrorName);
+        const { contract: { name = '', version = '', authors = [] }, source: { language = '' }, } = this.contractMetadata;
+        const interfaceDocs = (0, utils_js_1.commentBlock)([
+            `@name: ${interfaceName}`, // prettier-end-here
+            `@contractName: ${name}`,
+            `@contractVersion: ${version}`,
+            `@authors: ${authors.join(', ')}`,
+            `@language: ${language}`,
+        ]);
         const importTypes = typeImports.toImports({ useSubPaths });
         const template = (0, utils_js_1.compileTemplate)('typink/templates/index.hbs');
-        return (0, utils_js_1.beautifySourceCode)(template({ interfaceName, langErrorName, importTypes }));
+        return (0, utils_js_1.beautifySourceCode)(template({ interfaceName, interfaceDocs, langErrorName, importTypes }));
     }
 }
 exports.IndexGen = IndexGen;

package/cjs/typink/generator/QueryGen.js

@@ -25,50 +25,27 @@ class QueryGen {
         let callsOut = '';
         messages.forEach((messageDef) => {
             const { label, docs, selector, args } = messageDef;
-            callsOut += `${(0, utils_js_1.commentBlock)(docs, '\n', args.map((arg) => `@param {${this.typesGen.generateType(arg.type.type, 1)}} ${(0, utils_1.stringCamelCase)(arg.label)}`), optionsTypeName ? `@param {${optionsTypeName}} options` : '', '\n', `@selector ${selector}`)}`;
-            callsOut += `${(0, contracts_1.normalizeLabel)(label)}: ${this.generateMethodDef(messageDef)};\n\n`;
+            // In case there is an arg has label `options`,
+            // we use the name `_options` for the last options param
+            // This is just and edge case, so this approach works for now
+            const optionsParamName = args.some(({ label }) => label === 'options') ? '_options' : 'options';
+            callsOut += `${(0, utils_js_1.commentBlock)(docs, '\n', args.map((arg) => `@param {${this.typesGen.generateType(arg.type.type, 1)}} ${(0, utils_1.stringCamelCase)(arg.label)}`), optionsTypeName ? `@param {${optionsTypeName}} ${optionsParamName}` : '', '\n', `@selector ${selector}`)}`;
+            callsOut += `${(0, contracts_1.normalizeLabel)(label)}: ${this.generateMethodDef(messageDef, optionsParamName)};\n\n`;
         });
         return callsOut;
     }
-    generateMethodDef(def) {
+    generateMethodDef(def, optionsParamName = 'options') {
         const { args, returnType } = def;
-        this.importType(returnType.type);
-        args.forEach(({ type: { type } }) => this.importType(type));
         const paramsOut = this.generateParamsOut(args);
         const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
         // Unwrap langError result
         const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
-        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>>`;
+        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>>`;
     }
     generateParamsOut(args) {
         return args
             .map(({ type: { type }, label }) => `${(0, utils_1.stringCamelCase)(label)}: ${this.typesGen.generateType(type, 1)}`)
             .join(', ');
     }
-    importType(typeId) {
-        const contractType = this.contractMetadata.types[typeId];
-        const typeDef = (0, contracts_1.normalizeContractTypeDef)(this.contractMetadata.types[typeId].type.def);
-        if (this.typesGen.includedTypes[contractType.id]) {
-            this.typesGen.addTypeImport(this.typesGen.includedTypes[contractType.id].name);
-            return;
-        }
-        const { type, value } = typeDef;
-        switch (type) {
-            case 'Compact':
-            case 'Primitive':
-            case 'BitSequence':
-                return;
-            case 'Struct':
-                return value.fields.forEach(({ typeId }) => this.importType(typeId));
-            case 'Enum':
-                return value.members.forEach(({ fields }) => fields.map(({ typeId }) => this.importType(typeId)).flat());
-            case 'Tuple':
-                return value.fields.forEach((typeId) => this.importType(typeId));
-            case 'SizedVec':
-                return this.importType(value.typeParam);
-            case 'Sequence':
-                return this.importType(value.typeParam);
-        }
-    }
 }
 exports.QueryGen = QueryGen;

package/cjs/typink/generator/TxGen.js

@@ -15,11 +15,9 @@ class TxGen extends QueryGen_js_1.QueryGen {
         const template = (0, utils_js_1.compileTemplate)('typink/templates/tx.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, txCallsOut }));
     }
-    generateMethodDef(def) {
-        const { args } = def;
-        args.forEach(({ type: { type } }) => this.importType(type));
-        const paramsOut = this.generateParamsOut(args);
-        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>>`;
+    generateMethodDef(def, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(def.args);
+        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>>`;
     }
 }
 exports.TxGen = TxGen;

package/cjs/typink/generator/TypesGen.js

@@ -8,21 +8,91 @@ const SKIP_TYPES = ['Result', 'Option'];
 class TypesGen extends index_js_1.BaseTypesGen {
     contractMetadata;
     constructor(contractMetadata) {
-        super((0, contracts_1.extractContractTypes)(contractMetadata));
+        super((0, contracts_1.extractContractTypes)(contractMetadata), SKIP_TYPES);
         this.contractMetadata = contractMetadata;
-        this.skipTypes = SKIP_TYPES;
-        this.includedTypes = this.includeTypes();
+        this.includedTypes = this.calculateIncludedTypes();
     }
     generate(useSubPaths = false) {
         let defTypeOut = '';
         Object.values(this.includedTypes)
             .filter(({ skip, knownType }) => !(skip || knownType))
-            .forEach(({ nameOut, id }) => {
+            .forEach(({ nameOut, name, id }) => {
             defTypeOut += `export type ${nameOut} = ${this.generateType(id, 0, true)};\n\n`;
+            if (this.shouldGenerateTypeIn(id)) {
+                defTypeOut += `export type ${name} = ${this.generateType(id, 0)};\n\n`;
+            }
         });
         const importTypes = this.typeImports.toImports({ excludeModules: ['./types'], useSubPaths });
         const template = (0, utils_js_1.compileTemplate)('typink/templates/types.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
+    shouldGenerateTypeIn(id) {
+        const { messages, constructors } = this.contractMetadata.spec;
+        return ((this.#idInParameters(id, messages) || this.#idInParameters(id, constructors)) && this.#includeKnownTypes(id));
+    }
+    #idInParameters(id, messages) {
+        for (let message of messages) {
+            // prettier-ignore
+            const isIn = message.args.reduce((a, { type: { type: typeId } }) => a || this.#typeDependOn(typeId, id), false);
+            if (isIn)
+                return true;
+        }
+        return false;
+    }
+    // Find out does type depends on known types
+    // Example: `type TypeA = Struct { field: AccountId }` => includeKnownTypes(TypeA) === true
+    #includeKnownTypes(typeId) {
+        if (this.knownTypes[typeId])
+            return true;
+        const { types } = this.contractMetadata;
+        const defA = (0, contracts_1.normalizeContractTypeDef)(types[typeId].type.def);
+        const { type, value } = defA;
+        switch (type) {
+            case 'Struct':
+                return value.fields.some(({ typeId }) => this.#includeKnownTypes(typeId));
+            case 'Enum':
+                return value.members.some(({ fields }) => fields.some(({ typeId }) => this.#includeKnownTypes(typeId)));
+            case 'Tuple':
+                return value.fields.some((typeId) => this.#includeKnownTypes(typeId));
+            case 'Sequence':
+            case 'SizedVec':
+                const $innerType = this.types[value.typeParam].typeDef;
+                if ($innerType.type === 'Primitive' && $innerType.value.kind === 'u8') {
+                    return true; // ByteLikes
+                }
+                else {
+                    return this.#includeKnownTypes(value.typeParam);
+                }
+            case 'Primitive':
+            case 'Compact':
+            case 'BitSequence':
+                return false;
+        }
+    }
+    // Find out does typeA depends on typeB
+    // Example: `type TypeA = Struct { field: TypeB }` => typeDependOn(TypeA, TypeB) === true
+    #typeDependOn(typeA, typeB) {
+        if (typeA === typeB)
+            return true;
+        const { types } = this.contractMetadata;
+        const defA = (0, contracts_1.normalizeContractTypeDef)(types[typeA].type.def);
+        const { type, value } = defA;
+        // prettier-ignore
+        switch (type) {
+            case 'Struct':
+                return value.fields.reduce((a, { typeId }) => a || this.#typeDependOn(typeId, typeB), false);
+            case 'Enum':
+                return value.members.reduce((a, { fields }) => a || fields.reduce((a, { typeId }) => a || this.#typeDependOn(typeId, typeB), false), false);
+            case 'Tuple':
+                return value.fields.reduce((a, typeId) => a || this.#typeDependOn(typeId, typeB), false);
+            case 'Sequence':
+            case 'SizedVec':
+                return this.#typeDependOn(value.typeParam, typeB);
+            case 'Primitive':
+            case 'Compact':
+            case 'BitSequence':
+                return false;
+        }
+    }
 }
 exports.TypesGen = TypesGen;

package/cjs/typink/index.js

@@ -38,6 +38,6 @@ async function generateContractTypes(metadata, contract, outDir = '.', extension
     fs_1.default.writeFileSync(constructorTxTypesFileName, await constructorTxGen.generate(useSubPaths));
     fs_1.default.writeFileSync(eventsTypesFile, await eventsGen.generate(useSubPaths));
     fs_1.default.writeFileSync(indexTypesFileName, await indexGen.generate(useSubPaths));
-    return { interfaceName };
+    return { interfaceName, outputFolder: dirPath };
 }
 exports.generateContractTypes = generateContractTypes;

package/cjs/typink/templates/index.hbs

@@ -9,7 +9,7 @@ import { ContractEvents } from './events';
 
 export * from './types';
 
-export interface {{{interfaceName}}}<Rv extends RpcVersion = RpcV2, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi> {
+{{{interfaceDocs}}}export interface {{{interfaceName}}}<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi> {
     query: ContractQuery<ChainApi[Rv]>;
     tx: ContractTx<ChainApi[Rv]>;
     constructorQuery: ConstructorQuery<ChainApi[Rv]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/codegen",
@@ -18,14 +18,14 @@
     "copy": "cp -R ./src/chaintypes/templates ./dist/chaintypes && cp -R ./src/chaintypes/templates ./dist/cjs/chaintypes && cp -R ./src/typink/templates ./dist/typink && cp -R ./src/typink/templates ./dist/cjs/typink"
   },
   "dependencies": {
-    "@dedot/api": "0.4.1",
-    "@dedot/codecs": "0.4.1",
-    "@dedot/contracts": "0.4.1",
-    "@dedot/providers": "0.4.1",
-    "@dedot/runtime-specs": "0.4.1",
-    "@dedot/shape": "0.4.1",
-    "@dedot/types": "0.4.1",
-    "@dedot/utils": "0.4.1",
+    "@dedot/api": "0.5.0",
+    "@dedot/codecs": "0.5.0",
+    "@dedot/contracts": "0.5.0",
+    "@dedot/providers": "0.5.0",
+    "@dedot/runtime-specs": "0.5.0",
+    "@dedot/shape": "0.5.0",
+    "@dedot/types": "0.5.0",
+    "@dedot/utils": "0.5.0",
     "handlebars": "^4.7.8",
     "prettier": "^3.3.3"
   },
@@ -34,7 +34,7 @@
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "05b2a88dd2c78b17d68f0dd211e50be79e79852e",
+  "gitHead": "968148ade63e07644094fc033be719b320e18a18",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/shared/BaseTypesGen.d.ts

@@ -15,11 +15,13 @@ export declare abstract class BaseTypesGen {
     includedTypes: Record<TypeId, NamedType>;
     typeImports: TypeImports;
     skipTypes: string[];
-    protected constructor(types: PortableType[]);
+    knownTypes: Record<TypeId, string>;
+    protected constructor(types: PortableType[], skipTypes?: string[]);
     shouldGenerateTypeIn(_id: TypeId): boolean;
     typeCache: Record<string, string>;
     clearCache(): void;
-    includeTypes(): Record<TypeId, NamedType>;
+    protected calculateKnownTypes(): Record<TypeId, string>;
+    protected calculateIncludedTypes(): Record<TypeId, NamedType>;
     generateType(typeId: TypeId, nestedLevel?: number, typeOut?: boolean): string;
     generateObjectType(fields: Field[], nestedLevel?: number, typeOut?: boolean): string;
     cleanPath(path: string[]): string;

package/shared/BaseTypesGen.js

@@ -11,11 +11,13 @@ export class BaseTypesGen {
     includedTypes;
     typeImports;
     skipTypes;
-    constructor(types) {
+    knownTypes;
+    constructor(types, skipTypes = []) {
         this.types = types;
-        this.includedTypes = {};
+        this.skipTypes = skipTypes;
         this.typeImports = new TypeImports();
-        this.skipTypes = [];
+        this.knownTypes = this.calculateKnownTypes();
+        this.includedTypes = {};
     }
     shouldGenerateTypeIn(_id) {
         return false;
@@ -25,7 +27,17 @@ export class BaseTypesGen {
         this.typeCache = {};
         this.typeImports.clear();
     }
-    includeTypes() {
+    calculateKnownTypes() {
+        const typesWithPath = this.types.filter((one) => one.path.length > 0);
+        return typesWithPath.reduce((o, type) => {
+            const { path, id } = type;
+            const [knownType, codecName] = checkKnownCodecType(path.join('::'));
+            if (!knownType)
+                return o;
+            return { ...o, [id]: codecName };
+        }, {});
+    }
+    calculateIncludedTypes() {
         const pathsCount = new Map();
         const typesWithPath = this.types.filter((one) => one.path.length > 0);
         const skipIds = [];
@@ -57,14 +69,13 @@ export class BaseTypesGen {
                 return o;
             }
             const suffix = typeSuffixes.get(id) || '';
-            let knownType = false;
             let name, nameOut;
-            const [isKnownCodecType, codecName] = checkKnownCodecType(joinedPath);
-            if (isKnownCodecType) {
-                const codecType = findKnownCodecType(codecName);
+            const knownCodecName = this.knownTypes[id];
+            const knownType = !!knownCodecName;
+            if (knownType) {
+                const codecType = findKnownCodecType(knownCodecName);
                 name = codecType.typeIn;
                 nameOut = codecType.typeOut;
-                knownType = true;
             }
             else if (PATH_RM_INDEX_1.includes(path[1])) {
                 const newPath = path.slice();
@@ -74,7 +85,7 @@ export class BaseTypesGen {
             else {
                 name = this.cleanPath(path);
             }
-            if (this.shouldGenerateTypeIn(id)) {
+            if (!knownType && this.shouldGenerateTypeIn(id)) {
                 nameOut = name;
                 name = name.endsWith('Like') ? name : `${name}Like`;
             }

package/types.d.ts

@@ -1,3 +1,4 @@
 export interface GeneratedResult {
     interfaceName: string;
+    outputFolder: string;
 }

package/typink/generator/ConstructorQueryGen.d.ts

@@ -2,5 +2,5 @@ import { ContractConstructorMessage } from '@dedot/contracts';
 import { QueryGen } from './QueryGen.js';
 export declare class ConstructorQueryGen extends QueryGen {
     generate(useSubPaths?: boolean): Promise<string>;
-    generateMethodDef(def: ContractConstructorMessage): string;
+    generateMethodDef(def: ContractConstructorMessage, optionsParamName?: string): string;
 }

package/typink/generator/ConstructorQueryGen.js

@@ -11,13 +11,12 @@ export class ConstructorQueryGen extends QueryGen {
         const template = compileTemplate('typink/templates/constructor-query.hbs');
         return beautifySourceCode(template({ importTypes, constructorsOut }));
     }
-    generateMethodDef(def) {
+    generateMethodDef(def, optionsParamName = 'options') {
         const { args, returnType } = def;
-        args.forEach(({ type: { type } }) => this.importType(type));
         const paramsOut = this.generateParamsOut(args);
         const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
         // Unwrap langError result
         const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
-        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult<ChainApi>>>>`;
+        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult<ChainApi>>>>`;
     }
 }

package/typink/generator/ConstructorTxGen.d.ts

@@ -2,5 +2,5 @@ import { ContractConstructorMessage } from '@dedot/contracts';
 import { QueryGen } from './QueryGen.js';
 export declare class ConstructorTxGen extends QueryGen {
     generate(useSubPaths?: boolean): Promise<string>;
-    generateMethodDef(def: ContractConstructorMessage): string;
+    generateMethodDef(def: ContractConstructorMessage, optionsParamName?: string): string;
 }

package/typink/generator/ConstructorTxGen.js

@@ -11,10 +11,8 @@ export class ConstructorTxGen extends QueryGen {
         const template = compileTemplate('typink/templates/constructor-tx.hbs');
         return beautifySourceCode(template({ importTypes, constructorsOut }));
     }
-    generateMethodDef(def) {
-        const { args } = def;
-        args.forEach(({ type: { type } }) => this.importType(type));
-        const paramsOut = this.generateParamsOut(args);
-        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi>>`;
+    generateMethodDef(def, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(def.args);
+        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi>>`;
     }
 }

package/typink/generator/EventsGen.js

@@ -20,7 +20,6 @@ export class EventsGen extends QueryGen {
     }
     #generateEventDef(event) {
         const { args, label } = event;
-        args.forEach(({ type: { type } }) => this.importType(type));
         const paramsOut = this.generateParamsOut(args);
         return `GenericContractEvent<'${stringPascalCase(label)}', {${paramsOut}}>`;
     }

package/typink/generator/IndexGen.js

@@ -1,5 +1,5 @@
 import { TypeImports } from '../../shared/index.js';
-import { beautifySourceCode, compileTemplate } from '../../utils.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
 export class IndexGen {
     interfaceName;
     contractMetadata;
@@ -18,8 +18,16 @@ export class IndexGen {
         typeImports.addContractType('GenericContractApi');
         typeImports.addChainType('SubstrateApi');
         typeImports.addPortableType(langErrorName);
+        const { contract: { name = '', version = '', authors = [] }, source: { language = '' }, } = this.contractMetadata;
+        const interfaceDocs = commentBlock([
+            `@name: ${interfaceName}`, // prettier-end-here
+            `@contractName: ${name}`,
+            `@contractVersion: ${version}`,
+            `@authors: ${authors.join(', ')}`,
+            `@language: ${language}`,
+        ]);
         const importTypes = typeImports.toImports({ useSubPaths });
         const template = compileTemplate('typink/templates/index.hbs');
-        return beautifySourceCode(template({ interfaceName, langErrorName, importTypes }));
+        return beautifySourceCode(template({ interfaceName, interfaceDocs, langErrorName, importTypes }));
     }
 }

package/typink/generator/QueryGen.d.ts

@@ -6,7 +6,6 @@ export declare class QueryGen {
     constructor(contractMetadata: ContractMetadata, typeGen: TypesGen);
     generate(useSubPaths?: boolean): Promise<string>;
     doGenerate(messages: ContractMessage[], optionsTypeName?: string): string;
-    generateMethodDef(def: ContractMessage): string;
+    generateMethodDef(def: ContractMessage, optionsParamName?: string): string;
     generateParamsOut(args: ContractMessageArg[]): string;
-    importType(typeId: number): any;
 }

package/typink/generator/QueryGen.js

@@ -1,4 +1,4 @@
-import { normalizeContractTypeDef, normalizeLabel, } from '@dedot/contracts';
+import { normalizeLabel } from '@dedot/contracts';
 import { stringCamelCase } from '@dedot/utils';
 import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
 export class QueryGen {
@@ -22,49 +22,26 @@ export class QueryGen {
         let callsOut = '';
         messages.forEach((messageDef) => {
             const { label, docs, selector, args } = messageDef;
-            callsOut += `${commentBlock(docs, '\n', args.map((arg) => `@param {${this.typesGen.generateType(arg.type.type, 1)}} ${stringCamelCase(arg.label)}`), optionsTypeName ? `@param {${optionsTypeName}} options` : '', '\n', `@selector ${selector}`)}`;
-            callsOut += `${normalizeLabel(label)}: ${this.generateMethodDef(messageDef)};\n\n`;
+            // In case there is an arg has label `options`,
+            // we use the name `_options` for the last options param
+            // This is just and edge case, so this approach works for now
+            const optionsParamName = args.some(({ label }) => label === 'options') ? '_options' : 'options';
+            callsOut += `${commentBlock(docs, '\n', args.map((arg) => `@param {${this.typesGen.generateType(arg.type.type, 1)}} ${stringCamelCase(arg.label)}`), optionsTypeName ? `@param {${optionsTypeName}} ${optionsParamName}` : '', '\n', `@selector ${selector}`)}`;
+            callsOut += `${normalizeLabel(label)}: ${this.generateMethodDef(messageDef, optionsParamName)};\n\n`;
         });
         return callsOut;
     }
-    generateMethodDef(def) {
+    generateMethodDef(def, optionsParamName = 'options') {
         const { args, returnType } = def;
-        this.importType(returnType.type);
-        args.forEach(({ type: { type } }) => this.importType(type));
         const paramsOut = this.generateParamsOut(args);
         const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
         // Unwrap langError result
         const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
-        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>>`;
+        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>>`;
     }
     generateParamsOut(args) {
         return args
             .map(({ type: { type }, label }) => `${stringCamelCase(label)}: ${this.typesGen.generateType(type, 1)}`)
             .join(', ');
     }
-    importType(typeId) {
-        const contractType = this.contractMetadata.types[typeId];
-        const typeDef = normalizeContractTypeDef(this.contractMetadata.types[typeId].type.def);
-        if (this.typesGen.includedTypes[contractType.id]) {
-            this.typesGen.addTypeImport(this.typesGen.includedTypes[contractType.id].name);
-            return;
-        }
-        const { type, value } = typeDef;
-        switch (type) {
-            case 'Compact':
-            case 'Primitive':
-            case 'BitSequence':
-                return;
-            case 'Struct':
-                return value.fields.forEach(({ typeId }) => this.importType(typeId));
-            case 'Enum':
-                return value.members.forEach(({ fields }) => fields.map(({ typeId }) => this.importType(typeId)).flat());
-            case 'Tuple':
-                return value.fields.forEach((typeId) => this.importType(typeId));
-            case 'SizedVec':
-                return this.importType(value.typeParam);
-            case 'Sequence':
-                return this.importType(value.typeParam);
-        }
-    }
 }

package/typink/generator/TxGen.d.ts

@@ -2,5 +2,5 @@ import { ContractMessage } from '@dedot/contracts';
 import { QueryGen } from './QueryGen.js';
 export declare class TxGen extends QueryGen {
     generate(useSubPaths?: boolean): Promise<string>;
-    generateMethodDef(def: ContractMessage): string;
+    generateMethodDef(def: ContractMessage, optionsParamName?: string): string;
 }

package/typink/generator/TxGen.js

@@ -12,10 +12,8 @@ export class TxGen extends QueryGen {
         const template = compileTemplate('typink/templates/tx.hbs');
         return beautifySourceCode(template({ importTypes, txCallsOut }));
     }
-    generateMethodDef(def) {
-        const { args } = def;
-        args.forEach(({ type: { type } }) => this.importType(type));
-        const paramsOut = this.generateParamsOut(args);
-        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>>`;
+    generateMethodDef(def, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(def.args);
+        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>>`;
     }
 }

package/typink/generator/TypesGen.d.ts

@@ -1,7 +1,10 @@
+import { TypeId } from '@dedot/codecs';
 import { ContractMetadata } from '@dedot/contracts';
 import { BaseTypesGen } from '../../shared/index.js';
 export declare class TypesGen extends BaseTypesGen {
+    #private;
     contractMetadata: ContractMetadata;
     constructor(contractMetadata: ContractMetadata);
     generate(useSubPaths?: boolean): Promise<string>;
+    shouldGenerateTypeIn(id: TypeId): boolean;
 }

package/typink/generator/TypesGen.js

@@ -1,24 +1,94 @@
-import { extractContractTypes } from '@dedot/contracts';
+import { extractContractTypes, normalizeContractTypeDef } from '@dedot/contracts';
 import { BaseTypesGen } from '../../shared/index.js';
 import { beautifySourceCode, compileTemplate } from '../../utils.js';
 const SKIP_TYPES = ['Result', 'Option'];
 export class TypesGen extends BaseTypesGen {
     contractMetadata;
     constructor(contractMetadata) {
-        super(extractContractTypes(contractMetadata));
+        super(extractContractTypes(contractMetadata), SKIP_TYPES);
         this.contractMetadata = contractMetadata;
-        this.skipTypes = SKIP_TYPES;
-        this.includedTypes = this.includeTypes();
+        this.includedTypes = this.calculateIncludedTypes();
     }
     generate(useSubPaths = false) {
         let defTypeOut = '';
         Object.values(this.includedTypes)
             .filter(({ skip, knownType }) => !(skip || knownType))
-            .forEach(({ nameOut, id }) => {
+            .forEach(({ nameOut, name, id }) => {
             defTypeOut += `export type ${nameOut} = ${this.generateType(id, 0, true)};\n\n`;
+            if (this.shouldGenerateTypeIn(id)) {
+                defTypeOut += `export type ${name} = ${this.generateType(id, 0)};\n\n`;
+            }
         });
         const importTypes = this.typeImports.toImports({ excludeModules: ['./types'], useSubPaths });
         const template = compileTemplate('typink/templates/types.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
+    shouldGenerateTypeIn(id) {
+        const { messages, constructors } = this.contractMetadata.spec;
+        return ((this.#idInParameters(id, messages) || this.#idInParameters(id, constructors)) && this.#includeKnownTypes(id));
+    }
+    #idInParameters(id, messages) {
+        for (let message of messages) {
+            // prettier-ignore
+            const isIn = message.args.reduce((a, { type: { type: typeId } }) => a || this.#typeDependOn(typeId, id), false);
+            if (isIn)
+                return true;
+        }
+        return false;
+    }
+    // Find out does type depends on known types
+    // Example: `type TypeA = Struct { field: AccountId }` => includeKnownTypes(TypeA) === true
+    #includeKnownTypes(typeId) {
+        if (this.knownTypes[typeId])
+            return true;
+        const { types } = this.contractMetadata;
+        const defA = normalizeContractTypeDef(types[typeId].type.def);
+        const { type, value } = defA;
+        switch (type) {
+            case 'Struct':
+                return value.fields.some(({ typeId }) => this.#includeKnownTypes(typeId));
+            case 'Enum':
+                return value.members.some(({ fields }) => fields.some(({ typeId }) => this.#includeKnownTypes(typeId)));
+            case 'Tuple':
+                return value.fields.some((typeId) => this.#includeKnownTypes(typeId));
+            case 'Sequence':
+            case 'SizedVec':
+                const $innerType = this.types[value.typeParam].typeDef;
+                if ($innerType.type === 'Primitive' && $innerType.value.kind === 'u8') {
+                    return true; // ByteLikes
+                }
+                else {
+                    return this.#includeKnownTypes(value.typeParam);
+                }
+            case 'Primitive':
+            case 'Compact':
+            case 'BitSequence':
+                return false;
+        }
+    }
+    // Find out does typeA depends on typeB
+    // Example: `type TypeA = Struct { field: TypeB }` => typeDependOn(TypeA, TypeB) === true
+    #typeDependOn(typeA, typeB) {
+        if (typeA === typeB)
+            return true;
+        const { types } = this.contractMetadata;
+        const defA = normalizeContractTypeDef(types[typeA].type.def);
+        const { type, value } = defA;
+        // prettier-ignore
+        switch (type) {
+            case 'Struct':
+                return value.fields.reduce((a, { typeId }) => a || this.#typeDependOn(typeId, typeB), false);
+            case 'Enum':
+                return value.members.reduce((a, { fields }) => a || fields.reduce((a, { typeId }) => a || this.#typeDependOn(typeId, typeB), false), false);
+            case 'Tuple':
+                return value.fields.reduce((a, typeId) => a || this.#typeDependOn(typeId, typeB), false);
+            case 'Sequence':
+            case 'SizedVec':
+                return this.#typeDependOn(value.typeParam, typeB);
+            case 'Primitive':
+            case 'Compact':
+            case 'BitSequence':
+                return false;
+        }
+    }
 }

package/typink/index.js

@@ -32,5 +32,5 @@ export async function generateContractTypes(metadata, contract, outDir = '.', ex
     fs.writeFileSync(constructorTxTypesFileName, await constructorTxGen.generate(useSubPaths));
     fs.writeFileSync(eventsTypesFile, await eventsGen.generate(useSubPaths));
     fs.writeFileSync(indexTypesFileName, await indexGen.generate(useSubPaths));
-    return { interfaceName };
+    return { interfaceName, outputFolder: dirPath };
 }

package/typink/templates/index.hbs

@@ -9,7 +9,7 @@ import { ContractEvents } from './events';
 
 export * from './types';
 
-export interface {{{interfaceName}}}<Rv extends RpcVersion = RpcV2, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi> {
+{{{interfaceDocs}}}export interface {{{interfaceName}}}<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi> {
     query: ContractQuery<ChainApi[Rv]>;
     tx: ContractTx<ChainApi[Rv]>;
     constructorQuery: ConstructorQuery<ChainApi[Rv]>;