@getpara/evm-wallet-connectors 2.0.0-alpha.67 → 2.0.0-alpha.68

package/README.md

@@ -0,0 +1,20 @@
+https://www.npmjs.com/package/@getpara/evm-wallet-connectors
+
+The package is used with Para's React SDK Lite to enable external EVM wallet connections. Para automatically manages the Wagmi provider internally when you configure external wallet support.
+
+###Key Features
+
+- Wagmi Integration: Powered by Wagmi, the popular React hooks library for Ethereum
+- Automatic Setup: Para handles all Wagmi provider configuration internally
+- Unified Configuration: Configure chains and settings through Para's `externalWalletConfig`
+- All Wagmi Hooks Available: Use any Wagmi hook alongside Para hooks
+
+###Prerequisites
+
+To use Para, you need an API key. This key authenticates your requests to Para services and is essential for integration.
+
+Don't have an API key yet? Request access to the [Developer Portal](https://developer.getpara.com/) to create API keys, manage billing, teams, and more.
+
+###Learn more
+
+For more information on Para’s EVM Wallet Connectors visit the [Para Docs](https://docs.getpara.com/v2/react/guides/external-wallets/evm-lite#evm-wallets-with-react-sdk-lite)

package/dist/connectors/walletConnect.d.ts

@@ -0,0 +1,63 @@
+import type { Compute, ExactPartial, Omit } from '@wagmi/core/internal';
+import type { EthereumProvider } from '@walletconnect/ethereum-provider';
+import { type Address, type ProviderConnectInfo } from 'viem';
+type EthereumProviderOptions = Parameters<(typeof EthereumProvider)['init']>[0];
+export type WalletConnectParameters = Compute<{
+    /**
+     * 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 (e.g. the user has not approved or
+     * rejected the chain).
+     *
+     * 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 (e.g. 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 potentially valid 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 if the wallet does not support dynamic session updates.
+     * 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.
+     *
+     * @default true
+     */
+    isNewChainsStale?: boolean;
+} & Omit<EthereumProviderOptions, 'chains' | 'events' | 'optionalChains' | 'optionalEvents' | 'optionalMethods' | 'methods' | 'rpcMap' | 'showQrModal'> & ExactPartial<Pick<EthereumProviderOptions, 'showQrModal'>>>;
+type ConnectParams = {
+    chainId?: number | undefined;
+    isReconnecting?: boolean | undefined;
+    pairingTopic?: string | undefined;
+};
+export declare function walletConnect(parameters: WalletConnectParameters): import("@wagmi/core").CreateConnectorFn<import("@walletconnect/ethereum-provider").default, {
+    connect(parameters: ConnectParams): Promise<{
+        accounts: readonly Address[];
+        chainId: number;
+    }>;
+    getNamespaceChainsIds(): number[];
+    getRequestedChainsIds(): Promise<number[]>;
+    isChainsStale(): Promise<boolean>;
+    onConnect(connectInfo: ProviderConnectInfo): void;
+    onDisplayUri(uri: string): void;
+    onSessionDelete(data: {
+        topic: string;
+    }): void;
+    setRequestedChainsIds(chains: number[]): void;
+    requestedChainsStorageKey: `${string}.requestedChains`;
+}, {
+    [x: `${string}.requestedChains`]: number[];
+}>;
+export declare namespace walletConnect {
+    var type: "walletConnect";
+}
+export {};

package/dist/connectors/walletConnect.js

@@ -0,0 +1,366 @@
+"use client";
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-MMUBH76A.js";
+import {
+  ChainNotConfiguredError,
+  ProviderNotFoundError,
+  createConnector,
+  extractRpcUrls
+} from "@wagmi/core";
+import {
+  SwitchChainError,
+  UserRejectedRequestError,
+  getAddress,
+  numberToHex
+} from "viem";
+walletConnect.type = "walletConnect";
+function walletConnect(parameters) {
+  var _a;
+  const isNewChainsStale = (_a = parameters.isNewChainsStale) != null ? _a : true;
+  let provider_;
+  let providerPromise;
+  const NAMESPACE = "eip155";
+  let accountsChanged;
+  let chainChanged;
+  let connect;
+  let displayUri;
+  let sessionDelete;
+  let disconnect;
+  return createConnector((config) => ({
+    id: "walletConnect",
+    name: "WalletConnect",
+    type: walletConnect.type,
+    setup() {
+      return __async(this, null, function* () {
+        const provider = yield this.getProvider().catch(() => null);
+        if (!provider) return;
+        if (!connect) {
+          connect = this.onConnect.bind(this);
+          provider.on("connect", connect);
+        }
+        if (!sessionDelete) {
+          sessionDelete = this.onSessionDelete.bind(this);
+          provider.on("session_delete", sessionDelete);
+        }
+      });
+    },
+    connect() {
+      return __async(this, arguments, function* (_b = {}) {
+        var _c = _b, { chainId } = _c, rest = __objRest(_c, ["chainId"]);
+        var _a3, _b2, _c2;
+        try {
+          const provider = yield this.getProvider();
+          if (!provider) throw new ProviderNotFoundError();
+          if (!displayUri) {
+            displayUri = this.onDisplayUri;
+            provider.on("display_uri", displayUri);
+          }
+          let targetChainId = chainId;
+          if (!targetChainId) {
+            const state = (_b2 = yield (_a3 = config.storage) == null ? void 0 : _a3.getItem("state")) != null ? _b2 : {};
+            const isChainSupported = config.chains.some((x) => x.id === state.chainId);
+            if (isChainSupported) targetChainId = state.chainId;
+            else targetChainId = (_c2 = config.chains[0]) == null ? void 0 : _c2.id;
+          }
+          if (!targetChainId) throw new Error("No chains found on connector.");
+          const isChainsStale = yield this.isChainsStale();
+          if (provider.session && isChainsStale) yield provider.disconnect();
+          if (!provider.session || isChainsStale) {
+            const optionalChains = config.chains.filter((chain) => chain.id !== targetChainId).map((optionalChain) => optionalChain.id);
+            yield provider.connect(__spreadValues({
+              optionalChains: [targetChainId, ...optionalChains]
+            }, "pairingTopic" in rest ? { pairingTopic: rest.pairingTopic } : {}));
+            this.setRequestedChainsIds(config.chains.map((x) => x.id));
+          }
+          const accounts = (yield provider.enable()).map((x) => getAddress(x));
+          const currentChainId = yield this.getChainId();
+          if (displayUri) {
+            provider.removeListener("display_uri", displayUri);
+            displayUri = void 0;
+          }
+          if (connect) {
+            provider.removeListener("connect", connect);
+            connect = void 0;
+          }
+          if (!accountsChanged) {
+            accountsChanged = this.onAccountsChanged.bind(this);
+            provider.on("accountsChanged", accountsChanged);
+          }
+          if (!chainChanged) {
+            chainChanged = this.onChainChanged.bind(this);
+            provider.on("chainChanged", chainChanged);
+          }
+          if (!disconnect) {
+            disconnect = this.onDisconnect.bind(this);
+            provider.on("disconnect", disconnect);
+          }
+          if (!sessionDelete) {
+            sessionDelete = this.onSessionDelete.bind(this);
+            provider.on("session_delete", sessionDelete);
+          }
+          return { accounts, chainId: currentChainId };
+        } catch (error) {
+          if (/(user rejected|connection request reset)/i.test(error == null ? void 0 : error.message)) {
+            throw new UserRejectedRequestError(error);
+          }
+          throw error;
+        }
+      });
+    },
+    disconnect() {
+      return __async(this, null, function* () {
+        const provider = yield this.getProvider();
+        try {
+          yield provider == null ? void 0 : provider.disconnect();
+        } catch (error) {
+          if (!/No matching key/i.test(error.message)) throw error;
+        } finally {
+          if (chainChanged) {
+            provider == null ? void 0 : provider.removeListener("chainChanged", chainChanged);
+            chainChanged = void 0;
+          }
+          if (disconnect) {
+            provider == null ? void 0 : provider.removeListener("disconnect", disconnect);
+            disconnect = void 0;
+          }
+          if (!connect) {
+            connect = this.onConnect.bind(this);
+            provider == null ? void 0 : provider.on("connect", connect);
+          }
+          if (accountsChanged) {
+            provider == null ? void 0 : provider.removeListener("accountsChanged", accountsChanged);
+            accountsChanged = void 0;
+          }
+          if (sessionDelete) {
+            provider == null ? void 0 : provider.removeListener("session_delete", sessionDelete);
+            sessionDelete = void 0;
+          }
+          this.setRequestedChainsIds([]);
+        }
+      });
+    },
+    getAccounts() {
+      return __async(this, null, function* () {
+        const provider = yield this.getProvider();
+        return provider.accounts.map((x) => getAddress(x));
+      });
+    },
+    getProvider() {
+      return __async(this, arguments, function* ({ chainId } = {}) {
+        var _a3;
+        function initProvider() {
+          return __async(this, null, function* () {
+            var _a4;
+            const optionalChains = config.chains.map((x) => x.id);
+            if (!optionalChains.length) return;
+            const { EthereumProvider } = yield import("@walletconnect/ethereum-provider");
+            return yield EthereumProvider.init(__spreadProps(__spreadValues({}, parameters), {
+              disableProviderPing: true,
+              optionalChains,
+              projectId: parameters.projectId,
+              rpcMap: Object.fromEntries(
+                config.chains.map((chain) => {
+                  const [url] = extractRpcUrls({
+                    chain,
+                    transports: config.transports
+                  });
+                  return [chain.id, url];
+                })
+              ),
+              showQrModal: (_a4 = parameters.showQrModal) != null ? _a4 : true
+            }));
+          });
+        }
+        if (!provider_) {
+          if (!providerPromise) providerPromise = initProvider();
+          provider_ = yield providerPromise;
+          provider_ == null ? void 0 : provider_.events.setMaxListeners(Number.POSITIVE_INFINITY);
+        }
+        if (chainId) yield (_a3 = this.switchChain) == null ? void 0 : _a3.call(this, { chainId });
+        return provider_;
+      });
+    },
+    getChainId() {
+      return __async(this, null, function* () {
+        const provider = yield this.getProvider();
+        return provider.chainId;
+      });
+    },
+    isAuthorized() {
+      return __async(this, null, function* () {
+        try {
+          const [accounts, provider] = yield Promise.all([this.getAccounts(), this.getProvider()]);
+          if (!accounts.length) return false;
+          const isChainsStale = yield this.isChainsStale();
+          if (isChainsStale && provider.session) {
+            yield provider.disconnect().catch(() => {
+            });
+            return false;
+          }
+          return true;
+        } catch (e) {
+          return false;
+        }
+      });
+    },
+    switchChain(_0) {
+      return __async(this, arguments, function* ({ addEthereumChainParameter, chainId }) {
+        var _a3, _b, _c, _d, _e;
+        const provider = yield this.getProvider();
+        if (!provider) throw new ProviderNotFoundError();
+        const chain = config.chains.find((x) => x.id === chainId);
+        if (!chain) throw new SwitchChainError(new ChainNotConfiguredError());
+        try {
+          yield Promise.all([
+            new Promise((resolve) => {
+              const listener = ({ chainId: currentChainId }) => {
+                if (currentChainId === chainId) {
+                  config.emitter.off("change", listener);
+                  resolve();
+                }
+              };
+              config.emitter.on("change", listener);
+            }),
+            provider.request({
+              method: "wallet_switchEthereumChain",
+              params: [{ chainId: numberToHex(chainId) }]
+            })
+          ]);
+          const requestedChains = yield this.getRequestedChainsIds();
+          this.setRequestedChainsIds([...requestedChains, chainId]);
+          return chain;
+        } catch (err) {
+          const error = err;
+          if (/(user rejected)/i.test(error.message)) throw new UserRejectedRequestError(error);
+          try {
+            let blockExplorerUrls;
+            if (addEthereumChainParameter == null ? void 0 : addEthereumChainParameter.blockExplorerUrls) blockExplorerUrls = addEthereumChainParameter.blockExplorerUrls;
+            else blockExplorerUrls = ((_a3 = chain.blockExplorers) == null ? void 0 : _a3.default.url) ? [(_b = chain.blockExplorers) == null ? void 0 : _b.default.url] : [];
+            let rpcUrls;
+            if ((_c = addEthereumChainParameter == null ? void 0 : addEthereumChainParameter.rpcUrls) == null ? void 0 : _c.length) rpcUrls = addEthereumChainParameter.rpcUrls;
+            else rpcUrls = [...chain.rpcUrls.default.http];
+            const addEthereumChain = {
+              blockExplorerUrls,
+              chainId: numberToHex(chainId),
+              chainName: (_d = addEthereumChainParameter == null ? void 0 : addEthereumChainParameter.chainName) != null ? _d : chain.name,
+              iconUrls: addEthereumChainParameter == null ? void 0 : addEthereumChainParameter.iconUrls,
+              nativeCurrency: (_e = addEthereumChainParameter == null ? void 0 : addEthereumChainParameter.nativeCurrency) != null ? _e : chain.nativeCurrency,
+              rpcUrls
+            };
+            yield provider.request({
+              method: "wallet_addEthereumChain",
+              params: [addEthereumChain]
+            });
+            const requestedChains = yield this.getRequestedChainsIds();
+            this.setRequestedChainsIds([...requestedChains, chainId]);
+            return chain;
+          } catch (error2) {
+            throw new UserRejectedRequestError(error2);
+          }
+        }
+      });
+    },
+    onAccountsChanged(accounts) {
+      if (accounts.length === 0) this.onDisconnect();
+      else
+        config.emitter.emit("change", {
+          accounts: accounts.map((x) => getAddress(x))
+        });
+    },
+    onChainChanged(chain) {
+      const chainId = Number(chain);
+      config.emitter.emit("change", { chainId });
+    },
+    onConnect(connectInfo) {
+      return __async(this, null, function* () {
+        const chainId = Number(connectInfo.chainId);
+        const accounts = yield this.getAccounts();
+        config.emitter.emit("connect", { accounts, chainId });
+      });
+    },
+    onDisconnect(_error) {
+      return __async(this, null, function* () {
+        this.setRequestedChainsIds([]);
+        config.emitter.emit("disconnect");
+        const provider = yield this.getProvider();
+        if (accountsChanged) {
+          provider.removeListener("accountsChanged", accountsChanged);
+          accountsChanged = void 0;
+        }
+        if (chainChanged) {
+          provider.removeListener("chainChanged", chainChanged);
+          chainChanged = void 0;
+        }
+        if (disconnect) {
+          provider.removeListener("disconnect", disconnect);
+          disconnect = void 0;
+        }
+        if (sessionDelete) {
+          provider.removeListener("session_delete", sessionDelete);
+          sessionDelete = void 0;
+        }
+        if (!connect) {
+          connect = this.onConnect.bind(this);
+          provider.on("connect", connect);
+        }
+      });
+    },
+    onDisplayUri(uri) {
+      config.emitter.emit("message", { type: "display_uri", data: uri });
+    },
+    onSessionDelete() {
+      this.onDisconnect();
+    },
+    getNamespaceChainsIds() {
+      var _a3, _b, _c;
+      if (!provider_) return [];
+      const chainIds = (_c = (_b = (_a3 = provider_.session) == null ? void 0 : _a3.namespaces[NAMESPACE]) == null ? void 0 : _b.accounts) == null ? void 0 : _c.map(
+        (account) => Number.parseInt(account.split(":")[1] || "")
+      );
+      return chainIds != null ? chainIds : [];
+    },
+    getRequestedChainsIds() {
+      return __async(this, null, function* () {
+        var _a3, _b;
+        return (_b = yield (_a3 = config.storage) == null ? void 0 : _a3.getItem(this.requestedChainsStorageKey)) != null ? _b : [];
+      });
+    },
+    /**
+     * Checks if the target chains match the chains that were
+     * initially requested by the connector for the WalletConnect session.
+     * If there is a mismatch, this means that the chains on the connector
+     * are considered stale, and need to be revalidated at a later point (via
+     * connection).
+     *
+     * There may be a scenario where a dapp adds a chain to the
+     * connector later on, however, this chain will not have been approved or rejected
+     * by the wallet. In this case, the chain is considered stale.
+     */
+    isChainsStale() {
+      return __async(this, null, function* () {
+        if (!isNewChainsStale) return false;
+        const connectorChains = config.chains.map((x) => x.id);
+        const namespaceChains = this.getNamespaceChainsIds();
+        if (namespaceChains.length && !namespaceChains.some((id) => connectorChains.includes(id))) return false;
+        const requestedChains = yield this.getRequestedChainsIds();
+        return !connectorChains.every((id) => requestedChains.includes(id));
+      });
+    },
+    setRequestedChainsIds(chains) {
+      return __async(this, null, function* () {
+        var _a3;
+        yield (_a3 = config.storage) == null ? void 0 : _a3.setItem(this.requestedChainsStorageKey, chains);
+      });
+    },
+    get requestedChainsStorageKey() {
+      return `${this.id}.requestedChains`;
+    }
+  }));
+}
+export {
+  walletConnect
+};

package/dist/providers/EvmExternalWalletContext.js

@@ -19,11 +19,12 @@ import {
   useBalance
 } from "wagmi";
 import { isEIP6963Connector } from "../utils/isEIP6963Connector.js";
-import { getWalletConnectUri } from "../utils/getWalletConnectUri.js";
+import { emitWalletConnectUri } from "../utils/getWalletConnectUri.js";
 import { normalize } from "viem/ens";
 import { useExternalWalletStore } from "../stores/useStore.js";
 import {
-  defaultEvmExternalWallet
+  defaultEvmExternalWallet,
+  openMobileUrl
 } from "@getpara/react-common";
 import { isMobile } from "@getpara/web-sdk";
 import { etherUnits, formatUnits } from "viem";
@@ -170,11 +171,21 @@ function EvmExternalWalletProvider({
     };
   };
   const signMessage = (_0) => __async(this, [_0], function* ({ message, externalWallet }) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     let signOpts = {};
+    const connector = findConnector(
+      externalWallet ? externalWallet.providerId : getConnectorInfo(connectedConnector).providerId
+    );
+    const signUri = isMobile() && connector.type === "walletConnect" ? (_a = connector.paraDetails) == null ? void 0 : _a.deeplinkUri : void 0;
+    const openApp = () => {
+      if (signUri) {
+        openMobileUrl(signUri);
+      }
+    };
+    openApp();
     if (externalWallet) {
       signOpts = findConnectorAndAccount(externalWallet);
-      yield switchAccount((_a = externalWallet.providerId) != null ? _a : "");
+      yield switchAccount((_b = externalWallet.providerId) != null ? _b : "");
     }
     const address = signOpts.account ? typeof signOpts.account === "string" ? signOpts.account : signOpts.account.getAddress() : wagmiAddress;
     try {
@@ -191,7 +202,7 @@ function EvmExternalWalletProvider({
       console.error("Error signing message:", e.message, e.details);
       if (e.message.includes("Chain not configured") || e.details.includes("Chain not configured")) {
         setVerificationStage("switchingChain");
-        const currentChainParams = getChainParams((_c = (_b = chains[0]) == null ? void 0 : _b.id) != null ? _c : chainId);
+        const currentChainParams = getChainParams((_d = (_c = chains[0]) == null ? void 0 : _c.id) != null ? _d : chainId);
         if (!currentChainParams) {
           return {
             error: `Chain ${chainId} not found in configuration`
@@ -200,14 +211,14 @@ function EvmExternalWalletProvider({
         try {
           yield switchChainAsync({
             addEthereumChainParameter: currentChainParams,
-            chainId: (_e = (_d = chains[0]) == null ? void 0 : _d.id) != null ? _e : chainId
+            chainId: (_f = (_e = chains[0]) == null ? void 0 : _e.id) != null ? _f : chainId
           });
           setVerificationStage("verifying");
           return yield signMessage({ message, externalWallet });
         } catch (error) {
           console.error("Error adding chain:", error);
           return {
-            error: `Error adding chain. You may need to add ${currentChainParams == null ? void 0 : currentChainParams.chainName} support to ${(_h = (_g = (_f = connectedConnector == null ? void 0 : connectedConnector.paraDetails) == null ? void 0 : _f.name) != null ? _g : connectedConnector == null ? void 0 : connectedConnector.name) != null ? _h : "the wallet"} manually.`
+            error: `Error adding chain. You may need to add ${currentChainParams == null ? void 0 : currentChainParams.chainName} support to ${(_i = (_h = (_g = connectedConnector == null ? void 0 : connectedConnector.paraDetails) == null ? void 0 : _g.name) != null ? _h : connectedConnector == null ? void 0 : connectedConnector.name) != null ? _i : "the wallet"} manually.`
           };
         }
       }
@@ -254,6 +265,7 @@ function EvmExternalWalletProvider({
     return { error };
   });
   const login = (_0) => __async(this, [_0], function* ({ address, withFullParaAuth = false, providerId, provider }) {
+    var _a, _b, _c;
     try {
       refetchEnsName();
       refetchEnsAvatar();
@@ -269,7 +281,9 @@ function EvmExternalWalletProvider({
           ensAvatar,
           isConnectionOnly: connectionOnly,
           withVerification: includeWalletVerification
-        }
+        },
+        uri: window == null ? void 0 : window.location.origin,
+        chainId: (_c = (_b = (_a = chains[0]) == null ? void 0 : _a.id) != null ? _b : chainId) == null ? void 0 : _c.toString()
       });
     } catch (err) {
       yield disconnectAsync();
@@ -300,17 +314,20 @@ function EvmExternalWalletProvider({
     updateExternalWalletState({ isConnecting: false });
   });
   const connectBase = (connector) => __async(this, null, function* () {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
+    if (connector.type === "walletConnect" || ((_a = connector.paraDetails) == null ? void 0 : _a.internalId) === "WALLETCONNECT" || ((_b = connector.paraDetails) == null ? void 0 : _b.showQrModal)) {
+      yield emitWalletConnectUri(connector, connector.getUri);
+    }
     const walletChainId = yield connector.getChainId();
     const data = yield connectAsync({
       // If the wallet is already on a supported chain, use that to avoid a chain switch prompt.
-      chainId: (_c = (_a = chains.find(({ id }) => id === walletChainId)) == null ? void 0 : _a.id) != null ? _c : (
+      chainId: (_e = (_c = chains.find(({ id }) => id === walletChainId)) == null ? void 0 : _c.id) != null ? _e : (
         // Fall back to the first chain provided.
-        (_b = chains[0]) == null ? void 0 : _b.id
+        (_d = chains[0]) == null ? void 0 : _d.id
       ),
       connector
     });
-    return (_d = data.accounts) == null ? void 0 : _d[0];
+    return (_f = data.accounts) == null ? void 0 : _f[0];
   });
   const connect = (connector) => __async(this, null, function* () {
     updateExternalWalletState({ isConnecting: true });
@@ -358,12 +375,14 @@ function EvmExternalWalletProvider({
     return yield connect(_connector);
   });
   const findConnector = (providerId) => {
-    return connectorsRef.current.find(
+    var _a;
+    const connector = connectorsRef.current.find(
       (w) => {
-        var _a, _b, _c;
-        return [(_a = w == null ? void 0 : w.paraDetails) == null ? void 0 : _a.name, (_b = w == null ? void 0 : w.paraDetails) == null ? void 0 : _b.id, (_c = w == null ? void 0 : w.paraDetails) == null ? void 0 : _c.internalId].includes(providerId);
+        var _a2, _b, _c;
+        return [(_a2 = w == null ? void 0 : w.paraDetails) == null ? void 0 : _a2.name, (_b = w == null ? void 0 : w.paraDetails) == null ? void 0 : _b.id, (_c = w == null ? void 0 : w.paraDetails) == null ? void 0 : _c.internalId].includes(providerId);
       }
     );
+    return connector ? __spreadProps(__spreadValues({}, connector), { getUri: (_a = connector.paraDetails) == null ? void 0 : _a.getUri }) : void 0;
   };
   const requestInfo = (providerId) => __async(this, null, function* () {
     var _a, _b, _c, _d;
@@ -439,12 +458,11 @@ function EvmExternalWalletProvider({
     return c;
   }).filter((c) => !!c);
   const wallets = dedupedConnectors.map((c) => {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e;
     if (((_a = c.paraDetails) == null ? void 0 : _a.internalId) === "SAFE" && (typeof window === "undefined" || window.parent === window)) {
       return void 0;
     }
     const connector = __spreadValues(__spreadValues({}, c), c.paraDetails);
-    const supportsWalletConnect = connector.type === "walletConnect" || ((_b = connector.paraDetails) == null ? void 0 : _b.internalId) === "WALLETCONNECT" || ((_c = connector.paraDetails) == null ? void 0 : _c.showQrModal);
     const isInjected = !c.paraDetails && eip6963Names.includes(c.name);
     if (isInjected && connectors.some((c2) => {
       var _a2;
@@ -452,17 +470,17 @@ function EvmExternalWalletProvider({
     })) {
       return void 0;
     }
-    return __spreadValues(__spreadProps(__spreadValues({}, connector), {
+    return __spreadProps(__spreadValues({}, connector), {
       // Using name here since that's the only common id across the networks
       id: connector.name,
-      internalId: (_d = connector.internalId) != null ? _d : connector.name,
-      isExtension: (_e = connector.isExtension) != null ? _e : isInjected,
-      installed: (_f = connector.installed) != null ? _f : isInjected,
-      iconUrl: (_g = connector.iconUrl) != null ? _g : connector.icon,
+      internalId: (_b = connector.internalId) != null ? _b : connector.name,
+      isExtension: (_c = connector.isExtension) != null ? _c : isInjected,
+      installed: (_d = connector.installed) != null ? _d : isInjected,
+      iconUrl: (_e = connector.iconUrl) != null ? _e : connector.icon,
       connect: () => connect(connector),
       connectMobile: (manual) => connectMobile(connector, manual),
       type: "EVM"
-    }), supportsWalletConnect && { getQrUri: () => getWalletConnectUri(connector, connector.getUri) });
+    });
   }).filter(Boolean);
   const getConnectorInfo = (connector) => {
     const paraDetails = connector.paraDetails;

package/dist/types/Wallet.d.ts

@@ -1,13 +1,14 @@
 import { Connector, CreateConnectorFn } from 'wagmi';
-import { WalletConnectParameters } from 'wagmi/connectors';
 import { CoinbaseWalletOptions } from '../wallets/connectors/coinbase/coinbase.js';
 import { WalletConnectWalletOptions } from '../wallets/connectors/walletConnect/walletConnect.js';
 import { type WalletMetadata } from '@getpara/react-common';
 import ParaWeb from '@getpara/web-sdk';
+import { WalletConnectParameters } from '../connectors/walletConnect.js';
 export type Wallet = {
     createConnector?: (walletDetails: WalletDetailsParams) => CreateConnectorFn;
     createMobileConnector?: (walletDetails: WalletDetailsParams) => CreateConnectorFn;
     getUri?: (uri: string) => string;
+    deeplinkUri?: string;
 } & WalletMetadata;
 export interface DefaultWalletOptions {
     para?: ParaWeb;

package/dist/utils/getWalletConnectConnector.js

@@ -4,7 +4,7 @@ import {
   __spreadValues
 } from "../chunk-MMUBH76A.js";
 import { createConnector } from "wagmi";
-import { walletConnect } from "wagmi/connectors";
+import { walletConnect } from "../connectors/walletConnect.js";
 const walletConnectInstances = /* @__PURE__ */ new Map();
 const getOrCreateWalletConnectInstance = ({
   projectId,

package/dist/utils/getWalletConnectUri.d.ts

@@ -1,2 +1,2 @@
 import { Connector } from 'wagmi';
-export declare const getWalletConnectUri: (connector: Connector, uriConverter?: (uri: string) => string) => Promise<string>;
+export declare const emitWalletConnectUri: (connector: Connector, uriConverter?: (uri: string) => string) => Promise<void>;

package/dist/utils/getWalletConnectUri.js

@@ -2,24 +2,27 @@
 import {
   __async
 } from "../chunk-MMUBH76A.js";
-const getWalletConnectUri = (connector, uriConverter) => __async(void 0, null, function* () {
+const emitWalletConnectUri = (connector, uriConverter) => __async(void 0, null, function* () {
   var _a, _b;
+  if (typeof window === "undefined") {
+    return;
+  }
   const provider = yield (_b = (_a = connector.getProvider) == null ? void 0 : _a.call(connector)) != null ? _b : void 0;
   if (connector.type === "coinbaseWallet" && (provider == null ? void 0 : provider.qrUrl)) {
-    return provider.qrUrl;
+    window.dispatchEvent(new CustomEvent("PARA_WALLETCONNECT_URI_READY", { detail: provider.qrUrl }));
   }
   if (!provider || typeof provider.once !== "function" && typeof provider.on !== "function") {
     throw new Error("display_uri event not supported for this connector");
   }
   const listen = typeof provider.once === "function" ? provider.once.bind(provider) : provider.on.bind(provider);
-  return new Promise((resolve, reject) => {
-    const cancel = setTimeout(() => reject(new Error("display_uri event not emitted")), 1e4);
-    listen("display_uri", (uri) => {
-      clearTimeout(cancel);
-      resolve(uriConverter ? uriConverter(uri) : uri);
-    });
+  const cancel = setTimeout(() => console.error("display_uri event not emitted"), 1e4);
+  listen("display_uri", (uri) => {
+    clearTimeout(cancel);
+    window.dispatchEvent(
+      new CustomEvent("PARA_WALLETCONNECT_URI_READY", { detail: uriConverter ? uriConverter(uri) : uri })
+    );
   });
 });
 export {
-  getWalletConnectUri
+  emitWalletConnectUri
 };

package/dist/wallets/connectors/metaMask/metaMask.js

@@ -55,11 +55,13 @@ const metaMaskWallet = ({ projectId, walletConnectParameters }) => {
   if (providerMapTarget) {
     metaMaskTarget = providerMapTarget;
   }
+  const deeplinkUri = "metamask://";
+  const baseUri = isAndroid() ? `${deeplinkUri}wc` : isIOS() ? !isTelegram() ? (
+    // currently broken in MetaMask v6.5.0 https://github.com/MetaMask/metamask-mobile/issues/6457
+    `${deeplinkUri}wc`
+  ) : "https://metamask.app.link/wc" : "https://metamask.app.link/wc";
   const getUri = (uri) => {
-    return isAndroid() ? `metamask://wc?uri=${encodeURIComponent(uri)}` : isIOS() ? !isTelegram() ? (
-      // currently broken in MetaMask v6.5.0 https://github.com/MetaMask/metamask-mobile/issues/6457
-      `metamask://wc?uri=${encodeURIComponent(uri)}`
-    ) : `https://metamask.app.link/wc?uri=${encodeURIComponent(uri)}` : `https://metamask.app.link/wc?uri=${encodeURIComponent(uri)}`;
+    return `${baseUri}?uri=${encodeURIComponent(uri)}`;
   };
   return {
     id: "metaMask",
@@ -72,6 +74,7 @@ const metaMaskWallet = ({ projectId, walletConnectParameters }) => {
     isMobile: true,
     downloadUrl: "https://metamask.io/download/",
     getUri,
+    deeplinkUri,
     createConnector: isMetaMaskInjected ? getInjectedConnector({
       target: metaMaskTarget
     }) : getWalletConnectConnector({

package/dist/wallets/connectors/rainbow/rainbow.js

@@ -6,8 +6,13 @@ import { getWalletConnectConnector } from "../../../utils/getWalletConnectConnec
 import { icon } from "./rainbowIcon.js";
 const rainbowWallet = ({ projectId, walletConnectParameters }) => {
   const isRainbowInjected = hasInjectedProvider({ flag: "isRainbow" });
+  const deeplinkUri = "rainbow://";
+  const baseUri = isAndroid() ? `${deeplinkUri}wc` : isIOS() ? !isTelegram() ? (
+    // currently broken in MetaMask v6.5.0 https://github.com/MetaMask/metamask-mobile/issues/6457
+    `${deeplinkUri}wc`
+  ) : "https://rnbwapp.com/wc" : "https://rnbwapp.com/wc";
   const getUri = (uri) => {
-    return isAndroid() ? `rainbow://wc?uri=${encodeURIComponent(uri)}` : isIOS() ? !isTelegram() ? `rainbow://wc?uri=${encodeURIComponent(uri)}` : `https://rnbwapp.com/wc?uri=${encodeURIComponent(uri)}` : `https://rnbwapp.com/wc?uri=${encodeURIComponent(uri)}`;
+    return `${baseUri}?uri=${encodeURIComponent(uri)}`;
   };
   return {
     id: "rainbow",
@@ -20,6 +25,7 @@ const rainbowWallet = ({ projectId, walletConnectParameters }) => {
     isMobile: true,
     downloadUrl: "https://rainbow.me/",
     getUri,
+    deeplinkUri,
     createConnector: isRainbowInjected ? getInjectedConnector({ flag: "isRainbow" }) : getWalletConnectConnector({
       projectId,
       walletConnectParameters

package/dist/wallets/connectors/zerion/zerion.js

@@ -9,8 +9,10 @@ const zerionWallet = ({ projectId, walletConnectParameters }) => {
     namespace: "zerionWallet",
     flag: "isZerion"
   });
+  const deeplinkUri = "zerion://";
+  const baseUri = isTelegram() && isIOS() ? "https://app.zerion.io/wc" : `${deeplinkUri}wc`;
   const getUri = (uri) => {
-    return isTelegram() && isIOS() ? `https://app.zerion.io/wc?uri=${encodeURIComponent(uri)}` : `zerion://wc?uri=${encodeURIComponent(uri)}`;
+    return `${baseUri}?uri=${encodeURIComponent(uri)}`;
   };
   return {
     id: "zerion",
@@ -22,6 +24,7 @@ const zerionWallet = ({ projectId, walletConnectParameters }) => {
     isExtension: true,
     isMobile: true,
     getUri,
+    deeplinkUri,
     downloadUrl: "https://zerion.io/download",
     createConnector: isZerionInjected ? getInjectedConnector({
       namespace: "zerionWallet",

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@getpara/evm-wallet-connectors",
-  "version": "2.0.0-alpha.67",
+  "version": "2.0.0-alpha.68",
   "dependencies": {
     "@coinbase/wallet-sdk": "4.3.0",
-    "@getpara/wagmi-v2-connector": "2.0.0-alpha.67",
-    "@getpara/web-sdk": "2.0.0-alpha.67",
+    "@getpara/wagmi-v2-connector": "2.0.0-alpha.68",
+    "@getpara/web-sdk": "2.0.0-alpha.68",
+    "@walletconnect/ethereum-provider": "^2.22.4",
     "zustand": "^4.5.2",
     "zustand-sync-tabs": "^0.2.2"
   },
   "devDependencies": {
-    "@getpara/react-common": "2.0.0-alpha.67",
+    "@getpara/react-common": "2.0.0-alpha.68",
     "@tanstack/react-query": "^5.74.0",
     "@types/react": "^18.0.31",
     "@types/react-dom": "^18.2.7",
@@ -25,7 +26,7 @@
     "dist",
     "package.json"
   ],
-  "gitHead": "0266cc49e978575fed0b12c9bb0c832651e140eb",
+  "gitHead": "98955203281606201609bb4674f5984acb63d3bf",
   "main": "dist/index.js",
   "peerDependencies": {
     "@farcaster/miniapp-wagmi-connector": "^1.0.0",