@wagmi/core 0.6.12 → 0.7.1

package/dist/{declarations/src/connectors → connectors}/coinbaseWallet.d.ts

@@ -1,8 +1,11 @@
-import type { CoinbaseWalletProvider } from '@coinbase/wallet-sdk';
-import type { CoinbaseWalletSDKOptions } from '@coinbase/wallet-sdk/dist/CoinbaseWalletSDK';
+import { CoinbaseWalletProvider } from '@coinbase/wallet-sdk';
+import { CoinbaseWalletSDKOptions } from '@coinbase/wallet-sdk/dist/CoinbaseWalletSDK';
 import { providers } from 'ethers';
-import { Chain } from '../types';
-import { Connector } from './base';
+import { C as Chain } from '../index-bacc1c49.js';
+import { C as Connector } from '../base-5bd9b5ed.js';
+import 'abitype';
+import 'eventemitter3';
+
 declare type Options = CoinbaseWalletSDKOptions & {
     /**
      * Fallback Ethereum JSON RPC URL
@@ -15,7 +18,7 @@ declare type Options = CoinbaseWalletSDKOptions & {
      */
     chainId?: number;
 };
-export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletProvider, Options, providers.JsonRpcSigner> {
+declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletProvider, Options, providers.JsonRpcSigner> {
     #private;
     readonly id = "coinbaseWallet";
     readonly name = "Coinbase Wallet";
@@ -53,4 +56,5 @@ export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletPro
     protected onChainChanged: (chainId: number | string) => void;
     protected onDisconnect: () => void;
 }
-export {};
+
+export { CoinbaseWalletConnector };

package/dist/connectors/coinbaseWallet.js

@@ -0,0 +1,215 @@
+import {
+  AddChainError,
+  ChainNotConfiguredError,
+  Connector,
+  SwitchChainError,
+  UserRejectedRequestError,
+  normalizeChainId
+} from "../chunk-WA7I47EF.js";
+import "../chunk-4DNFSL2K.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "../chunk-MQXBDTVK.js";
+
+// src/connectors/coinbaseWallet.ts
+import { providers } from "ethers";
+import { getAddress, hexValue } from "ethers/lib/utils.js";
+var _client, _provider, _isUserRejectedRequestError, isUserRejectedRequestError_fn;
+var CoinbaseWalletConnector = class extends Connector {
+  constructor({ chains, options }) {
+    super({
+      chains,
+      options: {
+        reloadOnDisconnect: false,
+        ...options
+      }
+    });
+    __privateAdd(this, _isUserRejectedRequestError);
+    this.id = "coinbaseWallet";
+    this.name = "Coinbase Wallet";
+    this.ready = true;
+    __privateAdd(this, _client, void 0);
+    __privateAdd(this, _provider, void 0);
+    this.onAccountsChanged = (accounts) => {
+      if (accounts.length === 0)
+        this.emit("disconnect");
+      else
+        this.emit("change", { account: getAddress(accounts[0]) });
+    };
+    this.onChainChanged = (chainId) => {
+      const id = normalizeChainId(chainId);
+      const unsupported = this.isChainUnsupported(id);
+      this.emit("change", { chain: { id, unsupported } });
+    };
+    this.onDisconnect = () => {
+      this.emit("disconnect");
+    };
+  }
+  async connect({ chainId } = {}) {
+    try {
+      const provider = await this.getProvider();
+      provider.on("accountsChanged", this.onAccountsChanged);
+      provider.on("chainChanged", this.onChainChanged);
+      provider.on("disconnect", this.onDisconnect);
+      this.emit("message", { type: "connecting" });
+      const accounts = await provider.enable();
+      const account = getAddress(accounts[0]);
+      let id = await this.getChainId();
+      let unsupported = this.isChainUnsupported(id);
+      if (chainId && id !== chainId) {
+        const chain = await this.switchChain(chainId);
+        id = chain.id;
+        unsupported = this.isChainUnsupported(id);
+      }
+      return {
+        account,
+        chain: { id, unsupported },
+        provider: new providers.Web3Provider(
+          provider
+        )
+      };
+    } catch (error) {
+      if (/(user closed modal|accounts received is empty)/i.test(
+        error.message
+      ))
+        throw new UserRejectedRequestError(error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (!__privateGet(this, _provider))
+      return;
+    const provider = await this.getProvider();
+    provider.removeListener("accountsChanged", this.onAccountsChanged);
+    provider.removeListener("chainChanged", this.onChainChanged);
+    provider.removeListener("disconnect", this.onDisconnect);
+    provider.disconnect();
+    provider.close();
+  }
+  async getAccount() {
+    const provider = await this.getProvider();
+    const accounts = await provider.request({
+      method: "eth_accounts"
+    });
+    return getAddress(accounts[0]);
+  }
+  async getChainId() {
+    const provider = await this.getProvider();
+    const chainId = normalizeChainId(provider.chainId);
+    return chainId;
+  }
+  async getProvider() {
+    if (!__privateGet(this, _provider)) {
+      let CoinbaseWalletSDK = (await import("@coinbase/wallet-sdk")).default;
+      if (typeof CoinbaseWalletSDK !== "function" && typeof CoinbaseWalletSDK.default === "function")
+        CoinbaseWalletSDK = CoinbaseWalletSDK.default;
+      __privateSet(this, _client, new CoinbaseWalletSDK(this.options));
+      class WalletProvider {
+      }
+      class Client {
+      }
+      const walletExtensionChainId = __privateGet(this, _client).walletExtension?.getChainId();
+      const chain = this.chains.find(
+        (chain2) => this.options.chainId ? chain2.id === this.options.chainId : chain2.id === walletExtensionChainId
+      ) || this.chains[0];
+      const chainId = this.options.chainId || chain?.id;
+      const jsonRpcUrl = this.options.jsonRpcUrl || chain?.rpcUrls.default;
+      __privateSet(this, _provider, __privateGet(this, _client).makeWeb3Provider(jsonRpcUrl, chainId));
+    }
+    return __privateGet(this, _provider);
+  }
+  async getSigner({ chainId } = {}) {
+    const [provider, account] = await Promise.all([
+      this.getProvider(),
+      this.getAccount()
+    ]);
+    return new providers.Web3Provider(
+      provider,
+      chainId
+    ).getSigner(account);
+  }
+  async isAuthorized() {
+    try {
+      const account = await this.getAccount();
+      return !!account;
+    } catch {
+      return false;
+    }
+  }
+  async switchChain(chainId) {
+    const provider = await this.getProvider();
+    const id = hexValue(chainId);
+    try {
+      await provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: id }]
+      });
+      return this.chains.find((x) => x.id === chainId) ?? {
+        id: chainId,
+        name: `Chain ${id}`,
+        network: `${id}`,
+        rpcUrls: { default: "" }
+      };
+    } catch (error) {
+      const chain = this.chains.find((x) => x.id === chainId);
+      if (!chain)
+        throw new ChainNotConfiguredError({ chainId, connectorId: this.id });
+      if (error.code === 4902) {
+        try {
+          await provider.request({
+            method: "wallet_addEthereumChain",
+            params: [
+              {
+                chainId: id,
+                chainName: chain.name,
+                nativeCurrency: chain.nativeCurrency,
+                rpcUrls: [chain.rpcUrls.public ?? chain.rpcUrls.default],
+                blockExplorerUrls: this.getBlockExplorerUrls(chain)
+              }
+            ]
+          });
+          return chain;
+        } catch (addError) {
+          if (__privateMethod(this, _isUserRejectedRequestError, isUserRejectedRequestError_fn).call(this, addError))
+            throw new UserRejectedRequestError(addError);
+          throw new AddChainError();
+        }
+      }
+      if (__privateMethod(this, _isUserRejectedRequestError, isUserRejectedRequestError_fn).call(this, error))
+        throw new UserRejectedRequestError(error);
+      throw new SwitchChainError(error);
+    }
+  }
+  async watchAsset({
+    address,
+    decimals = 18,
+    image,
+    symbol
+  }) {
+    const provider = await this.getProvider();
+    return provider.request({
+      method: "wallet_watchAsset",
+      params: {
+        type: "ERC20",
+        options: {
+          address,
+          decimals,
+          image,
+          symbol
+        }
+      }
+    });
+  }
+};
+_client = new WeakMap();
+_provider = new WeakMap();
+_isUserRejectedRequestError = new WeakSet();
+isUserRejectedRequestError_fn = function(error) {
+  return /(user rejected)/i.test(error.message);
+};
+export {
+  CoinbaseWalletConnector
+};

package/dist/{declarations/src/connectors → connectors}/metaMask.d.ts

@@ -1,12 +1,17 @@
-import { Chain, Ethereum } from '../types';
-import { InjectedConnector, InjectedConnectorOptions } from './injected';
-export declare type MetaMaskConnectorOptions = Pick<InjectedConnectorOptions, 'shimChainChangedDisconnect' | 'shimDisconnect'> & {
+import { C as Chain, E as Ethereum } from '../index-bacc1c49.js';
+import { a as InjectedConnectorOptions, I as InjectedConnector } from '../injected-6980e5c3.js';
+import 'abitype';
+import 'ethers';
+import '../base-5bd9b5ed.js';
+import 'eventemitter3';
+
+declare type MetaMaskConnectorOptions = Pick<InjectedConnectorOptions, 'shimChainChangedDisconnect' | 'shimDisconnect'> & {
     /**
      * While "disconnected" with `shimDisconnect`, allows user to select a different MetaMask account (than the currently connected account) when trying to connect.
      */
     UNSTABLE_shimOnConnectSelectAccount?: boolean;
 };
-export declare class MetaMaskConnector extends InjectedConnector {
+declare class MetaMaskConnector extends InjectedConnector {
     #private;
     readonly id = "metaMask";
     readonly ready: boolean;
@@ -26,3 +31,5 @@ export declare class MetaMaskConnector extends InjectedConnector {
     }>;
     getProvider(): Promise<Ethereum | undefined>;
 }
+
+export { MetaMaskConnector, MetaMaskConnectorOptions };

package/dist/connectors/metaMask.js

@@ -0,0 +1,115 @@
+import {
+  ConnectorNotFoundError,
+  InjectedConnector,
+  ResourceUnavailableError,
+  UserRejectedRequestError,
+  getClient
+} from "../chunk-WA7I47EF.js";
+import "../chunk-4DNFSL2K.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "../chunk-MQXBDTVK.js";
+
+// src/connectors/metaMask.ts
+var _provider, _UNSTABLE_shimOnConnectSelectAccount, _getReady, getReady_fn, _findProvider, findProvider_fn;
+var MetaMaskConnector = class extends InjectedConnector {
+  constructor({
+    chains,
+    options: options_
+  } = {}) {
+    const options = {
+      name: "MetaMask",
+      shimDisconnect: true,
+      shimChainChangedDisconnect: true,
+      ...options_
+    };
+    super({ chains, options });
+    __privateAdd(this, _getReady);
+    __privateAdd(this, _findProvider);
+    this.id = "metaMask";
+    this.ready = typeof window != "undefined" && !!__privateMethod(this, _findProvider, findProvider_fn).call(this, window.ethereum);
+    __privateAdd(this, _provider, void 0);
+    __privateAdd(this, _UNSTABLE_shimOnConnectSelectAccount, void 0);
+    __privateSet(this, _UNSTABLE_shimOnConnectSelectAccount, options.UNSTABLE_shimOnConnectSelectAccount);
+  }
+  async connect({ chainId } = {}) {
+    try {
+      const provider = await this.getProvider();
+      if (!provider)
+        throw new ConnectorNotFoundError();
+      if (provider.on) {
+        provider.on("accountsChanged", this.onAccountsChanged);
+        provider.on("chainChanged", this.onChainChanged);
+        provider.on("disconnect", this.onDisconnect);
+      }
+      this.emit("message", { type: "connecting" });
+      if (__privateGet(this, _UNSTABLE_shimOnConnectSelectAccount) && this.options?.shimDisconnect && !getClient().storage?.getItem(this.shimDisconnectKey)) {
+        const accounts = await provider.request({
+          method: "eth_accounts"
+        }).catch(() => []);
+        const isConnected = !!accounts[0];
+        if (isConnected)
+          await provider.request({
+            method: "wallet_requestPermissions",
+            params: [{ eth_accounts: {} }]
+          });
+      }
+      const account = await this.getAccount();
+      let id = await this.getChainId();
+      let unsupported = this.isChainUnsupported(id);
+      if (chainId && id !== chainId) {
+        const chain = await this.switchChain(chainId);
+        id = chain.id;
+        unsupported = this.isChainUnsupported(id);
+      }
+      if (this.options?.shimDisconnect)
+        getClient().storage?.setItem(this.shimDisconnectKey, true);
+      return { account, chain: { id, unsupported }, provider };
+    } catch (error) {
+      if (this.isUserRejectedRequestError(error))
+        throw new UserRejectedRequestError(error);
+      if (error.code === -32002)
+        throw new ResourceUnavailableError(error);
+      throw error;
+    }
+  }
+  async getProvider() {
+    if (typeof window !== "undefined") {
+      __privateSet(this, _provider, __privateMethod(this, _findProvider, findProvider_fn).call(this, window.ethereum));
+    }
+    return __privateGet(this, _provider);
+  }
+};
+_provider = new WeakMap();
+_UNSTABLE_shimOnConnectSelectAccount = new WeakMap();
+_getReady = new WeakSet();
+getReady_fn = function(ethereum) {
+  const isMetaMask = !!ethereum?.isMetaMask;
+  if (!isMetaMask)
+    return;
+  if (ethereum.isBraveWallet && !ethereum._events && !ethereum._state)
+    return;
+  if (ethereum.isAvalanche)
+    return;
+  if (ethereum.isKuCoinWallet)
+    return;
+  if (ethereum.isPortal)
+    return;
+  if (ethereum.isTokenPocket)
+    return;
+  if (ethereum.isTokenary)
+    return;
+  return ethereum;
+};
+_findProvider = new WeakSet();
+findProvider_fn = function(ethereum) {
+  if (ethereum?.providers)
+    return ethereum.providers.find(__privateMethod(this, _getReady, getReady_fn));
+  return __privateMethod(this, _getReady, getReady_fn).call(this, ethereum);
+};
+export {
+  MetaMaskConnector
+};

package/dist/connectors/mock/index.d.ts

@@ -0,0 +1,78 @@
+import * as ethers from 'ethers';
+import { providers } from 'ethers';
+import { S as Signer, C as Chain } from '../../index-bacc1c49.js';
+import { C as Connector, a as ConnectorData } from '../../base-5bd9b5ed.js';
+import EventEmitter from 'eventemitter3';
+import 'abitype';
+
+declare type MockProviderOptions = {
+    chainId?: number;
+    flags?: {
+        isAuthorized?: boolean;
+        failConnect?: boolean;
+        failSwitchChain?: boolean;
+        noSwitchChain?: boolean;
+    };
+    signer: Signer;
+};
+declare type Events = {
+    accountsChanged(accounts: string[]): void;
+    chainChanged(chainId: number | string): void;
+    disconnect(): void;
+};
+declare type Event = keyof Events;
+declare class MockProvider extends providers.BaseProvider {
+    #private;
+    events: EventEmitter<Events, any>;
+    constructor(options: MockProviderOptions);
+    enable(): Promise<string[]>;
+    disconnect(): Promise<void>;
+    getAccounts(): Promise<`0x${string}`[]>;
+    getSigner(): ethers.Signer;
+    switchChain(chainId: number): Promise<void>;
+    watchAsset(_asset: {
+        address: string;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    on(event: Event, listener: providers.Listener): this;
+    once(event: Event, listener: providers.Listener): this;
+    removeListener(event: Event, listener: providers.Listener): this;
+    off(event: Event, listener: providers.Listener): this;
+    toJSON(): string;
+}
+
+declare class MockConnector extends Connector<MockProvider, MockProviderOptions> {
+    #private;
+    readonly id = "mock";
+    readonly name = "Mock";
+    readonly ready = true;
+    constructor(config: {
+        chains?: Chain[];
+        options: MockProviderOptions;
+    });
+    connect({ chainId }?: {
+        chainId?: number;
+    }): Promise<Required<ConnectorData<any>>>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<`0x${string}`>;
+    getChainId(): Promise<number>;
+    getProvider({ chainId }?: {
+        chainId?: number;
+    }): Promise<MockProvider>;
+    getSigner(): Promise<ethers.Signer>;
+    isAuthorized(): Promise<boolean>;
+    watchAsset(asset: {
+        address: string;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: () => void;
+    toJSON(): string;
+}
+
+export { MockConnector, MockProvider, MockProviderOptions };

package/dist/connectors/mock/index.js

@@ -0,0 +1,190 @@
+import {
+  Connector,
+  UserRejectedRequestError,
+  normalizeChainId
+} from "../../chunk-WA7I47EF.js";
+import "../../chunk-4DNFSL2K.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "../../chunk-MQXBDTVK.js";
+
+// src/connectors/mock/connector.ts
+import { getAddress as getAddress2 } from "ethers/lib/utils.js";
+
+// src/connectors/mock/provider.ts
+import { providers } from "ethers";
+import { getAddress } from "ethers/lib/utils.js";
+import { default as EventEmitter } from "eventemitter3";
+var _options, _signer;
+var MockProvider = class extends providers.BaseProvider {
+  constructor(options) {
+    super({ name: "Network", chainId: options.chainId ?? 1 });
+    this.events = new EventEmitter();
+    __privateAdd(this, _options, void 0);
+    __privateAdd(this, _signer, void 0);
+    __privateSet(this, _options, options);
+  }
+  async enable() {
+    if (__privateGet(this, _options).flags?.failConnect)
+      throw new UserRejectedRequestError(new Error("Failed to connect"));
+    if (!__privateGet(this, _signer))
+      __privateSet(this, _signer, __privateGet(this, _options).signer);
+    const address = await __privateGet(this, _signer).getAddress();
+    this.events.emit("accountsChanged", [address]);
+    return [address];
+  }
+  async disconnect() {
+    this.events.emit("disconnect");
+    __privateSet(this, _signer, void 0);
+  }
+  async getAccounts() {
+    const address = await __privateGet(this, _signer)?.getAddress();
+    if (!address)
+      return [];
+    return [getAddress(address)];
+  }
+  getSigner() {
+    const signer = __privateGet(this, _signer);
+    if (!signer)
+      throw new Error("Signer not found");
+    return signer;
+  }
+  async switchChain(chainId) {
+    if (__privateGet(this, _options).flags?.failSwitchChain)
+      throw new UserRejectedRequestError(new Error("Failed to switch chain"));
+    __privateGet(this, _options).chainId = chainId;
+    this.network.chainId = chainId;
+    this.events.emit("chainChanged", chainId);
+  }
+  async watchAsset(_asset) {
+    return true;
+  }
+  on(event, listener) {
+    this.events.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.events.once(event, listener);
+    return this;
+  }
+  removeListener(event, listener) {
+    this.events.removeListener(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.events.off(event, listener);
+    return this;
+  }
+  toJSON() {
+    return "<MockProvider>";
+  }
+};
+_options = new WeakMap();
+_signer = new WeakMap();
+
+// src/connectors/mock/connector.ts
+var _provider, _switchChain, switchChain_fn;
+var MockConnector = class extends Connector {
+  constructor(config) {
+    super(config);
+    __privateAdd(this, _switchChain);
+    this.id = "mock";
+    this.name = "Mock";
+    this.ready = true;
+    __privateAdd(this, _provider, void 0);
+    this.onAccountsChanged = (accounts) => {
+      if (accounts.length === 0)
+        this.emit("disconnect");
+      else
+        this.emit("change", { account: getAddress2(accounts[0]) });
+    };
+    this.onChainChanged = (chainId) => {
+      const id = normalizeChainId(chainId);
+      const unsupported = this.isChainUnsupported(id);
+      this.emit("change", { chain: { id, unsupported } });
+    };
+    this.onDisconnect = () => {
+      this.emit("disconnect");
+    };
+  }
+  async connect({ chainId } = {}) {
+    const provider = await this.getProvider({ chainId });
+    provider.on("accountsChanged", this.onAccountsChanged);
+    provider.on("chainChanged", this.onChainChanged);
+    provider.on("disconnect", this.onDisconnect);
+    this.emit("message", { type: "connecting" });
+    const accounts = await provider.enable();
+    const account = getAddress2(accounts[0]);
+    const id = normalizeChainId(provider._network.chainId);
+    const unsupported = this.isChainUnsupported(id);
+    const data = { account, chain: { id, unsupported }, provider };
+    if (!this.options.flags?.noSwitchChain)
+      this.switchChain = __privateMethod(this, _switchChain, switchChain_fn);
+    return new Promise(
+      (res) => setTimeout(() => res(data), 100)
+    );
+  }
+  async disconnect() {
+    const provider = await this.getProvider();
+    await provider.disconnect();
+    provider.removeListener("accountsChanged", this.onAccountsChanged);
+    provider.removeListener("chainChanged", this.onChainChanged);
+    provider.removeListener("disconnect", this.onDisconnect);
+  }
+  async getAccount() {
+    const provider = await this.getProvider();
+    const accounts = await provider.getAccounts();
+    const account = accounts[0];
+    if (!account)
+      throw new Error("Failed to get account");
+    return getAddress2(account);
+  }
+  async getChainId() {
+    const provider = await this.getProvider();
+    return normalizeChainId(provider.network.chainId);
+  }
+  async getProvider({ chainId } = {}) {
+    if (!__privateGet(this, _provider) || chainId)
+      __privateSet(this, _provider, new MockProvider({ ...this.options, chainId }));
+    return __privateGet(this, _provider);
+  }
+  async getSigner() {
+    const provider = await this.getProvider();
+    return provider.getSigner();
+  }
+  async isAuthorized() {
+    try {
+      const provider = await this.getProvider();
+      const account = await provider.getAccounts();
+      return this.options.flags?.isAuthorized ?? !!account;
+    } catch {
+      return false;
+    }
+  }
+  async watchAsset(asset) {
+    const provider = await this.getProvider();
+    return provider.watchAsset(asset);
+  }
+  toJSON() {
+    return "<MockConnector>";
+  }
+};
+_provider = new WeakMap();
+_switchChain = new WeakSet();
+switchChain_fn = async function(chainId) {
+  const provider = await this.getProvider();
+  await provider.switchChain(chainId);
+  return this.chains.find((x) => x.id === chainId) ?? {
+    id: chainId,
+    name: `Chain ${chainId}`,
+    network: `${chainId}`,
+    rpcUrls: { default: "" }
+  };
+};
+export {
+  MockConnector,
+  MockProvider
+};

package/dist/{declarations/src/connectors → connectors}/walletConnect.d.ts

@@ -1,10 +1,13 @@
-import type WalletConnectProvider from '@walletconnect/ethereum-provider';
+import WalletConnectProvider from '@walletconnect/ethereum-provider';
 import { providers } from 'ethers';
-import { Chain } from '../types';
-import { Connector } from './base';
+import { C as Chain } from '../index-bacc1c49.js';
+import { C as Connector } from '../base-5bd9b5ed.js';
+import 'abitype';
+import 'eventemitter3';
+
 declare type WalletConnectOptions = ConstructorParameters<typeof WalletConnectProvider>[0];
 declare type WalletConnectSigner = providers.JsonRpcSigner;
-export declare class WalletConnectConnector extends Connector<WalletConnectProvider, WalletConnectOptions, WalletConnectSigner> {
+declare class WalletConnectConnector extends Connector<WalletConnectProvider, WalletConnectOptions, WalletConnectSigner> {
     #private;
     readonly id = "walletConnect";
     readonly name = "WalletConnect";
@@ -38,4 +41,5 @@ export declare class WalletConnectConnector extends Connector<WalletConnectProvi
     protected onChainChanged: (chainId: number | string) => void;
     protected onDisconnect: () => void;
 }
-export {};
+
+export { WalletConnectConnector };