@injectivelabs/wallet-core 1.16.38 → 1.16.39-alpha.1

package/dist/esm/index.js

@@ -1,3 +1,1012 @@
-export * from './broadcaster/index.js';
-export * from './strategy/index.js';
-export * from './utils/index.js';
+import { ChainCosmosErrorCode, GeneralException, TransactionChainErrorModule, TransactionException, UnspecifiedErrorCode, WalletException, Web3Exception, isThrownException } from "@injectivelabs/exceptions";
+import { EventEmitter } from "eventemitter3";
+import { Wallet, WalletDeviceType, createEip712StdSignDoc, getEthereumSignerAddress, getInjectiveSignerAddress, isCosmosAminoOnlyWallet, isCosmosWallet, isEip712V2OnlyWallet, isEvmBrowserWallet, isEvmWallet } from "@injectivelabs/wallet-base";
+import { EvmChainId } from "@injectivelabs/ts-types";
+import { base64ToUint8Array, getGasPriceBasedOnMessage, hexToBase64, hexToBuff, hexToUint8Array, ofacList, recoverTypedSignaturePubKey, uint8ArrayToBase64 } from "@injectivelabs/sdk-ts/utils";
+import { PublicKey } from "@injectivelabs/sdk-ts/core/accounts";
+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 { SIGN_DIRECT, SIGN_EIP712, SIGN_EIP712_V2, 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/types.ts
+const WalletStrategyEmitterEventType = {
+	TransactionFail: "transaction-fail",
+	TransactionSigned: "transaction-signed",
+	TransactionSignStart: "transaction-sign-start",
+	TransactionBroadcastEnd: "transaction-broadcast-end",
+	WalletStrategyDisconnect: "wallet-strategy-disconnect",
+	TransactionBroadcastStart: "transaction-broadcast-start",
+	TransactionPreparationEnd: "transaction-preparation-end",
+	TransactionPreparationStart: "transaction-preparation-start"
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/strategy/BaseWalletStrategy.ts
+const getInitialWallet = (args) => {
+	if (args.wallet) return args.wallet;
+	const keys = Object.keys(args.strategies || {});
+	if (keys.length === 0) return Wallet.Metamask;
+	if (keys.includes(Wallet.Metamask) && args.evmOptions) return Wallet.Metamask;
+	if (keys.includes(Wallet.Keplr) && !args.evmOptions) return Wallet.Keplr;
+	return keys[0];
+};
+var BaseWalletStrategy = class {
+	constructor(args) {
+		_defineProperty(this, "strategies", void 0);
+		_defineProperty(this, "wallet", void 0);
+		_defineProperty(this, "args", void 0);
+		_defineProperty(this, "metadata", void 0);
+		_defineProperty(this, "wallets", void 0);
+		_defineProperty(this, "emitter", void 0);
+		_defineProperty(this, "on", void 0);
+		_defineProperty(this, "off", void 0);
+		_defineProperty(this, "emit", void 0);
+		this.args = args;
+		this.strategies = args.strategies;
+		this.wallet = getInitialWallet(args);
+		this.metadata = args.metadata;
+		this.emitter = new EventEmitter();
+		this.on = this.emitter.on.bind(this.emitter);
+		this.off = this.emitter.off.bind(this.emitter);
+		this.emit = this.emitter.emit.bind(this.emitter);
+	}
+	getWallet() {
+		return this.wallet;
+	}
+	async setWallet(wallet) {
+		this.wallet = wallet;
+		this.getStrategy();
+	}
+	setMetadata(metadata) {
+		var _this$getStrategy$set, _this$getStrategy;
+		console.log("Setting metadata", metadata);
+		this.metadata = metadata;
+		(_this$getStrategy$set = (_this$getStrategy = this.getStrategy()).setMetadata) === null || _this$getStrategy$set === void 0 || _this$getStrategy$set.call(_this$getStrategy, metadata);
+	}
+	getStrategy() {
+		if (!this.strategies[this.wallet]) throw new GeneralException(/* @__PURE__ */ new Error(`Wallet ${this.wallet} is not enabled/available!`));
+		return this.strategies[this.wallet];
+	}
+	getAddresses(args) {
+		return this.getStrategy().getAddresses(args);
+	}
+	getAddressesInfo(args) {
+		return this.getStrategy().getAddressesInfo(args);
+	}
+	getWalletDeviceType() {
+		return this.getStrategy().getWalletDeviceType();
+	}
+	getPubKey(address) {
+		return this.getStrategy().getPubKey(address);
+	}
+	enable(args) {
+		return this.getStrategy().enable(args);
+	}
+	async enableAndGetAddresses(args) {
+		await this.getStrategy().enable(args);
+		return this.getStrategy().getAddresses(args);
+	}
+	getEthereumChainId() {
+		return this.getStrategy().getEthereumChainId();
+	}
+	async getEvmTransactionReceipt(txHash, evmChainId) {
+		return this.getStrategy().getEvmTransactionReceipt(txHash, evmChainId);
+	}
+	async getSessionOrConfirm(address) {
+		return this.getStrategy().getSessionOrConfirm(address);
+	}
+	async getWalletClient() {
+		var _this$getStrategy2;
+		if ((_this$getStrategy2 = this.getStrategy()) === null || _this$getStrategy2 === void 0 ? void 0 : _this$getStrategy2.getWalletClient) {
+			var _this$getStrategy3, _this$getStrategy3$ge;
+			const result = (_this$getStrategy3 = this.getStrategy()) === null || _this$getStrategy3 === void 0 || (_this$getStrategy3$ge = _this$getStrategy3.getWalletClient) === null || _this$getStrategy3$ge === void 0 ? void 0 : _this$getStrategy3$ge.call(_this$getStrategy3);
+			if (result) return result;
+		}
+		throw new WalletException(/* @__PURE__ */ new Error("Wallet client not found. Please check your wallet strategy."));
+	}
+	async sendTransaction(tx, options) {
+		return this.getStrategy().sendTransaction(tx, options);
+	}
+	async sendEvmTransaction(tx, options) {
+		return this.getStrategy().sendEvmTransaction(tx, options);
+	}
+	async signEip712TypedData(eip712TypedData, address, options = {}) {
+		if (isCosmosWallet(this.wallet)) throw new WalletException(/* @__PURE__ */ new Error(`You can't sign Ethereum Transaction using ${this.wallet}`));
+		/** Phantom wallet needs enabling before signing */
+		if (this.wallet === Wallet.Phantom) await this.enable();
+		this.emit(WalletStrategyEmitterEventType.TransactionSignStart);
+		const response = await this.getStrategy().signEip712TypedData(eip712TypedData, address, options);
+		this.emit(WalletStrategyEmitterEventType.TransactionSigned);
+		return response;
+	}
+	async signAminoCosmosTransaction(transaction) {
+		if (isEvmWallet(this.wallet)) throw new WalletException(/* @__PURE__ */ new Error(`You can't sign Cosmos Transaction using ${this.wallet}`));
+		this.emit(WalletStrategyEmitterEventType.TransactionSignStart);
+		const response = await this.getStrategy().signAminoCosmosTransaction(transaction);
+		this.emit(WalletStrategyEmitterEventType.TransactionSigned);
+		return response;
+	}
+	async signCosmosTransaction(transaction) {
+		if (isEvmWallet(this.wallet)) throw new WalletException(/* @__PURE__ */ new Error(`You can't sign Cosmos Transaction using ${this.wallet}`));
+		this.emit(WalletStrategyEmitterEventType.TransactionSignStart);
+		const response = await this.getStrategy().signCosmosTransaction(transaction);
+		this.emit(WalletStrategyEmitterEventType.TransactionSigned);
+		return response;
+	}
+	async signArbitrary(signer, data) {
+		if (this.getStrategy().signArbitrary) {
+			this.emit(WalletStrategyEmitterEventType.TransactionSignStart);
+			const response = await this.getStrategy().signArbitrary(signer, data);
+			this.emit(WalletStrategyEmitterEventType.TransactionSigned);
+			return response;
+		}
+	}
+	async onAccountChange(callback) {
+		if (this.getStrategy().onAccountChange) return this.getStrategy().onAccountChange(callback);
+	}
+	async onChainIdChange(callback) {
+		if (this.getStrategy().onChainIdChange) return this.getStrategy().onChainIdChange(callback);
+	}
+	async disconnect() {
+		if (this.getStrategy().disconnect) {
+			await this.getStrategy().disconnect();
+			this.emit(WalletStrategyEmitterEventType.WalletStrategyDisconnect);
+		}
+	}
+	getCosmosWallet(chainId) {
+		const strategy = this.getStrategy();
+		if (strategy.getCosmosWallet == void 0) throw new WalletException(/* @__PURE__ */ new Error(`This method is not available for ${this.getWallet()} wallet`));
+		return strategy.getCosmosWallet(chainId);
+	}
+	async getEip1193Provider() {
+		if (this.getStrategy().getEip1193Provider) return this.getStrategy().getEip1193Provider();
+		throw new WalletException(/* @__PURE__ */ new Error("EIP1193 provider not found. Please check your wallet strategy."));
+	}
+	async getOfflineSigner(chainId) {
+		if (this.getStrategy().getOfflineSigner) return this.getStrategy().getOfflineSigner(chainId);
+		throw new WalletException(/* @__PURE__ */ new Error("Offline signer not found. Please check your wallet strategy."));
+	}
+};
+
+//#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);
+		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;
+	}
+	setOptions(options) {
+		this.simulateTx = options.simulateTx || this.simulateTx;
+		this.txTimeout = options.txTimeout || this.txTimeout;
+		this.txTimeoutOnFeeDelegation = options.txTimeoutOnFeeDelegation || this.txTimeoutOnFeeDelegation;
+	}
+	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));
+		}
+	}
+	/**
+	* 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, txTimeout: txTimeoutInBlocks } = this;
+		const msgs = Array.isArray(tx.msgs) ? tx.msgs : [tx.msgs];
+		const evmChainId = await this.getEvmChainId();
+		if (!evmChainId) throw new GeneralException(/* @__PURE__ */ new Error("Please provide evmChainId"));
+		/** Account Details * */
+		const { baseAccount, latestHeight } = await this.fetchAccountAndBlockDetails(tx.injectiveAddress);
+		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(JSON.stringify(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 response = await walletStrategy.sendTransaction(txRawEip712, {
+			chainId,
+			endpoints,
+			txTimeout: txTimeoutInBlocks,
+			address: tx.injectiveAddress
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+		return await new TxGrpcApi(endpoints.grpc).fetchTxPoll(response.txHash, txTimeoutTimeInMilliSeconds);
+	}
+	/**
+	* 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, txTimeout: txTimeoutInBlocks } = this;
+		const msgs = Array.isArray(tx.msgs) ? tx.msgs : [tx.msgs];
+		const evmChainId = await this.getEvmChainId();
+		if (!evmChainId) throw new GeneralException(/* @__PURE__ */ new Error("Please provide evmChainId"));
+		/** Account Details * */
+		const { baseAccount, latestHeight } = await this.fetchAccountAndBlockDetails(tx.injectiveAddress);
+		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(JSON.stringify(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 response = await walletStrategy.sendTransaction(txRawEip712, {
+			chainId,
+			endpoints,
+			txTimeout: txTimeoutInBlocks,
+			address: tx.injectiveAddress
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+		return await new TxGrpcApi(endpoints.grpc).fetchTxPoll(response.txHash, txTimeoutTimeInMilliSeconds);
+	}
+	/**
+	* 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, txTimeout: txTimeoutInBlocks } = this;
+		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.TransactionBroadcastEnd);
+			return await new TxGrpcApi(endpoints.grpc).fetchTxPoll(response.txHash, txTimeoutTimeInMilliSeconds);
+		} 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, txTimeout: txTimeoutInBlocks } = this;
+		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 } = await this.fetchAccountAndBlockDetails(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 pubKey = await walletStrategy.getPubKey(tx.injectiveAddress);
+		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 response$1 = await walletStrategy.sendTransaction(txRaw, {
+				chainId,
+				endpoints,
+				address: tx.injectiveAddress,
+				txTimeout: txTimeoutInBlocks
+			});
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+			return await new TxGrpcApi(endpoints.grpc).fetchTxPoll(response$1.txHash, txTimeoutTimeInMilliSeconds);
+		}
+		const directSignResponse = await walletStrategy.signCosmosTransaction({
+			txRaw,
+			chainId,
+			address: tx.injectiveAddress,
+			accountNumber: baseAccount.accountNumber
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastStart);
+		const response = await walletStrategy.sendTransaction(directSignResponse, {
+			chainId,
+			endpoints,
+			txTimeout: txTimeoutInBlocks,
+			address: tx.injectiveAddress
+		});
+		walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+		return await new TxGrpcApi(endpoints.grpc).fetchTxPoll(response.txHash, txTimeoutTimeInMilliSeconds);
+	}
+	/**
+	* 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, txTimeout: txTimeoutInBlocks } = this;
+		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 } = await this.fetchAccountAndBlockDetails(tx.injectiveAddress);
+		const timeoutHeight = toBigNumber(latestHeight).plus(txTimeoutInBlocks);
+		const pubKey = await walletStrategy.getPubKey();
+		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,
+			message: msgs,
+			memo: aminoSignResponse.signed.memo,
+			signMode: SIGN_EIP712,
+			fee: aminoSignResponse.signed.fee,
+			sequence: parseInt(aminoSignResponse.signed.sequence, 10),
+			timeoutHeight: parseInt(aminoSignResponse.signed.timeout_height, 10),
+			accountNumber: parseInt(aminoSignResponse.signed.account_number, 10),
+			chainId
+		});
+		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 });
+		if (response.code !== 0) throw new TransactionException(new Error(response.rawLog), {
+			code: UnspecifiedErrorCode,
+			contextCode: response.code,
+			contextModule: response.codespace
+		});
+		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, httpHeaders, walletStrategy, txTimeoutOnFeeDelegation, txTimeout: txTimeoutInBlocks } = this;
+		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;
+		/** Account Details * */
+		const { baseAccount, latestHeight } = await this.fetchAccountAndBlockDetails(tx.injectiveAddress);
+		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 transactionApi = new IndexerGrpcWeb3GwApi(endpoints.web3gw || endpoints.indexer);
+		if (httpHeaders) transactionApi.setMetadata(httpHeaders);
+		const broadcast = async () => await transactionApi.broadcastCosmosTxRequest({
+			address: tx.injectiveAddress,
+			txRaw: createTxRawFromSigResponse(directSignResponse),
+			signature: directSignResponse.signature.signature,
+			pubKey: directSignResponse.signature.pub_key || {
+				value: pubKey,
+				type: "/injective.crypto.v1beta1.ethsecp256k1.PubKey"
+			}
+		});
+		try {
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastStart);
+			const response = await broadcast();
+			walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
+			if (canDisableCosmosGasCheck && cosmosWallet.enableGasCheck) cosmosWallet.enableGasCheck(chainId);
+			return await new TxGrpcApi(endpoints.grpc).fetchTxPoll(response.txHash, txTimeoutTimeInMilliSeconds);
+		} 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) {
+		const { endpoints, httpHeaders } = this;
+		const chainClient = new ChainGrpcAuthApi(endpoints.grpc);
+		const tendermintClient = new ChainGrpcTendermintApi(endpoints.grpc);
+		if (httpHeaders) {
+			chainClient.setMetadata(httpHeaders);
+			tendermintClient.setMetadata(httpHeaders);
+		}
+		const accountDetails = await chainClient.fetchAccount(address);
+		const { baseAccount } = accountDetails;
+		return {
+			baseAccount,
+			latestHeight: (await tendermintClient.fetchLatestBlock()).header.height.toString(),
+			accountDetails
+		};
+	}
+};
+
+//#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 { BaseWalletStrategy, MsgBroadcaster, WalletStrategyEmitterEventType, Web3Broadcaster, checkIfTxRunOutOfGas };