@injectivelabs/wallet-evm 1.16.37 → 1.16.38-alpha.0

package/dist/cjs/index.cjs

@@ -0,0 +1,522 @@
+let __injectivelabs_utils = require("@injectivelabs/utils");
+let __injectivelabs_exceptions = require("@injectivelabs/exceptions");
+let __injectivelabs_wallet_base = require("@injectivelabs/wallet-base");
+let __injectivelabs_sdk_ts = require("@injectivelabs/sdk-ts");
+
+//#region src/strategy/utils/rabby.ts
+const $window$6 = (0, __injectivelabs_sdk_ts.isServerSide)() ? {} : window;
+async function getRabbyProvider({ timeout } = { timeout: 3e3 }) {
+	const provider = getRabbyFromWindow();
+	if (provider) return provider;
+	return listenForRabbyInitialized({ timeout });
+}
+async function listenForRabbyInitialized({ timeout } = { timeout: 3e3 }) {
+	return new Promise((resolve) => {
+		const handleInitialization = () => {
+			resolve(getRabbyFromWindow());
+		};
+		$window$6.addEventListener("rabby#initialized", handleInitialization, { once: true });
+		setTimeout(() => {
+			$window$6.removeEventListener("rabby#initialized", handleInitialization);
+			resolve(null);
+		}, timeout);
+	});
+}
+function getRabbyFromWindow() {
+	if (!(typeof window !== "undefined" && typeof $window$6.ethereum !== "undefined")) return;
+	if ($window$6.ethereum.isRabby) return $window$6.ethereum;
+	if ($window$6.providers) return $window$6.providers.find((p) => p.isRabby);
+}
+
+//#endregion
+//#region src/strategy/utils/Okx.ts
+const $window$5 = (0, __injectivelabs_sdk_ts.isServerSide)() ? {} : window;
+async function getOkxWalletProvider({ timeout } = { timeout: 3e3 }) {
+	const provider = getOkxWalletFromWindow();
+	if (provider) return provider;
+	return listenForOkxWalletInitialized({ timeout });
+}
+async function listenForOkxWalletInitialized({ timeout } = { timeout: 3e3 }) {
+	return new Promise((resolve) => {
+		const handleInitialization = () => {
+			resolve(getOkxWalletFromWindow());
+		};
+		$window$5.addEventListener("okxwallet#initialized", handleInitialization, { once: true });
+		setTimeout(() => {
+			$window$5.removeEventListener("okxwallet#initialized", handleInitialization);
+			resolve(null);
+		}, timeout);
+	});
+}
+function getOkxWalletFromWindow() {
+	if (!(typeof window !== "undefined" && (typeof $window$5.ethereum !== "undefined" || typeof $window$5.okxwallet !== "undefined"))) return;
+	if ($window$5.okxwallet) return $window$5.okxwallet;
+	if ($window$5.ethereum.isOkxWallet) return $window$5.ethereum;
+	if ($window$5.providers) return $window$5.providers.find((p) => p.isOkxWallet);
+}
+
+//#endregion
+//#region src/strategy/utils/bitget.ts
+const $window$4 = (0, __injectivelabs_sdk_ts.isServerSide)() ? {} : window;
+async function getBitGetProvider({ timeout } = { timeout: 3e3 }) {
+	const provider = getBitGetFromWindow();
+	if (provider) return provider;
+	return listenForBitGetInitialized({ timeout });
+}
+async function listenForBitGetInitialized({ timeout } = { timeout: 3e3 }) {
+	return new Promise((resolve) => {
+		const handleInitialization = () => {
+			resolve(getBitGetFromWindow());
+		};
+		$window$4.addEventListener("bitkeep#initialized", handleInitialization, { once: true });
+		setTimeout(() => {
+			$window$4.removeEventListener("bitkeep#initialized", handleInitialization);
+			resolve(null);
+		}, timeout);
+	});
+}
+function getBitGetFromWindow() {
+	if (!(typeof window !== "undefined" && (typeof $window$4.ethereum !== "undefined" || typeof $window$4.bitkeep !== "undefined"))) return;
+	if ($window$4.bitkeep && $window$4.bitkeep.ethereum) return $window$4.bitkeep.ethereum;
+}
+
+//#endregion
+//#region src/strategy/utils/phantom.ts
+const $window$3 = (0, __injectivelabs_sdk_ts.isServerSide)() ? {} : window;
+async function getPhantomProvider({ timeout } = { timeout: 3e3 }) {
+	const provider = getPhantomFromWindow();
+	if (provider) return provider;
+	return listenForPhantomInitialized({ timeout });
+}
+async function listenForPhantomInitialized({ timeout } = { timeout: 3e3 }) {
+	return new Promise((resolve) => {
+		const handleInitialization = () => {
+			resolve(getPhantomFromWindow());
+		};
+		$window$3.addEventListener("phantom#initialized", handleInitialization, { once: true });
+		setTimeout(() => {
+			$window$3.removeEventListener("phantom#initialized", handleInitialization);
+			resolve(null);
+		}, timeout);
+	});
+}
+function getPhantomFromWindow() {
+	if (!(typeof window !== "undefined" && (typeof $window$3.ethereum !== "undefined" || typeof $window$3.phantom !== "undefined"))) return;
+	if ($window$3.phantom) return $window$3.phantom.ethereum;
+	if ($window$3.ethereum.isPhantom) return $window$3.ethereum;
+	if ($window$3.providers) return $window$3.providers.find((p) => p.isPhantom);
+}
+
+//#endregion
+//#region src/strategy/utils/metamask.ts
+const $window$2 = (0, __injectivelabs_sdk_ts.isServerSide)() ? {} : window;
+async function getMetamaskProvider({ timeout } = { timeout: 3e3 }) {
+	const provider = getMetamaskFromWindow();
+	if (provider) return provider;
+	return listenForMetamaskInitialized({ timeout });
+}
+async function listenForMetamaskInitialized({ timeout } = { timeout: 3e3 }) {
+	return new Promise((resolve) => {
+		const handleInitialization = () => {
+			resolve(getMetamaskFromWindow());
+		};
+		$window$2.addEventListener("ethereum#initialized", handleInitialization, { once: true });
+		setTimeout(() => {
+			$window$2.removeEventListener("ethereum#initialized", handleInitialization);
+			resolve(null);
+		}, timeout);
+	});
+}
+function getMetamaskFromWindow() {
+	if (!(typeof window !== "undefined" && typeof $window$2.ethereum !== "undefined")) return;
+	if ($window$2.ethereum.isMetaMask) return $window$2.ethereum;
+	if ($window$2.providers) return $window$2.providers.find((p) => p.isMetaMask);
+}
+
+//#endregion
+//#region src/strategy/utils/trustWallet.ts
+const $window$1 = (0, __injectivelabs_sdk_ts.isServerSide)() ? {} : window;
+async function getTrustWalletProvider({ timeout } = { timeout: 3e3 }) {
+	const provider = getTrustWalletFromWindow();
+	if (provider) return provider;
+	return listenForTrustWalletInitialized({ timeout });
+}
+async function listenForTrustWalletInitialized({ timeout } = { timeout: 3e3 }) {
+	return new Promise((resolve) => {
+		const handleInitialization = () => {
+			resolve(getTrustWalletFromWindow());
+		};
+		$window$1.addEventListener("trustwallet#initialized", handleInitialization, { once: true });
+		setTimeout(() => {
+			$window$1.removeEventListener("trustwallet#initialized", handleInitialization);
+			resolve(null);
+		}, timeout);
+	});
+}
+function getTrustWalletFromWindow() {
+	if (!(typeof window !== "undefined" && (typeof $window$1.ethereum !== "undefined" || typeof $window$1.trustWallet !== "undefined"))) return;
+	if ($window$1.trustWallet) return $window$1.trustWallet;
+	if ($window$1.ethereum.isTrustWallet || $window$1.ethereum.isTrust) return $window$1.ethereum;
+	if ($window$1.providers) return $window$1.providers.find((p) => p.isTrustWallet);
+}
+
+//#endregion
+//#region src/utils/index.ts
+const getEvmProvider = async (wallet) => {
+	if (!(0, __injectivelabs_wallet_base.isEvmBrowserWallet)(wallet)) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error(`Evm Wallet for ${(0, __injectivelabs_utils.capitalize)(wallet)} is not supported.`));
+	try {
+		let provider;
+		if (wallet === __injectivelabs_wallet_base.Wallet.Metamask) provider = await getMetamaskProvider();
+		if (wallet === __injectivelabs_wallet_base.Wallet.Rabby) provider = await getRabbyProvider();
+		if (wallet === __injectivelabs_wallet_base.Wallet.BitGet) provider = await getBitGetProvider();
+		if (wallet === __injectivelabs_wallet_base.Wallet.Phantom) provider = await getPhantomProvider();
+		if (wallet === __injectivelabs_wallet_base.Wallet.TrustWallet) provider = await getTrustWalletProvider();
+		if (wallet === __injectivelabs_wallet_base.Wallet.OkxWallet) provider = await getOkxWalletProvider();
+		if (!provider) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error(`Please install ${(0, __injectivelabs_utils.capitalize)(wallet)} Extension`));
+		return provider;
+	} catch (_unused) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error(`Please install ${(0, __injectivelabs_utils.capitalize)(wallet)} Extension`));
+	}
+};
+const updateEvmNetwork = async (wallet, chainId) => {
+	if (!(0, __injectivelabs_wallet_base.isEvmBrowserWallet)(wallet)) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error(`Evm Wallet for ${(0, __injectivelabs_utils.capitalize)(wallet)} is not supported.`));
+	const provider = await getEvmProvider(wallet);
+	if (!provider) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error(`Please install ${(0, __injectivelabs_utils.capitalize)(wallet)} Extension`));
+	try {
+		const chainIdToHex = chainId.toString(16);
+		return await Promise.race([provider.request({
+			method: "wallet_switchEthereumChain",
+			params: [{ chainId: `0x${chainIdToHex}` }]
+		}), new Promise((resolve) => provider.on("chainChanged", ({ chain }) => {
+			if ((chain === null || chain === void 0 ? void 0 : chain.id) === chainIdToHex) resolve();
+		}))]);
+	} catch (_unused2) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error(`Please update your ${(0, __injectivelabs_utils.capitalize)(wallet)} network`));
+	}
+};
+
+//#endregion
+//#region src/strategy/utils/rainbow.ts
+const $window = (0, __injectivelabs_sdk_ts.isServerSide)() ? {} : window;
+async function getRainbowProvider({ timeout } = { timeout: 3e3 }) {
+	const provider = getRainbowWalletFromWindow();
+	if (provider) return provider;
+	return listenForRainbowWalletInitialized({ timeout });
+}
+async function listenForRainbowWalletInitialized({ timeout } = { timeout: 3e3 }) {
+	return new Promise((resolve) => {
+		const handleInitialization = () => {
+			resolve(getRainbowWalletFromWindow());
+		};
+		$window.addEventListener("rainbow#initialized", handleInitialization, { once: true });
+		setTimeout(() => {
+			$window.removeEventListener("rainbow#initialized", handleInitialization);
+			resolve(null);
+		}, timeout);
+	});
+}
+function getRainbowWalletFromWindow() {
+	if (!(typeof window !== "undefined" && (typeof $window.ethereum !== "undefined" || typeof $window.rainbow !== "undefined"))) return;
+	if ($window.rainbow) return $window.rainbow;
+	if ($window.ethereum.isRainbow) return $window.ethereum;
+	if ($window.providers) return $window.providers.find((p) => p.isRainbow);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/strategy/strategy.ts
+var EvmWallet = class extends __injectivelabs_wallet_base.BaseConcreteStrategy {
+	constructor(args) {
+		super(args);
+		_defineProperty(this, "wallet", void 0);
+		_defineProperty(this, "evmProviders", {});
+		if (!(0, __injectivelabs_wallet_base.isEvmBrowserWallet)(args.wallet)) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error(`Evm Wallet for ${(0, __injectivelabs_utils.capitalize)(args.wallet)} is not supported.`));
+		if (!(0, __injectivelabs_sdk_ts.isServerSide)()) {
+			window.addEventListener("eip6963:announceProvider", (announcement) => {
+				const event = announcement;
+				const walletName = event.detail.info.name.toLowerCase();
+				if (walletName === __injectivelabs_wallet_base.Wallet.Metamask.toLowerCase()) this.evmProviders[__injectivelabs_wallet_base.Wallet.Metamask] = event.detail.provider;
+				if (walletName === __injectivelabs_wallet_base.Wallet.Rabby.toLowerCase()) this.evmProviders[__injectivelabs_wallet_base.Wallet.Rabby] = event.detail.provider;
+				if (walletName === __injectivelabs_wallet_base.Wallet.Rainbow.toLowerCase()) this.evmProviders[__injectivelabs_wallet_base.Wallet.Rainbow] = event.detail.provider;
+				if (walletName === __injectivelabs_wallet_base.Wallet.Phantom.toLowerCase()) this.evmProviders[__injectivelabs_wallet_base.Wallet.Phantom] = event.detail.provider;
+				if (walletName === __injectivelabs_wallet_base.Wallet.OkxWallet.toLowerCase()) this.evmProviders[__injectivelabs_wallet_base.Wallet.OkxWallet] = event.detail.provider;
+				if (walletName === __injectivelabs_wallet_base.Wallet.BitGet.toLowerCase()) this.evmProviders[__injectivelabs_wallet_base.Wallet.BitGet] = event.detail.provider;
+				if (walletName === __injectivelabs_wallet_base.Wallet.TrustWallet.toLowerCase()) this.evmProviders[__injectivelabs_wallet_base.Wallet.TrustWallet] = event.detail.provider;
+			});
+			window.dispatchEvent(new Event("eip6963:requestProvider"));
+		}
+		this.wallet = args.wallet;
+	}
+	EvmWalletException(error, context) {
+		if (this.wallet === __injectivelabs_wallet_base.Wallet.Metamask) return new __injectivelabs_exceptions.MetamaskException(error, context);
+		if (this.wallet === __injectivelabs_wallet_base.Wallet.BitGet) return new __injectivelabs_exceptions.BitGetException(error, context);
+		if (this.wallet === __injectivelabs_wallet_base.Wallet.OkxWallet) return new __injectivelabs_exceptions.OkxWalletException(error, context);
+		if (this.wallet === __injectivelabs_wallet_base.Wallet.Phantom) return new __injectivelabs_exceptions.MetamaskException(error, context);
+		if (this.wallet === __injectivelabs_wallet_base.Wallet.TrustWallet) return new __injectivelabs_exceptions.TrustWalletException(error, context);
+		if (this.wallet === __injectivelabs_wallet_base.Wallet.Rainbow) return new __injectivelabs_exceptions.RainbowWalletException(error, context);
+		return new __injectivelabs_exceptions.WalletException(error, context);
+	}
+	async getWalletDeviceType() {
+		return Promise.resolve(__injectivelabs_wallet_base.WalletDeviceType.Browser);
+	}
+	async enable() {
+		return Promise.resolve(true);
+	}
+	async disconnect() {
+		if (this.listeners[__injectivelabs_wallet_base.WalletEventListener.AccountChange]) (await this.getEthereum()).removeListener("accountsChanged", this.listeners[__injectivelabs_wallet_base.WalletEventListener.AccountChange]);
+		if (this.listeners[__injectivelabs_wallet_base.WalletEventListener.ChainIdChange]) (await this.getEthereum()).removeListener("chainChanged", this.listeners[__injectivelabs_wallet_base.WalletEventListener.ChainIdChange]);
+		this.listeners = {};
+	}
+	async getAddresses() {
+		const ethereum = await this.getEthereum();
+		try {
+			return await ethereum.request({ method: "eth_requestAccounts" });
+		} catch (e) {
+			throw this.EvmWalletException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+			});
+		}
+	}
+	async getSessionOrConfirm(address) {
+		return Promise.resolve(`0x${(0, __injectivelabs_sdk_ts.uint8ArrayToHex)((0, __injectivelabs_sdk_ts.stringToUint8Array)(`Confirmation for ${address} at time: ${Date.now()}`))}`);
+	}
+	async sendEvmTransaction(transaction, _options) {
+		const ethereum = await this.getEthereum();
+		try {
+			return await ethereum.request({
+				method: "eth_sendTransaction",
+				params: [transaction]
+			});
+		} catch (e) {
+			throw this.EvmWalletException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SendEvmTransaction
+			});
+		}
+	}
+	async sendTransaction(transaction, options) {
+		const { endpoints, txTimeout } = options;
+		if (!endpoints) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You have to pass endpoints within the options for using Ethereum native wallets"));
+		const response = await new __injectivelabs_sdk_ts.TxGrpcApi(endpoints.grpc).broadcast(transaction, { txTimeout });
+		if (response.code !== 0) throw new __injectivelabs_exceptions.TransactionException(new Error(response.rawLog), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			contextCode: response.code,
+			contextModule: response.codespace
+		});
+		return response;
+	}
+	async signEip712TypedData(eip712json, address) {
+		const ethereum = await this.getEthereum();
+		try {
+			return await ethereum.request({
+				method: "eth_signTypedData_v4",
+				params: [address, eip712json]
+			});
+		} catch (e) {
+			if (e.message.includes("Ledger: The signature doesnt match the right address")) throw new __injectivelabs_exceptions.MetamaskException(/* @__PURE__ */ new Error("Please connect directly with Ledger to sign this transaction"), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+			});
+			throw new __injectivelabs_exceptions.MetamaskException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+			});
+		}
+	}
+	async signAminoCosmosTransaction(_transaction) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("This wallet does not support signing Cosmos transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+		});
+	}
+	async signCosmosTransaction(_transaction) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("This wallet does not support signing Cosmos transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+		});
+	}
+	async signArbitrary(signer, data) {
+		const ethereum = await this.getEthereum();
+		try {
+			return await ethereum.request({
+				method: "personal_sign",
+				params: [(0, __injectivelabs_sdk_ts.toUtf8)(data), signer]
+			});
+		} catch (e) {
+			throw this.EvmWalletException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignArbitrary
+			});
+		}
+	}
+	async getEthereumChainId() {
+		const ethereum = await this.getEthereum();
+		try {
+			return ethereum.request({ method: "eth_chainId" });
+		} catch (e) {
+			throw this.EvmWalletException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetChainId
+			});
+		}
+	}
+	async getEvmTransactionReceipt(txHash) {
+		const ethereum = await this.getEthereum();
+		const chainIdHex = await ethereum.request({ method: "eth_chainId" });
+		const publicClient = (0, __injectivelabs_wallet_base.getViemPublicClientFromEip1193Provider)(parseInt(chainIdHex, 16), ethereum);
+		try {
+			await publicClient.waitForTransactionReceipt({
+				hash: txHash,
+				timeout: 3e4,
+				pollingInterval: 3e3
+			});
+			return txHash;
+		} catch (_unused) {
+			throw new Error(`Failed to retrieve transaction receipt for txHash: ${txHash}`);
+		}
+	}
+	async getPubKey() {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You can only fetch PubKey from Cosmos native wallets"));
+	}
+	async onChainIdChanged(callback) {
+		const ethereum = await this.getEthereum();
+		this.listeners = { [__injectivelabs_wallet_base.WalletEventListener.ChainIdChange]: callback };
+		ethereum.on("chainChanged", callback);
+	}
+	async onAccountChange(callback) {
+		const ethereum = await this.getEthereum();
+		this.listeners = { [__injectivelabs_wallet_base.WalletEventListener.AccountChange]: callback };
+		ethereum.on("accountsChanged", callback);
+	}
+	async getEip1193Provider() {
+		return this.getEthereum();
+	}
+	async addEvmNetwork(chainId) {
+		var _chain$rpcUrls, _chain$blockExplorers;
+		const ethereum = await this.getEthereum();
+		const chainIdHex = `0x${chainId.toString(16)}`;
+		const chain = (0, __injectivelabs_wallet_base.getEvmChainConfig)(chainId);
+		const params = {
+			chainId: chainIdHex,
+			chainName: chain.name,
+			rpcUrls: [...((_chain$rpcUrls = chain.rpcUrls) === null || _chain$rpcUrls === void 0 || (_chain$rpcUrls = _chain$rpcUrls.default) === null || _chain$rpcUrls === void 0 ? void 0 : _chain$rpcUrls.http) || []],
+			blockExplorerUrls: ((_chain$blockExplorers = chain.blockExplorers) === null || _chain$blockExplorers === void 0 || (_chain$blockExplorers = _chain$blockExplorers.default) === null || _chain$blockExplorers === void 0 ? void 0 : _chain$blockExplorers.url) ? [chain.blockExplorers.default.url] : [],
+			nativeCurrency: chain.nativeCurrency
+		};
+		const TIMEOUT_MS = 3e4;
+		try {
+			await Promise.race([ethereum.request({
+				method: "wallet_switchEthereumChain",
+				params: [{ chainId: chainIdHex }]
+			}), new Promise((resolve, reject) => {
+				const handleChainChanged = (newChainId) => {
+					if (newChainId.toLowerCase() === chainIdHex.toLowerCase()) {
+						cleanup();
+						resolve();
+					}
+				};
+				const timeoutId = setTimeout(() => {
+					cleanup();
+					reject(/* @__PURE__ */ new Error("Chain switch timed out"));
+				}, TIMEOUT_MS);
+				const cleanup = () => {
+					ethereum.removeListener("chainChanged", handleChainChanged);
+					clearTimeout(timeoutId);
+				};
+				ethereum.on("chainChanged", handleChainChanged);
+			})]);
+		} catch (error) {
+			var _code, _data;
+			if (((_code = error.code) !== null && _code !== void 0 ? _code : error === null || error === void 0 || (_data = error.data) === null || _data === void 0 || (_data = _data.originalError) === null || _data === void 0 ? void 0 : _data.code) === 4902) {
+				await ethereum.request({
+					method: "wallet_addEthereumChain",
+					params: [params]
+				});
+				return;
+			}
+			if (error.message === "Chain switch timed out") throw this.EvmWalletException(/* @__PURE__ */ new Error("Chain switch timed out"), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetChainId
+			});
+			throw this.EvmWalletException(/* @__PURE__ */ new Error(`Something went wrong while adding ${(0, __injectivelabs_utils.capitalize)(this.wallet || "wallet")} network`), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetChainId
+			});
+		}
+	}
+	async getEthereum() {
+		const evmProvider = this.evmProviders[this.wallet];
+		if (evmProvider) return evmProvider;
+		const backUpProvider = this.wallet === __injectivelabs_wallet_base.Wallet.Metamask ? await getMetamaskProvider() : this.wallet === __injectivelabs_wallet_base.Wallet.Rabby ? await getRabbyProvider() : this.wallet === __injectivelabs_wallet_base.Wallet.Phantom ? await getPhantomProvider() : this.wallet === __injectivelabs_wallet_base.Wallet.BitGet ? await getBitGetProvider() : this.wallet === __injectivelabs_wallet_base.Wallet.OkxWallet ? await getOkxWalletProvider() : this.wallet === __injectivelabs_wallet_base.Wallet.TrustWallet ? await getTrustWalletProvider() : this.wallet === __injectivelabs_wallet_base.Wallet.Rainbow ? await getRainbowProvider() : void 0;
+		if (!backUpProvider) throw this.EvmWalletException(/* @__PURE__ */ new Error(`Please install the ${this.wallet} wallet extension.`), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletNotInstalledError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+		});
+		return backUpProvider;
+	}
+};
+
+//#endregion
+exports.EvmWalletStrategy = EvmWallet;
+exports.getBitGetProvider = getBitGetProvider;
+exports.getEvmProvider = getEvmProvider;
+exports.getMetamaskProvider = getMetamaskProvider;
+exports.getOkxWalletProvider = getOkxWalletProvider;
+exports.getPhantomProvider = getPhantomProvider;
+exports.getRabbyProvider = getRabbyProvider;
+exports.getRainbowProvider = getRainbowProvider;
+exports.getTrustWalletProvider = getTrustWalletProvider;
+exports.updateEvmNetwork = updateEvmNetwork;

package/dist/cjs/index.d.cts

@@ -0,0 +1,99 @@
+import { BaseConcreteStrategy, BrowserEip1993Provider, ConcreteEvmWalletStrategyArgs, ConcreteWalletStrategy, ConcreteWalletStrategyArgs, Eip1193Provider, SendTransactionOptions, StdSignDoc, Wallet, WalletDeviceType } from "@injectivelabs/wallet-base";
+import { AccountAddress, EvmChainId } from "@injectivelabs/ts-types";
+import { ErrorContext, ThrownException } from "@injectivelabs/exceptions";
+import { AminoSignResponse, DirectSignResponse, TxRaw, TxResponse } from "@injectivelabs/sdk-ts";
+
+//#region src/utils/index.d.ts
+declare const getEvmProvider: (wallet: Wallet) => Promise<BrowserEip1993Provider>;
+declare const updateEvmNetwork: (wallet: Wallet, chainId: EvmChainId) => Promise<unknown>;
+//#endregion
+//#region src/strategy/utils/rabby.d.ts
+declare function getRabbyProvider({
+  timeout
+}?: {
+  timeout: number;
+}): Promise<BrowserEip1993Provider>;
+//#endregion
+//#region src/strategy/utils/bitget.d.ts
+declare function getBitGetProvider({
+  timeout
+}?: {
+  timeout: number;
+}): Promise<BrowserEip1993Provider>;
+//#endregion
+//#region src/strategy/utils/Okx.d.ts
+declare function getOkxWalletProvider({
+  timeout
+}?: {
+  timeout: number;
+}): Promise<BrowserEip1993Provider>;
+//#endregion
+//#region src/strategy/utils/phantom.d.ts
+declare function getPhantomProvider({
+  timeout
+}?: {
+  timeout: number;
+}): Promise<BrowserEip1993Provider>;
+//#endregion
+//#region src/strategy/utils/rainbow.d.ts
+declare function getRainbowProvider({
+  timeout
+}?: {
+  timeout: number;
+}): Promise<BrowserEip1993Provider>;
+//#endregion
+//#region src/strategy/utils/metamask.d.ts
+declare function getMetamaskProvider({
+  timeout
+}?: {
+  timeout: number;
+}): Promise<BrowserEip1993Provider>;
+//#endregion
+//#region src/strategy/utils/trustWallet.d.ts
+declare function getTrustWalletProvider({
+  timeout
+}?: {
+  timeout: number;
+}): Promise<BrowserEip1993Provider>;
+//#endregion
+//#region src/strategy/strategy.d.ts
+declare class EvmWallet extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+  wallet?: Wallet;
+  evmProviders: Partial<Record<Wallet, BrowserEip1993Provider>>;
+  constructor(args: (ConcreteWalletStrategyArgs | ConcreteEvmWalletStrategyArgs) & {
+    wallet: Wallet;
+  });
+  EvmWalletException(error: Error, context?: ErrorContext): ThrownException;
+  getWalletDeviceType(): Promise<WalletDeviceType>;
+  enable(): Promise<boolean>;
+  disconnect(): Promise<void>;
+  getAddresses(): Promise<string[]>;
+  getSessionOrConfirm(address: AccountAddress): Promise<string>;
+  sendEvmTransaction(transaction: unknown, _options: {
+    address: AccountAddress;
+    evmChainId: EvmChainId;
+  }): Promise<string>;
+  sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+  signEip712TypedData(eip712json: string, address: AccountAddress): Promise<string>;
+  signAminoCosmosTransaction(_transaction: {
+    address: string;
+    signDoc: StdSignDoc;
+  }): Promise<AminoSignResponse>;
+  signCosmosTransaction(_transaction: {
+    txRaw: TxRaw;
+    accountNumber: number;
+    chainId: string;
+    address: string;
+  }): Promise<DirectSignResponse>;
+  signArbitrary(signer: AccountAddress, data: string | Uint8Array): Promise<string>;
+  getEthereumChainId(): Promise<string>;
+  getEvmTransactionReceipt(txHash: string): Promise<string>;
+  getPubKey(): Promise<string>;
+  onChainIdChanged(callback: (chain: string) => void): Promise<void>;
+  onAccountChange(callback: (account: AccountAddress | string[]) => void): Promise<void>;
+  getEip1193Provider(): Promise<Eip1193Provider>;
+  addEvmNetwork(chainId: EvmChainId): Promise<void>;
+  private getEthereum;
+}
+//#endregion
+export { EvmWallet as EvmWalletStrategy, getBitGetProvider, getEvmProvider, getMetamaskProvider, getOkxWalletProvider, getPhantomProvider, getRabbyProvider, getRainbowProvider, getTrustWalletProvider, updateEvmNetwork };

package/dist/cjs/package.json

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