@broxus/evm-connect 1.0.0

package/dist/esm/core/MetaMask.d.ts

@@ -0,0 +1,24 @@
+import detectEthereumProvider from '@metamask/detect-provider';
+import { type EthExecutionAPI, type MetaMaskProvider, type ProviderConnectInfo } from 'web3-types';
+import { EthereumConnector, type EthereumConnectorCtorParams } from '../core/EthereumConnector';
+import { type AddEthereumChainParams, ConnectionType } from '../types';
+interface MetaMaskEthereumProvider extends MetaMaskProvider<EthExecutionAPI> {
+    isConnected?: () => boolean;
+    providers?: MetaMaskEthereumProvider[];
+    get accounts(): string[];
+    get chainId(): string;
+}
+export interface MetaMaskCtorParams extends EthereumConnectorCtorParams {
+    options?: Parameters<typeof detectEthereumProvider>[0];
+}
+export declare class MetaMask extends EthereumConnector {
+    protected readonly params?: Readonly<MetaMaskCtorParams> | undefined;
+    readonly type = ConnectionType.INJECTED;
+    provider?: MetaMaskEthereumProvider;
+    constructor(params?: Readonly<MetaMaskCtorParams> | undefined);
+    connect(chainIdOrParams?: number | AddEthereumChainParams): Promise<void>;
+    disconnect(): Promise<void>;
+    protected init(): Promise<void>;
+    protected handleConnect({ chainId }: ProviderConnectInfo): void;
+}
+export {};

package/dist/esm/core/MetaMask.js

@@ -0,0 +1,152 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { debug, error, throwException } from '@broxus/js-utils';
+import detectEthereumProvider from '@metamask/detect-provider';
+import { action, makeObservable, override } from 'mobx';
+import { EthereumConnector } from '../core/EthereumConnector';
+import { ConnectionType, EIP6963Event } from '../types';
+import { parseChainId } from '../utils';
+const INJECTABLE_WALLETS = ['isBraveWallet', 'isRabby', 'isLedgerConnect', 'isTrust'];
+export class MetaMask extends EthereumConnector {
+    params;
+    type = ConnectionType.INJECTED;
+    constructor(params) {
+        super(params);
+        this.params = params;
+        makeObservable(this);
+        this.init().catch(error);
+    }
+    async connect(chainIdOrParams) {
+        if (!this.provider) {
+            throw new Error('Provider is not defined');
+        }
+        try {
+            this.setState('isConnecting', true);
+            const accounts = (await this.provider.request({ method: 'eth_requestAccounts' }));
+            const chainId = (await this.provider.request({ method: 'eth_chainId' }));
+            debug('Connect to MetaMask connection', accounts, chainId);
+            const receivedChainId = parseChainId(chainId);
+            const desiredChainId = typeof chainIdOrParams === 'number' ? chainIdOrParams : chainIdOrParams?.chainId;
+            if (!desiredChainId || receivedChainId === desiredChainId) {
+                this.setData({ accounts, chainId: receivedChainId });
+                this.setState({ isConnecting: false, isInitialized: true });
+                debug('MetaMask connection has skipped network switching.');
+                return;
+            }
+            if (!chainIdOrParams) {
+                debug('MetaMask connection has skipped network switching. Chain params or chainId is not provided.');
+                return;
+            }
+            debug('MetaMask connection trying to switch network.');
+            await this.switchNetwork(chainIdOrParams).then(async () => {
+                await this.connect(desiredChainId);
+            });
+        }
+        catch (e) {
+            this.setState('isConnecting', false);
+            throw e;
+        }
+    }
+    async disconnect() {
+        if (!this.provider) {
+            this.setState('isDisconnecting', false);
+            return;
+        }
+        try {
+            debug('Disconnect from MetaMask connection');
+            this.setState('isDisconnecting', true);
+            this.setData({ accounts: undefined, chainId: undefined });
+            this.setState('isDisconnecting', false);
+        }
+        catch (e) {
+            this.setState('isDisconnecting', false);
+            throw e;
+        }
+    }
+    async init() {
+        const onAnnouncement = (event) => {
+            if (event.detail.info.name === 'MetaMask' && event.detail.info.rdns === 'io.metamask') {
+                this.provider = event.detail.provider;
+            }
+        };
+        try {
+            this.setState('isInitializing', true);
+            const provider = await detectEthereumProvider(this.params?.options);
+            if (provider) {
+                this.provider = provider;
+                // Handle the case when e.g. metamask and coinbase wallet are both installed
+                if (this.provider.providers?.length) {
+                    this.provider = this.provider.providers.find(value => value.isMetaMask) ?? this.provider.providers[0];
+                }
+                window.addEventListener(EIP6963Event.ANNOUNCE_PROVIDER, onAnnouncement);
+                window.dispatchEvent(new Event(EIP6963Event.REQUEST_PROVIDER));
+                if (Object.keys(provider).some(key => INJECTABLE_WALLETS.includes(key))) {
+                    this.provider = undefined;
+                    throwException('No MetaMask provider found');
+                }
+            }
+        }
+        catch (e) {
+            window.removeEventListener(EIP6963Event.ANNOUNCE_PROVIDER, onAnnouncement);
+        }
+        if (!this.provider) {
+            this.setState({ isInitialized: false, isInitializing: false });
+            return;
+        }
+        try {
+            this.provider.on('accountsChanged', this.handleAccountsChanged);
+            this.provider.on('chainChanged', this.handleChainChanged);
+            this.provider.on('connect', this.handleConnect);
+            this.provider.on('disconnect', this.handleDisconnect);
+            const accounts = (await this.provider.request({ method: 'eth_accounts' }));
+            if (!accounts.length) {
+                throwException('No accounts returned');
+            }
+            const chainId = (await this.provider.request({ method: 'eth_chainId' }));
+            this.setData({ accounts, chainId: parseChainId(chainId) });
+            this.setState({ isInitialized: true, isInitializing: false });
+        }
+        catch (e) {
+            debug('MetaMask could not be pre-connected', e);
+            this.setState({ isInitialized: false, isInitializing: false });
+        }
+    }
+    handleConnect({ chainId }) {
+        this.setData({ chainId: parseChainId(chainId) });
+    }
+}
+__decorate([
+    override,
+    __metadata("design:type", Object)
+], MetaMask.prototype, "provider", void 0);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MetaMask.prototype, "connect", null);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MetaMask.prototype, "disconnect", null);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MetaMask.prototype, "init", null);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], MetaMask.prototype, "handleConnect", null);

package/dist/esm/core/WalletConnect.d.ts

@@ -0,0 +1,20 @@
+import EthereumProvider, { type EthereumProviderOptions } from '@walletconnect/ethereum-provider';
+import { EthereumConnector, type EthereumConnectorCtorParams } from '../core';
+import { type AddEthereumChainParams, ConnectionType } from '../types';
+export interface WalletConnectOptions extends Omit<EthereumProviderOptions, 'rpcMap'> {
+    rpcMap?: Record<number, string | string[]>;
+}
+export interface WalletConnectCtorParams extends EthereumConnectorCtorParams {
+    options: WalletConnectOptions;
+}
+export declare class WalletConnect extends EthereumConnector {
+    protected readonly params: Readonly<WalletConnectCtorParams>;
+    readonly type = ConnectionType.WALLET_CONNECT_V2;
+    provider?: EthereumProvider;
+    protected readonly options: WalletConnectOptions;
+    constructor(params: Readonly<WalletConnectCtorParams>);
+    connect(chainIdOrParams?: number | AddEthereumChainParams): Promise<void>;
+    disconnect(): Promise<void>;
+    protected init(): Promise<void>;
+    protected createProvider(): Promise<EthereumProvider>;
+}

package/dist/esm/core/WalletConnect.js

@@ -0,0 +1,134 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { debug, error, throwException } from '@broxus/js-utils';
+import EthereumProvider from '@walletconnect/ethereum-provider';
+import { action, makeObservable, override } from 'mobx';
+import { EthereumConnector } from '../core';
+import { ConnectionType } from '../types';
+export class WalletConnect extends EthereumConnector {
+    params;
+    type = ConnectionType.WALLET_CONNECT_V2;
+    options;
+    constructor(params) {
+        super(params);
+        this.params = params;
+        this.options = params.options;
+        makeObservable(this);
+        this.init().catch(error);
+    }
+    async connect(chainIdOrParams) {
+        const provider = await this.createProvider();
+        const desiredChainId = typeof chainIdOrParams === 'number' ? chainIdOrParams : chainIdOrParams?.chainId;
+        if (provider.session) {
+            if (!desiredChainId || desiredChainId === provider.chainId) {
+                return;
+            }
+            // WalletConnect exposes connected accounts, not chains: `eip155:${chainId}:${address}`
+            const eip155Accounts = provider.session.namespaces.eip155.accounts;
+            const isConnectedToDesiredChain = eip155Accounts.some(account => account.startsWith(`eip155:${desiredChainId}:`));
+            if (!isConnectedToDesiredChain) {
+                if (this.options.optionalChains?.includes(desiredChainId)) {
+                    throwException(`Cannot activate an optional chain (${desiredChainId}), as the wallet is not connected to it.\n\tYou should handle this error in application code, as there is no guarantee that a wallet is connected to a chain configured in "optionalChains".`);
+                }
+                throwException(`Unknown chain (${desiredChainId}). Make sure to include any chains you might connect to in the "chains" or "optionalChains" parameters when initializing WalletConnect.`);
+            }
+            await provider.request({
+                method: 'wallet_switchEthereumChain',
+                params: [{ chainId: `0x${desiredChainId.toString(16)}` }],
+            });
+            return;
+        }
+        try {
+            this.setState('isConnecting', true);
+            await provider.enable();
+            this.setData({ accounts: provider.accounts, chainId: provider.chainId });
+        }
+        catch (e) {
+            error('Could not connect to the wallet', e);
+            throw e;
+        }
+        finally {
+            this.setState({ isConnecting: false, isInitialized: true });
+        }
+    }
+    async disconnect() {
+        if (!this.provider) {
+            this.setState('isDisconnecting', false);
+            return;
+        }
+        try {
+            debug('Disconnect from Wallet Connect connection');
+            this.setState('isDisconnecting', true);
+            this.provider.removeListener('accountsChanged', this.handleAccountsChanged);
+            this.provider.removeListener('chainChanged', this.handleChainChanged);
+            this.provider.removeListener('disconnect', this.handleDisconnect);
+            await this.provider.disconnect();
+            this.setData({ accounts: undefined, chainId: undefined });
+            this.setState('isDisconnecting', false);
+            this.provider = undefined;
+        }
+        catch (e) {
+            this.setState('isDisconnecting', false);
+            throw e;
+        }
+    }
+    async init() {
+        this.setState('isInitializing', true);
+        try {
+            const provider = await this.createProvider();
+            if (!provider.session) {
+                throwException('No active session found. Connect your wallet first.');
+            }
+            this.setData({ accounts: provider.accounts, chainId: provider.chainId });
+            this.setState({ isInitialized: true, isInitializing: false });
+        }
+        catch (e) {
+            await this.disconnect();
+            this.setState({ isInitialized: false, isInitializing: false });
+            error('Wallet Connect could not be pre-connected', e);
+        }
+    }
+    async createProvider() {
+        // @ts-ignore
+        this.provider = await EthereumProvider.init(this.options);
+        this.provider.on('accountsChanged', this.handleAccountsChanged);
+        this.provider.on('chainChanged', this.handleChainChanged);
+        this.provider.on('disconnect', this.handleDisconnect);
+        return this.provider;
+    }
+}
+__decorate([
+    override,
+    __metadata("design:type", EthereumProvider)
+], WalletConnect.prototype, "provider", void 0);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WalletConnect.prototype, "connect", null);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WalletConnect.prototype, "disconnect", null);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WalletConnect.prototype, "init", null);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WalletConnect.prototype, "createProvider", null);

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

@@ -0,0 +1,4 @@
+export * from '../core/EIP6963Connector';
+export * from '../core/EthereumConnector';
+export * from '../core/MetaMask';
+export * from '../core/WalletConnect';

package/dist/esm/core/index.js

@@ -0,0 +1,4 @@
+export * from '../core/EIP6963Connector';
+export * from '../core/EthereumConnector';
+export * from '../core/MetaMask';
+export * from '../core/WalletConnect';

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

@@ -0,0 +1,4 @@
+export * from '../hooks/useEIP6963Connections';
+export * from '../hooks/useFilteredConnections';
+export * from '../hooks/useOrderedConnections';
+export * from '../hooks/useRecentConnectionMeta';

package/dist/esm/hooks/index.js

@@ -0,0 +1,4 @@
+export * from '../hooks/useEIP6963Connections';
+export * from '../hooks/useFilteredConnections';
+export * from '../hooks/useOrderedConnections';
+export * from '../hooks/useRecentConnectionMeta';

package/dist/esm/hooks/useEIP6963Connections.d.ts

@@ -0,0 +1,6 @@
+import { type EIP6963ProviderDetail } from 'web3/lib/commonjs/web3_eip6963';
+export declare const store: {
+    readonly subscribe: (callback: () => void) => () => void;
+    readonly value: () => EIP6963ProviderDetail<unknown>[];
+};
+export declare function useEIP6963Connections(): EIP6963ProviderDetail[];

package/dist/esm/hooks/useEIP6963Connections.js

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { EIP6963Event } from '../types';
+let providers = [];
+export const store = {
+    subscribe: (callback) => {
+        const onAnnouncement = (event) => {
+            if (providers.map(p => p.info.uuid).includes(event.detail.info.uuid))
+                return;
+            providers = [...providers, event.detail];
+            callback();
+        };
+        window.addEventListener(EIP6963Event.ANNOUNCE_PROVIDER, onAnnouncement);
+        window.dispatchEvent(new Event(EIP6963Event.REQUEST_PROVIDER));
+        return () => window.removeEventListener(EIP6963Event.ANNOUNCE_PROVIDER, onAnnouncement);
+    },
+    value: () => providers,
+};
+export function useEIP6963Connections() {
+    return React.useSyncExternalStore(store.subscribe, store.value, store.value);
+}

package/dist/esm/hooks/useFilteredConnections.d.ts

@@ -0,0 +1,2 @@
+import { type EvmWalletProviderConfig } from '../types';
+export declare function useFilteredConnections(providers: EvmWalletProviderConfig[], ids: string[]): EvmWalletProviderConfig[];

package/dist/esm/hooks/useFilteredConnections.js

@@ -0,0 +1,3 @@
+export function useFilteredConnections(providers, ids) {
+    return providers.filter(provider => ids.includes(provider.id));
+}

package/dist/esm/hooks/useOrderedConnections.d.ts

@@ -0,0 +1,2 @@
+import { type EvmWalletProviderConfig } from '../types';
+export declare function useOrderedConnections(providers: Readonly<EvmWalletProviderConfig[]>): EvmWalletProviderConfig[];

package/dist/esm/hooks/useOrderedConnections.js

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { useRecentConnectionMeta } from '../hooks/useRecentConnectionMeta';
+export function useOrderedConnections(providers) {
+    const [recentMeta] = useRecentConnectionMeta();
+    return React.useMemo(() => providers.reduce((acc, provider) => {
+        if (provider.id === recentMeta?.providerId) {
+            acc.unshift({ ...provider, isRecent: true });
+        }
+        else {
+            acc.push({ ...provider, isRecent: undefined });
+        }
+        return acc;
+    }, []), [providers, recentMeta?.providerId]);
+}

package/dist/esm/hooks/useRecentConnectionMeta.d.ts

@@ -0,0 +1,15 @@
+import { ConnectionType } from '../types';
+export interface RecentConnectionMeta {
+    chainId?: string;
+    disconnected?: boolean;
+    providerId: string;
+    type?: ConnectionType;
+}
+export declare function storeRecentConnectionMeta(meta: RecentConnectionMeta | undefined): void;
+export declare function getRecentConnectionMeta(): RecentConnectionMeta | undefined;
+type UseRecentConnectionMeta = [
+    value: RecentConnectionMeta | undefined,
+    setValue: (meta: RecentConnectionMeta | undefined) => void
+];
+export declare function useRecentConnectionMeta(): UseRecentConnectionMeta;
+export {};

package/dist/esm/hooks/useRecentConnectionMeta.js

@@ -0,0 +1,51 @@
+import { debug, storage } from '@broxus/js-utils';
+import * as React from 'react';
+import { EVM_RECENT_CONNECTION } from '../constants';
+import { ConnectionType } from '../types';
+function isRecentConnectionMeta(value) {
+    const meta = { providerId: value.providerId, type: value.type };
+    return Boolean(meta.type && ConnectionType[meta.type] && !!meta.providerId);
+}
+export function storeRecentConnectionMeta(meta) {
+    if (!meta) {
+        storage.remove(EVM_RECENT_CONNECTION);
+        return;
+    }
+    debug('Store EVM recent connection', meta);
+    storage.set(EVM_RECENT_CONNECTION, JSON.stringify(meta));
+}
+export function getRecentConnectionMeta() {
+    const value = storage.get(EVM_RECENT_CONNECTION);
+    if (!value) {
+        return undefined;
+    }
+    try {
+        const json = JSON.parse(value);
+        if (isRecentConnectionMeta(json)) {
+            return json;
+        }
+    }
+    catch (e) {
+        debug(e);
+    }
+    storeRecentConnectionMeta(undefined);
+    return undefined;
+}
+export function useRecentConnectionMeta() {
+    const [meta, setMeta] = React.useState(getRecentConnectionMeta());
+    React.useEffect(() => {
+        const onStorage = (event) => {
+            if (event.key === EVM_RECENT_CONNECTION && event.newValue) {
+                const json = JSON.parse(event.newValue);
+                if (isRecentConnectionMeta(json)) {
+                    setMeta(json);
+                }
+            }
+        };
+        window.addEventListener('storage', onStorage);
+        return () => {
+            window.removeEventListener('storage', onStorage);
+        };
+    }, []);
+    return [meta, storeRecentConnectionMeta];
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,8 @@
+export * from './components';
+export * from './context';
+export * from './core';
+export * from './hooks';
+export * from './services';
+export * from './utils';
+export * from './constants';
+export * from './types';

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+export * from './components';
+export * from './context';
+export * from './core';
+export * from './hooks';
+export * from './services';
+export * from './utils';
+export * from './constants';
+export * from './types';

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

@@ -0,0 +1,107 @@
+declare const _default: {
+    EVM_CONNECT_AGREEMENTS_NOTE: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_NOT_CONNECTED_HINT: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_INITIALIZING_HINT: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_CONNECT_BTN_TEXT: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_DISCONNECT_BTN_TEXT: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_CHANGE_NETWORK_BTN_TEXT: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_CHANGE_WALLET_BTN_TEXT: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_UNSUPPORTED_NETWORK_WARNING: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_CONNECTOR_BLOCKCHAIN_NAME: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_CONNECTOR_EXPLORER_HINT: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_INSTALL_PROVIDER: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_INSTALL_ANDROID_PLATFORM: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_INSTALL_IOS_PLATFORM: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_INSTALL_CHROME_EXTENSION_PLATFORM: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_INSTALL_FIREFOX_EXTENSION_PLATFORM: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_INSTALL_SAFARI_EXTENSION_PLATFORM: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_INSTALL_UNKNOWN_PLATFORM: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_DISPATCHER_POPUP_TITLE: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_DISPATCHER_POPUP_NOTE: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_TITLE: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_NOTE: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_FAILED_TITLE: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_FAILED_NOTE: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_TRY_AGAIN_BTN_TEXT: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_DISPATCHER_POPUP_CONNECTED_HINT: {
+        defaultMessage: string;
+        id: string;
+    };
+    EVM_CONNECT_DISPATCHER_POPUP_RECENT_HINT: {
+        defaultMessage: string;
+        id: string;
+    };
+};
+export default _default;