@injectivelabs/wallet-evm 1.15.0 → 1.15.2

package/dist/cjs/utils/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateEvmNetwork = exports.getEvmProvider = void 0;
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const utils_1 = require("@injectivelabs/utils");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const Okx_js_1 = require("../strategy/utils/Okx.js");
+const bitget_js_1 = require("../strategy/utils/bitget.js");
+const phantom_js_1 = require("../strategy/utils/phantom.js");
+const metamask_js_1 = require("../strategy/utils/metamask.js");
+const trustWallet_js_1 = require("../strategy/utils/trustWallet.js");
+const getEvmProvider = async (wallet) => {
+    if (!(0, wallet_base_1.isEvmBrowserWallet)(wallet)) {
+        throw new exceptions_1.WalletException(new Error(`Evm Wallet for ${(0, utils_1.capitalize)(wallet)} is not supported.`));
+    }
+    try {
+        let provider;
+        if (wallet === wallet_base_1.Wallet.Metamask) {
+            provider = (await (0, metamask_js_1.getMetamaskProvider)());
+        }
+        if (wallet === wallet_base_1.Wallet.BitGet) {
+            provider = (await (0, bitget_js_1.getBitGetProvider)());
+        }
+        if (wallet === wallet_base_1.Wallet.Phantom) {
+            provider = (await (0, phantom_js_1.getPhantomProvider)());
+        }
+        if (wallet === wallet_base_1.Wallet.TrustWallet) {
+            provider = (await (0, trustWallet_js_1.getTrustWalletProvider)());
+        }
+        if (wallet === wallet_base_1.Wallet.OkxWallet) {
+            provider = (await (0, Okx_js_1.getOkxWalletProvider)());
+        }
+        if (!provider) {
+            throw new exceptions_1.WalletException(new Error(`Please install ${(0, utils_1.capitalize)(wallet)} Extension`));
+        }
+        return provider;
+    }
+    catch (e) {
+        throw new exceptions_1.WalletException(new Error(`Please install ${(0, utils_1.capitalize)(wallet)} Extension`));
+    }
+};
+exports.getEvmProvider = getEvmProvider;
+const updateEvmNetwork = async (wallet, chainId) => {
+    if (!(0, wallet_base_1.isEvmBrowserWallet)(wallet)) {
+        throw new exceptions_1.WalletException(new Error(`Evm Wallet for ${(0, utils_1.capitalize)(wallet)} is not supported.`));
+    }
+    const provider = (await (0, exports.getEvmProvider)(wallet));
+    if (!provider) {
+        throw new exceptions_1.WalletException(new Error(`Please install ${(0, utils_1.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?.id === chainIdToHex) {
+                    resolve();
+                }
+            })),
+        ]);
+    }
+    catch (e) {
+        throw new exceptions_1.WalletException(new Error(`Please update your ${(0, utils_1.capitalize)(wallet)} network`));
+    }
+};
+exports.updateEvmNetwork = updateEvmNetwork;

package/dist/esm/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/esm/index.js

@@ -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/esm/package.json

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

package/dist/esm/strategy/strategy.d.ts

@@ -0,0 +1,39 @@
+import { TxRaw, TxResponse, DirectSignResponse, AminoSignResponse } from '@injectivelabs/sdk-ts';
+import { ErrorContext, ThrownException } from '@injectivelabs/exceptions';
+import { Wallet, StdSignDoc, WalletDeviceType, BaseConcreteStrategy, SendTransactionOptions, ConcreteWalletStrategy, ConcreteWalletStrategyArgs, ConcreteEthereumWalletStrategyArgs } from '@injectivelabs/wallet-base';
+import { AccountAddress, EthereumChainId } from '@injectivelabs/ts-types';
+export declare class EvmWallet extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+    wallet?: Wallet;
+    constructor(args: (ConcreteWalletStrategyArgs | ConcreteEthereumWalletStrategyArgs) & {
+        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>;
+    sendEthereumTransaction(transaction: unknown, _options: {
+        address: AccountAddress;
+        ethereumChainId: EthereumChainId;
+    }): 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>;
+    getEthereumTransactionReceipt(txHash: string): Promise<string>;
+    getPubKey(): Promise<string>;
+    onChainIdChanged(callback: (chain: string) => void): Promise<void>;
+    onAccountChange(callback: (account: AccountAddress | string[]) => void): Promise<void>;
+    private getEthereum;
+}

package/dist/esm/strategy/strategy.js

@@ -0,0 +1,235 @@
+/* eslint-disable class-methods-use-this */
+import { isEvmBrowserWallet } from '@injectivelabs/wallet-base';
+import { toUtf8, TxGrpcApi, } from '@injectivelabs/sdk-ts';
+import { ErrorType, WalletException, BitGetException, MetamaskException, OkxWalletException, UnspecifiedErrorCode, TransactionException, TrustWalletException, } from '@injectivelabs/exceptions';
+import { Wallet, WalletAction, WalletDeviceType, WalletEventListener, BaseConcreteStrategy, } from '@injectivelabs/wallet-base';
+import { sleep, capitalize } from '@injectivelabs/utils';
+import { getBitGetProvider, getPhantomProvider, getMetamaskProvider, getOkxWalletProvider, getTrustWalletProvider, } from './utils/index.js';
+export class EvmWallet extends BaseConcreteStrategy {
+    wallet;
+    constructor(args) {
+        super(args);
+        if (!isEvmBrowserWallet(args.wallet)) {
+            throw new WalletException(new Error(`Evm Wallet for ${capitalize(args.wallet)} is not supported.`));
+        }
+        this.wallet = args.wallet;
+    }
+    EvmWalletException(error, context) {
+        if (this.wallet === Wallet.Metamask) {
+            return new MetamaskException(error, context);
+        }
+        if (this.wallet === Wallet.BitGet) {
+            return new BitGetException(error, context);
+        }
+        if (this.wallet === Wallet.OkxWallet) {
+            return new OkxWalletException(error, context);
+        }
+        if (this.wallet === Wallet.Phantom) {
+            return new MetamaskException(error, context);
+        }
+        if (this.wallet === Wallet.TrustWallet) {
+            return new TrustWalletException(error, context);
+        }
+        return new WalletException(error, context);
+    }
+    async getWalletDeviceType() {
+        return Promise.resolve(WalletDeviceType.Browser);
+    }
+    async enable() {
+        return Promise.resolve(true);
+    }
+    async disconnect() {
+        if (this.listeners[WalletEventListener.AccountChange]) {
+            const ethereum = await this.getEthereum();
+            ethereum.removeListener('accountsChanged', this.listeners[WalletEventListener.AccountChange]);
+        }
+        if (this.listeners[WalletEventListener.ChainIdChange]) {
+            const ethereum = await this.getEthereum();
+            ethereum.removeListener('chainChanged', this.listeners[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: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.GetAccounts,
+            });
+        }
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async getSessionOrConfirm(address) {
+        return Promise.resolve(`0x${Buffer.from(`Confirmation for ${address} at time: ${Date.now()}`).toString('hex')}`);
+    }
+    async sendEthereumTransaction(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: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.SendEthereumTransaction,
+            });
+        }
+    }
+    async sendTransaction(transaction, options) {
+        const { endpoints, txTimeout } = options;
+        if (!endpoints) {
+            throw new WalletException(new Error('You have to pass endpoints within the options for using Ethereum native wallets'));
+        }
+        const txApi = new TxGrpcApi(endpoints.grpc);
+        const response = await txApi.broadcast(transaction, { txTimeout });
+        if (response.code !== 0) {
+            throw new TransactionException(new Error(response.rawLog), {
+                code: 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 MetamaskException(new Error('Please connect directly with Ledger to sign this transaction'), {
+                    code: UnspecifiedErrorCode,
+                    type: ErrorType.WalletError,
+                    contextModule: WalletAction.SignTransaction,
+                });
+            }
+            throw new MetamaskException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.SignTransaction,
+            });
+        }
+    }
+    async signAminoCosmosTransaction(_transaction) {
+        throw new WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: UnspecifiedErrorCode,
+            type: ErrorType.WalletError,
+            contextModule: WalletAction.SignTransaction,
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async signCosmosTransaction(_transaction) {
+        throw new WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: UnspecifiedErrorCode,
+            type: ErrorType.WalletError,
+            contextModule: WalletAction.SignTransaction,
+        });
+    }
+    async signArbitrary(signer, data) {
+        const ethereum = await this.getEthereum();
+        try {
+            const signature = await ethereum.request({
+                method: 'personal_sign',
+                params: [toUtf8(data), signer],
+            });
+            return signature;
+        }
+        catch (e) {
+            throw this.EvmWalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: 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: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.GetChainId,
+            });
+        }
+    }
+    async getEthereumTransactionReceipt(txHash) {
+        const ethereum = await this.getEthereum();
+        const interval = 1000;
+        const transactionReceiptRetry = async () => {
+            const receipt = (await ethereum.request({
+                method: 'eth_getTransactionReceipt',
+                params: [txHash],
+            }));
+            if (!receipt) {
+                await sleep(interval);
+                await transactionReceiptRetry();
+            }
+            return receipt;
+        };
+        try {
+            return await transactionReceiptRetry();
+        }
+        catch (e) {
+            throw this.EvmWalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.GetEthereumTransactionReceipt,
+            });
+        }
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async getPubKey() {
+        throw new WalletException(new Error('You can only fetch PubKey from Cosmos native wallets'));
+    }
+    async onChainIdChanged(callback) {
+        const ethereum = await this.getEthereum();
+        this.listeners = {
+            [WalletEventListener.ChainIdChange]: callback,
+        };
+        ethereum.on('chainChanged', callback);
+    }
+    async onAccountChange(callback) {
+        const ethereum = await this.getEthereum();
+        this.listeners = {
+            [WalletEventListener.AccountChange]: callback,
+        };
+        ethereum.on('accountsChanged', callback);
+    }
+    async getEthereum() {
+        const provider = this.wallet === Wallet.Metamask
+            ? await getMetamaskProvider()
+            : this.wallet === Wallet.Phantom
+                ? await getPhantomProvider()
+                : this.wallet === Wallet.BitGet
+                    ? await getBitGetProvider()
+                    : this.wallet === Wallet.OkxWallet
+                        ? await getOkxWalletProvider()
+                        : this.wallet === Wallet.TrustWallet
+                            ? await getTrustWalletProvider()
+                            : undefined;
+        if (!provider) {
+            throw this.EvmWalletException(new Error(`Please install the ${this.wallet} wallet extension.`), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletNotInstalledError,
+                contextModule: WalletAction.GetAccounts,
+            });
+        }
+        return provider;
+    }
+}

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

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

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

@@ -0,0 +1,46 @@
+import { isServerSide } from '@injectivelabs/sdk-ts';
+const $window = (isServerSide()
+    ? {}
+    : window);
+export 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/esm/strategy/utils/bitget.d.ts

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

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

@@ -0,0 +1,40 @@
+import { isServerSide } from '@injectivelabs/sdk-ts';
+const $window = (isServerSide()
+    ? {}
+    : window);
+export 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/esm/strategy/utils/index.d.ts

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

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

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

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

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

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

@@ -0,0 +1,41 @@
+import { isServerSide } from '@injectivelabs/sdk-ts';
+const $window = (isServerSide()
+    ? {}
+    : window);
+export 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/esm/strategy/utils/phantom.d.ts

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

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

@@ -0,0 +1,46 @@
+import { isServerSide } from '@injectivelabs/sdk-ts';
+const $window = (isServerSide()
+    ? {}
+    : window);
+export 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/esm/strategy/utils/trustWallet.d.ts

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

package/dist/esm/strategy/utils/trustWallet.js

@@ -0,0 +1,46 @@
+import { isServerSide } from '@injectivelabs/sdk-ts';
+const $window = (isServerSide()
+    ? {}
+    : window);
+export async function getTrustWalletProvider({ timeout } = { timeout: 3000 }) {
+    const provider = getTrustWalletFromWindow();
+    if (provider) {
+        return provider;
+    }
+    return listenForTrustWalletInitialized({
+        timeout,
+    });
+}
+async function listenForTrustWalletInitialized({ timeout } = { timeout: 3000 }) {
+    return new Promise((resolve) => {
+        const handleInitialization = () => {
+            resolve(getTrustWalletFromWindow());
+        };
+        $window.addEventListener('trustwallet#initialized', handleInitialization, {
+            once: true,
+        });
+        setTimeout(() => {
+            $window.removeEventListener('trustwallet#initialized', handleInitialization);
+            resolve(null);
+        }, timeout);
+    });
+}
+function getTrustWalletFromWindow() {
+    const injectedProviderExist = typeof window !== 'undefined' &&
+        (typeof $window.ethereum !== 'undefined' ||
+            typeof $window.trustWallet !== 'undefined');
+    // No injected providers exist.
+    if (!injectedProviderExist) {
+        return;
+    }
+    if ($window.trustWallet) {
+        return $window.trustWallet;
+    }
+    if ($window.ethereum.isTrustWallet || $window.ethereum.isTrust) {
+        return $window.ethereum;
+    }
+    if ($window.providers) {
+        return $window.providers.find((p) => p.isTrustWallet);
+    }
+    return;
+}

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

@@ -0,0 +1,4 @@
+import { Wallet, BrowserEip1993Provider } from '@injectivelabs/wallet-base';
+import { EthereumChainId } from '@injectivelabs/ts-types';
+export declare const getEvmProvider: (wallet: Wallet) => Promise<BrowserEip1993Provider>;
+export declare const updateEvmNetwork: (wallet: Wallet, chainId: EthereumChainId) => Promise<unknown>;