@injectivelabs/wallet-evm 1.16.38-alpha.7 → 1.16.38

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export { EvmWallet as EvmWalletStrategy } from './strategy/strategy.js';
+export * from './strategy/utils/index.js';
+export * from './utils/index.js';

package/dist/cjs/index.js

@@ -0,0 +1,21 @@
+"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 });
+exports.EvmWalletStrategy = void 0;
+var strategy_js_1 = require("./strategy/strategy.js");
+Object.defineProperty(exports, "EvmWalletStrategy", { enumerable: true, get: function () { return strategy_js_1.EvmWallet; } });
+__exportStar(require("./strategy/utils/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/strategy.d.ts

@@ -0,0 +1,43 @@
+import { Wallet, WalletDeviceType, BaseConcreteStrategy } from '@injectivelabs/wallet-base';
+import type { AccountAddress, EvmChainId } from '@injectivelabs/ts-types';
+import type { ErrorContext, ThrownException } from '@injectivelabs/exceptions';
+import type { TxRaw, TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
+import type { StdSignDoc, Eip1193Provider, SendTransactionOptions, BrowserEip1993Provider, ConcreteWalletStrategy, ConcreteWalletStrategyArgs, ConcreteEvmWalletStrategyArgs } from '@injectivelabs/wallet-base';
+export 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;
+}

package/dist/cjs/strategy/strategy.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmWallet = void 0;
+const utils_1 = require("@injectivelabs/utils");
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const index_js_1 = require("./utils/index.js");
+class EvmWallet extends wallet_base_1.BaseConcreteStrategy {
+    wallet;
+    evmProviders = {};
+    constructor(args) {
+        super(args);
+        if (!(0, wallet_base_1.isEvmBrowserWallet)(args.wallet)) {
+            throw new exceptions_1.WalletException(new Error(`Evm Wallet for ${(0, utils_1.capitalize)(args.wallet)} is not supported.`));
+        }
+        if (!(0, sdk_ts_1.isServerSide)()) {
+            window.addEventListener('eip6963:announceProvider', (announcement) => {
+                const event = announcement;
+                const walletName = event.detail.info.name.toLowerCase();
+                if (walletName === wallet_base_1.Wallet.Metamask.toLowerCase()) {
+                    this.evmProviders[wallet_base_1.Wallet.Metamask] = event.detail.provider;
+                }
+                if (walletName === wallet_base_1.Wallet.Rabby.toLowerCase()) {
+                    this.evmProviders[wallet_base_1.Wallet.Rabby] = event.detail.provider;
+                }
+                if (walletName === wallet_base_1.Wallet.Rainbow.toLowerCase()) {
+                    this.evmProviders[wallet_base_1.Wallet.Rainbow] = event.detail.provider;
+                }
+                if (walletName === wallet_base_1.Wallet.Phantom.toLowerCase()) {
+                    this.evmProviders[wallet_base_1.Wallet.Phantom] = event.detail.provider;
+                }
+                if (walletName === wallet_base_1.Wallet.OkxWallet.toLowerCase()) {
+                    this.evmProviders[wallet_base_1.Wallet.OkxWallet] = event.detail.provider;
+                }
+                if (walletName === wallet_base_1.Wallet.BitGet.toLowerCase()) {
+                    this.evmProviders[wallet_base_1.Wallet.BitGet] = event.detail.provider;
+                }
+                if (walletName === wallet_base_1.Wallet.TrustWallet.toLowerCase()) {
+                    this.evmProviders[wallet_base_1.Wallet.TrustWallet] = event.detail.provider;
+                }
+            });
+            window.dispatchEvent(new Event('eip6963:requestProvider'));
+        }
+        this.wallet = args.wallet;
+    }
+    EvmWalletException(error, context) {
+        if (this.wallet === wallet_base_1.Wallet.Metamask) {
+            return new exceptions_1.MetamaskException(error, context);
+        }
+        if (this.wallet === wallet_base_1.Wallet.BitGet) {
+            return new exceptions_1.BitGetException(error, context);
+        }
+        if (this.wallet === wallet_base_1.Wallet.OkxWallet) {
+            return new exceptions_1.OkxWalletException(error, context);
+        }
+        if (this.wallet === wallet_base_1.Wallet.Phantom) {
+            return new exceptions_1.MetamaskException(error, context);
+        }
+        if (this.wallet === wallet_base_1.Wallet.TrustWallet) {
+            return new exceptions_1.TrustWalletException(error, context);
+        }
+        if (this.wallet === wallet_base_1.Wallet.Rainbow) {
+            return new exceptions_1.RainbowWalletException(error, context);
+        }
+        return new exceptions_1.WalletException(error, context);
+    }
+    async getWalletDeviceType() {
+        return Promise.resolve(wallet_base_1.WalletDeviceType.Browser);
+    }
+    async enable() {
+        return Promise.resolve(true);
+    }
+    async disconnect() {
+        if (this.listeners[wallet_base_1.WalletEventListener.AccountChange]) {
+            const ethereum = await this.getEthereum();
+            ethereum.removeListener('accountsChanged', this.listeners[wallet_base_1.WalletEventListener.AccountChange]);
+        }
+        if (this.listeners[wallet_base_1.WalletEventListener.ChainIdChange]) {
+            const ethereum = await this.getEthereum();
+            ethereum.removeListener('chainChanged', this.listeners[wallet_base_1.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: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.GetAccounts,
+            });
+        }
+    }
+    async getSessionOrConfirm(address) {
+        return Promise.resolve(`0x${Buffer.from(`Confirmation for ${address} at time: ${Date.now()}`).toString('hex')}`);
+    }
+    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: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.SendEvmTransaction,
+            });
+        }
+    }
+    async sendTransaction(transaction, options) {
+        const { endpoints, txTimeout } = options;
+        if (!endpoints) {
+            throw new exceptions_1.WalletException(new Error('You have to pass endpoints within the options for using Ethereum native wallets'));
+        }
+        const txApi = new sdk_ts_1.TxGrpcApi(endpoints.grpc);
+        const response = await txApi.broadcast(transaction, { txTimeout });
+        if (response.code !== 0) {
+            throw new exceptions_1.TransactionException(new Error(response.rawLog), {
+                code: exceptions_1.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 exceptions_1.MetamaskException(new Error('Please connect directly with Ledger to sign this transaction'), {
+                    code: exceptions_1.UnspecifiedErrorCode,
+                    type: exceptions_1.ErrorType.WalletError,
+                    contextModule: wallet_base_1.WalletAction.SignTransaction,
+                });
+            }
+            throw new exceptions_1.MetamaskException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.SignTransaction,
+            });
+        }
+    }
+    async signAminoCosmosTransaction(_transaction) {
+        throw new exceptions_1.WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            type: exceptions_1.ErrorType.WalletError,
+            contextModule: wallet_base_1.WalletAction.SignTransaction,
+        });
+    }
+    async signCosmosTransaction(_transaction) {
+        throw new exceptions_1.WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            type: exceptions_1.ErrorType.WalletError,
+            contextModule: wallet_base_1.WalletAction.SignTransaction,
+        });
+    }
+    async signArbitrary(signer, data) {
+        const ethereum = await this.getEthereum();
+        try {
+            const signature = await ethereum.request({
+                method: 'personal_sign',
+                params: [(0, sdk_ts_1.toUtf8)(data), signer],
+            });
+            return signature;
+        }
+        catch (e) {
+            throw this.EvmWalletException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.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: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.GetChainId,
+            });
+        }
+    }
+    async getEvmTransactionReceipt(txHash) {
+        const ethereum = await this.getEthereum();
+        const interval = 3000;
+        const maxAttempts = 10;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            attempts++;
+            await (0, utils_1.sleep)(interval);
+            try {
+                const receipt = await ethereum.request({
+                    method: 'eth_getTransactionReceipt',
+                    params: [txHash],
+                });
+                if (receipt) {
+                    return txHash;
+                }
+            }
+            catch { }
+        }
+        throw new Error(`Failed to retrieve transaction receipt for txHash: ${txHash}`);
+    }
+    async getPubKey() {
+        throw new exceptions_1.WalletException(new Error('You can only fetch PubKey from Cosmos native wallets'));
+    }
+    async onChainIdChanged(callback) {
+        const ethereum = await this.getEthereum();
+        this.listeners = {
+            [wallet_base_1.WalletEventListener.ChainIdChange]: callback,
+        };
+        ethereum.on('chainChanged', callback);
+    }
+    async onAccountChange(callback) {
+        const ethereum = await this.getEthereum();
+        this.listeners = {
+            [wallet_base_1.WalletEventListener.AccountChange]: callback,
+        };
+        ethereum.on('accountsChanged', callback);
+    }
+    async getEip1193Provider() {
+        return this.getEthereum();
+    }
+    async addEvmNetwork(chainId) {
+        const ethereum = await this.getEthereum();
+        const chainIdToHex = chainId.toString(16);
+        const chain = (0, wallet_base_1.getEvmChainConfig)(chainId);
+        const params = {
+            chainId: `0x${chainIdToHex}`,
+            chainName: chain.name,
+            rpcUrls: [...(chain.rpcUrls?.default?.http || [])],
+            blockExplorerUrls: chain.blockExplorers?.default?.url
+                ? [chain.blockExplorers.default.url]
+                : [],
+            nativeCurrency: chain.nativeCurrency,
+        };
+        try {
+            await Promise.race([
+                ethereum.request({
+                    method: 'wallet_switchEthereumChain',
+                    params: [{ chainId: `0x${chainIdToHex}` }],
+                }),
+                new Promise((resolve) => ethereum.on('chainChanged', ({ chain }) => {
+                    if (chain?.id === chainIdToHex) {
+                        resolve();
+                    }
+                })),
+            ]);
+        }
+        catch (error) {
+            if (error.code === 4902) {
+                await ethereum.request({
+                    method: 'wallet_addEthereumChain',
+                    params: [params],
+                });
+                return;
+            }
+            throw this.EvmWalletException(new Error(`Something went wrong while adding ${(0, utils_1.capitalize)(this.wallet || 'wallet')} network`), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_1.WalletAction.GetChainId,
+            });
+        }
+    }
+    async getEthereum() {
+        const evmProvider = this.evmProviders[this.wallet];
+        if (evmProvider) {
+            return evmProvider;
+        }
+        const backUpProvider = this.wallet === wallet_base_1.Wallet.Metamask
+            ? await (0, index_js_1.getMetamaskProvider)()
+            : this.wallet === wallet_base_1.Wallet.Rabby
+                ? await (0, index_js_1.getRabbyProvider)()
+                : this.wallet === wallet_base_1.Wallet.Phantom
+                    ? await (0, index_js_1.getPhantomProvider)()
+                    : this.wallet === wallet_base_1.Wallet.BitGet
+                        ? await (0, index_js_1.getBitGetProvider)()
+                        : this.wallet === wallet_base_1.Wallet.OkxWallet
+                            ? await (0, index_js_1.getOkxWalletProvider)()
+                            : this.wallet === wallet_base_1.Wallet.TrustWallet
+                                ? await (0, index_js_1.getTrustWalletProvider)()
+                                : this.wallet === wallet_base_1.Wallet.Rainbow
+                                    ? await (0, index_js_1.getRainbowProvider)()
+                                    : undefined;
+        if (!backUpProvider) {
+            throw this.EvmWalletException(new Error(`Please install the ${this.wallet} wallet extension.`), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletNotInstalledError,
+                contextModule: wallet_base_1.WalletAction.GetAccounts,
+            });
+        }
+        return backUpProvider;
+    }
+}
+exports.EvmWallet = EvmWallet;

package/dist/cjs/strategy/utils/Okx.d.ts

@@ -0,0 +1,4 @@
+import type { BrowserEip1993Provider } from '@injectivelabs/wallet-base';
+export declare function getOkxWalletProvider({ timeout }?: {
+    timeout: number;
+}): Promise<BrowserEip1993Provider>;

package/dist/cjs/strategy/utils/Okx.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOkxWalletProvider = getOkxWalletProvider;
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const $window = ((0, sdk_ts_1.isServerSide)()
+    ? {}
+    : window);
+async function getOkxWalletProvider({ timeout } = { timeout: 3000 }) {
+    const provider = getOkxWalletFromWindow();
+    if (provider) {
+        return provider;
+    }
+    return listenForOkxWalletInitialized({
+        timeout,
+    });
+}
+async function listenForOkxWalletInitialized({ timeout } = { timeout: 3000 }) {
+    return new Promise((resolve) => {
+        const handleInitialization = () => {
+            resolve(getOkxWalletFromWindow());
+        };
+        $window.addEventListener('okxwallet#initialized', handleInitialization, {
+            once: true,
+        });
+        setTimeout(() => {
+            $window.removeEventListener('okxwallet#initialized', handleInitialization);
+            resolve(null);
+        }, timeout);
+    });
+}
+function getOkxWalletFromWindow() {
+    const injectedProviderExist = typeof window !== 'undefined' &&
+        (typeof $window.ethereum !== 'undefined' ||
+            typeof $window.okxwallet !== 'undefined');
+    // No injected providers exist.
+    if (!injectedProviderExist) {
+        return;
+    }
+    if ($window.okxwallet) {
+        return $window.okxwallet;
+    }
+    if ($window.ethereum.isOkxWallet) {
+        return $window.ethereum;
+    }
+    if ($window.providers) {
+        return $window.providers.find((p) => p.isOkxWallet);
+    }
+    return;
+}

package/dist/cjs/strategy/utils/bitget.d.ts

@@ -0,0 +1,4 @@
+import type { BrowserEip1993Provider } from '@injectivelabs/wallet-base';
+export declare function getBitGetProvider({ timeout }?: {
+    timeout: number;
+}): Promise<BrowserEip1993Provider>;

package/dist/cjs/strategy/utils/bitget.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBitGetProvider = getBitGetProvider;
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const $window = ((0, sdk_ts_1.isServerSide)()
+    ? {}
+    : window);
+async function getBitGetProvider({ timeout } = { timeout: 3000 }) {
+    const provider = getBitGetFromWindow();
+    if (provider) {
+        return provider;
+    }
+    return listenForBitGetInitialized({
+        timeout,
+    });
+}
+async function listenForBitGetInitialized({ timeout } = { timeout: 3000 }) {
+    return new Promise((resolve) => {
+        const handleInitialization = () => {
+            resolve(getBitGetFromWindow());
+        };
+        $window.addEventListener('bitkeep#initialized', handleInitialization, {
+            once: true,
+        });
+        setTimeout(() => {
+            $window.removeEventListener('bitkeep#initialized', handleInitialization);
+            resolve(null);
+        }, timeout);
+    });
+}
+function getBitGetFromWindow() {
+    const injectedProviderExist = typeof window !== 'undefined' &&
+        (typeof $window.ethereum !== 'undefined' ||
+            typeof $window.bitkeep !== 'undefined');
+    // No injected providers exist.
+    if (!injectedProviderExist) {
+        return;
+    }
+    if ($window.bitkeep && $window.bitkeep.ethereum) {
+        return $window.bitkeep.ethereum;
+    }
+    return;
+}

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

@@ -0,0 +1,7 @@
+export { getRabbyProvider } from './rabby.js';
+export { getBitGetProvider } from './bitget.js';
+export { getOkxWalletProvider } from './Okx.js';
+export { getPhantomProvider } from './phantom.js';
+export { getRainbowProvider } from './rainbow.js';
+export { getMetamaskProvider } from './metamask.js';
+export { getTrustWalletProvider } from './trustWallet.js';

package/dist/cjs/strategy/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrustWalletProvider = exports.getMetamaskProvider = exports.getRainbowProvider = exports.getPhantomProvider = exports.getOkxWalletProvider = exports.getBitGetProvider = exports.getRabbyProvider = void 0;
+var rabby_js_1 = require("./rabby.js");
+Object.defineProperty(exports, "getRabbyProvider", { enumerable: true, get: function () { return rabby_js_1.getRabbyProvider; } });
+var bitget_js_1 = require("./bitget.js");
+Object.defineProperty(exports, "getBitGetProvider", { enumerable: true, get: function () { return bitget_js_1.getBitGetProvider; } });
+var Okx_js_1 = require("./Okx.js");
+Object.defineProperty(exports, "getOkxWalletProvider", { enumerable: true, get: function () { return Okx_js_1.getOkxWalletProvider; } });
+var phantom_js_1 = require("./phantom.js");
+Object.defineProperty(exports, "getPhantomProvider", { enumerable: true, get: function () { return phantom_js_1.getPhantomProvider; } });
+var rainbow_js_1 = require("./rainbow.js");
+Object.defineProperty(exports, "getRainbowProvider", { enumerable: true, get: function () { return rainbow_js_1.getRainbowProvider; } });
+var metamask_js_1 = require("./metamask.js");
+Object.defineProperty(exports, "getMetamaskProvider", { enumerable: true, get: function () { return metamask_js_1.getMetamaskProvider; } });
+var trustWallet_js_1 = require("./trustWallet.js");
+Object.defineProperty(exports, "getTrustWalletProvider", { enumerable: true, get: function () { return trustWallet_js_1.getTrustWalletProvider; } });

package/dist/cjs/strategy/utils/metamask.d.ts

@@ -0,0 +1,4 @@
+import type { BrowserEip1993Provider } from '@injectivelabs/wallet-base';
+export declare function getMetamaskProvider({ timeout }?: {
+    timeout: number;
+}): Promise<BrowserEip1993Provider>;

package/dist/cjs/strategy/utils/metamask.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetamaskProvider = getMetamaskProvider;
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const $window = ((0, sdk_ts_1.isServerSide)()
+    ? {}
+    : window);
+async function getMetamaskProvider({ timeout } = { timeout: 3000 }) {
+    const provider = getMetamaskFromWindow();
+    if (provider) {
+        return provider;
+    }
+    return listenForMetamaskInitialized({
+        timeout,
+    });
+}
+async function listenForMetamaskInitialized({ timeout } = { timeout: 3000 }) {
+    return new Promise((resolve) => {
+        const handleInitialization = () => {
+            resolve(getMetamaskFromWindow());
+        };
+        $window.addEventListener('ethereum#initialized', handleInitialization, {
+            once: true,
+        });
+        setTimeout(() => {
+            $window.removeEventListener('ethereum#initialized', handleInitialization);
+            resolve(null);
+        }, timeout);
+    });
+}
+function getMetamaskFromWindow() {
+    const injectedProviderExist = typeof window !== 'undefined' && typeof $window.ethereum !== 'undefined';
+    // No injected providers exist.
+    if (!injectedProviderExist) {
+        return;
+    }
+    if ($window.ethereum.isMetaMask) {
+        return $window.ethereum;
+    }
+    if ($window.providers) {
+        return $window.providers.find((p) => p.isMetaMask);
+    }
+    return;
+}

package/dist/cjs/strategy/utils/phantom.d.ts

@@ -0,0 +1,4 @@
+import type { BrowserEip1993Provider } from '@injectivelabs/wallet-base';
+export declare function getPhantomProvider({ timeout }?: {
+    timeout: number;
+}): Promise<BrowserEip1993Provider>;

package/dist/cjs/strategy/utils/phantom.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPhantomProvider = getPhantomProvider;
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const $window = ((0, sdk_ts_1.isServerSide)()
+    ? {}
+    : window);
+async function getPhantomProvider({ timeout } = { timeout: 3000 }) {
+    const provider = getPhantomFromWindow();
+    if (provider) {
+        return provider;
+    }
+    return listenForPhantomInitialized({
+        timeout,
+    });
+}
+async function listenForPhantomInitialized({ timeout } = { timeout: 3000 }) {
+    return new Promise((resolve) => {
+        const handleInitialization = () => {
+            resolve(getPhantomFromWindow());
+        };
+        $window.addEventListener('phantom#initialized', handleInitialization, {
+            once: true,
+        });
+        setTimeout(() => {
+            $window.removeEventListener('phantom#initialized', handleInitialization);
+            resolve(null);
+        }, timeout);
+    });
+}
+function getPhantomFromWindow() {
+    const injectedProviderExist = typeof window !== 'undefined' &&
+        (typeof $window.ethereum !== 'undefined' ||
+            typeof $window.phantom !== 'undefined');
+    // No injected providers exist.
+    if (!injectedProviderExist) {
+        return;
+    }
+    if ($window.phantom) {
+        return $window.phantom.ethereum;
+    }
+    if ($window.ethereum.isPhantom) {
+        return $window.ethereum;
+    }
+    if ($window.providers) {
+        return $window.providers.find((p) => p.isPhantom);
+    }
+    return;
+}

package/dist/cjs/strategy/utils/rabby.d.ts

@@ -0,0 +1,4 @@
+import type { BrowserEip1993Provider } from '@injectivelabs/wallet-base';
+export declare function getRabbyProvider({ timeout }?: {
+    timeout: number;
+}): Promise<BrowserEip1993Provider>;