@broxus/evm-connect 1.0.0

package/dist/cjs/core/WalletConnect.js

@@ -0,0 +1,141 @@
+"use strict";
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletConnect = void 0;
+const js_utils_1 = require("@broxus/js-utils");
+const ethereum_provider_1 = __importDefault(require("@walletconnect/ethereum-provider"));
+const mobx_1 = require("mobx");
+const core_1 = require("../core");
+const types_1 = require("../types");
+class WalletConnect extends core_1.EthereumConnector {
+    params;
+    type = types_1.ConnectionType.WALLET_CONNECT_V2;
+    options;
+    constructor(params) {
+        super(params);
+        this.params = params;
+        this.options = params.options;
+        (0, mobx_1.makeObservable)(this);
+        this.init().catch(js_utils_1.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)) {
+                    (0, js_utils_1.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".`);
+                }
+                (0, js_utils_1.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) {
+            (0, js_utils_1.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 {
+            (0, js_utils_1.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) {
+                (0, js_utils_1.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 });
+            (0, js_utils_1.error)('Wallet Connect could not be pre-connected', e);
+        }
+    }
+    async createProvider() {
+        // @ts-ignore
+        this.provider = await ethereum_provider_1.default.init(this.options);
+        this.provider.on('accountsChanged', this.handleAccountsChanged);
+        this.provider.on('chainChanged', this.handleChainChanged);
+        this.provider.on('disconnect', this.handleDisconnect);
+        return this.provider;
+    }
+}
+exports.WalletConnect = WalletConnect;
+__decorate([
+    mobx_1.override,
+    __metadata("design:type", ethereum_provider_1.default)
+], WalletConnect.prototype, "provider", void 0);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WalletConnect.prototype, "connect", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WalletConnect.prototype, "disconnect", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WalletConnect.prototype, "init", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WalletConnect.prototype, "createProvider", null);

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

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("../core/EIP6963Connector"), exports);
+__exportStar(require("../core/EthereumConnector"), exports);
+__exportStar(require("../core/MetaMask"), exports);
+__exportStar(require("../core/WalletConnect"), exports);

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

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("../hooks/useEIP6963Connections"), exports);
+__exportStar(require("../hooks/useFilteredConnections"), exports);
+__exportStar(require("../hooks/useOrderedConnections"), exports);
+__exportStar(require("../hooks/useRecentConnectionMeta"), exports);

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

@@ -0,0 +1,47 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEIP6963Connections = exports.store = void 0;
+const React = __importStar(require("react"));
+const types_1 = require("../types");
+let providers = [];
+exports.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(types_1.EIP6963Event.ANNOUNCE_PROVIDER, onAnnouncement);
+        window.dispatchEvent(new Event(types_1.EIP6963Event.REQUEST_PROVIDER));
+        return () => window.removeEventListener(types_1.EIP6963Event.ANNOUNCE_PROVIDER, onAnnouncement);
+    },
+    value: () => providers,
+};
+function useEIP6963Connections() {
+    return React.useSyncExternalStore(exports.store.subscribe, exports.store.value, exports.store.value);
+}
+exports.useEIP6963Connections = useEIP6963Connections;

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

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

package/dist/cjs/hooks/useFilteredConnections.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFilteredConnections = void 0;
+function useFilteredConnections(providers, ids) {
+    return providers.filter(provider => ids.includes(provider.id));
+}
+exports.useFilteredConnections = useFilteredConnections;

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

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

package/dist/cjs/hooks/useOrderedConnections.js

@@ -0,0 +1,41 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOrderedConnections = void 0;
+const React = __importStar(require("react"));
+const useRecentConnectionMeta_1 = require("../hooks/useRecentConnectionMeta");
+function useOrderedConnections(providers) {
+    const [recentMeta] = (0, useRecentConnectionMeta_1.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]);
+}
+exports.useOrderedConnections = useOrderedConnections;

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

@@ -0,0 +1,80 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRecentConnectionMeta = exports.getRecentConnectionMeta = exports.storeRecentConnectionMeta = void 0;
+const js_utils_1 = require("@broxus/js-utils");
+const React = __importStar(require("react"));
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+function isRecentConnectionMeta(value) {
+    const meta = { providerId: value.providerId, type: value.type };
+    return Boolean(meta.type && types_1.ConnectionType[meta.type] && !!meta.providerId);
+}
+function storeRecentConnectionMeta(meta) {
+    if (!meta) {
+        js_utils_1.storage.remove(constants_1.EVM_RECENT_CONNECTION);
+        return;
+    }
+    (0, js_utils_1.debug)('Store EVM recent connection', meta);
+    js_utils_1.storage.set(constants_1.EVM_RECENT_CONNECTION, JSON.stringify(meta));
+}
+exports.storeRecentConnectionMeta = storeRecentConnectionMeta;
+function getRecentConnectionMeta() {
+    const value = js_utils_1.storage.get(constants_1.EVM_RECENT_CONNECTION);
+    if (!value) {
+        return undefined;
+    }
+    try {
+        const json = JSON.parse(value);
+        if (isRecentConnectionMeta(json)) {
+            return json;
+        }
+    }
+    catch (e) {
+        (0, js_utils_1.debug)(e);
+    }
+    storeRecentConnectionMeta(undefined);
+    return undefined;
+}
+exports.getRecentConnectionMeta = getRecentConnectionMeta;
+function useRecentConnectionMeta() {
+    const [meta, setMeta] = React.useState(getRecentConnectionMeta());
+    React.useEffect(() => {
+        const onStorage = (event) => {
+            if (event.key === constants_1.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];
+}
+exports.useRecentConnectionMeta = useRecentConnectionMeta;

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

@@ -0,0 +1,24 @@
+"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 });
+__exportStar(require("./components"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./core"), exports);
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./types"), exports);

package/dist/cjs/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;

package/dist/cjs/intl/index.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_intl_1 = require("react-intl");
+/* eslint-disable sort-keys */
+exports.default = (0, react_intl_1.defineMessages)({
+    EVM_CONNECT_AGREEMENTS_NOTE: {
+        defaultMessage: 'By connecting a wallet, you agree to Terms of Service and consent to its Privacy Policy.',
+        id: 'EVM_CONNECT_AGREEMENTS_NOTE',
+    },
+    EVM_CONNECT_NOT_CONNECTED_HINT: {
+        defaultMessage: 'Not connected',
+        id: 'EVM_CONNECT_NOT_CONNECTED_HINT',
+    },
+    EVM_CONNECT_INITIALIZING_HINT: {
+        defaultMessage: 'Initializing',
+        id: 'EVM_CONNECT_INITIALIZING_HINT',
+    },
+    EVM_CONNECT_CONNECT_BTN_TEXT: {
+        defaultMessage: 'Connect',
+        id: 'EVM_CONNECT_CONNECT_BTN_TEXT',
+    },
+    EVM_CONNECT_DISCONNECT_BTN_TEXT: {
+        defaultMessage: 'Disconnect',
+        id: 'EVM_CONNECT_DISCONNECT_BTN_TEXT',
+    },
+    EVM_CONNECT_CHANGE_NETWORK_BTN_TEXT: {
+        defaultMessage: 'Change network',
+        id: 'EVM_CONNECT_CHANGE_NETWORK_BTN_TEXT',
+    },
+    EVM_CONNECT_CHANGE_WALLET_BTN_TEXT: {
+        defaultMessage: 'Change wallet',
+        id: 'EVM_CONNECT_CHANGE_WALLET_BTN_TEXT',
+    },
+    EVM_CONNECT_UNSUPPORTED_NETWORK_WARNING: {
+        defaultMessage: 'Unsupported network',
+        id: 'EVM_CONNECT_UNSUPPORTED_NETWORK_WARNING',
+    },
+    EVM_CONNECT_CONNECTOR_BLOCKCHAIN_NAME: {
+        defaultMessage: 'Ethereum',
+        id: 'EVM_CONNECT_CONNECTOR_BLOCKCHAIN_NAME',
+    },
+    EVM_CONNECT_CONNECTOR_EXPLORER_HINT: {
+        defaultMessage: 'Open in {explorerTitle}',
+        id: 'EVM_CONNECT_CONNECTOR_EXPLORER_HINT',
+    },
+    EVM_CONNECT_INSTALL_PROVIDER: {
+        defaultMessage: 'Install {providerName}',
+        id: 'EVM_CONNECT_INSTALL_PROVIDER',
+    },
+    EVM_CONNECT_INSTALL_ANDROID_PLATFORM: {
+        defaultMessage: 'Install Android App',
+        id: 'EVM_CONNECT_INSTALL_ANDROID_PLATFORM',
+    },
+    EVM_CONNECT_INSTALL_IOS_PLATFORM: {
+        defaultMessage: 'Install iOS App',
+        id: 'EVM_CONNECT_INSTALL_IOS_PLATFORM',
+    },
+    EVM_CONNECT_INSTALL_CHROME_EXTENSION_PLATFORM: {
+        defaultMessage: 'Install Chrome extension',
+        id: 'EVM_CONNECT_INSTALL_CHROME_EXTENSION_PLATFORM',
+    },
+    EVM_CONNECT_INSTALL_FIREFOX_EXTENSION_PLATFORM: {
+        defaultMessage: 'Install Firefox extension',
+        id: 'EVM_CONNECT_INSTALL_FIREFOX_EXTENSION_PLATFORM',
+    },
+    EVM_CONNECT_INSTALL_SAFARI_EXTENSION_PLATFORM: {
+        defaultMessage: 'Install Safari extension',
+        id: 'EVM_CONNECT_INSTALL_SAFARI_EXTENSION_PLATFORM',
+    },
+    EVM_CONNECT_INSTALL_UNKNOWN_PLATFORM: {
+        defaultMessage: '—',
+        id: 'EVM_CONNECT_INSTALL_UNKNOWN_PLATFORM',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_TITLE: {
+        defaultMessage: 'Connect a wallet',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_TITLE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_NOTE: {
+        defaultMessage: 'At the moment we only support the wallets below.',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_NOTE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_TITLE: {
+        defaultMessage: 'Continue in {title}',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_REQUEST_TITLE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_NOTE: {
+        defaultMessage: 'Accept connection request in the wallet',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_REQUEST_NOTE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_FAILED_TITLE: {
+        defaultMessage: 'Connection failed',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_REQUEST_FAILED_TITLE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_FAILED_NOTE: {
+        defaultMessage: 'Connection can be declined if a previous request is still active',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_REQUEST_FAILED_NOTE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_TRY_AGAIN_BTN_TEXT: {
+        defaultMessage: 'Try again',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_REQUEST_TRY_AGAIN_BTN_TEXT',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_CONNECTED_HINT: {
+        defaultMessage: 'Connected',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_CONNECTED_HINT',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_RECENT_HINT: {
+        defaultMessage: 'Recent',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_RECENT_HINT',
+    },
+});