@hyperweb/telescope 1.15.0

package/main/generators/create-root-readme.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const files_1 = require("../utils/files");
+const path_1 = require("path");
+const utils_1 = require("@cosmology/utils");
+/**
+ * Gets the aliased function name if it's duplicated across multiple files
+ */
+function getAliasedFunctionName(builder, functionName, packageName) {
+    const duplicatedHelperFuncs = builder.store.getHelperFuncsInMultipleFiles();
+    const isDuplicated = duplicatedHelperFuncs.includes(functionName);
+    if (isDuplicated) {
+        const serialNumber = builder.store.getAndIncTypeSerialNumber(functionName);
+        if (serialNumber > 0) {
+            return (0, utils_1.makeAliasNameWithPackageAtEnd)({ package: packageName, name: functionName });
+        }
+    }
+    return functionName;
+}
+/**
+ * Cleans up comments by removing lint directives and technical annotations
+ */
+function cleanComment(comment) {
+    if (!comment)
+        return comment;
+    // Remove lint directives and technical annotations
+    const cleanedComment = comment
+        // Remove buf:lint:ignore directives
+        .replace(/buf:lint:ignore\s+[A-Z_]+/gi, '')
+        // Remove other common lint directives
+        .replace(/lint:ignore[:\s]+[A-Z_]+/gi, '')
+        // Remove protolint directives
+        .replace(/protolint:disable[:\s]+[A-Z_]+/gi, '')
+        // Remove eslint directives
+        .replace(/eslint-disable[:\s-]+[a-z-]+/gi, '')
+        // Remove multiple consecutive spaces
+        .replace(/\s+/g, ' ')
+        // Remove leading/trailing whitespace
+        .trim();
+    return cleanedComment;
+}
+/**
+ * Gets the project name from the output path
+ */
+function getProjectName(outPath) {
+    return (0, path_1.basename)(outPath);
+}
+/**
+ * Gets the appropriate import path for a function, considering bundle exports
+ */
+function getImportPath(builder, functionName, packageName, projectName, sourceFilename) {
+    const duplicatedHelperFuncs = builder.store.getHelperFuncsInMultipleFiles();
+    const isDuplicated = duplicatedHelperFuncs.includes(functionName);
+    // If the function is duplicated (and thus potentially aliased), it should be available in the bundle
+    if (isDuplicated) {
+        // Check the aliased function name to see if it would be different
+        const aliasedName = getAliasedFunctionName(builder, functionName, packageName);
+        if (aliasedName !== functionName) {
+            // Extract the top-level package name (e.g., 'akash' from 'akash.audit.v1beta2')
+            const topLevelPackage = packageName.split('.')[0];
+            // Function is aliased and should be available in bundle
+            return `${projectName}/${topLevelPackage}/bundle`;
+        }
+    }
+    // If we have source filename info, use the full file path
+    // This handles all functions with specific file locations
+    if (sourceFilename) {
+        // Remove .ts extension and convert to proper import path
+        const filePath = sourceFilename.replace(/\.ts$/, '');
+        return `${projectName}/${filePath}`;
+    }
+    // Fallback: import from the specific package path
+    return `${projectName}/${packageName.replace(/\./g, '/')}`;
+}
+/**
+ * Gets all types for a package by looking at export objects and filtering out extended forms
+ */
+function getTypesForPackage(builder, packageName) {
+    const types = [];
+    // Get all contexts for this package
+    const packageContexts = builder.contexts.filter(ctx => ctx.ref.proto.package === packageName);
+    packageContexts.forEach(context => {
+        // Get types from this context
+        const contextTypes = context.types.filter(type => !type.isNested);
+        contextTypes.forEach(typeInfo => {
+            const typeName = typeInfo.name;
+            // Filter out extended forms (these are created during code generation but not in the types array)
+            if (!typeName.endsWith('ProtoMsg') &&
+                !typeName.endsWith('Amino') &&
+                !typeName.endsWith('AminoMsg') &&
+                !typeName.endsWith('Encoded') &&
+                !typeName.endsWith('SDKType')) {
+                // Get the actual source file from the store mapping
+                const typeFiles = builder.store.getTypeFilesMapping(typeName);
+                let sourceFile;
+                if (typeFiles && typeFiles.length > 0) {
+                    // Use the first (or most relevant) file where this type is defined
+                    sourceFile = typeFiles[0];
+                }
+                else {
+                    // Fallback to context ref filename if not in mapping
+                    sourceFile = context.ref.filename.replace(/\.proto$/, '.ts');
+                }
+                types.push({
+                    name: typeName,
+                    sourceFile
+                });
+            }
+        });
+    });
+    // Remove duplicates and sort
+    const uniqueTypes = types.filter((type, index, self) => index === self.findIndex(t => t.name === type.name));
+    return uniqueTypes.sort((a, b) => a.name.localeCompare(b.name));
+}
+const plugin = (builder) => {
+    if (!builder.options.readme.enabled && !builder.options.mcpServer.enabled) {
+        return;
+    }
+    const readmePath = (0, path_1.join)(builder.outPath, "README.md");
+    const projectName = getProjectName(builder.outPath);
+    // Get function mappings from builder
+    const functionMappings = builder.getFunctionMappings();
+    // Generate package documentation
+    let packageDocs = "";
+    Object.keys(functionMappings).sort().forEach(packageName => {
+        const packageServices = functionMappings[packageName];
+        // Check if package has any methods before adding it
+        const hasQueryMethods = packageServices.Query && Object.keys(packageServices.Query).length > 0;
+        const hasMsgMethods = packageServices.Msg && Object.keys(packageServices.Msg).length > 0;
+        if (!hasQueryMethods && !hasMsgMethods) {
+            return; // Skip empty packages
+        }
+        packageDocs += `## ${packageName}\n\n`;
+        // Types section
+        const types = getTypesForPackage(builder, packageName);
+        if (types && types.length > 0) {
+            packageDocs += `### Types\n\n`;
+            packageDocs += `| Type | Name | Source |\n`;
+            packageDocs += `| --- | --- | --- |\n`;
+            types.forEach(type => {
+                packageDocs += `| Type | \`${type.name}\` | [View source ↗](${type.sourceFile}) |\n`;
+            });
+            packageDocs += '\n';
+        }
+        // Query section
+        if (packageServices.Query) {
+            packageDocs += `### Query Methods\n\n`;
+            const queryMethods = Object.keys(packageServices.Query);
+            queryMethods.forEach((methodName, index) => {
+                const method = packageServices.Query[methodName];
+                // Get the aliased function name using the same logic as bundler
+                const aliasedFunctionName = getAliasedFunctionName(builder, method.functionName, packageName);
+                const aliasedHookName = getAliasedFunctionName(builder, method.hookName, packageName);
+                packageDocs += `**${methodName}**\n\n`;
+                // Add comment directly after title (if exists)
+                if (method.comment) {
+                    packageDocs += `${cleanComment(method.comment)}\n\n`;
+                }
+                // Add import code block
+                const functionImportPath = getImportPath(builder, method.functionName, packageName, projectName, method.sourceFilename);
+                const hookImportPath = method.hookName ? getImportPath(builder, method.hookName, packageName, projectName, method.hookSourceFilename) : functionImportPath;
+                packageDocs += `\`\`\`ts\n`;
+                packageDocs += `import { ${aliasedFunctionName} } from '${functionImportPath}'\n`;
+                if (method.hookName && aliasedHookName !== aliasedFunctionName) {
+                    packageDocs += `import { ${aliasedHookName} } from '${hookImportPath}'\n`;
+                }
+                packageDocs += `\`\`\`\n\n`;
+                // Add function details in organized format
+                packageDocs += `| Field | Value | Source |\n`;
+                packageDocs += `| --- | --- | --- |\n`;
+                // Function source
+                const functionSourcePath = method.sourceFilename || `${packageName.replace(/\./g, '/')}/query.rpc.func.ts`;
+                packageDocs += `| Function | \`${aliasedFunctionName}\` | [View source ↗](${functionSourcePath}) |\n`;
+                // Hook source (React)
+                if (method.hookName && aliasedHookName !== aliasedFunctionName) {
+                    const hookSourcePath = method.hookSourceFilename || `${packageName.replace(/\./g, '/')}/query.rpc.react.ts`;
+                    packageDocs += `| Hook | \`${aliasedHookName}\` | [View source ↗](${hookSourcePath}) |\n`;
+                }
+                // Request type source
+                if (method.requestType) {
+                    const requestSourcePath = method.typeSourceFilename || `${packageName.replace(/\./g, '/')}/query.ts`;
+                    packageDocs += `| Request | \`${method.requestType}\` | [View source ↗](${requestSourcePath}) |\n`;
+                }
+                // Response type source
+                if (method.responseType) {
+                    const responseSourcePath = method.typeSourceFilename || `${packageName.replace(/\./g, '/')}/query.ts`;
+                    packageDocs += `| Response | \`${method.responseType}\` | [View source ↗](${responseSourcePath}) |\n`;
+                }
+                // Add spacing between methods (but not after the last one)
+                if (index < queryMethods.length - 1) {
+                    packageDocs += '\n---\n\n';
+                }
+                else {
+                    packageDocs += '\n';
+                }
+            });
+        }
+        // Transaction section
+        if (packageServices.Msg) {
+            packageDocs += `### Transaction Methods\n\n`;
+            const msgMethods = Object.keys(packageServices.Msg);
+            msgMethods.forEach((methodName, index) => {
+                const method = packageServices.Msg[methodName];
+                // Get the aliased function name using the same logic as bundler
+                const aliasedFunctionName = getAliasedFunctionName(builder, method.functionName, packageName);
+                const aliasedHookName = getAliasedFunctionName(builder, method.hookName, packageName);
+                packageDocs += `**${methodName}**\n\n`;
+                // Add comment directly after title (if exists)
+                if (method.comment) {
+                    packageDocs += `${cleanComment(method.comment)}\n\n`;
+                }
+                // Add import code block
+                const functionImportPath = getImportPath(builder, method.functionName, packageName, projectName, method.sourceFilename);
+                const hookImportPath = method.hookName ? getImportPath(builder, method.hookName, packageName, projectName, method.hookSourceFilename) : functionImportPath;
+                packageDocs += `\`\`\`ts\n`;
+                packageDocs += `import { ${aliasedFunctionName} } from '${functionImportPath}'\n`;
+                if (method.hookName && aliasedHookName !== aliasedFunctionName) {
+                    packageDocs += `import { ${aliasedHookName} } from '${hookImportPath}'\n`;
+                }
+                packageDocs += `\`\`\`\n\n`;
+                // Add function details in organized format
+                packageDocs += `| Field | Value | Source |\n`;
+                packageDocs += `| --- | --- | --- |\n`;
+                // Function source
+                const functionSourcePath = method.sourceFilename || `${packageName.replace(/\./g, '/')}/tx.rpc.func.ts`;
+                packageDocs += `| Function | \`${aliasedFunctionName}\` | [View source ↗](${functionSourcePath}) |\n`;
+                // Hook source (React)
+                if (method.hookName && aliasedHookName !== aliasedFunctionName) {
+                    const hookSourcePath = method.hookSourceFilename || `${packageName.replace(/\./g, '/')}/tx.rpc.react.ts`;
+                    packageDocs += `| Hook | \`${aliasedHookName}\` | [View source ↗](${hookSourcePath}) |\n`;
+                }
+                // Request type source
+                if (method.requestType) {
+                    const requestSourcePath = method.typeSourceFilename || `${packageName.replace(/\./g, '/')}/tx.ts`;
+                    packageDocs += `| Request | \`${method.requestType}\` | [View source ↗](${requestSourcePath}) |\n`;
+                }
+                // Response type source
+                if (method.responseType) {
+                    const responseSourcePath = method.typeSourceFilename || `${packageName.replace(/\./g, '/')}/tx.ts`;
+                    packageDocs += `| Response | \`${method.responseType}\` | [View source ↗](${responseSourcePath}) |\n`;
+                }
+                // Add spacing between methods (but not after the last one)
+                if (index < msgMethods.length - 1) {
+                    packageDocs += '\n---\n\n';
+                }
+                else {
+                    packageDocs += '\n';
+                }
+            });
+        }
+        // Add spacing between packages
+        packageDocs += '\n';
+    });
+    const readmeContent = `# Package Documentation
+${packageDocs}`;
+    (0, files_1.writeContentToFile)(builder.outPath, builder.options, readmeContent, readmePath);
+};
+exports.plugin = plugin;

package/main/generators/create-rpc-msg-client-all.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const dotty = __importStar(require("dotty"));
+const proto_parser_1 = require("@cosmology/proto-parser");
+const path_1 = require("path");
+const ast_1 = require("@cosmology/ast");
+const utils_1 = require("../utils");
+const imports_1 = require("../imports");
+const build_1 = require("../build");
+const case_1 = require("case");
+const plugin = (builder, bundler) => {
+    // if not enabled, exit
+    if (!builder.options?.rpcClients?.enabled) {
+        return;
+    }
+    if (builder.options?.rpcClients?.inline) {
+        return;
+    }
+    // if no scopes, do them all!
+    if (!builder.options.rpcClients.scoped ||
+        !builder.options.rpcClients.scoped.length ||
+        !builder.options.rpcClients.scopedIsExclusive) {
+        return makeAllRPCBundles(builder, bundler);
+    }
+};
+exports.plugin = plugin;
+const getFileName = (dir, filename) => {
+    filename = filename.replace(/\.ts$/, '');
+    const localname = (0, path_1.join)(dir, filename + '.tx');
+    return localname + '.ts';
+};
+const makeAllRPCBundles = (builder, bundler) => {
+    if (!builder.options.rpcClients.bundle)
+        return;
+    const dir = bundler.bundle.base;
+    const filename = 'rpc';
+    // refs with services
+    const refs = builder.store.getProtos().filter((ref) => {
+        const proto = (0, proto_parser_1.getNestedProto)(ref.traversed);
+        if (!proto?.Msg || proto.Msg?.type !== 'Service') {
+            return;
+        }
+        return true;
+    });
+    const check = refs.filter((ref) => {
+        const [base] = ref.proto.package.split('.');
+        return base === bundler.bundle.base;
+    });
+    if (!check.length) {
+        // if there are no services
+        // exit the plugin
+        return;
+    }
+    const packages = refs.reduce((m, ref) => {
+        const [base] = ref.proto.package.split('.');
+        if (base === 'cosmos' || base === bundler.bundle.base)
+            return [...new Set([...m, ref.proto.package])];
+        return m;
+    }, []);
+    const methodName = 'createRPCMsgClient';
+    const localname = getFileName(dir, filename ?? 'rpc');
+    const obj = {};
+    builder.rpcMsgClients.forEach(file => {
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        if (!packages.includes(file.package)) {
+            return;
+        }
+        const f = localname;
+        const f2 = file.localname;
+        const importPath = (0, utils_1.getRelativePath)(f, f2);
+        dotty.put(obj, file.package, importPath);
+    });
+    const ctx = new build_1.TelescopeParseContext((0, proto_parser_1.createEmptyProtoRef)(dir, localname), builder.store, builder.options);
+    let rpcast;
+    let msgExt = [];
+    let txRpcImport = [];
+    switch (builder.options?.rpcClients?.type) {
+        case "grpc-gateway":
+        case "tendermint":
+            ctx.proto.addUtil('Rpc');
+            rpcast = (0, ast_1.createScopedRpcFactory)(obj, methodName, 'MsgClientImpl', // make option later,
+            ctx.options);
+            if (ctx.proto.pluginValue('env') === 'v-next' && ctx.proto.pluginValue('rpcClients.extensions') && ctx.proto.pluginValue('stargateClients.addGetTxRpc')) {
+                const txRpcName = 'getSigning' + (0, case_1.pascal)(bundler.bundle.base + 'TxRpc');
+                txRpcImport = (0, ast_1.importStmt)([txRpcName], `./client${ctx.options.restoreImportExtension ?? ""}`);
+                msgExt = (0, ast_1.createRpcMsgExtension)(ctx.proto, txRpcName);
+            }
+            break;
+        case "grpc-web":
+            ctx.proto.addUtil('grpc');
+            ctx.proto.addUtil('NodeHttpTransport');
+            rpcast = (0, ast_1.createScopedGrpcWebMsgFactory)(obj, methodName, 'MsgClientImpl', // make option later,
+            ctx.options);
+            break;
+        default:
+            break;
+    }
+    const serviceImports = (0, imports_1.getDepsFromQueries)(ctx.queries, localname);
+    const imports = (0, imports_1.aggregateImports)(ctx, serviceImports, localname);
+    const importStmts = (0, imports_1.getImportStatements)(localname, [...(0, utils_1.fixlocalpaths)(imports)], builder.options);
+    const prog = []
+        .concat(txRpcImport)
+        .concat(importStmts)
+        .concat(rpcast)
+        .concat(msgExt);
+    const writeFilename = bundler.getFilename(localname);
+    bundler.writeAst(prog, writeFilename);
+    bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname);
+};

package/main/generators/create-rpc-msg-client-scoped.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const dotty = __importStar(require("dotty"));
+const proto_parser_1 = require("@cosmology/proto-parser");
+const path_1 = require("path");
+const ast_1 = require("@cosmology/ast");
+const utils_1 = require("../utils");
+const imports_1 = require("../imports");
+const build_1 = require("../build");
+const case_1 = require("case");
+const plugin = (builder, bundler) => {
+    // if not enabled, exit
+    if (!builder.options?.rpcClients?.enabled) {
+        return;
+    }
+    if (builder.options?.rpcClients?.inline) {
+        return;
+    }
+    // we have scopes!
+    builder.options.rpcClients.scoped?.forEach(rpc => {
+        if (rpc.dir !== bundler.bundle.base)
+            return;
+        makeRPC(builder, bundler, rpc);
+    });
+};
+exports.plugin = plugin;
+const getFileName = (dir, filename) => {
+    filename = filename.replace(/\.ts$/, '');
+    const localname = (0, path_1.join)(dir, filename + '.tx');
+    return localname + '.ts';
+};
+const makeRPC = (builder, bundler, rpc) => {
+    const dir = rpc.dir;
+    const packages = rpc.packages;
+    const methodName = rpc.methodNameTx ?? 'createRPCMsgClient';
+    const localname = getFileName(dir, rpc.filename ?? 'rpc');
+    const obj = {};
+    builder.rpcMsgClients.forEach(file => {
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        if (!packages.includes(file.package)) {
+            return;
+        }
+        const f = localname;
+        const f2 = file.localname;
+        const importPath = (0, utils_1.getRelativePath)(f, f2);
+        dotty.put(obj, file.package, importPath);
+    });
+    const ctx = new build_1.TelescopeParseContext((0, proto_parser_1.createEmptyProtoRef)(dir, localname), builder.store, builder.options);
+    let rpcast;
+    let msgExt = [];
+    let txRpcImport = [];
+    switch (builder.options?.rpcClients?.type) {
+        case "grpc-gateway":
+        // TODO no working scoped clients for grpc-gateway right now
+        case "tendermint":
+            // TODO add addUtil to generic context
+            ctx.proto.addUtil('Rpc');
+            rpcast = (0, ast_1.createScopedRpcFactory)(obj, methodName, 'MsgClientImpl', // make option later,
+            ctx.options);
+            if (rpc.isAll && ctx.proto.pluginValue('env') === 'v-next' && ctx.proto.pluginValue('rpcClients.extensions') && ctx.proto.pluginValue('stargateClients.addGetTxRpc')) {
+                const txRpcName = 'getSigning' + (0, case_1.pascal)(bundler.bundle.base + 'TxRpc');
+                txRpcImport = (0, ast_1.importStmt)([txRpcName], `./client${ctx.options.restoreImportExtension ?? ""}`);
+                msgExt = (0, ast_1.createRpcMsgExtension)(ctx.proto, txRpcName);
+            }
+            break;
+        case "grpc-web":
+            ctx.proto.addUtil('grpc');
+            ctx.proto.addUtil('NodeHttpTransport');
+            rpcast = (0, ast_1.createScopedGrpcWebMsgFactory)(obj, methodName, 'MsgClientImpl', // make option later,
+            ctx.options);
+            break;
+        default:
+            break;
+    }
+    const serviceImports = (0, imports_1.getDepsFromQueries)(ctx.queries, localname);
+    const imports = (0, imports_1.aggregateImports)(ctx, serviceImports, localname);
+    const importStmts = (0, imports_1.getImportStatements)(localname, [...(0, utils_1.fixlocalpaths)(imports)], builder.options);
+    const prog = []
+        .concat(txRpcImport)
+        .concat(importStmts)
+        .concat(rpcast)
+        .concat(msgExt);
+    const filename = bundler.getFilename(localname);
+    bundler.writeAst(prog, filename);
+    if (rpc.addToBundle) {
+        bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname);
+    }
+};

package/main/generators/create-rpc-msg-clients.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const imports_1 = require("../imports");
+const ast_1 = require("@cosmology/ast");
+const proto_parser_1 = require("@cosmology/proto-parser");
+const parse_1 = require("../parse");
+const utils_1 = require("@cosmology/utils");
+const plugin = (builder, bundler) => {
+    // if (!builder.options.rpcClients.enabled) {
+    //     return;
+    // }
+    const instantRpcBundlerFiles = {};
+    const mutationContexts = bundler
+        .contexts
+        .filter(context => context.mutations.length > 0);
+    const clients = mutationContexts.map(c => {
+        const enabled = c.proto.pluginValue('rpcClients.enabled');
+        if (!enabled)
+            return;
+        const inline = c.proto.pluginValue('rpcClients.inline');
+        if (inline)
+            return;
+        if (c.proto.isExcluded())
+            return;
+        const useCamelCase = c.proto.pluginValue("rpcClients.camelCase");
+        const localname = bundler.getLocalFilename(c.ref, 'rpc.msg');
+        const filename = bundler.getFilename(localname);
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        (0, parse_1.parse)(ctx);
+        const proto = (0, proto_parser_1.getNestedProto)(c.ref.traversed);
+        // hard-coding, for now, only Msg service
+        if (!proto?.Msg || proto.Msg?.type !== 'Service') {
+            return;
+        }
+        ////////
+        const asts = [];
+        const bundlerFile = {
+            proto: c.ref.filename,
+            package: c.ref.proto.package,
+            localname,
+            filename,
+            isMsg: true
+        };
+        switch (c.proto.pluginValue("rpcClients.type")) {
+            case 'grpc-gateway':
+                asts.push((0, ast_1.createGRPCGatewayMsgClass)(ctx.generic, proto.Msg));
+                break;
+            case 'grpc-web':
+                asts.push((0, ast_1.createGrpcWebMsgInterface)(ctx.generic, proto.Msg));
+                asts.push((0, ast_1.createGrpcWebMsgClass)(ctx.generic, proto.Msg));
+                asts.push((0, ast_1.GetDesc)(ctx.generic, proto.Msg));
+                const Desces = (0, ast_1.getMethodDesc)(ctx.generic, proto.Msg);
+                for (let i = 0; i < Desces.length; i++) {
+                    const element = Desces[i];
+                    asts.push(element);
+                }
+                asts.push((0, ast_1.grpcWebRpcInterface)());
+                asts.push((0, ast_1.getGrpcWebImpl)(ctx.generic));
+                break;
+            case 'tendermint':
+            default:
+                asts.push((0, ast_1.createRpcClientInterface)(ctx.generic, proto.Msg));
+                const svc = proto.Msg;
+                const instantOps = c.options.rpcClients?.instantOps ?? [];
+                instantOps.forEach((item) => {
+                    let nameMapping = {
+                        ...(0, utils_1.swapKeyValue)(item.nameMapping?.All ?? {}),
+                        ...(0, utils_1.swapKeyValue)(item.nameMapping?.Msg ?? {})
+                    };
+                    // get all query methods
+                    const patterns = item.include?.patterns;
+                    const serviceTypes = item.include?.serviceTypes;
+                    if (serviceTypes && !serviceTypes.includes("Tx")) {
+                        return;
+                    }
+                    const methodKeys = (0, utils_1.getQueryMethodNames)(bundlerFile.package, Object.keys(svc.methods ?? {}), patterns, useCamelCase ? utils_1.camel : String);
+                    if (!methodKeys || !methodKeys.length) {
+                        return;
+                    }
+                    asts.push((0, ast_1.createRpcClientInterface)(ctx.generic, svc, item.className, methodKeys, nameMapping));
+                    bundlerFile.instantExportedMethods = methodKeys.map((key) => svc.methods[key]);
+                    if (!instantRpcBundlerFiles[item.className]) {
+                        instantRpcBundlerFiles[item.className] = [];
+                    }
+                    instantRpcBundlerFiles[item.className].push({ ...bundlerFile });
+                });
+                asts.push((0, ast_1.createRpcClientClass)(ctx.generic, proto.Msg));
+                const env = c.proto.pluginValue('env');
+                if (env === 'v-next') {
+                    asts.push((0, ast_1.createRpcClientImpl)(ctx.generic, svc));
+                }
+        }
+        ////////
+        const serviceImports = (0, imports_1.getDepsFromQueries)(ctx.mutations, localname);
+        // TODO we do NOT need all imports...
+        const imports = (0, imports_1.buildAllImports)(ctx, serviceImports, localname);
+        const prog = []
+            .concat(imports)
+            .concat(ctx.body)
+            .concat(asts);
+        bundler.writeAst(prog, filename);
+        bundler.addToBundle(c, localname);
+        return {
+            package: c.ref.proto.package,
+            localname,
+            filename
+        };
+    }).filter(Boolean);
+    bundler.addRPCMsgClients(clients);
+    Object.keys(instantRpcBundlerFiles).forEach((className) => {
+        bundler.addStateManagers(`instantRpc_${className}`, instantRpcBundlerFiles[className]);
+    });
+};
+exports.plugin = plugin;