@dedot/codegen 0.0.1-next.c3d95ac1.3 → 0.0.1-next.cb041b89.17

package/cjs/{templates → chaintypes/templates}/types.hbs

@@ -1,4 +1,4 @@
-// Generated by @dedot/codegen
+// Generated by dedot cli
 
 {{{ importTypes }}}
 

package/cjs/index.js

@@ -10,67 +10,9 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+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 });
-exports.generateTypes = exports.generateTypesFromEndpoint = void 0;
-const dedot_1 = require("dedot");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const index_js_1 = require("./generator/index.js");
-const utils_1 = require("@dedot/utils");
-async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts') {
-    const api = await dedot_1.Dedot.new(endpoint);
-    const { methods } = await api.rpc.rpc_methods();
-    const apis = api.runtimeVersion.apis || {};
-    if (!chain) {
-        chain = (0, utils_1.stringCamelCase)(api.runtimeVersion.specName || api.runtimeChain || 'local');
-    }
-    await generateTypes(chain, api.metadata.latest, methods, apis, outDir, extension);
-    await api.disconnect();
-}
-exports.generateTypesFromEndpoint = generateTypesFromEndpoint;
-async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir = '.', extension = 'd.ts') {
-    const dirPath = path.resolve(outDir, chain);
-    const defTypesFileName = path.join(dirPath, `types.${extension}`);
-    const constsTypesFileName = path.join(dirPath, `consts.${extension}`);
-    const queryTypesFileName = path.join(dirPath, `query.${extension}`);
-    const jsonRpcFileName = path.join(dirPath, `json-rpc.${extension}`);
-    const indexFileName = path.join(dirPath, `index.${extension}`);
-    const errorsFileName = path.join(dirPath, `errors.${extension}`);
-    const eventsFileName = path.join(dirPath, `events.${extension}`);
-    const runtimeApisFileName = path.join(dirPath, `runtime.${extension}`);
-    const txFileName = path.join(dirPath, `tx.${extension}`);
-    if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-    }
-    const typesGen = new index_js_1.TypesGen(metadata);
-    const constsGen = new index_js_1.ConstsGen(typesGen);
-    const queryGen = new index_js_1.QueryGen(typesGen);
-    const jsonRpcGen = new index_js_1.JsonRpcGen(typesGen, rpcMethods);
-    const indexGen = new index_js_1.IndexGen(chain);
-    const errorsGen = new index_js_1.ErrorsGen(typesGen);
-    const eventsGen = new index_js_1.EventsGen(typesGen);
-    const runtimeApisGen = new index_js_1.RuntimeApisGen(typesGen, runtimeApis);
-    const txGen = new index_js_1.TxGen(typesGen);
-    fs.writeFileSync(defTypesFileName, await typesGen.generate());
-    fs.writeFileSync(errorsFileName, await errorsGen.generate());
-    fs.writeFileSync(eventsFileName, await eventsGen.generate());
-    fs.writeFileSync(jsonRpcFileName, await jsonRpcGen.generate());
-    fs.writeFileSync(queryTypesFileName, await queryGen.generate());
-    fs.writeFileSync(constsTypesFileName, await constsGen.generate());
-    fs.writeFileSync(txFileName, await txGen.generate());
-    fs.writeFileSync(indexFileName, await indexGen.generate());
-    fs.writeFileSync(runtimeApisFileName, await runtimeApisGen.generate());
-}
-exports.generateTypes = generateTypes;
+__exportStar(require("./chaintypes/index.js"), exports);
+__exportStar(require("./typink/index.js"), exports);

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

@@ -1,68 +1,93 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypesGen = exports.BASIC_KNOWN_TYPES = void 0;
-const codecs_1 = require("@dedot/codecs");
+exports.BaseTypesGen = exports.BASIC_KNOWN_TYPES = void 0;
 const utils_1 = require("@dedot/utils");
-const utils_js_1 = require("./utils.js");
+const utils_js_1 = require("../utils.js");
 const TypeImports_js_1 = require("./TypeImports.js");
 const known_codecs_js_1 = require("./known-codecs.js");
-// 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',
-];
 // 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();
+    skipTypes;
+    constructor(types) {
+        this.types = types;
+        this.includedTypes = {};
         this.typeImports = new TypeImports_js_1.TypeImports();
-    }
-    generate() {
-        this.clearCache();
-        let defTypeOut = '';
-        Object.values(this.includedTypes)
-            .filter(({ skip, knownType }) => !(skip || knownType))
-            .forEach(({ name, nameOut, id, docs }) => {
-            defTypeOut += `${(0, utils_js_1.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_js_1.compileTemplate)('types.hbs');
-        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
+        this.skipTypes = [];
     }
     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];
@@ -93,7 +118,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)}`);
         }
@@ -170,7 +195,7 @@ 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}'`,
@@ -200,7 +225,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';
                 }
@@ -230,98 +255,20 @@ class TypesGen {
     #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_js_1.isKnownCodecType)(joinedPath)) {
-                const codecType = (0, known_codecs_js_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, 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}`;
@@ -334,9 +281,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;
@@ -379,14 +325,13 @@ 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, utils_1.stringPascalCase)(diffType.path.at(-1));
             }
@@ -426,5 +371,8 @@ class TypesGen {
         }
         this.typeImports.addOutType(typeName);
     }
+    getEnumOptions(_typeId) {
+        return { tagKey: 'tag', valueKey: 'value' };
+    }
 }
-exports.TypesGen = TypesGen;
+exports.BaseTypesGen = BaseTypesGen;

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

@@ -8,29 +8,41 @@ class TypeImports {
     codecTypes;
     // Known types that're not codecs or chain/portable types defined in @dedot/types
     knownTypes;
-    specTypes;
+    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.specTypes = 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.specTypes.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.specTypes, '@dedot/specs'],
-            [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/contracts'],
             [this.portableTypes, './types'],
         ];
         return toImports
@@ -54,11 +66,17 @@ class TypeImports {
     addKnownType(...types) {
         types.forEach((one) => this.knownTypes.add(one));
     }
-    addSpecType(...types) {
-        types.forEach((one) => this.specTypes.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/shared/index.js

@@ -0,0 +1,19 @@
+"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("./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', 'ConstructorResult');
+        const { constructors } = this.contractMetadata.spec;
+        const constructorsOut = this.doGenerate(constructors);
+        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<ConstructorResult<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', 'GenericConstructorSubmittableExtrinsic');
+        const { constructors } = this.contractMetadata.spec;
+        const constructorsOut = this.doGenerate(constructors);
+        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) => GenericConstructorSubmittableExtrinsic<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');
+        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;