@hyperweb/telescope 1.15.0

package/main/generators/create-bundle.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const ast_1 = require("@cosmology/ast");
+const utils_1 = require("@cosmology/utils");
+const plugin = (builder, bundler) => {
+    if (!builder.options.bundle.enabled) {
+        return;
+    }
+    let prog = [];
+    if (builder.options.bundle.type === "namespace") {
+        const importPaths = (0, utils_1.duplicateImportPathsWithExt)(bundler.bundle.importPaths, builder.options.restoreImportExtension);
+        // [x] bundle
+        const body = (0, ast_1.recursiveModuleBundle)(builder.options, bundler.bundle.bundleVariables);
+        prog = prog.concat(importPaths).concat(body);
+    }
+    else if (builder.options.bundle.type === "module") {
+        // get export objs
+        const exportObjs = bundler.bundle.exportObjs;
+        if (!exportObjs) {
+            return;
+        }
+        // check each of exported identifiers is duplicated
+        exportObjs.forEach((exportObj) => {
+            const duplicatedTypeNames = exportObj.exportedIdentifiers.filter((identifier) => {
+                let isDuplicated = false;
+                if (exportObj.isHelperFunc) {
+                    const duplicatedHelperFuncs = builder.store.getHelperFuncsInMultipleFiles();
+                    isDuplicated = duplicatedHelperFuncs.some((helperFunc) => {
+                        return helperFunc === identifier;
+                    });
+                }
+                else {
+                    const duplicatedTypes = builder.store.getTypesInMultipleFiles();
+                    isDuplicated = duplicatedTypes.some((type) => {
+                        return type === identifier;
+                    });
+                }
+                return isDuplicated;
+            });
+            if (duplicatedTypeNames.length > 0) {
+                // export each, some duplicated with alias
+                const typesWithAlias = exportObj.exportedIdentifiers.map((identifier) => {
+                    const duplicatedType = duplicatedTypeNames.find((type) => type === identifier);
+                    if (duplicatedType) {
+                        let alias;
+                        if (exportObj.isHelperFunc) {
+                            const serialNumber = builder.store.getAndIncTypeSerialNumber(identifier);
+                            if (serialNumber > 0) {
+                                alias = (0, utils_1.makeAliasNameWithPackageAtEnd)({ package: exportObj.pkg, name: identifier });
+                            }
+                            else {
+                                alias = identifier;
+                            }
+                        }
+                        else {
+                            const serialNumber = builder.store.getAndIncTypeSerialNumber(identifier);
+                            if (serialNumber > 0) {
+                                alias = (0, utils_1.makeAliasName)({ package: exportObj.pkg, name: identifier });
+                            }
+                            else {
+                                alias = identifier;
+                            }
+                        }
+                        return { name: identifier, alias: alias };
+                    }
+                    return { name: identifier, alias: identifier };
+                });
+                prog.push((0, ast_1.exportTypesWithAlias)(typesWithAlias, exportObj.relativePath));
+            }
+            else {
+                // export *
+                prog.push((0, ast_1.exportAllFromRelPath)(exportObj.relativePath));
+            }
+        });
+    }
+    const localname = bundler.bundle.bundleFile;
+    const filename = bundler.getFilename(localname);
+    bundler.writeAst(prog, filename);
+    // [x] write an index file for each base
+    bundler.files.forEach((file) => builder.files.push(file));
+};
+exports.plugin = plugin;

package/main/generators/create-cosmwasm-bundle.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const ts_codegen_1 = require("@cosmwasm/ts-codegen");
+const plugin = async (builder) => {
+    if (!builder.options.cosmwasm) {
+        return;
+    }
+    const input = builder.options.cosmwasm;
+    const cosmWasmBuilder = new ts_codegen_1.TSBuilder(input);
+    await cosmWasmBuilder.build();
+    const file = input.options.bundle.bundleFile;
+    builder.files.push(file);
+};
+exports.plugin = plugin;

package/main/generators/create-custom-stargate-clients.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const path_1 = require("path");
+const ast_1 = require("@cosmology/ast");
+const case_1 = require("case");
+const utils_1 = require("@cosmology/utils");
+const imports_1 = require("../imports");
+const files_1 = require("../utils/files");
+const plugin = (builder, allRegistries, allConverters) => {
+    builder.options.rpcClients.clientStyle.customClientOption.map((currentClient) => {
+        if (!allRegistries || !allRegistries.length) {
+            return;
+        }
+        const registryImports = [];
+        const converterImports = [];
+        const clientFile = currentClient.fileName;
+        builder.files.push(clientFile);
+        const ctxRef = {
+            absolute: '/',
+            filename: '/',
+            proto: {
+                imports: [],
+                package: currentClient.name,
+                root: {},
+            }
+        };
+        const ctx = new ast_1.GenericParseContext(ctxRef, null, builder.options);
+        const registryVariables = [];
+        const converterVariables = [];
+        const filteredRegistries = allRegistries.filter(item => (0, utils_1.isPackageIncluded)(item.package, currentClient.include.patterns));
+        filteredRegistries.forEach(registry => {
+            let rel = (0, path_1.relative)((0, path_1.dirname)(clientFile), registry.localname);
+            if (!rel.startsWith('.'))
+                rel = `./${rel}`;
+            rel = (0, utils_1.toPosixPath)(rel);
+            const variable = (0, utils_1.variableSlug)(registry.localname);
+            registryVariables.push(variable);
+            registryImports.push((0, ast_1.importNamespace)(variable, rel));
+        });
+        const filteredConverters = allConverters.filter(item => (0, utils_1.isPackageIncluded)(item.package, currentClient.include.patterns));
+        filteredConverters.forEach(converter => {
+            let rel = (0, path_1.relative)((0, path_1.dirname)(clientFile), converter.localname);
+            if (!rel.startsWith('.'))
+                rel = `./${rel}`;
+            rel = (0, utils_1.toPosixPath)(rel);
+            const variable = (0, utils_1.variableSlug)(converter.localname);
+            converterVariables.push(variable);
+            converterImports.push((0, ast_1.importNamespace)(variable, rel));
+        });
+        const name = 'get' + (0, case_1.pascal)(currentClient.name + 'SigningClient');
+        const txRpcName = 'get' + (0, case_1.pascal)(currentClient.name + 'SigningTxRpc');
+        const prefix = (0, case_1.camel)(currentClient.name);
+        const aminos = (0, ast_1.createStargateClientAminoRegistry)({
+            context: ctx,
+            aminos: converterVariables,
+            aminoConverters: prefix + 'AminoConverters'
+        });
+        const protos = (0, ast_1.createStargateClientProtoRegistry)({
+            context: ctx,
+            registries: registryVariables,
+            protoTypeRegistry: prefix + 'ProtoRegistry'
+        });
+        const clientOptions = (0, ast_1.createStargateClientOptions)({
+            context: ctx,
+            name: name + 'Options',
+            protoTypeRegistry: prefix + 'ProtoRegistry',
+            aminoConverters: prefix + 'AminoConverters'
+        });
+        const clientBody = (0, ast_1.createStargateClient)({
+            context: ctx,
+            name,
+            options: name + 'Options',
+        });
+        let getTxRpc;
+        if (ctx.pluginValue("stargateClients.addGetTxRpc")) {
+            getTxRpc = (0, ast_1.createGetTxRpc)(ctx, txRpcName, name);
+        }
+        const imports = (0, imports_1.buildAllImportsFromGenericContext)(ctx, clientFile);
+        let importDecls = [...imports, ...registryImports, ...converterImports];
+        importDecls = (0, utils_1.duplicateImportPathsWithExt)(importDecls, builder.options.restoreImportExtension);
+        let cProg = importDecls
+            .concat(aminos)
+            .concat(protos)
+            .concat(clientOptions)
+            .concat(clientBody);
+        // replace all backslash path for windows
+        for (let i = 0; i < cProg.length; i++) {
+            if (cProg[i].source?.value) {
+                cProg[i].source.value = (0, utils_1.toPosixPath)(cProg[i].source?.value);
+            }
+        }
+        if (getTxRpc) {
+            cProg = cProg.concat(getTxRpc);
+        }
+        const clientOutFile = (0, path_1.join)(builder.outPath, clientFile);
+        (0, files_1.writeAstToFile)(builder.outPath, builder.options, cProg, clientOutFile);
+    });
+};
+exports.plugin = plugin;

package/main/generators/create-helpers.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const path_1 = require("path");
+const mkdirp_1 = require("mkdirp");
+const package_json_1 = __importDefault(require("../../package.json"));
+const files_1 = require("../utils/files");
+const helpers_1 = require("../helpers");
+const version = process.env.NODE_ENV === "test" ? "latest" : package_json_1.default.version;
+const header = `/**
+* This file and any referenced files were automatically generated by ${package_json_1.default.name}@${version}
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+\n`;
+const write = (builder, indexFile, content) => {
+    const indexOutFile = (0, path_1.join)(builder.outPath, indexFile);
+    mkdirp_1.mkdirp.sync((0, path_1.dirname)(indexOutFile));
+    (0, files_1.writeContentToFile)(builder.outPath, builder.options, header + content, indexOutFile);
+};
+const plugin = (builder) => {
+    write(builder, "helpers.ts", builder.options.prototypes.typingsFormat.num64 === "bigint"
+        ? (0, helpers_1.getHelperForBigint)(builder.options)
+        : (0, helpers_1.getHelper)(builder.options));
+    // should be exported
+    if (builder.options.stargateClients.addGetTxRpc ||
+        builder.options.includeExternalHelpers ||
+        builder.options.reactQuery?.enabled ||
+        builder.options?.helperFunctions?.enabled) {
+        // also react-query needs these...
+        builder.files.push("extern.ts");
+        if (builder.options?.helperFunctions?.enabled) {
+            write(builder, "extern.ts", helpers_1.externalIcJs);
+        }
+        else {
+            write(builder, "extern.ts", builder.options.rpcClients?.useConnectComet || builder.options.rpcClients?.useMakeClient ? helpers_1.externalComet : helpers_1.external);
+        }
+    }
+    if (builder.options.helperFunctions?.enabled) {
+        builder.files.push("helper-func-types.ts");
+        if (builder.options.interfaces?.enabled && builder.options.helperFunctions?.useGlobalDecoderRegistry) {
+            write(builder, "helper-func-types.ts", (0, helpers_1.getHelperFuncTypesForInterface)(builder.options));
+        }
+        else {
+            write(builder, "helper-func-types.ts", (0, helpers_1.getHelperFuncTypes)(builder.options));
+        }
+    }
+    if (builder.options.reactQuery?.enabled ||
+        (builder.options?.helperFunctions?.enabled &&
+            builder.options?.helperFunctions?.hooks?.react)) {
+        builder.files.push("react-query.ts");
+        if (builder.options?.helperFunctions?.enabled &&
+            builder.options?.helperFunctions?.hooks?.react) {
+            if (builder.options?.useInterchainJs) {
+                write(builder, "react-query.ts", (0, helpers_1.getReactQueryHelperHooksIcJs)(builder.options));
+            }
+            else {
+                write(builder, "react-query.ts", (0, helpers_1.getReactQueryHelperHooks)(builder.options));
+            }
+        }
+        else {
+            write(builder, "react-query.ts", (0, helpers_1.getReactQueryHelper)(builder.options));
+        }
+    }
+    if (builder.options?.helperFunctions?.enabled &&
+        builder.options?.helperFunctions?.hooks?.vue) {
+        builder.files.push("vue-query.ts");
+        write(builder, "vue-query.ts", (0, helpers_1.getVueQueryHelperHooks)(builder.options));
+    }
+    if (builder.options.mobx?.enabled) {
+        builder.files.push("mobx.ts");
+        write(builder, "mobx.ts", helpers_1.mobx);
+    }
+    if (builder.options.pinia?.enabled) {
+        builder.files.push("pinia-endpoint.ts");
+        write(builder, "pinia-endpoint.ts", helpers_1.pinia);
+    }
+    if (builder.options.rpcClients?.type === "grpc-gateway") {
+        builder.files.push("grpc-gateway.ts");
+        write(builder, "grpc-gateway.ts", helpers_1.grpcGateway);
+    }
+    if (builder.options.rpcClients?.type === "grpc-web") {
+        builder.files.push("grpc-web.ts");
+        write(builder, "grpc-web.ts", helpers_1.grpcWeb);
+    }
+    if (builder.options.prototypes.typingsFormat.customTypes.useEnhancedDecimal) {
+        builder.files.push("decimals.ts");
+        write(builder, "decimals.ts", helpers_1.decimal);
+    }
+    if (!builder.options.prototypes.typingsFormat.toJsonUnknown &&
+        builder.options.prototypes.methods.toJSON) {
+        builder.files.push("json-safe.ts");
+        write(builder, "json-safe.ts", helpers_1.jsonSafe);
+    }
+    if (builder.options.prototypes.typingsFormat.num64 === "bigint") {
+        builder.files.push("varint.ts");
+        write(builder, "varint.ts", helpers_1.varint);
+        builder.files.push("utf8.ts");
+        write(builder, "utf8.ts", helpers_1.utf8);
+        builder.files.push("binary.ts");
+        write(builder, "binary.ts", (0, helpers_1.getHelperForBinary)(builder.options));
+    }
+    if (builder.options.prototypes?.typingsFormat?.useTelescopeGeneratedType ||
+        (builder.options.interfaces?.enabled &&
+            (builder.options.interfaces?.useGlobalDecoderRegistry || builder.options.helperFunctions?.useGlobalDecoderRegistry)) ||
+        builder.options.helperFunctions?.enabled) {
+        builder.files.push("types.ts");
+        write(builder, "types.ts", (0, helpers_1.getTypesHelper)(builder.options));
+    }
+    if (builder.options.interfaces?.enabled &&
+        (builder.options.interfaces?.useGlobalDecoderRegistry || builder.options.helperFunctions?.useGlobalDecoderRegistry)) {
+        builder.files.push("registry.ts");
+        write(builder, "registry.ts", (0, helpers_1.getRegistryHelper)(builder.options));
+    }
+};
+exports.plugin = plugin;

package/main/generators/create-index.js

@@ -0,0 +1,75 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const utils_1 = require("../utils");
+const path_1 = require("path");
+const mkdirp_1 = require("mkdirp");
+const t = __importStar(require("@babel/types"));
+const generator_1 = __importDefault(require("@babel/generator"));
+//@ts-ignore
+const package_json_1 = __importDefault(require("../../package.json"));
+const files_1 = require("../utils/files");
+const version = process.env.NODE_ENV === "test" ? "latest" : package_json_1.default.version;
+const plugin = (builder) => {
+    if (!builder.options.bundle.enabled) {
+        return;
+    }
+    // finally, write one index file with all files, exported
+    const indexFile = "index.ts";
+    const indexOutFile = (0, path_1.join)(builder.outPath, indexFile);
+    const stmts = builder.files.map((file) => t.exportAllDeclaration(t.stringLiteral((0, utils_1.getRelativePath)(indexFile, file, builder.options.restoreImportExtension))));
+    const finalAst = t.program(stmts);
+    const indexContent = (0, generator_1.default)(finalAst).code;
+    mkdirp_1.mkdirp.sync((0, path_1.dirname)(indexOutFile));
+    const header = `/**
+  * This file and any referenced files were automatically generated by ${package_json_1.default.name}@${version}
+  * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+    * and run the transpile command or npm scripts command that is used to regenerate this bundle.
+  */
+ \n`;
+    (0, files_1.writeContentToFile)(builder.outPath, builder.options, header + indexContent, indexOutFile);
+    if (builder.options.bundle.enabled &&
+        builder.options.bundle.type === "module") {
+        const typePackageMapping = builder.store.getTypesInMultipleFiles();
+        const servicePackageMapping = builder.store.getHelperFuncsInMultipleFiles();
+        const typePackageMappingMap = typePackageMapping.reduce((obj, type) => {
+            const pkg = builder.store.getTypeFilesMapping(type);
+            obj[type] = pkg.join(", ");
+            return obj;
+        }, {});
+        // console.log("types in multiple files:", JSON.stringify(typePackageMappingMap, null, 2));
+        const servicePackageMappingMap = servicePackageMapping.reduce((obj, service) => {
+            const pkg = builder.store.getHelperFuncFilesMapping(service);
+            obj[service] = pkg.join(", ");
+            return obj;
+        }, {});
+        // console.log("services in multiple files:", JSON.stringify(servicePackageMappingMap, null, 2));
+    }
+};
+exports.plugin = plugin;

package/main/generators/create-lcd-client-all.js

@@ -0,0 +1,116 @@
+"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 build_1 = require("../build");
+const imports_1 = require("../imports");
+const plugin = (builder, bundler) => {
+    // if not enabled, exit
+    if (!builder.options?.lcdClients?.enabled) {
+        return;
+    }
+    // if no scopes, do them all!
+    if (!builder.options.lcdClients.scoped ||
+        !builder.options.lcdClients.scoped.length ||
+        !builder.options.lcdClients.scopedIsExclusive) {
+        return createAllLCDBundles(builder, bundler);
+    }
+};
+exports.plugin = plugin;
+const getFileName = (dir, filename) => {
+    const localname = (0, path_1.join)(dir, filename ?? 'lcd.ts');
+    if (localname.endsWith('.ts'))
+        return localname;
+    return localname + '.ts';
+};
+const createAllLCDBundles = (builder, bundler) => {
+    if (!builder.options.lcdClients.bundle)
+        return;
+    const dir = bundler.bundle.base;
+    const filename = 'lcd.ts';
+    // refs with services
+    const refs = builder.store.getProtos().filter((ref) => {
+        const proto = (0, proto_parser_1.getNestedProto)(ref.traversed);
+        //// Anything except Msg Service OK...
+        const allowedRpcServices = builder.options.rpcClients.enabledServices.filter(a => a !== 'Msg');
+        const found = allowedRpcServices.some(svc => {
+            return proto?.[svc] &&
+                proto[svc]?.type === 'Service';
+        });
+        if (!found) {
+            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 = 'createLCDClient';
+    const localname = getFileName(dir, filename);
+    const obj = {};
+    builder.lcdClients.forEach(file => {
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        // if (!packages.includes(file.package)) {
+        if (!(0, proto_parser_1.isRefIncluded)((0, proto_parser_1.createEmptyProtoRef)(file.package, file.proto), {
+            packages,
+        })) {
+            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);
+    const lcdast = (0, ast_1.createScopedLCDFactory)(ctx.proto, obj, methodName, 'LCDQueryClient' // make option later
+    );
+    const imports = (0, imports_1.aggregateImports)(ctx, {}, localname);
+    const importStmts = (0, imports_1.getImportStatements)(localname, [...(0, utils_1.fixlocalpaths)(imports)], builder.options);
+    const prog = []
+        .concat(importStmts)
+        .concat(lcdast);
+    const writeFilename = bundler.getFilename(localname);
+    bundler.writeAst(prog, writeFilename);
+    bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname);
+};

package/main/generators/create-lcd-client-scoped.js

@@ -0,0 +1,89 @@
+"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 build_1 = require("../build");
+const imports_1 = require("../imports");
+const plugin = (builder, bundler) => {
+    // if not enabled, exit
+    if (!builder.options?.lcdClients?.enabled) {
+        return;
+    }
+    // we have scopes!
+    builder.options.lcdClients.scoped?.forEach(lcd => {
+        if (lcd.dir !== bundler.bundle.base)
+            return;
+        makeLCD(builder, bundler, lcd);
+    });
+};
+exports.plugin = plugin;
+const getFileName = (dir, filename) => {
+    const localname = (0, path_1.join)(dir, filename ?? 'lcd.ts');
+    if (localname.endsWith('.ts'))
+        return localname;
+    return localname + '.ts';
+};
+const makeLCD = (builder, bundler, lcd) => {
+    const dir = lcd.dir;
+    const packages = lcd.packages;
+    const protos = lcd.protos;
+    const methodName = lcd.methodName ?? 'createLCDClient';
+    const localname = getFileName(dir, lcd.filename);
+    const obj = {};
+    builder.lcdClients.forEach(file => {
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        // if (!packages.includes(file.package)) {
+        if (!(0, proto_parser_1.isRefIncluded)((0, proto_parser_1.createEmptyProtoRef)(file.package, file.proto), {
+            packages,
+            protos
+        })) {
+            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);
+    const lcdast = (0, ast_1.createScopedLCDFactory)(ctx.proto, obj, methodName, 'LCDQueryClient' // make option later
+    );
+    const imports = (0, imports_1.aggregateImports)(ctx, {}, localname);
+    const importStmts = (0, imports_1.getImportStatements)(localname, [...(0, utils_1.fixlocalpaths)(imports)], builder.options);
+    const prog = []
+        .concat(importStmts)
+        .concat(lcdast);
+    const filename = bundler.getFilename(localname);
+    bundler.writeAst(prog, filename);
+    if (lcd.addToBundle) {
+        bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname);
+    }
+};

package/main/generators/create-lcd-clients.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const imports_1 = require("../imports");
+const proto_parser_1 = require("@cosmology/proto-parser");
+const parse_1 = require("../parse");
+const ast_1 = require("@cosmology/ast");
+const plugin = (builder, bundler) => {
+    if (!builder.options.lcdClients.enabled) {
+        return;
+    }
+    const queryContexts = bundler
+        .contexts
+        .filter(context => context.queries.length > 0 ||
+        context.services.length > 0);
+    // [x] write out one registry helper for all contexts w/mutations
+    const lcdClients = queryContexts.map(c => {
+        const enabled = c.proto.pluginValue('lcdClients.enabled');
+        if (!enabled)
+            return;
+        if (c.proto.isExcluded())
+            return;
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        (0, parse_1.parse)(ctx);
+        const proto = (0, proto_parser_1.getNestedProto)(c.ref.traversed);
+        //// Anything except Msg Service OK...
+        const allowedRpcServices = builder.options.rpcClients.enabledServices.filter(a => a !== 'Msg');
+        const found = allowedRpcServices.some(svc => {
+            return proto?.[svc] &&
+                proto[svc]?.type === 'Service';
+        });
+        if (!found) {
+            return;
+        }
+        ///
+        let getImportsFrom;
+        // get imports
+        allowedRpcServices.forEach(svcKey => {
+            if (proto[svcKey]) {
+                if (svcKey === 'Query') {
+                    getImportsFrom = ctx.queries;
+                }
+                else {
+                    getImportsFrom = ctx.services;
+                }
+            }
+        });
+        const localname = bundler.getLocalFilename(c.ref, 'lcd');
+        const filename = bundler.getFilename(localname);
+        let ast = null;
+        allowedRpcServices.forEach(svcKey => {
+            if (proto[svcKey]) {
+                ast = (0, ast_1.createLCDClient)(ctx.generic, proto[svcKey]);
+            }
+        });
+        if (!ast) {
+            return;
+        }
+        const serviceImports = (0, imports_1.getDepsFromQueries)(getImportsFrom, localname);
+        const imports = (0, imports_1.buildAllImports)(ctx, serviceImports, localname);
+        const prog = []
+            .concat(imports)
+            .concat(ctx.body)
+            .concat(ast);
+        bundler.writeAst(prog, filename);
+        bundler.addToBundle(c, localname);
+        return {
+            proto: c.ref.filename,
+            // TODO use this to build LCD aggregators with scopes
+            package: c.ref.proto.package,
+            localname,
+            filename
+        };
+    }).filter(Boolean);
+    bundler.addLCDClients(lcdClients);
+};
+exports.plugin = plugin;