@hyperweb/telescope 1.15.0

package/main/utils/index.js

@@ -0,0 +1,163 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelativePath = exports.fixlocalpaths = exports.UTIL_HELPERS = exports.UTILS = exports.getRoot = void 0;
+const path_1 = require("path");
+const utils_1 = require("@cosmology/utils");
+const getRoot = (ref) => {
+    if (ref.traversed)
+        return ref.traversed;
+    return ref.proto;
+};
+exports.getRoot = getRoot;
+// default example:
+// Long: { type: 'default', path: 'long', name: 'Long ' },
+// namespaced:
+// _m0: { type: 'namespace', path: 'protobufjs/minimal', name: '_m0' },
+exports.UTILS = {
+    _m0: { type: 'namespace', path: 'protobufjs/minimal', name: '_m0' },
+    AminoHeight: '__helpers__',
+    AminoMsg: '@cosmjs/amino',
+    AminoTypes: '@cosmjs/stargate',
+    base64FromBytes: '__helpers__',
+    bytesFromBase64: '__helpers__',
+    BrowserHeaders: 'browser-headers',
+    connectComet: '@cosmjs/tendermint-rpc',
+    Decimal: '@cosmjs/math',
+    padDecimal: '__helpers__',
+    createProtobufRpcClient: '@cosmjs/stargate',
+    Pubkey: '@cosmjs/amino',
+    decodeBech32Pubkey: '@cosmjs/amino',
+    DeepPartial: '__helpers__',
+    defaultRegistryTypes: '@cosmjs/stargate',
+    encodeBech32Pubkey: '@cosmjs/amino',
+    Exact: '__helpers__',
+    fm: { type: 'namespace', path: '__grpc-gateway__', name: 'fm' },
+    encodePubkey: '@cosmjs/proto-signing',
+    decodePubkey: '@cosmjs/proto-signing',
+    fromBase64: '@cosmjs/encoding',
+    fromBech32: '@cosmjs/encoding',
+    fromDuration: '__helpers__',
+    fromHex: '@cosmjs/encoding',
+    fromJsonTimestamp: '__helpers__',
+    fromTimestamp: '__helpers__',
+    fromUtf8: '@cosmjs/encoding',
+    GeneratedType: '@cosmjs/proto-signing',
+    createTm34QueryClient: '__extern__',
+    createConnectCometQueryClient: '__extern__',
+    getRpcClient: '__extern__',
+    createRpcClient: '__extern__',
+    getRpcEndpointKey: '__extern__',
+    HttpEndpoint: '@cosmjs/tendermint-rpc',
+    isObject: '__helpers__',
+    isSet: '__helpers__',
+    LCDClient: '@cosmology/lcd',
+    Long: '__helpers__',
+    OfflineSigner: '@cosmjs/proto-signing',
+    omitDefault: '__helpers__',
+    ProtobufRpcClient: '@cosmjs/stargate',
+    QueryClient: '@cosmjs/stargate',
+    Registry: '@cosmjs/proto-signing',
+    Rpc: '__helpers__',
+    StdFee: '__types__',
+    TxRpc: '__types__',
+    BroadcastTxReq: '__types__',
+    BroadcastTxRes: '__types__',
+    DeliverTxResponse: '__types__',
+    EncodeObject: '__types__',
+    SigningClientParams: '__types__',
+    grpc: '@improbable-eng/grpc-web',
+    setPaginationParams: '__helpers__',
+    SigningStargateClient: '@cosmjs/stargate',
+    Tendermint34Client: '@cosmjs/tendermint-rpc',
+    toBase64: '@cosmjs/encoding',
+    toDuration: '__helpers__',
+    toTimestamp: '__helpers__',
+    toUtf8: '@cosmjs/encoding',
+    useQuery: '@tanstack/react-query',
+    ComputedRef: 'vue',
+    computed: 'vue',
+    Ref: 'vue',
+    useRpcEndpoint: '__react-query__',
+    useRpcClient: '__react-query__',
+    useTendermintClient: '__react-query__',
+    ReactQueryParams: '__react-query__',
+    buildUseMutation: '__react-query__',
+    UseQueryParams: '__react-query__',
+    buildUseQuery: '__react-query__',
+    UseQueryOptions: '@tanstack/react-query',
+    buildUseVueMutation: '__vue-query__',
+    buildUseVueQuery: '__vue-query__',
+    QueryStore: '__mobx__',
+    MobxResponse: '__mobx__',
+    useEndpoint: '__pinia-endpoint__',
+    JsonSafe: '__json-safe__',
+    override: 'mobx',
+    makeObservable: 'mobx',
+    NodeHttpTransport: '@improbable-eng/grpc-web-node-http-transport',
+    UnaryMethodDefinitionishR: '__grpc-web__',
+    UnaryMethodDefinitionish: '__grpc-web__',
+    BinaryReader: '__binary__',
+    BinaryWriter: '__binary__',
+    TelescopeGeneratedType: '__types__',
+    GlobalDecoderRegistry: '__registry__',
+    buildTx: '__helper-func-types__',
+    ISigningClient: '__helper-func-types__',
+    buildQuery: '__helper-func-types__',
+    EndpointOrRpc: '__helper-func-types__',
+    toConverters: '@interchainjs/cosmos/utils',
+    toEncoders: '@interchainjs/cosmos/utils'
+};
+exports.UTIL_HELPERS = [
+    '__helpers__',
+    '__extern__',
+    '__react-query__',
+    '__vue-query__',
+    '__mobx__',
+    '__binary__',
+    '__pinia-endpoint__',
+    '__json-safe__',
+    '__grpc-gateway__',
+    '__grpc-web__',
+    '__types__',
+    '__registry__',
+    '__decimals__',
+    '__helper-func-types__'
+];
+const fixlocalpaths = (imports) => {
+    return imports.map((imp) => {
+        const fixedPath = (0, utils_1.toPosixPath)(imp.path);
+        return {
+            ...imp,
+            path: exports.UTIL_HELPERS.includes(imp.path) ||
+                imp.path.startsWith('.') ||
+                imp.path.startsWith('@')
+                ? fixedPath
+                : `./${fixedPath}`,
+        };
+    });
+};
+exports.fixlocalpaths = fixlocalpaths;
+const getRelativePath = (f1, f2, ext) => {
+    const rel = (0, path_1.relative)((0, path_1.dirname)(f1), f2);
+    let importPath = rel.replace((0, path_1.extname)(rel), '');
+    if (!/^\./.test(importPath))
+        importPath = `./${importPath}`;
+    importPath = (0, utils_1.toPosixPath)(importPath);
+    return (0, utils_1.restoreExtension)(importPath, ext);
+};
+exports.getRelativePath = getRelativePath;
+__exportStar(require("./common-create-bundle"), exports);

package/main/utils/unused.js

@@ -0,0 +1,73 @@
+"use strict";
+//@ts-nocheck
+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.unused = void 0;
+const t = __importStar(require("@babel/types"));
+// https://github.com/chuyik/babel-plugin-danger-remove-unused-import
+// https://github.com/chuyik/babel-plugin-danger-remove-unused-import/blob/c5454c21e94698a2464a12baa5590761932a71a8/License#L1
+exports.unused = {
+    Program: {
+        exit: (path) => {
+            const UnRefBindings = new Map();
+            for (const [name, binding] of Object.entries(path.scope.bindings)) {
+                if (!binding.path.parentPath || binding.kind !== 'module')
+                    continue;
+                const source = binding.path.parentPath.get('source');
+                const importName = source.node.value;
+                if (!t.isStringLiteral(source))
+                    continue;
+                const key = `${importName}(${source.node.loc &&
+                    source.node.loc.start.line})`;
+                if (!UnRefBindings.has(key)) {
+                    UnRefBindings.set(key, binding);
+                }
+                if (binding.referenced) {
+                    UnRefBindings.set(key, null);
+                }
+                else {
+                    const nodeType = binding.path.node.type;
+                    if (nodeType === 'ImportSpecifier') {
+                        binding.path.remove();
+                    }
+                    else if (nodeType === 'ImportDefaultSpecifier') {
+                        binding.path.remove();
+                    }
+                    else if (nodeType === 'ImportNamespaceSpecifier') {
+                        binding.path.remove();
+                    }
+                    else if (binding.path.parentPath) {
+                        binding.path.parentPath.remove();
+                    }
+                }
+            }
+            UnRefBindings.forEach((binding, key) => {
+                if (binding && binding.path.parentPath) {
+                    binding.path.parentPath.remove();
+                }
+            });
+        }
+    }
+};

package/module/build.js

@@ -0,0 +1,176 @@
+import { AminoParseContext, createAminoConverter, createCreateProtoType, createObjectWithMethods, createRegisterObject, createProtoEnum, createProtoEnumToJSON, createProtoEnumFromJSON, createProtoType, createProtoInterfaceEncodedType, createProtoTypeType, createSDKType, createAminoType, createAminoTypeType, createEnumSDKType, createEnumAminoType, makeAminoTypeInterface, GenericParseContext, ProtoParseContext, createTypeRegistry, createRegistryLoader, 
+// helper
+createHelperObject, createInterfaceDecoder, createInterfaceFromAmino, createInterfaceToAmino, createRegisterAminoProtoMapping, } from '@cosmology/ast';
+export const getMutations = (mutations) => {
+    return mutations.map((mutation) => {
+        return {
+            typeUrl: `/${mutation.package}.${mutation.message}`,
+            TypeName: mutation.message,
+            methodName: mutation.methodName
+        };
+    });
+};
+export const getAminoProtos = (mutations, store) => {
+    return mutations.map(mutation => {
+        const ref = store.findProto(mutation.messageImport);
+        return store.get(ref, mutation.message).obj;
+    });
+};
+export const buildBaseTypeScriptClass = (context, name, obj) => {
+    if (context.options.prototypes.enabled) {
+        context.body.push(createCreateProtoType(context.proto, name, obj));
+        context.body.push(createObjectWithMethods(context.proto, name, obj));
+        if (context.options.interfaces?.enabled && context.options.interfaces?.useGlobalDecoderRegistry && context.options.interfaces?.registerAllDecodersToGlobal) {
+            const registerObj = createRegisterObject(context.proto, name, obj);
+            if (registerObj) {
+                context.body.push(registerObj);
+                //createRegisterAminoProtoMapping
+                const registerAminoObj = createRegisterAminoProtoMapping(context.proto, name, obj);
+                if (registerAminoObj) {
+                    context.body.push(registerAminoObj);
+                }
+            }
+        }
+    }
+};
+export const buildBaseTypeScriptInterface = (context, name, obj) => {
+    context.body.push(createProtoType(context.proto, name, obj));
+    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding || context.options.prototypes?.methods?.fromProto || context.options.prototypes?.methods?.toProto) {
+        context.body.push(createProtoTypeType(context.proto, name, obj));
+    }
+    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding) {
+        // conditional type
+        const interfaceType = createProtoInterfaceEncodedType(context.proto, name, obj);
+        if (interfaceType) {
+            context.body.push(interfaceType);
+        }
+        context.body.push(createAminoType(context.proto, name, obj));
+        if (!context.options.aminoEncoding?.disableMsgTypes) {
+            context.body.push(createAminoTypeType(context.proto, name, obj));
+        }
+    }
+    if (context.options.useSDKTypes) {
+        context.body.push(createSDKType(context.proto, name, obj));
+    }
+};
+export const buildEnums = (context, name, obj) => {
+    context.body.push(createProtoEnum(context.proto, name, obj));
+    if (context.options.useSDKTypes) {
+        context.body.push(createEnumSDKType(context.proto, name, obj));
+    }
+    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding) {
+        context.body.push(createEnumAminoType(context.proto, name, obj));
+    }
+    context.body.push(createProtoEnumFromJSON(context.proto, name, obj));
+    context.body.push(createProtoEnumToJSON(context.proto, name, obj));
+};
+export class TelescopeParseContext {
+    constructor(ref, store, options) {
+        this.generic = new GenericParseContext(ref, store, options);
+        this.proto = new ProtoParseContext(ref, store, options);
+        this.amino = new AminoParseContext(ref, store, options);
+        this.options = options;
+        this.ref = ref;
+        this.store = store;
+        this.parsedImports = {};
+        this.body = [];
+        this.queries = [];
+        this.services = [];
+        this.mutations = [];
+        this.types = [];
+    }
+    hasMutations() {
+        return this.mutations.length > 0;
+    }
+    addType(name, obj, isNested) {
+        this.types.push({
+            name,
+            obj,
+            isNested
+        });
+    }
+    addMutation(mutation) {
+        this.mutations.push(mutation);
+    }
+    addQuery(query) {
+        this.queries.push(query);
+    }
+    addService(query) {
+        this.services.push(query);
+    }
+    // build main Class with methods
+    buildBase() {
+        this.types.forEach(typeReg => {
+            const { name, obj } = typeReg;
+            if (obj.type === 'Enum') {
+                buildEnums(this, name, obj);
+            }
+        });
+        this.types.forEach(typeReg => {
+            const { name, obj } = typeReg;
+            if (obj.type === 'Type') {
+                buildBaseTypeScriptInterface(this, name, obj);
+            }
+        });
+        this.types.forEach(typeReg => {
+            const { name, obj } = typeReg;
+            if (obj.type === 'Type') {
+                buildBaseTypeScriptClass(this, name, obj);
+            }
+        });
+        // interfaces
+        if (this.options.interfaces.enabled && !this.options.interfaces.useGlobalDecoderRegistry) {
+            const interfaces = Object.keys(this.ref.traversed.acceptsInterface ?? {});
+            if (interfaces.length) {
+                interfaces.forEach(interfaceName => {
+                    this.body.push(createInterfaceDecoder(this.proto, this.ref, interfaceName));
+                    if (this.options.aminoEncoding?.enabled &&
+                        !this.options.aminoEncoding?.useLegacyInlineEncoding) {
+                        this.body.push(createInterfaceFromAmino(this.proto, this.ref, interfaceName));
+                        this.body.push(createInterfaceToAmino(this.proto, this.ref, interfaceName));
+                    }
+                });
+            }
+        }
+    }
+    buildRegistry() {
+        this.body.push(createTypeRegistry(this.amino, getMutations(this.mutations)));
+    }
+    buildRegistryLoader() {
+        if (!this.options?.prototypes?.enableRegistryLoader) {
+            return;
+        }
+        this.body.push(createRegistryLoader(this.amino));
+    }
+    buildAminoInterfaces() {
+        if (!this.options?.aminoEncoding?.enabled || !this.options?.aminoEncoding?.useLegacyInlineEncoding)
+            return;
+        //
+        const protos = getAminoProtos(this.mutations, this.store);
+        protos.forEach(proto => {
+            this.body.push(makeAminoTypeInterface({
+                context: this.amino,
+                proto
+            }));
+        });
+    }
+    buildAminoConverter() {
+        this.body.push(createAminoConverter({
+            name: 'AminoConverter',
+            context: this.amino,
+            root: this.ref.traversed,
+            protos: getAminoProtos(this.mutations, this.store)
+        }));
+    }
+    buildHelperObject() {
+        if (!this.options?.prototypes?.enableMessageComposer) {
+            return;
+        }
+        // add methods
+        this.body.push(createHelperObject({
+            context: this.amino,
+            name: 'MessageComposer',
+            mutations: getMutations(this.mutations)
+        }));
+    }
+}

package/module/builder.js

@@ -0,0 +1,222 @@
+import { ProtoStore } from '@cosmology/proto-parser';
+import { TelescopeParseContext } from './build';
+import { defaultTelescopeOptions } from '@cosmology/types';
+import { toPosixPath } from '@cosmology/utils';
+import { bundlePackages } from './bundle';
+import { Bundler } from './bundler';
+import deepmerge from 'deepmerge';
+import { resolve } from 'path';
+import { plugin as createTypes } from './generators/create-types';
+import { plugin as createAminoConverters } from './generators/create-amino-converters';
+import { plugin as createRegistries } from './generators/create-registries';
+import { plugin as createLCDClients } from './generators/create-lcd-clients';
+import { plugin as createAggregatedLCDClient } from './generators/create-aggregated-lcd-client';
+import { plugin as createLCDClientsScoped } from './generators/create-lcd-client-scoped';
+import { plugin as createLCDClientsAll } from './generators/create-lcd-client-all';
+import { plugin as createRPCQueryClientsScoped } from './generators/create-rpc-query-client-scoped';
+import { plugin as createRPCQueryClientsAll } from './generators/create-rpc-query-client-all';
+import { plugin as createRPCMsgClientsScoped } from './generators/create-rpc-msg-client-scoped';
+import { plugin as createRPCMsgClientsAll } from './generators/create-rpc-msg-client-all';
+import { plugin as createRPCQueryClients } from './generators/create-rpc-query-clients';
+import { plugin as createRPCMsgClients } from './generators/create-rpc-msg-clients';
+import { plugin as createQueryFuncs } from './generators/create-query-funcs';
+import { plugin as createMsgFuncs } from './generators/create-msg-funcs';
+import { plugin as createReactQueryBundle } from './generators/create-react-query-bundle';
+import { plugin as createMobxBundle } from './generators/create-mobx-bundle';
+import { plugin as createStargateClients } from './generators/create-stargate-clients';
+import { plugin as createCustomStargateClients } from './generators/create-custom-stargate-clients';
+import { plugin as createAllStargateClients } from './generators/create-all-stargate-clients';
+import { plugin as createSdkModuleStargateClients } from './generators/create-sdk-module-stargate-clients';
+import { plugin as createBundle } from './generators/create-bundle';
+import { plugin as createIndex } from './generators/create-index';
+import { plugin as createHelpers } from './generators/create-helpers';
+import { plugin as createCosmWasmBundle } from './generators/create-cosmwasm-bundle';
+import { plugin as createPiniaStore } from './generators/create-pinia-store';
+import { plugin as createPiniaStoreBundle } from './generators/create-pinia-store-bundle';
+import { plugin as createRpcOpsBundle } from './generators/create-rpc-ops-bundle';
+import { plugin as customizeUtils } from './generators/customize-utils';
+import { plugin as createRootReadme } from './generators/create-root-readme';
+import { plugin as createMcpServer } from './generators/create-mcp-server';
+const sanitizeOptions = (options) => {
+    // If an element at the same key is present for both x and y, the value from y will appear in the result.
+    options = deepmerge(defaultTelescopeOptions, options ?? {});
+    // correct the path for windows
+    if (options.cosmwasm) {
+        options.cosmwasm.outPath = toPosixPath(options.cosmwasm.outPath);
+        options.cosmwasm.contracts = options.cosmwasm.contracts.map((item) => {
+            item.dir = toPosixPath(item.dir);
+            return item;
+        });
+    }
+    // strip off leading slashes
+    options.tsDisable.files = options.tsDisable.files.map((file) => file.startsWith('/') ? file : file.replace(/^\//, ''));
+    options.eslintDisable.files = options.eslintDisable.files.map((file) => file.startsWith('/') ? file : file.replace(/^\//, ''));
+    // uniq bc of deepmerge
+    options.rpcClients.enabledServices = [
+        ...new Set([...options.rpcClients.enabledServices]),
+    ];
+    return options;
+};
+export class TelescopeBuilder {
+    store;
+    protoDirs;
+    outPath;
+    options;
+    contexts = [];
+    files = [];
+    converters = [];
+    lcdClients = [];
+    rpcQueryClients = [];
+    rpcMsgClients = [];
+    registries = [];
+    stateManagers = {};
+    // Function mapping storage: package -> service -> method -> functionName
+    functionMappings = {};
+    constructor({ protoDirs, outPath, store, options, }) {
+        const fixedDirs = protoDirs.map((directory) => {
+            return toPosixPath(directory);
+        });
+        this.protoDirs = fixedDirs;
+        this.outPath = resolve(toPosixPath(outPath));
+        this.options = sanitizeOptions(options);
+        this.store = store ?? new ProtoStore(fixedDirs, this.options);
+        this.store.traverseAll();
+    }
+    context(ref) {
+        const ctx = new TelescopeParseContext(ref, this.store, this.options);
+        this.contexts.push(ctx);
+        return ctx;
+    }
+    addFunctionMapping(packageName, serviceName, methodName, functionName, hookName, comment, requestType, responseType, sourceFilename, hookSourceFilename, typeSourceFilename) {
+        if (!this.functionMappings[packageName]) {
+            this.functionMappings[packageName] = {};
+        }
+        if (!this.functionMappings[packageName][serviceName]) {
+            this.functionMappings[packageName][serviceName] = {};
+        }
+        this.functionMappings[packageName][serviceName][methodName] = {
+            functionName,
+            hookName,
+            comment,
+            requestType,
+            responseType,
+            sourceFilename,
+            hookSourceFilename,
+            typeSourceFilename
+        };
+    }
+    getFunctionMappings() {
+        return this.functionMappings;
+    }
+    addStateManagers(type, files) {
+        const state = this.stateManagers[type];
+        if (!state) {
+            this.stateManagers[type] = [];
+        }
+        [].push.apply(this.stateManagers[type], files);
+    }
+    addRPCQueryClients(files) {
+        [].push.apply(this.rpcQueryClients, files);
+    }
+    addRPCMsgClients(files) {
+        [].push.apply(this.rpcMsgClients, files);
+    }
+    addLCDClients(files) {
+        [].push.apply(this.lcdClients, files);
+    }
+    addRegistries(files) {
+        [].push.apply(this.registries, files);
+    }
+    addConverters(files) {
+        [].push.apply(this.converters, files);
+    }
+    async build() {
+        // check warnings
+        if (!this.options.aminoEncoding?.enabled &&
+            (this.options.prototypes?.methods?.fromAmino ||
+                this.options.prototypes?.methods?.toAmino)) {
+            console.warn("There could be compilation errors in generated code, because 'aminoEncoding.enabled: false' means amino types wouldn't be created, but 'toAmino' or 'fromAmino' need amino types.");
+        }
+        if (!this.options.prototypes.methods.fromPartial) {
+            console.warn("The 'fromPartial' option will be deprecated in a future version. Encoder objects need fromPartial to be a creator function to create instance of the type. So it should always be left on, otherwise there could be compilation errors in generated code.");
+        }
+        customizeUtils(this);
+        const allConverters = [];
+        const allRegistries = [];
+        // [x] get bundle of all packages
+        const bundles = bundlePackages(this.store).map((bundle) => {
+            // store bundleFile in filesToInclude
+            const bundler = new Bundler(this, bundle);
+            // [x] write out all TS files for package
+            createTypes(this, bundler);
+            // [x] write out one amino helper for all contexts w/mutations
+            createAminoConverters(this, bundler);
+            // [x] write out one registry helper for all contexts w/mutations
+            createRegistries(this, bundler);
+            // [x] write out one registry helper for all contexts w/mutations
+            createLCDClients(this, bundler);
+            createQueryFuncs(this, bundler);
+            createRPCQueryClients(this, bundler);
+            createMsgFuncs(this, bundler);
+            createRPCMsgClients(this, bundler);
+            createPiniaStore(this, bundler);
+            if (this.options.rpcClients.clientStyle.useUpdatedClientStyle) {
+                // generate sdk-module client file
+                if (this.options.rpcClients.clientStyle.type.includes('sdk-module-client') && this.options.rpcClients.clientStyle.sdkModuleClientOption.includes(bundler.bundle.base)) {
+                    createSdkModuleStargateClients(this, bundler);
+                }
+                // store registry and converter for all/custom client generation
+                if (bundler.registries) {
+                    allRegistries.push(...bundler.registries);
+                }
+                if (bundler.converters) {
+                    allConverters.push(...bundler.converters);
+                }
+            }
+            else {
+                // [x] write out one client for each base package, referencing the last two steps
+                createStargateClients(this, bundler);
+            }
+            return bundler;
+        });
+        if (this.options.rpcClients.clientStyle.useUpdatedClientStyle) {
+            // generate cutsom client file
+            if (this.options.rpcClients.clientStyle.type.includes('custom-client') && this.options.rpcClients.clientStyle.customClientOption && this.options.rpcClients.clientStyle.customClientOption.length !== 0) {
+                createCustomStargateClients(this, allRegistries, allConverters);
+            }
+            // generate all module client file
+            if (this.options.rpcClients.clientStyle.type.includes('all-client')) {
+                createAllStargateClients(this, allRegistries, allConverters);
+            }
+        }
+        // post run plugins
+        bundles.forEach((bundler) => {
+            createLCDClientsAll(this, bundler);
+            createLCDClientsScoped(this, bundler);
+            createRPCQueryClientsAll(this, bundler);
+            createRPCQueryClientsScoped(this, bundler);
+            createRPCMsgClientsAll(this, bundler);
+            createRPCMsgClientsScoped(this, bundler);
+            createBundle(this, bundler);
+        });
+        createRpcOpsBundle(this);
+        createReactQueryBundle(this);
+        createMobxBundle(this);
+        createAggregatedLCDClient(this);
+        await createCosmWasmBundle(this);
+        createHelpers(this);
+        createPiniaStoreBundle(this);
+        // finally, write one index file with all files, exported
+        createIndex(this);
+        createRootReadme(this);
+        // Generate MCP server at the very end after all files are written
+        if (this.options.mcpServer?.enabled && bundles.length > 0) {
+            // Use the first bundle that has contexts (typically the main aggregated bundle)
+            const primaryBundle = bundles.find(bundler => bundler.contexts.length > 0);
+            if (primaryBundle) {
+                createMcpServer(this, primaryBundle);
+            }
+        }
+        console.log(`✨ files transpiled in '${this.outPath}'`);
+    }
+}