@injectivelabs/sdk-ts 1.19.26 → 1.19.28

package/dist/cjs/{tx-Bwj03Ryo.cjs → tx-BrB6tTAl.cjs}

@@ -262,6 +262,392 @@ const getTxRawFromTxRawOrDirectSignResponse = (txRawOrDirectSignResponse) => {
 	return txRawOrDirectSignResponse.signed === void 0 ? txRawOrDirectSignResponse : createTxRawFromSigResponse(txRawOrDirectSignResponse);
 };
 
+//#endregion
+//#region src/core/tx/types/tx.ts
+const TxInclusionStrategy = {
+	Poll: "poll",
+	TendermintEvent: "tendermint-event",
+	TendermintEventAndPoll: "tendermint-event-and-poll"
+};
+const TxClientMode = {
+	gRpc: "grpc",
+	rest: "rest"
+};
+
+//#endregion
+//#region src/core/tx/api/TxEventInclusion.ts
+function normalizeTendermintWebSocketEndpoint(endpoint) {
+	let normalized = endpoint;
+	if (normalized.startsWith("http://")) normalized = `ws://${normalized.slice(7)}`;
+	else if (normalized.startsWith("https://")) normalized = `wss://${normalized.slice(8)}`;
+	return normalized.endsWith("/websocket") ? normalized : `${normalized.replace(/\/$/, "")}/websocket`;
+}
+async function subscribeToTendermintTxEvent({ txHash, timeout, endpoint, webSocketFactory }) {
+	const normalizedTxHash = normalizeTendermintTxHash(txHash);
+	const socket = createTendermintSocket(normalizeTendermintWebSocketEndpoint(endpoint), webSocketFactory);
+	const query = `tm.event='Tx' AND tx.hash='${normalizedTxHash}'`;
+	const requestId = `tx-event-${Date.now()}-${Math.random()}`;
+	return new Promise((resolve, reject) => {
+		let ready = false;
+		let waitSettled = false;
+		let closedIntentionally = false;
+		let timeoutId;
+		let waitResolve;
+		let waitReject;
+		const waitPromise = new Promise((resolveWait$1, rejectWait$1) => {
+			waitResolve = resolveWait$1;
+			waitReject = rejectWait$1;
+		});
+		const resolveSubscription = () => {
+			if (ready) return;
+			ready = true;
+			resolve({
+				close: cleanup,
+				wait: () => waitPromise
+			});
+		};
+		const cleanup = () => {
+			closedIntentionally = true;
+			clearTimeout(timeoutId);
+			socket.removeEventListener("open", onOpen);
+			socket.removeEventListener("message", onMessage);
+			socket.removeEventListener("error", onError);
+			socket.removeEventListener("close", onClose);
+			if (socket.readyState === 1 || socket.readyState === 0) socket.close();
+		};
+		const rejectWait = (error) => {
+			if (waitSettled) return;
+			waitSettled = true;
+			waitReject(error);
+			cleanup();
+		};
+		timeoutId = setTimeout(() => {
+			const error = /* @__PURE__ */ new Error(`Timed out waiting for Tendermint tx event after ${timeout}ms`);
+			if (ready) {
+				rejectWait(error);
+				return;
+			}
+			cleanup();
+			reject(error);
+		}, timeout);
+		const resolveWait = (response) => {
+			if (waitSettled) return;
+			waitSettled = true;
+			waitResolve(response);
+			cleanup();
+		};
+		const rejectForMessageError = (error) => {
+			if (ready) {
+				rejectWait(error);
+				return;
+			}
+			cleanup();
+			reject(error);
+		};
+		const onOpen = () => {
+			socket.send(JSON.stringify({
+				id: requestId,
+				jsonrpc: "2.0",
+				method: "subscribe",
+				params: { query }
+			}));
+		};
+		const onMessage = (event) => {
+			readMessageEventData(event).then((messageData) => {
+				const message = JSON.parse(messageData);
+				const eventResponse = parseTxEventResponse(message, normalizedTxHash);
+				if (eventResponse) {
+					resolveSubscription();
+					resolveWait(eventResponse);
+					return;
+				}
+				if (message.id !== requestId) return;
+				if (message.error) {
+					rejectForMessageError(/* @__PURE__ */ new Error(`Tendermint subscribe failed: ${JSON.stringify(message.error)}`));
+					return;
+				}
+				resolveSubscription();
+			}).catch((error) => {
+				rejectForMessageError(error instanceof Error ? error : /* @__PURE__ */ new Error(`Invalid Tendermint WebSocket JSON: ${String(error)}`));
+			});
+		};
+		const onError = () => {
+			const error = /* @__PURE__ */ new Error("Tendermint WebSocket error");
+			if (ready) {
+				rejectWait(error);
+				return;
+			}
+			cleanup();
+			reject(error);
+		};
+		const onClose = () => {
+			if (closedIntentionally) return;
+			const error = /* @__PURE__ */ new Error("Tendermint WebSocket closed");
+			if (ready) {
+				rejectWait(error);
+				return;
+			}
+			cleanup();
+			reject(error);
+		};
+		socket.addEventListener("open", onOpen);
+		socket.addEventListener("message", onMessage);
+		socket.addEventListener("error", onError);
+		socket.addEventListener("close", onClose);
+	});
+}
+function normalizeTendermintTxHash(txHash) {
+	if (!/^[0-9a-fA-F]{64}$/.test(txHash)) throw new Error("Invalid Tendermint tx hash");
+	return txHash.toUpperCase();
+}
+function createTendermintSocket(endpoint, webSocketFactory) {
+	if (webSocketFactory) return webSocketFactory(endpoint);
+	if (!globalThis.WebSocket) throw new Error("WebSocket is not available in this environment");
+	return new globalThis.WebSocket(endpoint);
+}
+async function readMessageEventData(event) {
+	const { data } = event;
+	if (typeof data === "string") return data;
+	if (typeof Blob !== "undefined" && data instanceof Blob) return data.text();
+	if (typeof ArrayBuffer !== "undefined" && data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+	if (ArrayBuffer.isView(data)) return new TextDecoder().decode(data);
+	return String(data);
+}
+function parseTxEventResponse(message, txHash) {
+	var _message$params$resul, _message$params, _message$result, _data$value, _ref, _value$TxResult, _txResult$result;
+	const data = (_message$params$resul = message === null || message === void 0 || (_message$params = message.params) === null || _message$params === void 0 || (_message$params = _message$params.result) === null || _message$params === void 0 ? void 0 : _message$params.data) !== null && _message$params$resul !== void 0 ? _message$params$resul : message === null || message === void 0 || (_message$result = message.result) === null || _message$result === void 0 ? void 0 : _message$result.data;
+	const eventTxHashes = readTxEventHashes(data);
+	if (eventTxHashes.length > 0 && !eventTxHashes.some((eventTxHash) => eventTxHash.toUpperCase() === txHash.toUpperCase())) return;
+	const value = (_data$value = data === null || data === void 0 ? void 0 : data.value) !== null && _data$value !== void 0 ? _data$value : data;
+	const txResult = (_ref = (_value$TxResult = value === null || value === void 0 ? void 0 : value.TxResult) !== null && _value$TxResult !== void 0 ? _value$TxResult : value === null || value === void 0 ? void 0 : value.tx_result) !== null && _ref !== void 0 ? _ref : value;
+	const result = (_txResult$result = txResult === null || txResult === void 0 ? void 0 : txResult.result) !== null && _txResult$result !== void 0 ? _txResult$result : txResult === null || txResult === void 0 ? void 0 : txResult.Result;
+	if (!txResult || !result) return;
+	return {
+		txHash,
+		logs: [],
+		timestamp: "",
+		data: result.data || "",
+		info: result.info || "",
+		events: result.events || [],
+		code: Number(result.code || 0),
+		codespace: result.codespace || "",
+		rawLog: result.log || result.raw_log || "",
+		height: Number(txResult.height || (value === null || value === void 0 ? void 0 : value.height) || 0),
+		gasUsed: Number(result.gas_used || result.gasUsed || 0),
+		gasWanted: Number(result.gas_wanted || result.gasWanted || 0)
+	};
+}
+function readTxEventHashes(data) {
+	var _data$events$txHash, _data$events, _data$events2;
+	const txHashEvent = (_data$events$txHash = data === null || data === void 0 || (_data$events = data.events) === null || _data$events === void 0 ? void 0 : _data$events["tx.hash"]) !== null && _data$events$txHash !== void 0 ? _data$events$txHash : data === null || data === void 0 || (_data$events2 = data.events) === null || _data$events2 === void 0 ? void 0 : _data$events2.tx_hash;
+	if (Array.isArray(txHashEvent)) return txHashEvent.map(String);
+	if (txHashEvent) return [String(txHashEvent)];
+	return [];
+}
+
+//#endregion
+//#region src/core/tx/api/TxInclusion.ts
+function isTendermintEventStrategy(inclusionStrategy) {
+	return inclusionStrategy === TxInclusionStrategy.TendermintEvent || inclusionStrategy === TxInclusionStrategy.TendermintEventAndPoll;
+}
+async function prepareTxInclusionWaiter({ txHash, timeout, options, fetchTx, fetchTxPoll, createRequestException }) {
+	const inclusionStrategy = options === null || options === void 0 ? void 0 : options.inclusionStrategy;
+	if (!isTendermintEventStrategy(inclusionStrategy)) return createPollingInclusionWaiter({
+		txHash,
+		timeout,
+		options,
+		fetchTxPoll
+	});
+	const eventOptions = options === null || options === void 0 ? void 0 : options.eventInclusion;
+	const rpcEndpoint = eventOptions === null || eventOptions === void 0 ? void 0 : eventOptions.rpcEndpoint;
+	const fallbackToPolling = (eventOptions === null || eventOptions === void 0 ? void 0 : eventOptions.fallbackToPolling) !== false;
+	if (!rpcEndpoint) {
+		var _eventOptions$onFallb;
+		const error = new __injectivelabs_exceptions.GeneralException(/* @__PURE__ */ new Error("Tendermint RPC endpoint is required for event inclusion"));
+		if (!fallbackToPolling) throw createRequestException(error, "event-inclusion");
+		eventOptions === null || eventOptions === void 0 || (_eventOptions$onFallb = eventOptions.onFallback) === null || _eventOptions$onFallb === void 0 || _eventOptions$onFallb.call(eventOptions, error);
+		return createPollingInclusionWaiter({
+			txHash,
+			timeout,
+			options,
+			fetchTxPoll
+		});
+	}
+	try {
+		const subscription = await subscribeToTendermintTxEvent({
+			txHash,
+			endpoint: rpcEndpoint,
+			timeout: (eventOptions === null || eventOptions === void 0 ? void 0 : eventOptions.timeout) || timeout,
+			webSocketFactory: eventOptions === null || eventOptions === void 0 ? void 0 : eventOptions.webSocketFactory
+		});
+		const hashMismatchPollAbortController = new AbortController();
+		const close = () => {
+			hashMismatchPollAbortController.abort();
+			subscription.close();
+		};
+		return {
+			txHash,
+			inclusionStrategy,
+			close,
+			wait: async (includedTxHash = txHash) => {
+				if (includedTxHash.toUpperCase() !== txHash.toUpperCase()) {
+					var _eventOptions$onFallb2;
+					subscription.close();
+					eventOptions === null || eventOptions === void 0 || (_eventOptions$onFallb2 = eventOptions.onFallback) === null || _eventOptions$onFallb2 === void 0 || _eventOptions$onFallb2.call(eventOptions, new __injectivelabs_exceptions.GeneralException(/* @__PURE__ */ new Error(`Broadcast tx hash ${includedTxHash} did not match subscribed tx hash ${txHash}`)));
+					return fetchTxPoll(createFetchTxPollArgs({
+						txHash: includedTxHash,
+						timeout,
+						options,
+						abortSignal: hashMismatchPollAbortController.signal
+					}));
+				}
+				if (inclusionStrategy === TxInclusionStrategy.TendermintEventAndPoll) return waitForSubscribedTxInclusionAndPoll({
+					txHash,
+					timeout,
+					fetchTx,
+					options,
+					fetchTxPoll,
+					subscription
+				});
+				return waitForSubscribedTxInclusion({
+					txHash,
+					timeout,
+					options,
+					fetchTx,
+					subscription,
+					fetchTxPoll,
+					createRequestException
+				});
+			}
+		};
+	} catch (e) {
+		var _eventOptions$onFallb3;
+		if (e instanceof __injectivelabs_exceptions.TransactionException) throw e;
+		const error = e instanceof Error ? e : new Error(String(e));
+		if (!fallbackToPolling) throw createRequestException(error, "event-inclusion");
+		eventOptions === null || eventOptions === void 0 || (_eventOptions$onFallb3 = eventOptions.onFallback) === null || _eventOptions$onFallb3 === void 0 || _eventOptions$onFallb3.call(eventOptions, error);
+		return createPollingInclusionWaiter({
+			txHash,
+			timeout,
+			options,
+			fetchTxPoll
+		});
+	}
+}
+function createPollingInclusionWaiter({ txHash, timeout, options, fetchTxPoll }) {
+	const pollAbortController = new AbortController();
+	return {
+		txHash,
+		inclusionStrategy: TxInclusionStrategy.Poll,
+		close: () => {
+			pollAbortController.abort();
+		},
+		wait: (includedTxHash = txHash) => fetchTxPoll(createFetchTxPollArgs({
+			txHash: includedTxHash,
+			timeout,
+			options,
+			abortSignal: pollAbortController.signal
+		}))
+	};
+}
+function createFetchTxPollArgs({ txHash, timeout, options, abortSignal }) {
+	return {
+		...(options === null || options === void 0 ? void 0 : options.pollingInterval) === void 0 ? {} : { pollingInterval: options.pollingInterval },
+		...abortSignal ? { abortSignal } : {},
+		txHash,
+		timeout
+	};
+}
+async function waitForSubscribedTxInclusion({ txHash, timeout, options, fetchTx, fetchTxPoll, subscription, createRequestException }) {
+	var _options$eventInclusi;
+	const fallbackToPolling = (options === null || options === void 0 || (_options$eventInclusi = options.eventInclusion) === null || _options$eventInclusi === void 0 ? void 0 : _options$eventInclusi.fallbackToPolling) !== false;
+	try {
+		return await waitForSubscribedTxEvent({
+			txHash,
+			subscription,
+			fetchTx
+		});
+	} catch (e) {
+		var _options$eventInclusi2, _options$eventInclusi3;
+		if (e instanceof __injectivelabs_exceptions.TransactionException) throw e;
+		const error = e instanceof __injectivelabs_exceptions.GeneralException ? e : new __injectivelabs_exceptions.GeneralException(new Error(String(e)));
+		if (!fallbackToPolling) throw createRequestException(error, "event-inclusion");
+		options === null || options === void 0 || (_options$eventInclusi2 = options.eventInclusion) === null || _options$eventInclusi2 === void 0 || (_options$eventInclusi3 = _options$eventInclusi2.onFallback) === null || _options$eventInclusi3 === void 0 || _options$eventInclusi3.call(_options$eventInclusi2, error);
+		return fetchTxPoll(createFetchTxPollArgs({
+			txHash,
+			timeout,
+			options
+		}));
+	}
+}
+async function waitForSubscribedTxInclusionAndPoll({ txHash, timeout, options, fetchTx, fetchTxPoll, subscription }) {
+	const pollAbortController = new AbortController();
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let finishedCount = 0;
+		let eventError;
+		let pollError;
+		const rejectIfBothFailed = () => {
+			if (finishedCount < 2 || settled) return;
+			reject(pollError || eventError || new __injectivelabs_exceptions.GeneralException(/* @__PURE__ */ new Error("Tx inclusion failed")));
+		};
+		const resolveOnce = (txResponse, source) => {
+			if (settled) return;
+			settled = true;
+			if (source === "poll") {
+				subscription.close();
+				resolve(txResponse);
+				return;
+			}
+			pollAbortController.abort();
+			resolve(txResponse);
+		};
+		const rejectTerminal = (error) => {
+			if (settled) return true;
+			if (error instanceof __injectivelabs_exceptions.TransactionException) {
+				settled = true;
+				subscription.close();
+				pollAbortController.abort();
+				reject(error);
+				return true;
+			}
+			return false;
+		};
+		waitForSubscribedTxEvent({
+			txHash,
+			subscription,
+			fetchTx
+		}).then((txResponse) => resolveOnce(txResponse, "event")).catch((error) => {
+			var _options$eventInclusi4, _options$eventInclusi5;
+			if (rejectTerminal(error)) return;
+			const fallbackError = error instanceof Error ? error : new Error(String(error));
+			eventError = fallbackError;
+			finishedCount += 1;
+			options === null || options === void 0 || (_options$eventInclusi4 = options.eventInclusion) === null || _options$eventInclusi4 === void 0 || (_options$eventInclusi5 = _options$eventInclusi4.onFallback) === null || _options$eventInclusi5 === void 0 || _options$eventInclusi5.call(_options$eventInclusi4, fallbackError);
+			rejectIfBothFailed();
+		});
+		fetchTxPoll(createFetchTxPollArgs({
+			txHash,
+			timeout,
+			options,
+			abortSignal: pollAbortController.signal
+		})).then((txResponse) => resolveOnce(txResponse, "poll")).catch((error) => {
+			if (rejectTerminal(error)) return;
+			pollError = error instanceof Error ? error : new Error(String(error));
+			finishedCount += 1;
+			rejectIfBothFailed();
+		});
+	});
+}
+async function waitForSubscribedTxEvent({ txHash, fetchTx, subscription }) {
+	const eventTx = await subscription.wait();
+	if (eventTx.code !== 0) throw new __injectivelabs_exceptions.TransactionException(new Error(eventTx.rawLog), {
+		contextCode: eventTx.code,
+		contextModule: eventTx.codespace
+	});
+	return fetchTx(txHash);
+}
+
 //#endregion
 //#region src/core/tx/api/TxGrpcApi.ts
 var TxGrpcApi = class extends require_BaseGrpcConsumer.BaseGrpcConsumer {
@@ -301,16 +687,24 @@ var TxGrpcApi = class extends require_BaseGrpcConsumer.BaseGrpcConsumer {
 			});
 		}
 	}
-	async fetchTxPoll(txHash, timeout = __injectivelabs_utils.DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS) {
+	async fetchTxPoll({ txHash, abortSignal, timeout = __injectivelabs_utils.DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS, pollingInterval = __injectivelabs_utils.DEFAULT_TX_POLL_INTERVAL_MS }) {
 		const deadline = Date.now() + timeout;
 		for (let start = Date.now(); start < deadline; start = Date.now()) {
+			this.throwIfTxPollingCancelled(abortSignal);
 			try {
-				const tx = await this.fetchTxDual(txHash, deadline);
+				const tx = await this.fetchTxDual({
+					txHash,
+					deadline,
+					abortSignal
+				});
+				this.throwIfTxPollingCancelled(abortSignal);
 				if (tx) return tx;
 			} catch (e) {
+				this.throwIfTxPollingCancelled(abortSignal);
 				if (e instanceof __injectivelabs_exceptions.TransactionException) throw e;
 			}
-			const gap = __injectivelabs_utils.DEFAULT_TX_POLL_INTERVAL_MS - (Date.now() - start);
+			this.throwIfTxPollingCancelled(abortSignal);
+			const gap = pollingInterval - (Date.now() - start);
 			if (gap > 0) await (0, __injectivelabs_utils.sleep)(gap);
 		}
 		throw new __injectivelabs_exceptions.GrpcUnaryRequestException(/* @__PURE__ */ new Error(`Transaction was not included in a block before timeout of ${timeout}ms`), {
@@ -318,20 +712,57 @@ var TxGrpcApi = class extends require_BaseGrpcConsumer.BaseGrpcConsumer {
 			contextModule: "fetch-tx-poll"
 		});
 	}
-	async safeFetchTx(txHash, delay) {
+	async waitForTxInclusion({ txHash, timeout = __injectivelabs_utils.DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS, options }) {
+		const txResponse = await (await this.prepareTxInclusionWait({
+			txHash,
+			timeout,
+			options
+		})).wait();
+		if (!txResponse) throw new __injectivelabs_exceptions.GrpcUnaryRequestException(/* @__PURE__ */ new Error(`The transaction with ${txHash} is not found`), {
+			context: "TxGrpcApi",
+			contextModule: "wait-for-tx-inclusion"
+		});
+		return txResponse;
+	}
+	async prepareTxInclusionWait({ txHash, timeout = __injectivelabs_utils.DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS, options }) {
+		return prepareTxInclusionWaiter({
+			txHash,
+			timeout,
+			options,
+			fetchTx: (includedTxHash) => this.fetchTx(includedTxHash),
+			fetchTxPoll: (args) => this.fetchTxPoll(args),
+			createRequestException: (error, contextModule) => new __injectivelabs_exceptions.GrpcUnaryRequestException(error, {
+				context: "TxGrpcApi",
+				contextModule
+			})
+		});
+	}
+	async safeFetchTx({ txHash, delay, abortSignal }) {
 		if (delay) await (0, __injectivelabs_utils.sleep)(delay);
+		this.throwIfTxPollingCancelled(abortSignal);
 		return this.fetchTx(txHash).catch((e) => {
 			if (e instanceof __injectivelabs_exceptions.TransactionException) throw e;
 			return null;
 		});
 	}
-	fetchTxDual(txHash, deadline) {
+	fetchTxDual({ txHash, deadline, abortSignal }) {
 		const STAGGER = 300;
 		const timeout = Math.max(0, Math.min(__injectivelabs_utils.DEFAULT_TX_POLL_CALL_TIMEOUT_MS, deadline - Date.now()));
-		const fetches = Promise.all([this.safeFetchTx(txHash), this.safeFetchTx(txHash, STAGGER)]).then(([a, b]) => a !== null && a !== void 0 ? a : b);
+		const fetches = Promise.all([this.safeFetchTx({
+			txHash,
+			abortSignal
+		}), this.safeFetchTx({
+			txHash,
+			delay: STAGGER,
+			abortSignal
+		})]).then(([a, b]) => a !== null && a !== void 0 ? a : b);
 		fetches.catch(() => {});
 		return Promise.race([fetches, (0, __injectivelabs_utils.sleep)(timeout).then(() => null)]);
 	}
+	throwIfTxPollingCancelled(abortSignal) {
+		if (!(abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) return;
+		throw new Error("Transaction inclusion polling was cancelled");
+	}
 	async simulate(txRaw) {
 		const txRawClone = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.TxRaw.create({ ...txRaw });
 		const simulateRequest = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_service_pb.SimulateRequest.create();
@@ -361,12 +792,19 @@ var TxGrpcApi = class extends require_BaseGrpcConsumer.BaseGrpcConsumer {
 		}
 	}
 	async broadcast(txRaw, options) {
-		const mode = (options === null || options === void 0 ? void 0 : options.mode) || __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_service_pb.BroadcastMode.SYNC;
 		const timeout = (options === null || options === void 0 ? void 0 : options.timeout) || (0, __injectivelabs_utils.toBigNumber)((options === null || options === void 0 ? void 0 : options.txTimeout) || __injectivelabs_utils.DEFAULT_BLOCK_TIMEOUT_HEIGHT).times(__injectivelabs_utils.DEFAULT_BLOCK_TIME_IN_SECONDS * 1e3).toNumber();
-		const broadcastTxRequest = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_service_pb.BroadcastTxRequest.create();
-		broadcastTxRequest.txBytes = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.TxRaw.toBinary(txRaw);
-		broadcastTxRequest.mode = mode;
+		const txHash = TxClient.hash(txRaw);
+		let inclusionWaiter;
 		try {
+			inclusionWaiter = await this.prepareTxInclusionWait({
+				txHash,
+				timeout,
+				options
+			});
+			const mode = (options === null || options === void 0 ? void 0 : options.mode) || (inclusionWaiter.inclusionStrategy !== TxInclusionStrategy.Poll ? __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_service_pb.BroadcastMode.ASYNC : __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_service_pb.BroadcastMode.SYNC);
+			const broadcastTxRequest = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_service_pb.BroadcastTxRequest.create();
+			broadcastTxRequest.txBytes = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.TxRaw.toBinary(txRaw);
+			broadcastTxRequest.mode = mode;
 			const txResponse = (await this.executeGrpcCall(broadcastTxRequest, this.client.broadcastTx.bind(this.client))).txResponse;
 			if (!txResponse) throw new __injectivelabs_exceptions.GrpcUnaryRequestException(/* @__PURE__ */ new Error(`The transaction has failed to be broadcasted`), {
 				context: "TxGrpcApi.broadcast",
@@ -377,8 +815,14 @@ var TxGrpcApi = class extends require_BaseGrpcConsumer.BaseGrpcConsumer {
 				contextModule: txResponse.codespace
 			});
 			if (options === null || options === void 0 ? void 0 : options.onBroadcast) options.onBroadcast(txResponse.txhash);
-			return await this.fetchTxPoll(txResponse.txhash, timeout);
+			const result = await inclusionWaiter.wait(txResponse.txhash);
+			if (!result) throw new __injectivelabs_exceptions.GrpcUnaryRequestException(/* @__PURE__ */ new Error(`The transaction with ${txResponse.txhash} is not found`), {
+				context: "TxGrpcApi.broadcast",
+				contextModule: "wait-for-tx-inclusion"
+			});
+			return result;
 		} catch (e) {
+			inclusionWaiter === null || inclusionWaiter === void 0 || inclusionWaiter.close();
 			if (e instanceof __injectivelabs_exceptions.TransactionException) throw e;
 			if (e instanceof __injectivelabs_exceptions.GrpcUnaryRequestException) throw e;
 			throw new __injectivelabs_exceptions.TransactionException(new Error(e));
@@ -465,17 +909,20 @@ var TxRestApi = class {
 			});
 		}
 	}
-	async fetchTxPoll(txHash, timeout = __injectivelabs_utils.DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS) {
+	async fetchTxPoll({ txHash, timeout = __injectivelabs_utils.DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS, pollingInterval = __injectivelabs_utils.DEFAULT_TX_POLL_INTERVAL_MS, abortSignal }) {
 		const deadline = Date.now() + timeout;
 		for (let start = Date.now(); start < deadline; start = Date.now()) {
+			this.throwIfTxPollingCancelled(abortSignal);
 			const callTimeout = Math.max(0, Math.min(__injectivelabs_utils.DEFAULT_TX_POLL_CALL_TIMEOUT_MS, deadline - Date.now()));
 			try {
 				const txResponse = await Promise.race([this.fetchTx(txHash), (0, __injectivelabs_utils.sleep)(callTimeout).then(() => null)]);
 				if (txResponse) return txResponse;
 			} catch (e) {
+				this.throwIfTxPollingCancelled(abortSignal);
 				if (e instanceof __injectivelabs_exceptions.TransactionException) throw e;
 			}
-			const remaining = __injectivelabs_utils.DEFAULT_TX_POLL_INTERVAL_MS - (Date.now() - start);
+			this.throwIfTxPollingCancelled(abortSignal);
+			const remaining = pollingInterval - (Date.now() - start);
 			if (remaining > 0) await (0, __injectivelabs_utils.sleep)(remaining);
 		}
 		throw new __injectivelabs_exceptions.HttpRequestException(/* @__PURE__ */ new Error(`Transaction was not included in a block before timeout of ${timeout}ms`), {
@@ -483,6 +930,35 @@ var TxRestApi = class {
 			contextModule: "TxRestApi.fetch-tx-poll"
 		});
 	}
+	throwIfTxPollingCancelled(abortSignal) {
+		if (!(abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) return;
+		throw new Error("Transaction inclusion polling was cancelled");
+	}
+	async waitForTxInclusion({ txHash, timeout = __injectivelabs_utils.DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS, options }) {
+		const txResponse = await (await this.prepareTxInclusionWait({
+			txHash,
+			timeout,
+			options
+		})).wait();
+		if (!txResponse) throw new __injectivelabs_exceptions.HttpRequestException(/* @__PURE__ */ new Error(`The transaction with ${txHash} is not found`), {
+			context: "TxRestApi",
+			contextModule: "wait-for-tx-inclusion"
+		});
+		return txResponse;
+	}
+	async prepareTxInclusionWait({ txHash, timeout = __injectivelabs_utils.DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS, options }) {
+		return prepareTxInclusionWaiter({
+			txHash,
+			timeout,
+			options,
+			fetchTx: (includedTxHash) => this.fetchTx(includedTxHash),
+			fetchTxPoll: (args) => this.fetchTxPoll(args),
+			createRequestException: (error, contextModule) => new __injectivelabs_exceptions.HttpRequestException(error, {
+				context: "TxRestApi",
+				contextModule
+			})
+		});
+	}
 	async simulate(txRaw) {
 		const txRawClone = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.TxRaw.create({ ...txRaw });
 		if (txRawClone.signatures.length === 0) txRawClone.signatures = [new Uint8Array(0)];
@@ -505,8 +981,15 @@ var TxRestApi = class {
 	}
 	async broadcast(txRaw, options) {
 		const timeout = (options === null || options === void 0 ? void 0 : options.timeout) || (0, __injectivelabs_utils.toBigNumber)((options === null || options === void 0 ? void 0 : options.txTimeout) || __injectivelabs_utils.DEFAULT_BLOCK_TIMEOUT_HEIGHT).times(__injectivelabs_utils.DEFAULT_BLOCK_TIME_IN_SECONDS * 1e3).toNumber();
+		const txHash = TxClient.hash(txRaw);
+		let inclusionWaiter;
 		try {
-			const { tx_response: txResponse } = await this.broadcastTx(txRaw, BroadcastMode.Sync);
+			inclusionWaiter = await this.prepareTxInclusionWait({
+				txHash,
+				timeout,
+				options
+			});
+			const { tx_response: txResponse } = await this.broadcastTx(txRaw, inclusionWaiter.inclusionStrategy !== TxInclusionStrategy.Poll ? BroadcastMode.Async : BroadcastMode.Sync);
 			if (!txResponse) throw new __injectivelabs_exceptions.HttpRequestException(/* @__PURE__ */ new Error("The transaction has failed to be broadcasted"), {
 				context: "TxRestApi.broadcast",
 				contextModule: "broadcast"
@@ -516,8 +999,14 @@ var TxRestApi = class {
 				contextModule: txResponse.codespace
 			});
 			if (options === null || options === void 0 ? void 0 : options.onBroadcast) options.onBroadcast(txResponse.txhash);
-			return await this.fetchTxPoll(txResponse.txhash, timeout);
+			const result = await inclusionWaiter.wait(txResponse.txhash);
+			if (!result) throw new __injectivelabs_exceptions.HttpRequestException(/* @__PURE__ */ new Error(`The transaction with ${txResponse.txhash} is not found`), {
+				context: "TxRestApi.broadcast",
+				contextModule: "wait-for-tx-inclusion"
+			});
+			return result;
 		} catch (e) {
+			inclusionWaiter === null || inclusionWaiter === void 0 || inclusionWaiter.close();
 			if (e instanceof __injectivelabs_exceptions.HttpRequestException) {
 				if (e.code !== http_status_codes.StatusCodes.OK) throw e;
 			}
@@ -610,7 +1099,13 @@ var TxRestApi = class {
 //#region src/core/tx/api/utils.ts
 const waitTxBroadcasted = (txHash, options) => {
 	const timeout = (0, __injectivelabs_utils.toBigNumber)((options === null || options === void 0 ? void 0 : options.txTimeout) || __injectivelabs_utils.DEFAULT_BLOCK_TIMEOUT_HEIGHT).times(__injectivelabs_utils.DEFAULT_BLOCK_TIME_IN_SECONDS * 1e3).toNumber();
-	return options.endpoints.grpc ? new TxGrpcApi(options.endpoints.grpc).fetchTxPoll(txHash, timeout) : new TxRestApi(options.endpoints.rest).fetchTxPoll(txHash, timeout);
+	return options.endpoints.grpc ? new TxGrpcApi(options.endpoints.grpc).fetchTxPoll({
+		txHash,
+		timeout
+	}) : new TxRestApi(options.endpoints.rest).fetchTxPoll({
+		txHash,
+		timeout
+	});
 };
 
 //#endregion
@@ -641,13 +1136,6 @@ const generateArbitrarySignDoc = (message, signer) => {
 	};
 };
 
-//#endregion
-//#region src/core/tx/types/tx.ts
-const TxClientMode = {
-	gRpc: "grpc",
-	rest: "rest"
-};
-
 //#endregion
 //#region src/core/tx/broadcaster/MsgBroadcasterWithPk.ts
 /**
@@ -737,7 +1225,11 @@ var MsgBroadcasterWithPk = class {
 			chainId: evmChainId,
 			signature: `0x${require_utils.uint8ArrayToHex(signature)}`
 		});
-		return await new TxGrpcApi(endpoints.grpc).fetchTxPoll(response.txHash);
+		const timeoutInMs = (0, __injectivelabs_utils.toBigNumber)(txTimeout).times(__injectivelabs_utils.DEFAULT_BLOCK_TIME_IN_SECONDS).times(1e3).toNumber();
+		return await new TxGrpcApi(endpoints.grpc).fetchTxPoll({
+			txHash: response.txHash,
+			timeout: timeoutInMs
+		});
 	}
 	/**
 	* Broadcasting the transaction using the client
@@ -952,6 +1444,12 @@ Object.defineProperty(exports, 'TxGrpcApi', {
     return TxGrpcApi;
   }
 });
+Object.defineProperty(exports, 'TxInclusionStrategy', {
+  enumerable: true,
+  get: function () {
+    return TxInclusionStrategy;
+  }
+});
 Object.defineProperty(exports, 'TxRestApi', {
   enumerable: true,
   get: function () {
@@ -1024,6 +1522,18 @@ Object.defineProperty(exports, 'isTxNotFoundError', {
     return isTxNotFoundError;
   }
 });
+Object.defineProperty(exports, 'normalizeTendermintWebSocketEndpoint', {
+  enumerable: true,
+  get: function () {
+    return normalizeTendermintWebSocketEndpoint;
+  }
+});
+Object.defineProperty(exports, 'subscribeToTendermintTxEvent', {
+  enumerable: true,
+  get: function () {
+    return subscribeToTendermintTxEvent;
+  }
+});
 Object.defineProperty(exports, 'waitTxBroadcasted', {
   enumerable: true,
   get: function () {