@dedot/codegen 0.0.1-next.ac8e621c.3 → 0.0.1-next.b6596712.6

package/cjs/{generator/TypesGen.js → shared/BaseTypesGen.js}

@@ -1,70 +1,96 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypesGen = exports.BASIC_KNOWN_TYPES = void 0;
-const util_1 = require("@polkadot/util");
-const codecs_1 = require("@dedot/codecs");
+exports.BaseTypesGen = exports.BASIC_KNOWN_TYPES = void 0;
 const utils_1 = require("@dedot/utils");
-const utils_2 = require("./utils");
-const known_types_1 = require("./known-types");
-const TypeImports_1 = require("./TypeImports");
-const known_codecs_1 = require("./known-codecs");
-// Skip generate types for these
-// as we do have native types for them
-const SKIP_TYPES = [
-    'BoundedBTreeMap',
-    'BoundedBTreeSet',
-    'BoundedVec',
-    'Box',
-    'BTreeMap',
-    'BTreeSet',
-    'Cow',
-    'Option',
-    'Range',
-    'RangeInclusive',
-    'Result',
-    'WeakBoundedVec',
-    'WrapperKeepOpaque',
-    'WrapperOpaque',
-];
+const utils_js_1 = require("../utils.js");
+const TypeImports_js_1 = require("./TypeImports.js");
+const known_codecs_js_1 = require("./known-codecs.js");
 // These are common & generic types, so we'll remove these from all paths at index 1
 // This helps make the type name shorter
 const PATH_RM_INDEX_1 = ['generic', 'misc', 'pallet', 'traits', 'types'];
 exports.BASIC_KNOWN_TYPES = ['BitSequence', 'Bytes', 'BytesLike', 'FixedBytes', 'FixedArray', 'Result'];
-const WRAPPER_TYPE_REGEX = /^(\w+)(<.*>)$/g;
-class TypesGen {
-    metadata;
-    /**
-     * Types will be generated its definition out.
-     */
+class BaseTypesGen {
+    types;
     includedTypes;
-    registry;
     typeImports;
-    constructor(metadata) {
-        this.metadata = metadata;
-        this.registry = new codecs_1.PortableRegistry(this.metadata);
-        this.includedTypes = this.#includedTypes();
-        this.typeImports = new TypeImports_1.TypeImports();
+    skipTypes;
+    constructor(types) {
+        this.types = types;
+        this.includedTypes = {};
+        this.typeImports = new TypeImports_js_1.TypeImports();
+        this.skipTypes = [];
     }
-    generate() {
-        this.clearCache();
-        let defTypeOut = '';
-        Object.values(this.includedTypes)
-            .filter(({ skip, knownType }) => !(skip || knownType))
-            .forEach(({ name, nameOut, id, docs }) => {
-            defTypeOut += `${(0, utils_2.commentBlock)(docs)}export type ${nameOut} = ${this.generateType(id, 0, true)};\n\n`;
-            if (this.#shouldGenerateTypeIn(id)) {
-                defTypeOut += `export type ${name} = ${this.generateType(id)};\n\n`;
-            }
-        });
-        const importTypes = this.typeImports.toImports('./types');
-        const template = (0, utils_2.compileTemplate)('types.hbs');
-        return (0, utils_2.beautifySourceCode)(template({ importTypes, defTypeOut }));
+    shouldGenerateTypeIn(_id) {
+        return false;
     }
     typeCache = {};
     clearCache() {
         this.typeCache = {};
         this.typeImports.clear();
     }
+    includeTypes() {
+        const pathsCount = new Map();
+        const typesWithPath = this.types.filter((one) => one.path.length > 0);
+        const skipIds = [];
+        const typeSuffixes = new Map();
+        typesWithPath.forEach(({ path, id }) => {
+            const joinedPath = path.join('::');
+            if (pathsCount.has(joinedPath)) {
+                // We compare 2 types with the same path here,
+                //  if they are the same type -> skip the current one, keep the first occurrence
+                //  if they are not the same type but has the same path -> we'll try to calculate & add a suffix for the current type name
+                const firstOccurrenceTypeId = pathsCount.get(joinedPath)[0];
+                const sameType = this.typeEql(firstOccurrenceTypeId, id);
+                if (sameType) {
+                    skipIds.push(id);
+                }
+                else {
+                    pathsCount.get(joinedPath).push(id);
+                    typeSuffixes.set(id, this.extractDupTypeSuffix(id, firstOccurrenceTypeId, pathsCount.get(joinedPath).length));
+                }
+            }
+            else {
+                pathsCount.set(joinedPath, [id]);
+            }
+        });
+        return typesWithPath.reduce((o, type) => {
+            const { path, id } = type;
+            const joinedPath = path.join('::');
+            if (this.skipTypes.includes(joinedPath) || this.skipTypes.includes(path.at(-1))) {
+                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);
+                name = codecType.typeIn;
+                nameOut = codecType.typeOut;
+                knownType = true;
+            }
+            else if (PATH_RM_INDEX_1.includes(path[1])) {
+                const newPath = path.slice();
+                newPath.splice(1, 1);
+                name = this.cleanPath(newPath);
+            }
+            else {
+                name = this.cleanPath(path);
+            }
+            if (this.shouldGenerateTypeIn(id)) {
+                nameOut = name;
+                name = name.endsWith('Like') ? name : `${name}Like`;
+            }
+            o[id] = {
+                name: `${name}${suffix}`,
+                nameOut: nameOut ? `${nameOut}${suffix}` : `${name}${suffix}`,
+                knownType,
+                skip: skipIds.includes(id),
+                ...type,
+            };
+            return o;
+        }, {});
+    }
     generateType(typeId, nestedLevel = 0, typeOut = false) {
         if (nestedLevel > 0) {
             const includedDef = this.includedTypes[typeId];
@@ -95,7 +121,7 @@ class TypesGen {
         return type;
     }
     #generateType(typeId, nestedLevel = 0, typeOut = false) {
-        const def = this.metadata.types[typeId];
+        const def = this.types[typeId];
         if (!def) {
             throw new Error(`Type def not found ${JSON.stringify(def)}`);
         }
@@ -103,7 +129,7 @@ class TypesGen {
         const { tag, value } = type;
         switch (tag) {
             case 'Primitive':
-                const $codec = (0, known_codecs_1.findKnownCodec)(value.kind);
+                const $codec = (0, known_codecs_js_1.findKnownCodec)(value.kind);
                 if ($codec.nativeType) {
                     return $codec.nativeType;
                 }
@@ -151,12 +177,12 @@ class TypesGen {
                     return 'null';
                 }
                 else if (members.every((x) => x.fields.length === 0)) {
-                    return members.map(({ name, docs }) => `${(0, utils_2.commentBlock)(docs)}'${(0, util_1.stringPascalCase)(name)}'`).join(' | ');
+                    return members.map(({ name, docs }) => `${(0, utils_js_1.commentBlock)(docs)}'${(0, utils_1.stringPascalCase)(name)}'`).join(' | ');
                 }
                 else {
                     const membersType = [];
                     for (const { fields, name, docs } of members) {
-                        const keyName = (0, util_1.stringPascalCase)(name);
+                        const keyName = (0, utils_1.stringPascalCase)(name);
                         if (fields.length === 0) {
                             membersType.push([keyName, null, docs]);
                         }
@@ -164,7 +190,7 @@ class TypesGen {
                             const valueType = fields.length === 1
                                 ? this.generateType(fields[0].typeId, nestedLevel + 1, typeOut)
                                 : `[${fields
-                                    .map(({ typeId, docs }) => `${(0, utils_2.commentBlock)(docs)}${this.generateType(typeId, nestedLevel + 1, typeOut)}`)
+                                    .map(({ typeId, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${this.generateType(typeId, nestedLevel + 1, typeOut)}`)
                                     .join(', ')}]`;
                             membersType.push([keyName, valueType, docs]);
                         }
@@ -172,14 +198,14 @@ class TypesGen {
                             membersType.push([keyName, this.generateObjectType(fields, nestedLevel + 1, typeOut), docs]);
                         }
                     }
-                    const { tagKey, valueKey } = this.registry.getEnumOptions(typeId);
+                    const { tagKey, valueKey } = this.getEnumOptions(typeId);
                     return membersType
                         .map(([keyName, valueType, docs]) => ({
                         tag: `${tagKey}: '${keyName}'`,
                         value: valueType ? `, ${valueKey}${this.#isOptionalType(valueType) ? '?' : ''}: ${valueType} ` : '',
                         docs,
                     }))
-                        .map(({ tag, value, docs }) => `${(0, utils_2.commentBlock)(docs)}{ ${tag}${value} }`)
+                        .map(({ tag, value, docs }) => `${(0, utils_js_1.commentBlock)(docs)}{ ${tag}${value} }`)
                         .join(' | ');
                 }
             }
@@ -202,7 +228,7 @@ class TypesGen {
             case 'Sequence':
             case 'SizedVec': {
                 const fixedSize = tag === 'SizedVec' ? `${value.len}` : null;
-                const $innerType = this.metadata.types[value.typeParam].type;
+                const $innerType = this.types[value.typeParam].type;
                 if ($innerType.tag === 'Primitive' && $innerType.value.kind === 'u8') {
                     return fixedSize ? `FixedBytes<${fixedSize}>` : typeOut ? 'Bytes' : 'BytesLike';
                 }
@@ -226,104 +252,26 @@ class TypesGen {
             };
         });
         return `{${props
-            .map(({ name, type, optional, docs }) => `${(0, utils_2.commentBlock)(docs)}${name}${optional ? '?' : ''}: ${type}`)
+            .map(({ name, type, optional, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${name}${optional ? '?' : ''}: ${type}`)
             .join(',\n')}}`;
     }
     #isOptionalType(type) {
         return type.endsWith('| undefined');
     }
-    #includedTypes() {
-        const { types } = this.metadata;
-        const pathsCount = new Map();
-        const typesWithPath = types.filter((one) => one.path.length > 0);
-        const skipIds = [];
-        const typeSuffixes = new Map();
-        typesWithPath.forEach(({ path, id }) => {
-            const joinedPath = path.join('::');
-            if (pathsCount.has(joinedPath)) {
-                // We compare 2 types with the same path here,
-                //  if they are the same type -> skip the current one, keep the first occurrence
-                //  if they are not the same type but has the same path -> we'll try to calculate & add a suffix for the current type name
-                const firstOccurrenceTypeId = pathsCount.get(joinedPath)[0];
-                const sameType = this.typeEql(firstOccurrenceTypeId, id);
-                if (sameType) {
-                    skipIds.push(id);
-                }
-                else {
-                    pathsCount.get(joinedPath).push(id);
-                    typeSuffixes.set(id, this.#extractDupTypeSuffix(id, firstOccurrenceTypeId, pathsCount.get(joinedPath).length));
-                }
-            }
-            else {
-                pathsCount.set(joinedPath, [id]);
-            }
-        });
-        return typesWithPath.reduce((o, type) => {
-            const { path, id } = type;
-            const joinedPath = path.join('::');
-            if (SKIP_TYPES.includes(joinedPath) || SKIP_TYPES.includes(path.at(-1))) {
-                return o;
-            }
-            const suffix = typeSuffixes.get(id) || '';
-            let knownType = false;
-            let name, nameOut;
-            if ((0, known_codecs_1.isKnownCodecType)(joinedPath)) {
-                const codecType = (0, known_codecs_1.findKnownCodecType)(path.at(-1));
-                name = codecType.typeIn;
-                nameOut = codecType.typeOut;
-                knownType = true;
-            }
-            else if (PATH_RM_INDEX_1.includes(path[1])) {
-                const newPath = path.slice();
-                newPath.splice(1, 1);
-                name = this.#cleanPath(newPath);
-            }
-            else {
-                name = this.#cleanPath(path);
-            }
-            if (this.#shouldGenerateTypeIn(id)) {
-                nameOut = name;
-                name = name.endsWith('Like') ? name : `${name}Like`;
-            }
-            o[id] = {
-                name: `${name}${suffix}`,
-                nameOut: nameOut ? `${nameOut}${suffix}` : `${name}${suffix}`,
-                knownType,
-                skip: skipIds.includes(id),
-                ...type,
-            };
-            return o;
-        }, {});
-    }
     #removeGenericPart(typeName) {
-        if (typeName.match(WRAPPER_TYPE_REGEX)) {
-            return typeName.replace(WRAPPER_TYPE_REGEX, (_, $1) => $1);
+        if (typeName.match(utils_js_1.WRAPPER_TYPE_REGEX)) {
+            return typeName.replace(utils_js_1.WRAPPER_TYPE_REGEX, (_, $1) => $1);
         }
         else {
             return typeName;
         }
     }
-    /**
-     * @description Remove duplicated part of the path
-     *
-     * Example:
-     * ["pallet_staking", "pallet", "pallet", "Event"]
-     * => ["pallet_staking", "pallet", "Event"]
-     *
-     * @param path
-     * @private
-     */
-    #cleanPath(path) {
+    cleanPath(path) {
         return path
-            .map((one) => (0, util_1.stringPascalCase)(one))
+            .map((one) => (0, utils_1.stringPascalCase)(one))
             .filter((one, idx, currentPath) => idx === 0 || one !== currentPath[idx - 1])
             .join('');
     }
-    #shouldGenerateTypeIn(id) {
-        const { callTypeId } = this.metadata.extrinsic;
-        const palletCallTypeIds = this.registry.getPalletCallTypeIds();
-        return callTypeId === id || palletCallTypeIds.includes(id);
-    }
     eqlCache = new Map();
     typeEql(idA, idB, level = 0) {
         const cacheKey = `${idA}==${idB}`;
@@ -336,9 +284,8 @@ class TypesGen {
     #typeEql(idA, idB, lvl = 0) {
         if (idA === idB)
             return true;
-        const { types } = this.metadata;
-        const typeA = types[idA];
-        const typeB = types[idB];
+        const typeA = this.types[idA];
+        const typeB = this.types[idB];
         if (typeA.path.join('::') !== typeB.path.join('::'))
             return false;
         const { type: defA, params: paramsA } = typeA;
@@ -381,19 +328,18 @@ class TypesGen {
             (param1.typeId === undefined) === (param2.typeId === undefined) &&
             (param1.typeId === undefined || this.#typeEql(param1.typeId, param2.typeId)));
     }
-    #extractDupTypeSuffix(dupTypeId, originalTypeId, dupCount) {
-        const { types } = this.metadata;
-        const originalTypeParams = types[originalTypeId].params;
-        const dupTypeParams = types[dupTypeId].params;
+    extractDupTypeSuffix(dupTypeId, originalTypeId, dupCount) {
+        const originalTypeParams = this.types[originalTypeId].params;
+        const dupTypeParams = this.types[dupTypeId].params;
         const diffParam = dupTypeParams.find((one, idx) => !this.#eqlTypeParam(one, originalTypeParams[idx]));
         // TODO make sure these suffix is unique if a type is duplicated more than 2 times
         if (diffParam?.typeId) {
-            const diffType = types[diffParam.typeId];
+            const diffType = this.types[diffParam.typeId];
             if (diffType.path.length > 0) {
-                return (0, util_1.stringPascalCase)(diffType.path.at(-1));
+                return (0, utils_1.stringPascalCase)(diffType.path.at(-1));
             }
             else if (diffType.type.tag === 'Primitive') {
-                return (0, util_1.stringPascalCase)(diffType.type.value.kind);
+                return (0, utils_1.stringPascalCase)(diffType.type.value.kind);
             }
         }
         // Last resort!
@@ -404,7 +350,7 @@ class TypesGen {
             typeName.forEach((one) => this.addTypeImport(one));
             return;
         }
-        if ((0, utils_1.isNativeType)(typeName)) {
+        if ((0, utils_js_1.isNativeType)(typeName)) {
             return;
         }
         for (let type of Object.values(this.includedTypes)) {
@@ -426,12 +372,10 @@ class TypesGen {
             this.typeImports.addCodecType(typeName);
             return;
         }
-        if (known_types_1.knownTypes.includes(typeName)) {
-            this.typeImports.addKnownType(typeName);
-        }
-        else {
-            this.typeImports.addOutType(typeName);
-        }
+        this.typeImports.addOutType(typeName);
+    }
+    getEnumOptions(_typeId) {
+        return { tagKey: 'tag', valueKey: 'value' };
     }
 }
-exports.TypesGen = TypesGen;
+exports.BaseTypesGen = BaseTypesGen;

package/cjs/{generator → shared}/TypeImports.js

@@ -8,30 +8,47 @@ class TypeImports {
     codecTypes;
     // Known types that're not codecs or chain/portable types defined in @dedot/types
     knownTypes;
+    knownJsonRpcTypes;
     // External types to define explicitly
     outTypes;
+    // Know types defined in @dedot/contracts
+    contractTypes;
+    // Know types defined in @dedot/api/chaintypes or dedot/chaintypes
+    chainTypes;
     constructor() {
         this.portableTypes = new Set();
         this.codecTypes = new Set();
         this.knownTypes = new Set();
+        this.knownJsonRpcTypes = new Set();
         this.outTypes = new Set();
+        this.contractTypes = new Set();
+        this.chainTypes = new Set();
     }
     clear() {
         this.portableTypes.clear();
         this.codecTypes.clear();
         this.knownTypes.clear();
+        this.knownJsonRpcTypes.clear();
         this.outTypes.clear();
+        this.contractTypes.clear();
+        this.chainTypes.clear();
     }
-    toImports(...excludeModules) {
+    toImports(config) {
+        const { excludeModules = [], useSubPaths = false } = config || {};
         // TODO generate outTypes!
+        const prefix = useSubPaths ? '' : '@';
         const toImports = [
-            [this.knownTypes, '@dedot/types'],
-            [this.codecTypes, '@dedot/codecs'],
+            [this.knownTypes, `${prefix}dedot/types`],
+            [this.knownJsonRpcTypes, `${prefix}dedot/types/json-rpc`],
+            [this.codecTypes, `${prefix}dedot/codecs`],
+            [this.contractTypes, `${prefix}dedot/contracts`],
+            [this.chainTypes, prefix ? '@dedot/api/chaintypes' : 'dedot/chaintypes'],
             [this.portableTypes, './types'],
         ];
         return toImports
             .filter(([_, module]) => !excludeModules.includes(module))
             .map(([types, module]) => this.#toImportLine(types, module))
+            .filter((line) => line.length > 0)
             .join('\n');
     }
     #toImportLine(types, module) {
@@ -49,8 +66,17 @@ class TypeImports {
     addKnownType(...types) {
         types.forEach((one) => this.knownTypes.add(one));
     }
+    addKnownJsonRpcType(...types) {
+        types.forEach((one) => this.knownJsonRpcTypes.add(one));
+    }
     addOutType(...types) {
         types.forEach((one) => this.outTypes.add(one));
     }
+    addContractType(...types) {
+        types.forEach((one) => this.contractTypes.add(one));
+    }
+    addChainType(...types) {
+        types.forEach((one) => this.chainTypes.add(one));
+    }
 }
 exports.TypeImports = TypeImports;

package/cjs/{generator → shared}/index.js

@@ -14,13 +14,6 @@ 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("./TypesGen"), exports);
-__exportStar(require("./ApiGen"), exports);
-__exportStar(require("./ConstsGen"), exports);
-__exportStar(require("./QueryGen"), exports);
-__exportStar(require("./RpcGen"), exports);
-__exportStar(require("./IndexGen"), exports);
-__exportStar(require("./ErrorsGen"), exports);
-__exportStar(require("./EventsGen"), exports);
-__exportStar(require("./TxGen"), exports);
-__exportStar(require("./RuntimeApisGen"), exports);
+__exportStar(require("./BaseTypesGen.js"), exports);
+__exportStar(require("./known-codecs.js"), exports);
+__exportStar(require("./TypeImports.js"), exports);

package/cjs/{generator → shared}/known-codecs.js

@@ -23,10 +23,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isKnownCodecType = exports.findKnownWrapperCodec = exports.findKnownCodec = exports.findKnownCodecType = exports.looseTypeCodecs = exports.normalizeCodecName = void 0;
-const $ = __importStar(require("@dedot/shape"));
+exports.checkKnownCodecType = exports.findKnownWrapperCodec = exports.findKnownCodec = exports.findKnownCodecType = exports.looseTypeCodecs = exports.normalizeCodecName = void 0;
 const Codecs = __importStar(require("@dedot/codecs"));
 const codecs_1 = require("@dedot/codecs");
+const $ = __importStar(require("@dedot/shape"));
 const utils_1 = require("@dedot/utils");
 const normalizeCodecName = (name) => {
     return name.startsWith('$') ? name : `$${name}`;
@@ -57,6 +57,8 @@ const KNOWN_PATHS = [
     /^primitive_types::\w+$/,
     /^sp_arithmetic::per_things::\w+$/,
     /^sp_arithmetic::fixed_point::\w+$/,
+    'ink_primitives::types::Hash',
+    { path: 'ink_primitives::types::AccountId', codec: 'AccountId32' },
 ];
 const WRAPPER_TYPE_REGEX = /^(\w+)<(.*)>$/;
 const TUPLE_TYPE_REGEX = /^\[(.*)]$/;
@@ -144,8 +146,25 @@ function findKnownWrapperCodec(typeName) {
     }
 }
 exports.findKnownWrapperCodec = findKnownWrapperCodec;
-function isKnownCodecType(path) {
+function checkKnownCodecType(path) {
     const joinedPath = Array.isArray(path) ? path.join('::') : path;
-    return KNOWN_PATHS.some((one) => joinedPath.match(one));
+    const knownPath = KNOWN_PATHS.find((one) => {
+        if (typeof one === 'string') {
+            return one === joinedPath;
+        }
+        else if (one instanceof RegExp) {
+            return one.test(joinedPath);
+        }
+        else {
+            return one.path === joinedPath;
+        }
+    });
+    if (!knownPath) {
+        return [false, ''];
+    }
+    if (typeof knownPath === 'string' || knownPath instanceof RegExp) {
+        return [true, joinedPath.split('::').at(-1)];
+    }
+    return [true, knownPath.codec];
 }
-exports.isKnownCodecType = isKnownCodecType;
+exports.checkKnownCodecType = checkKnownCodecType;

package/cjs/typink/generator/ConstructorQueryGen.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstructorQueryGen = void 0;
+const utils_js_1 = require("../../utils.js");
+const QueryGen_js_1 = require("./QueryGen.js");
+class ConstructorQueryGen extends QueryGen_js_1.QueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericConstructorQuery', 'GenericConstructorQueryCall', 'ConstructorCallOptions', 'ContractInstantiateResult');
+        const { constructors } = this.contractMetadata.spec;
+        const constructorsOut = this.doGenerate(constructors, 'ConstructorCallOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('typink/templates/constructor-query.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 `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ConstructorCallOptions) => Promise<ContractInstantiateResult<ChainApi>>>`;
+    }
+}
+exports.ConstructorQueryGen = ConstructorQueryGen;

package/cjs/typink/generator/ConstructorTxGen.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstructorTxGen = void 0;
+const utils_js_1 = require("../../utils.js");
+const QueryGen_js_1 = require("./QueryGen.js");
+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', 'GenericInstantiateSubmittableExtrinsic');
+        const { constructors } = this.contractMetadata.spec;
+        const constructorsOut = this.doGenerate(constructors, 'ConstructorTxOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        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>>`;
+    }
+}
+exports.ConstructorTxGen = ConstructorTxGen;

package/cjs/typink/generator/IndexGen.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexGen = void 0;
+const utils_1 = require("@dedot/utils");
+const index_js_1 = require("../../shared/index.js");
+const utils_js_1 = require("../../utils.js");
+const SUFFIX = 'contract_api';
+class IndexGen {
+    contractMetadata;
+    constructor(contractMetadata) {
+        this.contractMetadata = contractMetadata;
+    }
+    generate(useSubPaths = false) {
+        const contractName = (0, utils_1.stringPascalCase)(`${this.contractMetadata.contract.name}_${SUFFIX}`);
+        const typeImports = new index_js_1.TypeImports();
+        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
+        typeImports.addContractType('GenericContractApi');
+        typeImports.addChainType('SubstrateApi');
+        const importTypes = typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('typink/templates/index.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ contractName, importTypes }));
+    }
+}
+exports.IndexGen = IndexGen;