@injectivelabs/wallet-core 1.16.25-alpha.1 → 1.16.26

package/dist/cjs/broadcaster/Web3Broadcaster.d.ts

@@ -0,0 +1,30 @@
+import type { Network } from '@injectivelabs/networks';
+import type { EvmChainId } from '@injectivelabs/ts-types';
+import type BaseWalletStrategy from '../strategy/BaseWalletStrategy.js';
+interface SendTransactionOptions {
+    tx: {
+        from: string;
+        to: string;
+        gas: string;
+        maxFeePerGas: string;
+        maxPriorityFeePerGas: string | null;
+        data: any;
+    };
+    address: string;
+    evmChainId?: EvmChainId;
+}
+/**
+ * Preparing and broadcasting
+ * Ethereum transactions
+ */
+export declare class Web3Broadcaster {
+    private walletStrategy;
+    private evmChainId;
+    constructor({ walletStrategy, evmChainId, }: {
+        walletStrategy: BaseWalletStrategy;
+        evmChainId: EvmChainId;
+        network: Network;
+    });
+    sendTransaction(args: SendTransactionOptions): Promise<string>;
+}
+export {};

package/dist/cjs/broadcaster/Web3Broadcaster.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Web3Broadcaster = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+/**
+ * Preparing and broadcasting
+ * Ethereum transactions
+ */
+class Web3Broadcaster {
+    walletStrategy;
+    evmChainId;
+    constructor({ walletStrategy, evmChainId, }) {
+        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 exceptions_1.Web3Exception(new Error(e.message));
+        }
+    }
+}
+exports.Web3Broadcaster = Web3Broadcaster;

package/dist/cjs/broadcaster/index.d.ts

@@ -0,0 +1,3 @@
+export * from './MsgBroadcaster.js';
+export * from './Web3Broadcaster.js';
+export * from './types.js';

package/dist/cjs/broadcaster/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MsgBroadcaster.js"), exports);
+__exportStar(require("./Web3Broadcaster.js"), exports);
+__exportStar(require("./types.js"), exports);

package/dist/cjs/broadcaster/types.d.ts

@@ -0,0 +1,56 @@
+import type { EventEmitter } from 'eventemitter3';
+import type { Msgs } from '@injectivelabs/sdk-ts';
+import type { ChainId, EvmChainId } from '@injectivelabs/ts-types';
+import type BaseWalletStrategy from '../strategy/BaseWalletStrategy.js';
+import type { Network, NetworkEndpoints } from '@injectivelabs/networks';
+export interface MsgBroadcasterTxOptions {
+    memo?: string;
+    ethereumAddress?: string;
+    injectiveAddress?: string;
+    msgs: Msgs | Msgs[];
+    gas?: {
+        gasPrice?: string;
+        gas?: number; /** gas limit */
+        feePayer?: string;
+        granter?: string;
+    };
+}
+export interface MsgBroadcasterTxOptionsWithAddresses extends MsgBroadcasterTxOptions {
+    ethereumAddress: string;
+    injectiveAddress: string;
+}
+export interface MsgBroadcasterOptions {
+    network: Network;
+    endpoints?: NetworkEndpoints;
+    chainId?: ChainId;
+    evmChainId?: EvmChainId;
+    feePayerPubKey?: string;
+    simulateTx?: boolean;
+    txTimeoutOnFeeDelegation?: boolean;
+    txTimeout?: number;
+    walletStrategy: BaseWalletStrategy;
+    gasBufferCoefficient?: number;
+    httpHeaders?: Record<string, string>;
+}
+export declare const WalletStrategyEmitterEventType: {
+    readonly TransactionFail: "transaction-fail";
+    readonly TransactionSigned: "transaction-signed";
+    readonly TransactionSignStart: "transaction-sign-start";
+    readonly TransactionBroadcastEnd: "transaction-broadcast-end";
+    readonly WalletStrategyDisconnect: "wallet-strategy-disconnect";
+    readonly TransactionBroadcastStart: "transaction-broadcast-start";
+    readonly TransactionPreparationEnd: "transaction-preparation-end";
+    readonly TransactionPreparationStart: "transaction-preparation-start";
+};
+export type WalletStrategyEmitterEventType = (typeof WalletStrategyEmitterEventType)[keyof typeof WalletStrategyEmitterEventType];
+export type WalletStrategyEmitterEvents = {
+    [WalletStrategyEmitterEventType.TransactionFail]: Record<string, any>;
+    [WalletStrategyEmitterEventType.TransactionSigned]: Record<string, any>;
+    [WalletStrategyEmitterEventType.TransactionSignStart]: Record<string, any>;
+    [WalletStrategyEmitterEventType.TransactionBroadcastEnd]: Record<string, any>;
+    [WalletStrategyEmitterEventType.WalletStrategyDisconnect]: Record<string, any>;
+    [WalletStrategyEmitterEventType.TransactionBroadcastStart]: Record<string, any>;
+    [WalletStrategyEmitterEventType.TransactionPreparationEnd]: Record<string, any>;
+    [WalletStrategyEmitterEventType.TransactionPreparationStart]: Record<string, any>;
+};
+export type WalletStrategyEmitter = EventEmitter<WalletStrategyEmitterEvents>;

package/dist/cjs/broadcaster/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletStrategyEmitterEventType = void 0;
+exports.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',
+};

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './broadcaster/index.js';
+export * from './strategy/index.js';
+export * from './utils/index.js';

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./broadcaster/index.js"), exports);
+__exportStar(require("./strategy/index.js"), exports);
+__exportStar(require("./utils/index.js"), exports);

package/dist/cjs/package.json

@@ -1,3 +1,3 @@
 {
-  "type": "commonjs"
-}
+    "type": "commonjs"
+}

package/dist/cjs/strategy/BaseWalletStrategy.d.ts

@@ -0,0 +1,58 @@
+import { Wallet, type WalletMetadata } from '@injectivelabs/wallet-base';
+import type { StdSignDoc } from '@keplr-wallet/types';
+import type { OfflineSigner } from '@cosmjs/proto-signing';
+import type { AccountAddress } from '@injectivelabs/ts-types';
+import type { ChainId, EvmChainId } from '@injectivelabs/ts-types';
+import type { WalletStrategyEmitter } from '../broadcaster/types.js';
+import type { TxRaw, TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
+import type { Eip1193Provider, WalletDeviceType, ConcreteStrategiesArg, SendTransactionOptions, ConcreteWalletStrategy, onAccountChangeCallback, onChainIdChangeCallback, WalletStrategyArguments, CosmosWalletAbstraction, WalletStrategy as WalletStrategyInterface } from '@injectivelabs/wallet-base';
+export default class BaseWalletStrategy implements WalletStrategyInterface {
+    strategies: ConcreteStrategiesArg;
+    wallet: Wallet;
+    args: WalletStrategyArguments;
+    metadata?: WalletMetadata;
+    wallets?: Wallet[];
+    private emitter;
+    on: WalletStrategyEmitter['on'];
+    off: WalletStrategyEmitter['off'];
+    emit: WalletStrategyEmitter['emit'];
+    constructor(args: WalletStrategyArguments);
+    getWallet(): Wallet;
+    setWallet(wallet: Wallet): void;
+    setMetadata(metadata?: WalletMetadata): void;
+    getStrategy(): ConcreteWalletStrategy;
+    getAddresses(args?: unknown): Promise<AccountAddress[]>;
+    getWalletDeviceType(): Promise<WalletDeviceType>;
+    getPubKey(address?: string): Promise<string>;
+    enable(args?: unknown): Promise<boolean>;
+    enableAndGetAddresses(args?: unknown): Promise<AccountAddress[]>;
+    getEthereumChainId(): Promise<string>;
+    getEvmTransactionReceipt(txHash: string, evmChainId?: EvmChainId): Promise<void>;
+    getSessionOrConfirm(address?: AccountAddress): Promise<string>;
+    getWalletClient<T>(): Promise<T>;
+    sendTransaction(tx: DirectSignResponse | TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+    sendEvmTransaction(tx: any, options: {
+        evmChainId: EvmChainId;
+        address: AccountAddress;
+    }): Promise<string>;
+    signEip712TypedData(eip712TypedData: string, address: AccountAddress, options?: {
+        txTimeout?: number;
+    }): Promise<string>;
+    signAminoCosmosTransaction(transaction: {
+        signDoc: StdSignDoc;
+        address: string;
+    }): Promise<AminoSignResponse>;
+    signCosmosTransaction(transaction: {
+        txRaw: TxRaw;
+        accountNumber: number;
+        chainId: string;
+        address: string;
+    }): Promise<DirectSignResponse>;
+    signArbitrary(signer: string, data: string | Uint8Array): Promise<string | void>;
+    onAccountChange(callback: onAccountChangeCallback): Promise<void>;
+    onChainIdChange(callback: onChainIdChangeCallback): Promise<void>;
+    disconnect(): Promise<void>;
+    getCosmosWallet(chainId: ChainId): CosmosWalletAbstraction;
+    getEip1193Provider(): Promise<Eip1193Provider>;
+    getOfflineSigner(chainId: string): Promise<OfflineSigner>;
+}

package/dist/cjs/strategy/BaseWalletStrategy.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const eventemitter3_1 = require("eventemitter3");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const types_js_1 = require("../broadcaster/types.js");
+const getInitialWallet = (args) => {
+    if (args.wallet) {
+        return args.wallet;
+    }
+    const keys = Object.keys(args.strategies || {});
+    if (keys.length === 0) {
+        return wallet_base_1.Wallet.Metamask;
+    }
+    if (keys.includes(wallet_base_1.Wallet.Metamask) && args.evmOptions) {
+        return wallet_base_1.Wallet.Metamask;
+    }
+    if (keys.includes(wallet_base_1.Wallet.Keplr) && !args.evmOptions) {
+        return wallet_base_1.Wallet.Keplr;
+    }
+    return keys[0];
+};
+class BaseWalletStrategy {
+    strategies;
+    wallet;
+    args;
+    metadata;
+    wallets;
+    emitter;
+    on;
+    off;
+    emit;
+    constructor(args) {
+        this.args = args;
+        this.strategies = args.strategies;
+        this.wallet = getInitialWallet(args);
+        this.metadata = args.metadata;
+        this.emitter = new eventemitter3_1.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;
+    }
+    setWallet(wallet) {
+        this.wallet = wallet;
+        this.getStrategy();
+    }
+    setMetadata(metadata) {
+        console.log('Setting metadata', metadata);
+        this.metadata = metadata;
+        this.getStrategy().setMetadata?.(metadata);
+    }
+    getStrategy() {
+        if (!this.strategies[this.wallet]) {
+            throw new exceptions_1.GeneralException(new Error(`Wallet ${this.wallet} is not enabled/available!`));
+        }
+        return this.strategies[this.wallet];
+    }
+    getAddresses(args) {
+        return this.getStrategy().getAddresses(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() {
+        if (this.getStrategy()?.getWalletClient) {
+            const result = (this.getStrategy()?.getWalletClient)?.();
+            if (result) {
+                return result;
+            }
+        }
+        throw new exceptions_1.WalletException(new Error('Wallet client not found. Please check your wallet strategy.'));
+    }
+    async sendTransaction(tx, options) {
+        return this.getStrategy().sendTransaction(tx, options);
+    }
+    async sendEvmTransaction(tx /* TODO */, options) {
+        return this.getStrategy().sendEvmTransaction(tx, options);
+    }
+    async signEip712TypedData(eip712TypedData, address, options = {}) {
+        if ((0, wallet_base_1.isCosmosWallet)(this.wallet)) {
+            throw new exceptions_1.WalletException(new Error(`You can't sign Ethereum Transaction using ${this.wallet}`));
+        }
+        /** Phantom wallet needs enabling before signing */
+        if (this.wallet === wallet_base_1.Wallet.Phantom) {
+            await this.enable();
+        }
+        this.emit(types_js_1.WalletStrategyEmitterEventType.TransactionSignStart);
+        const response = await this.getStrategy().signEip712TypedData(eip712TypedData, address, options);
+        this.emit(types_js_1.WalletStrategyEmitterEventType.TransactionSigned);
+        return response;
+    }
+    async signAminoCosmosTransaction(transaction) {
+        if ((0, wallet_base_1.isEvmWallet)(this.wallet)) {
+            throw new exceptions_1.WalletException(new Error(`You can't sign Cosmos Transaction using ${this.wallet}`));
+        }
+        this.emit(types_js_1.WalletStrategyEmitterEventType.TransactionSignStart);
+        const response = await this.getStrategy().signAminoCosmosTransaction(transaction);
+        this.emit(types_js_1.WalletStrategyEmitterEventType.TransactionSigned);
+        return response;
+    }
+    async signCosmosTransaction(transaction) {
+        if ((0, wallet_base_1.isEvmWallet)(this.wallet)) {
+            throw new exceptions_1.WalletException(new Error(`You can't sign Cosmos Transaction using ${this.wallet}`));
+        }
+        this.emit(types_js_1.WalletStrategyEmitterEventType.TransactionSignStart);
+        const response = await this.getStrategy().signCosmosTransaction(transaction);
+        this.emit(types_js_1.WalletStrategyEmitterEventType.TransactionSigned);
+        return response;
+    }
+    async signArbitrary(signer, data) {
+        if (this.getStrategy().signArbitrary) {
+            this.emit(types_js_1.WalletStrategyEmitterEventType.TransactionSignStart);
+            const response = await this.getStrategy().signArbitrary(signer, data);
+            this.emit(types_js_1.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(types_js_1.WalletStrategyEmitterEventType.WalletStrategyDisconnect);
+        }
+    }
+    getCosmosWallet(chainId) {
+        const strategy = this.getStrategy();
+        if (strategy.getCosmosWallet == undefined) {
+            throw new exceptions_1.WalletException(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 exceptions_1.WalletException(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 exceptions_1.WalletException(new Error('Offline signer not found. Please check your wallet strategy.'));
+    }
+}
+exports.default = BaseWalletStrategy;

package/dist/cjs/strategy/index.d.ts

@@ -0,0 +1,2 @@
+import BaseWalletStrategy from './BaseWalletStrategy.js';
+export { BaseWalletStrategy };

package/dist/cjs/strategy/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseWalletStrategy = void 0;
+const BaseWalletStrategy_js_1 = __importDefault(require("./BaseWalletStrategy.js"));
+exports.BaseWalletStrategy = BaseWalletStrategy_js_1.default;

package/dist/cjs/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './tx.js';

package/dist/cjs/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tx.js"), exports);

package/dist/cjs/utils/tx.d.ts

@@ -0,0 +1 @@
+export declare const checkIfTxRunOutOfGas: (e: unknown) => boolean;

package/dist/cjs/utils/tx.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIfTxRunOutOfGas = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+const checkIfTxRunOutOfGas = (e) => {
+    return (e instanceof exceptions_1.TransactionException &&
+        e.contextCode === exceptions_1.ChainCosmosErrorCode.ErrOutOfGas &&
+        e.contextModule === exceptions_1.TransactionChainErrorModule.CosmosSdk &&
+        e.originalMessage.includes('out of gas'));
+};
+exports.checkIfTxRunOutOfGas = checkIfTxRunOutOfGas;

package/dist/esm/broadcaster/MsgBroadcaster.d.ts

@@ -0,0 +1,137 @@
+import { EvmChainId } from '@injectivelabs/ts-types';
+import type { NetworkEndpoints } from '@injectivelabs/networks';
+import type BaseWalletStrategy from '../strategy/BaseWalletStrategy.js';
+import type { ChainId as ChainIdType, EvmChainId as EvmChainIdType } from '@injectivelabs/ts-types';
+import type { MsgBroadcasterOptions, MsgBroadcasterTxOptions } from './types.js';
+import type { TxResponse } from '@injectivelabs/sdk-ts';
+/**
+ * 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 declare class MsgBroadcaster {
+    options: MsgBroadcasterOptions;
+    walletStrategy: BaseWalletStrategy;
+    endpoints: NetworkEndpoints;
+    chainId: ChainIdType;
+    txTimeout: number;
+    simulateTx: boolean;
+    txTimeoutOnFeeDelegation: boolean;
+    evmChainId?: EvmChainIdType;
+    gasBufferCoefficient: number;
+    retriesOnError: {
+        [x: string]: {
+            retries: number;
+            maxRetries: number;
+            timeout: number;
+        };
+    };
+    httpHeaders?: Record<string, string>;
+    constructor(options: MsgBroadcasterOptions);
+    setOptions(options: Partial<MsgBroadcasterOptions>): void;
+    getEvmChainId(): Promise<EvmChainId | undefined>;
+    /**
+     * Broadcasting the transaction using the client
+     * side approach for both cosmos and ethereum native wallets
+     *
+     * @param tx
+     * @returns {string} transaction hash
+     */
+    broadcast(tx: MsgBroadcasterTxOptions): Promise<TxResponse>;
+    /**
+     * 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
+     */
+    broadcastV2(tx: MsgBroadcasterTxOptions): Promise<TxResponse>;
+    /**
+     * Broadcasting the transaction using the feeDelegation
+     * support approach for both cosmos and ethereum native wallets
+     *
+     * @param tx
+     * @returns {string} transaction hash
+     */
+    broadcastWithFeeDelegation(tx: MsgBroadcasterTxOptions): Promise<TxResponse>;
+    /**
+     * 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
+     */
+    private broadcastEip712;
+    /**
+     * 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
+     */
+    private broadcastEip712V2;
+    /**
+     * Prepare/sign/broadcast transaction using
+     * Ethereum native wallets using the Web3Gateway.
+     *
+     * @param tx The transaction that needs to be broadcasted
+     * @returns transaction hash
+     */
+    private broadcastEip712WithFeeDelegation;
+    /**
+     * Prepare/sign/broadcast transaction using
+     * Cosmos native wallets on the client side.
+     *
+     * @param tx The transaction that needs to be broadcasted
+     * @returns transaction hash
+     */
+    private broadcastDirectSign;
+    /**
+     * 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
+     */
+    private experimentalBroadcastWalletThroughLedger;
+    /**
+     * Prepare/sign/broadcast transaction using
+     * Cosmos native wallets using the Web3Gateway.
+     *
+     * @param tx The transaction that needs to be broadcasted
+     * @returns transaction hash
+     */
+    private broadcastDirectSignWithFeeDelegation;
+    /**
+     * Fetch the fee payer's pub key from the web3 gateway
+     *
+     * Returns a base64 version of it
+     */
+    private fetchFeePayerPubKey;
+    private getStdFeeWithDynamicBaseFee;
+    /**
+     * 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)
+     */
+    private getTxWithSignersAndStdFee;
+    /**
+     * Create TxRaw and simulate it
+     */
+    private simulateTxRaw;
+    /**
+     * Create TxRaw and simulate it
+     */
+    private simulateTxWithSigners;
+    private retryOnException;
+    private fetchAccountAndBlockDetails;
+}