@dedot/codegen 0.0.1-next.cfee875e.21 → 0.0.1-next.d731b849.13

package/chaintypes/generator/ApiGen.d.ts

@@ -10,13 +10,13 @@ export declare abstract class ApiGen {
                 name: string;
                 typeId: number | undefined;
             }[];
-            type: {
-                tag: "Struct";
+            typeDef: {
+                type: "Struct";
                 value: {
                     fields: import("@dedot/codecs").Field[];
                 };
             } | {
-                tag: "Enum";
+                type: "Enum";
                 value: {
                     members: {
                         name: string;
@@ -26,33 +26,33 @@ export declare abstract class ApiGen {
                     }[];
                 };
             } | {
-                tag: "Sequence";
+                type: "Sequence";
                 value: {
                     typeParam: number;
                 };
             } | {
-                tag: "SizedVec";
+                type: "SizedVec";
                 value: {
                     len: number;
                     typeParam: number;
                 };
             } | {
-                tag: "Tuple";
+                type: "Tuple";
                 value: {
                     fields: number[];
                 };
             } | {
-                tag: "Primitive";
+                type: "Primitive";
                 value: {
                     kind: "bool" | "u8" | "i8" | "u16" | "i16" | "u32" | "i32" | "u64" | "i64" | "u128" | "i128" | "u256" | "i256" | "str" | "char";
                 };
             } | {
-                tag: "Compact";
+                type: "Compact";
                 value: {
                     typeParam: number;
                 };
             } | {
-                tag: "BitSequence";
+                type: "BitSequence";
                 value: {
                     bitOrderType: number;
                     bitStoreType: number;
@@ -67,13 +67,13 @@ export declare abstract class ApiGen {
                 entries: {
                     name: string;
                     modifier: string;
-                    type: {
-                        tag: "Plain";
+                    storageType: {
+                        type: "Plain";
                         value: {
                             valueTypeId: number;
                         };
                     } | {
-                        tag: "Map";
+                        type: "Map";
                         value: {
                             hashers: ("identity" | "blake2_128" | "blake2_256" | "blake2_128Concat" | "twox128" | "twox256" | "twox64Concat")[];
                             keyTypeId: number;

package/chaintypes/generator/ErrorsGen.js

@@ -29,8 +29,8 @@ export class ErrorsGen extends ApiGen {
     #getErrorDefs(errorTypeId) {
         const def = this.metadata.types[errorTypeId];
         assert(def, `Error def not found for id ${errorTypeId}`);
-        const { tag, value } = def.type;
-        assert(tag === 'Enum', `Invalid pallet error type!`);
+        const { type, value } = def.typeDef;
+        assert(type === 'Enum', 'Invalid pallet error type!');
         return value.members;
     }
 }

package/chaintypes/generator/EventsGen.js

@@ -41,8 +41,8 @@ export class EventsGen extends ApiGen {
     #getEventDefs(typeId) {
         const def = this.metadata.types[typeId];
         assert(def, `Event def not found for id ${typeId}`);
-        const { tag, value } = def.type;
-        assert(tag === 'Enum', 'Invalid pallet event type!');
+        const { type, value } = def.typeDef;
+        assert(type === 'Enum', 'Invalid pallet event type!');
         return value.members;
     }
     #generateMemberDefType(fields) {

package/chaintypes/generator/QueryGen.js

@@ -32,15 +32,15 @@ export class QueryGen extends ApiGen {
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
     #generateEntry(entry) {
-        const { name, type, docs, modifier } = entry;
+        const { name, storageType, docs, modifier } = entry;
         let valueType, keyTypeOut, keyTypeIn;
-        if (type.tag === 'Plain') {
-            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
+        if (storageType.type === 'Plain') {
+            valueType = this.typesGen.generateType(storageType.value.valueTypeId, 1, true);
         }
-        else if (type.tag === 'Map') {
-            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
-            keyTypeOut = this.typesGen.generateType(type.value.keyTypeId, 1, true);
-            keyTypeIn = this.typesGen.generateType(type.value.keyTypeId, 1);
+        else if (storageType.type === 'Map') {
+            valueType = this.typesGen.generateType(storageType.value.valueTypeId, 1, true);
+            keyTypeOut = this.typesGen.generateType(storageType.value.keyTypeId, 1, true);
+            keyTypeIn = this.typesGen.generateType(storageType.value.keyTypeId, 1);
         }
         else {
             throw Error('Invalid entry type!');

package/chaintypes/generator/TxGen.js

@@ -5,7 +5,7 @@ export class TxGen extends ApiGen {
     generate(useSubPaths = false) {
         const { pallets, types } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainTx', 'GenericTxCall', 'ISubmittableExtrinsic', 'ISubmittableResult', 'IRuntimeTxCall', 'RpcVersion', 'RpcV2', 'ISubmittableExtrinsicLegacy', 'TransactionStatusLegacy', 'TransactionStatusV2');
+        this.typesGen.typeImports.addKnownType('GenericChainTx', 'GenericTxCall', 'ISubmittableExtrinsic', 'ISubmittableResult', 'IRuntimeTxCall', 'RpcVersion', 'RpcV2', 'ISubmittableExtrinsicLegacy');
         const { callTypeId, addressTypeId, signatureTypeId } = this.metadata.extrinsic;
         const callTypeIn = this.typesGen.generateType(callTypeId, 1);
         const addressTypeIn = this.typesGen.generateType(addressTypeId, 1);
@@ -17,11 +17,11 @@ export class TxGen extends ApiGen {
         for (let pallet of pallets) {
             if (pallet.calls === undefined)
                 continue;
-            const { type } = types[pallet.calls];
-            if (type.tag !== 'Enum')
+            const { typeDef } = types[pallet.calls];
+            if (typeDef.type !== 'Enum')
                 continue;
-            const isFlatEnum = type.value.members.every((m) => m.fields.length === 0);
-            const typedTxs = type.value.members
+            const isFlatEnum = typeDef.value.members.every((m) => m.fields.length === 0);
+            const typedTxs = typeDef.value.members
                 .map((one) => ({
                 functionName: stringCamelCase(one.name),
                 params: one.fields.map((f) => ({
@@ -53,8 +53,8 @@ export class TxGen extends ApiGen {
     export type ChainSubmittableExtrinsic<Rv extends RpcVersion, T extends IRuntimeTxCall = ${callTypeIn}> = 
         Extrinsic<${addressTypeIn}, T, ${signatureTypeIn}, any[]> &
         (Rv extends RpcV2
-          ? ISubmittableExtrinsic<ISubmittableResult<FrameSystemEventRecord, TransactionStatusV2>>
-          : ISubmittableExtrinsicLegacy<ISubmittableResult<FrameSystemEventRecord, TransactionStatusLegacy>>)
+          ? ISubmittableExtrinsic<ISubmittableResult<FrameSystemEventRecord>>
+          : ISubmittableExtrinsicLegacy<ISubmittableResult<FrameSystemEventRecord>>)
         
     export type TxCall<Rv extends RpcVersion> = (...args: any[]) => ChainSubmittableExtrinsic<Rv>;    
 `;

package/chaintypes/generator/TypesGen.js

@@ -46,7 +46,7 @@ export class TypesGen extends BaseTypesGen {
     }
     shouldGenerateTypeIn(id) {
         const { callTypeId } = this.metadata.extrinsic;
-        const palletCallTypeIds = this.registry.getPalletCallTypeIds();
+        const palletCallTypeIds = this.registry.getFieldTypeIdsFromEnum(callTypeId);
         return callTypeId === id || palletCallTypeIds.includes(id);
     }
     getEnumOptions(typeId) {

package/cjs/chaintypes/generator/ErrorsGen.js

@@ -32,8 +32,8 @@ class ErrorsGen extends ApiGen_js_1.ApiGen {
     #getErrorDefs(errorTypeId) {
         const def = this.metadata.types[errorTypeId];
         (0, utils_1.assert)(def, `Error def not found for id ${errorTypeId}`);
-        const { tag, value } = def.type;
-        (0, utils_1.assert)(tag === 'Enum', `Invalid pallet error type!`);
+        const { type, value } = def.typeDef;
+        (0, utils_1.assert)(type === 'Enum', 'Invalid pallet error type!');
         return value.members;
     }
 }

package/cjs/chaintypes/generator/EventsGen.js

@@ -44,8 +44,8 @@ class EventsGen extends ApiGen_js_1.ApiGen {
     #getEventDefs(typeId) {
         const def = this.metadata.types[typeId];
         (0, utils_1.assert)(def, `Event def not found for id ${typeId}`);
-        const { tag, value } = def.type;
-        (0, utils_1.assert)(tag === 'Enum', 'Invalid pallet event type!');
+        const { type, value } = def.typeDef;
+        (0, utils_1.assert)(type === 'Enum', 'Invalid pallet event type!');
         return value.members;
     }
     #generateMemberDefType(fields) {

package/cjs/chaintypes/generator/QueryGen.js

@@ -35,15 +35,15 @@ class QueryGen extends ApiGen_js_1.ApiGen {
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
     #generateEntry(entry) {
-        const { name, type, docs, modifier } = entry;
+        const { name, storageType, docs, modifier } = entry;
         let valueType, keyTypeOut, keyTypeIn;
-        if (type.tag === 'Plain') {
-            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
+        if (storageType.type === 'Plain') {
+            valueType = this.typesGen.generateType(storageType.value.valueTypeId, 1, true);
         }
-        else if (type.tag === 'Map') {
-            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
-            keyTypeOut = this.typesGen.generateType(type.value.keyTypeId, 1, true);
-            keyTypeIn = this.typesGen.generateType(type.value.keyTypeId, 1);
+        else if (storageType.type === 'Map') {
+            valueType = this.typesGen.generateType(storageType.value.valueTypeId, 1, true);
+            keyTypeOut = this.typesGen.generateType(storageType.value.keyTypeId, 1, true);
+            keyTypeIn = this.typesGen.generateType(storageType.value.keyTypeId, 1);
         }
         else {
             throw Error('Invalid entry type!');

package/cjs/chaintypes/generator/TxGen.js

@@ -8,7 +8,7 @@ class TxGen extends index_js_1.ApiGen {
     generate(useSubPaths = false) {
         const { pallets, types } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainTx', 'GenericTxCall', 'ISubmittableExtrinsic', 'ISubmittableResult', 'IRuntimeTxCall', 'RpcVersion', 'RpcV2', 'ISubmittableExtrinsicLegacy', 'TransactionStatusLegacy', 'TransactionStatusV2');
+        this.typesGen.typeImports.addKnownType('GenericChainTx', 'GenericTxCall', 'ISubmittableExtrinsic', 'ISubmittableResult', 'IRuntimeTxCall', 'RpcVersion', 'RpcV2', 'ISubmittableExtrinsicLegacy');
         const { callTypeId, addressTypeId, signatureTypeId } = this.metadata.extrinsic;
         const callTypeIn = this.typesGen.generateType(callTypeId, 1);
         const addressTypeIn = this.typesGen.generateType(addressTypeId, 1);
@@ -20,11 +20,11 @@ class TxGen extends index_js_1.ApiGen {
         for (let pallet of pallets) {
             if (pallet.calls === undefined)
                 continue;
-            const { type } = types[pallet.calls];
-            if (type.tag !== 'Enum')
+            const { typeDef } = types[pallet.calls];
+            if (typeDef.type !== 'Enum')
                 continue;
-            const isFlatEnum = type.value.members.every((m) => m.fields.length === 0);
-            const typedTxs = type.value.members
+            const isFlatEnum = typeDef.value.members.every((m) => m.fields.length === 0);
+            const typedTxs = typeDef.value.members
                 .map((one) => ({
                 functionName: (0, utils_1.stringCamelCase)(one.name),
                 params: one.fields.map((f) => ({
@@ -56,8 +56,8 @@ class TxGen extends index_js_1.ApiGen {
     export type ChainSubmittableExtrinsic<Rv extends RpcVersion, T extends IRuntimeTxCall = ${callTypeIn}> = 
         Extrinsic<${addressTypeIn}, T, ${signatureTypeIn}, any[]> &
         (Rv extends RpcV2
-          ? ISubmittableExtrinsic<ISubmittableResult<FrameSystemEventRecord, TransactionStatusV2>>
-          : ISubmittableExtrinsicLegacy<ISubmittableResult<FrameSystemEventRecord, TransactionStatusLegacy>>)
+          ? ISubmittableExtrinsic<ISubmittableResult<FrameSystemEventRecord>>
+          : ISubmittableExtrinsicLegacy<ISubmittableResult<FrameSystemEventRecord>>)
         
     export type TxCall<Rv extends RpcVersion> = (...args: any[]) => ChainSubmittableExtrinsic<Rv>;    
 `;

package/cjs/chaintypes/generator/TypesGen.js

@@ -49,7 +49,7 @@ class TypesGen extends index_js_1.BaseTypesGen {
     }
     shouldGenerateTypeIn(id) {
         const { callTypeId } = this.metadata.extrinsic;
-        const palletCallTypeIds = this.registry.getPalletCallTypeIds();
+        const palletCallTypeIds = this.registry.getFieldTypeIdsFromEnum(callTypeId);
         return callTypeId === id || palletCallTypeIds.includes(id);
     }
     getEnumOptions(typeId) {

package/cjs/shared/BaseTypesGen.js

@@ -20,6 +20,9 @@ class BaseTypesGen {
         this.typeImports = new TypeImports_js_1.TypeImports();
         this.skipTypes = [];
     }
+    shouldGenerateTypeIn(_id) {
+        return false;
+    }
     typeCache = {};
     clearCache() {
         this.typeCache = {};
@@ -122,9 +125,9 @@ class BaseTypesGen {
         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 = (0, known_codecs_js_1.findKnownCodec)(value.kind);
                 if ($codec.nativeType) {
@@ -198,11 +201,11 @@ class BaseTypesGen {
                     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 }) => `${(0, utils_js_1.commentBlock)(docs)}{ ${tag}${value} }`)
+                        .map(({ type, value, docs }) => `${(0, utils_js_1.commentBlock)(docs)}{ ${type}${value} }`)
                         .join(' | ');
                 }
             }
@@ -224,9 +227,9 @@ class BaseTypesGen {
                 return this.generateType(value.typeParam, nestedLevel + 1, typeOut);
             case 'Sequence':
             case 'SizedVec': {
-                const fixedSize = tag === 'SizedVec' ? `${value.len}` : null;
-                const $innerType = this.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 {
@@ -235,7 +238,7 @@ class BaseTypesGen {
                 }
             }
             default:
-                throw new Error(`Invalid type! ${tag}`);
+                throw new Error(`Invalid type! ${type}`);
         }
     }
     generateObjectType(fields, nestedLevel = 0, typeOut = false) {
@@ -285,31 +288,32 @@ class BaseTypesGen {
         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;
@@ -335,8 +339,8 @@ class BaseTypesGen {
             if (diffType.path.length > 0) {
                 return (0, utils_1.stringPascalCase)(diffType.path.at(-1));
             }
-            else if (diffType.type.tag === 'Primitive') {
-                return (0, utils_1.stringPascalCase)(diffType.type.value.kind);
+            else if (diffType.typeDef.type === 'Primitive') {
+                return (0, utils_1.stringPascalCase)(diffType.typeDef.value.kind);
             }
         }
         // Last resort!
@@ -372,7 +376,7 @@ class BaseTypesGen {
         this.typeImports.addOutType(typeName);
     }
     getEnumOptions(_typeId) {
-        return { tagKey: 'tag', valueKey: 'value' };
+        return { tagKey: 'type', valueKey: 'value' };
     }
 }
 exports.BaseTypesGen = BaseTypesGen;

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', 'ConstructorCallOptions', 'ContractInstantiateResult');
+        this.typesGen.typeImports.addContractType('GenericConstructorQuery', 'GenericConstructorQueryCall', 'GenericConstructorCallResult', 'ConstructorCallOptions', 'ContractInstantiateResult');
         const { constructors } = this.contractMetadata.spec;
         const constructorsOut = this.doGenerate(constructors, 'ConstructorCallOptions');
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
@@ -15,10 +15,13 @@ class ConstructorQueryGen extends QueryGen_js_1.QueryGen {
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, constructorsOut }));
     }
     generateMethodDef(def) {
-        const { args } = def;
+        const { args, returnType } = def;
         args.forEach(({ type: { type } }) => this.importType(type));
         const paramsOut = this.generateParamsOut(args);
-        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ConstructorCallOptions) => Promise<ContractInstantiateResult<ChainApi>>>`;
+        const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
+        // Unwrap langError result
+        const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
+        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult<ChainApi>>>>`;
     }
 }
 exports.ConstructorQueryGen = ConstructorQueryGen;

package/cjs/typink/generator/EventsGen.js

@@ -0,0 +1,35 @@
+"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");
+const QueryGen_js_1 = require("./QueryGen.js");
+class EventsGen extends QueryGen_js_1.QueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addContractType('GenericContractEvents', 'GenericContractEvent');
+        const { events } = this.contractMetadata.spec;
+        let eventsOut = '';
+        events.forEach((event) => {
+            const { docs, label } = event;
+            const isV5 = 'signature_topic' in event;
+            eventsOut += `${(0, utils_js_1.commentBlock)(docs, '\n', isV5 ? event.signature_topic ? `@signature_topic: ${event.signature_topic}` : '- Anonymous event' : '')}`;
+            eventsOut += `${(0, utils_1.stringPascalCase)(label)}: ${this.#generateEventDef(event)};\n\n`;
+        });
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('typink/templates/events.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, eventsOut }));
+    }
+    #generateEventDef(event) {
+        const { args, label } = event;
+        args.forEach(({ type: { type } }) => this.importType(type));
+        const paramsOut = this.generateParamsOut(args);
+        return `GenericContractEvent<'${(0, utils_1.stringPascalCase)(label)}', {${paramsOut}}>`;
+    }
+    generateParamsOut(args) {
+        return args
+            .map(({ type: { type }, label, docs, indexed }) => `${(0, utils_js_1.commentBlock)(docs, '\n', `@indexed: ${indexed}`)}${(0, utils_1.stringCamelCase)(label)}: ${this.typesGen.generateType(type, 1)}`)
+            .join(', ');
+    }
+}
+exports.EventsGen = EventsGen;

package/cjs/typink/generator/IndexGen.js

@@ -7,18 +7,23 @@ const utils_js_1 = require("../../utils.js");
 const SUFFIX = 'contract_api';
 class IndexGen {
     contractMetadata;
-    constructor(contractMetadata) {
+    typesGen;
+    constructor(contractMetadata, typesGen) {
         this.contractMetadata = contractMetadata;
+        this.typesGen = typesGen;
     }
     generate(useSubPaths = false) {
         const contractName = (0, utils_1.stringPascalCase)(`${this.contractMetadata.contract.name}_${SUFFIX}`);
+        const langErrorId = this.contractMetadata.spec.lang_error.type;
+        const langErrorName = this.typesGen.cleanPath(this.contractMetadata.types[langErrorId].type.path);
         const typeImports = new index_js_1.TypeImports();
-        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion');
+        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
         typeImports.addContractType('GenericContractApi');
         typeImports.addChainType('SubstrateApi');
+        typeImports.addPortableType(langErrorName);
         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 }));
+        return (0, utils_js_1.beautifySourceCode)(template({ contractName, langErrorName, importTypes }));
     }
 }
 exports.IndexGen = IndexGen;

package/cjs/typink/generator/QueryGen.js

@@ -35,7 +35,9 @@ class QueryGen {
         this.importType(returnType.type);
         args.forEach(({ type: { type } }) => this.importType(type));
         const paramsOut = this.generateParamsOut(args);
-        const typeOut = this.typesGen.generateType(returnType.type, 0, true);
+        const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
+        // Unwrap langError result
+        const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
         return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>>`;
     }
     generateParamsOut(args) {
@@ -44,14 +46,14 @@ class QueryGen {
             .join(', ');
     }
     importType(typeId) {
-        const type = this.contractMetadata.types[typeId];
-        const def = (0, contracts_1.normalizeContractTypeDef)(this.contractMetadata.types[typeId].type.def);
-        if (this.typesGen.includedTypes[type.id]) {
-            this.typesGen.addTypeImport(this.typesGen.includedTypes[type.id].name);
+        const contractType = this.contractMetadata.types[typeId];
+        const typeDef = (0, contracts_1.normalizeContractTypeDef)(this.contractMetadata.types[typeId].type.def);
+        if (this.typesGen.includedTypes[contractType.id]) {
+            this.typesGen.addTypeImport(this.typesGen.includedTypes[contractType.id].name);
             return;
         }
-        const { tag, value } = def;
-        switch (tag) {
+        const { type, value } = typeDef;
+        switch (type) {
             case 'Compact':
             case 'Primitive':
             case 'BitSequence':

package/cjs/typink/generator/TypesGen.js

@@ -17,19 +17,12 @@ class TypesGen extends index_js_1.BaseTypesGen {
         let defTypeOut = '';
         Object.values(this.includedTypes)
             .filter(({ skip, knownType }) => !(skip || knownType))
-            .forEach(({ name, nameOut, id }) => {
+            .forEach(({ nameOut, id }) => {
             defTypeOut += `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({ excludeModules: ['./types'], useSubPaths });
         const template = (0, utils_js_1.compileTemplate)('typink/templates/types.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
-    shouldGenerateTypeIn(id) {
-        const { messages } = this.contractMetadata.spec;
-        return messages.some((message) => message.returnType.type === id);
-    }
 }
 exports.TypesGen = TypesGen;

package/cjs/typink/generator/index.js

@@ -20,3 +20,4 @@ __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/typink/index.js

@@ -17,6 +17,7 @@ async function generateContractTypes(metadata, contract, outDir = '.', 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 eventsTypesFile = path_1.default.join(dirPath, `events.${extension}`);
     const indexTypesFileName = path_1.default.join(dirPath, `index.${extension}`);
     if (!fs_1.default.existsSync(dirPath)) {
         fs_1.default.mkdirSync(dirPath, { recursive: true });
@@ -26,12 +27,14 @@ async function generateContractTypes(metadata, contract, outDir = '.', extension
     const txGen = new index_js_1.TxGen(contractMetadata, typesGen);
     const constructorTxGen = new index_js_1.ConstructorTxGen(contractMetadata, typesGen);
     const constructorQueryGen = new index_js_1.ConstructorQueryGen(contractMetadata, typesGen);
-    const indexGen = new index_js_1.IndexGen(contractMetadata);
+    const eventsGen = new index_js_1.EventsGen(contractMetadata, typesGen);
+    const indexGen = new index_js_1.IndexGen(contractMetadata, typesGen);
     fs_1.default.writeFileSync(typesFileName, await typesGen.generate(useSubPaths));
     fs_1.default.writeFileSync(queryTypesFileName, await queryGen.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(eventsTypesFile, await eventsGen.generate(useSubPaths));
     fs_1.default.writeFileSync(indexTypesFileName, await indexGen.generate(useSubPaths));
 }
 exports.generateContractTypes = generateContractTypes;

package/cjs/typink/templates/events.hbs

@@ -0,0 +1,8 @@
+// Generated by dedot cli
+
+import { GenericSubstrateApi } from '@dedot/types';
+{{{ importTypes }}}
+
+export interface ContractEvents<ChainApi extends GenericSubstrateApi> extends GenericContractEvents<ChainApi> {
+    {{{ eventsOut }}}
+}

package/cjs/typink/templates/index.hbs

@@ -5,10 +5,17 @@ import { ContractQuery } from './query';
 import { ContractTx } from './tx';
 import { ConstructorQuery } from './constructor-query';
 import { ConstructorTx } from './constructor-tx';
+import { ContractEvents } from './events'
 
-export interface {{{contractName}}}<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<ChainApi> {
-    query: ContractQuery<ChainApi[RpcVersion]>;
-    tx: ContractTx<ChainApi[RpcVersion]>;
-    constructorQuery: ConstructorQuery<ChainApi[RpcVersion]>;
-    constructorTx: ConstructorTx<ChainApi[RpcVersion]>;
+export interface {{{contractName}}}<Rv extends RpcVersion = RpcV2, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi> {
+    query: ContractQuery<ChainApi[Rv]>;
+    tx: ContractTx<ChainApi[Rv]>;
+    constructorQuery: ConstructorQuery<ChainApi[Rv]>;
+    constructorTx: ConstructorTx<ChainApi[Rv]>;
+    events: ContractEvents<ChainApi[Rv]>;
+
+    types: {
+      LangError: {{{langErrorName}}};
+      ChainApi: ChainApi[Rv];
+    };
 }

package/cjs/utils.js

@@ -36,7 +36,7 @@ exports.WRAPPER_TYPE_REGEX = /^(\w+)<(.*)>$/;
 exports.TUPLE_TYPE_REGEX = /^\[(.*)]$/;
 const commentBlock = (...docs) => {
     const flatLines = docs.flat();
-    if (flatLines.length === 0 || !flatLines.find((o) => !!o)) {
+    if (flatLines.length === 0 || !flatLines.some((o) => !!o)) {
         return '';
     }
     else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.0.1-next.cfee875e.21+cfee875",
+  "version": "0.0.1-next.d731b849.13+d731b84",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/codegen",
@@ -18,22 +18,22 @@
     "copy": "cp -R ./src/chaintypes/templates ./dist/chaintypes && cp -R ./src/chaintypes/templates ./dist/cjs/chaintypes && cp -R ./src/typink/templates ./dist/typink && cp -R ./src/typink/templates ./dist/cjs/typink"
   },
   "dependencies": {
-    "@dedot/api": "0.0.1-next.cfee875e.21+cfee875",
-    "@dedot/codecs": "0.0.1-next.cfee875e.21+cfee875",
-    "@dedot/providers": "0.0.1-next.cfee875e.21+cfee875",
-    "@dedot/runtime-specs": "0.0.1-next.cfee875e.21+cfee875",
-    "@dedot/shape": "0.0.1-next.cfee875e.21+cfee875",
-    "@dedot/types": "0.0.1-next.cfee875e.21+cfee875",
-    "@dedot/utils": "0.0.1-next.cfee875e.21+cfee875",
-    "handlebars": "^4.7.7",
-    "prettier": "^3.2.5"
+    "@dedot/api": "0.0.1-next.d731b849.13+d731b84",
+    "@dedot/codecs": "0.0.1-next.d731b849.13+d731b84",
+    "@dedot/providers": "0.0.1-next.d731b849.13+d731b84",
+    "@dedot/runtime-specs": "0.0.1-next.d731b849.13+d731b84",
+    "@dedot/shape": "0.0.1-next.d731b849.13+d731b84",
+    "@dedot/types": "0.0.1-next.d731b849.13+d731b84",
+    "@dedot/utils": "0.0.1-next.d731b849.13+d731b84",
+    "handlebars": "^4.7.8",
+    "prettier": "^3.3.3"
   },
   "publishConfig": {
     "access": "public",
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "cfee875eafba07e0fbb8a72556ca549a62ddceff",
+  "gitHead": "d731b849f66c92ca6fa69894e45792c49381d407",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/shared/BaseTypesGen.d.ts

@@ -16,7 +16,7 @@ export declare abstract class BaseTypesGen {
     typeImports: TypeImports;
     skipTypes: string[];
     protected constructor(types: PortableType[]);
-    abstract shouldGenerateTypeIn(id: TypeId): boolean;
+    shouldGenerateTypeIn(_id: TypeId): boolean;
     typeCache: Record<string, string>;
     clearCache(): void;
     includeTypes(): Record<TypeId, NamedType>;

package/shared/BaseTypesGen.js

@@ -17,6 +17,9 @@ export class BaseTypesGen {
         this.typeImports = new TypeImports();
         this.skipTypes = [];
     }
+    shouldGenerateTypeIn(_id) {
+        return false;
+    }
     typeCache = {};
     clearCache() {
         this.typeCache = {};
@@ -119,9 +122,9 @@ export class BaseTypesGen {
         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) {
@@ -195,11 +198,11 @@ export class BaseTypesGen {
                     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(' | ');
                 }
             }
@@ -221,9 +224,9 @@ export class BaseTypesGen {
                 return this.generateType(value.typeParam, nestedLevel + 1, typeOut);
             case 'Sequence':
             case 'SizedVec': {
-                const fixedSize = tag === 'SizedVec' ? `${value.len}` : null;
-                const $innerType = this.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 {
@@ -232,7 +235,7 @@ export class BaseTypesGen {
                 }
             }
             default:
-                throw new Error(`Invalid type! ${tag}`);
+                throw new Error(`Invalid type! ${type}`);
         }
     }
     generateObjectType(fields, nestedLevel = 0, typeOut = false) {
@@ -282,31 +285,32 @@ export class BaseTypesGen {
         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;
@@ -332,8 +336,8 @@ export class BaseTypesGen {
             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!
@@ -369,6 +373,6 @@ export class BaseTypesGen {
         this.typeImports.addOutType(typeName);
     }
     getEnumOptions(_typeId) {
-        return { tagKey: 'tag', valueKey: 'value' };
+        return { tagKey: 'type', valueKey: 'value' };
     }
 }

package/typink/generator/ConstructorQueryGen.js

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

package/typink/generator/EventsGen.d.ts

@@ -0,0 +1,7 @@
+import { ContractEventArg } from '@dedot/contracts';
+import { QueryGen } from './QueryGen.js';
+export declare class EventsGen extends QueryGen {
+    #private;
+    generate(useSubPaths?: boolean): Promise<string>;
+    generateParamsOut(args: ContractEventArg[]): string;
+}

package/typink/generator/EventsGen.js

@@ -0,0 +1,31 @@
+import { stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+import { QueryGen } from './QueryGen.js';
+export class EventsGen extends QueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addContractType('GenericContractEvents', 'GenericContractEvent');
+        const { events } = this.contractMetadata.spec;
+        let eventsOut = '';
+        events.forEach((event) => {
+            const { docs, label } = event;
+            const isV5 = 'signature_topic' in event;
+            eventsOut += `${commentBlock(docs, '\n', isV5 ? event.signature_topic ? `@signature_topic: ${event.signature_topic}` : '- Anonymous event' : '')}`;
+            eventsOut += `${stringPascalCase(label)}: ${this.#generateEventDef(event)};\n\n`;
+        });
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('typink/templates/events.hbs');
+        return beautifySourceCode(template({ importTypes, eventsOut }));
+    }
+    #generateEventDef(event) {
+        const { args, label } = event;
+        args.forEach(({ type: { type } }) => this.importType(type));
+        const paramsOut = this.generateParamsOut(args);
+        return `GenericContractEvent<'${stringPascalCase(label)}', {${paramsOut}}>`;
+    }
+    generateParamsOut(args) {
+        return args
+            .map(({ type: { type }, label, docs, indexed }) => `${commentBlock(docs, '\n', `@indexed: ${indexed}`)}${stringCamelCase(label)}: ${this.typesGen.generateType(type, 1)}`)
+            .join(', ');
+    }
+}

package/typink/generator/IndexGen.d.ts

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

package/typink/generator/IndexGen.js

@@ -4,17 +4,22 @@ import { beautifySourceCode, compileTemplate } from '../../utils.js';
 const SUFFIX = 'contract_api';
 export class IndexGen {
     contractMetadata;
-    constructor(contractMetadata) {
+    typesGen;
+    constructor(contractMetadata, typesGen) {
         this.contractMetadata = contractMetadata;
+        this.typesGen = typesGen;
     }
     generate(useSubPaths = false) {
         const contractName = stringPascalCase(`${this.contractMetadata.contract.name}_${SUFFIX}`);
+        const langErrorId = this.contractMetadata.spec.lang_error.type;
+        const langErrorName = this.typesGen.cleanPath(this.contractMetadata.types[langErrorId].type.path);
         const typeImports = new TypeImports();
-        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion');
+        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
         typeImports.addContractType('GenericContractApi');
         typeImports.addChainType('SubstrateApi');
+        typeImports.addPortableType(langErrorName);
         const importTypes = typeImports.toImports({ useSubPaths });
         const template = compileTemplate('typink/templates/index.hbs');
-        return beautifySourceCode(template({ contractName, importTypes }));
+        return beautifySourceCode(template({ contractName, langErrorName, importTypes }));
     }
 }

package/typink/generator/QueryGen.d.ts

@@ -1,12 +1,12 @@
-import { ContractMetadata, Message, ContractMessageArg } from '@dedot/contracts';
+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: Message[], optionsTypeName?: string): string;
-    generateMethodDef(def: Message): string;
+    doGenerate(messages: ContractMessage[], optionsTypeName?: string): string;
+    generateMethodDef(def: ContractMessage): string;
     generateParamsOut(args: ContractMessageArg[]): string;
     importType(typeId: number): any;
 }

package/typink/generator/QueryGen.js

@@ -32,7 +32,9 @@ export class QueryGen {
         this.importType(returnType.type);
         args.forEach(({ type: { type } }) => this.importType(type));
         const paramsOut = this.generateParamsOut(args);
-        const typeOut = this.typesGen.generateType(returnType.type, 0, true);
+        const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
+        // Unwrap langError result
+        const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
         return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>>`;
     }
     generateParamsOut(args) {
@@ -41,14 +43,14 @@ export class QueryGen {
             .join(', ');
     }
     importType(typeId) {
-        const type = this.contractMetadata.types[typeId];
-        const def = normalizeContractTypeDef(this.contractMetadata.types[typeId].type.def);
-        if (this.typesGen.includedTypes[type.id]) {
-            this.typesGen.addTypeImport(this.typesGen.includedTypes[type.id].name);
+        const contractType = this.contractMetadata.types[typeId];
+        const typeDef = normalizeContractTypeDef(this.contractMetadata.types[typeId].type.def);
+        if (this.typesGen.includedTypes[contractType.id]) {
+            this.typesGen.addTypeImport(this.typesGen.includedTypes[contractType.id].name);
             return;
         }
-        const { tag, value } = def;
-        switch (tag) {
+        const { type, value } = typeDef;
+        switch (type) {
             case 'Compact':
             case 'Primitive':
             case 'BitSequence':

package/typink/generator/TxGen.d.ts

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

package/typink/generator/TypesGen.d.ts

@@ -4,5 +4,4 @@ export declare class TypesGen extends BaseTypesGen {
     contractMetadata: ContractMetadata;
     constructor(contractMetadata: ContractMetadata);
     generate(useSubPaths?: boolean): Promise<string>;
-    shouldGenerateTypeIn(id: number): boolean;
 }

package/typink/generator/TypesGen.js

@@ -14,18 +14,11 @@ export class TypesGen extends BaseTypesGen {
         let defTypeOut = '';
         Object.values(this.includedTypes)
             .filter(({ skip, knownType }) => !(skip || knownType))
-            .forEach(({ name, nameOut, id }) => {
+            .forEach(({ nameOut, id }) => {
             defTypeOut += `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({ excludeModules: ['./types'], useSubPaths });
         const template = compileTemplate('typink/templates/types.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
-    shouldGenerateTypeIn(id) {
-        const { messages } = this.contractMetadata.spec;
-        return messages.some((message) => message.returnType.type === id);
-    }
 }

package/typink/generator/index.d.ts

@@ -4,3 +4,4 @@ export * from './TypesGen.js';
 export * from './TxGen.js';
 export * from './ConstructorTxGen.js';
 export * from './ConstructorQueryGen.js';
+export * from './EventsGen.js';

package/typink/generator/index.js

@@ -4,3 +4,4 @@ export * from './TypesGen.js';
 export * from './TxGen.js';
 export * from './ConstructorTxGen.js';
 export * from './ConstructorQueryGen.js';
+export * from './EventsGen.js';

package/typink/index.js

@@ -1,7 +1,7 @@
 import { parseRawMetadata } from '@dedot/contracts';
 import fs from 'fs';
 import path from 'path';
-import { IndexGen, QueryGen, TxGen, TypesGen, ConstructorTxGen, ConstructorQueryGen } from './generator/index.js';
+import { IndexGen, QueryGen, EventsGen, TxGen, TypesGen, ConstructorTxGen, ConstructorQueryGen, } from './generator/index.js';
 export async function generateContractTypes(metadata, contract, outDir = '.', extension = 'd.ts', useSubPaths = false) {
     let contractMetadata = typeof metadata === 'string' ? parseRawMetadata(metadata) : metadata;
     contract = contract || contractMetadata.contract.name;
@@ -11,6 +11,7 @@ export async function generateContractTypes(metadata, contract, outDir = '.', ex
     const txTypesFileName = path.join(dirPath, `tx.${extension}`);
     const constructorTxTypesFileName = path.join(dirPath, `constructor-tx.${extension}`);
     const constructorQueryTypesFileName = path.join(dirPath, `constructor-query.${extension}`);
+    const eventsTypesFile = path.join(dirPath, `events.${extension}`);
     const indexTypesFileName = path.join(dirPath, `index.${extension}`);
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
@@ -20,11 +21,13 @@ export async function generateContractTypes(metadata, contract, outDir = '.', ex
     const txGen = new TxGen(contractMetadata, typesGen);
     const constructorTxGen = new ConstructorTxGen(contractMetadata, typesGen);
     const constructorQueryGen = new ConstructorQueryGen(contractMetadata, typesGen);
-    const indexGen = new IndexGen(contractMetadata);
+    const eventsGen = new EventsGen(contractMetadata, typesGen);
+    const indexGen = new IndexGen(contractMetadata, typesGen);
     fs.writeFileSync(typesFileName, await typesGen.generate(useSubPaths));
     fs.writeFileSync(queryTypesFileName, await queryGen.generate(useSubPaths));
     fs.writeFileSync(txTypesFileName, await txGen.generate(useSubPaths));
     fs.writeFileSync(constructorQueryTypesFileName, await constructorQueryGen.generate(useSubPaths));
     fs.writeFileSync(constructorTxTypesFileName, await constructorTxGen.generate(useSubPaths));
+    fs.writeFileSync(eventsTypesFile, await eventsGen.generate(useSubPaths));
     fs.writeFileSync(indexTypesFileName, await indexGen.generate(useSubPaths));
 }

package/typink/templates/events.hbs

@@ -0,0 +1,8 @@
+// Generated by dedot cli
+
+import { GenericSubstrateApi } from '@dedot/types';
+{{{ importTypes }}}
+
+export interface ContractEvents<ChainApi extends GenericSubstrateApi> extends GenericContractEvents<ChainApi> {
+    {{{ eventsOut }}}
+}

package/typink/templates/index.hbs

@@ -5,10 +5,17 @@ import { ContractQuery } from './query';
 import { ContractTx } from './tx';
 import { ConstructorQuery } from './constructor-query';
 import { ConstructorTx } from './constructor-tx';
+import { ContractEvents } from './events'
 
-export interface {{{contractName}}}<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<ChainApi> {
-    query: ContractQuery<ChainApi[RpcVersion]>;
-    tx: ContractTx<ChainApi[RpcVersion]>;
-    constructorQuery: ConstructorQuery<ChainApi[RpcVersion]>;
-    constructorTx: ConstructorTx<ChainApi[RpcVersion]>;
+export interface {{{contractName}}}<Rv extends RpcVersion = RpcV2, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi> {
+    query: ContractQuery<ChainApi[Rv]>;
+    tx: ContractTx<ChainApi[Rv]>;
+    constructorQuery: ConstructorQuery<ChainApi[Rv]>;
+    constructorTx: ConstructorTx<ChainApi[Rv]>;
+    events: ContractEvents<ChainApi[Rv]>;
+
+    types: {
+      LangError: {{{langErrorName}}};
+      ChainApi: ChainApi[Rv];
+    };
 }

package/utils.js

@@ -7,7 +7,7 @@ export const WRAPPER_TYPE_REGEX = /^(\w+)<(.*)>$/;
 export const TUPLE_TYPE_REGEX = /^\[(.*)]$/;
 export const commentBlock = (...docs) => {
     const flatLines = docs.flat();
-    if (flatLines.length === 0 || !flatLines.find((o) => !!o)) {
+    if (flatLines.length === 0 || !flatLines.some((o) => !!o)) {
         return '';
     }
     else {