@wagmi/connectors 0.2.7 → 0.3.0

package/dist/walletConnect.d.ts

@@ -1,27 +1,69 @@
-import * as _walletconnect_universal_provider from '@walletconnect/universal-provider';
-import { UniversalProvider as UniversalProvider$1, UniversalProviderOpts } from '@walletconnect/universal-provider';
 import { Chain } from '@wagmi/core';
 import WalletConnectProvider from '@walletconnect/ethereum-provider';
+import { EthereumProviderOptions } from '@walletconnect/ethereum-provider/dist/types/EthereumProvider';
 import { providers } from 'ethers';
 import { C as Connector } from './base-84a689bb.js';
 import '@wagmi/core/chains';
 import 'eventemitter3';
 
-type UniversalProvider = InstanceType<typeof UniversalProvider$1>;
 type WalletConnectOptions = {
-    /** When `true`, uses default WalletConnect QR Code modal */
-    qrcode?: boolean;
-} & (({
-    version?: '1';
-} & ConstructorParameters<typeof WalletConnectProvider>[0]) | ({
     /**
-     * Project ID associated with [WalletConnect account](https://cloud.walletconnect.com)
+     * WalletConnect Cloud Project ID.
+     * @link https://cloud.walletconnect.com/sign-in.
      */
-    projectId: NonNullable<UniversalProviderOpts['projectId']>;
-    version: '2';
-} & Omit<UniversalProviderOpts, 'projectId'>));
+    projectId: EthereumProviderOptions['projectId'];
+    /**
+     * If a new chain is added to a previously existing configured connector `chains`, this flag
+     * will determine if that chain should be considered as stale. A stale chain is a chain that
+     * WalletConnect has yet to establish a relationship with (ie. the user has not approved or
+     * rejected the chain).
+     * Defaults to `true`.
+     *
+     * Preface: Whereas WalletConnect v1 supported dynamic chain switching, WalletConnect v2 requires
+     * the user to pre-approve a set of chains up-front. This comes with consequent UX nuances (see below) when
+     * a user tries to switch to a chain that they have not approved.
+     *
+     * This flag mainly affects the behavior when a wallet does not support dynamic chain authorization
+     * with WalletConnect v2.
+     *
+     * If `true` (default), the new chain will be treated as a stale chain. If the user
+     * has yet to establish a relationship (approved/rejected) with this chain in their WalletConnect
+     * session, the connector will disconnect upon the dapp auto-connecting, and the user will have to
+     * reconnect to the dapp (revalidate the chain) in order to approve the newly added chain.
+     * This is the default behavior to avoid an unexpected error upon switching chains which may
+     * be a confusing user experience (ie. the user will not know they have to reconnect
+     * unless the dapp handles these types of errors).
+     *
+     * If `false`, the new chain will be treated as a validated chain. This means that if the user
+     * has yet to establish a relationship with the chain in their WalletConnect session, wagmi will successfully
+     * auto-connect the user. This comes with the trade-off that the connector will throw an error
+     * when attempting to switch to the unapproved chain. This may be useful in cases where a dapp constantly
+     * modifies their configured chains, and they do not want to disconnect the user upon
+     * auto-connecting. If the user decides to switch to the unapproved chain, it is important that the
+     * dapp handles this error and prompts the user to reconnect to the dapp in order to approve
+     * the newly added chain.
+     *
+     */
+    isNewChainsStale?: boolean;
+    /**
+     * Metadata for your app.
+     * @link https://docs.walletconnect.com/2.0/javascript/providers/ethereum#initialization
+     */
+    metadata?: EthereumProviderOptions['metadata'];
+    /**
+     * Whether or not to show the QR code modal.
+     * @link https://docs.walletconnect.com/2.0/javascript/providers/ethereum#initialization
+     */
+    showQrModal?: EthereumProviderOptions['showQrModal'];
+};
 type WalletConnectSigner = providers.JsonRpcSigner;
-declare class WalletConnectConnector extends Connector<WalletConnectProvider | UniversalProvider, WalletConnectOptions, WalletConnectSigner> {
+type ConnectConfig = {
+    /** Target chain to connect to. */
+    chainId?: number;
+    /** If provided, will attempt to connect to an existing pairing. */
+    pairingTopic?: string;
+};
+declare class WalletConnectConnector extends Connector<WalletConnectProvider, WalletConnectOptions, WalletConnectSigner> {
     #private;
     readonly id = "walletConnect";
     readonly name = "WalletConnect";
@@ -30,12 +72,7 @@ declare class WalletConnectConnector extends Connector<WalletConnectProvider | U
         chains?: Chain[];
         options: WalletConnectOptions;
     });
-    get isQrCode(): boolean;
-    get namespacedChains(): string[];
-    get version(): "1" | "2" | undefined;
-    connect({ chainId }?: {
-        chainId?: number;
-    }): Promise<{
+    connect({ chainId, pairingTopic }?: ConnectConfig): Promise<{
         account: `0x${string}`;
         chain: {
             id: number;
@@ -46,18 +83,19 @@ declare class WalletConnectConnector extends Connector<WalletConnectProvider | U
     disconnect(): Promise<void>;
     getAccount(): Promise<`0x${string}`>;
     getChainId(): Promise<number>;
-    getProvider({ chainId, create, }?: {
+    getProvider({ chainId }?: {
         chainId?: number;
-        create?: boolean;
-    }): Promise<_walletconnect_universal_provider.default | WalletConnectProvider>;
+    }): Promise<WalletConnectProvider>;
     getSigner({ chainId }?: {
         chainId?: number;
     }): Promise<providers.JsonRpcSigner>;
     isAuthorized(): Promise<boolean>;
+    switchChain(chainId: number): Promise<Chain>;
     protected onAccountsChanged: (accounts: string[]) => void;
     protected onChainChanged: (chainId: number | string) => void;
     protected onDisconnect: () => void;
     protected onDisplayUri: (uri: string) => void;
+    protected onConnect: () => void;
 }
 
 export { WalletConnectConnector };

package/dist/walletConnect.js

@@ -11,42 +11,34 @@ import {
 import {
   SwitchChainError,
   UserRejectedRequestError,
-  getClient,
-  normalizeChainId
+  getClient
 } from "@wagmi/core";
 import { providers } from "ethers";
 import { getAddress, hexValue } from "ethers/lib/utils.js";
-var defaultV2Config = {
-  namespace: "eip155",
-  methods: [
-    "eth_sendTransaction",
-    "eth_sendRawTransaction",
-    "eth_sign",
-    "eth_signTransaction",
-    "eth_signTypedData",
-    "eth_signTypedData_v3",
-    "eth_signTypedData_v4",
-    "personal_sign",
-    "wallet_switchEthereumChain",
-    "wallet_addEthereumChain"
-  ],
-  events: ["accountsChanged", "chainChanged"]
-};
-var _provider, _initUniversalProviderPromise, _web3Modal, _createWeb3Modal, createWeb3Modal_fn, _initUniversalProvider, initUniversalProvider_fn, _createUniversalProvider, createUniversalProvider_fn, _isChainsAuthorized, isChainsAuthorized_fn, _switchChain, switchChain_fn;
+var NAMESPACE = "eip155";
+var REQUESTED_CHAINS_KEY = "wagmi.requestedChains";
+var ADD_ETH_CHAIN_METHOD = "wallet_addEthereumChain";
+var _provider, _initProviderPromise, _createProvider, createProvider_fn, _initProvider, initProvider_fn, _isChainsStale, isChainsStale_fn, _setupListeners, setupListeners_fn, _removeListeners, removeListeners_fn, _setRequestedChainsIds, setRequestedChainsIds_fn, _getRequestedChainsIds, getRequestedChainsIds_fn, _getNamespaceChainsIds, getNamespaceChainsIds_fn, _getNamespaceMethods, getNamespaceMethods_fn;
 var WalletConnectConnector = class extends Connector {
   constructor(config) {
-    super(config);
-    __privateAdd(this, _createWeb3Modal);
-    __privateAdd(this, _initUniversalProvider);
-    __privateAdd(this, _createUniversalProvider);
-    __privateAdd(this, _isChainsAuthorized);
-    __privateAdd(this, _switchChain);
+    super({
+      ...config,
+      options: { isNewChainsStale: true, ...config.options }
+    });
+    __privateAdd(this, _createProvider);
+    __privateAdd(this, _initProvider);
+    __privateAdd(this, _isChainsStale);
+    __privateAdd(this, _setupListeners);
+    __privateAdd(this, _removeListeners);
+    __privateAdd(this, _setRequestedChainsIds);
+    __privateAdd(this, _getRequestedChainsIds);
+    __privateAdd(this, _getNamespaceChainsIds);
+    __privateAdd(this, _getNamespaceMethods);
     __publicField(this, "id", "walletConnect");
     __publicField(this, "name", "WalletConnect");
     __publicField(this, "ready", true);
     __privateAdd(this, _provider, void 0);
-    __privateAdd(this, _initUniversalProviderPromise, void 0);
-    __privateAdd(this, _web3Modal, void 0);
+    __privateAdd(this, _initProviderPromise, void 0);
     __publicField(this, "onAccountsChanged", (accounts) => {
       if (accounts.length === 0)
         this.emit("disconnect");
@@ -54,127 +46,60 @@ var WalletConnectConnector = class extends Connector {
         this.emit("change", { account: getAddress(accounts[0]) });
     });
     __publicField(this, "onChainChanged", (chainId) => {
-      const id = normalizeChainId(chainId);
+      const id = Number(chainId);
       const unsupported = this.isChainUnsupported(id);
       this.emit("change", { chain: { id, unsupported } });
     });
     __publicField(this, "onDisconnect", () => {
+      __privateMethod(this, _setRequestedChainsIds, setRequestedChainsIds_fn).call(this, []);
       this.emit("disconnect");
     });
     __publicField(this, "onDisplayUri", (uri) => {
       this.emit("message", { type: "display_uri", data: uri });
     });
-    if (this.version === "2") {
-      __privateMethod(this, _createUniversalProvider, createUniversalProvider_fn).call(this);
-      if (this.isQrCode)
-        __privateMethod(this, _createWeb3Modal, createWeb3Modal_fn).call(this);
-    }
-  }
-  get isQrCode() {
-    return this.options.qrcode !== false;
-  }
-  get namespacedChains() {
-    return this.chains.map(
-      (chain) => `${defaultV2Config.namespace}:${chain.id}`
-    );
-  }
-  get version() {
-    if ("version" in this.options)
-      return this.options.version;
-    return "1";
+    __publicField(this, "onConnect", () => {
+      this.emit("connect", { provider: __privateGet(this, _provider) });
+    });
+    __privateMethod(this, _createProvider, createProvider_fn).call(this);
   }
-  async connect({ chainId } = {}) {
-    const isV1 = this.version === "1";
-    const isV2 = this.version === "2";
+  async connect({ chainId, pairingTopic } = {}) {
     try {
       let targetChainId = chainId;
       if (!targetChainId) {
         const lastUsedChainId = getClient().lastUsedChainId;
         if (lastUsedChainId && !this.isChainUnsupported(lastUsedChainId))
           targetChainId = lastUsedChainId;
+        else
+          targetChainId = this.chains[0]?.id;
       }
-      const provider = await this.getProvider({
-        chainId: targetChainId,
-        create: isV1
-      });
-      provider.on("accountsChanged", this.onAccountsChanged);
-      provider.on("chainChanged", this.onChainChanged);
-      provider.on("disconnect", this.onDisconnect);
-      if (isV2) {
-        provider.on("session_delete", this.onDisconnect);
-        provider.on("display_uri", this.onDisplayUri);
-        const isChainsAuthorized = await __privateMethod(this, _isChainsAuthorized, isChainsAuthorized_fn).call(this);
-        if (provider.session && !isChainsAuthorized)
-          await provider.disconnect();
-        if (!provider.session || provider.session && !isChainsAuthorized) {
-          await Promise.race([
-            provider.connect({
-              namespaces: {
-                [defaultV2Config.namespace]: {
-                  methods: defaultV2Config.methods,
-                  events: defaultV2Config.events,
-                  chains: this.namespacedChains,
-                  rpcMap: this.chains.reduce(
-                    (rpc, chain) => ({
-                      ...rpc,
-                      [chain.id]: chain.rpcUrls.default.http[0]
-                    }),
-                    {}
-                  )
-                }
-              }
-            }),
-            ...this.isQrCode ? [
-              new Promise(
-                (_resolve, reject) => provider.on("display_uri", async (uri) => {
-                  await __privateGet(this, _web3Modal)?.openModal({ uri });
-                  __privateGet(this, _web3Modal)?.subscribeModal(({ open }) => {
-                    if (!open)
-                      reject(new Error("user rejected"));
-                  });
-                })
-              )
-            ] : []
-          ]);
-          if (this.isQrCode)
-            __privateGet(this, _web3Modal)?.closeModal();
-        }
+      if (!targetChainId)
+        throw new Error("No chains found on connector.");
+      const provider = await this.getProvider();
+      __privateMethod(this, _setupListeners, setupListeners_fn).call(this);
+      const isChainsStale = __privateMethod(this, _isChainsStale, isChainsStale_fn).call(this);
+      if (provider.session && isChainsStale)
+        await provider.disconnect();
+      if (!provider.session || isChainsStale) {
+        const optionalChains = this.chains.filter((chain) => chain.id !== targetChainId).map((optionalChain) => optionalChain.id);
+        this.emit("message", { type: "connecting" });
+        await provider.connect({
+          pairingTopic,
+          chains: [targetChainId],
+          optionalChains
+        });
+        __privateMethod(this, _setRequestedChainsIds, setRequestedChainsIds_fn).call(this, this.chains.map(({ id: id2 }) => id2));
       }
-      setTimeout(() => this.emit("message", { type: "connecting" }), 0);
-      const accounts = await Promise.race([
-        provider.enable(),
-        ...isV1 && this.isQrCode ? [
-          new Promise(
-            (_res, reject) => provider.connector.on(
-              "disconnect",
-              () => reject(new Error("user rejected"))
-            )
-          )
-        ] : []
-      ]);
+      const accounts = await provider.enable();
       const account = getAddress(accounts[0]);
       const id = await this.getChainId();
       const unsupported = this.isChainUnsupported(id);
-      if (isV1) {
-        const walletName = provider.connector?.peerMeta?.name ?? "";
-        const switchChainAllowedRegex = /(imtoken|metamask|omni|rainbow|trust wallet)/i;
-        if (switchChainAllowedRegex.test(walletName))
-          this.switchChain = __privateMethod(this, _switchChain, switchChain_fn);
-      } else
-        this.switchChain = __privateMethod(this, _switchChain, switchChain_fn);
       return {
         account,
         chain: { id, unsupported },
-        provider: new providers.Web3Provider(
-          provider
-        )
+        provider: new providers.Web3Provider(provider)
       };
     } catch (error) {
-      if (isV2 && this.isQrCode)
-        __privateGet(this, _web3Modal)?.closeModal();
-      if (/user closed modal|user rejected/i.test(
-        error?.message
-      )) {
+      if (/user rejected/i.test(error?.message)) {
         throw new UserRejectedRequestError(error);
       }
       throw error;
@@ -187,62 +112,24 @@ var WalletConnectConnector = class extends Connector {
     } catch (error) {
       if (!/No matching key/i.test(error.message))
         throw error;
-    }
-    provider.removeListener("accountsChanged", this.onAccountsChanged);
-    provider.removeListener("chainChanged", this.onChainChanged);
-    provider.removeListener("disconnect", this.onDisconnect);
-    if (this.version === "1" && typeof localStorage !== "undefined")
-      localStorage.removeItem("walletconnect");
-    else {
-      provider.removeListener("session_delete", this.onDisconnect);
-      provider.removeListener("display_uri", this.onDisplayUri);
+    } finally {
+      __privateMethod(this, _removeListeners, removeListeners_fn).call(this);
+      __privateMethod(this, _setRequestedChainsIds, setRequestedChainsIds_fn).call(this, []);
     }
   }
   async getAccount() {
-    const provider = await this.getProvider();
-    let accounts;
-    if (this.version === "1")
-      accounts = provider.accounts;
-    else
-      accounts = await provider.request({
-        method: "eth_accounts"
-      });
+    const { accounts } = await this.getProvider();
     return getAddress(accounts[0]);
   }
   async getChainId() {
-    const provider = await this.getProvider();
-    if (this.version === "1")
-      return normalizeChainId(provider.chainId);
-    return getClient().data?.chain?.id ?? normalizeChainId(await provider.request({ method: "eth_chainId" }));
+    const { chainId } = await this.getProvider();
+    return chainId;
   }
-  async getProvider({
-    chainId,
-    create
-  } = {}) {
-    if (this.options.version === "2") {
-      if (!__privateGet(this, _provider))
-        await __privateMethod(this, _createUniversalProvider, createUniversalProvider_fn).call(this);
-      if (chainId)
-        __privateGet(this, _provider).setDefaultChain(
-          `${defaultV2Config.namespace}:${chainId}`
-        );
-      return __privateGet(this, _provider);
-    } else if (!__privateGet(this, _provider) || chainId || create) {
-      const rpc = !this.options?.infuraId ? this.chains.reduce(
-        (rpc2, chain) => ({
-          ...rpc2,
-          [chain.id]: chain.rpcUrls.default.http[0]
-        }),
-        {}
-      ) : {};
-      const WalletConnectProvider = (await import("@walletconnect/ethereum-provider")).default;
-      __privateSet(this, _provider, new WalletConnectProvider({
-        ...this.options,
-        chainId,
-        rpc: { ...rpc, ...this.options?.rpc }
-      }));
-      return __privateGet(this, _provider);
-    }
+  async getProvider({ chainId } = {}) {
+    if (!__privateGet(this, _provider))
+      await __privateMethod(this, _createProvider, createProvider_fn).call(this);
+    if (chainId)
+      await this.switchChain(chainId);
     return __privateGet(this, _provider);
   }
   async getSigner({ chainId } = {}) {
@@ -250,110 +137,165 @@ var WalletConnectConnector = class extends Connector {
       this.getProvider({ chainId }),
       this.getAccount()
     ]);
-    let provider_ = provider;
-    if (this.version === "2") {
-      const chainId_ = await this.getChainId();
-      provider_ = {
-        ...provider,
-        async request(args) {
-          return await provider.request(
-            args,
-            `${defaultV2Config.namespace}:${chainId ?? chainId_}`
-          );
-        }
-      };
-    }
-    return new providers.Web3Provider(provider_, chainId).getSigner(account);
+    return new providers.Web3Provider(provider, chainId).getSigner(account);
   }
   async isAuthorized() {
     try {
-      const [account, isChainsAuthorized] = await Promise.all([
+      const [account, provider] = await Promise.all([
         this.getAccount(),
-        __privateMethod(this, _isChainsAuthorized, isChainsAuthorized_fn).call(this)
+        this.getProvider()
       ]);
-      return !!account && isChainsAuthorized;
+      const isChainsStale = __privateMethod(this, _isChainsStale, isChainsStale_fn).call(this);
+      if (!account)
+        return false;
+      if (isChainsStale && provider.session) {
+        try {
+          await provider.disconnect();
+        } catch {
+        }
+        return false;
+      }
+      return true;
     } catch {
       return false;
     }
   }
+  async switchChain(chainId) {
+    const chain = this.chains.find((chain2) => chain2.id === chainId);
+    if (!chain)
+      throw new SwitchChainError(new Error("chain not found on connector."));
+    try {
+      const provider = await this.getProvider();
+      const namespaceChains = __privateMethod(this, _getNamespaceChainsIds, getNamespaceChainsIds_fn).call(this);
+      const namespaceMethods = __privateMethod(this, _getNamespaceMethods, getNamespaceMethods_fn).call(this);
+      const isChainApproved = namespaceChains.includes(chainId);
+      if (!isChainApproved && namespaceMethods.includes(ADD_ETH_CHAIN_METHOD)) {
+        await provider.request({
+          method: ADD_ETH_CHAIN_METHOD,
+          params: [
+            {
+              chainId: hexValue(chain.id),
+              blockExplorerUrls: [chain.blockExplorers?.default],
+              chainName: chain.name,
+              nativeCurrency: chain.nativeCurrency,
+              rpcUrls: [...chain.rpcUrls.default.http]
+            }
+          ]
+        });
+        const requestedChains = __privateMethod(this, _getRequestedChainsIds, getRequestedChainsIds_fn).call(this);
+        requestedChains.push(chainId);
+        __privateMethod(this, _setRequestedChainsIds, setRequestedChainsIds_fn).call(this, requestedChains);
+      }
+      await provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: hexValue(chainId) }]
+      });
+      return chain;
+    } catch (error) {
+      const message = typeof error === "string" ? error : error?.message;
+      if (/user rejected request/i.test(message)) {
+        throw new UserRejectedRequestError(error);
+      }
+      throw new SwitchChainError(error);
+    }
+  }
 };
 _provider = new WeakMap();
-_initUniversalProviderPromise = new WeakMap();
-_web3Modal = new WeakMap();
-_createWeb3Modal = new WeakSet();
-createWeb3Modal_fn = async function() {
-  const { Web3Modal } = await import("@web3modal/standalone");
-  const { version } = this.options;
-  __privateSet(this, _web3Modal, new Web3Modal({
-    walletConnectVersion: version === "2" ? 2 : 1,
-    projectId: version === "2" ? this.options.projectId : "",
-    standaloneChains: this.namespacedChains
-  }));
-};
-_initUniversalProvider = new WeakSet();
-initUniversalProvider_fn = async function() {
-  const WalletConnectProvider = (await import("@walletconnect/universal-provider")).default;
-  if (typeof WalletConnectProvider?.init === "function") {
-    __privateSet(this, _provider, await WalletConnectProvider.init(
-      this.options
-    ));
+_initProviderPromise = new WeakMap();
+_createProvider = new WeakSet();
+createProvider_fn = async function() {
+  if (!__privateGet(this, _initProviderPromise) && typeof window !== "undefined") {
+    __privateSet(this, _initProviderPromise, __privateMethod(this, _initProvider, initProvider_fn).call(this));
   }
+  return __privateGet(this, _initProviderPromise);
 };
-_createUniversalProvider = new WeakSet();
-createUniversalProvider_fn = async function() {
-  if (!__privateGet(this, _initUniversalProviderPromise)) {
-    __privateSet(this, _initUniversalProviderPromise, __privateMethod(this, _initUniversalProvider, initUniversalProvider_fn).call(this));
+_initProvider = new WeakSet();
+initProvider_fn = async function() {
+  const {
+    default: EthereumProvider,
+    OPTIONAL_EVENTS,
+    OPTIONAL_METHODS
+  } = await import("@walletconnect/ethereum-provider");
+  const [defaultChain, ...optionalChains] = this.chains.map(({ id }) => id);
+  if (defaultChain) {
+    const { projectId, showQrModal } = this.options;
+    __privateSet(this, _provider, await EthereumProvider.init({
+      showQrModal,
+      projectId,
+      optionalMethods: OPTIONAL_METHODS,
+      optionalEvents: OPTIONAL_EVENTS,
+      chains: [defaultChain],
+      optionalChains,
+      rpcMap: Object.fromEntries(
+        this.chains.map((chain) => [
+          chain.id,
+          chain.rpcUrls.default.http[0]
+        ])
+      )
+    }));
   }
-  return __privateGet(this, _initUniversalProviderPromise);
 };
-_isChainsAuthorized = new WeakSet();
-isChainsAuthorized_fn = async function() {
-  const provider = await this.getProvider();
-  if (this.version === "1")
-    return true;
-  const providerChains = provider.namespaces?.[defaultV2Config.namespace]?.chains || [];
-  const authorizedChainIds = providerChains.map(
+_isChainsStale = new WeakSet();
+isChainsStale_fn = function() {
+  const namespaceMethods = __privateMethod(this, _getNamespaceMethods, getNamespaceMethods_fn).call(this);
+  if (namespaceMethods.includes(ADD_ETH_CHAIN_METHOD))
+    return false;
+  if (!this.options.isNewChainsStale)
+    return false;
+  const requestedChains = __privateMethod(this, _getRequestedChainsIds, getRequestedChainsIds_fn).call(this);
+  const connectorChains = this.chains.map(({ id }) => id);
+  const namespaceChains = __privateMethod(this, _getNamespaceChainsIds, getNamespaceChainsIds_fn).call(this);
+  if (namespaceChains.length && !namespaceChains.some((id) => connectorChains.includes(id)))
+    return false;
+  return !connectorChains.every((id) => requestedChains.includes(id));
+};
+_setupListeners = new WeakSet();
+setupListeners_fn = function() {
+  if (!__privateGet(this, _provider))
+    return;
+  __privateMethod(this, _removeListeners, removeListeners_fn).call(this);
+  __privateGet(this, _provider).on("accountsChanged", this.onAccountsChanged);
+  __privateGet(this, _provider).on("chainChanged", this.onChainChanged);
+  __privateGet(this, _provider).on("disconnect", this.onDisconnect);
+  __privateGet(this, _provider).on("session_delete", this.onDisconnect);
+  __privateGet(this, _provider).on("display_uri", this.onDisplayUri);
+  __privateGet(this, _provider).on("connect", this.onConnect);
+};
+_removeListeners = new WeakSet();
+removeListeners_fn = function() {
+  if (!__privateGet(this, _provider))
+    return;
+  __privateGet(this, _provider).removeListener("accountsChanged", this.onAccountsChanged);
+  __privateGet(this, _provider).removeListener("chainChanged", this.onChainChanged);
+  __privateGet(this, _provider).removeListener("disconnect", this.onDisconnect);
+  __privateGet(this, _provider).removeListener("session_delete", this.onDisconnect);
+  __privateGet(this, _provider).removeListener("display_uri", this.onDisplayUri);
+  __privateGet(this, _provider).removeListener("connect", this.onConnect);
+};
+_setRequestedChainsIds = new WeakSet();
+setRequestedChainsIds_fn = function(chains) {
+  localStorage.setItem(REQUESTED_CHAINS_KEY, JSON.stringify(chains));
+};
+_getRequestedChainsIds = new WeakSet();
+getRequestedChainsIds_fn = function() {
+  const data = localStorage.getItem(REQUESTED_CHAINS_KEY);
+  return data ? JSON.parse(data) : [];
+};
+_getNamespaceChainsIds = new WeakSet();
+getNamespaceChainsIds_fn = function() {
+  if (!__privateGet(this, _provider))
+    return [];
+  const chainIds = __privateGet(this, _provider).session?.namespaces[NAMESPACE]?.chains?.map(
     (chain) => parseInt(chain.split(":")[1] || "")
   );
-  return !this.chains.some(({ id }) => !authorizedChainIds.includes(id));
+  return chainIds ?? [];
 };
-_switchChain = new WeakSet();
-switchChain_fn = async function(chainId) {
-  const provider = await this.getProvider();
-  const id = hexValue(chainId);
-  try {
-    await Promise.race([
-      provider.request({
-        method: "wallet_switchEthereumChain",
-        params: [{ chainId: id }]
-      }),
-      new Promise(
-        (res) => this.on("change", ({ chain }) => {
-          if (chain?.id === chainId)
-            res(chainId);
-        })
-      )
-    ]);
-    if (this.version === "2") {
-      ;
-      provider.setDefaultChain(
-        `${defaultV2Config.namespace}:${chainId}`
-      );
-      this.onChainChanged(chainId);
-    }
-    return this.chains.find((x) => x.id === chainId) ?? {
-      id: chainId,
-      name: `Chain ${id}`,
-      network: `${id}`,
-      nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
-      rpcUrls: { default: { http: [""] }, public: { http: [""] } }
-    };
-  } catch (error) {
-    const message = typeof error === "string" ? error : error?.message;
-    if (/user rejected request/i.test(message))
-      throw new UserRejectedRequestError(error);
-    throw new SwitchChainError(error);
-  }
+_getNamespaceMethods = new WeakSet();
+getNamespaceMethods_fn = function() {
+  if (!__privateGet(this, _provider))
+    return [];
+  const methods = __privateGet(this, _provider).session?.namespaces[NAMESPACE]?.methods;
+  return methods ?? [];
 };
 export {
   WalletConnectConnector

package/dist/walletConnectLegacy.d.ts

@@ -0,0 +1,45 @@
+import { Chain } from '@wagmi/core/chains';
+import WalletConnectProvider from '@walletconnect/legacy-provider';
+import { providers } from 'ethers';
+import { C as Connector } from './base-84a689bb.js';
+import '@wagmi/core';
+import 'eventemitter3';
+
+type WalletConnectOptions = ConstructorParameters<typeof WalletConnectProvider>[0];
+type WalletConnectSigner = providers.JsonRpcSigner;
+declare class WalletConnectLegacyConnector extends Connector<WalletConnectProvider, WalletConnectOptions, WalletConnectSigner> {
+    #private;
+    readonly id = "walletConnectLegacy";
+    readonly name = "WalletConnectLegacy";
+    readonly ready = true;
+    constructor(config: {
+        chains?: Chain[];
+        options: WalletConnectOptions;
+    });
+    connect({ chainId }?: {
+        chainId?: number;
+    }): Promise<{
+        account: `0x${string}`;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: providers.Web3Provider;
+    }>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<`0x${string}`>;
+    getChainId(): Promise<number>;
+    getProvider({ chainId, create, }?: {
+        chainId?: number;
+        create?: boolean;
+    }): Promise<WalletConnectProvider>;
+    getSigner({ chainId }?: {
+        chainId?: number;
+    }): Promise<providers.JsonRpcSigner>;
+    isAuthorized(): Promise<boolean>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: () => void;
+}
+
+export { WalletConnectLegacyConnector };

package/dist/walletConnectLegacy.js

@@ -0,0 +1,172 @@
+import {
+  Connector,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __publicField
+} from "./chunk-5NCTPR6C.js";
+
+// src/walletConnectLegacy.ts
+import {
+  SwitchChainError,
+  UserRejectedRequestError,
+  getClient,
+  normalizeChainId
+} from "@wagmi/core";
+import { providers } from "ethers";
+import { getAddress, hexValue } from "ethers/lib/utils.js";
+var switchChainAllowedRegex = /(imtoken|metamask|rainbow|trust wallet)/i;
+var _provider, _switchChain, switchChain_fn;
+var WalletConnectLegacyConnector = class extends Connector {
+  constructor(config) {
+    super(config);
+    __privateAdd(this, _switchChain);
+    __publicField(this, "id", "walletConnectLegacy");
+    __publicField(this, "name", "WalletConnectLegacy");
+    __publicField(this, "ready", true);
+    __privateAdd(this, _provider, void 0);
+    __publicField(this, "onAccountsChanged", (accounts) => {
+      if (accounts.length === 0)
+        this.emit("disconnect");
+      else
+        this.emit("change", { account: getAddress(accounts[0]) });
+    });
+    __publicField(this, "onChainChanged", (chainId) => {
+      const id = normalizeChainId(chainId);
+      const unsupported = this.isChainUnsupported(id);
+      this.emit("change", { chain: { id, unsupported } });
+    });
+    __publicField(this, "onDisconnect", () => {
+      this.emit("disconnect");
+    });
+  }
+  async connect({ chainId } = {}) {
+    try {
+      let targetChainId = chainId;
+      if (!targetChainId) {
+        const lastUsedChainId = getClient().lastUsedChainId;
+        if (lastUsedChainId && !this.isChainUnsupported(lastUsedChainId))
+          targetChainId = lastUsedChainId;
+      }
+      const provider = await this.getProvider({
+        chainId: targetChainId,
+        create: true
+      });
+      provider.on("accountsChanged", this.onAccountsChanged);
+      provider.on("chainChanged", this.onChainChanged);
+      provider.on("disconnect", this.onDisconnect);
+      setTimeout(() => this.emit("message", { type: "connecting" }), 0);
+      const accounts = await provider.enable();
+      const account = getAddress(accounts[0]);
+      const id = await this.getChainId();
+      const unsupported = this.isChainUnsupported(id);
+      const walletName = provider.connector?.peerMeta?.name ?? "";
+      if (switchChainAllowedRegex.test(walletName))
+        this.switchChain = __privateMethod(this, _switchChain, switchChain_fn);
+      return {
+        account,
+        chain: { id, unsupported },
+        provider: new providers.Web3Provider(
+          provider
+        )
+      };
+    } catch (error) {
+      if (/user closed modal/i.test(error.message))
+        throw new UserRejectedRequestError(error);
+      throw error;
+    }
+  }
+  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);
+    typeof localStorage !== "undefined" && localStorage.removeItem("walletconnect");
+  }
+  async getAccount() {
+    const provider = await this.getProvider();
+    const accounts = provider.accounts;
+    return getAddress(accounts[0]);
+  }
+  async getChainId() {
+    const provider = await this.getProvider();
+    const chainId = normalizeChainId(provider.chainId);
+    return chainId;
+  }
+  async getProvider({
+    chainId,
+    create
+  } = {}) {
+    if (!__privateGet(this, _provider) || chainId || create) {
+      const rpc = !this.options?.infuraId ? this.chains.reduce(
+        (rpc2, chain) => ({
+          ...rpc2,
+          [chain.id]: chain.rpcUrls.default.http[0]
+        }),
+        {}
+      ) : {};
+      const WalletConnectProvider = (await import("@walletconnect/legacy-provider")).default;
+      __privateSet(this, _provider, new WalletConnectProvider({
+        ...this.options,
+        chainId,
+        rpc: { ...rpc, ...this.options?.rpc }
+      }));
+    }
+    return __privateGet(this, _provider);
+  }
+  async getSigner({ chainId } = {}) {
+    const [provider, account] = await Promise.all([
+      this.getProvider({ chainId }),
+      this.getAccount()
+    ]);
+    return new providers.Web3Provider(
+      provider,
+      chainId
+    ).getSigner(account);
+  }
+  async isAuthorized() {
+    try {
+      const account = await this.getAccount();
+      return !!account;
+    } catch {
+      return false;
+    }
+  }
+};
+_provider = new WeakMap();
+_switchChain = new WeakSet();
+switchChain_fn = async function(chainId) {
+  const provider = await this.getProvider();
+  const id = hexValue(chainId);
+  try {
+    await Promise.race([
+      provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: id }]
+      }),
+      new Promise(
+        (res) => this.on("change", ({ chain }) => {
+          if (chain?.id === chainId)
+            res(chainId);
+        })
+      )
+    ]);
+    return this.chains.find((x) => x.id === chainId) ?? {
+      id: chainId,
+      name: `Chain ${id}`,
+      network: `${id}`,
+      nativeCurrency: { name: "Ether", decimals: 18, symbol: "ETH" },
+      rpcUrls: { default: { http: [""] }, public: { http: [""] } }
+    };
+  } catch (error) {
+    const message = typeof error === "string" ? error : error?.message;
+    if (/user rejected request/i.test(message))
+      throw new UserRejectedRequestError(error);
+    throw new SwitchChainError(error);
+  }
+};
+export {
+  WalletConnectLegacyConnector
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@wagmi/connectors",
   "description": "A collection of connectors for wagmi",
   "license": "MIT",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "peerDependencies": {
     "@wagmi/core": ">=0.9.x",
     "ethers": ">=5.5.1 <6",
@@ -19,11 +19,10 @@
   "dependencies": {
     "@coinbase/wallet-sdk": "^3.5.4",
     "@ledgerhq/connect-kit-loader": "^1.0.1",
-    "@walletconnect/ethereum-provider": "^1.8.0",
-    "@walletconnect/universal-provider": "2.3.3",
+    "@walletconnect/ethereum-provider": "^2.4.6",
+    "@walletconnect/legacy-provider": "^2.0.0",
     "@safe-global/safe-apps-provider": "^0.15.2",
     "@safe-global/safe-apps-sdk": "^7.9.0",
-    "@web3modal/standalone": "^2.1.1",
     "abitype": "^0.3.0",
     "eventemitter3": "^4.0.7"
   },
@@ -67,6 +66,10 @@
       "types": "./dist/walletConnect.d.ts",
       "default": "./dist/walletConnect.js"
     },
+    "./walletConnectLegacy": {
+      "types": "./dist/walletConnectLegacy.d.ts",
+      "default": "./dist/walletConnectLegacy.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -77,6 +80,7 @@
     "/mock",
     "/safe",
     "/walletConnect",
+    "/walletConnectLegacy",
     "/dist"
   ],
   "sideEffects": false,

package/walletConnectLegacy/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "main": "../dist/walletConnectLegacy.js"
+}