@dedot/codegen 0.0.1-alpha.34 → 0.0.1-alpha.35

package/{generator → 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/{generator → chaintypes/generator}/ConstsGen.js

@@ -1,6 +1,6 @@
 import { normalizeName, stringCamelCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
 import { ApiGen } from './ApiGen.js';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class ConstsGen extends ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
@@ -21,7 +21,7 @@ export class ConstsGen extends ApiGen {
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        const template = compileTemplate('consts.hbs');
+        const template = compileTemplate('chaintypes/templates/consts.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
 }

package/{generator → chaintypes/generator}/ErrorsGen.js

@@ -1,6 +1,6 @@
 import { assert, stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
 import { ApiGen } from './ApiGen.js';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class ErrorsGen extends ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
@@ -23,14 +23,14 @@ export class ErrorsGen extends ApiGen {
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        const template = compileTemplate('errors.hbs');
+        const template = compileTemplate('chaintypes/templates/errors.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
     #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/{generator → chaintypes/generator}/EventsGen.js

@@ -1,6 +1,6 @@
 import { assert, stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
 import { ApiGen } from './ApiGen.js';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class EventsGen extends ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
@@ -35,14 +35,14 @@ export class EventsGen extends ApiGen {
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        const template = compileTemplate('events.hbs');
+        const template = compileTemplate('chaintypes/templates/events.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
     #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/{generator → chaintypes/generator}/IndexGen.js

@@ -1,6 +1,6 @@
 import { stringPascalCase } from '@dedot/utils';
-import { TypeImports } from './TypeImports.js';
-import { beautifySourceCode, compileTemplate } from './utils.js';
+import { TypeImports } from '../../shared/index.js';
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
 export class IndexGen {
     chain;
     constructor(chain) {
@@ -11,7 +11,7 @@ export class IndexGen {
         const typeImports = new TypeImports();
         typeImports.addKnownType('GenericSubstrateApi', 'RpcLegacy', 'RpcV2', 'RpcVersion');
         const importTypes = typeImports.toImports({ useSubPaths });
-        const template = compileTemplate('index.hbs');
+        const template = compileTemplate('chaintypes/templates/index.hbs');
         return beautifySourceCode(template({ importTypes, interfaceName }));
     }
 }

package/{generator → chaintypes/generator}/JsonRpcGen.js

@@ -1,6 +1,6 @@
 import { subscriptionsInfo } from '@dedot/api';
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
 import { ApiGen } from './ApiGen.js';
-import { beautifySourceCode, compileTemplate } from './utils.js';
 const HIDDEN_RPCS = [
     // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
     'rpc_methods',
@@ -44,7 +44,7 @@ export class JsonRpcGen extends ApiGen {
         this.typesGen.typeImports.addKnownJsonRpcType('JsonRpcApis');
         const toExclude = Object.values(subscriptionsInfo).flat();
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        const template = compileTemplate('json-rpc.hbs');
+        const template = compileTemplate('chaintypes/templates/json-rpc.hbs');
         const jsonRpcMethods = this.rpcMethods
             .filter((one) => !ALIAS_RPCS.includes(one)) // exclude alias rpcs
             .filter((one) => !toExclude.includes(one)) // exclude unsubscribe methods

package/{generator → chaintypes/generator}/QueryGen.js

@@ -1,6 +1,6 @@
 import { normalizeName, stringCamelCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
 import { ApiGen } from './ApiGen.js';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class QueryGen extends ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
@@ -28,19 +28,19 @@ export class QueryGen extends ApiGen {
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        const template = compileTemplate('query.hbs');
+        const template = compileTemplate('chaintypes/templates/query.hbs');
         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/{generator → chaintypes/generator}/RuntimeApisGen.js

@@ -1,8 +1,8 @@
 import { getRuntimeApiNames, getRuntimeApiSpecs } from '@dedot/runtime-specs';
 import { calcRuntimeApiHash, stringSnakeCase, stringCamelCase } from '@dedot/utils';
+import { findKnownCodecType } from '../../shared/index.js';
+import { beautifySourceCode, commentBlock, compileTemplate, isNativeType, TUPLE_TYPE_REGEX, WRAPPER_TYPE_REGEX, } from '../../utils.js';
 import { ApiGen } from './ApiGen.js';
-import { findKnownCodecType } from './known-codecs.js';
-import { beautifySourceCode, commentBlock, compileTemplate, isNativeType, TUPLE_TYPE_REGEX, WRAPPER_TYPE_REGEX, } from './utils.js';
 export class RuntimeApisGen extends ApiGen {
     typesGen;
     runtimeApis;
@@ -44,7 +44,7 @@ export class RuntimeApisGen extends ApiGen {
             });
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        const template = compileTemplate('runtime.hbs');
+        const template = compileTemplate('chaintypes/templates/runtime.hbs');
         return beautifySourceCode(template({ importTypes, runtimeCallsOut }));
     }
     #isOptionalType(type) {

package/{generator → chaintypes/generator}/TxGen.js

@@ -1,6 +1,6 @@
 import { stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from '../../utils.js';
 import { ApiGen } from '../generator/index.js';
-import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from './utils.js';
 export class TxGen extends ApiGen {
     generate(useSubPaths = false) {
         const { pallets, types } = this.metadata;
@@ -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) => ({
@@ -58,7 +58,7 @@ export class TxGen extends ApiGen {
         
     export type TxCall<Rv extends RpcVersion> = (...args: any[]) => ChainSubmittableExtrinsic<Rv>;    
 `;
-        const template = compileTemplate('tx.hbs');
+        const template = compileTemplate('chaintypes/templates/tx.hbs');
         return beautifySourceCode(template({ importTypes, defTypes, txDefsOut }));
     }
     #normalizeParamName(name) {

package/chaintypes/generator/TypesGen.d.ts

@@ -0,0 +1,11 @@
+import { MetadataLatest, PortableRegistry, TypeId } from '@dedot/codecs';
+import { EnumOptions } from '@dedot/shape';
+import { BaseTypesGen } from '../../shared/index.js';
+export declare class TypesGen extends BaseTypesGen {
+    metadata: MetadataLatest;
+    registry: PortableRegistry;
+    constructor(metadata: MetadataLatest);
+    generate(useSubPaths?: boolean): Promise<string>;
+    shouldGenerateTypeIn(id: TypeId): boolean;
+    getEnumOptions(typeId: TypeId): EnumOptions;
+}

package/chaintypes/generator/TypesGen.js

@@ -0,0 +1,55 @@
+import { PortableRegistry } from '@dedot/codecs';
+import { BaseTypesGen } from '../../shared/index.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.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',
+];
+export class TypesGen extends BaseTypesGen {
+    metadata;
+    registry;
+    constructor(metadata) {
+        super(metadata.types);
+        this.metadata = metadata;
+        this.skipTypes = SKIP_TYPES;
+        this.registry = new PortableRegistry(this.metadata);
+        this.includedTypes = this.includeTypes();
+    }
+    generate(useSubPaths = false) {
+        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({ excludeModules: ['./types'], useSubPaths });
+        const template = compileTemplate('chaintypes/templates/types.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+    shouldGenerateTypeIn(id) {
+        const { callTypeId } = this.metadata.extrinsic;
+        const palletCallTypeIds = this.registry.getFieldTypeIdsFromEnum(callTypeId);
+        return callTypeId === id || palletCallTypeIds.includes(id);
+    }
+    getEnumOptions(typeId) {
+        return this.registry.getEnumOptions(typeId);
+    }
+}

package/chaintypes/index.d.ts

@@ -0,0 +1,3 @@
+import { MetadataLatest } from '@dedot/codecs';
+export declare function generateTypesFromEndpoint(chain: string, endpoint: string, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<void>;
+export declare function generateTypes(chain: string, metadata: MetadataLatest, rpcMethods: string[], runtimeApis: Record<string, number>, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<void>;

package/chaintypes/index.js

@@ -0,0 +1,49 @@
+import { LegacyClient } from '@dedot/api';
+import { WsProvider } from '@dedot/providers';
+import { stringCamelCase } from '@dedot/utils';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ConstsGen, ErrorsGen, EventsGen, IndexGen, JsonRpcGen, QueryGen, RuntimeApisGen, TxGen, TypesGen, } from './generator/index.js';
+export async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts', useSubPaths = false) {
+    const api = await LegacyClient.new(new WsProvider(endpoint));
+    const { methods } = await api.rpc.rpc_methods();
+    const apis = api.runtimeVersion.apis || {};
+    if (!chain) {
+        chain = stringCamelCase(api.runtimeVersion.specName || 'local');
+    }
+    await generateTypes(chain, api.metadata.latest, methods, apis, outDir, extension, useSubPaths);
+    await api.disconnect();
+}
+export async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir = '.', extension = 'd.ts', useSubPaths = false) {
+    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 TypesGen(metadata);
+    const constsGen = new ConstsGen(typesGen);
+    const queryGen = new QueryGen(typesGen);
+    const jsonRpcGen = new JsonRpcGen(typesGen, rpcMethods);
+    const indexGen = new IndexGen(chain);
+    const errorsGen = new ErrorsGen(typesGen);
+    const eventsGen = new EventsGen(typesGen);
+    const runtimeApisGen = new RuntimeApisGen(typesGen, runtimeApis);
+    const txGen = new TxGen(typesGen);
+    fs.writeFileSync(defTypesFileName, await typesGen.generate(useSubPaths));
+    fs.writeFileSync(errorsFileName, await errorsGen.generate(useSubPaths));
+    fs.writeFileSync(eventsFileName, await eventsGen.generate(useSubPaths));
+    fs.writeFileSync(jsonRpcFileName, await jsonRpcGen.generate(useSubPaths));
+    fs.writeFileSync(queryTypesFileName, await queryGen.generate(useSubPaths));
+    fs.writeFileSync(constsTypesFileName, await constsGen.generate(useSubPaths));
+    fs.writeFileSync(txFileName, await txGen.generate(useSubPaths));
+    fs.writeFileSync(indexFileName, await indexGen.generate(useSubPaths));
+    fs.writeFileSync(runtimeApisFileName, await runtimeApisGen.generate(useSubPaths));
+}

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

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

package/{templates → chaintypes/templates}/errors.hbs

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

package/{templates → chaintypes/templates}/events.hbs

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

package/{templates → chaintypes/templates}/index.hbs

@@ -1,4 +1,4 @@
-// Generated by @dedot/codegen
+// Generated by dedot cli
 
 {{{importTypes}}}
 import { ChainConsts } from './consts';

package/{templates → chaintypes/templates}/json-rpc.hbs

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

package/{templates → chaintypes/templates}/query.hbs

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

package/{templates → chaintypes/templates}/runtime.hbs

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

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

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

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

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

package/cjs/{generator → chaintypes/generator}/ConstsGen.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstsGen = void 0;
 const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("../../utils.js");
 const ApiGen_js_1 = require("./ApiGen.js");
-const utils_js_1 = require("./utils.js");
 class ConstsGen extends ApiGen_js_1.ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
@@ -24,7 +24,7 @@ class ConstsGen extends ApiGen_js_1.ApiGen {
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        const template = (0, utils_js_1.compileTemplate)('consts.hbs');
+        const template = (0, utils_js_1.compileTemplate)('chaintypes/templates/consts.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
 }

package/cjs/{generator → chaintypes/generator}/ErrorsGen.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorsGen = void 0;
 const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("../../utils.js");
 const ApiGen_js_1 = require("./ApiGen.js");
-const utils_js_1 = require("./utils.js");
 class ErrorsGen extends ApiGen_js_1.ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
@@ -26,14 +26,14 @@ class ErrorsGen extends ApiGen_js_1.ApiGen {
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        const template = (0, utils_js_1.compileTemplate)('errors.hbs');
+        const template = (0, utils_js_1.compileTemplate)('chaintypes/templates/errors.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
     #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/{generator → chaintypes/generator}/EventsGen.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventsGen = void 0;
 const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("../../utils.js");
 const ApiGen_js_1 = require("./ApiGen.js");
-const utils_js_1 = require("./utils.js");
 class EventsGen extends ApiGen_js_1.ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
@@ -38,14 +38,14 @@ class EventsGen extends ApiGen_js_1.ApiGen {
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        const template = (0, utils_js_1.compileTemplate)('events.hbs');
+        const template = (0, utils_js_1.compileTemplate)('chaintypes/templates/events.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
     #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/{generator → chaintypes/generator}/IndexGen.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexGen = void 0;
 const utils_1 = require("@dedot/utils");
-const TypeImports_js_1 = require("./TypeImports.js");
-const utils_js_1 = require("./utils.js");
+const index_js_1 = require("../../shared/index.js");
+const utils_js_1 = require("../../utils.js");
 class IndexGen {
     chain;
     constructor(chain) {
@@ -11,10 +11,10 @@ class IndexGen {
     }
     async generate(useSubPaths = false) {
         const interfaceName = (0, utils_1.stringPascalCase)(this.chain);
-        const typeImports = new TypeImports_js_1.TypeImports();
+        const typeImports = new index_js_1.TypeImports();
         typeImports.addKnownType('GenericSubstrateApi', 'RpcLegacy', 'RpcV2', 'RpcVersion');
         const importTypes = typeImports.toImports({ useSubPaths });
-        const template = (0, utils_js_1.compileTemplate)('index.hbs');
+        const template = (0, utils_js_1.compileTemplate)('chaintypes/templates/index.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, interfaceName }));
     }
 }

package/cjs/{generator → chaintypes/generator}/JsonRpcGen.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonRpcGen = void 0;
 const api_1 = require("@dedot/api");
+const utils_js_1 = require("../../utils.js");
 const ApiGen_js_1 = require("./ApiGen.js");
-const utils_js_1 = require("./utils.js");
 const HIDDEN_RPCS = [
     // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
     'rpc_methods',
@@ -47,7 +47,7 @@ class JsonRpcGen extends ApiGen_js_1.ApiGen {
         this.typesGen.typeImports.addKnownJsonRpcType('JsonRpcApis');
         const toExclude = Object.values(api_1.subscriptionsInfo).flat();
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        const template = (0, utils_js_1.compileTemplate)('json-rpc.hbs');
+        const template = (0, utils_js_1.compileTemplate)('chaintypes/templates/json-rpc.hbs');
         const jsonRpcMethods = this.rpcMethods
             .filter((one) => !ALIAS_RPCS.includes(one)) // exclude alias rpcs
             .filter((one) => !toExclude.includes(one)) // exclude unsubscribe methods

package/cjs/{generator → chaintypes/generator}/QueryGen.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryGen = void 0;
 const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("../../utils.js");
 const ApiGen_js_1 = require("./ApiGen.js");
-const utils_js_1 = require("./utils.js");
 class QueryGen extends ApiGen_js_1.ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
@@ -31,19 +31,19 @@ class QueryGen extends ApiGen_js_1.ApiGen {
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        const template = (0, utils_js_1.compileTemplate)('query.hbs');
+        const template = (0, utils_js_1.compileTemplate)('chaintypes/templates/query.hbs');
         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!');