@initia/initia.js 1.0.21 → 2.0.0-rc.1

package/dist/types_pb-K7pKBvcg.mjs

@@ -0,0 +1,1433 @@
+import { i as file_amino_amino$1, o as file_cosmos_proto_cosmos, s as file_gogoproto_gogo$3 } from "./amino_pb-Bi6YDY_U.mjs";
+import { r as file_cosmos_base_v1beta1_coin$1 } from "./coin_pb--WuIu4sX.mjs";
+import { m as ValidationError } from "./errors-CN1MFOLv.mjs";
+import { l as getAccount, n as createBroadcastResultWithWait, o as UnsignedTx, r as RpcClient, s as estimateGas, t as broadcast, u as file_cosmos_auth_v1beta1_auth } from "./broadcast-De8MdmYa.mjs";
+import { a as msgCustom, c as normalizeMsg, i as msg } from "./types-CSS5rfW1.mjs";
+import { _ as TxBodySchema, d as file_cosmos_crypto_secp256k1_keys, f as AuthInfoSchema, g as SignerInfoSchema, l as file_initia_crypto_v1beta1_ethsecp256k1_keys, m as ModeInfoSchema, n as packPubKey, p as FeeSchema, u as file_cosmos_crypto_ed25519_keys, v as TxRawSchema, x as SignMode } from "./public-key-DV-uGaUC.mjs";
+import { i as getTx, n as createAbiRegistry, r as createNoopAbiRegistry } from "./get-tx-0P40z_A4.mjs";
+import { a as encodeTxDirect, l as makeStdSignDoc, o as makeAminoSignBytes, t as buildStdFee } from "./sign-DqagxLcg.mjs";
+import { n as isDirectSigner, r as isEIP191Signer, t as isAminoSigner } from "./types-CLfdsa48.mjs";
+import "./constants-W6V0E-3W.mjs";
+import { r as validateHeaderConflict } from "./headers-CMO7ia_D.mjs";
+import { t as EvmRpcClient } from "./evm-rpc-BxpgXIAF.mjs";
+import { t as createGrpcClient } from "./grpc-client-DGyZjGcT.mjs";
+import { n as file_google_api_annotations$2, t as file_cosmos_base_query_v1beta1_pagination$1 } from "./pagination_pb-DlkDYAcN.mjs";
+import { a as file_tendermint_types_evidence, i as file_tendermint_types_block, l as file_tendermint_types_params, n as Service$1, o as file_tendermint_types_types, s as file_tendermint_version_types } from "./service_pb-Be-O-2-c.mjs";
+import { c as subscribe, i as waitForTx, o as createSession, r as waitForEvent, s as hasWebSocketEndpoint } from "./waiting-BigHYRNN.mjs";
+import { i as isUsernameServiceSupported, n as createUsernameService, t as createUnsupportedUsernameService } from "./service-BaMjxPNo.mjs";
+import { t as createDecode } from "./decode-CXGawqIZ.mjs";
+import { t as file_cosmos_msg_v1_msg$1 } from "./msg_pb-DxYxctLM.mjs";
+import { create, createRegistry, toBinary } from "@bufbuild/protobuf";
+import { fileDesc, serviceDesc } from "@bufbuild/protobuf/codegenv2";
+import { file_google_protobuf_any, file_google_protobuf_descriptor, file_google_protobuf_duration, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt";
+import { base64 } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { lru } from "tiny-lru";
+//#region src/cache/cache-manager.ts
+const DEFAULT_MAX_SIZE = 64;
+function createCacheManager() {
+	return {
+		moveAbi: lru(DEFAULT_MAX_SIZE),
+		denomToContract: lru(DEFAULT_MAX_SIZE),
+		contractToDenom: lru(DEFAULT_MAX_SIZE),
+		heightCache: lru(DEFAULT_MAX_SIZE)
+	};
+}
+//#endregion
+//#region src/cache/keys.ts
+const HEX_REGEX = /^[0-9a-f]+$/i;
+/** Throws if value is empty string */
+function assertNonEmpty(value, name) {
+	if (value === "") throw new ValidationError(name, "Cannot be empty");
+}
+/**
+* Validate hex string (without 0x prefix).
+* @throws if value contains non-hex characters
+*/
+function assertValidHex(value, name) {
+	if (!HEX_REGEX.test(value)) throw new ValidationError(name, `Invalid hex characters: ${value}`);
+}
+/**
+* Normalize Move address to lowercase 0x-prefixed 64-char hex.
+* @example "0x1" -> "0x0000000000000000000000000000000000000000000000000000000000000001"
+* @throws if address is empty, contains invalid hex, or exceeds 64 chars
+*/
+function normalizeMoveAddress(addr) {
+	assertNonEmpty(addr, "address");
+	const raw = addr.slice(0, 2).toLowerCase() === "0x" ? addr.slice(2) : addr;
+	if (raw.length === 0) throw new ValidationError("address", "Cannot be empty (only 0x prefix)");
+	assertValidHex(raw, "address");
+	if (raw.length > 64) throw new ValidationError("address", `Move address exceeds 64 hex chars: ${raw.length}`);
+	return "0x" + raw.toLowerCase().padStart(64, "0");
+}
+/**
+* Normalize EVM address to lowercase 0x-prefixed 40-char hex.
+* @example "0xABC..." -> "0xabc..."
+* @throws if address is empty, invalid hex, or not exactly 40 chars
+*/
+function normalizeEvmAddress(addr) {
+	assertNonEmpty(addr, "address");
+	const raw = addr.slice(0, 2).toLowerCase() === "0x" ? addr.slice(2) : addr;
+	if (raw.length === 0) throw new ValidationError("address", "Cannot be empty (only 0x prefix)");
+	assertValidHex(raw, "address");
+	if (raw.length !== 40) throw new ValidationError("address", `EVM address must be exactly 40 hex chars, got: ${raw.length}`);
+	return "0x" + raw.toLowerCase();
+}
+/**
+* Hash an arbitrary request object using JSON serialization + SHA-256.
+*
+* Used when proto schema is not available (e.g., at the cache proxy layer).
+* JSON.stringify on proto-es v2 messages is deterministic for identically
+* constructed messages (same field insertion order).
+*
+* Worst case for non-determinism: cache miss (never stale data).
+*/
+function hashRequestJson(request) {
+	const json = JSON.stringify(request, (_, v) => typeof v === "bigint" ? `__bigint__${v}` : v);
+	return bytesToHex(sha256(new TextEncoder().encode(json)));
+}
+/**
+* Build a cache key for a gRPC query, optionally scoped to a block height.
+*
+* - With height: `serviceName.methodName:requestHash:hHeight` (immutable snapshot)
+* - Without height: `serviceName.methodName:requestHash` (current state)
+*/
+function buildCacheKey(serviceName, methodName, requestHash, height) {
+	const baseKey = `${serviceName}.${methodName}:${requestHash}`;
+	if (height !== void 0) return `${baseKey}:h${height}`;
+	return baseKey;
+}
+/** Cache key generators with chainId namespacing */
+const cacheKeys = {
+	moveAbi: (chainId, addr, module) => {
+		assertNonEmpty(chainId, "chainId");
+		assertNonEmpty(module, "module");
+		return `${chainId}:move:${normalizeMoveAddress(addr)}:${module}`;
+	},
+	denomToContract: (chainId, denom) => {
+		assertNonEmpty(chainId, "chainId");
+		assertNonEmpty(denom, "denom");
+		return `${chainId}:d2c:${denom}`;
+	},
+	contractToDenom: (chainId, addr) => {
+		assertNonEmpty(chainId, "chainId");
+		return `${chainId}:c2d:${normalizeEvmAddress(addr)}`;
+	}
+};
+/** Pending request key prefixes with chainId namespacing */
+const pendingKeys = {
+	moveAbi: (chainId, addr, module) => {
+		assertNonEmpty(chainId, "chainId");
+		return `${chainId}:move:${normalizeMoveAddress(addr)}:${module}`;
+	},
+	denomMapping: (chainId, key) => {
+		assertNonEmpty(chainId, "chainId");
+		return `${chainId}:denom:${key}`;
+	}
+};
+//#endregion
+//#region src/client/cached-client.ts
+/**
+* Wrap a method with height-based caching.
+*
+* Only caches when QueryOptions.height is provided (immutable historical snapshot).
+* Without height, passes through to the original method with no overhead.
+*/
+function withHeightCache(serviceName, methodName, original, cache, pending, chainId) {
+	return async (request, options) => {
+		const height = options?.height;
+		if (height === void 0) return original(request, options);
+		const cacheKey = `${chainId}:${buildCacheKey(serviceName, methodName, hashRequestJson(request), height)}`;
+		if (!options?.skipCache) {
+			const cached = cache.heightCache.get(cacheKey);
+			if (cached !== void 0) return cached;
+		}
+		const pendingKey = `h:${cacheKey}`;
+		const inflight = pending.get(pendingKey);
+		if (inflight) return inflight;
+		const promise = original(request, options).then((result) => {
+			cache.heightCache.set(cacheKey, result);
+			return result;
+		}).finally(() => {
+			pending.delete(pendingKey);
+		});
+		pending.set(pendingKey, promise);
+		return promise;
+	};
+}
+/**
+* Wrap all methods of a service with height-based caching.
+*
+* Used for services without specialized immutable caching (e.g., bank, auth, gov).
+*/
+function createHeightCachedService(serviceName, service, cache, pending, chainId) {
+	return new Proxy(service, { get(target, prop, receiver) {
+		if (typeof prop !== "string") return Reflect.get(target, prop, receiver);
+		const original = target[prop];
+		if (typeof original !== "function") return original;
+		return withHeightCache(serviceName, prop, original, cache, pending, chainId);
+	} });
+}
+/**
+* Wrap move service with:
+* - Immutable cache for module() (Move ABI never changes after deploy)
+* - Height cache for all other methods
+*/
+function createCachedMoveService(moveService, cache, pending, chainId) {
+	const originalModule = moveService.module.bind(moveService);
+	return new Proxy(moveService, { get(target, prop) {
+		if (prop === "module") return async (request, options) => {
+			const normalizedAddr = normalizeMoveAddress(request.address);
+			const key = cacheKeys.moveAbi(chainId, normalizedAddr, request.moduleName);
+			const pKey = pendingKeys.moveAbi(chainId, normalizedAddr, request.moduleName);
+			if (!options?.skipCache) {
+				const cached = cache.moveAbi.get(key);
+				if (cached !== void 0) return cached;
+			}
+			const inflight = pending.get(pKey);
+			if (inflight) return inflight;
+			const promise = originalModule(request, options).then((result) => {
+				cache.moveAbi.set(key, result);
+				return result;
+			}).finally(() => {
+				pending.delete(pKey);
+			});
+			pending.set(pKey, promise);
+			return promise;
+		};
+		const original = Reflect.get(target, prop);
+		if (typeof prop === "string" && typeof original === "function") return withHeightCache("move", prop, original, cache, pending, chainId);
+		return original;
+	} });
+}
+/**
+* Wrap evm service with:
+* - Immutable cache for contractAddrByDenom() and denom() (each caches own direction only)
+* - Height cache for all other methods
+*/
+function createCachedEvmService(evmService, cache, pending, chainId) {
+	const originalContractAddrByDenom = evmService.contractAddrByDenom.bind(evmService);
+	const originalDenom = evmService.denom.bind(evmService);
+	return new Proxy(evmService, { get(target, prop) {
+		if (prop === "contractAddrByDenom") return async (request, options) => {
+			const key = cacheKeys.denomToContract(chainId, request.denom);
+			const pKey = pendingKeys.denomMapping(chainId, request.denom);
+			if (!options?.skipCache) {
+				const cached = cache.denomToContract.get(key);
+				if (cached !== void 0) return cached;
+			}
+			const inflight = pending.get(pKey);
+			if (inflight) return inflight;
+			const promise = originalContractAddrByDenom(request, options).then((result) => {
+				result.address = normalizeEvmAddress(result.address);
+				cache.denomToContract.set(key, result);
+				return result;
+			}).finally(() => {
+				pending.delete(pKey);
+			});
+			pending.set(pKey, promise);
+			return promise;
+		};
+		if (prop === "denom") return async (request, options) => {
+			const normalizedAddr = normalizeEvmAddress(request.contractAddr);
+			const key = cacheKeys.contractToDenom(chainId, normalizedAddr);
+			const pKey = pendingKeys.denomMapping(chainId, normalizedAddr);
+			if (!options?.skipCache) {
+				const cached = cache.contractToDenom.get(key);
+				if (cached !== void 0) return cached;
+			}
+			const inflight = pending.get(pKey);
+			if (inflight) return inflight;
+			const promise = originalDenom(request, options).then((result) => {
+				cache.contractToDenom.set(key, result);
+				return result;
+			}).finally(() => {
+				pending.delete(pKey);
+			});
+			pending.set(pKey, promise);
+			return promise;
+		};
+		const original = Reflect.get(target, prop);
+		if (typeof prop === "string" && typeof original === "function") return withHeightCache("evm", prop, original, cache, pending, chainId);
+		return original;
+	} });
+}
+/**
+* Wraps a client with caching for gRPC methods.
+*
+* - **Immutable methods** (move.module, evm.contractAddrByDenom, evm.denom):
+*   Specialized LRU cache with address normalization, always cached.
+*
+* - **All other methods with height**: General LRU cache keyed by
+*   `chainId:service.method:requestHash:hHeight`. Only activates when
+*   `QueryOptions.height` is provided (immutable historical snapshot).
+*
+* - **All other methods without height**: No caching (mutable current state).
+*
+* @param client - Raw gRPC client
+* @param chainId - Chain ID for cache key namespacing
+* @returns Client with caching enabled and clearCache() method
+*/
+function wrapClientWithCache(client, chainId) {
+	const cache = createCacheManager();
+	const pending = /* @__PURE__ */ new Map();
+	const cachedServices = /* @__PURE__ */ new Map();
+	/**
+	* Clear all caches and pending requests.
+	*/
+	function clearCache() {
+		cache.moveAbi.clear();
+		cache.denomToContract.clear();
+		cache.contractToDenom.clear();
+		cache.heightCache.clear();
+		pending.clear();
+		cachedServices.clear();
+	}
+	return new Proxy(client, {
+		get(target, prop) {
+			if (prop === "clearCache") return clearCache;
+			if (typeof prop !== "string") return Reflect.get(target, prop);
+			const service = Reflect.get(target, prop);
+			if (service === void 0) return void 0;
+			if (!cachedServices.has(prop)) if (prop === "move") cachedServices.set(prop, createCachedMoveService(service, cache, pending, chainId));
+			else if (prop === "evm") cachedServices.set(prop, createCachedEvmService(service, cache, pending, chainId));
+			else if (typeof service === "object" && service !== null) cachedServices.set(prop, createHeightCachedService(prop, service, cache, pending, chainId));
+			else return service;
+			return cachedServices.get(prop);
+		},
+		has(target, prop) {
+			if (prop === "clearCache") return true;
+			return Reflect.has(target, prop);
+		},
+		ownKeys(target) {
+			return [...Reflect.ownKeys(target), "clearCache"];
+		},
+		getOwnPropertyDescriptor(target, prop) {
+			if (prop === "clearCache") return {
+				configurable: true,
+				enumerable: true,
+				value: clearCache,
+				writable: false
+			};
+			return Reflect.getOwnPropertyDescriptor(target, prop);
+		}
+	});
+}
+//#endregion
+//#region src/wallet/chain-context.ts
+/**
+* Error thrown when signing is attempted without a signer.
+*/
+var NoSignerError = class extends Error {
+	constructor() {
+		super("Cannot sign: no signer provided.\nCreate context with signer: createInitiaContext({ network, signer }) or createChainContext(chainInfo, { signer })\nOr provide signer per-operation: ctx.sign(tx, { signer })");
+		this.name = "NoSignerError";
+	}
+};
+function pickQueryOptions(options) {
+	if (options?.height !== void 0) return {
+		height: BigInt(options.height),
+		skipCache: options.skipCache
+	};
+	if (options?.skipCache) return { skipCache: options.skipCache };
+}
+var ChainContextImpl = class ChainContextImpl {
+	client;
+	msgs;
+	abis;
+	_signer;
+	chainInfo;
+	usernames;
+	_address;
+	_nextSequence;
+	_evmRpc;
+	_evmTransport;
+	_rpc;
+	_tokenResolver;
+	_enricherFactory;
+	_enrichers;
+	_rpcOptions;
+	constructor(chainInfo, client, msgs, options) {
+		this.chainInfo = chainInfo;
+		this.client = client;
+		this.msgs = msgs;
+		this._signer = options?.signer;
+		this._address = options?.address;
+		this._evmTransport = options?.evmTransport;
+		this._tokenResolver = options?.tokenResolver;
+		this._enricherFactory = options?.enricherFactory;
+		this._rpcOptions = options?.rpcOptions ?? {};
+		if (options?.evmRpc) this._evmRpc = options.evmRpc;
+		if (options?.rpc) this._rpc = options.rpc;
+		this.abis = options?.abis ?? (options?.enricherFactory ? createAbiRegistry() : createNoopAbiRegistry());
+		this._enrichers = options?.enricherFactory ? options.enricherFactory(client, this.abis) : [];
+		this.usernames = chainInfo.chainType === "initia" && isUsernameServiceSupported(chainInfo.network) ? createUsernameService({ network: chainInfo.network }) : createUnsupportedUsernameService();
+	}
+	get signer() {
+		return this._signer;
+	}
+	get chainId() {
+		return this.chainInfo.chainId;
+	}
+	get chainType() {
+		return this.chainInfo.chainType;
+	}
+	get network() {
+		return this.chainInfo.network;
+	}
+	get address() {
+		return this._address;
+	}
+	get canSign() {
+		return this._signer !== void 0;
+	}
+	get canSignEIP191() {
+		return isEIP191Signer(this._signer);
+	}
+	/**
+	* EVM JSON-RPC client (lazy-initialized).
+	* Only available for minievm chains with evmRpc endpoint.
+	* Hidden from autocomplete unless T is narrowed to 'minievm'.
+	*/
+	get evmRpc() {
+		if (this._evmRpc) return this._evmRpc;
+		if (!this.chainInfo.evmRpc) throw new Error(`EVM RPC not available for chain "${this.chainInfo.chainId}".\nThis is only available for minievm chains with a JSON-RPC endpoint.`);
+		this._evmRpc = new EvmRpcClient(this.chainInfo.evmRpc, {
+			auth: this._rpcOptions.auth,
+			headers: this._rpcOptions.headers,
+			timeoutMs: this._rpcOptions.timeoutMs
+		});
+		return this._evmRpc;
+	}
+	/**
+	* Default EVM contract transport preference.
+	* When 'jsonrpc', createEvmContract uses JSON-RPC instead of gRPC.
+	*/
+	get evmTransport() {
+		return this._evmTransport;
+	}
+	/**
+	* CometBFT HTTP RPC client (lazy-initialized).
+	* Provides access to block_results, tx with index, txSearch, etc.
+	*/
+	get rpc() {
+		if (this._rpc) return this._rpc;
+		if (!this.chainInfo.rpc) throw new Error(`RPC not available for chain "${this.chainInfo.chainId}".\nProvide an RPC endpoint in chain configuration.`);
+		this._rpc = new RpcClient(this.chainInfo.rpc, {
+			auth: this._rpcOptions.auth,
+			headers: this._rpcOptions.headers,
+			timeoutMs: this._rpcOptions.timeoutMs
+		});
+		return this._rpc;
+	}
+	async getSignerAddress(signerOverride) {
+		const signer = signerOverride ?? this._signer;
+		if (!signer) throw new NoSignerError();
+		const prefix = this.chainInfo.bech32Prefix ?? "init";
+		if (signerOverride) return signer.getAddress(prefix);
+		if (!this._address) this._address = await signer.getAddress(prefix);
+		return this._address;
+	}
+	async requireAddress(addressOverride) {
+		if (addressOverride) return addressOverride;
+		if (this._address) return this._address;
+		if (this._signer) {
+			const prefix = this.chainInfo.bech32Prefix ?? "init";
+			this._address = await this._signer.getAddress(prefix);
+			return this._address;
+		}
+		throw new Error("No address available. Either create context with signer/address or provide address parameter.");
+	}
+	withSigner(signer) {
+		return new ChainContextImpl(this.chainInfo, this.client, this.msgs, {
+			signer,
+			...this.carryover()
+		});
+	}
+	forAddress(address) {
+		return new ChainContextImpl(this.chainInfo, this.client, this.msgs, {
+			address,
+			...this.carryover()
+		});
+	}
+	/** Collect state to preserve across withSigner()/forAddress(). */
+	carryover() {
+		return {
+			evmTransport: this._evmTransport,
+			tokenResolver: this._tokenResolver,
+			rpcOptions: this._rpcOptions,
+			evmRpc: this._evmRpc,
+			rpc: this._rpc,
+			abis: this.abis,
+			enricherFactory: this._enricherFactory
+		};
+	}
+	async getAccount(options) {
+		const addr = await this.requireAddress(options?.address);
+		return getAccount(this.client, addr, options?.height !== void 0 ? { height: options.height } : void 0);
+	}
+	async getBalance(options) {
+		const { Coin } = await import("./coin-DPWbtAFA.mjs").then((n) => n.i);
+		const addr = await this.requireAddress(options?.address);
+		const queryOptions = pickQueryOptions(options);
+		if (options?.denom) {
+			const response = await this.client.bank.balance({
+				address: addr,
+				denom: options.denom
+			}, queryOptions);
+			if (!response.balance) return [];
+			return [new Coin(response.balance.denom, response.balance.amount)];
+		}
+		return (await this.client.bank.allBalances({ address: addr }, queryOptions)).balances.map((b) => new Coin(b.denom, b.amount));
+	}
+	resetSequence() {
+		this._nextSequence = void 0;
+	}
+	async estimateGas(msgs, options) {
+		const addr = await this.getSignerAddress(options?.signer);
+		return estimateGas(this.client, msgs, addr, options);
+	}
+	async createTx(msgs, options) {
+		let accountNumber;
+		let sequence;
+		const hasAccount = options?.accountNumber !== void 0;
+		const hasSequence = options?.sequence !== void 0;
+		if (hasAccount !== hasSequence) throw new Error("Both accountNumber and sequence must be provided together, or neither");
+		if (hasAccount && hasSequence) {
+			accountNumber = BigInt(options.accountNumber);
+			sequence = BigInt(options.sequence);
+		} else {
+			const address = options?.address ?? await this.getSignerAddress(options?.signer);
+			const account = await getAccount(this.client, address);
+			accountNumber = account.number;
+			sequence = this._nextSequence !== void 0 && this._nextSequence > account.sequence ? this._nextSequence : account.sequence;
+		}
+		return new UnsignedTx({
+			msgs: msgs.map((m) => normalizeMsg(m)),
+			signMode: options?.signMode ?? this.defaultSignMode(options?.signer),
+			chainId: this.chainId,
+			accountNumber,
+			sequence,
+			fee: options?.fee ?? [],
+			gasLimit: BigInt(options?.gasLimit ?? 200000n),
+			memo: options?.memo ?? ""
+		});
+	}
+	/**
+	* Auto-determine signMode based on signer capabilities.
+	* preferredSignMode hint → AminoSigner-only → 'amino' → 'direct'
+	*/
+	defaultSignMode(signerOverride) {
+		const s = signerOverride ?? this._signer;
+		if (s?.preferredSignMode) return s.preferredSignMode;
+		if (s && isAminoSigner(s) && !isDirectSigner(s)) return "amino";
+		return "direct";
+	}
+	async sign(tx, options) {
+		const signer = options?.signer ?? this._signer;
+		if (!signer) throw new NoSignerError();
+		const prefix = this.chainInfo.bech32Prefix ?? "init";
+		const address = this._address ?? await signer.getAddress(prefix);
+		const pubKey = await signer.getPublicKey();
+		const algorithm = signer.algorithm === "eth_secp256k1" ? "ethsecp256k1" : "secp256k1";
+		switch (tx.signMode) {
+			case "direct": return this.signDirect(tx, signer, address, pubKey, algorithm);
+			case "amino": return this.signWithAmino(tx, signer, address, pubKey, algorithm);
+			case "eip191": return this.signWithEIP191(tx, signer, pubKey, algorithm);
+		}
+	}
+	async signDirect(tx, signer, address, pubKey, algorithm) {
+		if (!isDirectSigner(signer)) throw new Error("Signer does not support direct signing. Use a signer that implements DirectSigner, or set signMode to \"amino\".");
+		const { bodyBytes, authInfoBytes } = encodeTxDirect(tx, pubKey, algorithm);
+		const signDoc = {
+			bodyBytes,
+			authInfoBytes,
+			chainId: tx.chainId,
+			accountNumber: tx.accountNumber
+		};
+		const response = await signer.signDirect(address, signDoc);
+		return { txBytes: toBinary(TxRawSchema, create(TxRawSchema, {
+			bodyBytes: response.signed.bodyBytes,
+			authInfoBytes: response.signed.authInfoBytes,
+			signatures: [response.signature.signature]
+		})) };
+	}
+	async signWithAmino(tx, signer, address, pubKey, algorithm) {
+		if (!isAminoSigner(signer)) throw new Error("Signer does not support amino signing. Use a signer that implements AminoSigner.");
+		const aminoMsgs = tx.msgs.map((m) => m.toAmino());
+		const aminoSignDoc = {
+			chain_id: tx.chainId,
+			account_number: tx.accountNumber.toString(),
+			sequence: tx.sequence.toString(),
+			fee: buildStdFee(tx),
+			msgs: aminoMsgs,
+			memo: tx.memo
+		};
+		const response = await signer.signAmino(address, aminoSignDoc);
+		const signed = response.signed;
+		const bodyBytes = toBinary(TxBodySchema, create(TxBodySchema, {
+			messages: tx.msgs.map((m) => m.toAny()),
+			memo: signed.memo,
+			timeoutHeight: 0n,
+			extensionOptions: [],
+			nonCriticalExtensionOptions: []
+		}));
+		const signerInfo = create(SignerInfoSchema, {
+			publicKey: packPubKey(pubKey, algorithm),
+			modeInfo: create(ModeInfoSchema, { sum: {
+				case: "single",
+				value: { mode: SignMode.LEGACY_AMINO_JSON }
+			} }),
+			sequence: BigInt(signed.sequence)
+		});
+		const fee = create(FeeSchema, {
+			amount: signed.fee.amount.map((c) => ({
+				denom: c.denom,
+				amount: c.amount
+			})),
+			gasLimit: BigInt(signed.fee.gas),
+			payer: signed.fee.payer ?? "",
+			granter: signed.fee.granter ?? ""
+		});
+		return { txBytes: toBinary(TxRawSchema, create(TxRawSchema, {
+			bodyBytes,
+			authInfoBytes: toBinary(AuthInfoSchema, create(AuthInfoSchema, {
+				signerInfos: [signerInfo],
+				fee,
+				tip: void 0
+			})),
+			signatures: [base64.decode(response.signature.signature)]
+		})) };
+	}
+	async signWithEIP191(tx, signer, pubKey, algorithm) {
+		if (!isEIP191Signer(signer)) throw new Error("Signer does not support EIP-191 signing. Use a signer that implements signPersonal().");
+		const aminoBytes = makeAminoSignBytes(makeStdSignDoc(tx.msgs.map((m) => m.toAmino()), buildStdFee(tx), tx.chainId, tx.memo, tx.accountNumber, tx.sequence));
+		const signature = await signer.signPersonal(aminoBytes);
+		const { bodyBytes, authInfoBytes } = encodeTxDirect(tx, pubKey, algorithm);
+		return { txBytes: toBinary(TxRawSchema, create(TxRawSchema, {
+			bodyBytes,
+			authInfoBytes,
+			signatures: [signature]
+		})) };
+	}
+	async broadcast(signedTx) {
+		return broadcast(this.client, signedTx);
+	}
+	async waitForTx(txHash, options) {
+		return waitForTx(this.client, txHash, {
+			...options,
+			chainInfo: this.chainInfo
+		});
+	}
+	async waitForEvent(filter, options) {
+		return waitForEvent(this.client, filter, {
+			...options,
+			chainInfo: this.chainInfo
+		});
+	}
+	async signAndBroadcast(msgs, options) {
+		let txOptions = options;
+		if (!options?.fee || options.fee.length === 0) {
+			const estimate = await this.estimateGas(msgs, {
+				gasPrice: options?.gasPrice ?? this.chainInfo.gasPrice,
+				multiplier: options?.gasMultiplier,
+				signer: options?.signer
+			});
+			txOptions = {
+				...options,
+				fee: estimate.fee.map((c) => c.toProto()),
+				gasLimit: options?.gasLimit ?? estimate.gasLimit
+			};
+		}
+		const tx = await this.createTx(msgs, txOptions);
+		const signedTx = await this.sign(tx, txOptions);
+		const broadcastResult = await broadcast(this.client, signedTx);
+		this._nextSequence = tx.sequence + 1n;
+		if (options?.waitForConfirmation) {
+			const waitOptions = options.waitForConfirmation === true ? {} : options.waitForConfirmation;
+			return this.waitForTx(broadcastResult.txHash, waitOptions);
+		}
+		return createBroadcastResultWithWait(broadcastResult, (txHash, waitOpts) => this.waitForTx(txHash, waitOpts));
+	}
+	hasWebSocket() {
+		return hasWebSocketEndpoint(this.chainInfo, "cosmos");
+	}
+	hasEvmWebSocket() {
+		return hasWebSocketEndpoint(this.chainInfo, "evm");
+	}
+	createWebSocketSession() {
+		return createSession(this.chainInfo);
+	}
+	subscribeToBlocks(callback) {
+		return subscribe(this.chainInfo, { event: "block" }, callback);
+	}
+	subscribeToTxs(query, callback) {
+		return subscribe(this.chainInfo, {
+			event: "tx",
+			filter: query
+		}, callback);
+	}
+	subscribeToEvmLogs(filter, callback) {
+		return subscribe(this.chainInfo, {
+			event: "evmLogs",
+			filter
+		}, callback);
+	}
+	async getTokenInfo(options) {
+		return this.getTokenContract(options.token).getInfo();
+	}
+	async getTx(hash, options) {
+		return getTx(this.client, (packed) => this.msgs.decode(packed), hash, this._enrichers, options);
+	}
+	getTokenContract(token) {
+		if (!this._tokenResolver) throw new Error("Token resolver not configured. Use a typed factory (createInitiaContext, createMinievmContext, etc.) or pass tokenResolver to buildChainContextFactory.");
+		return this._tokenResolver(this.client, this.chainInfo.chainType, token, this._address);
+	}
+};
+/**
+* Build a platform-specific `createChainContext` function.
+*
+* This is an internal factory that injects the transport creator
+* (Node.js gRPC or browser gRPC-web) so that `chain-context.ts`
+* remains platform-agnostic.
+*
+* End users should prefer typed factories (`createInitiaContext`, etc.)
+* built via {@link buildTypedFactory}, which wrap this function with
+* chain-specific services, messages, and provider auto-creation.
+*
+* @param createTransport - Platform-specific transport creator
+* @returns `createChainContext` function
+*
+* @see buildTypedFactory — Builds the user-facing typed factories
+*/
+function buildChainContextFactory(createTransport, getServices, getMsgs, factoryOptions) {
+	return function createChainContext(chainInfo, options) {
+		if (options?.auth && options?.headers) validateHeaderConflict(options.auth, options.headers, "context");
+		const transport = options?.transport ?? createTransport(chainInfo, {
+			timeoutMs: options?.timeoutMs,
+			interceptors: options?.interceptors
+		});
+		const services = getServices(chainInfo);
+		const typeRegistry = factoryOptions?.getTypeRegistry?.(chainInfo);
+		return new ChainContextImpl(chainInfo, wrapClientWithCache(createGrpcClient(transport, services, options?.auth, options?.headers, typeRegistry), chainInfo.chainId), getMsgs(chainInfo.chainType), {
+			signer: options?.signer,
+			address: options?.address,
+			evmTransport: options?.evmTransport,
+			tokenResolver: factoryOptions?.tokenResolver,
+			enricherFactory: factoryOptions?.enricherFactory,
+			rpcOptions: {
+				auth: options?.auth,
+				headers: options?.headers,
+				timeoutMs: options?.timeoutMs
+			}
+		});
+	};
+}
+//#endregion
+//#region src/chain-config.ts
+function getMethodEntries(svc) {
+	if (!svc.method || typeof svc.method !== "object") throw new ValidationError("tx", `Expected a GenService with a .method record, got: ${svc == null ? String(svc) : `object with keys [${Object.keys(svc).join(", ")}]`}`);
+	return Object.entries(svc.method);
+}
+function extractSchemas(tx) {
+	const services = Array.isArray(tx) ? tx : [tx];
+	const schemas = [];
+	for (const svc of services) for (const [, method] of getMethodEntries(svc)) schemas.push(method.input);
+	return schemas;
+}
+function createMsgBuilders(tx) {
+	const services = Array.isArray(tx) ? tx : [tx];
+	const builders = {};
+	for (const svc of services) for (const [name, method] of getMethodEntries(svc)) builders[name] = (init) => msg(method.input, init);
+	return builders;
+}
+var ChainConfigBuilder = class ChainConfigBuilder {
+	modules = {};
+	typeInputs = [];
+	addModule(name, input) {
+		if (!input.query && !input.tx) throw new ValidationError(name, "at least one of query or tx must be provided");
+		const next = this.clone();
+		next.modules[name] = input;
+		if (input.tx) {
+			const schemas = extractSchemas(input.tx);
+			next.typeInputs.push(...schemas);
+		}
+		return next;
+	}
+	addTypes(...inputs) {
+		const next = this.clone();
+		next.typeInputs.push(...inputs);
+		return next;
+	}
+	build() {
+		const services = {};
+		for (const [name, mod] of Object.entries(this.modules)) if (mod.query) services[name] = mod.query;
+		const msgBuilders = {};
+		for (const [name, mod] of Object.entries(this.modules)) if (mod.tx) msgBuilders[name] = createMsgBuilders(mod.tx);
+		const allSchemas = [];
+		for (const mod of Object.values(this.modules)) if (mod.tx) allSchemas.push(...extractSchemas(mod.tx));
+		const decode = createDecode(allSchemas);
+		const registry = createRegistry(...this.typeInputs);
+		return {
+			services,
+			msgs: {
+				...msgBuilders,
+				custom: msgCustom,
+				decode
+			},
+			registry
+		};
+	}
+	clone() {
+		const next = new ChainConfigBuilder();
+		next.modules = { ...this.modules };
+		next.typeInputs = [...this.typeInputs];
+		return next;
+	}
+};
+function createChainConfig() {
+	return new ChainConfigBuilder();
+}
+//#endregion
+//#region node_modules/@buf/skip-mev_connect.bufbuild_es/node_modules/@buf/cosmos_gogo-proto.bufbuild_es/gogoproto/gogo_pb.js
+/**
+* Describes the file gogoproto/gogo.proto.
+*/
+const file_gogoproto_gogo$2 = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_descriptor]);
+//#endregion
+//#region node_modules/@buf/skip-mev_connect.bufbuild_es/node_modules/@buf/googleapis_googleapis.bufbuild_es/google/api/annotations_pb.js
+/**
+* Describes the file google/api/annotations.proto.
+*/
+const file_google_api_annotations$1 = /* @__PURE__ */ fileDesc("Chxnb29nbGUvYXBpL2Fubm90YXRpb25zLnByb3RvEgpnb29nbGUuYXBpOksKBGh0dHASHi5nb29nbGUucHJvdG9idWYuTWV0aG9kT3B0aW9ucxiwyrwiIAEoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGVSBGh0dHBCbgoOY29tLmdvb2dsZS5hcGlCEEFubm90YXRpb25zUHJvdG9QAVpBZ29vZ2xlLmdvbGFuZy5vcmcvZ2VucHJvdG8vZ29vZ2xlYXBpcy9hcGkvYW5ub3RhdGlvbnM7YW5ub3RhdGlvbnOiAgRHQVBJYgZwcm90bzM", [/* @__PURE__ */ fileDesc("ChVnb29nbGUvYXBpL2h0dHAucHJvdG8SCmdvb2dsZS5hcGkiVAoESHR0cBIjCgVydWxlcxgBIAMoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGUSJwofZnVsbHlfZGVjb2RlX3Jlc2VydmVkX2V4cGFuc2lvbhgCIAEoCCKBAgoISHR0cFJ1bGUSEAoIc2VsZWN0b3IYASABKAkSDQoDZ2V0GAIgASgJSAASDQoDcHV0GAMgASgJSAASDgoEcG9zdBgEIAEoCUgAEhAKBmRlbGV0ZRgFIAEoCUgAEg8KBXBhdGNoGAYgASgJSAASLwoGY3VzdG9tGAggASgLMh0uZ29vZ2xlLmFwaS5DdXN0b21IdHRwUGF0dGVybkgAEgwKBGJvZHkYByABKAkSFQoNcmVzcG9uc2VfYm9keRgMIAEoCRIxChNhZGRpdGlvbmFsX2JpbmRpbmdzGAsgAygLMhQuZ29vZ2xlLmFwaS5IdHRwUnVsZUIJCgdwYXR0ZXJuIi8KEUN1c3RvbUh0dHBQYXR0ZXJuEgwKBGtpbmQYASABKAkSDAoEcGF0aBgCIAEoCUJqCg5jb20uZ29vZ2xlLmFwaUIJSHR0cFByb3RvUAFaQWdvb2dsZS5nb2xhbmcub3JnL2dlbnByb3RvL2dvb2dsZWFwaXMvYXBpL2Fubm90YXRpb25zO2Fubm90YXRpb25z+AEBogIER0FQSWIGcHJvdG8z"), file_google_protobuf_descriptor]);
+//#endregion
+//#region node_modules/@buf/skip-mev_connect.bufbuild_es/connect/types/v2/currency_pair_pb.js
+/**
+* Describes the file connect/types/v2/currency_pair.proto.
+*/
+const file_connect_types_v2_currency_pair = /* @__PURE__ */ fileDesc("CiRjb25uZWN0L3R5cGVzL3YyL2N1cnJlbmN5X3BhaXIucHJvdG8SEGNvbm5lY3QudHlwZXMudjIiNQoMQ3VycmVuY3lQYWlyEgwKBEJhc2UYASABKAkSDQoFUXVvdGUYAiABKAk6CJigHwCA3CAAQipaKGdpdGh1Yi5jb20vc2tpcC1tZXYvY29ubmVjdC92Mi9wa2cvdHlwZXNiBnByb3RvMw", [file_gogoproto_gogo$2]);
+/**
+* Query is the query service for the x/oracle module.
+*
+* @generated from service connect.oracle.v2.Query
+*/
+const Query$14 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [
+	file_gogoproto_gogo$2,
+	file_google_api_annotations$1,
+	/* @__PURE__ */ fileDesc("Ch9jb25uZWN0L29yYWNsZS92Mi9nZW5lc2lzLnByb3RvEhFjb25uZWN0Lm9yYWNsZS52MiKdAQoKUXVvdGVQcmljZRI6CgVwcmljZRgBIAEoCUIryN4fANreHxVjb3Ntb3NzZGsuaW8vbWF0aC5JbnTStC0KY29zbW9zLkludBI9Cg9ibG9ja190aW1lc3RhbXAYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgjI3h8AkN8fARIUCgxibG9ja19oZWlnaHQYAyABKAQiYgoRQ3VycmVuY3lQYWlyU3RhdGUSMgoFcHJpY2UYASABKAsyHS5jb25uZWN0Lm9yYWNsZS52Mi5RdW90ZVByaWNlQgTI3h8BEg0KBW5vbmNlGAIgASgEEgoKAmlkGAMgASgEIq8BChNDdXJyZW5jeVBhaXJHZW5lc2lzEjsKDWN1cnJlbmN5X3BhaXIYASABKAsyHi5jb25uZWN0LnR5cGVzLnYyLkN1cnJlbmN5UGFpckIEyN4fABJAChNjdXJyZW5jeV9wYWlyX3ByaWNlGAIgASgLMh0uY29ubmVjdC5vcmFjbGUudjIuUXVvdGVQcmljZUIEyN4fARINCgVub25jZRgDIAEoBBIKCgJpZBgEIAEoBCJsCgxHZW5lc2lzU3RhdGUSSwoVY3VycmVuY3lfcGFpcl9nZW5lc2lzGAEgAygLMiYuY29ubmVjdC5vcmFjbGUudjIuQ3VycmVuY3lQYWlyR2VuZXNpc0IEyN4fABIPCgduZXh0X2lkGAIgASgEQi9aLWdpdGh1Yi5jb20vc2tpcC1tZXYvY29ubmVjdC92Mi94L29yYWNsZS90eXBlc2IGcHJvdG8z", [
+		file_gogoproto_gogo$2,
+		file_google_protobuf_timestamp,
+		file_cosmos_proto_cosmos,
+		file_connect_types_v2_currency_pair
+	]),
+	file_connect_types_v2_currency_pair
+]), 0);
+//#endregion
+//#region node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/cosmos/query/v1/query_pb.js
+/**
+* Describes the file cosmos/query/v1/query.proto.
+*/
+const file_cosmos_query_v1_query = /* @__PURE__ */ fileDesc("Chtjb3Ntb3MvcXVlcnkvdjEvcXVlcnkucHJvdG8SD2Nvc21vcy5xdWVyeS52MTpNChFtb2R1bGVfcXVlcnlfc2FmZRIeLmdvb2dsZS5wcm90b2J1Zi5NZXRob2RPcHRpb25zGPGMpgUgASgIUg9tb2R1bGVRdWVyeVNhZmVCKlooZ2l0aHViLmNvbS9jb3Ntb3MvY29zbW9zLXNkay90eXBlcy9xdWVyeWIGcHJvdG8z", [file_google_protobuf_descriptor]);
+/**
+* Query defines the gRPC querier service.
+*
+* @generated from service cosmos.auth.v1beta1.Query
+*/
+const Query$13 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [
+	file_cosmos_base_query_v1beta1_pagination$1,
+	file_gogoproto_gogo$3,
+	file_google_protobuf_any,
+	file_google_api_annotations$2,
+	file_cosmos_auth_v1beta1_auth,
+	file_cosmos_proto_cosmos,
+	file_cosmos_query_v1_query
+]), 0);
+//#endregion
+//#region node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/cosmos/bank/v1beta1/bank_pb.js
+/**
+* Describes the file cosmos/bank/v1beta1/bank.proto.
+*/
+const file_cosmos_bank_v1beta1_bank = /* @__PURE__ */ fileDesc("Ch5jb3Ntb3MvYmFuay92MWJldGExL2JhbmsucHJvdG8SE2Nvc21vcy5iYW5rLnYxYmV0YTEigQEKBlBhcmFtcxI6CgxzZW5kX2VuYWJsZWQYASADKAsyIC5jb3Ntb3MuYmFuay52MWJldGExLlNlbmRFbmFibGVkQgIYARIcChRkZWZhdWx0X3NlbmRfZW5hYmxlZBgCIAEoCDodiuewKhhjb3Ntb3Mtc2RrL3gvYmFuay9QYXJhbXMiMwoLU2VuZEVuYWJsZWQSDQoFZGVub20YASABKAkSDwoHZW5hYmxlZBgCIAEoCDoE6KAfASK6AQoFSW5wdXQSKQoHYWRkcmVzcxgBIAEoCUIY0rQtFGNvc21vcy5BZGRyZXNzU3RyaW5nEnAKBWNvaW5zGAIgAygLMhkuY29zbW9zLmJhc2UudjFiZXRhMS5Db2luQkbI3h8Aqt8fKGdpdGh1Yi5jb20vY29zbW9zL2Nvc21vcy1zZGsvdHlwZXMuQ29pbnOa57AqDGxlZ2FjeV9jb2luc6jnsCoBOhSIoB8A6KAfAILnsCoHYWRkcmVzcyKvAQoGT3V0cHV0EikKB2FkZHJlc3MYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxJwCgVjb2lucxgCIAMoCzIZLmNvc21vcy5iYXNlLnYxYmV0YTEuQ29pbkJGyN4fAKrfHyhnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3R5cGVzLkNvaW5zmuewKgxsZWdhY3lfY29pbnOo57AqAToIiKAfAOigHwAipQEKBlN1cHBseRJwCgV0b3RhbBgBIAMoCzIZLmNvc21vcy5iYXNlLnYxYmV0YTEuQ29pbkJGyN4fAKrfHyhnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3R5cGVzLkNvaW5zmuewKgxsZWdhY3lfY29pbnOo57AqATopGAGIoB8A6KAfAcq0LRtjb3Ntb3MuYmFuay52MWJldGExLlN1cHBseUkiPQoJRGVub21Vbml0Eg0KBWRlbm9tGAEgASgJEhAKCGV4cG9uZW50GAIgASgNEg8KB2FsaWFzZXMYAyADKAkixgEKCE1ldGFkYXRhEhMKC2Rlc2NyaXB0aW9uGAEgASgJEjMKC2Rlbm9tX3VuaXRzGAIgAygLMh4uY29zbW9zLmJhbmsudjFiZXRhMS5EZW5vbVVuaXQSDAoEYmFzZRgDIAEoCRIPCgdkaXNwbGF5GAQgASgJEgwKBG5hbWUYBSABKAkSDgoGc3ltYm9sGAYgASgJEhQKA3VyaRgHIAEoCUIH4t4fA1VSSRIdCgh1cmlfaGFzaBgIIAEoCUIL4t4fB1VSSUhhc2hCK1opZ2l0aHViLmNvbS9jb3Ntb3MvY29zbW9zLXNkay94L2JhbmsvdHlwZXNiBnByb3RvMw", [
+	file_gogoproto_gogo$3,
+	file_cosmos_proto_cosmos,
+	file_cosmos_base_v1beta1_coin$1,
+	file_cosmos_msg_v1_msg$1,
+	file_amino_amino$1
+]);
+/**
+* Query defines the gRPC querier service.
+*
+* @generated from service cosmos.bank.v1beta1.Query
+*/
+const Query$12 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Ch9jb3Ntb3MvYmFuay92MWJldGExL3F1ZXJ5LnByb3RvEhNjb3Ntb3MuYmFuay52MWJldGExIlkKE1F1ZXJ5QmFsYW5jZVJlcXVlc3QSKQoHYWRkcmVzcxgBIAEoCUIY0rQtFGNvc21vcy5BZGRyZXNzU3RyaW5nEg0KBWRlbm9tGAIgASgJOgiIoB8A6KAfACJCChRRdWVyeUJhbGFuY2VSZXNwb25zZRIqCgdiYWxhbmNlGAEgASgLMhkuY29zbW9zLmJhc2UudjFiZXRhMS5Db2luIqEBChdRdWVyeUFsbEJhbGFuY2VzUmVxdWVzdBIpCgdhZGRyZXNzGAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSOgoKcGFnaW5hdGlvbhgCIAEoCzImLmNvc21vcy5iYXNlLnF1ZXJ5LnYxYmV0YTEuUGFnZVJlcXVlc3QSFQoNcmVzb2x2ZV9kZW5vbRgDIAEoCDoIiKAfAOigHwAizAEKGFF1ZXJ5QWxsQmFsYW5jZXNSZXNwb25zZRJzCghiYWxhbmNlcxgBIAMoCzIZLmNvc21vcy5iYXNlLnYxYmV0YTEuQ29pbkJGyN4fAKrfHyhnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3R5cGVzLkNvaW5zmuewKgxsZWdhY3lfY29pbnOo57AqARI7CgpwYWdpbmF0aW9uGAIgASgLMicuY29zbW9zLmJhc2UucXVlcnkudjFiZXRhMS5QYWdlUmVzcG9uc2UikAEKHVF1ZXJ5U3BlbmRhYmxlQmFsYW5jZXNSZXF1ZXN0EikKB2FkZHJlc3MYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxI6CgpwYWdpbmF0aW9uGAIgASgLMiYuY29zbW9zLmJhc2UucXVlcnkudjFiZXRhMS5QYWdlUmVxdWVzdDoIiKAfAOigHwAi0gEKHlF1ZXJ5U3BlbmRhYmxlQmFsYW5jZXNSZXNwb25zZRJzCghiYWxhbmNlcxgBIAMoCzIZLmNvc21vcy5iYXNlLnYxYmV0YTEuQ29pbkJGyN4fAKrfHyhnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3R5cGVzLkNvaW5zmuewKgxsZWdhY3lfY29pbnOo57AqARI7CgpwYWdpbmF0aW9uGAIgASgLMicuY29zbW9zLmJhc2UucXVlcnkudjFiZXRhMS5QYWdlUmVzcG9uc2UiaQojUXVlcnlTcGVuZGFibGVCYWxhbmNlQnlEZW5vbVJlcXVlc3QSKQoHYWRkcmVzcxgBIAEoCUIY0rQtFGNvc21vcy5BZGRyZXNzU3RyaW5nEg0KBWRlbm9tGAIgASgJOgiIoB8A6KAfACJSCiRRdWVyeVNwZW5kYWJsZUJhbGFuY2VCeURlbm9tUmVzcG9uc2USKgoHYmFsYW5jZRgBIAEoCzIZLmNvc21vcy5iYXNlLnYxYmV0YTEuQ29pbiJfChdRdWVyeVRvdGFsU3VwcGx5UmVxdWVzdBI6CgpwYWdpbmF0aW9uGAEgASgLMiYuY29zbW9zLmJhc2UucXVlcnkudjFiZXRhMS5QYWdlUmVxdWVzdDoIiKAfAOigHwAiygEKGFF1ZXJ5VG90YWxTdXBwbHlSZXNwb25zZRJxCgZzdXBwbHkYASADKAsyGS5jb3Ntb3MuYmFzZS52MWJldGExLkNvaW5CRsjeHwCq3x8oZ2l0aHViLmNvbS9jb3Ntb3MvY29zbW9zLXNkay90eXBlcy5Db2luc5rnsCoMbGVnYWN5X2NvaW5zqOewKgESOwoKcGFnaW5hdGlvbhgCIAEoCzInLmNvc21vcy5iYXNlLnF1ZXJ5LnYxYmV0YTEuUGFnZVJlc3BvbnNlIiUKFFF1ZXJ5U3VwcGx5T2ZSZXF1ZXN0Eg0KBWRlbm9tGAEgASgJIk0KFVF1ZXJ5U3VwcGx5T2ZSZXNwb25zZRI0CgZhbW91bnQYASABKAsyGS5jb3Ntb3MuYmFzZS52MWJldGExLkNvaW5CCcjeHwCo57AqASIUChJRdWVyeVBhcmFtc1JlcXVlc3QiTQoTUXVlcnlQYXJhbXNSZXNwb25zZRI2CgZwYXJhbXMYASABKAsyGy5jb3Ntb3MuYmFuay52MWJldGExLlBhcmFtc0IJyN4fAKjnsCoBIlgKGlF1ZXJ5RGVub21zTWV0YWRhdGFSZXF1ZXN0EjoKCnBhZ2luYXRpb24YASABKAsyJi5jb3Ntb3MuYmFzZS5xdWVyeS52MWJldGExLlBhZ2VSZXF1ZXN0IpcBChtRdWVyeURlbm9tc01ldGFkYXRhUmVzcG9uc2USOwoJbWV0YWRhdGFzGAEgAygLMh0uY29zbW9zLmJhbmsudjFiZXRhMS5NZXRhZGF0YUIJyN4fAKjnsCoBEjsKCnBhZ2luYXRpb24YAiABKAsyJy5jb3Ntb3MuYmFzZS5xdWVyeS52MWJldGExLlBhZ2VSZXNwb25zZSIqChlRdWVyeURlbm9tTWV0YWRhdGFSZXF1ZXN0Eg0KBWRlbm9tGAEgASgJIlgKGlF1ZXJ5RGVub21NZXRhZGF0YVJlc3BvbnNlEjoKCG1ldGFkYXRhGAEgASgLMh0uY29zbW9zLmJhbmsudjFiZXRhMS5NZXRhZGF0YUIJyN4fAKjnsCoBIjcKJlF1ZXJ5RGVub21NZXRhZGF0YUJ5UXVlcnlTdHJpbmdSZXF1ZXN0Eg0KBWRlbm9tGAEgASgJImUKJ1F1ZXJ5RGVub21NZXRhZGF0YUJ5UXVlcnlTdHJpbmdSZXNwb25zZRI6CghtZXRhZGF0YRgBIAEoCzIdLmNvc21vcy5iYW5rLnYxYmV0YTEuTWV0YWRhdGFCCcjeHwCo57AqASJkChdRdWVyeURlbm9tT3duZXJzUmVxdWVzdBINCgVkZW5vbRgBIAEoCRI6CgpwYWdpbmF0aW9uGAIgASgLMiYuY29zbW9zLmJhc2UucXVlcnkudjFiZXRhMS5QYWdlUmVxdWVzdCJuCgpEZW5vbU93bmVyEikKB2FkZHJlc3MYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxI1CgdiYWxhbmNlGAIgASgLMhkuY29zbW9zLmJhc2UudjFiZXRhMS5Db2luQgnI3h8AqOewKgEijgEKGFF1ZXJ5RGVub21Pd25lcnNSZXNwb25zZRI1CgxkZW5vbV9vd25lcnMYASADKAsyHy5jb3Ntb3MuYmFuay52MWJldGExLkRlbm9tT3duZXISOwoKcGFnaW5hdGlvbhgCIAEoCzInLmNvc21vcy5iYXNlLnF1ZXJ5LnYxYmV0YTEuUGFnZVJlc3BvbnNlImUKF1F1ZXJ5U2VuZEVuYWJsZWRSZXF1ZXN0Eg4KBmRlbm9tcxgBIAMoCRI6CgpwYWdpbmF0aW9uGGMgASgLMiYuY29zbW9zLmJhc2UucXVlcnkudjFiZXRhMS5QYWdlUmVxdWVzdCKPAQoYUXVlcnlTZW5kRW5hYmxlZFJlc3BvbnNlEjYKDHNlbmRfZW5hYmxlZBgBIAMoCzIgLmNvc21vcy5iYW5rLnYxYmV0YTEuU2VuZEVuYWJsZWQSOwoKcGFnaW5hdGlvbhhjIAEoCzInLmNvc21vcy5iYXNlLnF1ZXJ5LnYxYmV0YTEuUGFnZVJlc3BvbnNlMo8QCgVRdWVyeRKdAQoHQmFsYW5jZRIoLmNvc21vcy5iYW5rLnYxYmV0YTEuUXVlcnlCYWxhbmNlUmVxdWVzdBopLmNvc21vcy5iYW5rLnYxYmV0YTEuUXVlcnlCYWxhbmNlUmVzcG9uc2UiPYjnsCoBgtPkkwIyEjAvY29zbW9zL2JhbmsvdjFiZXRhMS9iYWxhbmNlcy97YWRkcmVzc30vYnlfZGVub20SoAEKC0FsbEJhbGFuY2VzEiwuY29zbW9zLmJhbmsudjFiZXRhMS5RdWVyeUFsbEJhbGFuY2VzUmVxdWVzdBotLmNvc21vcy5iYW5rLnYxYmV0YTEuUXVlcnlBbGxCYWxhbmNlc1Jlc3BvbnNlIjSI57AqAYLT5JMCKRInL2Nvc21vcy9iYW5rL3YxYmV0YTEvYmFsYW5jZXMve2FkZHJlc3N9ErwBChFTcGVuZGFibGVCYWxhbmNlcxIyLmNvc21vcy5iYW5rLnYxYmV0YTEuUXVlcnlTcGVuZGFibGVCYWxhbmNlc1JlcXVlc3QaMy5jb3Ntb3MuYmFuay52MWJldGExLlF1ZXJ5U3BlbmRhYmxlQmFsYW5jZXNSZXNwb25zZSI+iOewKgGC0+STAjMSMS9jb3Ntb3MvYmFuay92MWJldGExL3NwZW5kYWJsZV9iYWxhbmNlcy97YWRkcmVzc30S1wEKF1NwZW5kYWJsZUJhbGFuY2VCeURlbm9tEjguY29zbW9zLmJhbmsudjFiZXRhMS5RdWVyeVNwZW5kYWJsZUJhbGFuY2VCeURlbm9tUmVxdWVzdBo5LmNvc21vcy5iYW5rLnYxYmV0YTEuUXVlcnlTcGVuZGFibGVCYWxhbmNlQnlEZW5vbVJlc3BvbnNlIkeI57AqAYLT5JMCPBI6L2Nvc21vcy9iYW5rL3YxYmV0YTEvc3BlbmRhYmxlX2JhbGFuY2VzL3thZGRyZXNzfS9ieV9kZW5vbRKUAQoLVG90YWxTdXBwbHkSLC5jb3Ntb3MuYmFuay52MWJldGExLlF1ZXJ5VG90YWxTdXBwbHlSZXF1ZXN0Gi0uY29zbW9zLmJhbmsudjFiZXRhMS5RdWVyeVRvdGFsU3VwcGx5UmVzcG9uc2UiKIjnsCoBgtPkkwIdEhsvY29zbW9zL2JhbmsvdjFiZXRhMS9zdXBwbHkSlAEKCFN1cHBseU9mEikuY29zbW9zLmJhbmsudjFiZXRhMS5RdWVyeVN1cHBseU9mUmVxdWVzdBoqLmNvc21vcy5iYW5rLnYxYmV0YTEuUXVlcnlTdXBwbHlPZlJlc3BvbnNlIjGI57AqAYLT5JMCJhIkL2Nvc21vcy9iYW5rL3YxYmV0YTEvc3VwcGx5L2J5X2Rlbm9tEoUBCgZQYXJhbXMSJy5jb3Ntb3MuYmFuay52MWJldGExLlF1ZXJ5UGFyYW1zUmVxdWVzdBooLmNvc21vcy5iYW5rLnYxYmV0YTEuUXVlcnlQYXJhbXNSZXNwb25zZSIoiOewKgGC0+STAh0SGy9jb3Ntb3MvYmFuay92MWJldGExL3BhcmFtcxKrAQoNRGVub21NZXRhZGF0YRIuLmNvc21vcy5iYW5rLnYxYmV0YTEuUXVlcnlEZW5vbU1ldGFkYXRhUmVxdWVzdBovLmNvc21vcy5iYW5rLnYxYmV0YTEuUXVlcnlEZW5vbU1ldGFkYXRhUmVzcG9uc2UiOYjnsCoBgtPkkwIuEiwvY29zbW9zL2JhbmsvdjFiZXRhMS9kZW5vbXNfbWV0YWRhdGEve2Rlbm9tfRLaAQoaRGVub21NZXRhZGF0YUJ5UXVlcnlTdHJpbmcSOy5jb3Ntb3MuYmFuay52MWJldGExLlF1ZXJ5RGVub21NZXRhZGF0YUJ5UXVlcnlTdHJpbmdSZXF1ZXN0GjwuY29zbW9zLmJhbmsudjFiZXRhMS5RdWVyeURlbm9tTWV0YWRhdGFCeVF1ZXJ5U3RyaW5nUmVzcG9uc2UiQYjnsCoBgtPkkwI2EjQvY29zbW9zL2JhbmsvdjFiZXRhMS9kZW5vbXNfbWV0YWRhdGFfYnlfcXVlcnlfc3RyaW5nEqYBCg5EZW5vbXNNZXRhZGF0YRIvLmNvc21vcy5iYW5rLnYxYmV0YTEuUXVlcnlEZW5vbXNNZXRhZGF0YVJlcXVlc3QaMC5jb3Ntb3MuYmFuay52MWJldGExLlF1ZXJ5RGVub21zTWV0YWRhdGFSZXNwb25zZSIxiOewKgGC0+STAiYSJC9jb3Ntb3MvYmFuay92MWJldGExL2Rlbm9tc19tZXRhZGF0YRKiAQoLRGVub21Pd25lcnMSLC5jb3Ntb3MuYmFuay52MWJldGExLlF1ZXJ5RGVub21Pd25lcnNSZXF1ZXN0Gi0uY29zbW9zLmJhbmsudjFiZXRhMS5RdWVyeURlbm9tT3duZXJzUmVzcG9uc2UiNojnsCoBgtPkkwIrEikvY29zbW9zL2JhbmsvdjFiZXRhMS9kZW5vbV9vd25lcnMve2Rlbm9tfRKaAQoLU2VuZEVuYWJsZWQSLC5jb3Ntb3MuYmFuay52MWJldGExLlF1ZXJ5U2VuZEVuYWJsZWRSZXF1ZXN0Gi0uY29zbW9zLmJhbmsudjFiZXRhMS5RdWVyeVNlbmRFbmFibGVkUmVzcG9uc2UiLojnsCoBgtPkkwIjEiEvY29zbW9zL2JhbmsvdjFiZXRhMS9zZW5kX2VuYWJsZWRCK1opZ2l0aHViLmNvbS9jb3Ntb3MvY29zbW9zLXNkay94L2JhbmsvdHlwZXNiBnByb3RvMw", [
+	file_cosmos_base_query_v1beta1_pagination$1,
+	file_gogoproto_gogo$3,
+	file_google_api_annotations$2,
+	file_cosmos_base_v1beta1_coin$1,
+	file_cosmos_bank_v1beta1_bank,
+	file_cosmos_proto_cosmos,
+	file_cosmos_query_v1_query,
+	file_amino_amino$1
+]), 0);
+/**
+* Service defines the gRPC querier service for tendermint queries.
+*
+* @generated from service cosmos.base.tendermint.v1beta1.Service
+*/
+const Service = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [
+	file_gogoproto_gogo$3,
+	file_google_protobuf_any,
+	file_google_api_annotations$2,
+	/* @__PURE__ */ fileDesc("Chp0ZW5kZXJtaW50L3AycC90eXBlcy5wcm90bxIOdGVuZGVybWludC5wMnAiQgoKTmV0QWRkcmVzcxISCgJpZBgBIAEoCUIG4t4fAklEEhIKAmlwGAIgASgJQgbi3h8CSVASDAoEcG9ydBgDIAEoDSJDCg9Qcm90b2NvbFZlcnNpb24SFAoDcDJwGAEgASgEQgfi3h8DUDJQEg0KBWJsb2NrGAIgASgEEgsKA2FwcBgDIAEoBCKTAgoPRGVmYXVsdE5vZGVJbmZvEj8KEHByb3RvY29sX3ZlcnNpb24YASABKAsyHy50ZW5kZXJtaW50LnAycC5Qcm90b2NvbFZlcnNpb25CBMjeHwASKgoPZGVmYXVsdF9ub2RlX2lkGAIgASgJQhHi3h8NRGVmYXVsdE5vZGVJRBITCgtsaXN0ZW5fYWRkchgDIAEoCRIPCgduZXR3b3JrGAQgASgJEg8KB3ZlcnNpb24YBSABKAkSEAoIY2hhbm5lbHMYBiABKAwSDwoHbW9uaWtlchgHIAEoCRI5CgVvdGhlchgIIAEoCzIkLnRlbmRlcm1pbnQucDJwLkRlZmF1bHROb2RlSW5mb090aGVyQgTI3h8AIk0KFERlZmF1bHROb2RlSW5mb090aGVyEhAKCHR4X2luZGV4GAEgASgJEiMKC3JwY19hZGRyZXNzGAIgASgJQg7i3h8KUlBDQWRkcmVzc0IzWjFnaXRodWIuY29tL2NvbWV0YmZ0L2NvbWV0YmZ0L3Byb3RvL3RlbmRlcm1pbnQvcDJwYgZwcm90bzM", [file_gogoproto_gogo$3]),
+	file_tendermint_types_types,
+	file_cosmos_base_query_v1beta1_pagination$1,
+	/* @__PURE__ */ fileDesc("Cipjb3Ntb3MvYmFzZS90ZW5kZXJtaW50L3YxYmV0YTEvdHlwZXMucHJvdG8SHmNvc21vcy5iYXNlLnRlbmRlcm1pbnQudjFiZXRhMSLnAQoFQmxvY2sSQQoGaGVhZGVyGAEgASgLMiYuY29zbW9zLmJhc2UudGVuZGVybWludC52MWJldGExLkhlYWRlckIJyN4fAKjnsCoBEi8KBGRhdGEYAiABKAsyFi50ZW5kZXJtaW50LnR5cGVzLkRhdGFCCcjeHwCo57AqARI7CghldmlkZW5jZRgDIAEoCzIeLnRlbmRlcm1pbnQudHlwZXMuRXZpZGVuY2VMaXN0QgnI3h8AqOewKgESLQoLbGFzdF9jb21taXQYBCABKAsyGC50ZW5kZXJtaW50LnR5cGVzLkNvbW1pdCLCAwoGSGVhZGVyEjkKB3ZlcnNpb24YASABKAsyHS50ZW5kZXJtaW50LnZlcnNpb24uQ29uc2Vuc3VzQgnI3h8AqOewKgESHQoIY2hhaW5faWQYAiABKAlCC+LeHwdDaGFpbklEEg4KBmhlaWdodBgDIAEoAxI3CgR0aW1lGAQgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEINyN4fAJDfHwGo57AqARI7Cg1sYXN0X2Jsb2NrX2lkGAUgASgLMhkudGVuZGVybWludC50eXBlcy5CbG9ja0lEQgnI3h8AqOewKgESGAoQbGFzdF9jb21taXRfaGFzaBgGIAEoDBIRCglkYXRhX2hhc2gYByABKAwSFwoPdmFsaWRhdG9yc19oYXNoGAggASgMEhwKFG5leHRfdmFsaWRhdG9yc19oYXNoGAkgASgMEhYKDmNvbnNlbnN1c19oYXNoGAogASgMEhAKCGFwcF9oYXNoGAsgASgMEhkKEWxhc3RfcmVzdWx0c19oYXNoGAwgASgMEhUKDWV2aWRlbmNlX2hhc2gYDSABKAwSGAoQcHJvcG9zZXJfYWRkcmVzcxgOIAEoCUI1WjNnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL2NsaWVudC9ncnBjL2NtdHNlcnZpY2ViBnByb3RvMw", [
+		file_gogoproto_gogo$3,
+		file_tendermint_types_types,
+		file_tendermint_types_evidence,
+		file_tendermint_version_types,
+		file_google_protobuf_timestamp,
+		file_amino_amino$1
+	]),
+	file_cosmos_proto_cosmos,
+	file_tendermint_types_block,
+	file_amino_amino$1
+]), 0);
+//#endregion
+//#region node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/cosmos/authz/v1beta1/authz_pb.js
+/**
+* Describes the file cosmos/authz/v1beta1/authz.proto.
+*/
+const file_cosmos_authz_v1beta1_authz = /* @__PURE__ */ fileDesc("CiBjb3Ntb3MvYXV0aHovdjFiZXRhMS9hdXRoei5wcm90bxIUY29zbW9zLmF1dGh6LnYxYmV0YTEibwoUR2VuZXJpY0F1dGhvcml6YXRpb24SCwoDbXNnGAEgASgJOkrKtC0iY29zbW9zLmF1dGh6LnYxYmV0YTEuQXV0aG9yaXphdGlvbornsCofY29zbW9zLXNkay9HZW5lcmljQXV0aG9yaXphdGlvbiKWAQoFR3JhbnQSUwoNYXV0aG9yaXphdGlvbhgBIAEoCzIULmdvb2dsZS5wcm90b2J1Zi5BbnlCJsq0LSJjb3Ntb3MuYXV0aHoudjFiZXRhMS5BdXRob3JpemF0aW9uEjgKCmV4cGlyYXRpb24YAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgjI3h8BkN8fASL1AQoSR3JhbnRBdXRob3JpemF0aW9uEikKB2dyYW50ZXIYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxIpCgdncmFudGVlGAIgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSUwoNYXV0aG9yaXphdGlvbhgDIAEoCzIULmdvb2dsZS5wcm90b2J1Zi5BbnlCJsq0LSJjb3Ntb3MuYXV0aHoudjFiZXRhMS5BdXRob3JpemF0aW9uEjQKCmV4cGlyYXRpb24YBCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgSQ3x8BIicKDkdyYW50UXVldWVJdGVtEhUKDW1zZ190eXBlX3VybHMYASADKAlCKlokZ2l0aHViLmNvbS9jb3Ntb3MvY29zbW9zLXNkay94L2F1dGh6yOEeAGIGcHJvdG8z", [
+	file_amino_amino$1,
+	file_cosmos_proto_cosmos,
+	file_google_protobuf_timestamp,
+	file_gogoproto_gogo$3,
+	file_google_protobuf_any
+]);
+/**
+* Query defines the gRPC querier service.
+*
+* @generated from service cosmos.authz.v1beta1.Query
+*/
+const Query$11 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("CiBjb3Ntb3MvYXV0aHovdjFiZXRhMS9xdWVyeS5wcm90bxIUY29zbW9zLmF1dGh6LnYxYmV0YTEivAEKElF1ZXJ5R3JhbnRzUmVxdWVzdBIpCgdncmFudGVyGAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSKQoHZ3JhbnRlZRgCIAEoCUIY0rQtFGNvc21vcy5BZGRyZXNzU3RyaW5nEhQKDG1zZ190eXBlX3VybBgDIAEoCRI6CgpwYWdpbmF0aW9uGAQgASgLMiYuY29zbW9zLmJhc2UucXVlcnkudjFiZXRhMS5QYWdlUmVxdWVzdCJ/ChNRdWVyeUdyYW50c1Jlc3BvbnNlEisKBmdyYW50cxgBIAMoCzIbLmNvc21vcy5hdXRoei52MWJldGExLkdyYW50EjsKCnBhZ2luYXRpb24YAiABKAsyJy5jb3Ntb3MuYmFzZS5xdWVyeS52MWJldGExLlBhZ2VSZXNwb25zZSKCAQoZUXVlcnlHcmFudGVyR3JhbnRzUmVxdWVzdBIpCgdncmFudGVyGAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSOgoKcGFnaW5hdGlvbhgCIAEoCzImLmNvc21vcy5iYXNlLnF1ZXJ5LnYxYmV0YTEuUGFnZVJlcXVlc3QikwEKGlF1ZXJ5R3JhbnRlckdyYW50c1Jlc3BvbnNlEjgKBmdyYW50cxgBIAMoCzIoLmNvc21vcy5hdXRoei52MWJldGExLkdyYW50QXV0aG9yaXphdGlvbhI7CgpwYWdpbmF0aW9uGAIgASgLMicuY29zbW9zLmJhc2UucXVlcnkudjFiZXRhMS5QYWdlUmVzcG9uc2UiggEKGVF1ZXJ5R3JhbnRlZUdyYW50c1JlcXVlc3QSKQoHZ3JhbnRlZRgBIAEoCUIY0rQtFGNvc21vcy5BZGRyZXNzU3RyaW5nEjoKCnBhZ2luYXRpb24YAiABKAsyJi5jb3Ntb3MuYmFzZS5xdWVyeS52MWJldGExLlBhZ2VSZXF1ZXN0IpMBChpRdWVyeUdyYW50ZWVHcmFudHNSZXNwb25zZRI4CgZncmFudHMYASADKAsyKC5jb3Ntb3MuYXV0aHoudjFiZXRhMS5HcmFudEF1dGhvcml6YXRpb24SOwoKcGFnaW5hdGlvbhgCIAEoCzInLmNvc21vcy5iYXNlLnF1ZXJ5LnYxYmV0YTEuUGFnZVJlc3BvbnNlMucDCgVRdWVyeRKDAQoGR3JhbnRzEiguY29zbW9zLmF1dGh6LnYxYmV0YTEuUXVlcnlHcmFudHNSZXF1ZXN0GikuY29zbW9zLmF1dGh6LnYxYmV0YTEuUXVlcnlHcmFudHNSZXNwb25zZSIkgtPkkwIeEhwvY29zbW9zL2F1dGh6L3YxYmV0YTEvZ3JhbnRzEqoBCg1HcmFudGVyR3JhbnRzEi8uY29zbW9zLmF1dGh6LnYxYmV0YTEuUXVlcnlHcmFudGVyR3JhbnRzUmVxdWVzdBowLmNvc21vcy5hdXRoei52MWJldGExLlF1ZXJ5R3JhbnRlckdyYW50c1Jlc3BvbnNlIjaC0+STAjASLi9jb3Ntb3MvYXV0aHovdjFiZXRhMS9ncmFudHMvZ3JhbnRlci97Z3JhbnRlcn0SqgEKDUdyYW50ZWVHcmFudHMSLy5jb3Ntb3MuYXV0aHoudjFiZXRhMS5RdWVyeUdyYW50ZWVHcmFudHNSZXF1ZXN0GjAuY29zbW9zLmF1dGh6LnYxYmV0YTEuUXVlcnlHcmFudGVlR3JhbnRzUmVzcG9uc2UiNoLT5JMCMBIuL2Nvc21vcy9hdXRoei92MWJldGExL2dyYW50cy9ncmFudGVlL3tncmFudGVlfUImWiRnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3gvYXV0aHpiBnByb3RvMw", [
+	file_google_api_annotations$2,
+	file_cosmos_base_query_v1beta1_pagination$1,
+	file_cosmos_authz_v1beta1_authz,
+	file_cosmos_proto_cosmos
+]), 0);
+/**
+* Query defines the gRPC querier service.
+*
+* @generated from service cosmos.feegrant.v1beta1.Query
+*/
+const Query$10 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("CiNjb3Ntb3MvZmVlZ3JhbnQvdjFiZXRhMS9xdWVyeS5wcm90bxIXY29zbW9zLmZlZWdyYW50LnYxYmV0YTEibQoVUXVlcnlBbGxvd2FuY2VSZXF1ZXN0EikKB2dyYW50ZXIYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxIpCgdncmFudGVlGAIgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmciSwoWUXVlcnlBbGxvd2FuY2VSZXNwb25zZRIxCglhbGxvd2FuY2UYASABKAsyHi5jb3Ntb3MuZmVlZ3JhbnQudjFiZXRhMS5HcmFudCJ/ChZRdWVyeUFsbG93YW5jZXNSZXF1ZXN0EikKB2dyYW50ZWUYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxI6CgpwYWdpbmF0aW9uGAIgASgLMiYuY29zbW9zLmJhc2UucXVlcnkudjFiZXRhMS5QYWdlUmVxdWVzdCKKAQoXUXVlcnlBbGxvd2FuY2VzUmVzcG9uc2USMgoKYWxsb3dhbmNlcxgBIAMoCzIeLmNvc21vcy5mZWVncmFudC52MWJldGExLkdyYW50EjsKCnBhZ2luYXRpb24YAiABKAsyJy5jb3Ntb3MuYmFzZS5xdWVyeS52MWJldGExLlBhZ2VSZXNwb25zZSKIAQofUXVlcnlBbGxvd2FuY2VzQnlHcmFudGVyUmVxdWVzdBIpCgdncmFudGVyGAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSOgoKcGFnaW5hdGlvbhgCIAEoCzImLmNvc21vcy5iYXNlLnF1ZXJ5LnYxYmV0YTEuUGFnZVJlcXVlc3QikwEKIFF1ZXJ5QWxsb3dhbmNlc0J5R3JhbnRlclJlc3BvbnNlEjIKCmFsbG93YW5jZXMYASADKAsyHi5jb3Ntb3MuZmVlZ3JhbnQudjFiZXRhMS5HcmFudBI7CgpwYWdpbmF0aW9uGAIgASgLMicuY29zbW9zLmJhc2UucXVlcnkudjFiZXRhMS5QYWdlUmVzcG9uc2UynwQKBVF1ZXJ5EqwBCglBbGxvd2FuY2USLi5jb3Ntb3MuZmVlZ3JhbnQudjFiZXRhMS5RdWVyeUFsbG93YW5jZVJlcXVlc3QaLy5jb3Ntb3MuZmVlZ3JhbnQudjFiZXRhMS5RdWVyeUFsbG93YW5jZVJlc3BvbnNlIj6C0+STAjgSNi9jb3Ntb3MvZmVlZ3JhbnQvdjFiZXRhMS9hbGxvd2FuY2Uve2dyYW50ZXJ9L3tncmFudGVlfRKmAQoKQWxsb3dhbmNlcxIvLmNvc21vcy5mZWVncmFudC52MWJldGExLlF1ZXJ5QWxsb3dhbmNlc1JlcXVlc3QaMC5jb3Ntb3MuZmVlZ3JhbnQudjFiZXRhMS5RdWVyeUFsbG93YW5jZXNSZXNwb25zZSI1gtPkkwIvEi0vY29zbW9zL2ZlZWdyYW50L3YxYmV0YTEvYWxsb3dhbmNlcy97Z3JhbnRlZX0SvQEKE0FsbG93YW5jZXNCeUdyYW50ZXISOC5jb3Ntb3MuZmVlZ3JhbnQudjFiZXRhMS5RdWVyeUFsbG93YW5jZXNCeUdyYW50ZXJSZXF1ZXN0GjkuY29zbW9zLmZlZWdyYW50LnYxYmV0YTEuUXVlcnlBbGxvd2FuY2VzQnlHcmFudGVyUmVzcG9uc2UiMYLT5JMCKxIpL2Nvc21vcy9mZWVncmFudC92MWJldGExL2lzc3VlZC97Z3JhbnRlcn1CGVoXY29zbW9zc2RrLmlvL3gvZmVlZ3JhbnRiBnByb3RvMw", [
+	/* @__PURE__ */ fileDesc("CiZjb3Ntb3MvZmVlZ3JhbnQvdjFiZXRhMS9mZWVncmFudC5wcm90bxIXY29zbW9zLmZlZWdyYW50LnYxYmV0YTEihwIKDkJhc2ljQWxsb3dhbmNlEnYKC3NwZW5kX2xpbWl0GAEgAygLMhkuY29zbW9zLmJhc2UudjFiZXRhMS5Db2luQkbI3h8Aqt8fKGdpdGh1Yi5jb20vY29zbW9zL2Nvc21vcy1zZGsvdHlwZXMuQ29pbnOa57AqDGxlZ2FjeV9jb2luc6jnsCoBEjQKCmV4cGlyYXRpb24YAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgSQ3x8BOkfKtC0lY29zbW9zLmZlZWdyYW50LnYxYmV0YTEuRmVlQWxsb3dhbmNlSYrnsCoZY29zbW9zLXNkay9CYXNpY0FsbG93YW5jZSKZBAoRUGVyaW9kaWNBbGxvd2FuY2USQQoFYmFzaWMYASABKAsyJy5jb3Ntb3MuZmVlZ3JhbnQudjFiZXRhMS5CYXNpY0FsbG93YW5jZUIJyN4fAKjnsCoBEjgKBnBlcmlvZBgCIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbkINyN4fAJjfHwGo57AqARJ9ChJwZXJpb2Rfc3BlbmRfbGltaXQYAyADKAsyGS5jb3Ntb3MuYmFzZS52MWJldGExLkNvaW5CRsjeHwCq3x8oZ2l0aHViLmNvbS9jb3Ntb3MvY29zbW9zLXNkay90eXBlcy5Db2luc5rnsCoMbGVnYWN5X2NvaW5zqOewKgESewoQcGVyaW9kX2Nhbl9zcGVuZBgEIAMoCzIZLmNvc21vcy5iYXNlLnYxYmV0YTEuQ29pbkJGyN4fAKrfHyhnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3R5cGVzLkNvaW5zmuewKgxsZWdhY3lfY29pbnOo57AqARI/CgxwZXJpb2RfcmVzZXQYBSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQg3I3h8AkN8fAajnsCoBOkrKtC0lY29zbW9zLmZlZWdyYW50LnYxYmV0YTEuRmVlQWxsb3dhbmNlSYrnsCocY29zbW9zLXNkay9QZXJpb2RpY0FsbG93YW5jZSLVAQoTQWxsb3dlZE1zZ0FsbG93YW5jZRJSCglhbGxvd2FuY2UYASABKAsyFC5nb29nbGUucHJvdG9idWYuQW55QinKtC0lY29zbW9zLmZlZWdyYW50LnYxYmV0YTEuRmVlQWxsb3dhbmNlSRIYChBhbGxvd2VkX21lc3NhZ2VzGAIgAygJOlCIoB8AyrQtJWNvc21vcy5mZWVncmFudC52MWJldGExLkZlZUFsbG93YW5jZUmK57AqHmNvc21vcy1zZGsvQWxsb3dlZE1zZ0FsbG93YW5jZSKxAQoFR3JhbnQSKQoHZ3JhbnRlchgBIAEoCUIY0rQtFGNvc21vcy5BZGRyZXNzU3RyaW5nEikKB2dyYW50ZWUYAiABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxJSCglhbGxvd2FuY2UYAyABKAsyFC5nb29nbGUucHJvdG9idWYuQW55QinKtC0lY29zbW9zLmZlZWdyYW50LnYxYmV0YTEuRmVlQWxsb3dhbmNlSUIZWhdjb3Ntb3NzZGsuaW8veC9mZWVncmFudGIGcHJvdG8z", [
+		file_gogoproto_gogo$3,
+		file_google_protobuf_any,
+		file_cosmos_proto_cosmos,
+		file_cosmos_base_v1beta1_coin$1,
+		file_amino_amino$1,
+		file_google_protobuf_timestamp,
+		file_google_protobuf_duration
+	]),
+	file_cosmos_base_query_v1beta1_pagination$1,
+	file_google_api_annotations$2,
+	file_cosmos_proto_cosmos
+]), 0);
+//#endregion
+//#region node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/cosmos/group/v1/types_pb.js
+/**
+* Describes the file cosmos/group/v1/types.proto.
+*/
+const file_cosmos_group_v1_types = /* @__PURE__ */ fileDesc("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", [
+	file_gogoproto_gogo$3,
+	file_google_protobuf_duration,
+	file_google_protobuf_timestamp,
+	file_cosmos_proto_cosmos,
+	file_google_protobuf_any,
+	file_amino_amino$1
+]);
+/**
+* Query is the cosmos.group.v1 Query service.
+*
+* @generated from service cosmos.group.v1.Query
+*/
+const Query$9 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [
+	file_gogoproto_gogo$3,
+	file_google_api_annotations$2,
+	file_cosmos_group_v1_types,
+	file_cosmos_base_query_v1beta1_pagination$1,
+	file_cosmos_proto_cosmos,
+	file_amino_amino$1
+]), 0);
+//#endregion
+//#region node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/cosmos/upgrade/v1beta1/upgrade_pb.js
+/**
+* Describes the file cosmos/upgrade/v1beta1/upgrade.proto.
+*/
+const file_cosmos_upgrade_v1beta1_upgrade$1 = /* @__PURE__ */ fileDesc("CiRjb3Ntb3MvdXBncmFkZS92MWJldGExL3VwZ3JhZGUucHJvdG8SFmNvc21vcy51cGdyYWRlLnYxYmV0YTEiwAEKBFBsYW4SDAoEbmFtZRgBIAEoCRI5CgR0aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEIPGAHI3h8AkN8fAajnsCoBEg4KBmhlaWdodBgDIAEoAxIMCgRpbmZvGAQgASgJEjcKFXVwZ3JhZGVkX2NsaWVudF9zdGF0ZRgFIAEoCzIULmdvb2dsZS5wcm90b2J1Zi5BbnlCAhgBOhjooB8BiuewKg9jb3Ntb3Mtc2RrL1BsYW4iwQEKF1NvZnR3YXJlVXBncmFkZVByb3Bvc2FsEg0KBXRpdGxlGAEgASgJEhMKC2Rlc2NyaXB0aW9uGAIgASgJEjUKBHBsYW4YAyABKAsyHC5jb3Ntb3MudXBncmFkZS52MWJldGExLlBsYW5CCcjeHwCo57AqATpLGAHooB8ByrQtGmNvc21vcy5nb3YudjFiZXRhMS5Db250ZW50iuewKiJjb3Ntb3Mtc2RrL1NvZnR3YXJlVXBncmFkZVByb3Bvc2FsIpYBCh1DYW5jZWxTb2Z0d2FyZVVwZ3JhZGVQcm9wb3NhbBINCgV0aXRsZRgBIAEoCRITCgtkZXNjcmlwdGlvbhgCIAEoCTpRGAHooB8ByrQtGmNvc21vcy5nb3YudjFiZXRhMS5Db250ZW50iuewKihjb3Ntb3Mtc2RrL0NhbmNlbFNvZnR3YXJlVXBncmFkZVByb3Bvc2FsIjQKDU1vZHVsZVZlcnNpb24SDAoEbmFtZRgBIAEoCRIPCgd2ZXJzaW9uGAIgASgEOgTooB8BQiJaHGNvc21vc3Nkay5pby94L3VwZ3JhZGUvdHlwZXPI4R4AYgZwcm90bzM", [
+	file_google_protobuf_any,
+	file_gogoproto_gogo$3,
+	file_google_protobuf_timestamp,
+	file_cosmos_proto_cosmos,
+	file_amino_amino$1
+]);
+/**
+* Query defines the gRPC upgrade querier service.
+*
+* @generated from service cosmos.upgrade.v1beta1.Query
+*/
+const Query$8 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [file_google_api_annotations$2, file_cosmos_upgrade_v1beta1_upgrade$1]), 0);
+/**
+* Query defines the gRPC querier service.
+*
+* @generated from service cosmos.consensus.v1.Query
+*/
+const Query$7 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Ch9jb3Ntb3MvY29uc2Vuc3VzL3YxL3F1ZXJ5LnByb3RvEhNjb3Ntb3MuY29uc2Vuc3VzLnYxIhQKElF1ZXJ5UGFyYW1zUmVxdWVzdCJIChNRdWVyeVBhcmFtc1Jlc3BvbnNlEjEKBnBhcmFtcxgBIAEoCzIhLnRlbmRlcm1pbnQudHlwZXMuQ29uc2Vuc3VzUGFyYW1zMooBCgVRdWVyeRKAAQoGUGFyYW1zEicuY29zbW9zLmNvbnNlbnN1cy52MS5RdWVyeVBhcmFtc1JlcXVlc3QaKC5jb3Ntb3MuY29uc2Vuc3VzLnYxLlF1ZXJ5UGFyYW1zUmVzcG9uc2UiI4LT5JMCHRIbL2Nvc21vcy9jb25zZW5zdXMvdjEvcGFyYW1zQjBaLmdpdGh1Yi5jb20vY29zbW9zL2Nvc21vcy1zZGsveC9jb25zZW5zdXMvdHlwZXNiBnByb3RvMw", [file_google_api_annotations$2, file_tendermint_types_params]), 0);
+//#endregion
+//#region node_modules/@buf/initia-labs_initia.bufbuild_es/initia/ibchooks/v1/types_pb.js
+/**
+* Describes the file initia/ibchooks/v1/types.proto.
+*/
+const file_initia_ibchooks_v1_types = /* @__PURE__ */ fileDesc("Ch5pbml0aWEvaWJjaG9va3MvdjEvdHlwZXMucHJvdG8SEmluaXRpYS5pYmNob29rcy52MSI/CgZQYXJhbXMSFwoPZGVmYXVsdF9hbGxvd2VkGAEgASgIOhyYoB8A6KAfAYrnsCoPaWJjaG9va3MvUGFyYW1zIicKA0FDTBIPCgdhZGRyZXNzGAEgASgJEg8KB2FsbG93ZWQYAiABKAgimQIKDVRyYW5zZmVyRnVuZHMSgAEKDmJhbGFuY2VfY2hhbmdlGAEgASgLMhkuY29zbW9zLmJhc2UudjFiZXRhMS5Db2luQk3I3h8A8t4fFXlhbWw6ImJhbGFuY2VfY2hhbmdlIqrfHydnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3R5cGVzLkNvaW6o57AqARKEAQoQYW1vdW50X2luX3BhY2tldBgCIAEoCzIZLmNvc21vcy5iYXNlLnYxYmV0YTEuQ29pbkJPyN4fAPLeHxd5YW1sOiJhbW91bnRfaW5fcGFja2V0IqrfHydnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3R5cGVzLkNvaW6o57AqAUI5Wi9naXRodWIuY29tL2luaXRpYS1sYWJzL2luaXRpYS94L2liYy1ob29rcy90eXBlc8jhHgCo4h4BYgZwcm90bzM", [
+	file_amino_amino$1,
+	file_cosmos_base_v1beta1_coin$1,
+	file_gogoproto_gogo$3
+]);
+/**
+* Query provides defines the gRPC querier service
+*
+* @generated from service initia.ibchooks.v1.Query
+*/
+const Query$6 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Ch5pbml0aWEvaWJjaG9va3MvdjEvcXVlcnkucHJvdG8SEmluaXRpYS5pYmNob29rcy52MSIiCg9RdWVyeUFDTFJlcXVlc3QSDwoHYWRkcmVzcxgBIAEoCSJJChBRdWVyeUFDTFJlc3BvbnNlEi8KA2FjbBgBIAEoCzIXLmluaXRpYS5pYmNob29rcy52MS5BQ0xCCcjeHwCo57AqAToE6KAfASJOChBRdWVyeUFDTHNSZXF1ZXN0EjoKCnBhZ2luYXRpb24YASABKAsyJi5jb3Ntb3MuYmFzZS5xdWVyeS52MWJldGExLlBhZ2VSZXF1ZXN0IoIBChFRdWVyeUFDTHNSZXNwb25zZRIwCgRhY2xzGAEgAygLMhcuaW5pdGlhLmliY2hvb2tzLnYxLkFDTEIJyN4fAKjnsCoBEjsKCnBhZ2luYXRpb24YAiABKAsyJy5jb3Ntb3MuYmFzZS5xdWVyeS52MWJldGExLlBhZ2VSZXNwb25zZSIUChJRdWVyeVBhcmFtc1JlcXVlc3QiTAoTUXVlcnlQYXJhbXNSZXNwb25zZRI1CgZwYXJhbXMYASABKAsyGi5pbml0aWEuaWJjaG9va3MudjEuUGFyYW1zQgnI3h8AqOewKgEy+wIKBVF1ZXJ5EnwKA0FDTBIjLmluaXRpYS5pYmNob29rcy52MS5RdWVyeUFDTFJlcXVlc3QaJC5pbml0aWEuaWJjaG9va3MudjEuUXVlcnlBQ0xSZXNwb25zZSIqgtPkkwIkEiIvaW5pdGlhL2liY2hvb2tzL3YxL2FjbHMve2FkZHJlc3N9EnUKBEFDTHMSJC5pbml0aWEuaWJjaG9va3MudjEuUXVlcnlBQ0xzUmVxdWVzdBolLmluaXRpYS5pYmNob29rcy52MS5RdWVyeUFDTHNSZXNwb25zZSIggtPkkwIaEhgvaW5pdGlhL2liY2hvb2tzL3YxL2FjbHMSfQoGUGFyYW1zEiYuaW5pdGlhLmliY2hvb2tzLnYxLlF1ZXJ5UGFyYW1zUmVxdWVzdBonLmluaXRpYS5pYmNob29rcy52MS5RdWVyeVBhcmFtc1Jlc3BvbnNlIiKC0+STAhwSGi9pbml0aWEvaWJjaG9va3MvdjEvcGFyYW1zQjlaL2dpdGh1Yi5jb20vaW5pdGlhLWxhYnMvaW5pdGlhL3gvaWJjLWhvb2tzL3R5cGVzyOEeAKjiHgBiBnByb3RvMw", [
+	file_amino_amino$1,
+	file_cosmos_base_query_v1beta1_pagination$1,
+	file_gogoproto_gogo$3,
+	file_google_api_annotations$2,
+	file_initia_ibchooks_v1_types
+]), 0);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/node_modules/@buf/cosmos_gogo-proto.bufbuild_es/gogoproto/gogo_pb.js
+/**
+* Describes the file gogoproto/gogo.proto.
+*/
+const file_gogoproto_gogo$1 = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_descriptor]);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/node_modules/@buf/cosmos_gogo-proto.bufbuild_es/gogoproto/gogo_pb.js
+/**
+* Describes the file gogoproto/gogo.proto.
+*/
+const file_gogoproto_gogo = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_descriptor]);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/amino/amino_pb.js
+/**
+* Describes the file amino/amino.proto.
+*/
+const file_amino_amino = /* @__PURE__ */ fileDesc("ChFhbWluby9hbWluby5wcm90bxIFYW1pbm86NgoEbmFtZRIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjxjKYFIAEoCVIEbmFtZTpNChBtZXNzYWdlX2VuY29kaW5nEh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGPKMpgUgASgJUg9tZXNzYWdlRW5jb2Rpbmc6PAoIZW5jb2RpbmcSHS5nb29nbGUucHJvdG9idWYuRmllbGRPcHRpb25zGPOMpgUgASgJUghlbmNvZGluZzo/CgpmaWVsZF9uYW1lEh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxj0jKYFIAEoCVIJZmllbGROYW1lOkcKDmRvbnRfb21pdGVtcHR5Eh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxj1jKYFIAEoCFINZG9udE9taXRlbXB0eTo/CgpvbmVvZl9uYW1lEh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxj2jKYFIAEoCVIJb25lb2ZOYW1lQi1aK2dpdGh1Yi5jb20vY29zbW9zL2Nvc21vcy1zZGsvdHlwZXMvdHgvYW1pbm9iBnByb3RvMw", [file_google_protobuf_descriptor]);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/cosmos/base/v1beta1/coin_pb.js
+/**
+* Describes the file cosmos/base/v1beta1/coin.proto.
+*/
+const file_cosmos_base_v1beta1_coin = /* @__PURE__ */ fileDesc("Ch5jb3Ntb3MvYmFzZS92MWJldGExL2NvaW4ucHJvdG8SE2Nvc21vcy5iYXNlLnYxYmV0YTEiXQoEQ29pbhINCgVkZW5vbRgBIAEoCRJACgZhbW91bnQYAiABKAlCMMjeHwDa3h8VY29zbW9zc2RrLmlvL21hdGguSW500rQtCmNvc21vcy5JbnSo57AqAToE6KAfASJhCgdEZWNDb2luEg0KBWRlbm9tGAEgASgJEkEKBmFtb3VudBgCIAEoCUIxyN4fANreHxtjb3Ntb3NzZGsuaW8vbWF0aC5MZWdhY3lEZWPStC0KY29zbW9zLkRlYzoE6KAfAUIsWiJnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3R5cGVz2OEeAIDiHgBiBnByb3RvMw", [
+	file_gogoproto_gogo,
+	file_cosmos_proto_cosmos,
+	file_amino_amino
+]);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/cosmos/base/query/v1beta1/pagination_pb.js
+/**
+* Describes the file cosmos/base/query/v1beta1/pagination.proto.
+*/
+const file_cosmos_base_query_v1beta1_pagination = /* @__PURE__ */ fileDesc("Cipjb3Ntb3MvYmFzZS9xdWVyeS92MWJldGExL3BhZ2luYXRpb24ucHJvdG8SGWNvc21vcy5iYXNlLnF1ZXJ5LnYxYmV0YTEiXwoLUGFnZVJlcXVlc3QSCwoDa2V5GAEgASgMEg4KBm9mZnNldBgCIAEoBBINCgVsaW1pdBgDIAEoBBITCgtjb3VudF90b3RhbBgEIAEoCBIPCgdyZXZlcnNlGAUgASgIIi8KDFBhZ2VSZXNwb25zZRIQCghuZXh0X2tleRgBIAEoDBINCgV0b3RhbBgCIAEoBEIqWihnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3R5cGVzL3F1ZXJ5YgZwcm90bzM");
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/ibc/applications/transfer/v1/transfer_pb.js
+/**
+* Describes the file ibc/applications/transfer/v1/transfer.proto.
+*/
+const file_ibc_applications_transfer_v1_transfer = /* @__PURE__ */ fileDesc("CitpYmMvYXBwbGljYXRpb25zL3RyYW5zZmVyL3YxL3RyYW5zZmVyLnByb3RvEhxpYmMuYXBwbGljYXRpb25zLnRyYW5zZmVyLnYxIi4KCkRlbm9tVHJhY2USDAoEcGF0aBgBIAEoCRISCgpiYXNlX2Rlbm9tGAIgASgJIjcKBlBhcmFtcxIUCgxzZW5kX2VuYWJsZWQYASABKAgSFwoPcmVjZWl2ZV9lbmFibGVkGAIgASgIQjlaN2dpdGh1Yi5jb20vY29zbW9zL2liYy1nby92OC9tb2R1bGVzL2FwcHMvdHJhbnNmZXIvdHlwZXNiBnByb3RvMw");
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/node_modules/@buf/googleapis_googleapis.bufbuild_es/google/api/annotations_pb.js
+/**
+* Describes the file google/api/annotations.proto.
+*/
+const file_google_api_annotations = /* @__PURE__ */ fileDesc("Chxnb29nbGUvYXBpL2Fubm90YXRpb25zLnByb3RvEgpnb29nbGUuYXBpOksKBGh0dHASHi5nb29nbGUucHJvdG9idWYuTWV0aG9kT3B0aW9ucxiwyrwiIAEoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGVSBGh0dHBCbgoOY29tLmdvb2dsZS5hcGlCEEFubm90YXRpb25zUHJvdG9QAVpBZ29vZ2xlLmdvbGFuZy5vcmcvZ2VucHJvdG8vZ29vZ2xlYXBpcy9hcGkvYW5ub3RhdGlvbnM7YW5ub3RhdGlvbnOiAgRHQVBJYgZwcm90bzM", [/* @__PURE__ */ fileDesc("ChVnb29nbGUvYXBpL2h0dHAucHJvdG8SCmdvb2dsZS5hcGkiVAoESHR0cBIjCgVydWxlcxgBIAMoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGUSJwofZnVsbHlfZGVjb2RlX3Jlc2VydmVkX2V4cGFuc2lvbhgCIAEoCCKBAgoISHR0cFJ1bGUSEAoIc2VsZWN0b3IYASABKAkSDQoDZ2V0GAIgASgJSAASDQoDcHV0GAMgASgJSAASDgoEcG9zdBgEIAEoCUgAEhAKBmRlbGV0ZRgFIAEoCUgAEg8KBXBhdGNoGAYgASgJSAASLwoGY3VzdG9tGAggASgLMh0uZ29vZ2xlLmFwaS5DdXN0b21IdHRwUGF0dGVybkgAEgwKBGJvZHkYByABKAkSFQoNcmVzcG9uc2VfYm9keRgMIAEoCRIxChNhZGRpdGlvbmFsX2JpbmRpbmdzGAsgAygLMhQuZ29vZ2xlLmFwaS5IdHRwUnVsZUIJCgdwYXR0ZXJuIi8KEUN1c3RvbUh0dHBQYXR0ZXJuEgwKBGtpbmQYASABKAkSDAoEcGF0aBgCIAEoCUJqCg5jb20uZ29vZ2xlLmFwaUIJSHR0cFByb3RvUAFaQWdvb2dsZS5nb2xhbmcub3JnL2dlbnByb3RvL2dvb2dsZWFwaXMvYXBpL2Fubm90YXRpb25zO2Fubm90YXRpb25z+AEBogIER0FQSWIGcHJvdG8z"), file_google_protobuf_descriptor]);
+/**
+* Query provides defines the gRPC querier service.
+*
+* @generated from service ibc.applications.transfer.v1.Query
+*/
+const Query$5 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [
+	file_gogoproto_gogo$1,
+	file_cosmos_base_v1beta1_coin,
+	file_cosmos_base_query_v1beta1_pagination,
+	file_ibc_applications_transfer_v1_transfer,
+	file_google_api_annotations
+]), 0);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/cosmos/upgrade/v1beta1/upgrade_pb.js
+/**
+* Describes the file cosmos/upgrade/v1beta1/upgrade.proto.
+*/
+const file_cosmos_upgrade_v1beta1_upgrade = /* @__PURE__ */ fileDesc("CiRjb3Ntb3MvdXBncmFkZS92MWJldGExL3VwZ3JhZGUucHJvdG8SFmNvc21vcy51cGdyYWRlLnYxYmV0YTEiwAEKBFBsYW4SDAoEbmFtZRgBIAEoCRI5CgR0aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEIPGAHI3h8AkN8fAajnsCoBEg4KBmhlaWdodBgDIAEoAxIMCgRpbmZvGAQgASgJEjcKFXVwZ3JhZGVkX2NsaWVudF9zdGF0ZRgFIAEoCzIULmdvb2dsZS5wcm90b2J1Zi5BbnlCAhgBOhjooB8BiuewKg9jb3Ntb3Mtc2RrL1BsYW4iwQEKF1NvZnR3YXJlVXBncmFkZVByb3Bvc2FsEg0KBXRpdGxlGAEgASgJEhMKC2Rlc2NyaXB0aW9uGAIgASgJEjUKBHBsYW4YAyABKAsyHC5jb3Ntb3MudXBncmFkZS52MWJldGExLlBsYW5CCcjeHwCo57AqATpLGAHooB8ByrQtGmNvc21vcy5nb3YudjFiZXRhMS5Db250ZW50iuewKiJjb3Ntb3Mtc2RrL1NvZnR3YXJlVXBncmFkZVByb3Bvc2FsIpYBCh1DYW5jZWxTb2Z0d2FyZVVwZ3JhZGVQcm9wb3NhbBINCgV0aXRsZRgBIAEoCRITCgtkZXNjcmlwdGlvbhgCIAEoCTpRGAHooB8ByrQtGmNvc21vcy5nb3YudjFiZXRhMS5Db250ZW50iuewKihjb3Ntb3Mtc2RrL0NhbmNlbFNvZnR3YXJlVXBncmFkZVByb3Bvc2FsIjQKDU1vZHVsZVZlcnNpb24SDAoEbmFtZRgBIAEoCRIPCgd2ZXJzaW9uGAIgASgEOgTooB8BQiJaHGNvc21vc3Nkay5pby94L3VwZ3JhZGUvdHlwZXPI4R4AYgZwcm90bzM", [
+	file_google_protobuf_any,
+	file_gogoproto_gogo,
+	file_google_protobuf_timestamp,
+	file_cosmos_proto_cosmos,
+	file_amino_amino
+]);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/ibc/core/client/v1/client_pb.js
+/**
+* Describes the file ibc/core/client/v1/client.proto.
+*/
+const file_ibc_core_client_v1_client = /* @__PURE__ */ fileDesc("Ch9pYmMvY29yZS9jbGllbnQvdjEvY2xpZW50LnByb3RvEhJpYmMuY29yZS5jbGllbnQudjEiVgoVSWRlbnRpZmllZENsaWVudFN0YXRlEhEKCWNsaWVudF9pZBgBIAEoCRIqCgxjbGllbnRfc3RhdGUYAiABKAsyFC5nb29nbGUucHJvdG9idWYuQW55InsKGENvbnNlbnN1c1N0YXRlV2l0aEhlaWdodBIwCgZoZWlnaHQYASABKAsyGi5pYmMuY29yZS5jbGllbnQudjEuSGVpZ2h0QgTI3h8AEi0KD2NvbnNlbnN1c19zdGF0ZRgCIAEoCzIULmdvb2dsZS5wcm90b2J1Zi5BbnkieAoVQ2xpZW50Q29uc2Vuc3VzU3RhdGVzEhEKCWNsaWVudF9pZBgBIAEoCRJMChBjb25zZW5zdXNfc3RhdGVzGAIgAygLMiwuaWJjLmNvcmUuY2xpZW50LnYxLkNvbnNlbnN1c1N0YXRlV2l0aEhlaWdodEIEyN4fACJECgZIZWlnaHQSFwoPcmV2aXNpb25fbnVtYmVyGAEgASgEEhcKD3JldmlzaW9uX2hlaWdodBgCIAEoBDoIiKAfAJigHwAiIQoGUGFyYW1zEhcKD2FsbG93ZWRfY2xpZW50cxgBIAMoCSLYAQoUQ2xpZW50VXBkYXRlUHJvcG9zYWwSDQoFdGl0bGUYASABKAkSEwoLZGVzY3JpcHRpb24YAiABKAkSNwoRc3ViamVjdF9jbGllbnRfaWQYAyABKAlCHPLeHxh5YW1sOiJzdWJqZWN0X2NsaWVudF9pZCISPQoUc3Vic3RpdHV0ZV9jbGllbnRfaWQYBCABKAlCH/LeHxt5YW1sOiJzdWJzdGl0dXRlX2NsaWVudF9pZCI6JBgBiKAfAMq0LRpjb3Ntb3MuZ292LnYxYmV0YTEuQ29udGVudCLsAQoPVXBncmFkZVByb3Bvc2FsEg0KBXRpdGxlGAEgASgJEhMKC2Rlc2NyaXB0aW9uGAIgASgJEjAKBHBsYW4YAyABKAsyHC5jb3Ntb3MudXBncmFkZS52MWJldGExLlBsYW5CBMjeHwASVQoVdXBncmFkZWRfY2xpZW50X3N0YXRlGAQgASgLMhQuZ29vZ2xlLnByb3RvYnVmLkFueUIg8t4fHHlhbWw6InVwZ3JhZGVkX2NsaWVudF9zdGF0ZSI6LBgBiKAfAJigHwDooB8ByrQtGmNvc21vcy5nb3YudjFiZXRhMS5Db250ZW50QjpaOGdpdGh1Yi5jb20vY29zbW9zL2liYy1nby92OC9tb2R1bGVzL2NvcmUvMDItY2xpZW50L3R5cGVzYgZwcm90bzM", [
+	file_cosmos_upgrade_v1beta1_upgrade,
+	file_cosmos_proto_cosmos,
+	file_gogoproto_gogo$1,
+	file_google_protobuf_any
+]);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/ibc/core/channel/v1/channel_pb.js
+/**
+* Describes the file ibc/core/channel/v1/channel.proto.
+*/
+const file_ibc_core_channel_v1_channel = /* @__PURE__ */ fileDesc("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", [file_gogoproto_gogo$1, file_ibc_core_client_v1_client]);
+/**
+* Query provides defines the gRPC querier service
+*
+* @generated from service ibc.core.channel.v1.Query
+*/
+const Query$4 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [
+	file_ibc_core_client_v1_client,
+	file_cosmos_base_query_v1beta1_pagination,
+	file_ibc_core_channel_v1_channel,
+	file_google_api_annotations,
+	file_google_protobuf_any,
+	file_gogoproto_gogo$1
+]), 0);
+/**
+* Query provides defines the gRPC querier service
+*
+* @generated from service ibc.core.client.v1.Query
+*/
+const Query$3 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [
+	file_cosmos_base_query_v1beta1_pagination,
+	file_ibc_core_client_v1_client,
+	file_google_protobuf_any,
+	file_google_api_annotations,
+	file_gogoproto_gogo$1
+]), 0);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/ibc/core/connection/v1/connection_pb.js
+/**
+* Describes the file ibc/core/connection/v1/connection.proto.
+*/
+const file_ibc_core_connection_v1_connection = /* @__PURE__ */ fileDesc("CidpYmMvY29yZS9jb25uZWN0aW9uL3YxL2Nvbm5lY3Rpb24ucHJvdG8SFmliYy5jb3JlLmNvbm5lY3Rpb24udjEi4QEKDUNvbm5lY3Rpb25FbmQSEQoJY2xpZW50X2lkGAEgASgJEjEKCHZlcnNpb25zGAIgAygLMh8uaWJjLmNvcmUuY29ubmVjdGlvbi52MS5WZXJzaW9uEiwKBXN0YXRlGAMgASgOMh0uaWJjLmNvcmUuY29ubmVjdGlvbi52MS5TdGF0ZRJACgxjb3VudGVycGFydHkYBCABKAsyJC5pYmMuY29yZS5jb25uZWN0aW9uLnYxLkNvdW50ZXJwYXJ0eUIEyN4fABIUCgxkZWxheV9wZXJpb2QYBSABKAQ6BIigHwAi9AEKFElkZW50aWZpZWRDb25uZWN0aW9uEgoKAmlkGAEgASgJEhEKCWNsaWVudF9pZBgCIAEoCRIxCgh2ZXJzaW9ucxgDIAMoCzIfLmliYy5jb3JlLmNvbm5lY3Rpb24udjEuVmVyc2lvbhIsCgVzdGF0ZRgEIAEoDjIdLmliYy5jb3JlLmNvbm5lY3Rpb24udjEuU3RhdGUSQAoMY291bnRlcnBhcnR5GAUgASgLMiQuaWJjLmNvcmUuY29ubmVjdGlvbi52MS5Db3VudGVycGFydHlCBMjeHwASFAoMZGVsYXlfcGVyaW9kGAYgASgEOgSIoB8AInoKDENvdW50ZXJwYXJ0eRIRCgljbGllbnRfaWQYASABKAkSFQoNY29ubmVjdGlvbl9pZBgCIAEoCRI6CgZwcmVmaXgYAyABKAsyJC5pYmMuY29yZS5jb21taXRtZW50LnYxLk1lcmtsZVByZWZpeEIEyN4fADoEiKAfACIcCgtDbGllbnRQYXRocxINCgVwYXRocxgBIAMoCSIzCg9Db25uZWN0aW9uUGF0aHMSEQoJY2xpZW50X2lkGAEgASgJEg0KBXBhdGhzGAIgAygJIjUKB1ZlcnNpb24SEgoKaWRlbnRpZmllchgBIAEoCRIQCghmZWF0dXJlcxgCIAMoCToEiKAfACItCgZQYXJhbXMSIwobbWF4X2V4cGVjdGVkX3RpbWVfcGVyX2Jsb2NrGAEgASgEKpkBCgVTdGF0ZRI2Ch9TVEFURV9VTklOSVRJQUxJWkVEX1VOU1BFQ0lGSUVEEAAaEYqdIA1VTklOSVRJQUxJWkVEEhgKClNUQVRFX0lOSVQQARoIip0gBElOSVQSHgoNU1RBVEVfVFJZT1BFThACGguKnSAHVFJZT1BFThIYCgpTVEFURV9PUEVOEAMaCIqdIARPUEVOGgSIox4AQj5aPGdpdGh1Yi5jb20vY29zbW9zL2liYy1nby92OC9tb2R1bGVzL2NvcmUvMDMtY29ubmVjdGlvbi90eXBlc2IGcHJvdG8z", [file_gogoproto_gogo$1, /* @__PURE__ */ fileDesc("CidpYmMvY29yZS9jb21taXRtZW50L3YxL2NvbW1pdG1lbnQucHJvdG8SFmliYy5jb3JlLmNvbW1pdG1lbnQudjEiIAoKTWVya2xlUm9vdBIMCgRoYXNoGAEgASgMOgSIoB8AIiIKDE1lcmtsZVByZWZpeBISCgprZXlfcHJlZml4GAEgASgMIh4KCk1lcmtsZVBhdGgSEAoIa2V5X3BhdGgYASADKAkiPwoLTWVya2xlUHJvb2YSMAoGcHJvb2ZzGAEgAygLMiAuY29zbW9zLmljczIzLnYxLkNvbW1pdG1lbnRQcm9vZkI+WjxnaXRodWIuY29tL2Nvc21vcy9pYmMtZ28vdjgvbW9kdWxlcy9jb3JlLzIzLWNvbW1pdG1lbnQvdHlwZXNiBnByb3RvMw", [file_gogoproto_gogo$1, /* @__PURE__ */ fileDesc("Chxjb3Ntb3MvaWNzMjMvdjEvcHJvb2ZzLnByb3RvEg9jb3Ntb3MuaWNzMjMudjEiewoORXhpc3RlbmNlUHJvb2YSCwoDa2V5GAEgASgMEg0KBXZhbHVlGAIgASgMEiUKBGxlYWYYAyABKAsyFy5jb3Ntb3MuaWNzMjMudjEuTGVhZk9wEiYKBHBhdGgYBCADKAsyGC5jb3Ntb3MuaWNzMjMudjEuSW5uZXJPcCJ/ChFOb25FeGlzdGVuY2VQcm9vZhILCgNrZXkYASABKAwSLQoEbGVmdBgCIAEoCzIfLmNvc21vcy5pY3MyMy52MS5FeGlzdGVuY2VQcm9vZhIuCgVyaWdodBgDIAEoCzIfLmNvc21vcy5pY3MyMy52MS5FeGlzdGVuY2VQcm9vZiLvAQoPQ29tbWl0bWVudFByb29mEjAKBWV4aXN0GAEgASgLMh8uY29zbW9zLmljczIzLnYxLkV4aXN0ZW5jZVByb29mSAASNgoIbm9uZXhpc3QYAiABKAsyIi5jb3Ntb3MuaWNzMjMudjEuTm9uRXhpc3RlbmNlUHJvb2ZIABIsCgViYXRjaBgDIAEoCzIbLmNvc21vcy5pY3MyMy52MS5CYXRjaFByb29mSAASOwoKY29tcHJlc3NlZBgEIAEoCzIlLmNvc21vcy5pY3MyMy52MS5Db21wcmVzc2VkQmF0Y2hQcm9vZkgAQgcKBXByb29mIsgBCgZMZWFmT3ASJQoEaGFzaBgBIAEoDjIXLmNvc21vcy5pY3MyMy52MS5IYXNoT3ASLAoLcHJlaGFzaF9rZXkYAiABKA4yFy5jb3Ntb3MuaWNzMjMudjEuSGFzaE9wEi4KDXByZWhhc2hfdmFsdWUYAyABKA4yFy5jb3Ntb3MuaWNzMjMudjEuSGFzaE9wEikKBmxlbmd0aBgEIAEoDjIZLmNvc21vcy5pY3MyMy52MS5MZW5ndGhPcBIOCgZwcmVmaXgYBSABKAwiUAoHSW5uZXJPcBIlCgRoYXNoGAEgASgOMhcuY29zbW9zLmljczIzLnYxLkhhc2hPcBIOCgZwcmVmaXgYAiABKAwSDgoGc3VmZml4GAMgASgMIo0BCglQcm9vZlNwZWMSKgoJbGVhZl9zcGVjGAEgASgLMhcuY29zbW9zLmljczIzLnYxLkxlYWZPcBIuCgppbm5lcl9zcGVjGAIgASgLMhouY29zbW9zLmljczIzLnYxLklubmVyU3BlYxIRCgltYXhfZGVwdGgYAyABKAUSEQoJbWluX2RlcHRoGAQgASgFIqYBCglJbm5lclNwZWMSEwoLY2hpbGRfb3JkZXIYASADKAUSEgoKY2hpbGRfc2l6ZRgCIAEoBRIZChFtaW5fcHJlZml4X2xlbmd0aBgDIAEoBRIZChFtYXhfcHJlZml4X2xlbmd0aBgEIAEoBRITCgtlbXB0eV9jaGlsZBgFIAEoDBIlCgRoYXNoGAYgASgOMhcuY29zbW9zLmljczIzLnYxLkhhc2hPcCI6CgpCYXRjaFByb29mEiwKB2VudHJpZXMYASADKAsyGy5jb3Ntb3MuaWNzMjMudjEuQmF0Y2hFbnRyeSJ/CgpCYXRjaEVudHJ5EjAKBWV4aXN0GAEgASgLMh8uY29zbW9zLmljczIzLnYxLkV4aXN0ZW5jZVByb29mSAASNgoIbm9uZXhpc3QYAiABKAsyIi5jb3Ntb3MuaWNzMjMudjEuTm9uRXhpc3RlbmNlUHJvb2ZIAEIHCgVwcm9vZiJ/ChRDb21wcmVzc2VkQmF0Y2hQcm9vZhI2CgdlbnRyaWVzGAEgAygLMiUuY29zbW9zLmljczIzLnYxLkNvbXByZXNzZWRCYXRjaEVudHJ5Ei8KDWxvb2t1cF9pbm5lcnMYAiADKAsyGC5jb3Ntb3MuaWNzMjMudjEuSW5uZXJPcCKdAQoUQ29tcHJlc3NlZEJhdGNoRW50cnkSOgoFZXhpc3QYASABKAsyKS5jb3Ntb3MuaWNzMjMudjEuQ29tcHJlc3NlZEV4aXN0ZW5jZVByb29mSAASQAoIbm9uZXhpc3QYAiABKAsyLC5jb3Ntb3MuaWNzMjMudjEuQ29tcHJlc3NlZE5vbkV4aXN0ZW5jZVByb29mSABCBwoFcHJvb2YiawoYQ29tcHJlc3NlZEV4aXN0ZW5jZVByb29mEgsKA2tleRgBIAEoDBINCgV2YWx1ZRgCIAEoDBIlCgRsZWFmGAMgASgLMhcuY29zbW9zLmljczIzLnYxLkxlYWZPcBIMCgRwYXRoGAQgAygFIp0BChtDb21wcmVzc2VkTm9uRXhpc3RlbmNlUHJvb2YSCwoDa2V5GAEgASgMEjcKBGxlZnQYAiABKAsyKS5jb3Ntb3MuaWNzMjMudjEuQ29tcHJlc3NlZEV4aXN0ZW5jZVByb29mEjgKBXJpZ2h0GAMgASgLMikuY29zbW9zLmljczIzLnYxLkNvbXByZXNzZWRFeGlzdGVuY2VQcm9vZiplCgZIYXNoT3ASCwoHTk9fSEFTSBAAEgoKBlNIQTI1NhABEgoKBlNIQTUxMhACEgoKBktFQ0NBSxADEg0KCVJJUEVNRDE2MBAEEgsKB0JJVENPSU4QBRIOCgpTSEE1MTJfMjU2EAYqqwEKCExlbmd0aE9wEg0KCU5PX1BSRUZJWBAAEg0KCVZBUl9QUk9UTxABEgsKB1ZBUl9STFAQAhIPCgtGSVhFRDMyX0JJRxADEhIKDkZJWEVEMzJfTElUVExFEAQSDwoLRklYRUQ2NF9CSUcQBRISCg5GSVhFRDY0X0xJVFRMRRAGEhQKEFJFUVVJUkVfMzJfQllURVMQBxIUChBSRVFVSVJFXzY0X0JZVEVTEAhCIlogZ2l0aHViLmNvbS9jb3Ntb3MvaWNzMjMvZ287aWNzMjNiBnByb3RvMw")])]);
+/**
+* Query provides defines the gRPC querier service
+*
+* @generated from service ibc.core.connection.v1.Query
+*/
+const Query$2 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [
+	file_gogoproto_gogo$1,
+	file_cosmos_base_query_v1beta1_pagination,
+	file_ibc_core_client_v1_client,
+	file_ibc_core_connection_v1_connection,
+	file_google_api_annotations,
+	file_google_protobuf_any
+]), 0);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/ibc/applications/interchain_accounts/controller/v1/controller_pb.js
+/**
+* Describes the file ibc/applications/interchain_accounts/controller/v1/controller.proto.
+*/
+const file_ibc_applications_interchain_accounts_controller_v1_controller = /* @__PURE__ */ fileDesc("CkNpYmMvYXBwbGljYXRpb25zL2ludGVyY2hhaW5fYWNjb3VudHMvY29udHJvbGxlci92MS9jb250cm9sbGVyLnByb3RvEjJpYmMuYXBwbGljYXRpb25zLmludGVyY2hhaW5fYWNjb3VudHMuY29udHJvbGxlci52MSIkCgZQYXJhbXMSGgoSY29udHJvbGxlcl9lbmFibGVkGAEgASgIQlJaUGdpdGh1Yi5jb20vY29zbW9zL2liYy1nby92OC9tb2R1bGVzL2FwcHMvMjctaW50ZXJjaGFpbi1hY2NvdW50cy9jb250cm9sbGVyL3R5cGVzYgZwcm90bzM");
+/**
+* Query provides defines the gRPC querier service.
+*
+* @generated from service ibc.applications.interchain_accounts.controller.v1.Query
+*/
+const Query$1 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Cj5pYmMvYXBwbGljYXRpb25zL2ludGVyY2hhaW5fYWNjb3VudHMvY29udHJvbGxlci92MS9xdWVyeS5wcm90bxIyaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLmNvbnRyb2xsZXIudjEiRQodUXVlcnlJbnRlcmNoYWluQWNjb3VudFJlcXVlc3QSDQoFb3duZXIYASABKAkSFQoNY29ubmVjdGlvbl9pZBgCIAEoCSIxCh5RdWVyeUludGVyY2hhaW5BY2NvdW50UmVzcG9uc2USDwoHYWRkcmVzcxgBIAEoCSIUChJRdWVyeVBhcmFtc1JlcXVlc3QiYQoTUXVlcnlQYXJhbXNSZXNwb25zZRJKCgZwYXJhbXMYASABKAsyOi5pYmMuYXBwbGljYXRpb25zLmludGVyY2hhaW5fYWNjb3VudHMuY29udHJvbGxlci52MS5QYXJhbXMy/AMKBVF1ZXJ5EpoCChFJbnRlcmNoYWluQWNjb3VudBJRLmliYy5hcHBsaWNhdGlvbnMuaW50ZXJjaGFpbl9hY2NvdW50cy5jb250cm9sbGVyLnYxLlF1ZXJ5SW50ZXJjaGFpbkFjY291bnRSZXF1ZXN0GlIuaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLmNvbnRyb2xsZXIudjEuUXVlcnlJbnRlcmNoYWluQWNjb3VudFJlc3BvbnNlIl6C0+STAlgSVi9pYmMvYXBwcy9pbnRlcmNoYWluX2FjY291bnRzL2NvbnRyb2xsZXIvdjEvb3duZXJzL3tvd25lcn0vY29ubmVjdGlvbnMve2Nvbm5lY3Rpb25faWR9EtUBCgZQYXJhbXMSRi5pYmMuYXBwbGljYXRpb25zLmludGVyY2hhaW5fYWNjb3VudHMuY29udHJvbGxlci52MS5RdWVyeVBhcmFtc1JlcXVlc3QaRy5pYmMuYXBwbGljYXRpb25zLmludGVyY2hhaW5fYWNjb3VudHMuY29udHJvbGxlci52MS5RdWVyeVBhcmFtc1Jlc3BvbnNlIjqC0+STAjQSMi9pYmMvYXBwcy9pbnRlcmNoYWluX2FjY291bnRzL2NvbnRyb2xsZXIvdjEvcGFyYW1zQlJaUGdpdGh1Yi5jb20vY29zbW9zL2liYy1nby92OC9tb2R1bGVzL2FwcHMvMjctaW50ZXJjaGFpbi1hY2NvdW50cy9jb250cm9sbGVyL3R5cGVzYgZwcm90bzM", [file_ibc_applications_interchain_accounts_controller_v1_controller, file_google_api_annotations]), 0);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/ibc/applications/interchain_accounts/host/v1/host_pb.js
+/**
+* Describes the file ibc/applications/interchain_accounts/host/v1/host.proto.
+*/
+const file_ibc_applications_interchain_accounts_host_v1_host = /* @__PURE__ */ fileDesc("CjdpYmMvYXBwbGljYXRpb25zL2ludGVyY2hhaW5fYWNjb3VudHMvaG9zdC92MS9ob3N0LnByb3RvEixpYmMuYXBwbGljYXRpb25zLmludGVyY2hhaW5fYWNjb3VudHMuaG9zdC52MSI2CgZQYXJhbXMSFAoMaG9zdF9lbmFibGVkGAEgASgIEhYKDmFsbG93X21lc3NhZ2VzGAIgAygJQkxaSmdpdGh1Yi5jb20vY29zbW9zL2liYy1nby92OC9tb2R1bGVzL2FwcHMvMjctaW50ZXJjaGFpbi1hY2NvdW50cy9ob3N0L3R5cGVzYgZwcm90bzM");
+/**
+* Query provides defines the gRPC querier service.
+*
+* @generated from service ibc.applications.interchain_accounts.host.v1.Query
+*/
+const Query = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("CjhpYmMvYXBwbGljYXRpb25zL2ludGVyY2hhaW5fYWNjb3VudHMvaG9zdC92MS9xdWVyeS5wcm90bxIsaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLmhvc3QudjEiFAoSUXVlcnlQYXJhbXNSZXF1ZXN0IlsKE1F1ZXJ5UGFyYW1zUmVzcG9uc2USRAoGcGFyYW1zGAEgASgLMjQuaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLmhvc3QudjEuUGFyYW1zMs0BCgVRdWVyeRLDAQoGUGFyYW1zEkAuaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLmhvc3QudjEuUXVlcnlQYXJhbXNSZXF1ZXN0GkEuaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLmhvc3QudjEuUXVlcnlQYXJhbXNSZXNwb25zZSI0gtPkkwIuEiwvaWJjL2FwcHMvaW50ZXJjaGFpbl9hY2NvdW50cy9ob3N0L3YxL3BhcmFtc0JMWkpnaXRodWIuY29tL2Nvc21vcy9pYmMtZ28vdjgvbW9kdWxlcy9hcHBzLzI3LWludGVyY2hhaW4tYWNjb3VudHMvaG9zdC90eXBlc2IGcHJvdG8z", [file_google_api_annotations, file_ibc_applications_interchain_accounts_host_v1_host]), 0);
+//#endregion
+//#region node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/cosmos/bank/v1beta1/tx_pb.js
+/**
+* Describes the file cosmos/bank/v1beta1/tx.proto.
+*/
+const file_cosmos_bank_v1beta1_tx = /* @__PURE__ */ fileDesc("Chxjb3Ntb3MvYmFuay92MWJldGExL3R4LnByb3RvEhNjb3Ntb3MuYmFuay52MWJldGExIowCCgdNc2dTZW5kEi4KDGZyb21fYWRkcmVzcxgBIAEoCUIY0rQtFGNvc21vcy5BZGRyZXNzU3RyaW5nEiwKCnRvX2FkZHJlc3MYAiABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxJxCgZhbW91bnQYAyADKAsyGS5jb3Ntb3MuYmFzZS52MWJldGExLkNvaW5CRsjeHwCq3x8oZ2l0aHViLmNvbS9jb3Ntb3MvY29zbW9zLXNkay90eXBlcy5Db2luc5rnsCoMbGVnYWN5X2NvaW5zqOewKgE6MIigHwDooB8AguewKgxmcm9tX2FkZHJlc3OK57AqEmNvc21vcy1zZGsvTXNnU2VuZCIRCg9Nc2dTZW5kUmVzcG9uc2UiqwEKDE1zZ011bHRpU2VuZBI1CgZpbnB1dHMYASADKAsyGi5jb3Ntb3MuYmFuay52MWJldGExLklucHV0QgnI3h8AqOewKgESNwoHb3V0cHV0cxgCIAMoCzIbLmNvc21vcy5iYW5rLnYxYmV0YTEuT3V0cHV0QgnI3h8AqOewKgE6K+igHwCC57AqBmlucHV0c4rnsCoXY29zbW9zLXNkay9Nc2dNdWx0aVNlbmQiFgoUTXNnTXVsdGlTZW5kUmVzcG9uc2UirAEKD01zZ1VwZGF0ZVBhcmFtcxIrCglhdXRob3JpdHkYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxI2CgZwYXJhbXMYAiABKAsyGy5jb3Ntb3MuYmFuay52MWJldGExLlBhcmFtc0IJyN4fAKjnsCoBOjSC57AqCWF1dGhvcml0eYrnsCohY29zbW9zLXNkay94L2JhbmsvTXNnVXBkYXRlUGFyYW1zIhkKF01zZ1VwZGF0ZVBhcmFtc1Jlc3BvbnNlIsIBChFNc2dTZXRTZW5kRW5hYmxlZBIrCglhdXRob3JpdHkYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxI2CgxzZW5kX2VuYWJsZWQYAiADKAsyIC5jb3Ntb3MuYmFuay52MWJldGExLlNlbmRFbmFibGVkEhcKD3VzZV9kZWZhdWx0X2ZvchgDIAMoCTovguewKglhdXRob3JpdHmK57AqHGNvc21vcy1zZGsvTXNnU2V0U2VuZEVuYWJsZWQiGwoZTXNnU2V0U2VuZEVuYWJsZWRSZXNwb25zZTKBAwoDTXNnEkoKBFNlbmQSHC5jb3Ntb3MuYmFuay52MWJldGExLk1zZ1NlbmQaJC5jb3Ntb3MuYmFuay52MWJldGExLk1zZ1NlbmRSZXNwb25zZRJZCglNdWx0aVNlbmQSIS5jb3Ntb3MuYmFuay52MWJldGExLk1zZ011bHRpU2VuZBopLmNvc21vcy5iYW5rLnYxYmV0YTEuTXNnTXVsdGlTZW5kUmVzcG9uc2USYgoMVXBkYXRlUGFyYW1zEiQuY29zbW9zLmJhbmsudjFiZXRhMS5Nc2dVcGRhdGVQYXJhbXMaLC5jb3Ntb3MuYmFuay52MWJldGExLk1zZ1VwZGF0ZVBhcmFtc1Jlc3BvbnNlEmgKDlNldFNlbmRFbmFibGVkEiYuY29zbW9zLmJhbmsudjFiZXRhMS5Nc2dTZXRTZW5kRW5hYmxlZBouLmNvc21vcy5iYW5rLnYxYmV0YTEuTXNnU2V0U2VuZEVuYWJsZWRSZXNwb25zZRoFgOewKgFCK1opZ2l0aHViLmNvbS9jb3Ntb3MvY29zbW9zLXNkay94L2JhbmsvdHlwZXNiBnByb3RvMw", [
+	file_gogoproto_gogo$3,
+	file_cosmos_base_v1beta1_coin$1,
+	file_cosmos_bank_v1beta1_bank,
+	file_cosmos_proto_cosmos,
+	file_cosmos_msg_v1_msg$1,
+	file_amino_amino$1
+]);
+/**
+* Msg defines the bank Msg service.
+*
+* @generated from service cosmos.bank.v1beta1.Msg
+*/
+const Msg$15 = /* @__PURE__ */ serviceDesc(file_cosmos_bank_v1beta1_tx, 0);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/node_modules/@buf/cosmos_cosmos-sdk.bufbuild_es/cosmos/msg/v1/msg_pb.js
+/**
+* Describes the file cosmos/msg/v1/msg.proto.
+*/
+const file_cosmos_msg_v1_msg = /* @__PURE__ */ fileDesc("Chdjb3Ntb3MvbXNnL3YxL21zZy5wcm90bxINY29zbW9zLm1zZy52MTo8CgdzZXJ2aWNlEh8uZ29vZ2xlLnByb3RvYnVmLlNlcnZpY2VPcHRpb25zGPCMpgUgASgIUgdzZXJ2aWNlOjoKBnNpZ25lchIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjwjKYFIAMoCVIGc2lnbmVyQi9aLWdpdGh1Yi5jb20vY29zbW9zL2Nvc21vcy1zZGsvdHlwZXMvbXNnc2VydmljZWIGcHJvdG8z", [file_google_protobuf_descriptor]);
+//#endregion
+//#region node_modules/@buf/cosmos_ibc.bufbuild_es/ibc/applications/transfer/v1/tx_pb.js
+/**
+* Describes the file ibc/applications/transfer/v1/tx.proto.
+*/
+const file_ibc_applications_transfer_v1_tx = /* @__PURE__ */ fileDesc("CiVpYmMvYXBwbGljYXRpb25zL3RyYW5zZmVyL3YxL3R4LnByb3RvEhxpYmMuYXBwbGljYXRpb25zLnRyYW5zZmVyLnYxIqUCCgtNc2dUcmFuc2ZlchITCgtzb3VyY2VfcG9ydBgBIAEoCRIWCg5zb3VyY2VfY2hhbm5lbBgCIAEoCRIzCgV0b2tlbhgDIAEoCzIZLmNvc21vcy5iYXNlLnYxYmV0YTEuQ29pbkIJyN4fAKjnsCoBEg4KBnNlbmRlchgEIAEoCRIQCghyZWNlaXZlchgFIAEoCRI9Cg50aW1lb3V0X2hlaWdodBgGIAEoCzIaLmliYy5jb3JlLmNsaWVudC52MS5IZWlnaHRCCcjeHwCo57AqARIZChF0aW1lb3V0X3RpbWVzdGFtcBgHIAEoBBIMCgRtZW1vGAggASgJOiqIoB8AguewKgZzZW5kZXKK57AqFmNvc21vcy1zZGsvTXNnVHJhbnNmZXIiLQoTTXNnVHJhbnNmZXJSZXNwb25zZRIQCghzZXF1ZW5jZRgBIAEoBDoEiKAfACJuCg9Nc2dVcGRhdGVQYXJhbXMSDgoGc2lnbmVyGAEgASgJEjoKBnBhcmFtcxgCIAEoCzIkLmliYy5hcHBsaWNhdGlvbnMudHJhbnNmZXIudjEuUGFyYW1zQgTI3h8AOg+IoB8AguewKgZzaWduZXIiGQoXTXNnVXBkYXRlUGFyYW1zUmVzcG9uc2Uy7AEKA01zZxJoCghUcmFuc2ZlchIpLmliYy5hcHBsaWNhdGlvbnMudHJhbnNmZXIudjEuTXNnVHJhbnNmZXIaMS5pYmMuYXBwbGljYXRpb25zLnRyYW5zZmVyLnYxLk1zZ1RyYW5zZmVyUmVzcG9uc2USdAoMVXBkYXRlUGFyYW1zEi0uaWJjLmFwcGxpY2F0aW9ucy50cmFuc2Zlci52MS5Nc2dVcGRhdGVQYXJhbXMaNS5pYmMuYXBwbGljYXRpb25zLnRyYW5zZmVyLnYxLk1zZ1VwZGF0ZVBhcmFtc1Jlc3BvbnNlGgWA57AqAUI5WjdnaXRodWIuY29tL2Nvc21vcy9pYmMtZ28vdjgvbW9kdWxlcy9hcHBzL3RyYW5zZmVyL3R5cGVzYgZwcm90bzM", [
+	file_amino_amino,
+	file_gogoproto_gogo$1,
+	file_cosmos_msg_v1_msg,
+	file_cosmos_base_v1beta1_coin,
+	file_ibc_core_client_v1_client,
+	file_ibc_applications_transfer_v1_transfer
+]);
+/**
+* Msg defines the ibc/transfer Msg service.
+*
+* @generated from service ibc.applications.transfer.v1.Msg
+*/
+const Msg$14 = /* @__PURE__ */ serviceDesc(file_ibc_applications_transfer_v1_tx, 0);
+/**
+* Msg defines the ibc/channel Msg service.
+*
+* @generated from service ibc.core.channel.v1.Msg
+*/
+const Msg$13 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [
+	file_gogoproto_gogo$1,
+	file_ibc_core_client_v1_client,
+	file_ibc_core_channel_v1_channel,
+	file_cosmos_msg_v1_msg
+]), 0);
+/**
+* Msg defines the ibc/client Msg service.
+*
+* @generated from service ibc.core.client.v1.Msg
+*/
+const Msg$12 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [
+	file_cosmos_msg_v1_msg,
+	file_cosmos_upgrade_v1beta1_upgrade,
+	file_gogoproto_gogo$1,
+	file_google_protobuf_any,
+	file_ibc_core_client_v1_client
+]), 0);
+/**
+* Msg defines the ibc/connection Msg service.
+*
+* @generated from service ibc.core.connection.v1.Msg
+*/
+const Msg$11 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Ch9pYmMvY29yZS9jb25uZWN0aW9uL3YxL3R4LnByb3RvEhZpYmMuY29yZS5jb25uZWN0aW9uLnYxItUBChVNc2dDb25uZWN0aW9uT3BlbkluaXQSEQoJY2xpZW50X2lkGAEgASgJEkAKDGNvdW50ZXJwYXJ0eRgCIAEoCzIkLmliYy5jb3JlLmNvbm5lY3Rpb24udjEuQ291bnRlcnBhcnR5QgTI3h8AEjAKB3ZlcnNpb24YAyABKAsyHy5pYmMuY29yZS5jb25uZWN0aW9uLnYxLlZlcnNpb24SFAoMZGVsYXlfcGVyaW9kGAQgASgEEg4KBnNpZ25lchgFIAEoCToPiKAfAILnsCoGc2lnbmVyIh8KHU1zZ0Nvbm5lY3Rpb25PcGVuSW5pdFJlc3BvbnNlIo0EChRNc2dDb25uZWN0aW9uT3BlblRyeRIRCgljbGllbnRfaWQYASABKAkSIgoWcHJldmlvdXNfY29ubmVjdGlvbl9pZBgCIAEoCUICGAESKgoMY2xpZW50X3N0YXRlGAMgASgLMhQuZ29vZ2xlLnByb3RvYnVmLkFueRJACgxjb3VudGVycGFydHkYBCABKAsyJC5pYmMuY29yZS5jb25uZWN0aW9uLnYxLkNvdW50ZXJwYXJ0eUIEyN4fABIUCgxkZWxheV9wZXJpb2QYBSABKAQSPgoVY291bnRlcnBhcnR5X3ZlcnNpb25zGAYgAygLMh8uaWJjLmNvcmUuY29ubmVjdGlvbi52MS5WZXJzaW9uEjYKDHByb29mX2hlaWdodBgHIAEoCzIaLmliYy5jb3JlLmNsaWVudC52MS5IZWlnaHRCBMjeHwASEgoKcHJvb2ZfaW5pdBgIIAEoDBIUCgxwcm9vZl9jbGllbnQYCSABKAwSFwoPcHJvb2ZfY29uc2Vuc3VzGAogASgMEjoKEGNvbnNlbnN1c19oZWlnaHQYCyABKAsyGi5pYmMuY29yZS5jbGllbnQudjEuSGVpZ2h0QgTI3h8AEg4KBnNpZ25lchgMIAEoCRIiChpob3N0X2NvbnNlbnN1c19zdGF0ZV9wcm9vZhgNIAEoDDoPiKAfAILnsCoGc2lnbmVyIh4KHE1zZ0Nvbm5lY3Rpb25PcGVuVHJ5UmVzcG9uc2UiqgMKFE1zZ0Nvbm5lY3Rpb25PcGVuQWNrEhUKDWNvbm5lY3Rpb25faWQYASABKAkSIgoaY291bnRlcnBhcnR5X2Nvbm5lY3Rpb25faWQYAiABKAkSMAoHdmVyc2lvbhgDIAEoCzIfLmliYy5jb3JlLmNvbm5lY3Rpb24udjEuVmVyc2lvbhIqCgxjbGllbnRfc3RhdGUYBCABKAsyFC5nb29nbGUucHJvdG9idWYuQW55EjYKDHByb29mX2hlaWdodBgFIAEoCzIaLmliYy5jb3JlLmNsaWVudC52MS5IZWlnaHRCBMjeHwASEQoJcHJvb2ZfdHJ5GAYgASgMEhQKDHByb29mX2NsaWVudBgHIAEoDBIXCg9wcm9vZl9jb25zZW5zdXMYCCABKAwSOgoQY29uc2Vuc3VzX2hlaWdodBgJIAEoCzIaLmliYy5jb3JlLmNsaWVudC52MS5IZWlnaHRCBMjeHwASDgoGc2lnbmVyGAogASgJEiIKGmhvc3RfY29uc2Vuc3VzX3N0YXRlX3Byb29mGAsgASgMOg+IoB8AguewKgZzaWduZXIiHgocTXNnQ29ubmVjdGlvbk9wZW5BY2tSZXNwb25zZSKdAQoYTXNnQ29ubmVjdGlvbk9wZW5Db25maXJtEhUKDWNvbm5lY3Rpb25faWQYASABKAkSEQoJcHJvb2ZfYWNrGAIgASgMEjYKDHByb29mX2hlaWdodBgDIAEoCzIaLmliYy5jb3JlLmNsaWVudC52MS5IZWlnaHRCBMjeHwASDgoGc2lnbmVyGAQgASgJOg+IoB8AguewKgZzaWduZXIiIgogTXNnQ29ubmVjdGlvbk9wZW5Db25maXJtUmVzcG9uc2UiaAoPTXNnVXBkYXRlUGFyYW1zEg4KBnNpZ25lchgBIAEoCRI0CgZwYXJhbXMYAiABKAsyHi5pYmMuY29yZS5jb25uZWN0aW9uLnYxLlBhcmFtc0IEyN4fADoPiKAfAILnsCoGc2lnbmVyIhkKF01zZ1VwZGF0ZVBhcmFtc1Jlc3BvbnNlMvQECgNNc2cSegoSQ29ubmVjdGlvbk9wZW5Jbml0Ei0uaWJjLmNvcmUuY29ubmVjdGlvbi52MS5Nc2dDb25uZWN0aW9uT3BlbkluaXQaNS5pYmMuY29yZS5jb25uZWN0aW9uLnYxLk1zZ0Nvbm5lY3Rpb25PcGVuSW5pdFJlc3BvbnNlEncKEUNvbm5lY3Rpb25PcGVuVHJ5EiwuaWJjLmNvcmUuY29ubmVjdGlvbi52MS5Nc2dDb25uZWN0aW9uT3BlblRyeRo0LmliYy5jb3JlLmNvbm5lY3Rpb24udjEuTXNnQ29ubmVjdGlvbk9wZW5UcnlSZXNwb25zZRJ3ChFDb25uZWN0aW9uT3BlbkFjaxIsLmliYy5jb3JlLmNvbm5lY3Rpb24udjEuTXNnQ29ubmVjdGlvbk9wZW5BY2saNC5pYmMuY29yZS5jb25uZWN0aW9uLnYxLk1zZ0Nvbm5lY3Rpb25PcGVuQWNrUmVzcG9uc2USgwEKFUNvbm5lY3Rpb25PcGVuQ29uZmlybRIwLmliYy5jb3JlLmNvbm5lY3Rpb24udjEuTXNnQ29ubmVjdGlvbk9wZW5Db25maXJtGjguaWJjLmNvcmUuY29ubmVjdGlvbi52MS5Nc2dDb25uZWN0aW9uT3BlbkNvbmZpcm1SZXNwb25zZRJyChZVcGRhdGVDb25uZWN0aW9uUGFyYW1zEicuaWJjLmNvcmUuY29ubmVjdGlvbi52MS5Nc2dVcGRhdGVQYXJhbXMaLy5pYmMuY29yZS5jb25uZWN0aW9uLnYxLk1zZ1VwZGF0ZVBhcmFtc1Jlc3BvbnNlGgWA57AqAUI+WjxnaXRodWIuY29tL2Nvc21vcy9pYmMtZ28vdjgvbW9kdWxlcy9jb3JlLzAzLWNvbm5lY3Rpb24vdHlwZXNiBnByb3RvMw", [
+	file_gogoproto_gogo$1,
+	file_cosmos_msg_v1_msg,
+	file_google_protobuf_any,
+	file_ibc_core_client_v1_client,
+	file_ibc_core_connection_v1_connection
+]), 0);
+/**
+* Msg defines the 27-interchain-accounts/controller Msg service.
+*
+* @generated from service ibc.applications.interchain_accounts.controller.v1.Msg
+*/
+const Msg$10 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("CjtpYmMvYXBwbGljYXRpb25zL2ludGVyY2hhaW5fYWNjb3VudHMvY29udHJvbGxlci92MS90eC5wcm90bxIyaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLmNvbnRyb2xsZXIudjEiZQocTXNnUmVnaXN0ZXJJbnRlcmNoYWluQWNjb3VudBINCgVvd25lchgBIAEoCRIVCg1jb25uZWN0aW9uX2lkGAIgASgJEg8KB3ZlcnNpb24YAyABKAk6DoigHwCC57AqBW93bmVyIlEKJE1zZ1JlZ2lzdGVySW50ZXJjaGFpbkFjY291bnRSZXNwb25zZRISCgpjaGFubmVsX2lkGAEgASgJEg8KB3BvcnRfaWQYAiABKAk6BIigHwAivAEKCU1zZ1NlbmRUeBINCgVvd25lchgBIAEoCRIVCg1jb25uZWN0aW9uX2lkGAIgASgJEl8KC3BhY2tldF9kYXRhGAMgASgLMkQuaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLnYxLkludGVyY2hhaW5BY2NvdW50UGFja2V0RGF0YUIEyN4fABIYChByZWxhdGl2ZV90aW1lb3V0GAQgASgEOg6IoB8AguewKgVvd25lciIrChFNc2dTZW5kVHhSZXNwb25zZRIQCghzZXF1ZW5jZRgBIAEoBDoEiKAfACKEAQoPTXNnVXBkYXRlUGFyYW1zEg4KBnNpZ25lchgBIAEoCRJQCgZwYXJhbXMYAiABKAsyOi5pYmMuYXBwbGljYXRpb25zLmludGVyY2hhaW5fYWNjb3VudHMuY29udHJvbGxlci52MS5QYXJhbXNCBMjeHwA6D4igHwCC57AqBnNpZ25lciIZChdNc2dVcGRhdGVQYXJhbXNSZXNwb25zZTKKBAoDTXNnEscBChlSZWdpc3RlckludGVyY2hhaW5BY2NvdW50ElAuaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLmNvbnRyb2xsZXIudjEuTXNnUmVnaXN0ZXJJbnRlcmNoYWluQWNjb3VudBpYLmliYy5hcHBsaWNhdGlvbnMuaW50ZXJjaGFpbl9hY2NvdW50cy5jb250cm9sbGVyLnYxLk1zZ1JlZ2lzdGVySW50ZXJjaGFpbkFjY291bnRSZXNwb25zZRKOAQoGU2VuZFR4Ej0uaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLmNvbnRyb2xsZXIudjEuTXNnU2VuZFR4GkUuaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLmNvbnRyb2xsZXIudjEuTXNnU2VuZFR4UmVzcG9uc2USoAEKDFVwZGF0ZVBhcmFtcxJDLmliYy5hcHBsaWNhdGlvbnMuaW50ZXJjaGFpbl9hY2NvdW50cy5jb250cm9sbGVyLnYxLk1zZ1VwZGF0ZVBhcmFtcxpLLmliYy5hcHBsaWNhdGlvbnMuaW50ZXJjaGFpbl9hY2NvdW50cy5jb250cm9sbGVyLnYxLk1zZ1VwZGF0ZVBhcmFtc1Jlc3BvbnNlGgWA57AqAUJSWlBnaXRodWIuY29tL2Nvc21vcy9pYmMtZ28vdjgvbW9kdWxlcy9hcHBzLzI3LWludGVyY2hhaW4tYWNjb3VudHMvY29udHJvbGxlci90eXBlc2IGcHJvdG8z", [
+	file_gogoproto_gogo$1,
+	/* @__PURE__ */ fileDesc("CjRpYmMvYXBwbGljYXRpb25zL2ludGVyY2hhaW5fYWNjb3VudHMvdjEvcGFja2V0LnByb3RvEidpYmMuYXBwbGljYXRpb25zLmludGVyY2hhaW5fYWNjb3VudHMudjEidgobSW50ZXJjaGFpbkFjY291bnRQYWNrZXREYXRhEjsKBHR5cGUYASABKA4yLS5pYmMuYXBwbGljYXRpb25zLmludGVyY2hhaW5fYWNjb3VudHMudjEuVHlwZRIMCgRkYXRhGAIgASgMEgwKBG1lbW8YAyABKAkiMgoIQ29zbW9zVHgSJgoIbWVzc2FnZXMYASADKAsyFC5nb29nbGUucHJvdG9idWYuQW55KlgKBFR5cGUSJQoQVFlQRV9VTlNQRUNJRklFRBAAGg+KnSALVU5TUEVDSUZJRUQSIwoPVFlQRV9FWEVDVVRFX1RYEAEaDoqdIApFWEVDVVRFX1RYGgSIox4AQkdaRWdpdGh1Yi5jb20vY29zbW9zL2liYy1nby92OC9tb2R1bGVzL2FwcHMvMjctaW50ZXJjaGFpbi1hY2NvdW50cy90eXBlc2IGcHJvdG8z", [file_google_protobuf_any, file_gogoproto_gogo$1]),
+	file_ibc_applications_interchain_accounts_controller_v1_controller,
+	file_cosmos_msg_v1_msg
+]), 0);
+/**
+* Msg defines the 27-interchain-accounts/host Msg service.
+*
+* @generated from service ibc.applications.interchain_accounts.host.v1.Msg
+*/
+const Msg$9 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("CjVpYmMvYXBwbGljYXRpb25zL2ludGVyY2hhaW5fYWNjb3VudHMvaG9zdC92MS90eC5wcm90bxIsaWJjLmFwcGxpY2F0aW9ucy5pbnRlcmNoYWluX2FjY291bnRzLmhvc3QudjEifgoPTXNnVXBkYXRlUGFyYW1zEg4KBnNpZ25lchgBIAEoCRJKCgZwYXJhbXMYAiABKAsyNC5pYmMuYXBwbGljYXRpb25zLmludGVyY2hhaW5fYWNjb3VudHMuaG9zdC52MS5QYXJhbXNCBMjeHwA6D4igHwCC57AqBnNpZ25lciIZChdNc2dVcGRhdGVQYXJhbXNSZXNwb25zZTKjAQoDTXNnEpQBCgxVcGRhdGVQYXJhbXMSPS5pYmMuYXBwbGljYXRpb25zLmludGVyY2hhaW5fYWNjb3VudHMuaG9zdC52MS5Nc2dVcGRhdGVQYXJhbXMaRS5pYmMuYXBwbGljYXRpb25zLmludGVyY2hhaW5fYWNjb3VudHMuaG9zdC52MS5Nc2dVcGRhdGVQYXJhbXNSZXNwb25zZRoFgOewKgFCTFpKZ2l0aHViLmNvbS9jb3Ntb3MvaWJjLWdvL3Y4L21vZHVsZXMvYXBwcy8yNy1pbnRlcmNoYWluLWFjY291bnRzL2hvc3QvdHlwZXNiBnByb3RvMw", [
+	file_gogoproto_gogo$1,
+	file_cosmos_msg_v1_msg,
+	file_ibc_applications_interchain_accounts_host_v1_host
+]), 0);
+/**
+* Msg defines the authz Msg service.
+*
+* @generated from service cosmos.authz.v1beta1.Msg
+*/
+const Msg$8 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Ch1jb3Ntb3MvYXV0aHovdjFiZXRhMS90eC5wcm90bxIUY29zbW9zLmF1dGh6LnYxYmV0YTEivQEKCE1zZ0dyYW50EikKB2dyYW50ZXIYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxIpCgdncmFudGVlGAIgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSNQoFZ3JhbnQYAyABKAsyGy5jb3Ntb3MuYXV0aHoudjFiZXRhMS5HcmFudEIJyN4fAKjnsCoBOiSC57AqB2dyYW50ZXKK57AqE2Nvc21vcy1zZGsvTXNnR3JhbnQiEgoQTXNnR3JhbnRSZXNwb25zZSKaAQoHTXNnRXhlYxIpCgdncmFudGVlGAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSPwoEbXNncxgCIAMoCzIULmdvb2dsZS5wcm90b2J1Zi5BbnlCG8q0LRdjb3Ntb3MuYmFzZS52MWJldGExLk1zZzojguewKgdncmFudGVliuewKhJjb3Ntb3Mtc2RrL01zZ0V4ZWMiIgoPTXNnRXhlY1Jlc3BvbnNlEg8KB3Jlc3VsdHMYASADKAwingEKCU1zZ1Jldm9rZRIpCgdncmFudGVyGAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSKQoHZ3JhbnRlZRgCIAEoCUIY0rQtFGNvc21vcy5BZGRyZXNzU3RyaW5nEhQKDG1zZ190eXBlX3VybBgDIAEoCTolguewKgdncmFudGVyiuewKhRjb3Ntb3Mtc2RrL01zZ1Jldm9rZSITChFNc2dSZXZva2VSZXNwb25zZTL/AQoDTXNnEk8KBUdyYW50Eh4uY29zbW9zLmF1dGh6LnYxYmV0YTEuTXNnR3JhbnQaJi5jb3Ntb3MuYXV0aHoudjFiZXRhMS5Nc2dHcmFudFJlc3BvbnNlEkwKBEV4ZWMSHS5jb3Ntb3MuYXV0aHoudjFiZXRhMS5Nc2dFeGVjGiUuY29zbW9zLmF1dGh6LnYxYmV0YTEuTXNnRXhlY1Jlc3BvbnNlElIKBlJldm9rZRIfLmNvc21vcy5hdXRoei52MWJldGExLk1zZ1Jldm9rZRonLmNvc21vcy5hdXRoei52MWJldGExLk1zZ1Jldm9rZVJlc3BvbnNlGgWA57AqAUIqWiRnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3gvYXV0aHrI4R4AYgZwcm90bzM", [
+	file_cosmos_proto_cosmos,
+	file_gogoproto_gogo$3,
+	file_google_protobuf_any,
+	file_cosmos_authz_v1beta1_authz,
+	file_cosmos_msg_v1_msg$1,
+	file_amino_amino$1
+]), 0);
+/**
+* Msg defines the feegrant msg service.
+*
+* @generated from service cosmos.feegrant.v1beta1.Msg
+*/
+const Msg$7 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("CiBjb3Ntb3MvZmVlZ3JhbnQvdjFiZXRhMS90eC5wcm90bxIXY29zbW9zLmZlZWdyYW50LnYxYmV0YTEi7AEKEU1zZ0dyYW50QWxsb3dhbmNlEikKB2dyYW50ZXIYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxIpCgdncmFudGVlGAIgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSUgoJYWxsb3dhbmNlGAMgASgLMhQuZ29vZ2xlLnByb3RvYnVmLkFueUIpyrQtJWNvc21vcy5mZWVncmFudC52MWJldGExLkZlZUFsbG93YW5jZUk6LYLnsCoHZ3JhbnRlcornsCocY29zbW9zLXNkay9Nc2dHcmFudEFsbG93YW5jZSIbChlNc2dHcmFudEFsbG93YW5jZVJlc3BvbnNlIpoBChJNc2dSZXZva2VBbGxvd2FuY2USKQoHZ3JhbnRlchgBIAEoCUIY0rQtFGNvc21vcy5BZGRyZXNzU3RyaW5nEikKB2dyYW50ZWUYAiABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZzouguewKgdncmFudGVyiuewKh1jb3Ntb3Mtc2RrL01zZ1Jldm9rZUFsbG93YW5jZSIcChpNc2dSZXZva2VBbGxvd2FuY2VSZXNwb25zZSJLChJNc2dQcnVuZUFsbG93YW5jZXMSKAoGcHJ1bmVyGAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmc6C4LnsCoGcHJ1bmVyIhwKGk1zZ1BydW5lQWxsb3dhbmNlc1Jlc3BvbnNlMugCCgNNc2cScAoOR3JhbnRBbGxvd2FuY2USKi5jb3Ntb3MuZmVlZ3JhbnQudjFiZXRhMS5Nc2dHcmFudEFsbG93YW5jZRoyLmNvc21vcy5mZWVncmFudC52MWJldGExLk1zZ0dyYW50QWxsb3dhbmNlUmVzcG9uc2UScwoPUmV2b2tlQWxsb3dhbmNlEisuY29zbW9zLmZlZWdyYW50LnYxYmV0YTEuTXNnUmV2b2tlQWxsb3dhbmNlGjMuY29zbW9zLmZlZWdyYW50LnYxYmV0YTEuTXNnUmV2b2tlQWxsb3dhbmNlUmVzcG9uc2UScwoPUHJ1bmVBbGxvd2FuY2VzEisuY29zbW9zLmZlZWdyYW50LnYxYmV0YTEuTXNnUHJ1bmVBbGxvd2FuY2VzGjMuY29zbW9zLmZlZWdyYW50LnYxYmV0YTEuTXNnUHJ1bmVBbGxvd2FuY2VzUmVzcG9uc2UaBYDnsCoBQhlaF2Nvc21vc3Nkay5pby94L2ZlZWdyYW50YgZwcm90bzM", [
+	file_google_protobuf_any,
+	file_cosmos_proto_cosmos,
+	file_cosmos_msg_v1_msg$1,
+	file_amino_amino$1
+]), 0);
+/**
+* Msg is the cosmos.group.v1 Msg service.
+*
+* @generated from service cosmos.group.v1.Msg
+*/
+const Msg$6 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("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", [
+	file_gogoproto_gogo$3,
+	file_cosmos_proto_cosmos,
+	file_google_protobuf_any,
+	file_cosmos_group_v1_types,
+	file_cosmos_msg_v1_msg$1,
+	file_amino_amino$1
+]), 0);
+/**
+* Msg defines the bank Msg service.
+*
+* @generated from service cosmos.crisis.v1beta1.Msg
+*/
+const Msg$5 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Ch5jb3Ntb3MvY3Jpc2lzL3YxYmV0YTEvdHgucHJvdG8SFWNvc21vcy5jcmlzaXMudjFiZXRhMSKtAQoSTXNnVmVyaWZ5SW52YXJpYW50EigKBnNlbmRlchgBIAEoCUIY0rQtFGNvc21vcy5BZGRyZXNzU3RyaW5nEh0KFWludmFyaWFudF9tb2R1bGVfbmFtZRgCIAEoCRIXCg9pbnZhcmlhbnRfcm91dGUYAyABKAk6NYigHwDooB8AguewKgZzZW5kZXKK57AqHWNvc21vcy1zZGsvTXNnVmVyaWZ5SW52YXJpYW50IhwKGk1zZ1ZlcmlmeUludmFyaWFudFJlc3BvbnNlIrIBCg9Nc2dVcGRhdGVQYXJhbXMSKwoJYXV0aG9yaXR5GAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSOgoMY29uc3RhbnRfZmVlGAIgASgLMhkuY29zbW9zLmJhc2UudjFiZXRhMS5Db2luQgnI3h8AqOewKgE6NoLnsCoJYXV0aG9yaXR5iuewKiNjb3Ntb3Mtc2RrL3gvY3Jpc2lzL01zZ1VwZGF0ZVBhcmFtcyIZChdNc2dVcGRhdGVQYXJhbXNSZXNwb25zZTLlAQoDTXNnEm8KD1ZlcmlmeUludmFyaWFudBIpLmNvc21vcy5jcmlzaXMudjFiZXRhMS5Nc2dWZXJpZnlJbnZhcmlhbnQaMS5jb3Ntb3MuY3Jpc2lzLnYxYmV0YTEuTXNnVmVyaWZ5SW52YXJpYW50UmVzcG9uc2USZgoMVXBkYXRlUGFyYW1zEiYuY29zbW9zLmNyaXNpcy52MWJldGExLk1zZ1VwZGF0ZVBhcmFtcxouLmNvc21vcy5jcmlzaXMudjFiZXRhMS5Nc2dVcGRhdGVQYXJhbXNSZXNwb25zZRoFgOewKgFCLVorZ2l0aHViLmNvbS9jb3Ntb3MvY29zbW9zLXNkay94L2NyaXNpcy90eXBlc2IGcHJvdG8z", [
+	file_gogoproto_gogo$3,
+	file_cosmos_proto_cosmos,
+	file_cosmos_msg_v1_msg$1,
+	file_amino_amino$1,
+	file_cosmos_base_v1beta1_coin$1
+]), 0);
+/**
+* Msg defines the upgrade Msg service.
+*
+* @generated from service cosmos.upgrade.v1beta1.Msg
+*/
+const Msg$4 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Ch9jb3Ntb3MvdXBncmFkZS92MWJldGExL3R4LnByb3RvEhZjb3Ntb3MudXBncmFkZS52MWJldGExIqoBChJNc2dTb2Z0d2FyZVVwZ3JhZGUSKwoJYXV0aG9yaXR5GAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSNQoEcGxhbhgCIAEoCzIcLmNvc21vcy51cGdyYWRlLnYxYmV0YTEuUGxhbkIJyN4fAKjnsCoBOjCC57AqCWF1dGhvcml0eYrnsCodY29zbW9zLXNkay9Nc2dTb2Z0d2FyZVVwZ3JhZGUiHAoaTXNnU29mdHdhcmVVcGdyYWRlUmVzcG9uc2UibwoQTXNnQ2FuY2VsVXBncmFkZRIrCglhdXRob3JpdHkYASABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZzouguewKglhdXRob3JpdHmK57AqG2Nvc21vcy1zZGsvTXNnQ2FuY2VsVXBncmFkZSIaChhNc2dDYW5jZWxVcGdyYWRlUmVzcG9uc2Uy7AEKA01zZxJxCg9Tb2Z0d2FyZVVwZ3JhZGUSKi5jb3Ntb3MudXBncmFkZS52MWJldGExLk1zZ1NvZnR3YXJlVXBncmFkZRoyLmNvc21vcy51cGdyYWRlLnYxYmV0YTEuTXNnU29mdHdhcmVVcGdyYWRlUmVzcG9uc2USawoNQ2FuY2VsVXBncmFkZRIoLmNvc21vcy51cGdyYWRlLnYxYmV0YTEuTXNnQ2FuY2VsVXBncmFkZRowLmNvc21vcy51cGdyYWRlLnYxYmV0YTEuTXNnQ2FuY2VsVXBncmFkZVJlc3BvbnNlGgWA57AqAUIeWhxjb3Ntb3NzZGsuaW8veC91cGdyYWRlL3R5cGVzYgZwcm90bzM", [
+	file_gogoproto_gogo$3,
+	file_cosmos_proto_cosmos,
+	file_cosmos_upgrade_v1beta1_upgrade$1,
+	file_cosmos_msg_v1_msg$1,
+	file_amino_amino$1
+]), 0);
+/**
+* Msg defines the consensus Msg service.
+*
+* @generated from service cosmos.consensus.v1.Msg
+*/
+const Msg$3 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Chxjb3Ntb3MvY29uc2Vuc3VzL3YxL3R4LnByb3RvEhNjb3Ntb3MuY29uc2Vuc3VzLnYxIr0CCg9Nc2dVcGRhdGVQYXJhbXMSKwoJYXV0aG9yaXR5GAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSLAoFYmxvY2sYAiABKAsyHS50ZW5kZXJtaW50LnR5cGVzLkJsb2NrUGFyYW1zEjIKCGV2aWRlbmNlGAMgASgLMiAudGVuZGVybWludC50eXBlcy5FdmlkZW5jZVBhcmFtcxI0Cgl2YWxpZGF0b3IYBCABKAsyIS50ZW5kZXJtaW50LnR5cGVzLlZhbGlkYXRvclBhcmFtcxIqCgRhYmNpGAUgASgLMhwudGVuZGVybWludC50eXBlcy5BQkNJUGFyYW1zOjmC57AqCWF1dGhvcml0eYrnsComY29zbW9zLXNkay94L2NvbnNlbnN1cy9Nc2dVcGRhdGVQYXJhbXMiGQoXTXNnVXBkYXRlUGFyYW1zUmVzcG9uc2UycAoDTXNnEmIKDFVwZGF0ZVBhcmFtcxIkLmNvc21vcy5jb25zZW5zdXMudjEuTXNnVXBkYXRlUGFyYW1zGiwuY29zbW9zLmNvbnNlbnN1cy52MS5Nc2dVcGRhdGVQYXJhbXNSZXNwb25zZRoFgOewKgFCMFouZ2l0aHViLmNvbS9jb3Ntb3MvY29zbW9zLXNkay94L2NvbnNlbnN1cy90eXBlc2IGcHJvdG8z", [
+	file_amino_amino$1,
+	file_cosmos_proto_cosmos,
+	file_cosmos_msg_v1_msg$1,
+	file_tendermint_types_params
+]), 0);
+/**
+* Msg defines the x/auth Msg service.
+*
+* @generated from service cosmos.auth.v1beta1.Msg
+*/
+const Msg$2 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Chxjb3Ntb3MvYXV0aC92MWJldGExL3R4LnByb3RvEhNjb3Ntb3MuYXV0aC52MWJldGExIqwBCg9Nc2dVcGRhdGVQYXJhbXMSKwoJYXV0aG9yaXR5GAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSNgoGcGFyYW1zGAIgASgLMhsuY29zbW9zLmF1dGgudjFiZXRhMS5QYXJhbXNCCcjeHwCo57AqATo0guewKglhdXRob3JpdHmK57AqIWNvc21vcy1zZGsveC9hdXRoL01zZ1VwZGF0ZVBhcmFtcyIZChdNc2dVcGRhdGVQYXJhbXNSZXNwb25zZTJwCgNNc2cSYgoMVXBkYXRlUGFyYW1zEiQuY29zbW9zLmF1dGgudjFiZXRhMS5Nc2dVcGRhdGVQYXJhbXMaLC5jb3Ntb3MuYXV0aC52MWJldGExLk1zZ1VwZGF0ZVBhcmFtc1Jlc3BvbnNlGgWA57AqAUIrWilnaXRodWIuY29tL2Nvc21vcy9jb3Ntb3Mtc2RrL3gvYXV0aC90eXBlc2IGcHJvdG8z", [
+	file_gogoproto_gogo$3,
+	file_cosmos_proto_cosmos,
+	file_cosmos_msg_v1_msg$1,
+	file_amino_amino$1,
+	file_cosmos_auth_v1beta1_auth
+]), 0);
+/**
+* Msg defines the hook Msg service.
+*
+* @generated from service initia.ibchooks.v1.Msg
+*/
+const Msg$1 = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Chtpbml0aWEvaWJjaG9va3MvdjEvdHgucHJvdG8SEmluaXRpYS5pYmNob29rcy52MSKhAQoMTXNnVXBkYXRlQUNMEisKCWF1dGhvcml0eRgBIAEoCUIY0rQtFGNvc21vcy5BZGRyZXNzU3RyaW5nEikKB2FkZHJlc3MYAiABKAlCGNK0LRRjb3Ntb3MuQWRkcmVzc1N0cmluZxIPCgdhbGxvd2VkGAMgASgIOiiC57AqCWF1dGhvcml0eYrnsCoVaWJjaG9va3MvTXNnVXBkYXRlQUNMIhYKFE1zZ1VwZGF0ZUFDTFJlc3BvbnNlIqIBCg9Nc2dVcGRhdGVQYXJhbXMSKwoJYXV0aG9yaXR5GAEgASgJQhjStC0UY29zbW9zLkFkZHJlc3NTdHJpbmcSNQoGcGFyYW1zGAIgASgLMhouaW5pdGlhLmliY2hvb2tzLnYxLlBhcmFtc0IJyN4fAKjnsCoBOiuC57AqCWF1dGhvcml0eYrnsCoYaWJjaG9va3MvTXNnVXBkYXRlUGFyYW1zIhkKF01zZ1VwZGF0ZVBhcmFtc1Jlc3BvbnNlMscBCgNNc2cSVwoJVXBkYXRlQUNMEiAuaW5pdGlhLmliY2hvb2tzLnYxLk1zZ1VwZGF0ZUFDTBooLmluaXRpYS5pYmNob29rcy52MS5Nc2dVcGRhdGVBQ0xSZXNwb25zZRJgCgxVcGRhdGVQYXJhbXMSIy5pbml0aWEuaWJjaG9va3MudjEuTXNnVXBkYXRlUGFyYW1zGisuaW5pdGlhLmliY2hvb2tzLnYxLk1zZ1VwZGF0ZVBhcmFtc1Jlc3BvbnNlGgWA57AqAUI1Wi9naXRodWIuY29tL2luaXRpYS1sYWJzL2luaXRpYS94L2liYy1ob29rcy90eXBlc8jhHgBiBnByb3RvMw", [
+	file_amino_amino$1,
+	file_cosmos_msg_v1_msg$1,
+	file_cosmos_proto_cosmos,
+	file_gogoproto_gogo$3,
+	file_initia_ibchooks_v1_types
+]), 0);
+/**
+* Msg defines the intertx Msg service.
+*
+* @generated from service initia.intertx.v1.Msg
+*/
+const Msg = /* @__PURE__ */ serviceDesc(/* @__PURE__ */ fileDesc("Chppbml0aWEvaW50ZXJ0eC92MS90eC5wcm90bxIRaW5pdGlhLmludGVydHgudjEixgEKEk1zZ1JlZ2lzdGVyQWNjb3VudBINCgVvd25lchgBIAEoCRIvCg1jb25uZWN0aW9uX2lkGAIgASgJQhjy3h8UeWFtbDoiY29ubmVjdGlvbl9pZCISDwoHdmVyc2lvbhgDIAEoCRIsCghvcmRlcmluZxgEIAEoDjIaLmliYy5jb3JlLmNoYW5uZWwudjEuT3JkZXI6MYigHwDooB8AguewKgVvd25lcornsCoaaW50ZXJ0eC9Nc2dSZWdpc3RlckFjY291bnQiHAoaTXNnUmVnaXN0ZXJBY2NvdW50UmVzcG9uc2UinAEKC01zZ1N1Ym1pdFR4Eg0KBW93bmVyGAEgASgJEi8KDWNvbm5lY3Rpb25faWQYAiABKAlCGPLeHxR5YW1sOiJjb25uZWN0aW9uX2lkIhIhCgNtc2cYAyABKAsyFC5nb29nbGUucHJvdG9idWYuQW55OiqIoB8A6KAfAILnsCoFb3duZXKK57AqE2ludGVydHgvTXNnU3VibWl0VHgiFQoTTXNnU3VibWl0VHhSZXNwb25zZTLJAQoDTXNnEmcKD1JlZ2lzdGVyQWNjb3VudBIlLmluaXRpYS5pbnRlcnR4LnYxLk1zZ1JlZ2lzdGVyQWNjb3VudBotLmluaXRpYS5pbnRlcnR4LnYxLk1zZ1JlZ2lzdGVyQWNjb3VudFJlc3BvbnNlElIKCFN1Ym1pdFR4Eh4uaW5pdGlhLmludGVydHgudjEuTXNnU3VibWl0VHgaJi5pbml0aWEuaW50ZXJ0eC52MS5Nc2dTdWJtaXRUeFJlc3BvbnNlGgWA57AqAUIvWi1naXRodWIuY29tL2luaXRpYS1sYWJzL2luaXRpYS94L2ludGVydHgvdHlwZXNiBnByb3RvMw", [
+	file_amino_amino$1,
+	file_cosmos_msg_v1_msg$1,
+	file_gogoproto_gogo$3,
+	file_google_protobuf_any,
+	file_ibc_core_channel_v1_channel
+]), 0);
+//#endregion
+//#region src/chains/common.ts
+function createBaseConfig() {
+	return createChainConfig().addModule("auth", { query: Query$13 }).addModule("bank", {
+		query: Query$12,
+		tx: Msg$15
+	}).addModule("tx", { query: Service$1 }).addModule("tendermint", { query: Service }).addModule("ibc", {
+		query: [
+			Query$5,
+			Query$4,
+			Query$3,
+			Query$2
+		],
+		tx: [
+			Msg$14,
+			Msg$13,
+			Msg$12,
+			Msg$11
+		]
+	}).addModule("ibcIca", {
+		query: [Query$1, Query],
+		tx: [Msg$10, Msg$9]
+	}).addModule("authz", {
+		query: Query$11,
+		tx: Msg$8
+	}).addModule("feegrant", {
+		query: Query$10,
+		tx: Msg$7
+	}).addModule("group", {
+		query: Query$9,
+		tx: Msg$6
+	}).addModule("crisis", { tx: Msg$5 }).addModule("upgrade", {
+		query: Query$8,
+		tx: Msg$4
+	}).addModule("consensus", {
+		query: Query$7,
+		tx: Msg$3
+	}).addModule("cosmosAuth", { tx: Msg$2 }).addModule("ibcHooks", {
+		query: Query$6,
+		tx: Msg$1
+	}).addModule("interTx", { tx: Msg }).addModule("oracle", { query: Query$14 }).addTypes(file_cosmos_crypto_ed25519_keys, file_cosmos_crypto_secp256k1_keys, file_initia_crypto_v1beta1_ethsecp256k1_keys, file_cosmos_auth_v1beta1_auth);
+}
+//#endregion
+//#region node_modules/@buf/initia-labs_opinit.bufbuild_es/opinit/ophost/v1/types_pb.js
+/**
+* Describes the file opinit/ophost/v1/types.proto.
+*/
+const file_opinit_ophost_v1_types = /* @__PURE__ */ fileDesc("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", [
+	file_amino_amino$1,
+	file_cosmos_base_v1beta1_coin$1,
+	file_cosmos_proto_cosmos,
+	file_gogoproto_gogo$3,
+	file_google_protobuf_any,
+	file_google_protobuf_duration,
+	file_google_protobuf_timestamp
+]);
+//#endregion
+export { NoSignerError as _, file_cosmos_bank_v1beta1_tx as a, file_google_api_annotations as c, file_amino_amino as d, file_gogoproto_gogo$1 as f, createChainConfig as g, ChainConfigBuilder as h, file_cosmos_msg_v1_msg as i, file_cosmos_base_query_v1beta1_pagination as l, file_cosmos_query_v1_query as m, createBaseConfig as n, file_ibc_core_channel_v1_channel as o, file_cosmos_bank_v1beta1_bank as p, file_ibc_applications_transfer_v1_tx as r, file_ibc_core_client_v1_client as s, file_opinit_ophost_v1_types as t, file_cosmos_base_v1beta1_coin as u, buildChainContextFactory as v, wrapClientWithCache as y };
+
+//# sourceMappingURL=types_pb-K7pKBvcg.mjs.map