@initia/initia.js 1.0.20 → 2.0.0-rc.0

package/dist/waiting-BigHYRNN.mjs

@@ -0,0 +1,1081 @@
+import { h as WebSocketNotAvailableError, p as TimeoutError } from "./errors-CN1MFOLv.mjs";
+import "./constants-W6V0E-3W.mjs";
+//#region src/client/websocket/types.ts
+/**
+* Default session options.
+*/
+const DEFAULT_SESSION_OPTIONS = {
+	autoReconnect: true,
+	maxRetries: Infinity,
+	retryDelay: 1e3,
+	maxRetryDelay: 3e4
+};
+/** Default timeout for subscription confirmation (10 seconds) */
+const SUBSCRIPTION_TIMEOUT_MS = 1e4;
+/**
+* Helper to check if an event spec is a Cosmos event.
+*/
+function isCosmosEvent(spec) {
+	return spec.event === "block" || spec.event === "blockHeader" || spec.event === "tx" || spec.event === "validatorUpdates" || spec.event === "cosmosCustom";
+}
+/**
+* Helper to check if an event spec is an EVM event.
+*/
+function isEvmEvent(spec) {
+	return spec.event === "evmLogs" || spec.event === "evmHeads" || spec.event === "evmPendingTxs" || spec.event === "evmSyncing" || spec.event === "evmCustom";
+}
+//#endregion
+//#region src/client/websocket/cosmos-session.ts
+/**
+* Internal Cosmos WebSocket session for CometBFT subscriptions.
+* @internal
+*/
+var InternalCosmosSession = class {
+	ws = null;
+	subscriptions = /* @__PURE__ */ new Map();
+	messageIdCounter = 0;
+	pendingSubscriptions = /* @__PURE__ */ new Map();
+	isConnected = false;
+	connectionPromise = null;
+	isUserClose = false;
+	reconnectAttempt = 0;
+	reconnectTimer = null;
+	options;
+	constructor(wssUrl, options = {}) {
+		this.wssUrl = wssUrl;
+		this.options = {
+			...DEFAULT_SESSION_OPTIONS,
+			onConnectionEvent: options.onConnectionEvent
+		};
+		if (options.autoReconnect !== void 0) this.options.autoReconnect = options.autoReconnect;
+		if (options.maxRetries !== void 0) this.options.maxRetries = options.maxRetries;
+		if (options.retryDelay !== void 0) this.options.retryDelay = options.retryDelay;
+		if (options.maxRetryDelay !== void 0) this.options.maxRetryDelay = options.maxRetryDelay;
+	}
+	emitEvent(type, extra) {
+		this.options.onConnectionEvent?.({
+			type,
+			timestamp: Date.now(),
+			...extra
+		});
+	}
+	async connect() {
+		return new Promise((resolve, reject) => {
+			this.ws = new WebSocket(this.wssUrl);
+			this.ws.onopen = () => {
+				this.isConnected = true;
+				this.connectionPromise = null;
+				this.reconnectAttempt = 0;
+				this.emitEvent("connect");
+				resolve();
+			};
+			this.ws.onerror = () => {
+				this.connectionPromise = null;
+				const errorMsg = `WebSocket connection failed: ${this.wssUrl}`;
+				this.emitEvent("error", { error: errorMsg });
+				reject(new Error(errorMsg));
+			};
+			this.ws.onclose = () => {
+				const wasConnected = this.isConnected;
+				this.isConnected = false;
+				this.ws = null;
+				if (wasConnected && !this.isUserClose) {
+					this.emitEvent("disconnect", { error: "Connection closed unexpectedly" });
+					this.scheduleReconnect();
+				}
+			};
+			this.ws.onmessage = (event) => {
+				this.handleMessage(event);
+			};
+		});
+	}
+	rejectAllPending(reason) {
+		for (const [, pending] of this.pendingSubscriptions) pending.reject(new Error(reason));
+		this.pendingSubscriptions.clear();
+	}
+	scheduleReconnect() {
+		if (!this.options.autoReconnect) return;
+		if (this.reconnectAttempt >= this.options.maxRetries) {
+			this.rejectAllPending("Max reconnection attempts reached");
+			this.emitEvent("maxRetriesReached");
+			return;
+		}
+		this.reconnectAttempt++;
+		const delay = Math.min(this.options.retryDelay * Math.pow(2, this.reconnectAttempt - 1), this.options.maxRetryDelay);
+		this.emitEvent("reconnect", { attempt: this.reconnectAttempt });
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectAndResubscribe();
+		}, delay);
+	}
+	async reconnectAndResubscribe() {
+		try {
+			await this.connect();
+			this.resubscribeAll();
+		} catch {}
+	}
+	resubscribeAll() {
+		const queries = Array.from(this.subscriptions.keys());
+		for (const query of queries) {
+			const messageId = ++this.messageIdCounter;
+			this.ws?.send(JSON.stringify({
+				jsonrpc: "2.0",
+				method: "subscribe",
+				id: messageId,
+				params: [query]
+			}));
+		}
+	}
+	async ensureConnected() {
+		if (this.isConnected && this.ws) return;
+		if (this.connectionPromise) return this.connectionPromise;
+		this.connectionPromise = this.connect();
+		return this.connectionPromise;
+	}
+	handleMessage(event) {
+		try {
+			const data = JSON.parse(event.data);
+			if (data.result?.query && data.result?.data?.value) {
+				const query = data.result.query;
+				const callback = this.subscriptions.get(query);
+				if (callback) callback(data.result.data.value);
+				return;
+			}
+			if (data.id !== void 0 && data.result !== void 0) {
+				const pending = this.pendingSubscriptions.get(data.id);
+				if (pending) {
+					this.pendingSubscriptions.delete(data.id);
+					pending.resolve();
+				}
+				return;
+			}
+		} catch {}
+	}
+	async subscribe(query, callback) {
+		await this.ensureConnected();
+		const messageId = ++this.messageIdCounter;
+		const subscriptionId = `cosmos-${messageId}-${Date.now()}`;
+		await new Promise((resolve, reject) => {
+			this.pendingSubscriptions.set(messageId, {
+				resolve,
+				reject,
+				query
+			});
+			this.ws.send(JSON.stringify({
+				jsonrpc: "2.0",
+				method: "subscribe",
+				id: messageId,
+				params: [query]
+			}));
+			setTimeout(() => {
+				if (this.pendingSubscriptions.has(messageId)) {
+					this.pendingSubscriptions.delete(messageId);
+					reject(/* @__PURE__ */ new Error(`Subscription confirmation timeout for query: ${query}`));
+				}
+			}, SUBSCRIPTION_TIMEOUT_MS);
+		});
+		this.subscriptions.set(query, callback);
+		return {
+			id: subscriptionId,
+			unsubscribe: () => {
+				this.subscriptions.delete(query);
+				if (this.ws && this.isConnected) this.ws.send(JSON.stringify({
+					jsonrpc: "2.0",
+					method: "unsubscribe",
+					id: ++this.messageIdCounter,
+					params: [query]
+				}));
+			}
+		};
+	}
+	get connected() {
+		return this.isConnected;
+	}
+	get subscriptionCount() {
+		return this.subscriptions.size;
+	}
+	close() {
+		this.isUserClose = true;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		this.subscriptions.clear();
+		this.rejectAllPending("Session closed");
+		if (this.ws) {
+			this.ws.close();
+			this.ws = null;
+		}
+		this.isConnected = false;
+	}
+};
+//#endregion
+//#region src/client/websocket/evm-session.ts
+/**
+* Internal EVM WebSocket session for Ethereum-compatible subscriptions.
+* @internal
+*/
+var InternalEvmSession = class {
+	ws = null;
+	subscriptions = /* @__PURE__ */ new Map();
+	/** Stored subscription info for resubscription */
+	subscriptionInfo = /* @__PURE__ */ new Map();
+	messageIdCounter = 0;
+	pendingSubscriptions = /* @__PURE__ */ new Map();
+	isConnected = false;
+	connectionPromise = null;
+	isUserClose = false;
+	reconnectAttempt = 0;
+	reconnectTimer = null;
+	options;
+	constructor(wssUrl, options = {}) {
+		this.wssUrl = wssUrl;
+		this.options = {
+			...DEFAULT_SESSION_OPTIONS,
+			onConnectionEvent: options.onConnectionEvent
+		};
+		if (options.autoReconnect !== void 0) this.options.autoReconnect = options.autoReconnect;
+		if (options.maxRetries !== void 0) this.options.maxRetries = options.maxRetries;
+		if (options.retryDelay !== void 0) this.options.retryDelay = options.retryDelay;
+		if (options.maxRetryDelay !== void 0) this.options.maxRetryDelay = options.maxRetryDelay;
+	}
+	emitEvent(type, extra) {
+		this.options.onConnectionEvent?.({
+			type,
+			timestamp: Date.now(),
+			...extra
+		});
+	}
+	async connect() {
+		return new Promise((resolve, reject) => {
+			this.ws = new WebSocket(this.wssUrl);
+			this.ws.onopen = () => {
+				this.isConnected = true;
+				this.connectionPromise = null;
+				this.reconnectAttempt = 0;
+				this.emitEvent("connect");
+				resolve();
+			};
+			this.ws.onerror = () => {
+				this.connectionPromise = null;
+				const errorMsg = `WebSocket connection failed: ${this.wssUrl}`;
+				this.emitEvent("error", { error: errorMsg });
+				reject(new Error(errorMsg));
+			};
+			this.ws.onclose = () => {
+				const wasConnected = this.isConnected;
+				this.isConnected = false;
+				this.ws = null;
+				if (wasConnected && !this.isUserClose) {
+					this.emitEvent("disconnect", { error: "Connection closed unexpectedly" });
+					this.scheduleReconnect();
+				}
+			};
+			this.ws.onmessage = (event) => {
+				this.handleMessage(event);
+			};
+		});
+	}
+	rejectAllPending(reason) {
+		for (const [, pending] of this.pendingSubscriptions) pending.reject(new Error(reason));
+		this.pendingSubscriptions.clear();
+	}
+	scheduleReconnect() {
+		if (!this.options.autoReconnect) return;
+		if (this.reconnectAttempt >= this.options.maxRetries) {
+			this.rejectAllPending("Max reconnection attempts reached");
+			this.emitEvent("maxRetriesReached");
+			return;
+		}
+		this.reconnectAttempt++;
+		const delay = Math.min(this.options.retryDelay * Math.pow(2, this.reconnectAttempt - 1), this.options.maxRetryDelay);
+		this.emitEvent("reconnect", { attempt: this.reconnectAttempt });
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectAndResubscribe();
+		}, delay);
+	}
+	async reconnectAndResubscribe() {
+		try {
+			await this.connect();
+			await this.resubscribeAll();
+		} catch {}
+	}
+	async resubscribeAll() {
+		const oldInfos = new Map(this.subscriptionInfo);
+		this.subscriptions.clear();
+		this.subscriptionInfo.clear();
+		for (const [, info] of oldInfos) try {
+			await this.subscribe(info.type, info.params, info.callback);
+		} catch {}
+	}
+	async ensureConnected() {
+		if (this.isConnected && this.ws) return;
+		if (this.connectionPromise) return this.connectionPromise;
+		this.connectionPromise = this.connect();
+		return this.connectionPromise;
+	}
+	handleMessage(event) {
+		try {
+			const data = JSON.parse(event.data);
+			if (data.id !== void 0 && data.result !== void 0) {
+				const pending = this.pendingSubscriptions.get(data.id);
+				if (pending) {
+					pending.resolve(data.result);
+					this.pendingSubscriptions.delete(data.id);
+				}
+				return;
+			}
+			if (data.method === "eth_subscription" && data.params?.subscription) {
+				const callback = this.subscriptions.get(data.params.subscription);
+				if (callback) callback(data.params.result);
+			}
+		} catch {}
+	}
+	async subscribe(type, params, callback) {
+		await this.ensureConnected();
+		const messageId = ++this.messageIdCounter;
+		const subscribeParams = type === "logs" ? [type, params] : [type];
+		const subscriptionId = await new Promise((resolve, reject) => {
+			this.pendingSubscriptions.set(messageId, {
+				resolve,
+				reject
+			});
+			this.ws.send(JSON.stringify({
+				jsonrpc: "2.0",
+				method: "eth_subscribe",
+				id: messageId,
+				params: subscribeParams
+			}));
+			setTimeout(() => {
+				if (this.pendingSubscriptions.has(messageId)) {
+					this.pendingSubscriptions.delete(messageId);
+					reject(/* @__PURE__ */ new Error("Subscription confirmation timeout"));
+				}
+			}, SUBSCRIPTION_TIMEOUT_MS);
+		});
+		this.subscriptions.set(subscriptionId, callback);
+		this.subscriptionInfo.set(subscriptionId, {
+			type,
+			params,
+			callback
+		});
+		return {
+			id: subscriptionId,
+			unsubscribe: () => {
+				this.subscriptions.delete(subscriptionId);
+				this.subscriptionInfo.delete(subscriptionId);
+				if (this.ws && this.isConnected) this.ws.send(JSON.stringify({
+					jsonrpc: "2.0",
+					method: "eth_unsubscribe",
+					id: ++this.messageIdCounter,
+					params: [subscriptionId]
+				}));
+			}
+		};
+	}
+	get connected() {
+		return this.isConnected;
+	}
+	get subscriptionCount() {
+		return this.subscriptions.size;
+	}
+	close() {
+		this.isUserClose = true;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		this.subscriptions.clear();
+		this.subscriptionInfo.clear();
+		this.rejectAllPending("Session closed");
+		if (this.ws) {
+			this.ws.close();
+			this.ws = null;
+		}
+		this.isConnected = false;
+	}
+};
+//#endregion
+//#region src/client/websocket/session.ts
+/**
+* Unified WebSocket session for managing subscriptions to both Cosmos and EVM events.
+*
+* Lazily creates connections to the appropriate WebSocket based on the event type.
+* For minievm chains, a single session can manage both Cosmos and EVM subscriptions.
+*
+* Features:
+* - **Auto-reconnect**: Automatically reconnects on disconnect with exponential backoff (default: enabled)
+* - **Re-subscription**: All subscriptions are automatically restored after reconnection
+* - **Connection events**: Optional callback for monitoring connection state changes
+*
+* @example Basic usage
+* ```typescript
+* const session = createSession(chainInfo)
+*
+* // Subscribe to Cosmos events (uses wss endpoint)
+* const blockSub = await session.subscribe({ event: 'block' }, (block) => {
+*   console.log('New block:', block)
+* })
+*
+* // Subscribe to EVM events (uses evmWss endpoint)
+* const logSub = await session.subscribe({
+*   event: 'evmLogs',
+*   filter: { address: '0x...' }
+* }, (log) => {
+*   console.log('EVM log:', log)
+* })
+*
+* // Check connection status
+* console.log('Cosmos connected:', session.cosmosConnected)
+* console.log('EVM connected:', session.evmConnected)
+*
+* // Cleanup all connections
+* session.close()
+* ```
+*
+* @example With connection monitoring
+* ```typescript
+* const session = createSession(chainInfo, {
+*   onConnectionEvent: (event) => {
+*     console.log(`[${event.type}] at ${new Date(event.timestamp).toISOString()}`)
+*     if (event.type === 'reconnect') {
+*       console.log(`  Attempt #${event.attempt}`)
+*     }
+*     if (event.error) {
+*       console.log(`  Error: ${event.error}`)
+*     }
+*   }
+* })
+* ```
+*
+* @example Disable auto-reconnect
+* ```typescript
+* const session = createSession(chainInfo, { autoReconnect: false })
+* ```
+*/
+var WebSocketSession = class {
+	cosmosSession;
+	evmSession;
+	constructor(chainInfo, options = {}) {
+		this.chainInfo = chainInfo;
+		this.options = options;
+	}
+	/**
+	* Subscribe to blockchain events.
+	*
+	* Automatically routes to the appropriate WebSocket based on event type.
+	* Event data type is inferred from the event spec. Use generic parameter
+	* to override with a custom type.
+	*
+	* @typeParam T - Optional custom type override for event data
+	* @param spec - Event specification
+	* @param callback - Function called for each event with inferred or custom type
+	* @returns Subscription handle
+	*
+	* @example Default type inference
+	* ```typescript
+	* session.subscribe({ event: 'block' }, (block) => {
+	*   console.log(block.header?.height)  // WsBlock type inferred
+	* })
+	* ```
+	*
+	* @example Custom type override
+	* ```typescript
+	* interface MyBlock { header: { height: string } }
+	* session.subscribe<MyBlock>({ event: 'block' }, (block) => {
+	*   console.log(block.header.height)  // MyBlock type used
+	* })
+	* ```
+	*/
+	async subscribe(spec, callback) {
+		if (isCosmosEvent(spec)) return this.subscribeCosmos(spec, callback);
+		else return this.subscribeEvm(spec, callback);
+	}
+	async subscribeCosmos(spec, callback) {
+		if (!this.cosmosSession) {
+			if (!this.chainInfo.wss) throw new WebSocketNotAvailableError(this.chainInfo.chainId);
+			this.cosmosSession = new InternalCosmosSession(this.chainInfo.wss, this.options);
+		}
+		let query;
+		let dataExtractor = (data) => data;
+		switch (spec.event) {
+			case "block":
+				query = "tm.event='NewBlock'";
+				dataExtractor = (data) => {
+					return data.block ?? data;
+				};
+				break;
+			case "blockHeader":
+				query = "tm.event='NewBlockHeader'";
+				dataExtractor = (data) => {
+					return data.header ?? data;
+				};
+				break;
+			case "tx":
+				query = spec.filter ? `tm.event='Tx' AND ${spec.filter}` : "tm.event='Tx'";
+				dataExtractor = (data) => {
+					return data.TxResult ?? data;
+				};
+				break;
+			case "validatorUpdates":
+				query = "tm.event='ValidatorSetUpdates'";
+				break;
+			case "cosmosCustom":
+				query = spec.query;
+				break;
+		}
+		return this.cosmosSession.subscribe(query, (data) => {
+			callback(dataExtractor(data));
+		});
+	}
+	async subscribeEvm(spec, callback) {
+		if (!this.evmSession) {
+			const evmWss = this.chainInfo.evmWss;
+			if (!evmWss) throw new WebSocketNotAvailableError(this.chainInfo.chainId);
+			this.evmSession = new InternalEvmSession(evmWss, this.options);
+		}
+		let type;
+		let params = {};
+		switch (spec.event) {
+			case "evmLogs":
+				type = "logs";
+				params = spec.filter ?? {};
+				break;
+			case "evmHeads":
+				type = "newHeads";
+				break;
+			case "evmPendingTxs":
+				type = "newPendingTransactions";
+				break;
+			case "evmSyncing":
+				type = "syncing";
+				break;
+			case "evmCustom":
+				type = spec.type;
+				params = spec.params ?? {};
+				break;
+		}
+		return this.evmSession.subscribe(type, params, callback);
+	}
+	/**
+	* Check if Cosmos WebSocket endpoint is available.
+	*/
+	get hasCosmosEndpoint() {
+		return !!this.chainInfo.wss;
+	}
+	/**
+	* Check if EVM WebSocket endpoint is available.
+	*/
+	get hasEvmEndpoint() {
+		return !!this.chainInfo.evmWss;
+	}
+	/**
+	* Check if Cosmos WebSocket is currently connected.
+	*/
+	get cosmosConnected() {
+		return this.cosmosSession?.connected ?? false;
+	}
+	/**
+	* Check if EVM WebSocket is currently connected.
+	*/
+	get evmConnected() {
+		return this.evmSession?.connected ?? false;
+	}
+	/**
+	* Get total number of active subscriptions across all connections.
+	*/
+	get subscriptionCount() {
+		return (this.cosmosSession?.subscriptionCount ?? 0) + (this.evmSession?.subscriptionCount ?? 0);
+	}
+	/**
+	* Close all WebSocket connections and subscriptions.
+	*/
+	close() {
+		this.cosmosSession?.close();
+		this.evmSession?.close();
+		this.cosmosSession = void 0;
+		this.evmSession = void 0;
+	}
+};
+/**
+* Create a WebSocket session for subscribing to blockchain events.
+*
+* The session lazily connects to the appropriate WebSocket (Cosmos or EVM)
+* based on the events you subscribe to.
+*
+* **Auto-reconnect behavior** (enabled by default):
+* - Automatically reconnects when connection drops unexpectedly
+* - Uses exponential backoff: 1s, 2s, 4s, 8s... up to 30s max
+* - Re-subscribes all existing subscriptions after reconnection
+* - Disable with `{ autoReconnect: false }` for manual control
+*
+* @param chainInfo - Chain configuration
+* @param options - Session options (auto-reconnect, connection events)
+* @returns WebSocketSession instance
+*
+* @example Basic usage
+* ```typescript
+* const session = createSession(chainInfo)
+*
+* // Mixed Cosmos and EVM subscriptions (for minievm chains)
+* await session.subscribe({ event: 'block' }, onBlock)
+* await session.subscribe({ event: 'evmLogs', filter: {...} }, onLog)
+*
+* session.close()
+* ```
+*
+* @example With connection monitoring
+* ```typescript
+* const session = createSession(chainInfo, {
+*   onConnectionEvent: (event) => {
+*     if (event.type === 'disconnect') {
+*       console.warn('WebSocket disconnected:', event.error)
+*     } else if (event.type === 'reconnect') {
+*       console.log(`Reconnecting... (attempt ${event.attempt})`)
+*     } else if (event.type === 'connect') {
+*       console.log('WebSocket connected')
+*     }
+*   }
+* })
+* ```
+*
+* @example Custom reconnect settings
+* ```typescript
+* const session = createSession(chainInfo, {
+*   autoReconnect: true,
+*   maxRetries: 10,        // Give up after 10 attempts
+*   retryDelay: 2000,      // Start with 2s delay
+*   maxRetryDelay: 60000,  // Cap at 60s
+* })
+* ```
+*/
+function createSession(chainInfo, options) {
+	return new WebSocketSession(chainInfo, options);
+}
+/**
+* Subscribe to blockchain events with automatic session management.
+*
+* Creates a temporary session for the subscription and closes it when unsubscribed.
+* For multiple subscriptions, use `createSession()` for better efficiency.
+*
+* Event data type is inferred from the event spec. Use generic parameter
+* to override with a custom type.
+*
+* @typeParam T - Optional custom type override for event data
+* @param chainInfo - Chain configuration
+* @param spec - Event specification
+* @param callback - Function called for each event with inferred or custom type
+* @returns Subscription handle
+*
+* @example Default type inference
+* ```typescript
+* const sub = await subscribe(chainInfo, { event: 'block' }, (block) => {
+*   console.log('New block:', block.header?.height)  // WsBlock inferred
+* })
+* ```
+*
+* @example Custom type override
+* ```typescript
+* interface MyBlock { header: { height: string } }
+* const sub = await subscribe<MyBlock>(chainInfo, { event: 'block' }, (block) => {
+*   console.log('New block:', block.header.height)  // MyBlock used
+* })
+* ```
+*/
+async function subscribe(chainInfo, spec, callback) {
+	const session = createSession(chainInfo);
+	const sub = await session.subscribe(spec, callback);
+	return {
+		id: sub.id,
+		unsubscribe: () => {
+			sub.unsubscribe();
+			session.close();
+		}
+	};
+}
+/**
+* Check if WebSocket endpoint is available for the chain.
+*
+* @param chainInfo - Chain configuration
+* @param type - Endpoint type to check (default: 'cosmos')
+* @returns true if the endpoint is available
+*
+* @example
+* ```typescript
+* if (hasWebSocketEndpoint(chainInfo)) {
+*   // Cosmos WS available
+* }
+*
+* if (hasWebSocketEndpoint(chainInfo, 'evm')) {
+*   // EVM WS available (minievm chains)
+* }
+* ```
+*/
+function hasWebSocketEndpoint(chainInfo, type = "cosmos") {
+	return type === "cosmos" ? !!chainInfo.wss : !!chainInfo.evmWss;
+}
+//#endregion
+//#region src/client/websocket/waiting.ts
+/** Internal: Format raw tx response to TxResult */
+function formatTxResult(tx) {
+	return {
+		height: tx.height,
+		txHash: tx.txhash,
+		code: tx.code,
+		rawLog: tx.rawLog,
+		gasUsed: tx.gasUsed,
+		gasWanted: tx.gasWanted,
+		events: tx.events.map((e) => ({
+			type: e.type,
+			attributes: e.attributes.map((a) => ({
+				key: a.key,
+				value: a.value
+			}))
+		}))
+	};
+}
+/** Internal: Query transaction from client */
+async function queryTx(client, txHash) {
+	try {
+		const response = await client.tx.getTx({ hash: txHash });
+		if (response.txResponse) return formatTxResult(response.txResponse);
+	} catch {}
+	return null;
+}
+/**
+* Wait for a transaction to be included in a block.
+*
+* **Strategy selection:**
+* - If `chainInfo` is provided and has WebSocket endpoint → uses WebSocket
+* - Otherwise → uses polling
+*
+* **WebSocket mode** (recommended for fast chains):
+* - Subscribes to new blocks and queries tx on each block
+* - Uses "Subscribe First, Query After" pattern to avoid race conditions
+* - Falls back to polling if WebSocket connection fails
+*
+* **Polling mode**:
+* - Queries tx at regular intervals until found or timeout
+*
+* @param client - gRPC client with tx service
+* @param txHash - Transaction hash to wait for
+* @param options - Wait options (timeout, pollInterval, chainInfo)
+* @returns Transaction result when found
+* @throws {TimeoutError} If the transaction is not found within the timeout
+*
+* @example Polling mode (basic)
+* ```typescript
+* const txResult = await waitForTx(client, txHash)
+* ```
+*
+* @example WebSocket mode (recommended)
+* ```typescript
+* const txResult = await waitForTx(client, txHash, { chainInfo })
+* ```
+*
+* @example Via ChainContext (automatic WebSocket)
+* ```typescript
+* const result = await ctx.signAndBroadcast(msgs)
+* const txResult = await ctx.waitForTx(result.txHash)
+* ```
+*/
+async function waitForTx(client, txHash, options = {}) {
+	if (options.chainInfo?.wss) try {
+		return await waitForTxWebSocket(client, txHash, options.chainInfo, options);
+	} catch (error) {
+		if (error instanceof TimeoutError) throw error;
+	}
+	return waitForTxPolling(client, txHash, options);
+}
+/**
+* Internal: WebSocket-based waitForTx implementation.
+*
+* Uses "Subscribe First, Query After" pattern:
+* 1. Subscribe to block events first (guarantees future blocks)
+* 2. Query for existing tx after subscription established
+* 3. This avoids race condition where tx is included during subscription setup
+*/
+async function waitForTxWebSocket(client, txHash, chainInfo, options) {
+	const timeout = options.timeout ?? 3e4;
+	return new Promise((resolve, reject) => {
+		let resolved = false;
+		let session = null;
+		let sub = null;
+		let timer = null;
+		const cleanup = () => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			if (sub) {
+				sub.unsubscribe();
+				sub = null;
+			}
+			if (session) {
+				session.close();
+				session = null;
+			}
+		};
+		const complete = (result) => {
+			if (resolved) return;
+			resolved = true;
+			cleanup();
+			resolve(result);
+		};
+		const fail = (error) => {
+			if (resolved) return;
+			resolved = true;
+			cleanup();
+			reject(error);
+		};
+		timer = setTimeout(() => {
+			fail(new TimeoutError(`waitForTx(${txHash})`, timeout));
+		}, timeout);
+		const execute = async () => {
+			session = createSession(chainInfo, { autoReconnect: false });
+			sub = await session.subscribe({ event: "block" }, () => {
+				if (resolved) return;
+				queryTx(client, txHash).then((result) => {
+					if (result && !resolved) complete(result);
+				});
+			});
+			if (resolved) return;
+			const existing = await queryTx(client, txHash);
+			if (existing && !resolved) complete(existing);
+		};
+		execute().catch(fail);
+	});
+}
+/**
+* Internal: Polling-based waitForTx implementation.
+*/
+async function waitForTxPolling(client, txHash, options) {
+	const timeout = options.timeout ?? 3e4;
+	const pollInterval = options.pollInterval ?? 1e3;
+	const startTime = Date.now();
+	while (true) {
+		if (Date.now() - startTime > timeout) throw new TimeoutError(`waitForTx(${txHash})`, timeout);
+		const result = await queryTx(client, txHash);
+		if (result) return result;
+		await new Promise((r) => setTimeout(r, pollInterval));
+	}
+}
+/**
+* Build CometBFT query string from EventFilter.
+*
+* @param filter - Event filter criteria
+* @param fromHeight - Optional minimum block height
+* @returns CometBFT query string
+*
+* @example
+* ```typescript
+* buildEventQuery({ type: 'transfer', attributes: { recipient: 'init1...' } })
+* // => "transfer.recipient='init1...'"
+*
+* buildEventQuery({ type: 'transfer' }, 1000n)
+* // => "tx.height>=1000"
+* ```
+*/
+function buildEventQuery(filter, fromHeight) {
+	const conditions = [];
+	if (filter.attributes) for (const [key, value] of Object.entries(filter.attributes)) conditions.push(`${filter.type}.${key}='${value}'`);
+	if (conditions.length === 0) conditions.push("tx.height>0");
+	if (fromHeight !== void 0) conditions.push(`tx.height>=${fromHeight}`);
+	return conditions.join(" AND ");
+}
+/**
+* Check if a TxResult matches the given EventFilter.
+*
+* @param tx - Transaction result to check
+* @param filter - Event filter criteria
+* @returns true if the transaction contains a matching event
+*/
+function matchesEventFilter(tx, filter) {
+	for (const event of tx.events) {
+		if (event.type !== filter.type) continue;
+		if (!filter.attributes || Object.keys(filter.attributes).length === 0) return true;
+		const attrMap = new Map(event.attributes.map((a) => [a.key, a.value]));
+		let allMatch = true;
+		for (const [key, value] of Object.entries(filter.attributes)) if (attrMap.get(key) !== value) {
+			allMatch = false;
+			break;
+		}
+		if (allMatch) return true;
+	}
+	return false;
+}
+/**
+* Wait for transactions containing events that match the filter criteria.
+*
+* **Strategy selection:**
+* - If `chainInfo` is provided and has WebSocket endpoint → uses WebSocket for real-time events
+* - Otherwise → uses polling via `getTxsEvent` gRPC
+*
+* **WebSocket mode** (recommended for waiting on future events):
+* - Subscribes to new transactions first
+* - Queries historical transactions from `fromHeight`
+* - Combines results in ascending height order
+*
+* **Polling mode**:
+* - Queries `getTxsEvent` at regular intervals
+* - Filters results by event type/attributes
+*
+* @param client - gRPC client with tx service (must support getTxsEvent)
+* @param filter - Event filter criteria
+* @param options - Wait options (timeout, pollInterval, chainInfo, fromHeight, maxResults)
+* @returns Array of TxResult matching the filter
+* @throws {TimeoutError} If no matching events found within timeout
+*
+* @example Wait for transfer events (polling)
+* ```typescript
+* const txs = await waitForEvent(client, {
+*   type: 'transfer',
+*   attributes: { recipient: 'init1...' }
+* })
+* ```
+*
+* @example Wait for events from specific height (WebSocket)
+* ```typescript
+* const txs = await waitForEvent(client, {
+*   type: 'transfer',
+*   attributes: { recipient: 'init1...' }
+* }, {
+*   chainInfo,
+*   fromHeight: 1000n,
+*   maxResults: 10
+* })
+* ```
+*/
+async function waitForEvent(client, filter, options = {}) {
+	if (options.chainInfo?.wss) try {
+		return await waitForEventWebSocket(client, filter, options.chainInfo, options);
+	} catch (error) {
+		if (error instanceof TimeoutError) throw error;
+	}
+	return waitForEventPolling(client, filter, options);
+}
+/**
+* Internal: WebSocket-based waitForEvent implementation.
+*
+* Uses "Subscribe First, Query After" pattern:
+* 1. Subscribe to tx events first (guarantees future transactions)
+* 2. Query historical transactions matching filter
+* 3. Combine and deduplicate results
+*/
+async function waitForEventWebSocket(client, filter, chainInfo, options) {
+	const timeout = options.timeout ?? 6e4;
+	const maxResults = options.maxResults ?? 100;
+	return new Promise((resolve, reject) => {
+		let resolved = false;
+		let session = null;
+		let sub = null;
+		let timer = null;
+		const results = /* @__PURE__ */ new Map();
+		const cleanup = () => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			if (sub) {
+				sub.unsubscribe();
+				sub = null;
+			}
+			if (session) {
+				session.close();
+				session = null;
+			}
+		};
+		const complete = () => {
+			if (resolved) return;
+			resolved = true;
+			cleanup();
+			resolve(Array.from(results.values()).sort((a, b) => a.height < b.height ? -1 : a.height > b.height ? 1 : 0).slice(0, maxResults));
+		};
+		const fail = (error) => {
+			if (resolved) return;
+			resolved = true;
+			cleanup();
+			reject(error);
+		};
+		const addResult = (tx) => {
+			if (resolved) return;
+			if (!results.has(tx.txHash) && matchesEventFilter(tx, filter)) {
+				results.set(tx.txHash, tx);
+				if (results.size >= maxResults) complete();
+			}
+		};
+		timer = setTimeout(() => {
+			if (results.size > 0) complete();
+			else fail(new TimeoutError(`waitForEvent(${filter.type})`, timeout));
+		}, timeout);
+		const execute = async () => {
+			session = createSession(chainInfo, { autoReconnect: false });
+			sub = await session.subscribe({ event: "tx" }, (wsTx) => {
+				if (resolved) return;
+				if (wsTx.height && wsTx.result) addResult({
+					height: BigInt(wsTx.height),
+					txHash: wsTx.tx ?? "",
+					code: wsTx.result.code ?? 0,
+					rawLog: wsTx.result.log ?? "",
+					gasUsed: BigInt(wsTx.result.gas_used ?? "0"),
+					gasWanted: BigInt(wsTx.result.gas_wanted ?? "0"),
+					events: (wsTx.result.events ?? []).map((e) => ({
+						type: e.type ?? "",
+						attributes: (e.attributes ?? []).map((a) => ({
+							key: a.key ?? "",
+							value: a.value ?? ""
+						}))
+					}))
+				});
+			});
+			if (resolved) return;
+			const query = buildEventQuery(filter, options.fromHeight);
+			try {
+				const response = await client.tx.getTxsEvent({
+					query,
+					limit: BigInt(maxResults),
+					orderBy: 1
+				});
+				for (const txResponse of response.txResponses) {
+					if (resolved) break;
+					addResult(formatTxResult(txResponse));
+				}
+				if (results.size >= maxResults) complete();
+			} catch {}
+		};
+		execute().catch(fail);
+	});
+}
+/**
+* Internal: Polling-based waitForEvent implementation.
+*/
+async function waitForEventPolling(client, filter, options) {
+	const timeout = options.timeout ?? 6e4;
+	const pollInterval = options.pollInterval ?? 1e3;
+	const maxResults = options.maxResults ?? 100;
+	const startTime = Date.now();
+	const results = /* @__PURE__ */ new Map();
+	const query = buildEventQuery(filter, options.fromHeight);
+	while (true) {
+		if (Date.now() - startTime > timeout) {
+			if (results.size > 0) return Array.from(results.values()).sort((a, b) => a.height < b.height ? -1 : a.height > b.height ? 1 : 0).slice(0, maxResults);
+			throw new TimeoutError(`waitForEvent(${filter.type})`, timeout);
+		}
+		try {
+			const response = await client.tx.getTxsEvent({
+				query,
+				limit: BigInt(maxResults),
+				orderBy: 1
+			});
+			for (const txResponse of response.txResponses) {
+				const tx = formatTxResult(txResponse);
+				if (!results.has(tx.txHash) && matchesEventFilter(tx, filter)) results.set(tx.txHash, tx);
+			}
+			if (results.size >= maxResults) return Array.from(results.values()).sort((a, b) => a.height < b.height ? -1 : a.height > b.height ? 1 : 0).slice(0, maxResults);
+		} catch {}
+		await new Promise((r) => setTimeout(r, pollInterval));
+	}
+}
+//#endregion
+export { WebSocketSession as a, subscribe as c, waitForTx as i, isCosmosEvent as l, matchesEventFilter as n, createSession as o, waitForEvent as r, hasWebSocketEndpoint as s, buildEventQuery as t, isEvmEvent as u };
+
+//# sourceMappingURL=waiting-BigHYRNN.mjs.map