@dedot/codegen 0.0.1-next.41a5fa17.16 → 0.0.1-next.49d80ab2.3

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

@@ -1,66 +1,93 @@
-import { PortableRegistry } from '@dedot/codecs';
 import { normalizeName, stringPascalCase } from '@dedot/utils';
-import { isNativeType, beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
-import { knownTypes } from './known-types.js';
+import { commentBlock, isNativeType, WRAPPER_TYPE_REGEX } from '../utils.js';
 import { TypeImports } from './TypeImports.js';
-import { findKnownCodec, findKnownCodecType, isKnownCodecType } from './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',
-];
+import { checkKnownCodecType, findKnownCodec, findKnownCodecType } from './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'];
 export const BASIC_KNOWN_TYPES = ['BitSequence', 'Bytes', 'BytesLike', 'FixedBytes', 'FixedArray', 'Result'];
-const WRAPPER_TYPE_REGEX = /^(\w+)(<.*>)$/g;
-export class TypesGen {
-    metadata;
-    /**
-     * Types will be generated its definition out.
-     */
+export class BaseTypesGen {
+    types;
     includedTypes;
-    registry;
     typeImports;
-    constructor(metadata) {
-        this.metadata = metadata;
-        this.registry = new PortableRegistry(this.metadata);
-        this.includedTypes = this.#includedTypes();
+    skipTypes;
+    constructor(types) {
+        this.types = types;
+        this.includedTypes = {};
         this.typeImports = new TypeImports();
+        this.skipTypes = [];
     }
-    generate() {
-        this.clearCache();
-        let defTypeOut = '';
-        Object.values(this.includedTypes)
-            .filter(({ skip, knownType }) => !(skip || knownType))
-            .forEach(({ name, nameOut, id, docs }) => {
-            defTypeOut += `${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 = compileTemplate('types.hbs');
-        return 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] = checkKnownCodecType(joinedPath);
+            if (isKnownCodecType) {
+                const codecType = 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];
@@ -91,13 +118,13 @@ export 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)}`);
         }
-        const { type, path, docs } = def;
-        const { tag, value } = type;
-        switch (tag) {
+        const { typeDef, path, docs } = def;
+        const { type, value } = typeDef;
+        switch (type) {
             case 'Primitive':
                 const $codec = findKnownCodec(value.kind);
                 if ($codec.nativeType) {
@@ -168,14 +195,14 @@ export 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}'`,
+                        type: `${tagKey}: '${keyName}'`,
                         value: valueType ? `, ${valueKey}${this.#isOptionalType(valueType) ? '?' : ''}: ${valueType} ` : '',
                         docs,
                     }))
-                        .map(({ tag, value, docs }) => `${commentBlock(docs)}{ ${tag}${value} }`)
+                        .map(({ type, value, docs }) => `${commentBlock(docs)}{ ${type}${value} }`)
                         .join(' | ');
                 }
             }
@@ -197,9 +224,9 @@ export class TypesGen {
                 return this.generateType(value.typeParam, nestedLevel + 1, typeOut);
             case 'Sequence':
             case 'SizedVec': {
-                const fixedSize = tag === 'SizedVec' ? `${value.len}` : null;
-                const $innerType = this.metadata.types[value.typeParam].type;
-                if ($innerType.tag === 'Primitive' && $innerType.value.kind === 'u8') {
+                const fixedSize = type === 'SizedVec' ? `${value.len}` : null;
+                const $innerType = this.types[value.typeParam].typeDef;
+                if ($innerType.type === 'Primitive' && $innerType.value.kind === 'u8') {
                     return fixedSize ? `FixedBytes<${fixedSize}>` : typeOut ? 'Bytes' : 'BytesLike';
                 }
                 else {
@@ -208,7 +235,7 @@ export class TypesGen {
                 }
             }
             default:
-                throw new Error(`Invalid type! ${tag}`);
+                throw new Error(`Invalid type! ${type}`);
         }
     }
     generateObjectType(fields, nestedLevel = 0, typeOut = false) {
@@ -228,69 +255,6 @@ export 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 (isKnownCodecType(joinedPath)) {
-                const codecType = 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);
@@ -299,27 +263,12 @@ export class TypesGen {
             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) => 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}`;
@@ -332,36 +281,36 @@ export 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;
-        const { type: defB, params: paramsB } = typeB;
+        const { typeDef: defA, params: paramsA } = typeA;
+        const { typeDef: defB, params: paramsB } = typeB;
         if (!this.#eqlArray(paramsA, paramsB, (valA, valB) => this.#eqlTypeParam(valA, valB))) {
             return false;
         }
-        if (defA.tag !== defB.tag)
+        if (defA.type !== defB.type)
             return false;
-        if (defA.tag === 'BitSequence')
+        if (defA.type === 'BitSequence')
             return true;
-        if (defA.tag === 'Primitive' && defB.tag === 'Primitive') {
+        if (defA.type === 'Primitive' && defB.type === 'Primitive') {
             return defA.value.kind === defB.value.kind;
         }
-        if ((defA.tag === 'Compact' && defB.tag === 'Compact') || (defA.tag === 'Sequence' && defB.tag === 'Sequence')) {
+        if ((defA.type === 'Compact' && defB.type === 'Compact') ||
+            (defA.type === 'Sequence' && defB.type === 'Sequence')) {
             return this.typeEql(defA.value.typeParam, defB.value.typeParam, lvl + 1);
         }
-        if (defA.tag === 'SizedVec' && defB.tag === 'SizedVec') {
+        if (defA.type === 'SizedVec' && defB.type === 'SizedVec') {
             return defA.value.len === defB.value.len && this.typeEql(defA.value.typeParam, defB.value.typeParam, lvl + 1);
         }
-        if (defA.tag === 'Tuple' && defB.tag === 'Tuple') {
+        if (defA.type === 'Tuple' && defB.type === 'Tuple') {
             return this.#eqlArray(defA.value.fields, defB.value.fields, (val1, val2) => this.typeEql(val1, val2, lvl + 1));
         }
-        if (defA.tag === 'Struct' && defB.tag === 'Struct') {
+        if (defA.type === 'Struct' && defB.type === 'Struct') {
             return this.#eqlFields(defA.value.fields, defB.value.fields, lvl);
         }
-        if (defA.tag === 'Enum' && defB.tag === 'Enum') {
+        if (defA.type === 'Enum' && defB.type === 'Enum') {
             return this.#eqlArray(defA.value.members, defB.value.members, (val1, val2) => val1.name === val2.name && val1.index === val2.index && this.#eqlFields(val1.fields, val2.fields, lvl));
         }
         return false;
@@ -377,19 +326,18 @@ export 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 stringPascalCase(diffType.path.at(-1));
             }
-            else if (diffType.type.tag === 'Primitive') {
-                return stringPascalCase(diffType.type.value.kind);
+            else if (diffType.typeDef.type === 'Primitive') {
+                return stringPascalCase(diffType.typeDef.value.kind);
             }
         }
         // Last resort!
@@ -422,11 +370,9 @@ export class TypesGen {
             this.typeImports.addCodecType(typeName);
             return;
         }
-        if (knownTypes.includes(typeName)) {
-            this.typeImports.addKnownType(typeName);
-        }
-        else {
-            this.typeImports.addOutType(typeName);
-        }
+        this.typeImports.addOutType(typeName);
+    }
+    getEnumOptions(_typeId) {
+        return { tagKey: 'type', valueKey: 'value' };
     }
 }

package/{generator → shared}/TypeImports.d.ts

@@ -1,14 +1,25 @@
+type ImportConfig = {
+    excludeModules?: string[];
+    useSubPaths?: boolean;
+};
 export declare class TypeImports {
     #private;
     portableTypes: Set<string>;
     codecTypes: Set<string>;
     knownTypes: Set<string>;
+    knownJsonRpcTypes: Set<string>;
     outTypes: Set<string>;
+    contractTypes: Set<string>;
+    chainTypes: Set<string>;
     constructor();
     clear(): void;
-    toImports(...excludeModules: string[]): string;
+    toImports(config?: ImportConfig): string;
     addPortableType(...types: string[]): void;
     addCodecType(...types: string[]): void;
     addKnownType(...types: string[]): void;
+    addKnownJsonRpcType(...types: string[]): void;
     addOutType(...types: string[]): void;
+    addContractType(...types: string[]): void;
+    addChainType(...types: string[]): void;
 }
+export {};

package/{generator → shared}/TypeImports.js

@@ -5,30 +5,47 @@ export 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) {
@@ -46,7 +63,16 @@ export 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));
+    }
 }

package/shared/index.d.ts

@@ -0,0 +1,3 @@
+export * from './BaseTypesGen.js';
+export * from './known-codecs.js';
+export * from './TypeImports.js';

package/shared/index.js

@@ -0,0 +1,3 @@
+export * from './BaseTypesGen.js';
+export * from './known-codecs.js';
+export * from './TypeImports.js';

package/{generator → shared}/known-codecs.d.ts

@@ -20,4 +20,4 @@ export declare const looseTypeCodecs: Record<string, AnyShape>;
 export declare function findKnownCodecType(name: string): CodecType;
 export declare function findKnownCodec<I = unknown, O = I>(typeName: string): $.Shape<I, O>;
 export declare function findKnownWrapperCodec(typeName: string): $.AnyShape | undefined;
-export declare function isKnownCodecType(path: string | string[]): boolean;
+export declare function checkKnownCodecType(path: string | string[]): [boolean, string];

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

@@ -1,6 +1,6 @@
-import * as $ from '@dedot/shape';
 import * as Codecs from '@dedot/codecs';
 import { $AccountId20, $AccountId32, $Bytes, $ConsensusEngineId, $Era, $EthereumAddress, $MultiAddress, $OpaqueExtrinsic, $PrefixedStorageKey, $RawBytes, $StorageData, $StorageKey, $UncheckedExtrinsic, } from '@dedot/codecs';
+import * as $ from '@dedot/shape';
 import { assert } from '@dedot/utils';
 export const normalizeCodecName = (name) => {
     return name.startsWith('$') ? name : `$${name}`;
@@ -30,6 +30,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 = /^\[(.*)]$/;
@@ -114,7 +116,24 @@ export function findKnownWrapperCodec(typeName) {
         return $.Tuple(...$inner);
     }
 }
-export function isKnownCodecType(path) {
+export 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];
 }

package/typink/generator/ConstructorQueryGen.d.ts

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

package/typink/generator/ConstructorQueryGen.js

@@ -0,0 +1,20 @@
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+import { QueryGen } from './QueryGen.js';
+export class ConstructorQueryGen extends 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 = compileTemplate('typink/templates/constructor-query.hbs');
+        return 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>>>`;
+    }
+}

package/typink/generator/ConstructorTxGen.d.ts

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

package/typink/generator/ConstructorTxGen.js

@@ -0,0 +1,20 @@
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+import { QueryGen } from './QueryGen.js';
+export class ConstructorTxGen extends 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 = compileTemplate('typink/templates/constructor-tx.hbs');
+        return 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>>`;
+    }
+}

package/typink/generator/IndexGen.d.ts

@@ -0,0 +1,6 @@
+import { ContractMetadata } from '@dedot/contracts';
+export declare class IndexGen {
+    contractMetadata: ContractMetadata;
+    constructor(contractMetadata: ContractMetadata);
+    generate(useSubPaths?: boolean): Promise<string>;
+}

package/typink/generator/IndexGen.js

@@ -0,0 +1,20 @@
+import { stringPascalCase } from '@dedot/utils';
+import { TypeImports } from '../../shared/index.js';
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+const SUFFIX = 'contract_api';
+export class IndexGen {
+    contractMetadata;
+    constructor(contractMetadata) {
+        this.contractMetadata = contractMetadata;
+    }
+    generate(useSubPaths = false) {
+        const contractName = stringPascalCase(`${this.contractMetadata.contract.name}_${SUFFIX}`);
+        const typeImports = new TypeImports();
+        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
+        typeImports.addContractType('GenericContractApi');
+        typeImports.addChainType('SubstrateApi');
+        const importTypes = typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('typink/templates/index.hbs');
+        return beautifySourceCode(template({ contractName, importTypes }));
+    }
+}

package/typink/generator/QueryGen.d.ts

@@ -0,0 +1,12 @@
+import { ContractMetadata, ContractMessage, ContractMessageArg } from '@dedot/contracts';
+import { TypesGen } from './TypesGen.js';
+export declare class QueryGen {
+    contractMetadata: ContractMetadata;
+    typesGen: TypesGen;
+    constructor(contractMetadata: ContractMetadata, typeGen: TypesGen);
+    generate(useSubPaths?: boolean): Promise<string>;
+    doGenerate(messages: ContractMessage[], optionsTypeName?: string): string;
+    generateMethodDef(def: ContractMessage): string;
+    generateParamsOut(args: ContractMessageArg[]): string;
+    importType(typeId: number): any;
+}