@dedot/codegen 0.17.0 → 0.17.1-next.9d03d21b.3

package/cjs/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types.js"), exports);
 __exportStar(require("./chaintypes/index.js"), exports);
 __exportStar(require("./typink/index.js"), exports);
+__exportStar(require("./sol/index.js"), exports);

package/cjs/sol/generator/ConstructorQueryGen.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstructorQueryGen = void 0;
+const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("../../utils.js");
+class ConstructorQueryGen {
+    abi;
+    typesGen;
+    constructor(abi, typesGen) {
+        this.abi = abi;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        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 = (0, utils_js_1.compileTemplate)('sol/templates/constructor-query.hbs');
+        return (0, utils_js_1.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 += `${(0, utils_js_1.commentBlock)(inputs.map((input, idx) => `@param {${this.typesGen.generateType(input, abiItem, 1)}} ${(0, utils_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) => `${(0, utils_1.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;
+    }
+}
+exports.ConstructorQueryGen = ConstructorQueryGen;

package/cjs/sol/generator/ConstructorTxGen.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstructorTxGen = void 0;
+const utils_js_1 = require("../../utils.js");
+const ConstructorQueryGen_js_1 = require("./ConstructorQueryGen.js");
+class ConstructorTxGen extends ConstructorQueryGen_js_1.ConstructorQueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        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 = (0, utils_js_1.compileTemplate)('sol/templates/constructor-tx.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, constructorsOut }));
+    }
+    generateMethodDef(abiItem, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(abiItem);
+        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi, ContractApi>, Type>`;
+    }
+}
+exports.ConstructorTxGen = ConstructorTxGen;

package/cjs/sol/generator/EventsGen.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsGen = void 0;
+const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("../../utils.js");
+class EventsGen {
+    abi;
+    typesGen;
+    constructor(abi, typesGen) {
+        this.abi = abi;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        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 += `${(0, utils_1.stringPascalCase)(name)}: ${this.#generateEventDef(event)};\n\n`;
+        });
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('sol/templates/events.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, eventsOut }));
+    }
+    #generateEventDef(abiItem) {
+        const { name } = abiItem;
+        const paramsOut = this.generateParamsOut(abiItem);
+        return `GenericContractEvent<'${(0, utils_1.stringPascalCase)(name)}', {${paramsOut}}, Type>`;
+    }
+    generateParamsOut(abiItem) {
+        const { inputs } = abiItem;
+        return inputs
+            .map((o, idx) => `${(0, utils_js_1.commentBlock)(`@indexed: ${o.indexed}`)}${(0, utils_1.stringCamelCase)(o.name || `arg${idx}`)}: ${this.typesGen.generateType(o, abiItem, 1)}`)
+            .join(', ');
+    }
+}
+exports.EventsGen = EventsGen;

package/cjs/sol/generator/IndexGen.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexGen = void 0;
+const index_js_1 = require("../../shared/index.js");
+const utils_js_1 = require("../../utils.js");
+class IndexGen {
+    interfaceName;
+    typesGen;
+    constructor(interfaceName, typesGen) {
+        this.interfaceName = interfaceName;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        const interfaceName = this.interfaceName;
+        const typeImports = new index_js_1.TypeImports();
+        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
+        typeImports.addContractType('SolGenericContractApi', 'SolRegistry');
+        typeImports.addChainType('SubstrateApi');
+        const importTypes = typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('sol/templates/index.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({
+            interfaceName,
+            importTypes,
+        }));
+    }
+}
+exports.IndexGen = IndexGen;

package/cjs/sol/generator/QueryGen.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryGen = void 0;
+const contracts_1 = require("@dedot/contracts");
+const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("../../utils.js");
+class QueryGen {
+    abi;
+    typesGen;
+    constructor(abi, typesGen) {
+        this.abi = abi;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        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 = (0, utils_js_1.compileTemplate)('sol/templates/query.hbs');
+        return (0, utils_js_1.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 += `${(0, utils_js_1.commentBlock)(inputs.map((input, idx) => `@param {${this.typesGen.generateType(input, def, 1)}} ${(0, utils_1.stringCamelCase)(input.name || `arg${idx}`)}`), optionsTypeName ? `@param {${optionsTypeName}} ${optionsParamName}` : '')}`;
+            callsOut += `${(0, contracts_1.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) => `${(0, utils_1.stringCamelCase)(input.name || `arg${idx}`)}: ${this.typesGen.generateType(input, abiItem, 1)}`)
+            .join(', ');
+    }
+}
+exports.QueryGen = QueryGen;

package/cjs/sol/generator/TxGen.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxGen = void 0;
+const utils_js_1 = require("../../utils.js");
+const QueryGen_js_1 = require("./QueryGen.js");
+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', '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 = (0, utils_js_1.compileTemplate)('sol/templates/tx.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, txCallsOut }));
+    }
+    generateMethodDef(abiItem, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(abiItem);
+        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>, Type>`;
+    }
+}
+exports.TxGen = TxGen;

package/cjs/sol/generator/TypesGen.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypesGen = exports.BASIC_KNOWN_TYPES = exports.SUPPORTED_SOLIDITY_TYPES = void 0;
+const utils_1 = require("@dedot/utils");
+const TypeImports_js_1 = require("../../shared/TypeImports.js");
+const utils_js_1 = require("../../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+)?]$/;
+exports.SUPPORTED_SOLIDITY_TYPES = [
+    INT_TYPES,
+    UINT_TYPES,
+    BYTES_TYPES,
+    FIXED_TYPES,
+    UNFIXED_TYPES,
+    STRING_TYPES,
+    BOOL_TYPES,
+    ADDRESS_TYPES,
+    FUNCTION_TYPES,
+    COMPONENT_TYPES,
+];
+exports.BASIC_KNOWN_TYPES = [
+    /^(H160)$/,
+    /^(FixedBytes)<(\d+)>$/,
+    /^(Bytes)$/,
+    /^(BytesLike)$/,
+    /^(Fixed)<(\d+),(\d+)>$/,
+    /^(UFixed)<(\d+),(\d+)>$/,
+    /^(FixedArray)$/,
+];
+class TypesGen {
+    abi;
+    typeImports;
+    constructor(abi) {
+        this.abi = abi;
+        this.typeImports = new TypeImports_js_1.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 = (0, utils_js_1.compileTemplate)('sol/templates/types.hbs');
+        return (0, utils_js_1.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 (0, utils_1.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 = (0, utils_js_1.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 ((0, utils_js_1.isNativeType)(typeName)) {
+            return;
+        }
+        const re = exports.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);
+    }
+    clearCache() {
+        this.typeImports.clear();
+    }
+}
+exports.TypesGen = TypesGen;

package/cjs/sol/generator/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IndexGen.js"), exports);
+__exportStar(require("./QueryGen.js"), exports);
+__exportStar(require("./TypesGen.js"), exports);
+__exportStar(require("./TxGen.js"), exports);
+__exportStar(require("./ConstructorTxGen.js"), exports);
+__exportStar(require("./ConstructorQueryGen.js"), exports);
+__exportStar(require("./EventsGen.js"), exports);

package/cjs/sol/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSolContractTypes = void 0;
+const utils_1 = require("@dedot/utils");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const index_js_1 = require("./generator/index.js");
+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_1.default.resolve(outDir, (0, utils_1.stringDashCase)(contractName));
+    const typesFileName = path_1.default.join(dirPath, `types.${extension}`);
+    const queryTypesFileName = path_1.default.join(dirPath, `query.${extension}`);
+    const eventsTypesFileName = path_1.default.join(dirPath, `events.${extension}`);
+    const txTypesFileName = path_1.default.join(dirPath, `tx.${extension}`);
+    const constructorTxTypesFileName = path_1.default.join(dirPath, `constructor-tx.${extension}`);
+    const constructorQueryTypesFileName = path_1.default.join(dirPath, `constructor-query.${extension}`);
+    const indexTypesFileName = path_1.default.join(dirPath, `index.${extension}`);
+    if (!fs_1.default.existsSync(dirPath)) {
+        fs_1.default.mkdirSync(dirPath, { recursive: true });
+    }
+    const interfaceName = `${(0, utils_1.stringPascalCase)(`${contractName}`)}ContractApi`;
+    const typesGen = new index_js_1.TypesGen(abiItems);
+    const queryGen = new index_js_1.QueryGen(abiItems, typesGen);
+    const eventsGen = new index_js_1.EventsGen(abiItems, typesGen);
+    const txGen = new index_js_1.TxGen(abiItems, typesGen);
+    const constructorTxGen = new index_js_1.ConstructorTxGen(abiItems, typesGen);
+    const constructorQueryGen = new index_js_1.ConstructorQueryGen(abiItems, typesGen);
+    const indexGen = new index_js_1.IndexGen(interfaceName, typesGen);
+    fs_1.default.writeFileSync(typesFileName, await typesGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(queryTypesFileName, await queryGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(eventsTypesFileName, await eventsGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(txTypesFileName, await txGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(constructorQueryTypesFileName, await constructorQueryGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(constructorTxTypesFileName, await constructorTxGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(indexTypesFileName, await indexGen.generate(useSubPaths));
+    return { interfaceName, outputFolder: dirPath };
+}
+exports.generateSolContractTypes = generateSolContractTypes;

package/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/sol/templates/types.hbs

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

package/cjs/typink/generator/ConstructorQueryGen.js

@@ -7,7 +7,7 @@ class ConstructorQueryGen extends QueryGen_js_1.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 });
@@ -20,7 +20,7 @@ class ConstructorQueryGen extends QueryGen_js_1.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>`;
     }
 }
 exports.ConstructorQueryGen = ConstructorQueryGen;

package/cjs/typink/generator/ConstructorTxGen.js

@@ -7,7 +7,7 @@ class ConstructorTxGen extends QueryGen_js_1.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 });
@@ -16,7 +16,7 @@ class ConstructorTxGen extends QueryGen_js_1.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>`;
     }
 }
 exports.ConstructorTxGen = ConstructorTxGen;

package/cjs/typink/generator/EventsGen.js

@@ -8,7 +8,7 @@ class EventsGen extends QueryGen_js_1.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;
@@ -24,7 +24,7 @@ class EventsGen extends QueryGen_js_1.QueryGen {
     #generateEventDef(event) {
         const { args, label } = event;
         const paramsOut = this.generateParamsOut(args);
-        return `GenericContractEvent<'${(0, utils_1.stringPascalCase)(label)}', {${paramsOut}}>`;
+        return `GenericContractEvent<'${(0, utils_1.stringPascalCase)(label)}', {${paramsOut}}, Type>`;
     }
     generateParamsOut(args) {
         return args