@injectivelabs/wallet-core 1.20.8 → 1.20.10

package/dist/cjs/index.d.cts

@@ -1,314 +1,8 @@
-import { ConcreteStrategiesArg, ConcreteWalletStrategy, CosmosWalletAbstraction, Eip1193Provider, SendTransactionOptions, Wallet, WalletDeviceType, WalletMetadata, WalletStrategy, WalletStrategyArguments, WalletStrategyEmitter, onAccountChangeCallback, onChainIdChangeCallback } from "@injectivelabs/wallet-base";
-import { StdSignDoc } from "@keplr-wallet/types";
-import { OfflineSigner } from "@cosmjs/proto-signing";
-import { AccountAddress, ChainId, EvmChainId } from "@injectivelabs/ts-types";
-import { TxClientInclusionOptions, TxResponse } from "@injectivelabs/sdk-ts/core/tx";
-import { AminoSignResponse, DirectSignResponse, TxRaw } from "@injectivelabs/sdk-ts/types";
-import { Msgs } from "@injectivelabs/sdk-ts/core/modules";
-import { Network, NetworkEndpoints } from "@injectivelabs/networks";
-import { AuthBaseAccount } from "@injectivelabs/sdk-ts/client/chain";
+import { t as BaseWalletStrategy } from "./BaseWalletStrategy-Bvs5nQRI.cjs";
+import { a as MsgBroadcasterTxOptionsWithAddresses, i as MsgBroadcasterTxOptions, n as MsgBroadcaster, r as MsgBroadcasterOptions, t as Web3Broadcaster } from "./index-NsR1NUse.cjs";
+import "./index-DLoAMD9J.cjs";
 
 //#region src/utils/tx.d.ts
 declare const checkIfTxRunOutOfGas: (e: unknown) => boolean;
 //#endregion
-//#region src/strategy/BaseWalletStrategy.d.ts
-declare class BaseWalletStrategy implements WalletStrategy {
-  strategies: ConcreteStrategiesArg;
-  wallet: Wallet;
-  args: WalletStrategyArguments;
-  metadata?: WalletMetadata;
-  wallets?: Wallet[];
-  private emitter;
-  on: WalletStrategyEmitter['on'];
-  off: WalletStrategyEmitter['off'];
-  emit: WalletStrategyEmitter['emit'];
-  constructor(args: WalletStrategyArguments);
-  /**
-   * Get the emitter instance.
-   * Used to pass to strategies so they can emit events directly.
-   */
-  getEmitter(): WalletStrategyEmitter;
-  getWallet(): Wallet;
-  setWallet(wallet: Wallet): Promise<void>;
-  setMetadata(metadata?: WalletMetadata): void;
-  getStrategy(): ConcreteWalletStrategy;
-  getAddresses(args?: unknown): Promise<AccountAddress[]>;
-  getAddressesInfo(args?: unknown): Promise<{
-    address: string;
-    derivationPath: string;
-    baseDerivationPath: string;
-  }[]>;
-  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>;
-}
-//#endregion
-//#region src/broadcaster/types.d.ts
-interface MsgBroadcasterTxOptions {
-  memo?: string;
-  msgs: Msgs | Msgs[];
-  ethereumAddress?: string;
-  injectiveAddress?: string;
-  accountDetails?: AuthBaseAccount;
-  txTimeoutInBlocks?: number;
-  txInclusion?: TxClientInclusionOptions;
-  gas?: {
-    gasPrice?: string;
-    gas?: number; /** gas limit */
-    feePayer?: string;
-    granter?: string;
-  };
-}
-interface MsgBroadcasterTxOptionsWithAddresses extends MsgBroadcasterTxOptions {
-  ethereumAddress: string;
-  injectiveAddress: string;
-}
-interface MsgBroadcasterOptions {
-  network: Network;
-  endpoints?: NetworkEndpoints;
-  chainId?: ChainId;
-  evmChainId?: EvmChainId;
-  feePayerPubKey?: string;
-  simulateTx?: boolean;
-  txTimeoutOnFeeDelegation?: boolean;
-  txTimeout?: number;
-  txInclusion?: TxClientInclusionOptions;
-  walletStrategy: BaseWalletStrategy;
-  gasBufferCoefficient?: number;
-  httpHeaders?: Record<string, string>;
-}
-//#endregion
-//#region src/broadcaster/MsgBroadcaster.d.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
- */
-declare class MsgBroadcaster {
-  options: MsgBroadcasterOptions;
-  walletStrategy: BaseWalletStrategy;
-  endpoints: NetworkEndpoints;
-  chainId: ChainId;
-  txTimeout: number;
-  simulateTx: boolean;
-  txTimeoutOnFeeDelegation: boolean;
-  evmChainId?: EvmChainId;
-  gasBufferCoefficient: number;
-  retriesOnError: {
-    [x: string]: {
-      retries: number;
-      maxRetries: number;
-      timeout: number;
-    };
-  };
-  httpHeaders?: Record<string, string>;
-  txInclusion?: TxClientInclusionOptions;
-  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>;
-  /**
-   * Sign and broadcast a pre-built transaction whose fee payer signature
-   * is already provided (e.g. from the RFQ executor / web3-gw `prepare`
-   * endpoint). The taker is signed locally with the supplied private key.
-   *
-   * Autosign-only: the caller passes the autosign private key directly
-   * (e.g. `sharedWalletStore.autoSign.privateKey`). We don't go through
-   * `walletStrategy.signCosmosTransaction` because the PK strategy stubs
-   * that out — and going through the wallet strategy would defeat the
-   * point of autosign (no popups).
-   *
-   * @param tx Base64-encoded or raw `TxRaw` bytes returned by the prepare endpoint
-   * @param feePayerSig Hex (`0x...`) or base64 fee payer signature
-   * @param accountNumber Account number of the taker
-   * @param privateKey Taker (autosign) private key — hex, with or without `0x`
-   * @returns transaction response with txHash
-   */
-  broadcastWithFeePayerSig({
-    tx,
-    privateKey,
-    feePayerSig,
-    accountNumber,
-    txInclusion,
-    txTimeoutInBlocks: txTimeoutInBlocksParam
-  }: {
-    privateKey: string;
-    feePayerSig: string;
-    accountNumber: number;
-    tx: Uint8Array | string;
-    txInclusion?: TxClientInclusionOptions;
-    txTimeoutInBlocks?: number;
-  }): 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;
-  private resolveTimeoutInBlocks;
-  private resolveTxInclusionOptions;
-  private createTxGrpcApi;
-  private waitForTxInclusion;
-  private prepareTxInclusionWaiter;
-  private waitForPreparedTxInclusion;
-}
-//#endregion
-//#region src/broadcaster/Web3Broadcaster.d.ts
-interface SendTransactionOptions$1 {
-  tx: {
-    from: string;
-    to: string;
-    gas: string;
-    maxFeePerGas: string;
-    maxPriorityFeePerGas: string | null;
-    data: any;
-  };
-  address: string;
-  evmChainId?: EvmChainId;
-}
-/**
- * Preparing and broadcasting
- * Ethereum transactions
- */
-declare class Web3Broadcaster {
-  private walletStrategy;
-  private evmChainId;
-  constructor({
-    walletStrategy,
-    evmChainId
-  }: {
-    walletStrategy: BaseWalletStrategy;
-    evmChainId: EvmChainId;
-    network: Network;
-  });
-  sendTransaction(args: SendTransactionOptions$1): Promise<string>;
-}
-//#endregion
 export { BaseWalletStrategy, MsgBroadcaster, MsgBroadcasterOptions, MsgBroadcasterTxOptions, MsgBroadcasterTxOptionsWithAddresses, Web3Broadcaster, checkIfTxRunOutOfGas };

package/dist/cjs/strategy-D8mmr647.cjs

@@ -0,0 +1,167 @@
+const require_defineProperty = require('./defineProperty-CImP5zIM.cjs');
+let __injectivelabs_exceptions = require("@injectivelabs/exceptions");
+let eventemitter3 = require("eventemitter3");
+let __injectivelabs_wallet_base_light = require("@injectivelabs/wallet-base/light");
+
+//#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 __injectivelabs_wallet_base_light.Wallet.Metamask;
+	if (keys.includes(__injectivelabs_wallet_base_light.Wallet.Metamask) && args.evmOptions) return __injectivelabs_wallet_base_light.Wallet.Metamask;
+	if (keys.includes(__injectivelabs_wallet_base_light.Wallet.Keplr) && !args.evmOptions) return __injectivelabs_wallet_base_light.Wallet.Keplr;
+	return keys[0];
+};
+var BaseWalletStrategy = class {
+	constructor(args) {
+		require_defineProperty._defineProperty(this, "strategies", void 0);
+		require_defineProperty._defineProperty(this, "wallet", void 0);
+		require_defineProperty._defineProperty(this, "args", void 0);
+		require_defineProperty._defineProperty(this, "metadata", void 0);
+		require_defineProperty._defineProperty(this, "wallets", void 0);
+		require_defineProperty._defineProperty(this, "emitter", void 0);
+		require_defineProperty._defineProperty(this, "on", void 0);
+		require_defineProperty._defineProperty(this, "off", void 0);
+		require_defineProperty._defineProperty(this, "emit", void 0);
+		this.args = args;
+		this.strategies = args.strategies;
+		this.wallet = getInitialWallet(args);
+		this.metadata = args.metadata;
+		this.emitter = new eventemitter3.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);
+	}
+	/**
+	* Get the emitter instance.
+	* Used to pass to strategies so they can emit events directly.
+	*/
+	getEmitter() {
+		return this.emitter;
+	}
+	getWallet() {
+		return this.wallet;
+	}
+	async setWallet(wallet) {
+		var _strategy$initStrateg;
+		this.wallet = wallet;
+		const strategy = this.getStrategy();
+		await (strategy === null || strategy === void 0 || (_strategy$initStrateg = strategy.initStrategy) === null || _strategy$initStrateg === void 0 ? void 0 : _strategy$initStrateg.call(strategy));
+	}
+	setMetadata(metadata) {
+		var _this$getStrategy$set, _this$getStrategy;
+		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 __injectivelabs_exceptions.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 __injectivelabs_exceptions.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 ((0, __injectivelabs_wallet_base_light.isCosmosWallet)(this.wallet)) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error(`You can't sign Ethereum Transaction using ${this.wallet}`));
+		/** Phantom wallet needs enabling before signing */
+		if (this.wallet === __injectivelabs_wallet_base_light.Wallet.Phantom) await this.enable();
+		this.emit(__injectivelabs_wallet_base_light.WalletStrategyEmitterEventType.TransactionSignStart);
+		const response = await this.getStrategy().signEip712TypedData(eip712TypedData, address, options);
+		this.emit(__injectivelabs_wallet_base_light.WalletStrategyEmitterEventType.TransactionSigned);
+		return response;
+	}
+	async signAminoCosmosTransaction(transaction) {
+		if ((0, __injectivelabs_wallet_base_light.isEvmWallet)(this.wallet)) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error(`You can't sign Cosmos Transaction using ${this.wallet}`));
+		this.emit(__injectivelabs_wallet_base_light.WalletStrategyEmitterEventType.TransactionSignStart);
+		const response = await this.getStrategy().signAminoCosmosTransaction(transaction);
+		this.emit(__injectivelabs_wallet_base_light.WalletStrategyEmitterEventType.TransactionSigned);
+		return response;
+	}
+	async signCosmosTransaction(transaction) {
+		if ((0, __injectivelabs_wallet_base_light.isEvmWallet)(this.wallet)) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error(`You can't sign Cosmos Transaction using ${this.wallet}`));
+		this.emit(__injectivelabs_wallet_base_light.WalletStrategyEmitterEventType.TransactionSignStart);
+		const response = await this.getStrategy().signCosmosTransaction(transaction);
+		this.emit(__injectivelabs_wallet_base_light.WalletStrategyEmitterEventType.TransactionSigned);
+		return response;
+	}
+	async signArbitrary(signer, data) {
+		if (this.getStrategy().signArbitrary) {
+			this.emit(__injectivelabs_wallet_base_light.WalletStrategyEmitterEventType.TransactionSignStart);
+			const response = await this.getStrategy().signArbitrary(signer, data);
+			this.emit(__injectivelabs_wallet_base_light.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(__injectivelabs_wallet_base_light.WalletStrategyEmitterEventType.WalletStrategyDisconnect);
+		}
+	}
+	getCosmosWallet(chainId) {
+		const strategy = this.getStrategy();
+		if (strategy.getCosmosWallet == void 0) throw new __injectivelabs_exceptions.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 __injectivelabs_exceptions.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 __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("Offline signer not found. Please check your wallet strategy."));
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'BaseWalletStrategy', {
+  enumerable: true,
+  get: function () {
+    return BaseWalletStrategy;
+  }
+});

package/dist/cjs/strategy.cjs

@@ -0,0 +1,4 @@
+require('./defineProperty-CImP5zIM.cjs');
+const require_strategy = require('./strategy-D8mmr647.cjs');
+
+exports.BaseWalletStrategy = require_strategy.BaseWalletStrategy;

package/dist/cjs/strategy.d.cts

@@ -0,0 +1,3 @@
+import { t as BaseWalletStrategy } from "./BaseWalletStrategy-Bvs5nQRI.cjs";
+import "./index-DLoAMD9J.cjs";
+export { BaseWalletStrategy };

package/dist/esm/BaseWalletStrategy-D2xNJmzo.d.ts

@@ -0,0 +1,71 @@
+import { ConcreteStrategiesArg, ConcreteWalletStrategy, CosmosWalletAbstraction, Eip1193Provider, SendTransactionOptions, Wallet, WalletDeviceType, WalletMetadata, WalletStrategy, WalletStrategyArguments, WalletStrategyEmitter, onAccountChangeCallback, onChainIdChangeCallback } from "@injectivelabs/wallet-base/light";
+import { AccountAddress, ChainId, EvmChainId } from "@injectivelabs/ts-types";
+import { TxResponse } from "@injectivelabs/sdk-ts/core/tx";
+import { StdSignDoc } from "@keplr-wallet/types";
+import { OfflineSigner } from "@cosmjs/proto-signing";
+import { AminoSignResponse, DirectSignResponse, TxRaw } from "@injectivelabs/sdk-ts/types";
+
+//#region src/strategy/BaseWalletStrategy.d.ts
+
+declare class BaseWalletStrategy implements WalletStrategy {
+  strategies: ConcreteStrategiesArg;
+  wallet: Wallet;
+  args: WalletStrategyArguments;
+  metadata?: WalletMetadata;
+  wallets?: Wallet[];
+  private emitter;
+  on: WalletStrategyEmitter['on'];
+  off: WalletStrategyEmitter['off'];
+  emit: WalletStrategyEmitter['emit'];
+  constructor(args: WalletStrategyArguments);
+  /**
+   * Get the emitter instance.
+   * Used to pass to strategies so they can emit events directly.
+   */
+  getEmitter(): WalletStrategyEmitter;
+  getWallet(): Wallet;
+  setWallet(wallet: Wallet): Promise<void>;
+  setMetadata(metadata?: WalletMetadata): void;
+  getStrategy(): ConcreteWalletStrategy;
+  getAddresses(args?: unknown): Promise<AccountAddress[]>;
+  getAddressesInfo(args?: unknown): Promise<{
+    address: string;
+    derivationPath: string;
+    baseDerivationPath: string;
+  }[]>;
+  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>;
+}
+//#endregion
+export { BaseWalletStrategy as t };