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

package/dist/esm/index.d.ts

@@ -1,3 +1,139 @@
-export { CosmosWallet } from './wallet.js';
-export { CosmosWalletStrategy } from './strategy/strategy.js';
-export * from './utils/index.js';
+import { BaseConcreteStrategy, ConcreteWalletStrategy, SendTransactionOptions, StdSignDoc, Wallet, WalletDeviceType } from "@injectivelabs/wallet-base";
+import * as _cosmjs_stargate0 from "@cosmjs/stargate";
+import { StdFee } from "@cosmjs/stargate";
+import { CosmosTxV1Beta1TxPb } from "@injectivelabs/sdk-ts";
+import { TxResponse } from "@injectivelabs/sdk-ts/core/tx";
+import { AccountAddress, ChainId, CosmosChainId, EvmChainId, TestnetCosmosChainId } from "@injectivelabs/ts-types";
+import * as _keplr_wallet_types0 from "@keplr-wallet/types";
+import { AminoSignResponse, Keplr, OfflineAminoSigner, StdSignDoc as StdSignDoc$1 } from "@keplr-wallet/types";
+import { EncodeObject, OfflineSigner } from "@cosmjs/proto-signing";
+import { AminoSignResponse as AminoSignResponse$1, DirectSignResponse, TxRaw } from "@injectivelabs/sdk-ts/types";
+
+//#region src/utils/index.d.ts
+declare const isCosmosWalletInstalled: (wallet: Wallet) => boolean;
+declare const confirmCosmosAddress: ({
+  wallet,
+  chainId,
+  injectiveAddress
+}: {
+  wallet: Wallet;
+  chainId: ChainId;
+  injectiveAddress: string;
+}) => Promise<void>;
+//#endregion
+//#region src/wallet.d.ts
+declare class CosmosWallet {
+  wallet: Wallet;
+  private chainId;
+  constructor({
+    wallet,
+    chainId
+  }: {
+    wallet: Wallet;
+    chainId: CosmosChainId | TestnetCosmosChainId | ChainId;
+  });
+  isChainIdSupported(chainId: CosmosChainId): Promise<boolean>;
+  getCosmosWallet(): Promise<Keplr>;
+  chainNotSupported(): Promise<void>;
+  getAccounts(): Promise<readonly _keplr_wallet_types0.AccountData[]>;
+  getKey(): Promise<{
+    name: string;
+    algo: string;
+    isNanoLedger: boolean;
+    pubKey: Uint8Array;
+    address: Uint8Array;
+    bech32Address: string;
+  }>;
+  getOfflineSigner(chainId?: string): Promise<OfflineSigner>;
+  getOfflineAminoSigner(): Promise<OfflineAminoSigner>;
+  /**
+   * This method is used to broadcast a transaction to the network.
+   * Since it uses the `Sync` mode, it will not wait for the transaction to be included in a block,
+   * so we have to make sure the transaction is included in a block after its broadcasted
+   *
+   * @param txRaw - raw transaction to broadcast
+   * @returns tx hash
+   */
+  broadcastTx(txRaw: CosmosTxV1Beta1TxPb.TxRaw): Promise<string>;
+  /**
+   * This method is used to broadcast a transaction to the network.
+   * Since it uses the `Block` mode, and it will wait for the transaction to be included in a block,
+   *
+   * @param txRaw - raw transaction to broadcast
+   * @returns tx hash
+   */
+  broadcastTxBlock(txRaw: CosmosTxV1Beta1TxPb.TxRaw): Promise<string>;
+  signAndBroadcastAminoUsingCosmjs(messages: EncodeObject[], stdFee: StdFee, endpoints: {
+    rest: string;
+    rpc: string;
+  }): Promise<_cosmjs_stargate0.DeliverTxResponse>;
+  signArbitrary({
+    data,
+    signer
+  }: {
+    signer: string;
+    data: string | Uint8Array;
+  }): Promise<string>;
+  signEIP712CosmosTx({
+    eip712,
+    signDoc
+  }: {
+    eip712: any;
+    signDoc: StdSignDoc$1;
+  }): Promise<AminoSignResponse>;
+  checkChainIdSupport(): Promise<boolean>;
+  private getCosmos;
+  disableGasCheck(): Promise<void>;
+  enableGasCheck(): Promise<void>;
+}
+//#endregion
+//#region src/strategy/strategy.d.ts
+declare class CosmosWalletStrategy extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+  wallet: Wallet;
+  private cosmosWallet;
+  constructor(args: {
+    chainId: ChainId | CosmosChainId;
+    endpoints?: {
+      rest: string;
+      rpc: string;
+    };
+  } & {
+    wallet: Wallet;
+  });
+  getWalletDeviceType(): Promise<WalletDeviceType>;
+  enable(): Promise<boolean>;
+  disconnect(): Promise<void>;
+  getAddresses(): Promise<string[]>;
+  getAddressesInfo(): Promise<{
+    address: string;
+    derivationPath: string;
+    baseDerivationPath: string;
+  }[]>;
+  getSessionOrConfirm(address: AccountAddress): Promise<string>;
+  sendEvmTransaction(_transaction: unknown, _options: {
+    address: AccountAddress;
+    evmChainId: EvmChainId;
+  }): Promise<string>;
+  sendTransaction(transaction: DirectSignResponse | TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+  signAminoCosmosTransaction(transaction: {
+    address: string;
+    signDoc: StdSignDoc;
+  }): Promise<AminoSignResponse$1>;
+  signCosmosTransaction(transaction: {
+    txRaw: TxRaw;
+    accountNumber: number;
+    chainId: string;
+    address: AccountAddress;
+  }): Promise<DirectSignResponse>;
+  signEip712TypedData(_eip712TypedData: string, _address: AccountAddress): Promise<string>;
+  signArbitrary(signer: string, data: string | Uint8Array): Promise<string>;
+  getEthereumChainId(): Promise<string>;
+  getEvmTransactionReceipt(_txHash: string): Promise<string>;
+  getPubKey(): Promise<string>;
+  onAccountChange(callback: (account: AccountAddress | string[]) => void): Promise<void>;
+  getCosmosWallet(chainId: ChainId): CosmosWallet;
+  getOfflineSigner(chainId?: string): Promise<OfflineSigner>;
+  private getCurrentCosmosWallet;
+}
+//#endregion
+export { CosmosWallet, CosmosWalletStrategy, confirmCosmosAddress, isCosmosWalletInstalled };

package/dist/esm/index.js

@@ -1,3 +1,465 @@
-export { CosmosWallet } from './wallet.js';
-export { CosmosWalletStrategy } from './strategy/strategy.js';
-export * from './utils/index.js';
+import { capitalize } from "@injectivelabs/utils";
+import { BaseConcreteStrategy, BroadcastMode, Wallet, WalletAction, WalletDeviceType, WalletEventListener, createCosmosSignDocFromSignDoc } from "@injectivelabs/wallet-base";
+import { PublicKey } from "@injectivelabs/sdk-ts/core/accounts";
+import { stringToUint8Array, uint8ArrayToBase64, uint8ArrayToHex } from "@injectivelabs/sdk-ts/utils";
+import { CosmosWalletException, ErrorType, GeneralException, TransactionException, UnspecifiedErrorCode, WalletErrorActionModule } from "@injectivelabs/exceptions";
+import { SigningStargateClient } from "@cosmjs/stargate";
+import { CosmosTxV1Beta1TxPb } from "@injectivelabs/sdk-ts";
+import { createSignDocFromTransaction, createTxRawFromSigResponse, waitTxBroadcasted } from "@injectivelabs/sdk-ts/core/tx";
+
+//#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/wallet.ts
+const $window = typeof window !== "undefined" ? window : {};
+var CosmosWallet = class CosmosWallet {
+	constructor({ wallet, chainId }) {
+		_defineProperty(this, "wallet", void 0);
+		_defineProperty(this, "chainId", void 0);
+		this.wallet = wallet;
+		this.chainId = chainId;
+	}
+	async isChainIdSupported(chainId) {
+		const { wallet } = this;
+		return new CosmosWallet({
+			chainId,
+			wallet
+		}).checkChainIdSupport();
+	}
+	async getCosmosWallet() {
+		const { chainId } = this;
+		const cosmos = this.getCosmos();
+		try {
+			await cosmos.enable(chainId);
+			return cosmos;
+		} catch (e) {
+			throw new CosmosWalletException(new Error(e.message));
+		}
+	}
+	async chainNotSupported() {
+		const { chainId, wallet } = this;
+		const chainName = chainId.split("-");
+		const context = wallet === Wallet.Keplr ? "https://chains.keplr.app/" : wallet === Wallet.OWallet ? "https://owallet.io/" : void 0;
+		throw new CosmosWalletException(/* @__PURE__ */ new Error(`${capitalize(wallet)} may not support ${chainName[0] || chainId} network. Please check if the chain can be added.`), context ? { context } : {});
+	}
+	async getAccounts() {
+		const { chainId } = this;
+		const cosmos = this.getCosmos();
+		try {
+			return cosmos.getOfflineSigner(chainId).getAccounts();
+		} catch (e) {
+			throw new CosmosWalletException(new Error(e.message), { contextModule: WalletErrorActionModule.GetAccounts });
+		}
+	}
+	async getKey() {
+		const { wallet, chainId } = this;
+		const cosmosWallet = await this.getCosmosWallet();
+		try {
+			return cosmosWallet.getKey(chainId);
+		} catch (e) {
+			throw new CosmosWalletException(new Error(e.message), { contextModule: wallet });
+		}
+	}
+	async getOfflineSigner(chainId) {
+		const { wallet } = this;
+		try {
+			return this.getCosmos().getOfflineSigner(chainId || this.chainId);
+		} catch (e) {
+			throw new CosmosWalletException(new Error(e.message), { contextModule: wallet });
+		}
+	}
+	async getOfflineAminoSigner() {
+		const { chainId, wallet } = this;
+		if (![Wallet.Keplr, Wallet.OWallet].includes(wallet)) throw new CosmosWalletException(/* @__PURE__ */ new Error(`getOfflineAminoSigner is not support on ${capitalize(wallet)}`));
+		const cosmosWallet = await this.getCosmosWallet();
+		try {
+			return cosmosWallet.getOfflineSignerOnlyAmino(chainId);
+		} catch (e) {
+			throw new CosmosWalletException(new Error(e.message), { context: wallet });
+		}
+	}
+	/**
+	* This method is used to broadcast a transaction to the network.
+	* Since it uses the `Sync` mode, it will not wait for the transaction to be included in a block,
+	* so we have to make sure the transaction is included in a block after its broadcasted
+	*
+	* @param txRaw - raw transaction to broadcast
+	* @returns tx hash
+	*/
+	async broadcastTx(txRaw) {
+		const { chainId, wallet } = this;
+		const cosmosWallet = await this.getCosmosWallet();
+		try {
+			const result = await cosmosWallet.sendTx(chainId, CosmosTxV1Beta1TxPb.TxRaw.toBinary(txRaw), BroadcastMode.Sync);
+			if (!result || result.length === 0) throw new TransactionException(/* @__PURE__ */ new Error("Transaction failed to be broadcasted"), { contextModule: wallet });
+			return uint8ArrayToHex(result);
+		} catch (e) {
+			if (e instanceof TransactionException) throw e;
+			throw new CosmosWalletException(new Error(e.message), {
+				context: "broadcast-tx",
+				contextModule: wallet
+			});
+		}
+	}
+	/**
+	* This method is used to broadcast a transaction to the network.
+	* Since it uses the `Block` mode, and it will wait for the transaction to be included in a block,
+	*
+	* @param txRaw - raw transaction to broadcast
+	* @returns tx hash
+	*/
+	async broadcastTxBlock(txRaw) {
+		const { chainId, wallet } = this;
+		const cosmosWallet = await this.getCosmosWallet();
+		try {
+			const result = await cosmosWallet.sendTx(chainId, CosmosTxV1Beta1TxPb.TxRaw.toBinary(txRaw), BroadcastMode.Block);
+			if (!result || result.length === 0) throw new TransactionException(/* @__PURE__ */ new Error("Transaction failed to be broadcasted"), { contextModule: wallet });
+			return uint8ArrayToHex(result);
+		} catch (e) {
+			if (e instanceof TransactionException) throw e;
+			throw new CosmosWalletException(new Error(e.message), {
+				context: "broadcast-tx",
+				contextModule: wallet
+			});
+		}
+	}
+	async signAndBroadcastAminoUsingCosmjs(messages, stdFee, endpoints) {
+		const { chainId, wallet } = this;
+		const cosmosWallet = await this.getCosmosWallet();
+		if (![Wallet.Keplr, Wallet.OWallet].includes(wallet)) throw new CosmosWalletException(/* @__PURE__ */ new Error(`signAndBroadcastAminoUsingCosmjs is not support on ${capitalize(wallet)}`));
+		if (!endpoints.rpc) throw new GeneralException(/* @__PURE__ */ new Error(`Please provide rpc endpoint`));
+		const offlineSigner = cosmosWallet.getOfflineSignerOnlyAmino(chainId);
+		const [account] = await offlineSigner.getAccounts();
+		return await (await SigningStargateClient.connectWithSigner(endpoints.rpc, offlineSigner)).signAndBroadcast(account.address, messages, stdFee);
+	}
+	async signArbitrary({ data, signer }) {
+		const { chainId, wallet } = this;
+		const cosmosWallet = await this.getCosmosWallet();
+		if (wallet !== Wallet.Keplr) throw new CosmosWalletException(/* @__PURE__ */ new Error(`signArbitrary is not supported on ${capitalize(wallet)}`));
+		try {
+			return (await cosmosWallet.signArbitrary(chainId, signer, data)).signature;
+		} catch (e) {
+			throw new CosmosWalletException(new Error(e.message), {
+				context: wallet,
+				contextModule: "sign-arbitrary"
+			});
+		}
+	}
+	async signEIP712CosmosTx({ eip712, signDoc }) {
+		const { chainId, wallet } = this;
+		const cosmosWallet = await this.getCosmosWallet();
+		const key = await this.getKey();
+		try {
+			return cosmosWallet.experimentalSignEIP712CosmosTx_v0(chainId, key.bech32Address, eip712, signDoc);
+		} catch (e) {
+			throw new CosmosWalletException(new Error(e.message), {
+				context: wallet,
+				contextModule: "sign-eip712-cosmos-tx"
+			});
+		}
+	}
+	async checkChainIdSupport() {
+		const { chainId, wallet } = this;
+		const cosmos = this.getCosmos();
+		const chainName = chainId.split("-");
+		try {
+			return !!await cosmos.getKey(chainId);
+		} catch (_unused) {
+			throw new CosmosWalletException(/* @__PURE__ */ new Error(`${capitalize(wallet)} doesn't support ${chainName[0] || chainId} network. Please use another Cosmos wallet`));
+		}
+	}
+	getCosmos() {
+		const { wallet } = this;
+		if (!$window) throw new CosmosWalletException(/* @__PURE__ */ new Error(`Please install ${capitalize(wallet)} extension`), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletNotInstalledError,
+			contextModule: wallet
+		});
+		let cosmos = void 0;
+		if (wallet === Wallet.OWallet) cosmos = $window.owallet;
+		if (wallet === Wallet.Keplr) cosmos = $window.keplr;
+		if (wallet === Wallet.Ninji) cosmos = $window.ninji;
+		if (wallet === Wallet.Leap) cosmos = $window.leap;
+		if (!cosmos) throw new CosmosWalletException(/* @__PURE__ */ new Error(`Please install ${capitalize(wallet)} extension`), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletNotInstalledError,
+			contextModule: wallet
+		});
+		return cosmos;
+	}
+	async disableGasCheck() {
+		const { wallet } = this;
+		const cosmosWallet = await this.getCosmosWallet();
+		if (![Wallet.Keplr, Wallet.OWallet].includes(wallet)) throw new CosmosWalletException(/* @__PURE__ */ new Error(`disableGasCheck is not support on ${capitalize(wallet)}`));
+		cosmosWallet.defaultOptions = {
+			...cosmosWallet.defaultOptions,
+			sign: {
+				...cosmosWallet.defaultOptions.sign,
+				disableBalanceCheck: true
+			}
+		};
+	}
+	async enableGasCheck() {
+		const { wallet } = this;
+		const cosmosWallet = await this.getCosmosWallet();
+		if (![Wallet.Keplr, Wallet.OWallet].includes(wallet)) throw new CosmosWalletException(/* @__PURE__ */ new Error(`EnableGasCheck is not support on ${capitalize(wallet)}`));
+		cosmosWallet.defaultOptions = {
+			...cosmosWallet.defaultOptions,
+			sign: {
+				...cosmosWallet.defaultOptions.sign,
+				disableBalanceCheck: false
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/data/index.ts
+const cosmosWallets$1 = [
+	Wallet.Leap,
+	Wallet.Ninji,
+	Wallet.Keplr,
+	Wallet.OWallet
+];
+
+//#endregion
+//#region src/utils/index.ts
+const isCosmosWalletInstalled = (wallet) => {
+	const $window$1 = typeof window !== "undefined" ? window : {};
+	switch (wallet) {
+		case Wallet.Keplr: return $window$1.keplr !== void 0;
+		case Wallet.Ninji: return $window$1.ninji !== void 0;
+		case Wallet.Leap: return $window$1.leap !== void 0;
+		case Wallet.OWallet: return $window$1.oWallet !== void 0;
+		default: return false;
+	}
+};
+const confirmCosmosAddress = async ({ wallet, chainId, injectiveAddress }) => {
+	if (!cosmosWallets$1.includes(wallet)) throw new CosmosWalletException(/* @__PURE__ */ new Error(`Cosmos Wallet for ${capitalize(wallet)} is not supported.`));
+	const key = await new CosmosWallet({
+		chainId,
+		wallet
+	}).getKey();
+	const { address: derivedAddress } = PublicKey.fromBase64(uint8ArrayToBase64(key.pubKey)).toAddress();
+	if (derivedAddress !== injectiveAddress) throw new CosmosWalletException(/* @__PURE__ */ new Error(`Connected ${capitalize(wallet)} address is wrong. Please update Injective on ${capitalize(wallet)}.`));
+};
+
+//#endregion
+//#region src/strategy/strategy.ts
+const cosmosWallets = [
+	Wallet.Leap,
+	Wallet.Ninji,
+	Wallet.Keplr,
+	Wallet.OWallet
+];
+var CosmosWalletStrategy = class extends BaseConcreteStrategy {
+	constructor(args) {
+		super({
+			...args,
+			chainId: args.chainId
+		});
+		_defineProperty(this, "wallet", void 0);
+		_defineProperty(this, "cosmosWallet", void 0);
+		if (!cosmosWallets.includes(args.wallet)) throw new CosmosWalletException(/* @__PURE__ */ new Error(`Cosmos Wallet for ${capitalize(args.wallet)} is not supported.`));
+		this.wallet = args.wallet;
+		this.chainId = args.chainId;
+		this.cosmosWallet = new CosmosWallet({
+			wallet: args.wallet,
+			chainId: args.chainId
+		});
+	}
+	async getWalletDeviceType() {
+		return (await this.getCurrentCosmosWallet().getKey()).isNanoLedger ? Promise.resolve(WalletDeviceType.Hardware) : Promise.resolve(WalletDeviceType.Browser);
+	}
+	async enable() {
+		return await this.getCurrentCosmosWallet().checkChainIdSupport();
+	}
+	async disconnect() {
+		const { wallet } = this;
+		if (this.listeners[WalletEventListener.AccountChange]) {
+			if (wallet === Wallet.Ninji) window.ninji.off("accountsChanged", this.listeners[WalletEventListener.AccountChange]);
+			if ([Wallet.Keplr, Wallet.OWallet].includes(wallet)) window.removeEventListener("keplr_keystorechange", this.listeners[WalletEventListener.AccountChange]);
+			if (wallet === Wallet.Leap) window.removeEventListener("leap_keystorechange", this.listeners[WalletEventListener.AccountChange]);
+		}
+		this.listeners = {};
+	}
+	async getAddresses() {
+		const cosmosWallet = this.getCurrentCosmosWallet();
+		try {
+			return (await cosmosWallet.getAccounts()).map((account) => account.address);
+		} catch (e) {
+			throw new CosmosWalletException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				context: WalletAction.GetAccounts
+			});
+		}
+	}
+	async getAddressesInfo() {
+		throw new CosmosWalletException(/* @__PURE__ */ new Error("getAddressesInfo is not implemented"), {
+			code: UnspecifiedErrorCode,
+			context: WalletAction.GetAccounts
+		});
+	}
+	async getSessionOrConfirm(address) {
+		return Promise.resolve(`0x${uint8ArrayToHex(stringToUint8Array(`Confirmation for ${address} at time: ${Date.now()}`))}`);
+	}
+	async sendEvmTransaction(_transaction, _options) {
+		const { wallet } = this;
+		throw new CosmosWalletException(/* @__PURE__ */ new Error(`sendEvmTransaction is not supported. ${capitalize(wallet)} only supports sending cosmos transactions`), {
+			code: UnspecifiedErrorCode,
+			context: WalletAction.SendEvmTransaction
+		});
+	}
+	async sendTransaction(transaction, options) {
+		const cosmosWallet = this.getCurrentCosmosWallet();
+		const txRaw = createTxRawFromSigResponse(transaction);
+		if (!options.endpoints) throw new CosmosWalletException(/* @__PURE__ */ new Error("You have to pass endpoints within the options to broadcast transaction"));
+		try {
+			return await waitTxBroadcasted(await cosmosWallet.broadcastTx(txRaw), options);
+		} catch (e) {
+			if (e instanceof TransactionException) throw e;
+			throw new TransactionException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				context: WalletAction.SendTransaction
+			});
+		}
+	}
+	async signAminoCosmosTransaction(transaction) {
+		const signer = await this.getCurrentCosmosWallet().getOfflineAminoSigner();
+		try {
+			return await signer.signAmino(transaction.address, transaction.signDoc);
+		} catch (e) {
+			throw new CosmosWalletException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				context: WalletAction.SignTransaction
+			});
+		}
+	}
+	async signCosmosTransaction(transaction) {
+		const signer = await this.getCurrentCosmosWallet().getOfflineSigner(this.chainId);
+		const signDoc = createSignDocFromTransaction(transaction);
+		try {
+			if (!("signDirect" in signer)) throw new CosmosWalletException(/* @__PURE__ */ new Error("signDirect not available"), {
+				code: UnspecifiedErrorCode,
+				context: WalletAction.SendTransaction
+			});
+			return await signer.signDirect(transaction.address, createCosmosSignDocFromSignDoc(signDoc));
+		} catch (e) {
+			throw new CosmosWalletException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				context: WalletAction.SendTransaction
+			});
+		}
+	}
+	async signEip712TypedData(_eip712TypedData, _address) {
+		throw new CosmosWalletException(/* @__PURE__ */ new Error("This wallet does not support signing Evm transactions"), {
+			code: UnspecifiedErrorCode,
+			context: WalletAction.SendTransaction
+		});
+	}
+	async signArbitrary(signer, data) {
+		const cosmosWallet = this.getCurrentCosmosWallet();
+		try {
+			return await cosmosWallet.signArbitrary({
+				data,
+				signer
+			});
+		} catch (e) {
+			throw new CosmosWalletException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				context: WalletAction.SignArbitrary
+			});
+		}
+	}
+	async getEthereumChainId() {
+		const { wallet } = this;
+		throw new CosmosWalletException(/* @__PURE__ */ new Error(`getEthereumChainId is not supported on ${capitalize(wallet)}`), {
+			code: UnspecifiedErrorCode,
+			context: WalletAction.GetChainId
+		});
+	}
+	async getEvmTransactionReceipt(_txHash) {
+		const { wallet } = this;
+		throw new CosmosWalletException(/* @__PURE__ */ new Error(`getEvmTransactionReceipt is not supported on ${capitalize(wallet)}`), {
+			code: UnspecifiedErrorCode,
+			context: WalletAction.GetEvmTransactionReceipt
+		});
+	}
+	async getPubKey() {
+		return uint8ArrayToBase64((await this.getCurrentCosmosWallet().getKey()).pubKey);
+	}
+	async onAccountChange(callback) {
+		const { wallet } = this;
+		const listener = async () => {
+			const [account] = await this.getAddresses();
+			callback(account);
+		};
+		this.listeners = { [WalletEventListener.AccountChange]: listener };
+		if (wallet === Wallet.Ninji) window.ninji.on("accountsChanged", listener);
+		if ([Wallet.Keplr, Wallet.OWallet].includes(wallet)) window.addEventListener("keplr_keystorechange", listener);
+		if (wallet === Wallet.Leap) window.addEventListener("leap_keystorechange", listener);
+	}
+	getCosmosWallet(chainId) {
+		const { wallet, cosmosWallet } = this;
+		return !cosmosWallet ? new CosmosWallet({
+			chainId,
+			wallet
+		}) : cosmosWallet;
+	}
+	async getOfflineSigner(chainId) {
+		const cosmosWallet = await this.getCosmosWallet(chainId || this.chainId);
+		if (!cosmosWallet) throw new Error("no cosmos wallet");
+		return await cosmosWallet.getOfflineSigner(chainId || this.chainId);
+	}
+	getCurrentCosmosWallet() {
+		const { wallet, cosmosWallet } = this;
+		if (!cosmosWallet) throw new CosmosWalletException(/* @__PURE__ */ new Error(`Please install the ${capitalize(wallet)} wallet extension`), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletNotInstalledError,
+			context: WalletAction.SignTransaction
+		});
+		return cosmosWallet;
+	}
+};
+
+//#endregion
+export { CosmosWallet, CosmosWalletStrategy, confirmCosmosAddress, isCosmosWalletInstalled };

package/dist/esm/package.json

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