@broxus/evm-connect 1.0.0

package/dist/cjs/core/EIP6963Connector.js

@@ -0,0 +1,127 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EIP6963Connector = void 0;
+const js_utils_1 = require("@broxus/js-utils");
+const mobx_1 = require("mobx");
+const core_1 = require("../core");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+class EIP6963Connector extends core_1.EthereumConnector {
+    params;
+    type = types_1.ConnectionType.EIP_6963_INJECTED;
+    constructor(params) {
+        super(params);
+        this.params = params;
+        this.provider = params.provider;
+        (0, mobx_1.makeObservable)(this);
+        this.provider.on('accountsChanged', this.handleAccountsChanged);
+        this.provider.on('chainChanged', this.handleChainChanged);
+        this.provider.on('connect', this.handleConnect);
+        this.provider.on('disconnect', this.handleDisconnect);
+        this.init().catch(js_utils_1.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' }));
+            (0, js_utils_1.debug)(`Connect to ${this.params.info.name} connection`, accounts, chainId);
+            const receivedChainId = (0, utils_1.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 });
+                (0, js_utils_1.debug)(`${this.params.info.name} connection has skipped network switching.`);
+                return;
+            }
+            if (!chainIdOrParams) {
+                (0, js_utils_1.debug)(`${this.params.info.name} connection has skipped network switching. Chain params or chainId is not provided.`);
+                return;
+            }
+            (0, js_utils_1.debug)(`${this.params.info.name} 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 {
+            (0, js_utils_1.debug)(`Disconnect from ${this.params.info.name} 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() {
+        this.setState('isInitializing', true);
+        if (!this.provider) {
+            this.setState({ isInitialized: false, isInitializing: false });
+            return;
+        }
+        try {
+            const accounts = (await this.provider.request({ method: 'eth_accounts' }));
+            if (!accounts.length) {
+                (0, js_utils_1.throwException)('No accounts returned');
+            }
+            const chainId = (await this.provider.request({ method: 'eth_chainId' }));
+            this.setData({ accounts, chainId: (0, utils_1.parseChainId)(chainId) });
+            this.setState({ isInitialized: true, isInitializing: false });
+        }
+        catch (e) {
+            (0, js_utils_1.debug)(`${this.params.info.name} could not be pre-connected`, e);
+            this.setState({ isInitialized: false, isInitializing: false });
+        }
+    }
+    handleConnect({ chainId }) {
+        this.setData({ chainId: (0, utils_1.parseChainId)(chainId) });
+    }
+}
+exports.EIP6963Connector = EIP6963Connector;
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EIP6963Connector.prototype, "connect", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], EIP6963Connector.prototype, "disconnect", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], EIP6963Connector.prototype, "init", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], EIP6963Connector.prototype, "handleConnect", null);

package/dist/cjs/core/EthereumConnector.d.ts

@@ -0,0 +1,43 @@
+import { AbstractStore } from '@broxus/js-core';
+import { type EthExecutionAPI, type ProviderRpcError } from 'web3-types';
+import { type AddEthereumChainParams, type ConnectionType, type SupportedProviders, type WatchAssetParameters } from '../types';
+export interface EthereumConnectorCtorParams {
+    onDisconnect?: (err: ProviderRpcError) => Promise<void> | void;
+}
+export interface EthereumConnectorData {
+    accounts?: string[];
+    chainId?: number;
+}
+export interface EthereumConnectorState {
+    isConnecting?: boolean;
+    isDisconnecting?: boolean;
+    isInitialized?: boolean;
+    isInitializing?: boolean;
+}
+export declare abstract class EthereumConnector extends AbstractStore<EthereumConnectorData, EthereumConnectorState> {
+    protected readonly params?: Readonly<EthereumConnectorCtorParams> | undefined;
+    readonly type?: ConnectionType;
+    /**
+     * An
+     * EIP-1193 ({@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1193.md}) and
+     * EIP-1102 ({@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1102.md}) compliant provider.
+     * May also comply with EIP-3085 ({@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-3085.md}).
+     * This property must be defined while the connector is active.
+     */
+    provider?: SupportedProviders<EthExecutionAPI>;
+    protected constructor(params?: Readonly<EthereumConnectorCtorParams> | undefined);
+    abstract connect(...args: unknown[]): Promise<void>;
+    abstract disconnect(...args: unknown[]): Promise<void>;
+    addNetwork(chainParams: AddEthereumChainParams): Promise<void>;
+    switchNetwork(chainIdOrParams: number | AddEthereumChainParams): Promise<void>;
+    watchAsset(params: WatchAssetParameters): Promise<true>;
+    get accounts(): EthereumConnectorData['accounts'];
+    get chainId(): EthereumConnectorData['chainId'];
+    get isConnecting(): EthereumConnectorState['isConnecting'];
+    get isDisconnecting(): EthereumConnectorState['isDisconnecting'];
+    get isInitialized(): EthereumConnectorState['isInitialized'];
+    get isInitializing(): EthereumConnectorState['isInitializing'];
+    protected handleAccountsChanged(accounts: string[]): void;
+    protected handleChainChanged(chainId: string): void;
+    protected handleDisconnect(err: ProviderRpcError): void;
+}

package/dist/cjs/core/EthereumConnector.js

@@ -0,0 +1,190 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EthereumConnector = void 0;
+const js_core_1 = require("@broxus/js-core");
+const js_utils_1 = require("@broxus/js-utils");
+const mobx_1 = require("mobx");
+class EthereumConnector extends js_core_1.AbstractStore {
+    params;
+    type;
+    /**
+     * An
+     * EIP-1193 ({@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1193.md}) and
+     * EIP-1102 ({@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1102.md}) compliant provider.
+     * May also comply with EIP-3085 ({@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-3085.md}).
+     * This property must be defined while the connector is active.
+     */
+    provider;
+    constructor(params) {
+        super();
+        this.params = params;
+    }
+    async addNetwork(chainParams) {
+        if (!this.provider) {
+            throw new Error('Provider is not defined');
+        }
+        await this.provider.request({
+            method: 'wallet_addEthereumChain',
+            params: [{ ...chainParams }],
+        });
+    }
+    async switchNetwork(chainIdOrParams) {
+        if (!this.provider) {
+            throw new Error('Provider is not defined');
+        }
+        try {
+            const chainId = typeof chainIdOrParams === 'number' ? chainIdOrParams : chainIdOrParams?.chainId;
+            const desiredChainId = `0x${chainId.toString(16)}`;
+            await this.provider.request({
+                method: 'wallet_switchEthereumChain',
+                params: [{ chainId: desiredChainId }],
+            });
+        }
+        catch (e) {
+            // https://github.com/MetaMask/metamask-mobile/issues/3312#issuecomment-1065923294
+            const errorCode = e.data?.originalError?.code || e.code;
+            // 4902 indicates that the chain has not been added to MetaMask and wallet_addEthereumChain needs to be called
+            // https://docs.metamask.io/guide/rpc-api.html#wallet-switchethereumchain
+            if (errorCode === 4902 && typeof chainIdOrParams !== 'number') {
+                await this.addNetwork(chainIdOrParams);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    async watchAsset(params) {
+        if (!this.provider) {
+            throw new Error('Provider is not defined');
+        }
+        return this.provider
+            .request({
+            method: 'wallet_watchAsset',
+            params: {
+                options: {
+                    address: params.address, // The address that the token is at.
+                    decimals: params.decimals, // The number of decimals in the token
+                    image: params.image, // A string url of the token logo
+                    symbol: params.symbol, // A ticker symbol or shorthand, up to 5 chars.
+                },
+                type: 'ERC20', // Initially only supports ERC20, but eventually more!
+            },
+        })
+            .then(result => {
+            if (!result) {
+                throw new Error('Watch asset request was rejected');
+            }
+            return true;
+        });
+    }
+    get accounts() {
+        return this._data.accounts;
+    }
+    get chainId() {
+        return this._data.chainId;
+    }
+    get isConnecting() {
+        return this._state.isConnecting;
+    }
+    get isDisconnecting() {
+        return this._state.isDisconnecting;
+    }
+    get isInitialized() {
+        return this._state.isInitialized;
+    }
+    get isInitializing() {
+        return this._state.isInitializing;
+    }
+    handleAccountsChanged(accounts) {
+        (0, js_utils_1.debug)(`Accounts have been changed to ${accounts}`);
+        this.setData({ accounts });
+    }
+    handleChainChanged(chainId) {
+        (0, js_utils_1.debug)(`Chain has been changed to ${chainId}`);
+        this.setData({ chainId: Number.parseInt(chainId, 16) });
+    }
+    handleDisconnect(err) {
+        this.setData(() => ({}));
+        this.params?.onDisconnect?.(err);
+    }
+}
+exports.EthereumConnector = EthereumConnector;
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", Object)
+], EthereumConnector.prototype, "provider", void 0);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EthereumConnector.prototype, "addNetwork", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EthereumConnector.prototype, "switchNetwork", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EthereumConnector.prototype, "watchAsset", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EthereumConnector.prototype, "accounts", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EthereumConnector.prototype, "chainId", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EthereumConnector.prototype, "isConnecting", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EthereumConnector.prototype, "isDisconnecting", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EthereumConnector.prototype, "isInitialized", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EthereumConnector.prototype, "isInitializing", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], EthereumConnector.prototype, "handleAccountsChanged", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], EthereumConnector.prototype, "handleChainChanged", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], EthereumConnector.prototype, "handleDisconnect", null);

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

@@ -0,0 +1,159 @@
+"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.MetaMask = void 0;
+const js_utils_1 = require("@broxus/js-utils");
+const detect_provider_1 = __importDefault(require("@metamask/detect-provider"));
+const mobx_1 = require("mobx");
+const EthereumConnector_1 = require("../core/EthereumConnector");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const INJECTABLE_WALLETS = ['isBraveWallet', 'isRabby', 'isLedgerConnect', 'isTrust'];
+class MetaMask extends EthereumConnector_1.EthereumConnector {
+    params;
+    type = types_1.ConnectionType.INJECTED;
+    constructor(params) {
+        super(params);
+        this.params = params;
+        (0, mobx_1.makeObservable)(this);
+        this.init().catch(js_utils_1.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' }));
+            (0, js_utils_1.debug)('Connect to MetaMask connection', accounts, chainId);
+            const receivedChainId = (0, utils_1.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 });
+                (0, js_utils_1.debug)('MetaMask connection has skipped network switching.');
+                return;
+            }
+            if (!chainIdOrParams) {
+                (0, js_utils_1.debug)('MetaMask connection has skipped network switching. Chain params or chainId is not provided.');
+                return;
+            }
+            (0, js_utils_1.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 {
+            (0, js_utils_1.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 (0, detect_provider_1.default)(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(types_1.EIP6963Event.ANNOUNCE_PROVIDER, onAnnouncement);
+                window.dispatchEvent(new Event(types_1.EIP6963Event.REQUEST_PROVIDER));
+                if (Object.keys(provider).some(key => INJECTABLE_WALLETS.includes(key))) {
+                    this.provider = undefined;
+                    (0, js_utils_1.throwException)('No MetaMask provider found');
+                }
+            }
+        }
+        catch (e) {
+            window.removeEventListener(types_1.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) {
+                (0, js_utils_1.throwException)('No accounts returned');
+            }
+            const chainId = (await this.provider.request({ method: 'eth_chainId' }));
+            this.setData({ accounts, chainId: (0, utils_1.parseChainId)(chainId) });
+            this.setState({ isInitialized: true, isInitializing: false });
+        }
+        catch (e) {
+            (0, js_utils_1.debug)('MetaMask could not be pre-connected', e);
+            this.setState({ isInitialized: false, isInitializing: false });
+        }
+    }
+    handleConnect({ chainId }) {
+        this.setData({ chainId: (0, utils_1.parseChainId)(chainId) });
+    }
+}
+exports.MetaMask = MetaMask;
+__decorate([
+    mobx_1.override,
+    __metadata("design:type", Object)
+], MetaMask.prototype, "provider", void 0);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MetaMask.prototype, "connect", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MetaMask.prototype, "disconnect", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MetaMask.prototype, "init", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], MetaMask.prototype, "handleConnect", null);

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