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

package/dist/esm/broadcaster/MsgBroadcaster.js

@@ -1,916 +0,0 @@
-import { EvmChainId } from '@injectivelabs/ts-types';
-import { isTestnet, isMainnet, getNetworkInfo, getNetworkEndpoints, } from '@injectivelabs/networks';
-import { sleep, getStdFee, toBigNumber, DEFAULT_GAS_PRICE, DEFAULT_BLOCK_TIMEOUT_HEIGHT, DEFAULT_BLOCK_TIME_IN_SECONDS, } from '@injectivelabs/utils';
-import { WalletException, GeneralException, isThrownException, UnspecifiedErrorCode, ChainCosmosErrorCode, TransactionException, TransactionChainErrorModule, } from '@injectivelabs/exceptions';
-import { Wallet, isCosmosWallet, WalletDeviceType, isEvmBrowserWallet, isEip712V2OnlyWallet, createEip712StdSignDoc, isCosmosAminoOnlyWallet, getEthereumSignerAddress, getInjectiveSignerAddress, } from '@injectivelabs/wallet-base';
-import { TxGrpcApi, hexToBuff, PublicKey, SIGN_DIRECT, hexToBase64, ofacWallets, SIGN_EIP712, SIGN_EIP712_V2, ChainGrpcAuthApi, createTxRawEIP712, createTransaction, ChainGrpcTxFeesApi, getAminoStdSignDoc, getEip712TypedData, createWeb3Extension, getEip712TypedDataV2, IndexerGrpcWeb3GwApi, ChainGrpcTendermintApi, getGasPriceBasedOnMessage, createTxRawFromSigResponse, recoverTypedSignaturePubKey, createTransactionWithSigners, } from '@injectivelabs/sdk-ts';
-import { checkIfTxRunOutOfGas } from '../utils/index.js';
-import { WalletStrategyEmitterEventType } from './types.js';
-const getEthereumWalletPubKey = async ({ pubKey, eip712TypedData, signature, }) => {
-    if (pubKey) {
-        return pubKey;
-    }
-    const recoveredPubKey = await recoverTypedSignaturePubKey(
-    // TODO: fix type
-    eip712TypedData, signature);
-    return hexToBase64(recoveredPubKey);
-};
-const defaultRetriesConfig = () => ({
-    [`${TransactionChainErrorModule.CosmosSdk}-${ChainCosmosErrorCode.ErrMempoolIsFull}`]: {
-        retries: 0,
-        maxRetries: 10,
-        timeout: 1000,
-    },
-});
-/**
- * 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
- */
-export class MsgBroadcaster {
-    options;
-    walletStrategy;
-    endpoints;
-    chainId;
-    txTimeout = DEFAULT_BLOCK_TIMEOUT_HEIGHT;
-    simulateTx = true;
-    txTimeoutOnFeeDelegation = false;
-    evmChainId;
-    gasBufferCoefficient = 1.2;
-    retriesOnError = defaultRetriesConfig();
-    httpHeaders;
-    constructor(options) {
-        const networkInfo = getNetworkInfo(options.network);
-        this.options = options;
-        this.simulateTx =
-            options.simulateTx !== undefined ? options.simulateTx : true;
-        this.txTimeout = options.txTimeout || DEFAULT_BLOCK_TIMEOUT_HEIGHT;
-        this.txTimeoutOnFeeDelegation =
-            options.txTimeoutOnFeeDelegation !== undefined
-                ? 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(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 (ofacWallets.includes(txWithAddresses.ethereumAddress)) {
-            throw new GeneralException(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 (ofacWallets.includes(txWithAddresses.ethereumAddress)) {
-            throw new GeneralException(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 (ofacWallets.includes(txWithAddresses.ethereumAddress)) {
-            throw new GeneralException(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) {
-        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(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 * 1000;
-        const gas = (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?.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 web3Extension = createWeb3Extension({
-            evmChainId,
-        });
-        const txRawEip712 = createTxRawEIP712(txRaw, web3Extension);
-        /** 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) {
-        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(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 * 1000;
-        const gas = (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_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.pubKey?.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 web3Extension = createWeb3Extension({
-            evmChainId,
-        });
-        const txRawEip712 = createTxRawEIP712(txRaw, web3Extension);
-        /** 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(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 * 1000;
-        let timeoutHeight = undefined;
-        if (txTimeoutOnFeeDelegation) {
-            const latestBlock = await new ChainGrpcTendermintApi(endpoints.grpc).fetchLatestBlock();
-            const latestHeight = latestBlock.header.height;
-            timeoutHeight = toBigNumber(latestHeight)
-                .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)) {
-                    /** Account Details * */
-                    const accountDetails = await new ChainGrpcAuthApi(endpoints.grpc).fetchAccount(tx.injectiveAddress);
-                    const { baseAccount } = accountDetails;
-                    /** 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) {
-        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())) {
-            const walletDeviceType = await walletStrategy.getWalletDeviceType();
-            const isLedgerConnected = walletDeviceType === WalletDeviceType.Hardware;
-            if (isLedgerConnected) {
-                return this.experimentalBroadcastWalletThroughLedger(tx);
-            }
-        }
-        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 * 1000;
-        const signMode = isCosmosAminoOnlyWallet(walletStrategy.wallet)
-            ? SIGN_EIP712
-            : SIGN_DIRECT;
-        const pubKey = await walletStrategy.getPubKey(tx.injectiveAddress);
-        const gas = (tx.gas?.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)) {
-            const aminoSignDoc = getAminoStdSignDoc({
-                ...tx,
-                ...baseAccount,
-                msgs,
-                chainId,
-                gas: gas || tx.gas?.gas?.toString(),
-                timeoutHeight: timeoutHeight.toFixed(),
-            });
-            const signResponse = await walletStrategy.signAminoCosmosTransaction({
-                signDoc: aminoSignDoc,
-                address: tx.injectiveAddress,
-            });
-            txRaw.signatures = [
-                Buffer.from(signResponse.signature.signature, 'base64'),
-            ];
-            walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastStart);
-            const response = await walletStrategy.sendTransaction(txRaw, {
-                chainId,
-                endpoints,
-                address: tx.injectiveAddress,
-                txTimeout: txTimeoutInBlocks,
-            });
-            walletStrategy.emit(WalletStrategyEmitterEventType.TransactionBroadcastEnd);
-            return await new TxGrpcApi(endpoints.grpc).fetchTxPoll(response.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) {
-        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())) {
-            const walletDeviceType = await walletStrategy.getWalletDeviceType();
-            const isLedgerConnected = walletDeviceType === WalletDeviceType.Hardware;
-            if (!isLedgerConnected) {
-                throw new GeneralException(new Error(`This method can only be used when Ledger is connected through ${walletStrategy.getWallet()}`));
-            }
-        }
-        if (!evmChainId) {
-            throw new GeneralException(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.gas?.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.gas?.gas?.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,
-        });
-        /** Preparing the transaction for client broadcasting */
-        const web3Extension = createWeb3Extension({
-            evmChainId,
-        });
-        const txRawEip712 = createTxRawEIP712(txRaw, web3Extension);
-        if (simulateTx) {
-            await this.simulateTxRaw(txRawEip712);
-        }
-        /** Append Signatures */
-        const signatureBuff = Buffer.from(aminoSignResponse.signature.signature, 'base64');
-        txRawEip712.signatures = [signatureBuff];
-        /** 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) {
-        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) {
-            const walletDeviceType = await walletStrategy.getWalletDeviceType();
-            const isLedgerConnectedOnKeplr = walletDeviceType === WalletDeviceType.Hardware;
-            if (isLedgerConnectedOnKeplr) {
-                throw new GeneralException(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 feePayerAccountDetails = await chainGrpcAuthApi.fetchAccount(feePayer);
-        const { baseAccount: feePayerBaseAccount } = feePayerAccountDetails;
-        const timeoutHeight = toBigNumber(latestHeight).plus(txTimeoutOnFeeDelegation
-            ? txTimeoutInBlocks
-            : DEFAULT_BLOCK_TIMEOUT_HEIGHT);
-        const txTimeoutTimeInSeconds = txTimeoutInBlocks * DEFAULT_BLOCK_TIME_IN_SECONDS;
-        const txTimeoutTimeInMilliSeconds = txTimeoutTimeInSeconds * 1000;
-        const pubKey = await walletStrategy.getPubKey();
-        const gas = (tx.gas?.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 }),
-        });
-        // Temporary remove tx gas check because Keplr doesn't recognize 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);
-            // Re-enable tx gas check removed above
-            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(new Error('Please provide a feePayerPubKey'));
-        }
-        if (response.feePayerPubKey.key.startsWith('0x') ||
-            response.feePayerPubKey.key.length === 66) {
-            return Buffer.from(response.feePayerPubKey.key, 'hex').toString('base64');
-        }
-        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?.baseFee || DEFAULT_GAS_PRICE);
-        }
-        catch { }
-        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) {
-        const { simulateTx } = this;
-        if (!simulateTx) {
-            return {
-                ...createTransactionWithSigners(args),
-                stdFee: await this.getStdFeeWithDynamicBaseFee(args.fee),
-            };
-        }
-        const result = await this.simulateTxWithSigners(args);
-        if (!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);
-        }
-        const simulationResponse = await client.simulate(txRaw);
-        return simulationResponse;
-    }
-    /**
-     * 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);
-        }
-        const simulationResponse = await client.simulate(txRaw);
-        return simulationResponse;
-    }
-    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;
-        const latestBlock = await tendermintClient.fetchLatestBlock();
-        const latestHeight = latestBlock.header.height;
-        return {
-            baseAccount,
-            latestHeight,
-            accountDetails,
-        };
-    }
-}