@getpara/evm-wallet-connectors 2.0.0-alpha.3 → 2.0.0-alpha.6

package/dist/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/providers/EvmExternalWalletContext.d.ts

@@ -7,6 +7,7 @@ export type EvmExternalWalletContextType = {
     chainId?: number;
     username?: string;
     avatar?: string;
+    balance?: string;
     disconnect: () => Promise<void>;
     switchChain: (chainId: number) => Promise<{
         error?: string[];
@@ -24,6 +25,7 @@ export type EvmExternalWalletContextType = {
         signature?: string;
         error?: string;
     }>;
+    getWalletBalance: () => Promise<string | undefined>;
 };
 export declare const EvmExternalWalletContext: import("react").Context<EvmExternalWalletContextType>;
 export type EvmExternalWalletProviderConfig = {

package/dist/providers/EvmExternalWalletContext.js

@@ -0,0 +1,369 @@
+"use client";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useEffect, useMemo, useRef } from "react";
+import {
+  useAccount,
+  useSwitchChain,
+  useConnect,
+  useDisconnect,
+  useEnsName,
+  useEnsAvatar,
+  useSignMessage,
+  useSwitchAccount,
+  useConnections,
+  useBalance
+} from "wagmi";
+import { isEIP6963Connector } from "../utils/isEIP6963Connector.js";
+import { getWalletConnectUri } from "../utils/getWalletConnectUri.js";
+import { normalize } from "viem/ens";
+import { useExternalWalletStore } from "../stores/useStore.js";
+import { isMobile } from "@getpara/web-sdk";
+import { etherUnits, formatUnits } from "viem";
+const defaultEvmExternalWallet = {
+  wallets: [],
+  chains: [],
+  chainId: void 0,
+  username: void 0,
+  avatar: void 0,
+  balance: void 0,
+  disconnect: () => Promise.resolve(),
+  switchChain: () => Promise.resolve({}),
+  connectParaEmbedded: () => Promise.resolve({}),
+  signMessage: () => Promise.resolve({}),
+  signVerificationMessage: () => Promise.resolve({}),
+  getWalletBalance: () => Promise.resolve(void 0)
+};
+const EvmExternalWalletContext = createContext(defaultEvmExternalWallet);
+function EvmExternalWalletProvider({
+  children,
+  onSwitchWallet,
+  para,
+  walletsWithFullAuth,
+  connectedWallet
+}) {
+  const { connectAsync, connectors: untypedConnectors } = useConnect();
+  const connections = useConnections();
+  const {
+    address: wagmiAddress,
+    isConnecting,
+    isReconnecting,
+    chainId,
+    connector: connectedConnector,
+    isConnected
+  } = useAccount();
+  const { switchAccount: wagmiSwitchAccount } = useSwitchAccount();
+  const { chains, switchChainAsync } = useSwitchChain();
+  const { disconnectAsync } = useDisconnect();
+  const { data: ensName, refetch: refetchEnsName } = useEnsName({ address: wagmiAddress });
+  const { data: ensAvatar, refetch: refetchEnsAvatar } = useEnsAvatar({
+    name: normalize(ensName)
+  });
+  const { signMessageAsync } = useSignMessage();
+  const verificationMessage = useRef();
+  const { refetch: getBalance } = useBalance({ address: wagmiAddress });
+  const isLocalConnecting = useExternalWalletStore((state) => state.isConnecting);
+  const updateExternalWalletState = useExternalWalletStore((state) => state.updateState);
+  const getStoredExternalWallets = () => {
+    const storedExternalWalletsString = localStorage.getItem("@CAPSULE/externalWallets");
+    let storedExternalWallets = {};
+    if (storedExternalWalletsString) {
+      storedExternalWallets = JSON.parse(storedExternalWalletsString);
+    }
+    return storedExternalWallets;
+  };
+  const switchAccount = useCallback(
+    (connectorName) => {
+      var _a;
+      const connector = (_a = connections.find((c) => c.connector.name === connectorName)) == null ? void 0 : _a.connector;
+      if (!connector) {
+        console.warn(`connector not found: ${connectorName}`);
+        return;
+      }
+      wagmiSwitchAccount({ connector });
+    },
+    [connections, wagmiSwitchAccount]
+  );
+  const getWalletBalance = useCallback(
+    // Format from wei to eth
+    () => __async(this, null, function* () {
+      const { data: balance } = yield getBalance();
+      return balance ? formatUnits(balance.value, etherUnits.wei) : void 0;
+    }),
+    [chainId, wagmiAddress, getBalance]
+  );
+  useEffect(() => {
+    const storedExternalWallet = getStoredExternalWallets()[wagmiAddress != null ? wagmiAddress : ""];
+    if (!isConnecting && !isReconnecting && !isLocalConnecting && !!wagmiAddress && !storedExternalWallet && (connectedConnector == null ? void 0 : connectedConnector.id) !== "para") {
+      reset();
+    }
+  }, [isConnecting, isReconnecting, isLocalConnecting, wagmiAddress, connectedConnector]);
+  useEffect(() => {
+    const storedExternalWallet = Object.values(para.externalWallets || {})[0];
+    if (!isLocalConnecting && !isConnecting && !isReconnecting && (storedExternalWallet == null ? void 0 : storedExternalWallet.type) === "EVM" && (storedExternalWallet == null ? void 0 : storedExternalWallet.address) !== wagmiAddress && (connectedConnector == null ? void 0 : connectedConnector.id) !== "para") {
+      switchWallet(wagmiAddress);
+    }
+  }, [isLocalConnecting, wagmiAddress, isReconnecting, isConnecting]);
+  useEffect(() => {
+    if (!isLocalConnecting && !isConnecting && !isReconnecting && connectedWallet && connectedConnector && connectedWallet.type === "EVM" && connectedConnector.name !== 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;
+      }
+      connectParaEmbedded();
+    }
+  }, [isLocalConnecting, isConnecting, isReconnecting, isConnected, connectedConnector]);
+  const connectors = untypedConnectors;
+  const reset = () => __async(this, null, function* () {
+    yield disconnectAsync();
+    yield para.logout();
+  });
+  const signMessage = (message) => __async(this, null, function* () {
+    try {
+      const signature = yield signMessageAsync({
+        message,
+        account: wagmiAddress
+      });
+      return {
+        address: wagmiAddress,
+        signature
+      };
+    } catch (e) {
+      switch (e.name) {
+        case "UserRejectedRequestError": {
+          return { error: "Signature request rejected" };
+        }
+        default: {
+          return { error: "An unknown error occurred" };
+        }
+      }
+    }
+  });
+  const signVerificationMessage = () => __async(this, null, function* () {
+    const signature = yield signMessage(verificationMessage.current);
+    return signature;
+  });
+  const switchChain = (chainId2) => __async(this, null, function* () {
+    var _a, _b, _c;
+    let error;
+    try {
+      yield switchChainAsync({ chainId: chainId2 });
+    } catch (e) {
+      if (e.details.includes("Missing or invalid.")) {
+        const chain = chains.find((c) => c.id === chainId2);
+        error = [
+          "Network not supported.",
+          `You may need to add ${chain == null ? void 0 : chain.name} support to ${(_c = (_b = (_a = connectedConnector == null ? void 0 : connectedConnector.paraDetails) == null ? void 0 : _a.name) != null ? _b : connectedConnector == null ? void 0 : connectedConnector.name) != null ? _c : "the wallet"} manually.`
+        ];
+      } else {
+        switch (e.name) {
+          case "UserRejectedRequestError": {
+            error = ["Change request rejected"];
+            break;
+          }
+          default: {
+            error = ["An unknown error occurred"];
+            break;
+          }
+        }
+      }
+    }
+    return { error };
+  });
+  const login = (_0) => __async(this, [_0], function* ({
+    address,
+    walletId,
+    connectorName
+  }) {
+    var _a;
+    try {
+      refetchEnsName();
+      refetchEnsAvatar();
+      return yield para.loginExternalWallet({
+        externalWallet: {
+          address,
+          type: "EVM",
+          provider: connectorName,
+          withFullParaAuth: walletsWithFullAuth == null ? void 0 : walletsWithFullAuth.includes((_a = walletId == null ? void 0 : walletId.toUpperCase()) != null ? _a : ""),
+          ensName,
+          ensAvatar
+        }
+      });
+    } catch (err) {
+      yield disconnectAsync();
+      yield para.logout();
+      throw "Error logging you in. Please try again.";
+    }
+  });
+  const switchWallet = (address) => __async(this, null, function* () {
+    var _a;
+    updateExternalWalletState({ isConnecting: true });
+    let error;
+    if (!address) {
+      yield para.logout();
+    } else {
+      if (para.isExternalWalletAuth) {
+        yield reset();
+      } else {
+        try {
+          yield login({
+            address,
+            connectorName: connectedConnector == null ? void 0 : connectedConnector.name,
+            walletId: (_a = getParaDetails(connectedConnector.id)) == null ? void 0 : _a.id
+          });
+        } catch (err) {
+          error = err;
+        }
+      }
+    }
+    onSwitchWallet == null ? void 0 : onSwitchWallet({ address, error });
+    updateExternalWalletState({ isConnecting: false });
+  });
+  const connect = (connector) => __async(this, null, function* () {
+    var _a, _b, _c, _d;
+    updateExternalWalletState({ isConnecting: true });
+    yield disconnectAsync();
+    const walletChainId = yield connector.getChainId();
+    let authState;
+    let address;
+    let error;
+    try {
+      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 : (
+          // Fall back to the first chain provided.
+          (_b = chains[0]) == null ? void 0 : _b.id
+        ),
+        connector
+      });
+      address = (_d = data.accounts) == null ? void 0 : _d[0];
+      if (address) {
+        try {
+          authState = yield login({ address, connectorName: connector.name, walletId: connector.paraDetails.id });
+          verificationMessage.current = authState.stage === "verify" ? authState.signatureVerificationMessage : void 0;
+        } catch (err) {
+          address = void 0;
+          error = err;
+        }
+      }
+    } catch (e) {
+      switch (e.name) {
+        case "UserRejectedRequestError": {
+          error = "Connection request rejected";
+          break;
+        }
+        case "ResourceUnavailableRpcError": {
+          `${connector.name} not detected`;
+          break;
+        }
+        default: {
+          error = "An unknown error occurred";
+          break;
+        }
+      }
+    }
+    updateExternalWalletState({ isConnecting: false });
+    return { address, authState, error };
+  });
+  const connectMobile = (connector, isManualWalletConnect) => __async(this, null, function* () {
+    const _isMobile = isManualWalletConnect !== void 0 ? isManualWalletConnect : isMobile();
+    const _connector = connector.walletConnectModalConnector && _isMobile ? connector.walletConnectModalConnector : connector;
+    return yield connect(_connector);
+  });
+  const getQrUri = (connector) => () => {
+    var _a;
+    return getWalletConnectUri(connector, (_a = connector.paraDetails) == null ? void 0 : _a.getUri);
+  };
+  const nonEip6963ConnectorsByRdns = {};
+  let walletConnectModalConnector;
+  connectors.filter((c) => !isEIP6963Connector(c)).forEach((c) => {
+    if (c.paraDetails) {
+      nonEip6963ConnectorsByRdns[c.paraDetails.rdns] = c.paraDetails;
+      if (c.paraDetails.isWalletConnectModalConnector) {
+        walletConnectModalConnector = c;
+      }
+    }
+  });
+  const eip6963ids = connectors.filter((c) => isEIP6963Connector(c)).map((c) => c.id);
+  const dedupedConnectors = connectors.map((c) => {
+    var _a, _b, _c;
+    if ((_a = c.paraDetails) == null ? void 0 : _a.isWalletConnectModalConnector) {
+      return;
+    }
+    if (!isEIP6963Connector(c) && eip6963ids.includes((_b = c.paraDetails) == null ? void 0 : _b.rdns)) {
+      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) {
+      return __spreadProps(__spreadValues({}, c), { walletConnectModalConnector });
+    }
+    return c;
+  }).filter((c) => !!c);
+  const wallets = dedupedConnectors.map((c) => {
+    const connector = __spreadValues(__spreadValues({}, c), c.paraDetails);
+    return __spreadProps(__spreadValues({}, connector), {
+      connect: () => connect(connector),
+      connectMobile: (isManualWalletConnect) => connectMobile(connector, isManualWalletConnect),
+      type: "EVM",
+      getQrUri: getQrUri(connector)
+    });
+  });
+  const getParaDetails = (id) => {
+    var _a;
+    return (_a = connectors.find((w) => w.id === id)) == null ? void 0 : _a.paraDetails;
+  };
+  const formattedChains = chains.map((c) => {
+    return {
+      id: c.id,
+      name: c.name
+    };
+  });
+  const username = useMemo(() => ensName != null ? ensName : wagmiAddress, [ensName, wagmiAddress]);
+  const connectParaEmbedded = useCallback(() => __async(this, null, function* () {
+    const paraConnectorInstance = connectors.find((c) => c.id === "para");
+    if (!paraConnectorInstance) {
+      return { error: "No para connector instance" };
+    }
+    try {
+      const result = yield connectAsync({ connector: paraConnectorInstance });
+      return { result };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : "Unknown error";
+      return { error };
+    }
+  }), [connectors]);
+  return /* @__PURE__ */ jsx(
+    EvmExternalWalletContext.Provider,
+    {
+      value: {
+        wallets,
+        chains: formattedChains,
+        chainId,
+        username,
+        avatar: ensAvatar,
+        disconnect: disconnectAsync,
+        switchChain,
+        connectParaEmbedded,
+        signMessage,
+        signVerificationMessage,
+        getWalletBalance
+      },
+      children
+    }
+  );
+}
+export {
+  EvmExternalWalletContext,
+  EvmExternalWalletProvider
+};

package/dist/providers/ParaEvmContext.js

@@ -0,0 +1,81 @@
+"use client";
+import {
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { createConfig, WagmiProvider } from "wagmi";
+import { connectorsForWallets } from "../wallets/connectorsForWallets.js";
+import { http } from "viem";
+import { computeWalletConnectMetaData } from "../utils/computeWalletConnectMetaData.js";
+import { EvmExternalWalletProvider } from "./EvmExternalWalletContext.js";
+import { paraConnector } from "@getpara/wagmi-v2-connector";
+const createDefaultTransports = (chains) => {
+  const transportsObject = chains.reduce((acc, chain) => {
+    const key = chain.id;
+    acc[key] = http();
+    return acc;
+  }, {});
+  return transportsObject;
+};
+function ParaEvmProvider({
+  children,
+  internalConfig,
+  config: _config,
+  wagmiProviderProps
+}) {
+  const para = internalConfig.para;
+  const _a = _config, {
+    projectId,
+    appName,
+    appDescription,
+    appIcon,
+    appUrl,
+    wallets,
+    chains,
+    transports,
+    paraConnectorOptions
+  } = _a, wagmiConfigParams = __objRest(_a, [
+    "projectId",
+    "appName",
+    "appDescription",
+    "appIcon",
+    "appUrl",
+    "wallets",
+    "chains",
+    "transports",
+    "paraConnectorOptions"
+  ]);
+  const paraConnectorInstance = useMemo(() => {
+    return paraConnector({
+      para,
+      chains: [...chains],
+      disableModal: true,
+      appName,
+      options: paraConnectorOptions != null ? paraConnectorOptions : {}
+    });
+  }, [para]);
+  const config = useMemo(() => {
+    const wcMetadata = computeWalletConnectMetaData({ appName, appDescription, appUrl, appIcon });
+    const baseConnectors = connectorsForWallets(wallets, {
+      projectId,
+      appName,
+      appDescription,
+      appUrl,
+      appIcon,
+      walletConnectParameters: { metadata: wcMetadata }
+    });
+    const allConnectors = [...baseConnectors, paraConnectorInstance];
+    return createConfig(__spreadProps(__spreadValues({}, wagmiConfigParams), {
+      chains,
+      transports: transports || createDefaultTransports(chains),
+      connectors: allConnectors
+    }));
+  }, [wallets, paraConnectorInstance]);
+  return /* @__PURE__ */ jsx(WagmiProvider, __spreadProps(__spreadValues({ config }, wagmiProviderProps), { children: /* @__PURE__ */ jsx(EvmExternalWalletProvider, __spreadProps(__spreadValues({}, internalConfig), { children })) }));
+}
+export {
+  ParaEvmProvider
+};

package/dist/stores/useStore.js

@@ -0,0 +1,22 @@
+"use client";
+import {
+  __spreadValues
+} from "../chunk-MMUBH76A.js";
+import { create } from "zustand";
+import { syncTabs } from "zustand-sync-tabs";
+const useExternalWalletStore = create(
+  syncTabs(
+    (set) => ({
+      isConnecting: false,
+      updateState: (state) => {
+        set(__spreadValues({}, state));
+      }
+    }),
+    {
+      name: "para-evm-external-wallet-state"
+    }
+  )
+);
+export {
+  useExternalWalletStore
+};

package/dist/types/Wallet.js

@@ -0,0 +1 @@
+"use client";

package/dist/types/utils.d.ts

@@ -9,7 +9,7 @@ export type Mutable<type extends object> = {
 };
 /** Strict version of built-in Omit type */
 export type Omit<type, keys extends keyof type> = Pick<type, Exclude<keyof type, keys>>;
-export type WalletProviderFlags = 'isApexWallet' | 'isAvalanche' | 'isBackpack' | 'isBifrost' | 'isBitKeep' | 'isBitski' | 'isBlockWallet' | 'isBraveWallet' | 'isCoinbaseWallet' | 'isDawn' | 'isEnkrypt' | 'isExodus' | 'isFrame' | 'isFrontier' | 'isGamestop' | 'isHyperPay' | 'isImToken' | 'isKuCoinWallet' | 'isMathWallet' | 'isMetaMask' | 'isNestWallet' | 'isOkxWallet' | 'isOKExWallet' | 'isOneInchAndroidWallet' | 'isOneInchIOSWallet' | 'isOpera' | 'isPhantom' | 'isPortal' | 'isRabby' | 'isRainbow' | 'isStatus' | 'isTally' | 'isTokenPocket' | 'isTokenary' | 'isTrust' | 'isTrustWallet' | 'isXDEFI' | 'isZerion' | 'isTalisman' | 'isZeal' | 'isCoin98' | 'isMEWwallet' | 'isSafeheron' | 'isSafePal' | '__seif';
+export type WalletProviderFlags = 'isApexWallet' | 'isAvalanche' | 'isBackpack' | 'isBifrost' | 'isBitKeep' | 'isBitski' | 'isBlockWallet' | 'isBraveWallet' | 'isCoinbaseWallet' | 'isDawn' | 'isEnkrypt' | 'isExodus' | 'isFrame' | 'isFrontier' | 'isGamestop' | 'isHyperPay' | 'isImToken' | 'isKuCoinWallet' | 'isMathWallet' | 'isMetaMask' | 'isNestWallet' | 'isOkxWallet' | 'isOKExWallet' | 'isOneInchAndroidWallet' | 'isOneInchIOSWallet' | 'isOpera' | 'isPhantom' | 'isPortal' | 'isRabby' | 'isRainbow' | 'isSafe' | 'isStatus' | 'isTally' | 'isTokenPocket' | 'isTokenary' | 'isTrust' | 'isTrustWallet' | 'isXDEFI' | 'isZerion' | 'isTalisman' | 'isZeal' | 'isCoin98' | 'isMEWwallet' | 'isSafeheron' | 'isSafePal' | '__seif';
 export type WalletProvider = Evaluate<EIP1193Provider & {
     [key in WalletProviderFlags]?: true | undefined;
 } & {

package/dist/types/utils.js

@@ -0,0 +1 @@
+"use client";

package/dist/utils/computeWalletConnectMetaData.js

@@ -0,0 +1,18 @@
+"use client";
+import "../chunk-MMUBH76A.js";
+const computeWalletConnectMetaData = ({
+  appName,
+  appDescription,
+  appUrl,
+  appIcon
+}) => {
+  return {
+    name: appName,
+    description: appDescription != null ? appDescription : appName,
+    url: appUrl != null ? appUrl : typeof window !== "undefined" ? window.location.href : "",
+    icons: [...appIcon ? [appIcon] : []]
+  };
+};
+export {
+  computeWalletConnectMetaData
+};

package/dist/utils/getInjectedConnector.js

@@ -0,0 +1,69 @@
+"use client";
+import {
+  __spreadValues
+} from "../chunk-MMUBH76A.js";
+import { createConnector } from "wagmi";
+import { injected } from "wagmi/connectors";
+function getExplicitInjectedProvider(flag) {
+  const _window = typeof window !== "undefined" ? window : void 0;
+  if (typeof _window === "undefined" || typeof _window.ethereum === "undefined") return;
+  const providers = _window.ethereum.providers;
+  return providers ? providers.find((provider) => provider[flag]) : _window.ethereum[flag] ? _window.ethereum : void 0;
+}
+function getWindowProviderNamespace(namespace) {
+  const providerSearch = (provider, namespace2) => {
+    const [property, ...path] = namespace2.split(".");
+    const _provider = provider[property];
+    if (_provider) {
+      if (path.length === 0) return _provider;
+      return providerSearch(_provider, path.join("."));
+    }
+  };
+  if (typeof window !== "undefined") return providerSearch(window, namespace);
+}
+function hasInjectedProvider({ flag, namespace }) {
+  if (namespace && typeof getWindowProviderNamespace(namespace) !== "undefined") return true;
+  if (flag && typeof getExplicitInjectedProvider(flag) !== "undefined") return true;
+  return false;
+}
+function getInjectedProvider({ flag, namespace }) {
+  var _a;
+  const _window = typeof window !== "undefined" ? window : void 0;
+  if (typeof _window === "undefined") return;
+  if (namespace) {
+    const windowProvider = getWindowProviderNamespace(namespace);
+    if (windowProvider) return windowProvider;
+  }
+  const providers = (_a = _window.ethereum) == null ? void 0 : _a.providers;
+  if (flag) {
+    const provider = getExplicitInjectedProvider(flag);
+    if (provider) return provider;
+  }
+  if (typeof providers !== "undefined" && providers.length > 0) return providers[0];
+  return _window.ethereum;
+}
+function createInjectedConnector(provider) {
+  return (walletDetails) => {
+    const injectedConfig = provider ? {
+      target: () => ({
+        id: walletDetails.paraDetails.id,
+        name: walletDetails.paraDetails.name,
+        provider
+      })
+    } : {};
+    return createConnector((config) => __spreadValues(__spreadValues({}, injected(injectedConfig)(config)), walletDetails));
+  };
+}
+function getInjectedConnector({
+  flag,
+  namespace,
+  target
+}) {
+  const provider = target ? target : getInjectedProvider({ flag, namespace });
+  return createInjectedConnector(provider);
+}
+export {
+  getInjectedConnector,
+  getInjectedProvider,
+  hasInjectedProvider
+};

package/dist/utils/getWalletConnectConnector.js

@@ -0,0 +1,61 @@
+"use client";
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-MMUBH76A.js";
+import { createConnector } from "wagmi";
+import { walletConnect } from "wagmi/connectors";
+const walletConnectInstances = /* @__PURE__ */ new Map();
+const getOrCreateWalletConnectInstance = ({
+  projectId,
+  walletConnectParameters,
+  paraDetailsShowQrModal
+}) => {
+  let config = __spreadProps(__spreadValues({}, walletConnectParameters ? walletConnectParameters : {}), {
+    projectId,
+    showQrModal: false
+    // Required. Otherwise WalletConnect modal (Web3Modal) will popup during time of connection for a wallet
+  });
+  if (paraDetailsShowQrModal) {
+    config = __spreadProps(__spreadValues({}, config), { showQrModal: true });
+  }
+  const serializedConfig = JSON.stringify(config);
+  const sharedWalletConnector = walletConnectInstances.get(serializedConfig);
+  if (sharedWalletConnector) {
+    return sharedWalletConnector;
+  }
+  const newWalletConnectInstance = walletConnect(config);
+  walletConnectInstances.set(serializedConfig, newWalletConnectInstance);
+  return newWalletConnectInstance;
+};
+function createWalletConnectConnector({
+  projectId,
+  walletDetails,
+  walletConnectParameters
+}) {
+  return createConnector((config) => __spreadProps(__spreadValues(__spreadValues({}, getOrCreateWalletConnectInstance({
+    projectId,
+    walletConnectParameters,
+    // Used in `connectorsForWallets` to add another
+    // walletConnect wallet into Para with modal popup option
+    paraDetailsShowQrModal: walletDetails.paraDetails.showQrModal
+  })(config)), walletDetails), {
+    id: walletDetails.paraDetails.id
+  }));
+}
+function getWalletConnectConnector({
+  projectId,
+  walletConnectParameters
+}) {
+  if (!projectId || projectId === "") {
+    return;
+  }
+  return (walletDetails) => createWalletConnectConnector({
+    projectId,
+    walletDetails,
+    walletConnectParameters
+  });
+}
+export {
+  getWalletConnectConnector
+};

package/dist/utils/getWalletConnectUri.js

@@ -0,0 +1,22 @@
+"use client";
+import {
+  __async
+} from "../chunk-MMUBH76A.js";
+const getWalletConnectUri = (connector, uriConverter) => __async(void 0, null, function* () {
+  const provider = yield connector.getProvider();
+  if (connector.type === "coinbaseWallet") {
+    return provider.qrUrl;
+  }
+  return new Promise(
+    (resolve) => (
+      // Wagmi v2 doesn't have a return type for provider yet
+      // @ts-expect-error
+      provider.once("display_uri", (uri) => {
+        resolve(uriConverter ? uriConverter(uri) : uri);
+      })
+    )
+  );
+});
+export {
+  getWalletConnectUri
+};