@injectivelabs/wallet-evm 1.15.0 → 1.15.2

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

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

package/dist/cjs/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/cjs/strategy/strategy.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmWallet = void 0;
+/* eslint-disable class-methods-use-this */
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const wallet_base_2 = require("@injectivelabs/wallet-base");
+const utils_1 = require("@injectivelabs/utils");
+const index_js_1 = require("./utils/index.js");
+class EvmWallet extends wallet_base_2.BaseConcreteStrategy {
+    wallet;
+    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.`));
+        }
+        this.wallet = args.wallet;
+    }
+    EvmWalletException(error, context) {
+        if (this.wallet === wallet_base_2.Wallet.Metamask) {
+            return new exceptions_1.MetamaskException(error, context);
+        }
+        if (this.wallet === wallet_base_2.Wallet.BitGet) {
+            return new exceptions_1.BitGetException(error, context);
+        }
+        if (this.wallet === wallet_base_2.Wallet.OkxWallet) {
+            return new exceptions_1.OkxWalletException(error, context);
+        }
+        if (this.wallet === wallet_base_2.Wallet.Phantom) {
+            return new exceptions_1.MetamaskException(error, context);
+        }
+        if (this.wallet === wallet_base_2.Wallet.TrustWallet) {
+            return new exceptions_1.TrustWalletException(error, context);
+        }
+        return new exceptions_1.WalletException(error, context);
+    }
+    async getWalletDeviceType() {
+        return Promise.resolve(wallet_base_2.WalletDeviceType.Browser);
+    }
+    async enable() {
+        return Promise.resolve(true);
+    }
+    async disconnect() {
+        if (this.listeners[wallet_base_2.WalletEventListener.AccountChange]) {
+            const ethereum = await this.getEthereum();
+            ethereum.removeListener('accountsChanged', this.listeners[wallet_base_2.WalletEventListener.AccountChange]);
+        }
+        if (this.listeners[wallet_base_2.WalletEventListener.ChainIdChange]) {
+            const ethereum = await this.getEthereum();
+            ethereum.removeListener('chainChanged', this.listeners[wallet_base_2.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_2.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: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_2.WalletAction.SendEthereumTransaction,
+            });
+        }
+    }
+    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_2.WalletAction.SignTransaction,
+                });
+            }
+            throw new exceptions_1.MetamaskException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_2.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_2.WalletAction.SignTransaction,
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    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_2.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_2.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_2.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 (0, utils_1.sleep)(interval);
+                await transactionReceiptRetry();
+            }
+            return receipt;
+        };
+        try {
+            return await transactionReceiptRetry();
+        }
+        catch (e) {
+            throw this.EvmWalletException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletError,
+                contextModule: wallet_base_2.WalletAction.GetEthereumTransactionReceipt,
+            });
+        }
+    }
+    // eslint-disable-next-line class-methods-use-this
+    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_2.WalletEventListener.ChainIdChange]: callback,
+        };
+        ethereum.on('chainChanged', callback);
+    }
+    async onAccountChange(callback) {
+        const ethereum = await this.getEthereum();
+        this.listeners = {
+            [wallet_base_2.WalletEventListener.AccountChange]: callback,
+        };
+        ethereum.on('accountsChanged', callback);
+    }
+    async getEthereum() {
+        const provider = this.wallet === wallet_base_2.Wallet.Metamask
+            ? await (0, index_js_1.getMetamaskProvider)()
+            : this.wallet === wallet_base_2.Wallet.Phantom
+                ? await (0, index_js_1.getPhantomProvider)()
+                : this.wallet === wallet_base_2.Wallet.BitGet
+                    ? await (0, index_js_1.getBitGetProvider)()
+                    : this.wallet === wallet_base_2.Wallet.OkxWallet
+                        ? await (0, index_js_1.getOkxWalletProvider)()
+                        : this.wallet === wallet_base_2.Wallet.TrustWallet
+                            ? await (0, index_js_1.getTrustWalletProvider)()
+                            : undefined;
+        if (!provider) {
+            throw this.EvmWalletException(new Error(`Please install the ${this.wallet} wallet extension.`), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                type: exceptions_1.ErrorType.WalletNotInstalledError,
+                contextModule: wallet_base_2.WalletAction.GetAccounts,
+            });
+        }
+        return provider;
+    }
+}
+exports.EvmWallet = EvmWallet;

package/dist/cjs/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/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 { 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,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/cjs/strategy/utils/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrustWalletProvider = exports.getMetamaskProvider = exports.getPhantomProvider = exports.getBitGetProvider = exports.getOkxWalletProvider = void 0;
+var Okx_js_1 = require("./Okx.js");
+Object.defineProperty(exports, "getOkxWalletProvider", { enumerable: true, get: function () { return Okx_js_1.getOkxWalletProvider; } });
+var bitget_js_1 = require("./bitget.js");
+Object.defineProperty(exports, "getBitGetProvider", { enumerable: true, get: function () { return bitget_js_1.getBitGetProvider; } });
+var phantom_js_1 = require("./phantom.js");
+Object.defineProperty(exports, "getPhantomProvider", { enumerable: true, get: function () { return phantom_js_1.getPhantomProvider; } });
+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 { 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 { 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/trustWallet.d.ts

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

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrustWalletProvider = getTrustWalletProvider;
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const $window = ((0, sdk_ts_1.isServerSide)()
+    ? {}
+    : window);
+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/cjs/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>;