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

package/sol/generator/TypesGen.js

@@ -0,0 +1,212 @@
+import { stringPascalCase } from '@dedot/utils';
+import { TypeImports } from '../../shared/TypeImports.js';
+import { beautifySourceCode, compileTemplate, isNativeType } from '../../utils.js';
+const INT_TYPES = /^int(\d+)?(\[(\d+)?])*?$/;
+const UINT_TYPES = /^uint(\d+)?(\[(\d+)?])*?$/;
+const BYTES_TYPES = /^bytes(\d+)?(\[(\d+)?])*?$/;
+const FIXED_TYPES = /^fixed(\d+x\d+)?(\[(\d+)?])*?$/;
+const UNFIXED_TYPES = /^ufixed(\d+x\d+)?(\[(\d+)?])*?$/;
+const STRING_TYPES = /^string(\[(\d+)?])*?$/;
+const BOOL_TYPES = /^bool(\[(\d+)?])*?$/;
+const ADDRESS_TYPES = /^address(\[(\d+)?])*?$/;
+const FUNCTION_TYPES = /^function(\[(\d+)?])*?$/;
+const COMPONENT_TYPES = /^tuple(\[(\d+)?])*?$/;
+const ARRAY_DIM = /\[(\d+)?]/g;
+const ONLY_ARRAY_DIM = /^\[(\d+)?]$/;
+export const SUPPORTED_SOLIDITY_TYPES = [
+    INT_TYPES,
+    UINT_TYPES,
+    BYTES_TYPES,
+    FIXED_TYPES,
+    UNFIXED_TYPES,
+    STRING_TYPES,
+    BOOL_TYPES,
+    ADDRESS_TYPES,
+    FUNCTION_TYPES,
+    COMPONENT_TYPES,
+];
+export const BASIC_KNOWN_TYPES = [
+    /^(H160)$/,
+    /^(FixedBytes)<(\d+)>$/,
+    /^(Bytes)$/,
+    /^(BytesLike)$/,
+    /^(Fixed)<(\d+),(\d+)>$/,
+    /^(UFixed)<(\d+),(\d+)>$/,
+    /^(FixedArray)$/,
+];
+export class TypesGen {
+    abi;
+    typeImports;
+    constructor(abi) {
+        this.abi = abi;
+        this.typeImports = new TypeImports();
+    }
+    generate(useSubPaths = false) {
+        let defTypeOut = '';
+        this.abi.forEach((abiItem) => {
+            if (abiItem.type === 'fallback' || abiItem.type === 'receive')
+                return;
+            if (abiItem.type === 'function' || abiItem.type === 'constructor' || abiItem.type === 'event') {
+                const { inputs } = abiItem;
+                inputs
+                    .filter((o) => o.components && o.components.length > 0)
+                    .forEach((o) => {
+                    defTypeOut += `export type ${this.generateTypeName(o, abiItem)} = ${this.generateType(o, abiItem, 0)};\n\n`;
+                });
+            }
+            if (abiItem.type === 'function') {
+                const { outputs } = abiItem;
+                outputs
+                    .filter((o) => o.components && o.components.length > 0)
+                    .forEach((o) => {
+                    defTypeOut += `export type ${this.generateTypeName(o, abiItem, true)} = ${this.generateType(o, abiItem, 0, true)};\n\n`;
+                });
+            }
+        });
+        const importTypes = this.typeImports.toImports({ excludeModules: ['./types.js'], useSubPaths });
+        const template = compileTemplate('sol/templates/types.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+    generateTypeName(typeDef, abiItem, typeOut = false) {
+        if (abiItem.type === 'fallback' || abiItem.type === 'receive')
+            return '';
+        if (COMPONENT_TYPES.test(typeDef.type)) {
+            const baseName = abiItem.type === 'constructor'
+                ? `${typeDef.name}_input`
+                : `${abiItem.name}_${typeDef.name}_${typeOut ? 'output' : 'input'}`;
+            return stringPascalCase(baseName);
+        }
+        return '';
+    }
+    generateType(typeDef, abiItem, nestedLevel = 0, typeOut = false) {
+        if (nestedLevel > 0 && abiItem) {
+            let typeName = this.generateTypeName(typeDef, abiItem, typeOut);
+            if (typeName.length === 0) {
+                typeName = this.#generateType(typeDef, nestedLevel, typeOut);
+                return typeName;
+            }
+            this.addTypeImport(typeName);
+            return typeName;
+        }
+        return this.#generateType(typeDef, nestedLevel, typeOut);
+    }
+    #generateType(typeDef, nestedLevel = 0, typeOut = false) {
+        const { type } = typeDef;
+        let baseType = this.#generateBaseType(typeDef, nestedLevel, typeOut);
+        if (!COMPONENT_TYPES.test(type)) {
+            // baseType of component types are all generated types, eg: { a: bigint, b: string }
+            // So we don't import them here.
+            this.addTypeImport(baseType);
+        }
+        // Match all array dimensions
+        const dimensions = type.match(ARRAY_DIM);
+        dimensions
+            // Match each dimension to see if fixed array or dynamic array (eg: [3] vs [])
+            ?.map((o) => o.match(ONLY_ARRAY_DIM))
+            .forEach(([_, n]) => {
+            if (n) {
+                this.addTypeImport('FixedArray');
+                baseType = `FixedArray<${baseType}, ${n}>`;
+            }
+            else {
+                baseType = isNativeType(baseType.replaceAll('[]', '')) ? `${baseType}[]` : `Array<${baseType}>`;
+            }
+        });
+        return baseType;
+    }
+    #generateBaseType(typeDef, nestedLevel = 0, typeOut = false) {
+        const { type } = typeDef;
+        if (INT_TYPES.test(type)) {
+            const [_, bitsStr] = type.match(INT_TYPES);
+            // Default to 256 when unspecified
+            const bits = bitsStr ? parseInt(bitsStr) : 256;
+            const isSafeNumber = bits <= 48;
+            return isSafeNumber ? `number` : 'bigint';
+        }
+        else if (UINT_TYPES.test(type)) {
+            const [_, bitsStr] = type.match(UINT_TYPES);
+            // Default to 256 when unspecified
+            const bits = bitsStr ? parseInt(bitsStr) : 256;
+            const isSafeNumber = bits <= 48;
+            return isSafeNumber ? `number` : 'bigint';
+        }
+        else if (BYTES_TYPES.test(type)) {
+            const [_, n] = type.match(BYTES_TYPES);
+            if (n) {
+                return `FixedBytes<${n}>`;
+            }
+            if (typeOut) {
+                return `Bytes`;
+            }
+            return `BytesLike`;
+        }
+        else if (BOOL_TYPES.test(type)) {
+            return 'boolean';
+        }
+        else if (STRING_TYPES.test(type)) {
+            return 'string';
+        }
+        else if (COMPONENT_TYPES.test(type)) {
+            const { components = [] } = typeDef;
+            if (components.length === 0) {
+                return '[]';
+            }
+            else {
+                const objectType = this.generateObjectType(components, nestedLevel + 1, typeOut);
+                return `${objectType}`;
+            }
+        }
+        else if (ADDRESS_TYPES.test(type)) {
+            return `H160`;
+        }
+        else if (FUNCTION_TYPES.test(type)) {
+            // Function type is an address (20 bytes) followed by a function selector (4 bytes).
+            // Ref: https://docs.soliditylang.org/en/latest/abi-spec.html#:~:text=function%3A%20an%20address%20(20%20bytes)%20followed%20by%20a%20function%20selector%20(4%20bytes).%20Encoded%20identical%20to%20bytes24.
+            return `FixedBytes<24>`;
+        }
+        else if (FIXED_TYPES.test(type)) {
+            const [_, denotation] = type.match(FIXED_TYPES);
+            // Ref: https://docs.soliditylang.org/en/latest/abi-spec.html#:~:text=fixed%2C%20ufixed%3A%20synonyms%20for%20fixed128x18%2C%20ufixed128x18%20respectively.%20For%20computing%20the%20function%20selector%2C%20fixed128x18%20and%20ufixed128x18%20have%20to%20be%20used.
+            const [m, n] = denotation ? denotation.split('x').map((s) => parseInt(s)) : [128, 18];
+            return `Fixed<${m},${n}>`;
+        }
+        else if (UNFIXED_TYPES.test(type)) {
+            const [_, denotation] = type.match(UNFIXED_TYPES);
+            // Ref: https://docs.soliditylang.org/en/latest/abi-spec.html#:~:text=fixed%2C%20ufixed%3A%20synonyms%20for%20fixed128x18%2C%20ufixed128x18%20respectively.%20For%20computing%20the%20function%20selector%2C%20fixed128x18%20and%20ufixed128x18%20have%20to%20be%20used.
+            const [m, n] = denotation ? denotation.split('x').map((s) => parseInt(s)) : [128, 18];
+            return `UFixed<${m},${n}>`;
+        }
+        else {
+            throw new Error(`Unsupported Solidity type: ${type}`);
+        }
+    }
+    generateObjectType(components, nestedLevel = 0, typeOut = false) {
+        const props = components.map((typeDef) => {
+            const type = this.generateType(typeDef, undefined, nestedLevel + 1, typeOut);
+            return {
+                name: typeDef.name,
+                type,
+            };
+        });
+        if (props.length > 0 && props.at(0).name.length === 0) {
+            return `[${props.map(({ type }) => `${type}`).join(', ')}]`;
+        }
+        return `{${props.map(({ name, type }) => `${name}: ${type}`).join(',\n')}}`;
+    }
+    addTypeImport(typeName) {
+        if (Array.isArray(typeName)) {
+            typeName.forEach((one) => this.addTypeImport(one));
+            return;
+        }
+        if (isNativeType(typeName)) {
+            return;
+        }
+        const re = BASIC_KNOWN_TYPES.find((re) => typeName.match(re));
+        if (re) {
+            const typeBase = typeName.match(re)[1];
+            this.typeImports.addCodecType(typeBase);
+            return;
+        }
+        this.typeImports.addPortableType(typeName);
+    }
+}

package/sol/generator/index.d.ts

@@ -0,0 +1,7 @@
+export * from './IndexGen.js';
+export * from './QueryGen.js';
+export * from './TypesGen.js';
+export * from './TxGen.js';
+export * from './ConstructorTxGen.js';
+export * from './ConstructorQueryGen.js';
+export * from './EventsGen.js';

package/sol/generator/index.js

@@ -0,0 +1,7 @@
+export * from './IndexGen.js';
+export * from './QueryGen.js';
+export * from './TypesGen.js';
+export * from './TxGen.js';
+export * from './ConstructorTxGen.js';
+export * from './ConstructorQueryGen.js';
+export * from './EventsGen.js';

package/sol/index.d.ts

@@ -0,0 +1,3 @@
+import { SolAbi } from '@dedot/contracts';
+import { GeneratedResult } from '../types.js';
+export declare function generateSolContractTypes(abi: SolAbi | string, contract?: string | undefined, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<GeneratedResult>;

package/sol/index.js

@@ -0,0 +1,35 @@
+import { stringDashCase, stringPascalCase } from '@dedot/utils';
+import fs from 'fs';
+import path from 'path';
+import { ConstructorQueryGen, ConstructorTxGen, EventsGen, IndexGen, QueryGen, TxGen, TypesGen, } from './generator/index.js';
+export async function generateSolContractTypes(abi, contract = 'contract', outDir = '.', extension = 'd.ts', useSubPaths = false) {
+    let abiItems = typeof abi === 'string' ? JSON.parse(abi) : abi;
+    const contractName = contract;
+    const dirPath = path.resolve(outDir, stringDashCase(contractName));
+    const typesFileName = path.join(dirPath, `types.${extension}`);
+    const queryTypesFileName = path.join(dirPath, `query.${extension}`);
+    const eventsTypesFileName = path.join(dirPath, `events.${extension}`);
+    const txTypesFileName = path.join(dirPath, `tx.${extension}`);
+    const constructorTxTypesFileName = path.join(dirPath, `constructor-tx.${extension}`);
+    const constructorQueryTypesFileName = path.join(dirPath, `constructor-query.${extension}`);
+    const indexTypesFileName = path.join(dirPath, `index.${extension}`);
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+    const interfaceName = `${stringPascalCase(`${contractName}`)}ContractApi`;
+    const typesGen = new TypesGen(abiItems);
+    const queryGen = new QueryGen(abiItems, typesGen);
+    const eventsGen = new EventsGen(abiItems, typesGen);
+    const txGen = new TxGen(abiItems, typesGen);
+    const constructorTxGen = new ConstructorTxGen(abiItems, typesGen);
+    const constructorQueryGen = new ConstructorQueryGen(abiItems, typesGen);
+    const indexGen = new IndexGen(interfaceName, typesGen);
+    fs.writeFileSync(typesFileName, await typesGen.generate(useSubPaths));
+    fs.writeFileSync(queryTypesFileName, await queryGen.generate(useSubPaths));
+    fs.writeFileSync(eventsTypesFileName, await eventsGen.generate(useSubPaths));
+    fs.writeFileSync(txTypesFileName, await txGen.generate(useSubPaths));
+    fs.writeFileSync(constructorQueryTypesFileName, await constructorQueryGen.generate(useSubPaths));
+    fs.writeFileSync(constructorTxTypesFileName, await constructorTxGen.generate(useSubPaths));
+    fs.writeFileSync(indexTypesFileName, await indexGen.generate(useSubPaths));
+    return { interfaceName, outputFolder: dirPath };
+}

package/sol/templates/constructor-query.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ConstructorQuery <ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericConstructorQuery <ChainApi, Type> {
+    {{{ constructorsOut }}}
+}

package/sol/templates/constructor-tx.hbs

@@ -0,0 +1,11 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ConstructorTx<
+  ChainApi extends GenericSubstrateApi, 
+  ContractApi extends SolGenericContractApi,
+  Type extends MetadataType
+> extends GenericConstructorTx <ChainApi, Type> {
+  {{{ constructorsOut }}}
+}

package/sol/templates/events.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ContractEvents <ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractEvents <ChainApi, Type> {
+    {{{ eventsOut }}}
+}

package/sol/templates/index.hbs

@@ -0,0 +1,23 @@
+// Generated by dedot cli
+
+{{{importTypes}}}
+import { ContractQuery } from './query.js';
+import { ContractTx } from './tx.js';
+import { ConstructorQuery } from './constructor-query.js';
+import { ConstructorTx } from './constructor-tx.js';
+import { ContractEvents } from './events.js';
+
+export * from './types.js';
+
+{{{interfaceDocs}}}export interface {{{interfaceName}}}<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends SolGenericContractApi<Rv, ChainApi> {
+    metadataType: 'sol';
+    query: ContractQuery<ChainApi[Rv], 'sol'>;
+    tx: ContractTx<ChainApi[Rv], 'sol'>;
+    constructorQuery: ConstructorQuery<ChainApi[Rv], 'sol'>;
+    events: ContractEvents<ChainApi[Rv], 'sol'>;
+    constructorTx: ConstructorTx<ChainApi[Rv], {{{interfaceName}}}, 'sol'>;
+
+    types: {
+      ChainApi: ChainApi[Rv];
+    };
+}

package/sol/templates/query.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ContractQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractQuery<ChainApi, Type> {
+    {{{ queryCallsOut }}}
+}

package/sol/templates/tx.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ContractTx<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractTx<ChainApi, Type> {
+    {{{ txCallsOut }}}
+}

package/sol/templates/types.hbs

@@ -0,0 +1,5 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+{{{ defTypeOut }}}

package/typink/generator/ConstructorQueryGen.js

@@ -4,7 +4,7 @@ export class ConstructorQueryGen extends QueryGen {
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
         this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
-        this.typesGen.typeImports.addContractType('GenericConstructorQuery', 'GenericConstructorQueryCall', 'GenericConstructorCallResult', 'ConstructorCallOptions', 'ContractInstantiateResult');
+        this.typesGen.typeImports.addContractType('GenericConstructorQuery', 'GenericConstructorQueryCall', 'GenericConstructorCallResult', 'ConstructorCallOptions', 'ContractInstantiateResult', 'MetadataType');
         const { constructors } = this.contractMetadata.spec;
         const constructorsOut = this.doGenerate(constructors, 'ConstructorCallOptions');
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
@@ -17,6 +17,6 @@ export class ConstructorQueryGen extends QueryGen {
         const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
         // Unwrap langError result
         const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
-        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult<ChainApi>>>>`;
+        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult<ChainApi>>>, Type>`;
     }
 }

package/typink/generator/ConstructorTxGen.js

@@ -4,7 +4,7 @@ export class ConstructorTxGen extends QueryGen {
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
         this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
-        this.typesGen.typeImports.addContractType('GenericConstructorTx', 'GenericConstructorTxCall', 'ConstructorTxOptions', 'GenericContractApi', 'GenericInstantiateSubmittableExtrinsic');
+        this.typesGen.typeImports.addContractType('GenericConstructorTx', 'GenericConstructorTxCall', 'ConstructorTxOptions', 'InkGenericContractApi', 'GenericInstantiateSubmittableExtrinsic', 'MetadataType');
         const { constructors } = this.contractMetadata.spec;
         const constructorsOut = this.doGenerate(constructors, 'ConstructorTxOptions');
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
@@ -13,6 +13,6 @@ export class ConstructorTxGen extends QueryGen {
     }
     generateMethodDef(def, optionsParamName = 'options') {
         const paramsOut = this.generateParamsOut(def.args);
-        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi, ContractApi>>`;
+        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi, ContractApi>, Type>`;
     }
 }

package/typink/generator/EventsGen.js

@@ -5,7 +5,7 @@ export class EventsGen extends QueryGen {
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
         this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
-        this.typesGen.typeImports.addContractType('GenericContractEvents', 'GenericContractEvent');
+        this.typesGen.typeImports.addContractType('GenericContractEvents', 'GenericContractEvent', 'MetadataType');
         const { events } = this.contractMetadata.spec;
         let eventsOut = '';
         const isV5 = this.contractMetadata.version === 5;
@@ -21,7 +21,7 @@ export class EventsGen extends QueryGen {
     #generateEventDef(event) {
         const { args, label } = event;
         const paramsOut = this.generateParamsOut(args);
-        return `GenericContractEvent<'${stringPascalCase(label)}', {${paramsOut}}>`;
+        return `GenericContractEvent<'${stringPascalCase(label)}', {${paramsOut}}, Type>`;
     }
     generateParamsOut(args) {
         return args

package/typink/generator/IndexGen.js

@@ -16,7 +16,7 @@ export class IndexGen {
         const langErrorName = this.typesGen.cleanPath(this.contractMetadata.types[langErrorId].type.path);
         const typeImports = new 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/typink/generator/QueryGen.js

@@ -11,7 +11,7 @@ export 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 });
@@ -37,7 +37,7 @@ export 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/typink/generator/TxGen.js

@@ -4,7 +4,7 @@ export class TxGen extends 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');
@@ -14,6 +14,6 @@ export class TxGen extends 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>`;
     }
 }

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