@getpara/evm-wallet-connectors 2.0.0-fc.3 → 2.0.0

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.d.ts

@@ -4,7 +4,9 @@ import { TExternalHooks } from './externalHooks.js';
 export type EvmExternalWalletContextType = ExternalWalletContextType & ChainManagement<number> & BalanceManagement & ConnectParaEmbedded & TExternalHooks & {
     username?: string;
     avatar?: string;
-} & FarcasterMiniAppManagement;
+} & FarcasterMiniAppManagement & {
+    verificationStage: 'verifying' | 'switchingChain';
+};
 export declare const EvmExternalWalletContext: import("react").Context<EvmExternalWalletContextType>;
 export type EvmExternalWalletProviderConfig = ExternalWalletProviderConfigBase;
-export declare function EvmExternalWalletProvider({ children, onSwitchWallet, para, walletsWithFullAuth, connectedWallet, includeWalletVerification, connectionOnly, }: EvmExternalWalletProviderConfig & PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+export declare function EvmExternalWalletProvider({ children, onSwitchWallet, para, walletsWithFullAuth, connectedWallet: connectedWalletProp, includeWalletVerification, connectionOnly, }: EvmExternalWalletProviderConfig & PropsWithChildren): import("react/jsx-runtime").JSX.Element;

package/dist/providers/EvmExternalWalletContext.js

@@ -5,7 +5,7 @@ import {
   __spreadValues
 } from "../chunk-MMUBH76A.js";
 import { jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useEffect, useMemo, useRef } from "react";
+import { createContext, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   useAccount,
   useSwitchChain,
@@ -19,22 +19,26 @@ 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";
 import { externalHooks } from "./externalHooks.js";
-const EvmExternalWalletContext = createContext(defaultEvmExternalWallet);
+const EvmExternalWalletContext = createContext(__spreadProps(__spreadValues({}, defaultEvmExternalWallet), {
+  farcasterStatus: void 0,
+  verificationStage: void 0
+}));
 function EvmExternalWalletProvider({
   children,
   onSwitchWallet,
   para,
   walletsWithFullAuth,
-  connectedWallet,
+  connectedWallet: connectedWalletProp,
   includeWalletVerification,
   connectionOnly
 }) {
@@ -50,18 +54,20 @@ function EvmExternalWalletProvider({
   } = useAccount();
   const { switchAccount: wagmiSwitchAccount } = useSwitchAccount();
   const { chains, switchChainAsync } = useSwitchChain();
-  const { disconnectAsync } = useDisconnect();
+  const { disconnectAsync, status: disconnectStatus } = useDisconnect();
   const { data: ensName, refetch: refetchEnsName } = useEnsName({ address: wagmiAddress });
   const { data: ensAvatar, refetch: refetchEnsAvatar } = useEnsAvatar({
     name: normalize(ensName)
   });
   const { signMessageAsync } = useSignMessage();
-  const isLinkingAccount = useRef(false);
+  const connectedWallet = connectedWalletProp ? para.findWallet(connectedWalletProp.id, connectedWalletProp.type) : null;
+  const disconnectTypeRef = useRef();
   const verificationMessage = useRef();
   const { refetch: getBalance } = useBalance({ address: wagmiAddress });
   const connectors = untypedConnectors;
   const connectionsRef = useRef(connections);
   const connectorsRef = useRef(connectors);
+  const [verificationStage, setVerificationStage] = useState("verifying");
   const isLocalConnecting = useExternalWalletStore((state) => state.isConnecting);
   const updateExternalWalletState = useExternalWalletStore((state) => state.updateState);
   const getStoredExternalWallets = () => {
@@ -75,14 +81,18 @@ function EvmExternalWalletProvider({
   const switchAccount = useCallback(
     (connectorName) => {
       var _a;
-      const connector = (_a = connections.find((c) => c.connector.name === connectorName)) == null ? void 0 : _a.connector;
+      const connector = (_a = connectionsRef.current.find((c) => {
+        var _a2;
+        const paraDetails = (_a2 = c.connector) == null ? void 0 : _a2.paraDetails;
+        return [paraDetails == null ? void 0 : paraDetails.name, paraDetails == null ? void 0 : paraDetails.id, paraDetails == null ? void 0 : paraDetails.internalId].includes(connectorName);
+      })) == null ? void 0 : _a.connector;
       if (!connector) {
         console.warn(`connector not found: ${connectorName}`);
         return;
       }
       wagmiSwitchAccount({ connector });
     },
-    [connections, wagmiSwitchAccount]
+    [wagmiSwitchAccount]
   );
   const findConnectorAndAccount = (externalWallet) => {
     var _a;
@@ -90,12 +100,10 @@ function EvmExternalWalletProvider({
     switch (true) {
       case !!externalWallet.providerId:
         {
-          connector = (_a = connectionsRef.current.find(
-            (c) => {
-              var _a2;
-              return ((_a2 = c.connector.paraDetails) == null ? void 0 : _a2.internalId) === externalWallet.providerId;
-            }
-          )) == null ? void 0 : _a.connector;
+          connector = (_a = connectionsRef.current.find((c) => {
+            var _a2;
+            return ((_a2 = c.connector) == null ? void 0 : _a2.name) === externalWallet.providerId;
+          })) == null ? void 0 : _a.connector;
         }
         break;
     }
@@ -111,40 +119,76 @@ function EvmExternalWalletProvider({
   );
   useEffect(() => {
     const storedExternalWallet = getStoredExternalWallets()[wagmiAddress != null ? wagmiAddress : ""];
-    if (!isConnecting && !isReconnecting && !isLocalConnecting && !!wagmiAddress && !storedExternalWallet && (connectedConnector == null ? void 0 : connectedConnector.id) !== "para" && !isLinkingAccount.current && para.isReady && !para.isFarcasterMiniApp) {
+    if ((connectedConnector == null ? void 0 : connectedConnector.id) === "para") {
+      return;
+    }
+    if (!isConnecting && !isReconnecting && !isLocalConnecting && !!wagmiAddress && !storedExternalWallet && !disconnectTypeRef.current && para.isReady && !para.isFarcasterMiniApp) {
       reset();
     }
   }, [isConnected, isLocalConnecting, wagmiAddress, connectedConnector, para.isReady, para.isFarcasterMiniApp]);
   useEffect(() => {
     const storedExternalWallet = Object.values(para.externalWallets || {})[0];
-    if (!isLocalConnecting && isConnected && (storedExternalWallet == null ? void 0 : storedExternalWallet.type) === "EVM" && (storedExternalWallet == null ? void 0 : storedExternalWallet.address) !== wagmiAddress && (connectedConnector == null ? void 0 : connectedConnector.id) !== "para" && !isLinkingAccount.current) {
+    if (!isLocalConnecting && isConnected && (storedExternalWallet == null ? void 0 : storedExternalWallet.type) === "EVM" && (storedExternalWallet == null ? void 0 : storedExternalWallet.address) !== wagmiAddress && (connectedConnector == null ? void 0 : connectedConnector.id) !== "para" && !disconnectTypeRef.current) {
       switchWallet(wagmiAddress);
     }
   }, [isLocalConnecting, wagmiAddress, isConnected]);
   useEffect(() => {
-    if (!isLocalConnecting && !isConnecting && !isReconnecting && connectedWallet && connectedConnector && connectedWallet.type === "EVM" && connectedConnector.name !== connectedWallet.name) {
+    var _a;
+    const connectedConnectorName = (connectedConnector == null ? void 0 : connectedConnector.name) === "WalletConnect" ? (_a = connectedConnector == null ? void 0 : connectedConnector.paraDetails) == null ? void 0 : _a.name : connectedConnector == null ? void 0 : connectedConnector.name;
+    if (!isLocalConnecting && !isConnecting && !isReconnecting && connectedWallet && connectedConnector && connectedWallet.type === "EVM" && connectedConnectorName !== connectedWallet.name) {
       switchAccount(connectedWallet.isExternal ? connectedWallet.name : "Para");
     }
   }, [isLocalConnecting, isConnecting, isReconnecting, connectedWallet, wagmiSwitchAccount]);
   useEffect(() => {
-    if (!isLocalConnecting && !isConnecting && !isReconnecting && !isConnected && !connectedConnector) {
-      if (Object.values(para.wallets).length === 0) {
-        return;
+    const connectPara = () => __async(this, null, function* () {
+      if (!isLocalConnecting && !isConnecting && !isReconnecting && !isConnected && !connectedConnector) {
+        if (Object.values(para.wallets).length === 0 || !(yield para.isFullyLoggedIn())) {
+          return;
+        }
+        connectParaEmbedded();
       }
-      connectParaEmbedded();
-    }
+    });
+    connectPara();
   }, [isLocalConnecting, isConnecting, isReconnecting, isConnected, connectedConnector]);
   const reset = () => __async(this, null, function* () {
     yield disconnectAsync();
     yield para.logout();
   });
+  const getChainParams = (chainId2) => {
+    var _a;
+    const chain = chains.find((c) => c.id === chainId2);
+    if (!chain) return null;
+    return {
+      chainId: `0x${chainId2.toString(16)}`,
+      chainName: chain.name,
+      nativeCurrency: {
+        name: chain.nativeCurrency.name,
+        symbol: chain.nativeCurrency.symbol,
+        decimals: chain.nativeCurrency.decimals
+      },
+      rpcUrls: [chain.rpcUrls.default.http[0]],
+      blockExplorerUrls: ((_a = chain.blockExplorers) == null ? void 0 : _a.default) ? [chain.blockExplorers.default.url] : void 0
+    };
+  };
   const signMessage = (_0) => __async(this, [_0], function* ({ message, externalWallet }) {
+    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((_b = externalWallet.providerId) != null ? _b : "");
     }
+    const address = signOpts.account ? typeof signOpts.account === "string" ? signOpts.account : signOpts.account.getAddress() : wagmiAddress;
     try {
-      const address = signOpts.account ? typeof signOpts.account === "string" ? signOpts.account : signOpts.account.getAddress() : wagmiAddress;
       const signature = yield signMessageAsync(__spreadValues({
         message,
         account: address
@@ -155,6 +199,29 @@ function EvmExternalWalletProvider({
       };
     } catch (e) {
       console.error("Error signing message:", e);
+      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((_d = (_c = chains[0]) == null ? void 0 : _c.id) != null ? _d : chainId);
+        if (!currentChainParams) {
+          return {
+            error: `Chain ${chainId} not found in configuration`
+          };
+        }
+        try {
+          yield switchChainAsync({
+            addEthereumChainParameter: currentChainParams,
+            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 ${(_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.`
+          };
+        }
+      }
       switch (e.name) {
         case "UserRejectedRequestError": {
           return { error: "Signature request rejected" };
@@ -166,6 +233,7 @@ function EvmExternalWalletProvider({
     }
   });
   const signVerificationMessage = () => __async(this, null, function* () {
+    setVerificationStage("verifying");
     const signature = yield signMessage({ message: verificationMessage.current });
     return signature;
   });
@@ -197,11 +265,13 @@ function EvmExternalWalletProvider({
     return { error };
   });
   const login = (_0) => __async(this, [_0], function* ({ address, withFullParaAuth = false, providerId, provider }) {
+    var _a, _b, _c;
     try {
       refetchEnsName();
       refetchEnsAvatar();
       return yield para.loginExternalWallet({
         externalWallet: {
+          partnerId: para.partnerId,
           address,
           type: "EVM",
           provider,
@@ -211,9 +281,11 @@ 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) {
+    } catch (e) {
       yield disconnectAsync();
       yield para.logout();
       throw "Error logging you in. Please try again.";
@@ -242,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 });
@@ -268,7 +343,7 @@ function EvmExternalWalletProvider({
           authState = yield login(__spreadValues({
             address
           }, loginInfo));
-          verificationMessage.current = authState.stage === "verify" ? authState.signatureVerificationMessage : void 0;
+          verificationMessage.current = authState.signatureVerificationMessage;
         } catch (err) {
           address = void 0;
           error = err;
@@ -299,41 +374,59 @@ function EvmExternalWalletProvider({
     const _connector = connector.walletConnectModalConnector && _isMobile ? connector.walletConnectModalConnector : connector;
     return yield connect(_connector);
   });
+  const findConnector = (providerId) => {
+    var _a;
+    const connector = connectorsRef.current.find(
+      (w) => {
+        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;
-    const connector = connectors.find((c) => {
-      var _a2;
-      return ((_a2 = c.paraDetails) == null ? void 0 : _a2.internalId) === providerId;
-    });
-    if (connector.isAuthorized) isLinkingAccount.current = true;
+    var _a, _b, _c, _d;
+    const connector = findConnector(providerId);
+    disconnectTypeRef.current = "ACCOUNT_LINKING";
     try {
-      const address = yield connectBase(connector);
+      let address;
+      if (connector.connected && ((_a = connector.accounts) == null ? void 0 : _a[0])) {
+        address = connector.accounts[0];
+      } else {
+        address = yield connectBase(connector);
+      }
+      const providerId2 = (_c = (_b = wallets.find((w) => {
+        var _a2, _b2;
+        return (w == null ? void 0 : w.name) === ((_b2 = (_a2 = connector == null ? void 0 : connector.paraDetails) == null ? void 0 : _a2.name) != null ? _b2 : "");
+      })) == null ? void 0 : _b.name) != null ? _c : connector == null ? void 0 : connector.name;
       return {
+        partnerId: para.partnerId,
         address,
         type: "EVM",
-        providerId: (_a = connector.paraDetails) == null ? void 0 : _a.internalId,
-        provider: connector.name,
+        providerId: providerId2,
+        provider: providerId2,
         ensName,
         ensAvatar
       };
     } catch (e) {
-      throw new Error((_b = e == null ? void 0 : e.message) != null ? _b : e);
+      throw new Error((_d = e == null ? void 0 : e.message) != null ? _d : e);
     }
   });
-  const disconnectBase = (providerId) => __async(this, null, function* () {
+  const disconnectBase = (_0, ..._1) => __async(this, [_0, ..._1], function* (providerId, { disconnectType } = {}) {
     var _a;
     if (!providerId) {
       throw new Error("Provider ID is required to disconnect");
     }
-    const connector = connectors.find((c) => {
-      var _a2;
-      return ((_a2 = c.paraDetails) == null ? void 0 : _a2.internalId) === providerId;
-    });
-    isLinkingAccount.current = true;
+    const connector = findConnector(providerId);
+    if (disconnectType) {
+      disconnectTypeRef.current = disconnectType;
+    }
     try {
-      yield connector.disconnect();
+      yield connector == null ? void 0 : connector.disconnect();
     } catch (e) {
       throw new Error((_a = e == null ? void 0 : e.message) != null ? _a : e);
+    } finally {
+      disconnectTypeRef.current = void 0;
     }
   });
   const nonEip6963ConnectorsByRdns = {};
@@ -346,45 +439,56 @@ function EvmExternalWalletProvider({
       }
     }
   });
-  const eip6963ids = connectors.filter((c) => isEIP6963Connector(c)).map((c) => c.id);
+  const eip6963Names = connectors.filter((c) => isEIP6963Connector(c)).map((c) => c.name);
   const dedupedConnectors = connectors.map((c) => {
-    var _a, _b, _c;
+    var _a, _b;
     if ((_a = c.paraDetails) == null ? void 0 : _a.isWalletConnectModalConnector) {
       return;
     }
-    if (!isEIP6963Connector(c) && eip6963ids.includes((_b = c.paraDetails) == null ? void 0 : _b.rdns)) {
+    if (!isEIP6963Connector(c) && eip6963Names.includes(c.name)) {
       return;
     }
     if (isEIP6963Connector(c)) {
       const paraMetadata = nonEip6963ConnectorsByRdns[c.id];
       return __spreadProps(__spreadValues({}, c), { paraDetails: paraMetadata });
     }
-    if (((_c = c.paraDetails) == null ? void 0 : _c.id) === "WALLETCONNECT" && walletConnectModalConnector) {
+    if (((_b = c.paraDetails) == null ? void 0 : _b.internalId) === "WALLETCONNECT" && walletConnectModalConnector) {
       return __spreadProps(__spreadValues({}, c), { walletConnectModalConnector });
     }
     return c;
   }).filter((c) => !!c);
   const wallets = dedupedConnectors.map((c) => {
-    var _a, _b, _c;
+    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);
-    return __spreadValues(__spreadProps(__spreadValues({}, connector), {
+    const isInjected = !c.paraDetails && eip6963Names.includes(c.name);
+    if (isInjected && connectors.some((c2) => {
+      var _a2;
+      return ((_a2 = c2.paraDetails) == null ? void 0 : _a2.rdns) === c2.id;
+    })) {
+      return void 0;
+    }
+    return __spreadProps(__spreadValues({}, connector), {
+      // Using name here since that's the only common id across the networks
+      id: connector.name,
+      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;
-    const providerId = paraDetails == null ? void 0 : paraDetails.internalId;
-    const withFullParaAuth = walletsWithFullAuth == null ? void 0 : walletsWithFullAuth.includes(providerId);
+    const withFullParaAuth = walletsWithFullAuth === "ALL" || (walletsWithFullAuth == null ? void 0 : walletsWithFullAuth.includes(paraDetails == null ? void 0 : paraDetails.internalId));
     return {
       type: "EVM",
-      providerId,
-      provider: paraDetails == null ? void 0 : paraDetails.name,
+      providerId: connector.name,
+      provider: connector.name,
       withFullParaAuth
     };
   };
@@ -404,10 +508,10 @@ function EvmExternalWalletProvider({
       }
     );
     if (!connection) {
-      return void 0;
+      return { isPresent: false };
     }
     const address = (_a = connection == null ? void 0 : connection.accounts) == null ? void 0 : _a[0];
-    return address ? { isConnected: true, address } : { isConnected: false };
+    return address ? { isPresent: true, isConnected: true, address } : { isPresent: true, isConnected: false };
   }, [connections]);
   const connectParaEmbedded = useCallback(() => __async(this, null, function* () {
     const paraConnectorInstance = connectors.find((c) => c.id === "para");
@@ -438,6 +542,7 @@ function EvmExternalWalletProvider({
         username,
         avatar: ensAvatar,
         disconnect: disconnectAsync,
+        disconnectStatus,
         switchChain,
         connectParaEmbedded,
         signMessage,
@@ -445,7 +550,8 @@ function EvmExternalWalletProvider({
         getWalletBalance,
         requestInfo,
         disconnectBase,
-        farcasterStatus
+        farcasterStatus,
+        verificationStage
       }, externalHooks),
       children
     }

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/utils/isEIP6963Connector.js

@@ -2,7 +2,7 @@
 import "../chunk-MMUBH76A.js";
 const isEIP6963Connector = (wallet) => {
   var _a;
-  return !!(!wallet.isRainbowKitConnector && ((_a = wallet.icon) == null ? void 0 : _a.startsWith("data:image")) && wallet.uid && wallet.name);
+  return !!(!wallet.isRainbowKitConnector && ((_a = wallet.icon) == null ? void 0 : _a.trim().startsWith("data:image")) && wallet.uid && wallet.name);
 };
 export {
   isEIP6963Connector

package/dist/wallets/connectors/backpack/backpack.js

@@ -13,7 +13,7 @@ const backpackWallet = ({ projectId, walletConnectParameters }) => {
     id: "backpack",
     internalId: "BACKPACK",
     name: "Backpack",
-    rdns: "app.backpack.mobile",
+    rdns: "app.backpack",
     iconUrl: icon,
     installed: isBackpackInjected,
     isExtension: true,

package/dist/wallets/connectors/farcaster/farcaster.js

@@ -13,7 +13,7 @@ const farcasterWallet = ({ para, createFarcasterConnector }) => {
     iconUrl: icon,
     installed: (para == null ? void 0 : para.isReady) && (para == null ? void 0 : para.isFarcasterMiniApp),
     isExtension: true,
-    downloadUrl: "https://warpcast.xyz/",
+    downloadUrl: "https://farcaster.xyz/",
     createConnector: (walletDetails) => createConnector((config) => __spreadValues(__spreadValues({}, createFarcasterConnector()(config)), walletDetails))
   };
 };

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,20 +1,21 @@
 {
   "name": "@getpara/evm-wallet-connectors",
-  "version": "2.0.0-fc.3",
+  "version": "2.0.0",
   "dependencies": {
     "@coinbase/wallet-sdk": "4.3.0",
-    "@getpara/wagmi-v2-connector": "2.0.0-fc.3",
-    "@getpara/web-sdk": "2.0.0-fc.3",
+    "@getpara/wagmi-v2-connector": "2.0.0",
+    "@getpara/web-sdk": "2.0.0",
+    "@walletconnect/ethereum-provider": "2.23.0",
     "zustand": "^4.5.2",
     "zustand-sync-tabs": "^0.2.2"
   },
   "devDependencies": {
-    "@getpara/react-common": "2.0.0-fc.3",
+    "@getpara/react-common": "2.0.0",
     "@tanstack/react-query": "^5.74.0",
     "@types/react": "^18.0.31",
     "@types/react-dom": "^18.2.7",
     "typescript": "^5.8.3",
-    "viem": "^2.24.2",
+    "viem": "^2.38.5",
     "wagmi": "^2.14.16"
   },
   "exports": {
@@ -25,7 +26,7 @@
     "dist",
     "package.json"
   ],
-  "gitHead": "5ba068331384bed874c0da0d3d0e1fed6bf03ff9",
+  "gitHead": "a64b6aa9b3c481a2d955022f621e495fb55e549e",
   "main": "dist/index.js",
   "peerDependencies": {
     "@farcaster/miniapp-wagmi-connector": "^1.0.0",