@dedot/codegen 0.17.0 → 0.17.1-next.db98ff20.1

package/cjs/typink/generator/IndexGen.js

@@ -19,7 +19,7 @@ class IndexGen {
         const langErrorName = this.typesGen.cleanPath(this.contractMetadata.types[langErrorId].type.path);
         const typeImports = new index_js_1.TypeImports();
         typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
-        typeImports.addContractType('GenericContractApi', 'WithLazyStorage');
+        typeImports.addContractType('InkGenericContractApi', 'WithLazyStorage');
         typeImports.addChainType('SubstrateApi');
         typeImports.addPortableType(langErrorName);
         const [rootStorageName, lazyStorageName] = this.#extractRootStorageNames(typeImports);

package/cjs/typink/generator/QueryGen.js

@@ -14,7 +14,7 @@ class QueryGen {
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
         this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
-        this.typesGen.typeImports.addContractType('GenericContractQuery', 'GenericContractQueryCall', 'ContractCallOptions', 'GenericContractCallResult', 'ContractCallResult');
+        this.typesGen.typeImports.addContractType('GenericContractQuery', 'GenericContractQueryCall', 'ContractCallOptions', 'GenericContractCallResult', 'ContractCallResult', 'MetadataType');
         const { messages } = this.contractMetadata.spec;
         const queryCallsOut = this.doGenerate(messages, 'ContractCallOptions');
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
@@ -40,7 +40,7 @@ class QueryGen {
         const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
         // Unwrap langError result
         const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
-        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>>`;
+        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>, Type>`;
     }
     generateParamsOut(args) {
         return args

package/cjs/typink/generator/TxGen.js

@@ -7,7 +7,7 @@ class TxGen extends QueryGen_js_1.QueryGen {
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
         this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
-        this.typesGen.typeImports.addContractType('GenericContractTx', 'GenericContractTxCall', 'ContractTxOptions', 'ContractSubmittableExtrinsic');
+        this.typesGen.typeImports.addContractType('GenericContractTx', 'GenericContractTxCall', 'ContractTxOptions', 'ContractSubmittableExtrinsic', 'MetadataType');
         const { messages } = this.contractMetadata.spec;
         const txMessages = messages.filter((one) => one.mutates);
         const txCallsOut = this.doGenerate(txMessages, 'ContractTxOptions');
@@ -17,7 +17,7 @@ class TxGen extends QueryGen_js_1.QueryGen {
     }
     generateMethodDef(def, optionsParamName = 'options') {
         const paramsOut = this.generateParamsOut(def.args);
-        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>>`;
+        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>, Type>`;
     }
 }
 exports.TxGen = TxGen;

package/cjs/typink/templates/constructor-query.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ConstructorQuery<ChainApi extends GenericSubstrateApi> extends GenericConstructorQuery<ChainApi> {
+export interface ConstructorQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericConstructorQuery<ChainApi, Type> {  
     {{{ constructorsOut }}}
 }

package/cjs/typink/templates/constructor-tx.hbs

@@ -4,7 +4,8 @@
 
 export interface ConstructorTx<
   ChainApi extends GenericSubstrateApi,
-  ContractApi extends GenericContractApi = GenericContractApi,
-> extends GenericConstructorTx<ChainApi> {
+  ContractApi extends InkGenericContractApi,
+  Type extends MetadataType
+> extends GenericConstructorTx<ChainApi, Type> {
     {{{ constructorsOut }}}
 }

package/cjs/typink/templates/events.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractEvents<ChainApi extends GenericSubstrateApi> extends GenericContractEvents<ChainApi> {
+export interface ContractEvents <ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractEvents <ChainApi, Type> {
     {{{ eventsOut }}}
 }

package/cjs/typink/templates/index.hbs

@@ -9,21 +9,22 @@ import { ContractEvents } from './events.js';
 
 export * from './types.js';
 
-{{{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]>;
-    constructorTx: ConstructorTx<ChainApi[Rv], {{{interfaceName}}}>;
-    events: ContractEvents<ChainApi[Rv]>;
+{{{interfaceDocs}}}export interface {{{interfaceName}}}<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends InkGenericContractApi<Rv, ChainApi> {
+    metadataType: 'ink';
+    query: ContractQuery<ChainApi[Rv], 'ink'>;
+    tx: ContractTx<ChainApi[Rv], 'ink'>;
+    constructorQuery: ConstructorQuery<ChainApi[Rv], 'ink'>;
+    constructorTx: ConstructorTx<ChainApi[Rv], {{{interfaceName}}}, 'ink'>;
+    events: ContractEvents<ChainApi[Rv], 'ink'>;
     storage: {
       root(): Promise<{{{rootStorageName}}}>;
       lazy(): {{{lazyStorageName}}};
     };
 
     types: {
+      ChainApi: ChainApi[Rv];
       RootStorage: {{{rootStorageName}}};
       LazyStorage: {{{lazyStorageName}}};
       LangError: {{{langErrorName}}};
-      ChainApi: ChainApi[Rv];
     };
 }

package/cjs/typink/templates/query.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractQuery<ChainApi extends GenericSubstrateApi> extends GenericContractQuery<ChainApi> {
+export interface ContractQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractQuery<ChainApi, Type> {
     {{{ queryCallsOut }}}
 }

package/cjs/typink/templates/tx.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractTx<ChainApi extends GenericSubstrateApi> extends GenericContractTx<ChainApi> {
+export interface ContractTx<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractTx<ChainApi, Type> {
     {{{ txCallsOut }}}
 }

package/index.d.ts

@@ -1,3 +1,4 @@
 export * from './types.js';
 export * from './chaintypes/index.js';
 export * from './typink/index.js';
+export * from './sol/index.js';

package/index.js

@@ -1,3 +1,4 @@
 export * from './types.js';
 export * from './chaintypes/index.js';
 export * from './typink/index.js';
+export * from './sol/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.17.0",
+  "version": "0.17.1-next.db98ff20.1+db98ff20",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@dedot.dev>",
   "homepage": "https://dedot.dev",
@@ -14,18 +14,19 @@
   "type": "module",
   "scripts": {
     "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json && yarn copy",
+    "test": "npx vitest --watch=false",
     "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo",
-    "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"
+    "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 && cp -R ./src/sol/templates ./dist/sol && cp -R ./src/sol/templates ./dist/cjs/sol"
   },
   "dependencies": {
-    "@dedot/api": "0.17.0",
-    "@dedot/codecs": "0.17.0",
-    "@dedot/contracts": "0.17.0",
-    "@dedot/providers": "0.17.0",
-    "@dedot/runtime-specs": "0.17.0",
-    "@dedot/shape": "0.17.0",
-    "@dedot/types": "0.17.0",
-    "@dedot/utils": "0.17.0",
+    "@dedot/api": "0.17.1-next.db98ff20.1+db98ff20",
+    "@dedot/codecs": "0.17.1-next.db98ff20.1+db98ff20",
+    "@dedot/contracts": "0.17.1-next.db98ff20.1+db98ff20",
+    "@dedot/providers": "0.17.1-next.db98ff20.1+db98ff20",
+    "@dedot/runtime-specs": "0.17.1-next.db98ff20.1+db98ff20",
+    "@dedot/shape": "0.17.1-next.db98ff20.1+db98ff20",
+    "@dedot/types": "0.17.1-next.db98ff20.1+db98ff20",
+    "@dedot/utils": "0.17.1-next.db98ff20.1+db98ff20",
     "handlebars": "^4.7.8",
     "prettier": "^3.6.2"
   },
@@ -37,7 +38,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "77e751248ad7bca0cb374e17e65afef791fb3e4d",
+  "gitHead": "db98ff20684d2a74b5e5402cabf43ef601d05d31",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/sol/generator/ConstructorQueryGen.d.ts

@@ -0,0 +1,12 @@
+import { TypesGen } from '@dedot/codegen/sol/generator/TypesGen';
+import { SolAbi, SolAbiConstructor } from '@dedot/contracts';
+export declare class ConstructorQueryGen {
+    readonly abi: SolAbi;
+    readonly typesGen: TypesGen;
+    constructor(abi: SolAbi, typesGen: TypesGen);
+    generate(useSubPaths?: boolean): Promise<string>;
+    doGenerateConstructorFragment(abiItem: SolAbiConstructor, optionsTypeName?: string): string;
+    generateMethodDef(abiItem: SolAbiConstructor, optionsParamName?: string): string;
+    generateParamsOut(abiItem: SolAbiConstructor): string;
+    protected findConstructor(): SolAbiConstructor;
+}

package/sol/generator/ConstructorQueryGen.js

@@ -0,0 +1,51 @@
+import { stringCamelCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+export class ConstructorQueryGen {
+    abi;
+    typesGen;
+    constructor(abi, typesGen) {
+        this.abi = abi;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericConstructorQuery', 'GenericConstructorQueryCall', 'GenericConstructorCallResult', 'ConstructorCallOptions', 'ContractInstantiateResult', 'MetadataType');
+        let constructor = this.findConstructor();
+        const constructorsOut = this.doGenerateConstructorFragment(constructor, 'ConstructorCallOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/constructor-query.hbs');
+        return beautifySourceCode(template({ importTypes, constructorsOut }));
+    }
+    doGenerateConstructorFragment(abiItem, optionsTypeName) {
+        let callsOut = '';
+        const { inputs = [] } = abiItem;
+        // 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 = inputs.some(({ name }) => name === 'options') ? '_options' : 'options';
+        callsOut += `${commentBlock(inputs.map((input, idx) => `@param {${this.typesGen.generateType(input, abiItem, 1)}} ${stringCamelCase(input.name || `arg${idx}`)}`), optionsTypeName ? `@param {${optionsTypeName}} ${optionsParamName}` : '')}`;
+        callsOut += `new: ${this.generateMethodDef(abiItem, optionsParamName)};\n\n`;
+        return callsOut;
+    }
+    generateMethodDef(abiItem, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(abiItem);
+        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<[], ContractInstantiateResult<ChainApi>>>, Type>`;
+    }
+    generateParamsOut(abiItem) {
+        return abiItem.inputs
+            .map((input, idx) => `${stringCamelCase(input.name || `arg${idx}`)}: ${this.typesGen.generateType(input, abiItem, 1)}`)
+            .join(', ');
+    }
+    findConstructor() {
+        let constructor = this.abi.find((item) => item.type === 'constructor');
+        // Fallback to default constructor
+        if (!constructor) {
+            constructor = {
+                inputs: [],
+                stateMutability: 'nonpayable',
+                type: 'constructor',
+            };
+        }
+        return constructor;
+    }
+}

package/sol/generator/ConstructorTxGen.d.ts

@@ -0,0 +1,6 @@
+import { SolAbiConstructor } from '@dedot/contracts';
+import { ConstructorQueryGen } from './ConstructorQueryGen.js';
+export declare class ConstructorTxGen extends ConstructorQueryGen {
+    generate(useSubPaths?: boolean): Promise<string>;
+    generateMethodDef(abiItem: SolAbiConstructor, optionsParamName?: string): string;
+}

package/sol/generator/ConstructorTxGen.js

@@ -0,0 +1,17 @@
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+import { ConstructorQueryGen } from './ConstructorQueryGen.js';
+export class ConstructorTxGen extends ConstructorQueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericConstructorTx', 'SolGenericContractApi', 'GenericConstructorTxCall', 'ConstructorTxOptions', 'GenericInstantiateSubmittableExtrinsic', 'MetadataType');
+        let constructor = this.findConstructor();
+        const constructorsOut = this.doGenerateConstructorFragment(constructor, 'ConstructorTxOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/constructor-tx.hbs');
+        return beautifySourceCode(template({ importTypes, constructorsOut }));
+    }
+    generateMethodDef(abiItem, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(abiItem);
+        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi, ContractApi>, Type>`;
+    }
+}

package/sol/generator/EventsGen.d.ts

@@ -0,0 +1,10 @@
+import { SolAbi, SolAbiEvent } from '@dedot/contracts';
+import { TypesGen } from './TypesGen.js';
+export declare class EventsGen {
+    #private;
+    readonly abi: SolAbi;
+    readonly typesGen: TypesGen;
+    constructor(abi: SolAbi, typesGen: TypesGen);
+    generate(useSubPaths?: boolean): Promise<string>;
+    generateParamsOut(abiItem: SolAbiEvent): string;
+}

package/sol/generator/EventsGen.js

@@ -0,0 +1,34 @@
+import { stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+export class EventsGen {
+    abi;
+    typesGen;
+    constructor(abi, typesGen) {
+        this.abi = abi;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractEvents', 'GenericContractEvent', 'MetadataType');
+        const events = this.abi.filter((o) => o.type === 'event');
+        let eventsOut = '';
+        events.forEach((event) => {
+            const { name, anonymous } = event;
+            eventsOut += `${stringPascalCase(name)}: ${this.#generateEventDef(event)};\n\n`;
+        });
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/events.hbs');
+        return beautifySourceCode(template({ importTypes, eventsOut }));
+    }
+    #generateEventDef(abiItem) {
+        const { name } = abiItem;
+        const paramsOut = this.generateParamsOut(abiItem);
+        return `GenericContractEvent<'${stringPascalCase(name)}', {${paramsOut}}, Type>`;
+    }
+    generateParamsOut(abiItem) {
+        const { inputs } = abiItem;
+        return inputs
+            .map((o, idx) => `${commentBlock(`@indexed: ${o.indexed}`)}${stringCamelCase(o.name || `arg${idx}`)}: ${this.typesGen.generateType(o, abiItem, 1)}`)
+            .join(', ');
+    }
+}

package/sol/generator/IndexGen.d.ts

@@ -0,0 +1,7 @@
+import { TypesGen } from './TypesGen.js';
+export declare class IndexGen {
+    interfaceName: string;
+    typesGen: TypesGen;
+    constructor(interfaceName: string, typesGen: TypesGen);
+    generate(useSubPaths?: boolean): Promise<string>;
+}

package/sol/generator/IndexGen.js

@@ -0,0 +1,23 @@
+import { TypeImports } from '../../shared/index.js';
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+export class IndexGen {
+    interfaceName;
+    typesGen;
+    constructor(interfaceName, typesGen) {
+        this.interfaceName = interfaceName;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        const interfaceName = this.interfaceName;
+        const typeImports = new TypeImports();
+        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
+        typeImports.addContractType('SolGenericContractApi', 'SolRegistry');
+        typeImports.addChainType('SubstrateApi');
+        const importTypes = typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/index.hbs');
+        return beautifySourceCode(template({
+            interfaceName,
+            importTypes,
+        }));
+    }
+}

package/sol/generator/QueryGen.d.ts

@@ -0,0 +1,11 @@
+import { SolAbi, SolAbiFunction } from '@dedot/contracts';
+import { TypesGen } from './TypesGen.js';
+export declare class QueryGen {
+    readonly abi: SolAbi;
+    readonly typesGen: TypesGen;
+    constructor(abi: SolAbi, typesGen: TypesGen);
+    generate(useSubPaths?: boolean): Promise<string>;
+    doGenerate(functions: SolAbiFunction[], optionsTypeName?: string): string;
+    generateMethodDef(abiItem: SolAbiFunction, optionsParamName?: string): string;
+    generateParamsOut(abiItem: SolAbiFunction): string;
+}

package/sol/generator/QueryGen.js

@@ -0,0 +1,46 @@
+import { normalizeLabel } from '@dedot/contracts';
+import { stringCamelCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+export class QueryGen {
+    abi;
+    typesGen;
+    constructor(abi, typesGen) {
+        this.abi = abi;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractQuery', 'GenericContractQueryCall', 'ContractCallOptions', 'GenericContractCallResult', 'ContractCallResult', 'MetadataType');
+        const functions = this.abi.filter((item) => item.type === 'function');
+        const queryCallsOut = this.doGenerate(functions, 'ContractCallOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/query.hbs');
+        return beautifySourceCode(template({ importTypes, queryCallsOut }));
+    }
+    doGenerate(functions, optionsTypeName) {
+        let callsOut = '';
+        functions.forEach((def) => {
+            const { inputs, name } = def;
+            // 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 = inputs.some(({ name }) => name === 'options') ? '_options' : 'options';
+            callsOut += `${commentBlock(inputs.map((input, idx) => `@param {${this.typesGen.generateType(input, def, 1)}} ${stringCamelCase(input.name || `arg${idx}`)}`), optionsTypeName ? `@param {${optionsTypeName}} ${optionsParamName}` : '')}`;
+            callsOut += `${normalizeLabel(name)}: ${this.generateMethodDef(def, optionsParamName)};\n\n`;
+        });
+        return callsOut;
+    }
+    generateMethodDef(abiItem, optionsParamName = 'options') {
+        const { outputs } = abiItem;
+        const paramsOut = this.generateParamsOut(abiItem);
+        const typeOutInner = `${outputs.map((o) => this.typesGen.generateType(o, abiItem, 1, true)).join(',')}`;
+        // If there is only one output, we don't need to wrap it in a tuple, for user-friendly
+        const typeOut = outputs.length === 1 ? typeOutInner : `[${typeOutInner}]`;
+        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>, Type>`;
+    }
+    generateParamsOut(abiItem) {
+        return abiItem.inputs
+            .map((input, idx) => `${stringCamelCase(input.name || `arg${idx}`)}: ${this.typesGen.generateType(input, abiItem, 1)}`)
+            .join(', ');
+    }
+}

package/sol/generator/TxGen.d.ts

@@ -0,0 +1,6 @@
+import { SolAbiFunction } from '@dedot/contracts';
+import { QueryGen } from './QueryGen.js';
+export declare class TxGen extends QueryGen {
+    generate(useSubPaths?: boolean): Promise<string>;
+    generateMethodDef(abiItem: SolAbiFunction, optionsParamName?: string): string;
+}

package/sol/generator/TxGen.js

@@ -0,0 +1,17 @@
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+import { QueryGen } from './QueryGen.js';
+export class TxGen extends QueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractTx', 'GenericContractTxCall', 'ContractTxOptions', 'ContractSubmittableExtrinsic', 'MetadataType');
+        const txFunctions = this.abi.filter((item) => item.type === 'function' && item.stateMutability !== 'view');
+        const txCallsOut = this.doGenerate(txFunctions, 'ContractTxOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/tx.hbs');
+        return beautifySourceCode(template({ importTypes, txCallsOut }));
+    }
+    generateMethodDef(abiItem, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(abiItem);
+        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>, Type>`;
+    }
+}

package/sol/generator/TypesGen.d.ts

@@ -0,0 +1,15 @@
+import { SolAbi, SolAbiItem, SolAbiTypeDef } from '@dedot/contracts';
+import { TypeImports } from '../../shared/TypeImports.js';
+export declare const SUPPORTED_SOLIDITY_TYPES: RegExp[];
+export declare const BASIC_KNOWN_TYPES: RegExp[];
+export declare class TypesGen {
+    #private;
+    readonly abi: SolAbi;
+    typeImports: TypeImports;
+    constructor(abi: SolAbi);
+    generate(useSubPaths?: boolean): Promise<string>;
+    generateTypeName(typeDef: SolAbiTypeDef, abiItem: SolAbiItem, typeOut?: boolean): string;
+    generateType(typeDef: SolAbiTypeDef, abiItem?: SolAbiItem, nestedLevel?: number, typeOut?: boolean): string;
+    generateObjectType(components: SolAbiTypeDef[], nestedLevel?: number, typeOut?: boolean): string;
+    addTypeImport(typeName: string | string[]): void;
+}