@dedot/codegen 0.0.1-next.f5bf4fc2.1 → 0.1.0

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;
+}

package/typink/generator/QueryGen.js

@@ -0,0 +1,68 @@
+import { normalizeContractTypeDef, normalizeLabel, } from '@dedot/contracts';
+import { stringCamelCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+export class QueryGen {
+    contractMetadata;
+    typesGen;
+    constructor(contractMetadata, typeGen) {
+        this.contractMetadata = contractMetadata;
+        this.typesGen = typeGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractQuery', 'GenericContractQueryCall', 'ContractCallOptions', 'GenericContractCallResult', 'ContractCallResult');
+        const { messages } = this.contractMetadata.spec;
+        const queryCallsOut = this.doGenerate(messages, 'ContractCallOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('typink/templates/query.hbs');
+        return beautifySourceCode(template({ importTypes, queryCallsOut }));
+    }
+    doGenerate(messages, optionsTypeName) {
+        let callsOut = '';
+        messages.forEach((messageDef) => {
+            const { label, docs, selector, args } = messageDef;
+            callsOut += `${commentBlock(docs, '\n', args.map((arg) => `@param {${this.typesGen.generateType(arg.type.type, 1)}} ${stringCamelCase(arg.label)}`), optionsTypeName ? `@param {${optionsTypeName}} options` : '', '\n', `@selector ${selector}`)}`;
+            callsOut += `${normalizeLabel(label)}: ${this.generateMethodDef(messageDef)};\n\n`;
+        });
+        return callsOut;
+    }
+    generateMethodDef(def) {
+        const { args, returnType } = def;
+        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);
+        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>>`;
+    }
+    generateParamsOut(args) {
+        return args
+            .map(({ type: { type }, label }) => `${stringCamelCase(label)}: ${this.typesGen.generateType(type, 1)}`)
+            .join(', ');
+    }
+    importType(typeId) {
+        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 { type, value } = typeDef;
+        switch (type) {
+            case 'Compact':
+            case 'Primitive':
+            case 'BitSequence':
+                return;
+            case 'Struct':
+                return value.fields.forEach(({ typeId }) => this.importType(typeId));
+            case 'Enum':
+                return value.members.forEach(({ fields }) => fields.map(({ typeId }) => this.importType(typeId)).flat());
+            case 'Tuple':
+                return value.fields.forEach((typeId) => this.importType(typeId));
+            case 'SizedVec':
+                return this.importType(value.typeParam);
+            case 'Sequence':
+                return this.importType(value.typeParam);
+        }
+    }
+}

package/typink/generator/TxGen.d.ts

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

package/typink/generator/TxGen.js

@@ -0,0 +1,21 @@
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+import { QueryGen } from './QueryGen.js';
+export class TxGen extends QueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractTx', 'GenericContractTxCall', 'ContractTxOptions', 'ContractSubmittableExtrinsic');
+        const { messages } = this.contractMetadata.spec;
+        const txMessages = messages.filter((one) => one.mutates);
+        const txCallsOut = this.doGenerate(txMessages, 'ContractTxOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('typink/templates/tx.hbs');
+        return beautifySourceCode(template({ importTypes, txCallsOut }));
+    }
+    generateMethodDef(def) {
+        const { args } = def;
+        args.forEach(({ type: { type } }) => this.importType(type));
+        const paramsOut = this.generateParamsOut(args);
+        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>>`;
+    }
+}

package/typink/generator/TypesGen.d.ts

@@ -0,0 +1,7 @@
+import { ContractMetadata } from '@dedot/contracts';
+import { BaseTypesGen } from '../../shared/index.js';
+export declare class TypesGen extends BaseTypesGen {
+    contractMetadata: ContractMetadata;
+    constructor(contractMetadata: ContractMetadata);
+    generate(useSubPaths?: boolean): Promise<string>;
+}

package/typink/generator/TypesGen.js

@@ -0,0 +1,24 @@
+import { extractContractTypes } from '@dedot/contracts';
+import { BaseTypesGen } from '../../shared/index.js';
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+const SKIP_TYPES = ['Result', 'Option'];
+export class TypesGen extends BaseTypesGen {
+    contractMetadata;
+    constructor(contractMetadata) {
+        super(extractContractTypes(contractMetadata));
+        this.contractMetadata = contractMetadata;
+        this.skipTypes = SKIP_TYPES;
+        this.includedTypes = this.includeTypes();
+    }
+    generate(useSubPaths = false) {
+        let defTypeOut = '';
+        Object.values(this.includedTypes)
+            .filter(({ skip, knownType }) => !(skip || knownType))
+            .forEach(({ nameOut, id }) => {
+            defTypeOut += `export type ${nameOut} = ${this.generateType(id, 0, true)};\n\n`;
+        });
+        const importTypes = this.typeImports.toImports({ excludeModules: ['./types'], useSubPaths });
+        const template = compileTemplate('typink/templates/types.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+}

package/typink/generator/index.d.ts

@@ -0,0 +1,7 @@
+export * from './IndexGen.js';
+export * from './QueryGen.js';
+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

@@ -0,0 +1,7 @@
+export * from './IndexGen.js';
+export * from './QueryGen.js';
+export * from './TypesGen.js';
+export * from './TxGen.js';
+export * from './ConstructorTxGen.js';
+export * from './ConstructorQueryGen.js';
+export * from './EventsGen.js';

package/typink/index.d.ts

@@ -0,0 +1,2 @@
+import { ContractMetadata } from '@dedot/contracts';
+export declare function generateContractTypes(metadata: ContractMetadata | string, contract?: string, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<void>;

package/typink/index.js

@@ -0,0 +1,33 @@
+import { parseRawMetadata } from '@dedot/contracts';
+import fs from 'fs';
+import path from 'path';
+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;
+    const dirPath = path.resolve(outDir, contract);
+    const typesFileName = path.join(dirPath, `types.${extension}`);
+    const queryTypesFileName = path.join(dirPath, `query.${extension}`);
+    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 });
+    }
+    const typesGen = new TypesGen(contractMetadata);
+    const queryGen = new QueryGen(contractMetadata, typesGen);
+    const txGen = new TxGen(contractMetadata, typesGen);
+    const constructorTxGen = new ConstructorTxGen(contractMetadata, typesGen);
+    const constructorQueryGen = new ConstructorQueryGen(contractMetadata, typesGen);
+    const eventsGen = new EventsGen(contractMetadata, typesGen);
+    const indexGen = new IndexGen(contractMetadata);
+    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/constructor-query.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ConstructorQuery<ChainApi extends GenericSubstrateApi> extends GenericConstructorQuery<ChainApi> {
+    {{{ constructorsOut }}}
+}

package/typink/templates/constructor-tx.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ConstructorTx<ChainApi extends GenericSubstrateApi> extends GenericConstructorTx<ChainApi> {
+    {{{ constructorsOut }}}
+}

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

@@ -0,0 +1,16 @@
+// Generated by dedot cli
+
+{{{importTypes}}}
+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}}}<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]>;
+}

package/typink/templates/query.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ContractQuery<ChainApi extends GenericSubstrateApi> extends GenericContractQuery<ChainApi> {
+    {{{ queryCallsOut }}}
+}

package/typink/templates/tx.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ContractTx<ChainApi extends GenericSubstrateApi> extends GenericContractTx<ChainApi> {
+    {{{ txCallsOut }}}
+}

package/typink/templates/types.hbs

@@ -0,0 +1,5 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+{{{ defTypeOut }}}

package/{generator/utils.d.ts → utils.d.ts}

@@ -2,9 +2,14 @@ export declare const WRAPPER_TYPE_REGEX: RegExp;
 export declare const TUPLE_TYPE_REGEX: RegExp;
 export declare const commentBlock: (...docs: (string | string[])[]) => string;
 export declare const beautifySourceCode: (source: string) => Promise<string>;
-export declare const compileTemplate: (templateFileName: string) => HandlebarsTemplateDelegate<any>;
+export declare const compileTemplate: (templateFile: string) => HandlebarsTemplateDelegate<any>;
 /**
  * Check if a word is TypeScript/JavaScript reserved
  * @param word
  */
 export declare const isReservedWord: (word: string) => boolean;
+/**
+ * Check if a type is native JS/TS type
+ * @param type
+ */
+export declare const isNativeType: (type: string) => boolean;

package/{generator/utils.js → 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) {
+    if (flatLines.length === 0 || !flatLines.some((o) => !!o)) {
         return '';
     }
     else {
@@ -19,11 +19,11 @@ ${flatLines.map((line) => `* ${line.replaceAll(/\s+/g, ' ').trim()}`).join('\n')
     }
 };
 export const beautifySourceCode = async (source) => {
-    const prettierOptions = await prettier.resolveConfig(path.resolve(currentDirname(), '../../../../.prettierrc.js'));
+    const prettierOptions = await prettier.resolveConfig(path.resolve(currentDirname(), '../../../.prettierrc.cjs'));
     return prettier.format(source, { parser: 'babel-ts', ...prettierOptions });
 };
-export const compileTemplate = (templateFileName) => {
-    const templateFilePath = path.resolve(currentDirname(), `../templates/${templateFileName}`);
+export const compileTemplate = (templateFile) => {
+    const templateFilePath = path.resolve(currentDirname(), templateFile);
     return handlebars.compile(fs.readFileSync(templateFilePath, 'utf8'));
 };
 // TODO add more reserved words
@@ -33,3 +33,31 @@ const TS_RESERVED_WORDS = ['new', 'class'];
  * @param word
  */
 export const isReservedWord = (word) => TS_RESERVED_WORDS.includes(word);
+const TS_PRIMITIVE_TYPES = [
+    'void',
+    'undefined',
+    'null',
+    'number',
+    'boolean',
+    'bigint',
+    'Map',
+    'Set',
+    'string',
+    'any',
+    'Array',
+    'Record',
+];
+/**
+ * Check if a type is native JS/TS type
+ * @param type
+ */
+export const isNativeType = (type) => {
+    return TS_PRIMITIVE_TYPES.some((one) => {
+        if (typeof one === 'string') {
+            return one === type;
+        }
+        else {
+            return type.match(one);
+        }
+    });
+};

package/cjs/genSupportedChainTypes.js

@@ -1,83 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("./index");
-const static_substrate_1 = require("@polkadot/types-support/metadata/static-substrate");
-const substrate_hex_1 = __importDefault(require("@polkadot/types-support/metadata/v15/substrate-hex"));
-const codecs_1 = require("@dedot/codecs");
-const dedot_1 = require("dedot");
-const NETWORKS = [
-    {
-        chain: 'substrate',
-        metadataHex: substrate_hex_1.default,
-        rpcMethods: static_substrate_1.rpc.methods,
-    },
-    {
-        chain: 'polkadot',
-        endpoint: 'wss://rpc.polkadot.io',
-    },
-    {
-        chain: 'kusama',
-        endpoint: 'wss://kusama-rpc.polkadot.io',
-    },
-    {
-        chain: 'astar',
-        endpoint: 'wss://rpc.astar.network',
-    },
-    {
-        chain: 'moonbeam',
-        endpoint: 'wss://moonbeam.api.onfinality.io/public-ws',
-    },
-    {
-        chain: 'polkadotAssetHub',
-        endpoint: 'wss://polkadot-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'kusamaAssetHub',
-        endpoint: 'wss://kusama-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'rococo',
-        endpoint: 'wss://rococo-rpc.polkadot.io/',
-    },
-    {
-        chain: 'rococoAssetHub',
-        endpoint: 'wss://rococo-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'aleph',
-        endpoint: 'wss://aleph-zero.api.onfinality.io/public-ws',
-    },
-    {
-        chain: 'westendAssetHub',
-        endpoint: 'wss://westend-asset-hub-rpc.polkadot.io',
-    },
-];
-const OUT_DIR = 'packages/chaintypes/src';
-async function run() {
-    for (const network of NETWORKS) {
-        const { chain, endpoint, metadataHex, rpcMethods } = network;
-        if (endpoint) {
-            console.log(`Generate types for ${chain} via endpoint ${endpoint}`);
-            await (0, index_1.generateTypesFromChain)(network, endpoint, OUT_DIR);
-        }
-        else if (metadataHex && rpcMethods) {
-            console.log(`Generate types for ${chain} via raw data`);
-            const metadata = codecs_1.$Metadata.tryDecode(metadataHex);
-            const runtimeVersion = getRuntimeVersion(metadata);
-            await (0, index_1.generateTypes)(network, metadata.latest, rpcMethods, runtimeVersion.apis, OUT_DIR);
-        }
-    }
-    console.log('DONE!');
-}
-const getRuntimeVersion = (metadata) => {
-    const registry = new codecs_1.PortableRegistry(metadata.latest);
-    const executor = new dedot_1.ConstantExecutor({
-        registry,
-        metadataLatest: metadata.latest,
-    });
-    return executor.execute('system', 'version');
-};
-run().catch(console.log);

package/cjs/generator/ErrorsGen.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorsGen = void 0;
-const ApiGen_1 = require("./ApiGen");
-const utils_1 = require("./utils");
-const util_1 = require("@polkadot/util");
-const utils_2 = require("@dedot/utils");
-class ErrorsGen extends ApiGen_1.ApiGen {
-    generate() {
-        const { pallets } = this.metadata;
-        this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainErrors', 'GenericPalletError');
-        let defTypeOut = '';
-        for (let pallet of pallets) {
-            const errorTypeId = pallet.error;
-            if (!errorTypeId) {
-                continue;
-            }
-            const errorDefs = this.#getErrorDefs(errorTypeId);
-            defTypeOut += (0, utils_1.commentBlock)(`Pallet \`${pallet.name}\`'s errors`);
-            defTypeOut += `${(0, util_1.stringCamelCase)(pallet.name)}: {
-        ${errorDefs
-                .map(({ name, docs }) => `${(0, utils_1.commentBlock)(docs)}${(0, util_1.stringPascalCase)(name)}: GenericPalletError`)
-                .join(',\n')}
-          
-        ${(0, utils_1.commentBlock)('Generic pallet error')}[error: string]: GenericPalletError,
-      },`;
-        }
-        const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_1.compileTemplate)('errors.hbs');
-        return (0, utils_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
-    }
-    #getErrorDefs(errorTypeId) {
-        const def = this.metadata.types[errorTypeId];
-        (0, utils_2.assert)(def, `Error def not found for id ${errorTypeId}`);
-        const { tag, value } = def.type;
-        (0, utils_2.assert)(tag === 'Enum', `Invalid pallet error type!`);
-        return value.members;
-    }
-}
-exports.ErrorsGen = ErrorsGen;

package/cjs/generator/IndexGen.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexGen = void 0;
-const utils_1 = require("./utils");
-const util_1 = require("@polkadot/util");
-class IndexGen {
-    networkInfo;
-    constructor(networkInfo) {
-        this.networkInfo = networkInfo;
-    }
-    async generate() {
-        const { chain } = this.networkInfo;
-        const interfaceName = (0, util_1.stringPascalCase)(chain);
-        const template = (0, utils_1.compileTemplate)('index.hbs');
-        return (0, utils_1.beautifySourceCode)(template({ interfaceName }));
-    }
-}
-exports.IndexGen = IndexGen;

package/cjs/generator/QueryGen.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryGen = void 0;
-const util_1 = require("@polkadot/util");
-const utils_1 = require("@dedot/utils");
-const generator_1 = require("../generator");
-const utils_2 = require("./utils");
-class QueryGen extends generator_1.ApiGen {
-    generate() {
-        const { pallets } = this.metadata;
-        this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainStorage', 'GenericStorageQuery', 'Callback');
-        let defTypeOut = '';
-        for (let pallet of pallets) {
-            const storage = pallet.storage;
-            if (!storage)
-                continue;
-            const queries = storage.entries.map((one) => this.#generateEntry(one));
-            const queryDefs = queries.map(({ name, valueType, keyType, docs }) => `${(0, utils_2.commentBlock)(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`);
-            defTypeOut += (0, utils_2.commentBlock)(`Pallet \`${pallet.name}\`'s storage queries`);
-            defTypeOut += `${(0, util_1.stringLowerFirst)(pallet.name)}: {
-        ${queryDefs.join(',\n')}
-        
-        ${(0, utils_2.commentBlock)('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
-      },`;
-        }
-        const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_2.compileTemplate)('query.hbs');
-        return (0, utils_2.beautifySourceCode)(template({ importTypes, defTypeOut }));
-    }
-    #generateEntry(entry) {
-        const { name, type, docs, modifier } = entry;
-        let valueType, keyType;
-        if (type.tag === 'Plain') {
-            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
-        }
-        else if (type.tag === 'Map') {
-            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
-            keyType = this.typesGen.generateType(type.value.keyTypeId, 1);
-        }
-        else {
-            throw Error('Invalid entry type!');
-        }
-        const isOptional = modifier === 'Optional';
-        valueType = `${valueType}${isOptional ? ' | undefined' : ''}`;
-        docs.push('\n');
-        if (keyType) {
-            docs.push(`@param {${keyType}} arg`);
-        }
-        docs.push(`@param {Callback<${valueType}> =} callback`);
-        return {
-            name: (0, utils_1.normalizeName)(name),
-            valueType,
-            keyType: keyType ? `arg: ${keyType}` : '',
-            docs,
-        };
-    }
-}
-exports.QueryGen = QueryGen;