@injectivelabs/wallet-core 1.20.8 → 1.20.10

package/dist/esm/broadcaster-CA8Ix8IA.js

@@ -0,0 +1,1059 @@
+import { t as _defineProperty } from "./defineProperty-D4YE9KXX.js";
+import { ChainCosmosErrorCode, GeneralException, TransactionChainErrorModule, TransactionException, UnspecifiedErrorCode, WalletException, Web3Exception, isThrownException } from "@injectivelabs/exceptions";
+import { EvmChainId } from "@injectivelabs/ts-types";
+import { PrivateKey, PublicKey } from "@injectivelabs/sdk-ts/core/accounts";
+import { base64ToUint8Array, getGasPriceBasedOnMessage, hexToBase64, hexToBuff, hexToUint8Array, ofacList, recoverTypedSignaturePubKey, safeBigIntStringify, uint8ArrayToBase64 } from "@injectivelabs/sdk-ts/utils";
+import { IndexerGrpcWeb3GwApi } from "@injectivelabs/sdk-ts/client/indexer";
+import { getNetworkEndpoints, getNetworkInfo, isMainnet, isTestnet } from "@injectivelabs/networks";
+import { ChainGrpcAuthApi, ChainGrpcTendermintApi, ChainGrpcTxFeesApi } from "@injectivelabs/sdk-ts/client/chain";
+import { DEFAULT_BLOCK_TIMEOUT_HEIGHT, DEFAULT_BLOCK_TIME_IN_SECONDS, DEFAULT_GAS_PRICE, getStdFee, sleep, toBigNumber } from "@injectivelabs/utils";
+import { Wallet, WalletDeviceType, WalletStrategyEmitterEventType, createEip712StdSignDoc, getEthereumSignerAddress, getInjectiveSignerAddress, isCosmosAminoOnlyWallet, isCosmosWallet, isEip712V2OnlyWallet, isEvmBrowserWallet } from "@injectivelabs/wallet-base";
+import { CosmosTxV1Beta1TxPb, SIGN_DIRECT, SIGN_EIP712, SIGN_EIP712_V2, TxClient, TxGrpcApi, createTransaction, createTransactionWithSigners, createTxRawEIP712, createTxRawFromSigResponse, createWeb3Extension, getAminoStdSignDoc, getEip712TypedData, getEip712TypedDataV2 } from "@injectivelabs/sdk-ts/core/tx";
+
+//#region src/utils/tx.ts
+const checkIfTxRunOutOfGas = (e) => {
+	return e instanceof TransactionException && e.contextCode === ChainCosmosErrorCode.ErrOutOfGas && e.contextModule === TransactionChainErrorModule.CosmosSdk && e.originalMessage.includes("out of gas");
+};
+
+//#endregion
+//#region src/broadcaster/MsgBroadcaster.ts
+const getEthereumWalletPubKey = async ({ pubKey, eip712TypedData, signature }) => {
+	if (pubKey) return pubKey;
+	return hexToBase64(await recoverTypedSignaturePubKey(eip712TypedData, signature));
+};
+const defaultRetriesConfig = () => ({ [`${TransactionChainErrorModule.CosmosSdk}-${ChainCosmosErrorCode.ErrMempoolIsFull}`]: {
+	retries: 0,
+	maxRetries: 10,
+	timeout: 1e3
+} });
+/**
+* This class is used to broadcast transactions
+* using the WalletStrategy as a handler
+* for the sign/broadcast flow of the transactions
+*
+* Mainly used for building UI products
+*/
+var MsgBroadcaster = class {
+	constructor(options) {
+		_defineProperty(this, "options", void 0);
+		_defineProperty(this, "walletStrategy", void 0);
+		_defineProperty(this, "endpoints", void 0);
+		_defineProperty(this, "chainId", void 0);
+		_defineProperty(this, "txTimeout", DEFAULT_BLOCK_TIMEOUT_HEIGHT);
+		_defineProperty(this, "simulateTx", true);
+		_defineProperty(this, "txTimeoutOnFeeDelegation", false);
+		_defineProperty(this, "evmChainId", void 0);
+		_defineProperty(this, "gasBufferCoefficient", 1.2);
+		_defineProperty(this, "retriesOnError", defaultRetriesConfig());
+		_defineProperty(this, "httpHeaders", void 0);
+		_defineProperty(this, "txInclusion", void 0);
+		const networkInfo = getNetworkInfo(options.network);
+		this.options = options;
+		this.simulateTx = options.simulateTx !== void 0 ? options.simulateTx : true;
+		this.txTimeout = options.txTimeout || DEFAULT_BLOCK_TIMEOUT_HEIGHT;
+		this.txTimeoutOnFeeDelegation = options.txTimeoutOnFeeDelegation !== void 0 ? options.txTimeoutOnFeeDelegation : true;
+		this.gasBufferCoefficient = options.gasBufferCoefficient || 1.2;
+		this.chainId = options.chainId || networkInfo.chainId;
+		this.evmChainId = options.evmChainId || networkInfo.evmChainId;
+		this.endpoints = options.endpoints || getNetworkEndpoints(options.network);
+		this.walletStrategy = options.walletStrategy;
+		this.httpHeaders = options.httpHeaders;
+		this.txInclusion = options.txInclusion;
+	}
+	setOptions(options) {
+		this.simulateTx = options.simulateTx || this.simulateTx;
+		this.txTimeout = options.txTimeout || this.txTimeout;
+		this.txTimeoutOnFeeDelegation = options.txTimeoutOnFeeDelegation || this.txTimeoutOnFeeDelegation;
+		this.txInclusion = options.txInclusion || this.txInclusion;
+	}
+	async getEvmChainId() {
+		const { walletStrategy } = this;
+		if (!isEvmBrowserWallet(walletStrategy.wallet)) return this.evmChainId;
+		const mainnetEvmIds = [EvmChainId.Mainnet, EvmChainId.MainnetEvm];
+		const testnetEvmIds = [EvmChainId.Sepolia, EvmChainId.TestnetEvm];
+		const devnetEvmIds = [
+			EvmChainId.Sepolia,
+			EvmChainId.DevnetEvm,
+			EvmChainId.MainnetEvm,
+			EvmChainId.TestnetEvm
+		];
+		try {
+			const chainId = await walletStrategy.getEthereumChainId();
+			if (!chainId) return this.evmChainId;
+			const evmChainId = parseInt(chainId, 16);
+			if (isNaN(evmChainId)) return this.evmChainId;
+			if (isMainnet(this.options.network) && !mainnetEvmIds.includes(evmChainId) || isTestnet(this.options.network) && !testnetEvmIds.includes(evmChainId) || !isMainnet(this.options.network) && !isTestnet(this.options.network) && !devnetEvmIds.includes(evmChainId)) throw new WalletException(/* @__PURE__ */ new Error("Your selected network is incorrect"));
+			return evmChainId;
+		} catch (e) {
+			throw new WalletException(e);
+		}
+	}
+	/**
+	* Broadcasting the transaction using the client
+	* side approach for both cosmos and ethereum native wallets
+	*
+	* @param tx
+	* @returns {string} transaction hash
+	*/
+	async broadcast(tx) {
+		const { walletStrategy } = this;
+		const txWithAddresses = {
+			...tx,
+			ethereumAddress: getEthereumSignerAddress(tx.injectiveAddress),
+			injectiveAddress: getInjectiveSignerAddress(tx.injectiveAddress)
+		};
+		if (ofacList.includes(txWithAddresses.ethereumAddress)) throw new GeneralException(/* @__PURE__ */ new Error("You cannot execute this transaction"));
+		try {
+			return isCosmosWallet(walletStrategy.wallet) ? await this.broadcastDirectSign(txWithAddresses) : isEip712V2OnlyWallet(walletStrategy.wallet) ? await this.broadcastEip712V2(txWithAddresses) : await this.broadcastEip712(txWithAddresses);
+		} catch (e) {
+			const error = e;
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionFail);
+			if (isThrownException(error)) throw error;
+			throw new TransactionException(new Error(error));
+		}
+	}
+	/**
+	* Broadcasting the transaction using the client
+	* side approach for both cosmos and ethereum native wallets
+	* Note: using EIP712_V2 for Ethereum wallets
+	*
+	* @param tx
+	* @returns {string} transaction hash
+	*/
+	async broadcastV2(tx) {
+		const { walletStrategy } = this;
+		const txWithAddresses = {
+			...tx,
+			ethereumAddress: getEthereumSignerAddress(tx.injectiveAddress),
+			injectiveAddress: getInjectiveSignerAddress(tx.injectiveAddress)
+		};
+		if (ofacList.includes(txWithAddresses.ethereumAddress)) throw new GeneralException(/* @__PURE__ */ new Error("You cannot execute this transaction"));
+		try {
+			return isCosmosWallet(walletStrategy.wallet) ? await this.broadcastDirectSign(txWithAddresses) : await this.broadcastEip712V2(txWithAddresses);
+		} catch (e) {
+			const error = e;
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionFail);
+			if (isThrownException(error)) throw error;
+			throw new TransactionException(new Error(error));
+		}
+	}
+	/**
+	* Broadcasting the transaction using the feeDelegation
+	* support approach for both cosmos and ethereum native wallets
+	*
+	* @param tx
+	* @returns {string} transaction hash
+	*/
+	async broadcastWithFeeDelegation(tx) {
+		const { walletStrategy } = this;
+		const txWithAddresses = {
+			...tx,
+			ethereumAddress: getEthereumSignerAddress(tx.injectiveAddress),
+			injectiveAddress: getInjectiveSignerAddress(tx.injectiveAddress)
+		};
+		if (ofacList.includes(txWithAddresses.ethereumAddress)) throw new GeneralException(/* @__PURE__ */ new Error("You cannot execute this transaction"));
+		try {
+			return isCosmosWallet(walletStrategy.wallet) ? await this.broadcastDirectSignWithFeeDelegation(txWithAddresses) : await this.broadcastEip712WithFeeDelegation(txWithAddresses);
+		} catch (e) {
+			const error = e;
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionFail);
+			if (isThrownException(error)) throw error;
+			throw new TransactionException(new Error(error));
+		}
+	}
+	/**
+	* Sign and broadcast a pre-built transaction whose fee payer signature
+	* is already provided (e.g. from the RFQ executor / web3-gw `prepare`
+	* endpoint). The taker is signed locally with the supplied private key.
+	*
+	* Autosign-only: the caller passes the autosign private key directly
+	* (e.g. `sharedWalletStore.autoSign.privateKey`). We don't go through
+	* `walletStrategy.signCosmosTransaction` because the PK strategy stubs
+	* that out — and going through the wallet strategy would defeat the
+	* point of autosign (no popups).
+	*
+	* @param tx Base64-encoded or raw `TxRaw` bytes returned by the prepare endpoint
+	* @param feePayerSig Hex (`0x...`) or base64 fee payer signature
+	* @param accountNumber Account number of the taker
+	* @param privateKey Taker (autosign) private key — hex, with or without `0x`
+	* @returns transaction response with txHash
+	*/
+	async broadcastWithFeePayerSig({ tx, privateKey, feePayerSig, accountNumber, txInclusion, txTimeoutInBlocks: txTimeoutInBlocksParam }) {
+		const { chainId, endpoints, walletStrategy } = this;
+		const txTimeoutInBlocks = this.resolveTimeoutInBlocks(txTimeoutInBlocksParam);
+		const pk = PrivateKey.fromHex(privateKey);
+		if (ofacList.includes(pk.toHex().toLowerCase())) throw new GeneralException(/* @__PURE__ */ new Error("You cannot execute this transaction"));
+		const txBytes = typeof tx === "string" ? base64ToUint8Array(tx) : tx;
+		const txRaw = CosmosTxV1Beta1TxPb.TxRaw.fromBinary(txBytes);
+		try {
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionPreparationStart);
+			const signDoc = CosmosTxV1Beta1TxPb.SignDoc.create({
+				chainId,
+				bodyBytes: txRaw.bodyBytes,
+				authInfoBytes: txRaw.authInfoBytes,
+				accountNumber: BigInt(accountNumber)
+			});
+			const signDocBytes = CosmosTxV1Beta1TxPb.SignDoc.toBinary(signDoc);
+			const takerSig = await pk.sign(signDocBytes);
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionPreparationEnd);
+			txRaw.signatures = [takerSig, feePayerSig.startsWith("0x") ? hexToUint8Array(feePayerSig.slice(2)) : base64ToUint8Array(feePayerSig)];
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastStart);
+			const txInclusionOptions = this.resolveTxInclusionOptions({ txInclusion });
+			const txResponse = await new TxGrpcApi(endpoints.grpc).broadcast(txRaw, {
+				txTimeout: txTimeoutInBlocks,
+				...txInclusionOptions,
+				onBroadcast: () => {
+					walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastSynced);
+				}
+			});
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+			if (txResponse.code !== 0) throw new TransactionException(/* @__PURE__ */ new Error(`Transaction failed - ${txResponse.rawLog} - ${txResponse.txHash}`), {
+				code: UnspecifiedErrorCode,
+				contextCode: txResponse.code,
+				contextModule: txResponse.codespace
+			});
+			return txResponse;
+		} catch (e) {
+			const error = e;
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionFail);
+			if (isThrownException(error)) throw error;
+			throw new TransactionException(new Error(error));
+		}
+	}
+	/**
+	* Prepare/sign/broadcast transaction using
+	* Ethereum native wallets on the client side.
+	*
+	* Note: Gas estimation not available
+	*
+	* @param tx The transaction that needs to be broadcasted
+	* @returns transaction hash
+	*/
+	async broadcastEip712(tx) {
+		var _tx$gas, _baseAccount$pubKey;
+		const { chainId, endpoints, walletStrategy } = this;
+		const txTimeoutInBlocks = this.resolveTimeoutInBlocks(tx.txTimeoutInBlocks);
+		const msgs = Array.isArray(tx.msgs) ? tx.msgs : [tx.msgs];
+		const [evmChainId, { baseAccount, latestHeight }] = await Promise.all([this.getEvmChainId(), this.fetchAccountAndBlockDetails(tx.injectiveAddress, tx.accountDetails)]);
+		if (!evmChainId) throw new GeneralException(/* @__PURE__ */ new Error("Please provide evmChainId"));
+		const timeoutHeight = toBigNumber(latestHeight.toString()).plus(txTimeoutInBlocks);
+		const txTimeoutTimeInSeconds = txTimeoutInBlocks * DEFAULT_BLOCK_TIME_IN_SECONDS;
+		const txTimeoutTimeInMilliSeconds = txTimeoutTimeInSeconds * 1e3;
+		const gas = (((_tx$gas = tx.gas) === null || _tx$gas === void 0 ? void 0 : _tx$gas.gas) || getGasPriceBasedOnMessage(msgs)).toString();
+		let stdFee = getStdFee({
+			...tx.gas,
+			gas
+		});
+		/**
+		* Account has not been created on chain
+		* and we cannot simulate the transaction
+		* to estimate the gas
+		**/
+		if (!baseAccount.pubKey) stdFee = await this.getStdFeeWithDynamicBaseFee(stdFee);
+		else {
+			const { stdFee: simulatedStdFee } = await this.getTxWithSignersAndStdFee({
+				chainId,
+				signMode: SIGN_EIP712,
+				memo: tx.memo,
+				message: msgs,
+				timeoutHeight: timeoutHeight.toNumber(),
+				signers: {
+					pubKey: baseAccount.pubKey.key,
+					accountNumber: baseAccount.accountNumber,
+					sequence: baseAccount.sequence
+				},
+				fee: stdFee
+			});
+			stdFee = simulatedStdFee;
+		}
+		/** EIP712 for signing on Ethereum wallets */
+		const eip712TypedData = getEip712TypedData({
+			msgs,
+			fee: stdFee,
+			tx: {
+				memo: tx.memo,
+				accountNumber: baseAccount.accountNumber.toString(),
+				sequence: baseAccount.sequence.toString(),
+				timeoutHeight: timeoutHeight.toFixed(),
+				chainId
+			},
+			evmChainId
+		});
+		/** Signing on Ethereum */
+		const signature = await walletStrategy.signEip712TypedData(safeBigIntStringify(eip712TypedData), tx.ethereumAddress, { txTimeout: txTimeoutTimeInSeconds });
+		const pubKeyOrSignatureDerivedPubKey = await getEthereumWalletPubKey({
+			pubKey: (_baseAccount$pubKey = baseAccount.pubKey) === null || _baseAccount$pubKey === void 0 ? void 0 : _baseAccount$pubKey.key,
+			eip712TypedData,
+			signature
+		});
+		/** Preparing the transaction for client broadcasting */
+		const { txRaw } = createTransaction({
+			message: msgs,
+			memo: tx.memo,
+			signMode: SIGN_EIP712,
+			fee: stdFee,
+			pubKey: pubKeyOrSignatureDerivedPubKey,
+			sequence: baseAccount.sequence,
+			timeoutHeight: timeoutHeight.toNumber(),
+			accountNumber: baseAccount.accountNumber,
+			chainId
+		});
+		const txRawEip712 = createTxRawEIP712(txRaw, createWeb3Extension({ evmChainId }));
+		/** Append Signatures */
+		txRawEip712.signatures = [hexToBuff(signature)];
+		const inclusionWaiter = await this.prepareTxInclusionWaiter({
+			tx,
+			txRawOrSignResponse: txRawEip712,
+			timeout: txTimeoutTimeInMilliSeconds
+		});
+		let response;
+		try {
+			response = await walletStrategy.sendTransaction(txRawEip712, {
+				chainId,
+				endpoints,
+				txTimeout: txTimeoutInBlocks,
+				txInclusion: this.resolveTxInclusionOptions(tx),
+				address: tx.injectiveAddress,
+				onBroadcast: () => {
+					walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastSynced);
+				}
+			});
+		} catch (e) {
+			inclusionWaiter.close();
+			throw e;
+		}
+		const confirmedTx = await this.waitForPreparedTxInclusion({
+			tx,
+			inclusionWaiter,
+			responseTxHash: response.txHash,
+			timeout: txTimeoutTimeInMilliSeconds
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+		return confirmedTx;
+	}
+	/**
+	* Prepare/sign/broadcast transaction using
+	* Ethereum native wallets on the client side.
+	*
+	* Note: Gas estimation not available
+	*
+	* @param tx The transaction that needs to be broadcasted
+	* @returns transaction hash
+	*/
+	async broadcastEip712V2(tx) {
+		var _tx$gas2, _baseAccount$pubKey2;
+		const { chainId, endpoints, walletStrategy } = this;
+		const txTimeoutInBlocks = this.resolveTimeoutInBlocks(tx.txTimeoutInBlocks);
+		const msgs = Array.isArray(tx.msgs) ? tx.msgs : [tx.msgs];
+		const [evmChainId, { baseAccount, latestHeight }] = await Promise.all([this.getEvmChainId(), this.fetchAccountAndBlockDetails(tx.injectiveAddress, tx.accountDetails)]);
+		if (!evmChainId) throw new GeneralException(/* @__PURE__ */ new Error("Please provide evmChainId"));
+		const timeoutHeight = toBigNumber(latestHeight).plus(txTimeoutInBlocks);
+		const txTimeoutTimeInSeconds = txTimeoutInBlocks * DEFAULT_BLOCK_TIME_IN_SECONDS;
+		const txTimeoutTimeInMilliSeconds = txTimeoutTimeInSeconds * 1e3;
+		const gas = (((_tx$gas2 = tx.gas) === null || _tx$gas2 === void 0 ? void 0 : _tx$gas2.gas) || getGasPriceBasedOnMessage(msgs)).toString();
+		let stdFee = getStdFee({
+			...tx.gas,
+			gas
+		});
+		/**
+		* Account has not been created on chain
+		* and we cannot simulate the transaction
+		* to estimate the gas
+		**/
+		if (!baseAccount.pubKey) stdFee = await this.getStdFeeWithDynamicBaseFee(stdFee);
+		else {
+			const { stdFee: simulatedStdFee } = await this.getTxWithSignersAndStdFee({
+				chainId,
+				signMode: SIGN_EIP712_V2,
+				memo: tx.memo,
+				message: msgs,
+				timeoutHeight: timeoutHeight.toNumber(),
+				signers: {
+					pubKey: baseAccount.pubKey.key,
+					sequence: baseAccount.sequence,
+					accountNumber: baseAccount.accountNumber
+				},
+				fee: stdFee
+			});
+			stdFee = simulatedStdFee;
+		}
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionPreparationStart);
+		/** EIP712 for signing on Ethereum wallets */
+		const eip712TypedData = getEip712TypedDataV2({
+			msgs,
+			fee: stdFee,
+			tx: {
+				memo: tx.memo,
+				accountNumber: baseAccount.accountNumber.toString(),
+				sequence: baseAccount.sequence.toString(),
+				timeoutHeight: timeoutHeight.toFixed(),
+				chainId
+			},
+			evmChainId
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionPreparationEnd);
+		/** Signing on Ethereum */
+		const signature = await walletStrategy.signEip712TypedData(safeBigIntStringify(eip712TypedData), tx.ethereumAddress, { txTimeout: txTimeoutTimeInSeconds });
+		const pubKeyOrSignatureDerivedPubKey = await getEthereumWalletPubKey({
+			pubKey: (_baseAccount$pubKey2 = baseAccount.pubKey) === null || _baseAccount$pubKey2 === void 0 ? void 0 : _baseAccount$pubKey2.key,
+			eip712TypedData,
+			signature
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastStart);
+		const { txRaw } = createTransaction({
+			message: msgs,
+			memo: tx.memo,
+			signMode: SIGN_EIP712_V2,
+			fee: stdFee,
+			pubKey: pubKeyOrSignatureDerivedPubKey,
+			sequence: baseAccount.sequence,
+			timeoutHeight: timeoutHeight.toNumber(),
+			accountNumber: baseAccount.accountNumber,
+			chainId
+		});
+		const txRawEip712 = createTxRawEIP712(txRaw, createWeb3Extension({ evmChainId }));
+		/** Append Signatures */
+		txRawEip712.signatures = [hexToBuff(signature)];
+		const inclusionWaiter = await this.prepareTxInclusionWaiter({
+			tx,
+			timeout: txTimeoutTimeInMilliSeconds,
+			txRawOrSignResponse: txRawEip712
+		});
+		let response;
+		try {
+			response = await walletStrategy.sendTransaction(txRawEip712, {
+				chainId,
+				endpoints,
+				txTimeout: txTimeoutInBlocks,
+				txInclusion: this.resolveTxInclusionOptions(tx),
+				address: tx.injectiveAddress,
+				onBroadcast: () => {
+					walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastSynced);
+				}
+			});
+		} catch (e) {
+			inclusionWaiter.close();
+			throw e;
+		}
+		const confirmedTx = await this.waitForPreparedTxInclusion({
+			tx,
+			inclusionWaiter,
+			responseTxHash: response.txHash,
+			timeout: txTimeoutTimeInMilliSeconds
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+		return confirmedTx;
+	}
+	/**
+	* Prepare/sign/broadcast transaction using
+	* Ethereum native wallets using the Web3Gateway.
+	*
+	* @param tx The transaction that needs to be broadcasted
+	* @returns transaction hash
+	*/
+	async broadcastEip712WithFeeDelegation(tx) {
+		const { endpoints, simulateTx, httpHeaders, walletStrategy, txTimeoutOnFeeDelegation } = this;
+		const txTimeoutInBlocks = this.resolveTimeoutInBlocks(tx.txTimeoutInBlocks);
+		const msgs = Array.isArray(tx.msgs) ? tx.msgs : [tx.msgs];
+		const web3Msgs = msgs.map((msg) => msg.toWeb3());
+		const evmChainId = await this.getEvmChainId();
+		if (!evmChainId) throw new GeneralException(/* @__PURE__ */ new Error("Please provide evmChainId"));
+		const transactionApi = new IndexerGrpcWeb3GwApi(endpoints.web3gw || endpoints.indexer);
+		if (httpHeaders) transactionApi.setMetadata(httpHeaders);
+		const txTimeoutTimeInSeconds = txTimeoutInBlocks * DEFAULT_BLOCK_TIME_IN_SECONDS;
+		const txTimeoutTimeInMilliSeconds = txTimeoutTimeInSeconds * 1e3;
+		let timeoutHeight = void 0;
+		if (txTimeoutOnFeeDelegation) timeoutHeight = toBigNumber((await new ChainGrpcTendermintApi(endpoints.grpc).fetchLatestBlock()).header.height.toString()).plus(txTimeoutInBlocks).toNumber();
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionPreparationStart);
+		const prepareTxResponse = await transactionApi.prepareTxRequest({
+			timeoutHeight,
+			memo: tx.memo,
+			message: web3Msgs,
+			address: tx.ethereumAddress,
+			chainId: evmChainId,
+			gasLimit: getGasPriceBasedOnMessage(msgs),
+			estimateGas: simulateTx
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionPreparationEnd);
+		const signature = await walletStrategy.signEip712TypedData(prepareTxResponse.data, tx.ethereumAddress, { txTimeout: txTimeoutTimeInSeconds });
+		const broadcast = async () => await transactionApi.broadcastTxRequest({
+			signature,
+			message: web3Msgs,
+			txResponse: prepareTxResponse,
+			chainId: evmChainId
+		});
+		try {
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastStart);
+			const response = await broadcast();
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastSynced);
+			const confirmedTx = await this.waitForTxInclusion({
+				tx,
+				txHash: response.txHash,
+				timeout: txTimeoutTimeInMilliSeconds
+			});
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+			return confirmedTx;
+		} catch (e) {
+			const error = e;
+			if (isThrownException(error)) {
+				const exception = error;
+				/**
+				* First MsgExec transaction with a PrivateKey wallet
+				* always runs out of gas for some reason, temporary solution
+				* to just broadcast the transaction twice
+				**/
+				if (walletStrategy.wallet === Wallet.PrivateKey && checkIfTxRunOutOfGas(exception)) {
+					const { baseAccount } = await new ChainGrpcAuthApi(endpoints.grpc).fetchAccount(tx.injectiveAddress);
+					/** We only do it on the first account tx fail */
+					if (baseAccount.sequence > 1) throw e;
+					return await this.broadcastEip712WithFeeDelegation(tx);
+				}
+				return await this.retryOnException(exception, broadcast);
+			}
+			throw e;
+		}
+	}
+	/**
+	* Prepare/sign/broadcast transaction using
+	* Cosmos native wallets on the client side.
+	*
+	* @param tx The transaction that needs to be broadcasted
+	* @returns transaction hash
+	*/
+	async broadcastDirectSign(tx) {
+		var _tx$gas3;
+		const { chainId, endpoints, walletStrategy } = this;
+		const txTimeoutInBlocks = this.resolveTimeoutInBlocks(tx.txTimeoutInBlocks);
+		const msgs = Array.isArray(tx.msgs) ? tx.msgs : [tx.msgs];
+		/**
+		* When using Ledger with Keplr/Leap we have
+		* to send EIP712 to sign on Keplr/Leap
+		*/
+		if ([Wallet.Keplr, Wallet.Leap].includes(walletStrategy.getWallet())) {
+			if (await walletStrategy.getWalletDeviceType() === WalletDeviceType.Hardware) return this.experimentalBroadcastWalletThroughLedger(tx);
+		}
+		const [{ baseAccount, latestHeight }, pubKey] = await Promise.all([this.fetchAccountAndBlockDetails(tx.injectiveAddress, tx.accountDetails), walletStrategy.getPubKey(tx.injectiveAddress)]);
+		const timeoutHeight = toBigNumber(latestHeight).plus(txTimeoutInBlocks);
+		const txTimeoutTimeInMilliSeconds = txTimeoutInBlocks * DEFAULT_BLOCK_TIME_IN_SECONDS * 1e3;
+		const signMode = isCosmosAminoOnlyWallet(walletStrategy.wallet) ? SIGN_EIP712 : SIGN_DIRECT;
+		const gas = (((_tx$gas3 = tx.gas) === null || _tx$gas3 === void 0 ? void 0 : _tx$gas3.gas) || getGasPriceBasedOnMessage(msgs)).toString();
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionPreparationStart);
+		/** Prepare the Transaction * */
+		const { txRaw } = await this.getTxWithSignersAndStdFee({
+			chainId,
+			signMode,
+			memo: tx.memo,
+			message: msgs,
+			timeoutHeight: timeoutHeight.toNumber(),
+			signers: {
+				pubKey,
+				accountNumber: baseAccount.accountNumber,
+				sequence: baseAccount.sequence
+			},
+			fee: getStdFee({
+				...tx.gas,
+				gas
+			})
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionPreparationEnd);
+		/** Ledger using Cosmos app only allows signing amino docs */
+		if (isCosmosAminoOnlyWallet(walletStrategy.wallet)) {
+			var _tx$gas4;
+			const aminoSignDoc = getAminoStdSignDoc({
+				...tx,
+				...baseAccount,
+				msgs,
+				chainId,
+				gas: gas || ((_tx$gas4 = tx.gas) === null || _tx$gas4 === void 0 || (_tx$gas4 = _tx$gas4.gas) === null || _tx$gas4 === void 0 ? void 0 : _tx$gas4.toString()),
+				timeoutHeight: timeoutHeight.toFixed()
+			});
+			txRaw.signatures = [base64ToUint8Array((await walletStrategy.signAminoCosmosTransaction({
+				signDoc: aminoSignDoc,
+				address: tx.injectiveAddress
+			})).signature.signature)];
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastStart);
+			const inclusionWaiter$1 = await this.prepareTxInclusionWaiter({
+				tx,
+				txRawOrSignResponse: txRaw,
+				timeout: txTimeoutTimeInMilliSeconds
+			});
+			let response$1;
+			try {
+				response$1 = await walletStrategy.sendTransaction(txRaw, {
+					chainId,
+					endpoints,
+					address: tx.injectiveAddress,
+					txTimeout: txTimeoutInBlocks,
+					txInclusion: this.resolveTxInclusionOptions(tx),
+					onBroadcast: () => {
+						walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastSynced);
+					}
+				});
+			} catch (e) {
+				inclusionWaiter$1.close();
+				throw e;
+			}
+			const confirmedTx$1 = await this.waitForPreparedTxInclusion({
+				tx,
+				inclusionWaiter: inclusionWaiter$1,
+				timeout: txTimeoutTimeInMilliSeconds,
+				responseTxHash: response$1.txHash
+			});
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+			return confirmedTx$1;
+		}
+		const directSignResponse = await walletStrategy.signCosmosTransaction({
+			txRaw,
+			chainId,
+			address: tx.injectiveAddress,
+			accountNumber: baseAccount.accountNumber
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastStart);
+		const inclusionWaiter = await this.prepareTxInclusionWaiter({
+			tx,
+			timeout: txTimeoutTimeInMilliSeconds,
+			txRawOrSignResponse: directSignResponse
+		});
+		let response;
+		try {
+			response = await walletStrategy.sendTransaction(directSignResponse, {
+				chainId,
+				endpoints,
+				txTimeout: txTimeoutInBlocks,
+				txInclusion: this.resolveTxInclusionOptions(tx),
+				address: tx.injectiveAddress,
+				onBroadcast: () => {
+					walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastSynced);
+				}
+			});
+		} catch (e) {
+			inclusionWaiter.close();
+			throw e;
+		}
+		const confirmedTx = await this.waitForPreparedTxInclusion({
+			tx,
+			inclusionWaiter,
+			responseTxHash: response.txHash,
+			timeout: txTimeoutTimeInMilliSeconds
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+		return confirmedTx;
+	}
+	/**
+	* We use this method only when we want to broadcast a transaction using Ledger on Keplr/Leap for Injective
+	*
+	* Note: Gas estimation not available
+	* @param tx the transaction that needs to be broadcasted
+	*/
+	async experimentalBroadcastWalletThroughLedger(tx) {
+		var _tx$gas5, _tx$gas6;
+		const { chainId, endpoints, evmChainId, simulateTx, walletStrategy } = this;
+		const txTimeoutInBlocks = this.resolveTimeoutInBlocks(tx.txTimeoutInBlocks);
+		const msgs = Array.isArray(tx.msgs) ? tx.msgs : [tx.msgs];
+		/**
+		* We can only use this method
+		* when Ledger is connected through Keplr
+		*/
+		if ([Wallet.Keplr, Wallet.Leap].includes(walletStrategy.getWallet())) {
+			if (!(await walletStrategy.getWalletDeviceType() === WalletDeviceType.Hardware)) throw new GeneralException(/* @__PURE__ */ new Error(`This method can only be used when Ledger is connected through ${walletStrategy.getWallet()}`));
+		}
+		if (!evmChainId) throw new GeneralException(/* @__PURE__ */ new Error("Please provide evmChainId"));
+		const cosmosWallet = walletStrategy.getCosmosWallet(chainId);
+		const [{ baseAccount, latestHeight }, pubKey] = await Promise.all([this.fetchAccountAndBlockDetails(tx.injectiveAddress, tx.accountDetails), walletStrategy.getPubKey()]);
+		const timeoutHeight = toBigNumber(latestHeight).plus(txTimeoutInBlocks);
+		const gas = (((_tx$gas5 = tx.gas) === null || _tx$gas5 === void 0 ? void 0 : _tx$gas5.gas) || getGasPriceBasedOnMessage(msgs)).toString();
+		/** EIP712 for signing on Ethereum wallets */
+		const eip712TypedData = getEip712TypedData({
+			msgs,
+			fee: await this.getStdFeeWithDynamicBaseFee({
+				...tx.gas,
+				gas
+			}),
+			tx: {
+				chainId,
+				memo: tx.memo,
+				timeoutHeight: timeoutHeight.toFixed(),
+				sequence: baseAccount.sequence.toString(),
+				accountNumber: baseAccount.accountNumber.toString()
+			},
+			evmChainId
+		});
+		const aminoSignResponse = await cosmosWallet.signEIP712CosmosTx({
+			eip712: eip712TypedData,
+			signDoc: createEip712StdSignDoc({
+				...tx,
+				...baseAccount,
+				msgs,
+				chainId,
+				gas: gas || ((_tx$gas6 = tx.gas) === null || _tx$gas6 === void 0 || (_tx$gas6 = _tx$gas6.gas) === null || _tx$gas6 === void 0 ? void 0 : _tx$gas6.toString()),
+				timeoutHeight: timeoutHeight.toFixed()
+			})
+		});
+		/**
+		* Create TxRaw from the signed tx that we
+		* get as a response in case the user changed the fee/memo
+		* on the Keplr popup
+		*/
+		const { txRaw } = createTransaction({
+			pubKey,
+			chainId,
+			message: msgs,
+			signMode: SIGN_EIP712,
+			memo: aminoSignResponse.signed.memo,
+			fee: aminoSignResponse.signed.fee,
+			sequence: parseInt(aminoSignResponse.signed.sequence, 10),
+			accountNumber: parseInt(aminoSignResponse.signed.account_number, 10),
+			timeoutHeight: parseInt(aminoSignResponse.signed.timeout_height, 10)
+		});
+		const txRawEip712 = createTxRawEIP712(txRaw, createWeb3Extension({ evmChainId }));
+		if (simulateTx) await this.simulateTxRaw(txRawEip712);
+		txRawEip712.signatures = [base64ToUint8Array(aminoSignResponse.signature.signature)];
+		/** Broadcast the transaction */
+		const response = await new TxGrpcApi(endpoints.grpc).broadcast(txRawEip712, {
+			txTimeout: txTimeoutInBlocks,
+			...this.resolveTxInclusionOptions(tx),
+			onBroadcast: () => {
+				walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastSynced);
+			}
+		});
+		if (response.code !== 0) throw new TransactionException(new Error(response.rawLog), {
+			code: UnspecifiedErrorCode,
+			contextCode: response.code,
+			contextModule: response.codespace
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+		return response;
+	}
+	/**
+	* Prepare/sign/broadcast transaction using
+	* Cosmos native wallets using the Web3Gateway.
+	*
+	* @param tx The transaction that needs to be broadcasted
+	* @returns transaction hash
+	*/
+	async broadcastDirectSignWithFeeDelegation(tx) {
+		var _tx$gas7;
+		const { options, chainId, endpoints, simulateTx, httpHeaders, walletStrategy, txTimeoutOnFeeDelegation } = this;
+		const txTimeoutInBlocks = this.resolveTimeoutInBlocks(tx.txTimeoutInBlocks);
+		const msgs = Array.isArray(tx.msgs) ? tx.msgs : [tx.msgs];
+		/**
+		* We can only use this method when Keplr is connected
+		* with ledger
+		*/
+		if (walletStrategy.getWallet() === Wallet.Keplr) {
+			if (await walletStrategy.getWalletDeviceType() === WalletDeviceType.Hardware) throw new GeneralException(/* @__PURE__ */ new Error("Keplr + Ledger is not available with fee delegation. Connect with Ledger directly."));
+		}
+		const cosmosWallet = walletStrategy.getCosmosWallet(chainId);
+		const canDisableCosmosGasCheck = [Wallet.Keplr, Wallet.OWallet].includes(walletStrategy.wallet);
+		const feePayerPubKey = await this.fetchFeePayerPubKey(options.feePayerPubKey);
+		const feePayerPublicKey = PublicKey.fromBase64(feePayerPubKey);
+		const feePayer = feePayerPublicKey.toAddress().address;
+		const transactionApi = new IndexerGrpcWeb3GwApi(endpoints.web3gw || endpoints.indexer);
+		if (httpHeaders) transactionApi.setMetadata(httpHeaders);
+		const fetchAccountBlockDetails = async () => {
+			try {
+				const { baseAccount: baseAccount$1, latestHeight: latestHeight$1 } = await this.fetchAccountAndBlockDetails(tx.injectiveAddress, tx.accountDetails);
+				return {
+					baseAccount: baseAccount$1,
+					latestHeight: latestHeight$1
+				};
+			} catch (e) {
+				const error = e;
+				if (isThrownException(error) && error.message.toLowerCase().includes(`account ${tx.injectiveAddress} not found`)) {
+					await transactionApi.prepareCosmosTxRequest({
+						address: tx.injectiveAddress,
+						message: msgs.map((msg) => msg.toWeb3Gw()),
+						memo: tx.memo,
+						estimateGas: simulateTx
+					});
+					const { baseAccount: baseAccount$1, latestHeight: latestHeight$1 } = await this.fetchAccountAndBlockDetails(tx.injectiveAddress);
+					return {
+						baseAccount: baseAccount$1,
+						latestHeight: latestHeight$1
+					};
+				}
+				throw e;
+			}
+		};
+		/** Account Details * */
+		const { baseAccount, latestHeight } = await fetchAccountBlockDetails();
+		const chainGrpcAuthApi = new ChainGrpcAuthApi(endpoints.grpc);
+		if (httpHeaders) chainGrpcAuthApi.setMetadata(httpHeaders);
+		const { baseAccount: feePayerBaseAccount } = await chainGrpcAuthApi.fetchAccount(feePayer);
+		const timeoutHeight = toBigNumber(latestHeight).plus(txTimeoutOnFeeDelegation ? txTimeoutInBlocks : DEFAULT_BLOCK_TIMEOUT_HEIGHT);
+		const txTimeoutTimeInMilliSeconds = txTimeoutInBlocks * DEFAULT_BLOCK_TIME_IN_SECONDS * 1e3;
+		const pubKey = await walletStrategy.getPubKey();
+		const gas = (((_tx$gas7 = tx.gas) === null || _tx$gas7 === void 0 ? void 0 : _tx$gas7.gas) || getGasPriceBasedOnMessage(msgs)).toString();
+		/** Prepare the Transaction * */
+		const { txRaw } = await this.getTxWithSignersAndStdFee({
+			chainId,
+			memo: tx.memo,
+			message: msgs,
+			timeoutHeight: timeoutHeight.toNumber(),
+			signers: [{
+				pubKey,
+				accountNumber: baseAccount.accountNumber,
+				sequence: baseAccount.sequence
+			}, {
+				pubKey: feePayerPublicKey.toBase64(),
+				accountNumber: feePayerBaseAccount.accountNumber,
+				sequence: feePayerBaseAccount.sequence
+			}],
+			fee: getStdFee({
+				...tx.gas,
+				gas,
+				payer: feePayer
+			})
+		});
+		if (canDisableCosmosGasCheck && cosmosWallet.disableGasCheck) cosmosWallet.disableGasCheck(chainId);
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionPreparationStart);
+		const directSignResponse = await walletStrategy.signCosmosTransaction({
+			txRaw,
+			chainId,
+			address: tx.injectiveAddress,
+			accountNumber: baseAccount.accountNumber
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionPreparationEnd);
+		const signedTxRaw = createTxRawFromSigResponse(directSignResponse);
+		const broadcast = async () => await transactionApi.broadcastCosmosTxRequest({
+			txRaw: signedTxRaw,
+			address: tx.injectiveAddress,
+			signature: directSignResponse.signature.signature,
+			pubKey: directSignResponse.signature.pub_key || {
+				value: pubKey,
+				type: "/injective.crypto.v1beta1.ethsecp256k1.PubKey"
+			}
+		});
+		try {
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastStart);
+			const inclusionWaiter = await this.prepareTxInclusionWaiter({
+				tx,
+				txRawOrSignResponse: signedTxRaw,
+				timeout: txTimeoutTimeInMilliSeconds
+			});
+			let response;
+			try {
+				response = await broadcast();
+			} catch (e) {
+				inclusionWaiter.close();
+				throw e;
+			}
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastSynced);
+			if (canDisableCosmosGasCheck && cosmosWallet.enableGasCheck) cosmosWallet.enableGasCheck(chainId);
+			const confirmedTx = await this.waitForPreparedTxInclusion({
+				tx,
+				inclusionWaiter,
+				responseTxHash: response.txHash,
+				timeout: txTimeoutTimeInMilliSeconds
+			});
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+			return confirmedTx;
+		} catch (e) {
+			const error = e;
+			if (isThrownException(error)) {
+				const exception = error;
+				return await this.retryOnException(exception, broadcast);
+			}
+			throw e;
+		}
+	}
+	/**
+	* Fetch the fee payer's pub key from the web3 gateway
+	*
+	* Returns a base64 version of it
+	*/
+	async fetchFeePayerPubKey(existingFeePayerPubKey) {
+		if (existingFeePayerPubKey) return existingFeePayerPubKey;
+		const { endpoints, httpHeaders } = this;
+		const transactionApi = new IndexerGrpcWeb3GwApi(endpoints.web3gw || endpoints.indexer);
+		if (httpHeaders) transactionApi.setMetadata(httpHeaders);
+		const response = await transactionApi.fetchFeePayer();
+		if (!response.feePayerPubKey) throw new GeneralException(/* @__PURE__ */ new Error("Please provide a feePayerPubKey"));
+		if (response.feePayerPubKey.key.startsWith("0x") || response.feePayerPubKey.key.length === 66) return uint8ArrayToBase64(hexToUint8Array(response.feePayerPubKey.key));
+		return response.feePayerPubKey.key;
+	}
+	async getStdFeeWithDynamicBaseFee(args) {
+		const client = new ChainGrpcTxFeesApi(this.endpoints.grpc);
+		let baseFee = DEFAULT_GAS_PRICE;
+		try {
+			const response = await client.fetchEipBaseFee();
+			baseFee = Number((response === null || response === void 0 ? void 0 : response.baseFee) || DEFAULT_GAS_PRICE);
+		} catch (_unused) {}
+		if (!args) return getStdFee(baseFee ? { gasPrice: baseFee } : {});
+		if (typeof args === "string") return getStdFee({
+			...baseFee && { gasPrice: toBigNumber(baseFee).toFixed() },
+			gas: args
+		});
+		return getStdFee({
+			...args,
+			...baseFee && { gasPrice: toBigNumber(baseFee).toFixed() }
+		});
+	}
+	/**
+	* In case we don't want to simulate the transaction
+	* we get the gas limit based on the message type.
+	*
+	* If we want to simulate the transaction we set the
+	* gas limit based on the simulation and add a small multiplier
+	* to be safe (factor of 1.2 as default)
+	*/
+	async getTxWithSignersAndStdFee(args) {
+		var _result$gasInfo;
+		const { simulateTx } = this;
+		if (!simulateTx) return {
+			...createTransactionWithSigners(args),
+			stdFee: await this.getStdFeeWithDynamicBaseFee(args.fee)
+		};
+		const result = await this.simulateTxWithSigners(args);
+		if (!((_result$gasInfo = result.gasInfo) === null || _result$gasInfo === void 0 ? void 0 : _result$gasInfo.gasUsed)) return {
+			...createTransactionWithSigners(args),
+			stdFee: await this.getStdFeeWithDynamicBaseFee(args.fee)
+		};
+		const stdGasFee = { ...await this.getStdFeeWithDynamicBaseFee({
+			...getStdFee(args.fee),
+			gas: toBigNumber(result.gasInfo.gasUsed).times(this.gasBufferCoefficient).toFixed()
+		}) };
+		return {
+			...createTransactionWithSigners({
+				...args,
+				fee: stdGasFee
+			}),
+			stdFee: stdGasFee
+		};
+	}
+	/**
+	* Create TxRaw and simulate it
+	*/
+	async simulateTxRaw(txRaw) {
+		const { endpoints, httpHeaders } = this;
+		txRaw.signatures = [new Uint8Array(0)];
+		const client = new TxGrpcApi(endpoints.grpc);
+		if (httpHeaders) client.setMetadata(httpHeaders);
+		return await client.simulate(txRaw);
+	}
+	/**
+	* Create TxRaw and simulate it
+	*/
+	async simulateTxWithSigners(args) {
+		const { endpoints, httpHeaders } = this;
+		const { txRaw } = createTransactionWithSigners(args);
+		txRaw.signatures = Array(Array.isArray(args.signers) ? args.signers.length : 1).fill(new Uint8Array(0));
+		const client = new TxGrpcApi(endpoints.grpc);
+		if (httpHeaders) client.setMetadata(httpHeaders);
+		return await client.simulate(txRaw);
+	}
+	async retryOnException(exception, retryLogic) {
+		const errorsToRetry = Object.keys(this.retriesOnError);
+		const errorKey = `${exception.contextModule}-${exception.contextCode}`;
+		if (!errorsToRetry.includes(errorKey)) throw exception;
+		const retryConfig = this.retriesOnError[errorKey];
+		if (retryConfig.retries >= retryConfig.maxRetries) {
+			this.retriesOnError = defaultRetriesConfig();
+			throw exception;
+		}
+		await sleep(retryConfig.timeout);
+		try {
+			retryConfig.retries += 1;
+			return await retryLogic();
+		} catch (e) {
+			const error = e;
+			if (isThrownException(error)) return this.retryOnException(error, retryLogic);
+			throw e;
+		}
+	}
+	async fetchAccountAndBlockDetails(address, existingAccountDetails) {
+		const { endpoints, httpHeaders } = this;
+		const tendermintClient = new ChainGrpcTendermintApi(endpoints.grpc);
+		if (httpHeaders) tendermintClient.setMetadata(httpHeaders);
+		if (existingAccountDetails) return {
+			baseAccount: existingAccountDetails,
+			latestHeight: (await tendermintClient.fetchLatestBlock()).header.height.toString()
+		};
+		const chainClient = new ChainGrpcAuthApi(endpoints.grpc);
+		if (httpHeaders) chainClient.setMetadata(httpHeaders);
+		const [accountDetails, latestBlock] = await Promise.all([chainClient.fetchAccount(address), tendermintClient.fetchLatestBlock()]);
+		const { baseAccount } = accountDetails;
+		return {
+			baseAccount,
+			latestHeight: latestBlock.header.height.toString()
+		};
+	}
+	resolveTimeoutInBlocks(override) {
+		return typeof override === "number" && Number.isInteger(override) && override > 0 ? override : this.txTimeout;
+	}
+	resolveTxInclusionOptions(tx) {
+		var _txInclusion$eventInc;
+		const txInclusion = (tx === null || tx === void 0 ? void 0 : tx.txInclusion) || this.txInclusion;
+		if (!txInclusion) return;
+		return {
+			...txInclusion,
+			eventInclusion: {
+				...txInclusion.eventInclusion,
+				rpcEndpoint: ((_txInclusion$eventInc = txInclusion.eventInclusion) === null || _txInclusion$eventInc === void 0 ? void 0 : _txInclusion$eventInc.rpcEndpoint) || this.endpoints.rpc
+			}
+		};
+	}
+	createTxGrpcApi() {
+		const client = new TxGrpcApi(this.endpoints.grpc);
+		if (this.httpHeaders) client.setMetadata(this.httpHeaders);
+		return client;
+	}
+	async waitForTxInclusion({ tx, txHash, timeout }) {
+		return this.createTxGrpcApi().waitForTxInclusion({
+			txHash,
+			timeout,
+			options: this.resolveTxInclusionOptions(tx)
+		});
+	}
+	async prepareTxInclusionWaiter({ tx, timeout, txRawOrSignResponse }) {
+		const txRaw = createTxRawFromSigResponse(txRawOrSignResponse);
+		const txHash = TxClient.hash(txRaw);
+		return this.createTxGrpcApi().prepareTxInclusionWait({
+			txHash,
+			timeout,
+			options: this.resolveTxInclusionOptions(tx)
+		});
+	}
+	async waitForPreparedTxInclusion({ tx, timeout, responseTxHash, inclusionWaiter }) {
+		if (!inclusionWaiter) return this.waitForTxInclusion({
+			tx,
+			timeout,
+			txHash: responseTxHash
+		});
+		const confirmedTx = await inclusionWaiter.wait(responseTxHash);
+		if (!confirmedTx) throw new TransactionException(/* @__PURE__ */ new Error(`The transaction with ${responseTxHash} is not found`));
+		return confirmedTx;
+	}
+};
+
+//#endregion
+//#region src/broadcaster/Web3Broadcaster.ts
+/**
+* Preparing and broadcasting
+* Ethereum transactions
+*/
+var Web3Broadcaster = class {
+	constructor({ walletStrategy, evmChainId }) {
+		_defineProperty(this, "walletStrategy", void 0);
+		_defineProperty(this, "evmChainId", void 0);
+		this.evmChainId = evmChainId;
+		this.walletStrategy = walletStrategy;
+	}
+	async sendTransaction(args) {
+		const { evmChainId, walletStrategy } = this;
+		try {
+			const chainId = args.evmChainId || evmChainId;
+			const txHash = await walletStrategy.sendEvmTransaction(args.tx, {
+				evmChainId: chainId,
+				address: args.address
+			});
+			await walletStrategy.getEvmTransactionReceipt(txHash, chainId);
+			return txHash;
+		} catch (e) {
+			throw new Web3Exception(new Error(e.message));
+		}
+	}
+};
+
+//#endregion
+export { MsgBroadcaster as n, checkIfTxRunOutOfGas as r, Web3Broadcaster as t };