@getpara/evm-wallet-connectors 1.7.0 → 1.8.0

package/dist/package.json

@@ -1,4 +1,3 @@
 {
-  "type": "module",
-  "sideEffects": false
+  "type": "module"
 }

package/dist/providers/EvmExternalWalletContext.d.ts

@@ -6,6 +6,7 @@ export declare const defaultEvmExternalWallet: {
     chainId: any;
     username: any;
     avatar: any;
+    balance: any;
     disconnect: () => Promise<void>;
     switchChain: () => Promise<{}>;
     signMessage: () => Promise<{}>;
@@ -17,6 +18,7 @@ export declare const EvmExternalWalletContext: import("react").Context<{
     chainId: number;
     username: string;
     avatar?: string;
+    balance?: string;
     disconnect: () => Promise<void>;
     switchChain: (chainId: number) => Promise<{
         error?: string[];

package/dist/providers/EvmExternalWalletContext.js

@@ -0,0 +1,345 @@
+"use client";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useEffect, useMemo, useRef } from "react";
+import {
+  useAccount,
+  useSwitchChain,
+  useConnect,
+  useDisconnect,
+  useEnsName,
+  useEnsAvatar,
+  useSwitchAccount,
+  useConnections,
+  useSignMessage,
+  useBalance
+} from "wagmi";
+import { isEIP6963Connector } from "../utils/isEIP6963Connector.js";
+import { getWalletConnectUri } from "../utils/getWalletConnectUri.js";
+import {
+  isMobile,
+  useExternalWalletProviderStore,
+  useWalletState,
+  WalletType
+} from "@getpara/react-sdk";
+import { normalize } from "viem/ens";
+import { useExternalWalletStore } from "../stores/useStore.js";
+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({}),
+  signMessage: () => Promise.resolve({}),
+  signVerificationMessage: () => Promise.resolve({})
+};
+const EvmExternalWalletContext = createContext(defaultEvmExternalWallet);
+function EvmExternalWalletProvider({ children, para, onSwitchWallet }) {
+  const { connectAsync, connectors: untypedConnectors } = useConnect();
+  const connections = useConnections();
+  const { address: wagmiAddress, isConnecting, isReconnecting, chainId, connector: connectedConnector } = useAccount();
+  const { chains, switchChainAsync } = useSwitchChain();
+  const { disconnectAsync } = useDisconnect();
+  const { switchAccountAsync } = useSwitchAccount();
+  const { signMessageAsync } = useSignMessage();
+  const { data: ensName, refetch: refetchEnsName } = useEnsName({ address: wagmiAddress });
+  const { data: ensAvatar, refetch: refetchEnsAvatar } = useEnsAvatar({
+    name: normalize(ensName)
+  });
+  const { data: wagmiBalance, isLoading: isBalanceLoading } = useBalance({ address: wagmiAddress });
+  const fullAuthWallets = useExternalWalletProviderStore((state) => state.fullAuthWallets);
+  const { selectedWallet } = useWalletState();
+  const isLocalConnecting = useExternalWalletStore((state) => state.isConnecting);
+  const updateExternalWalletState = useExternalWalletStore((state) => state.updateState);
+  const verificationMessage = useRef();
+  const getStoredExternalWallets = () => {
+    const storedExternalWalletsString = localStorage.getItem("@CAPSULE/externalWallets");
+    let storedExternalWallets = {};
+    if (storedExternalWalletsString) {
+      storedExternalWallets = JSON.parse(storedExternalWalletsString);
+    }
+    return storedExternalWallets;
+  };
+  const balance = useMemo(
+    // Format from wei to eth
+    () => isBalanceLoading || wagmiBalance === void 0 ? void 0 : formatUnits(wagmiBalance.value, etherUnits.wei),
+    [wagmiBalance, isBalanceLoading]
+  );
+  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) === WalletType.EVM && (storedExternalWallet == null ? void 0 : storedExternalWallet.address) !== wagmiAddress && (connectedConnector == null ? void 0 : connectedConnector.id) !== "para") {
+      switchWallet(wagmiAddress);
+    }
+  }, [isLocalConnecting, wagmiAddress, isReconnecting, isConnecting]);
+  useEffect(() => {
+    const wallet = para.findWallet(selectedWallet.id, selectedWallet.type);
+    if (wallet && connectedConnector && wallet.type === WalletType.EVM && (connectedConnector.id === "para" && wallet.isExternal || connectedConnector.id !== "para" && !wallet.isExternal)) {
+      switchAccount(wallet.isExternal ? wallet.name : "Para");
+    }
+  }, [selectedWallet]);
+  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 switchAccount = (connectorName) => __async(this, null, function* () {
+    var _a;
+    const connector = (_a = connections.find((c) => c.connector.name === connectorName)) == null ? void 0 : _a.connector;
+    if (!connector) {
+      throw new Error(`connector not found: ${connectorName}`);
+    }
+    yield switchAccountAsync({ connector });
+  });
+  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.externalWalletLogin({
+        address,
+        type: WalletType.EVM,
+        provider: connectorName,
+        withFullParaAuth: fullAuthWallets == null ? void 0 : fullAuthWallets.includes((_a = walletId == null ? void 0 : walletId.toUpperCase()) != null ? _a : "")
+      });
+    } 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({ 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 address;
+    let error;
+    let userExists = false;
+    let isVerified = false;
+    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 {
+          const loginResp = yield login({ address, connectorName: connector.name, walletId: connector.paraDetails.id });
+          userExists = loginResp.userExists;
+          isVerified = loginResp.isVerified;
+          verificationMessage.current = loginResp.signatureVerificationMessage;
+        } 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, error, userExists, isVerified };
+  });
+  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: WalletType.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 disconnect = disconnectAsync;
+  return /* @__PURE__ */ jsx(
+    EvmExternalWalletContext.Provider,
+    {
+      value: useMemo(
+        () => ({
+          wallets,
+          chains: formattedChains,
+          chainId,
+          username,
+          avatar: ensAvatar,
+          balance,
+          disconnect,
+          switchChain,
+          signMessage,
+          signVerificationMessage
+        }),
+        [
+          wallets,
+          formattedChains,
+          chainId,
+          username,
+          ensAvatar,
+          balance,
+          disconnect,
+          switchChain,
+          signMessage,
+          signVerificationMessage
+        ]
+      ),
+      children
+    }
+  );
+}
+export {
+  EvmExternalWalletContext,
+  EvmExternalWalletProvider,
+  defaultEvmExternalWallet
+};

package/dist/providers/ParaEvmContext.js

@@ -0,0 +1,115 @@
+"use client";
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, 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 { EvmExternalWalletContext, EvmExternalWalletProvider } from "./EvmExternalWalletContext.js";
+import { useClient, useExternalWalletProviderStore } from "@getpara/react-sdk";
+import { connect } from "wagmi/actions";
+import { paraConnector } from "@getpara/wagmi-v2-integration";
+const createDefaultTransports = (chains) => {
+  const transportsObject = chains.reduce((acc, chain) => {
+    const key = chain.id;
+    acc[key] = http();
+    return acc;
+  }, {});
+  return transportsObject;
+};
+function ParaEvmProvider(_a) {
+  var _b = _a, { children, config: _config } = _b, wagmiProviderProps = __objRest(_b, ["children", "config"]);
+  var _a2;
+  const updateExternalWalletProviderState = useExternalWalletProviderStore((state) => state.updateState);
+  const EvmProvider = useExternalWalletProviderStore((state) => state.EvmProvider);
+  const evmContext = useExternalWalletProviderStore((state) => state.evmContext);
+  const para = (_a2 = _config.para) != null ? _a2 : useClient();
+  const _b2 = _config, {
+    projectId,
+    appName,
+    appDescription,
+    appIcon,
+    appUrl,
+    wallets,
+    chains,
+    transports,
+    paraDisableModal,
+    paraOptions
+  } = _b2, wagmiConfigParams = __objRest(_b2, [
+    "projectId",
+    "appName",
+    "appDescription",
+    "appIcon",
+    "appUrl",
+    "wallets",
+    "chains",
+    "transports",
+    "paraDisableModal",
+    "paraOptions"
+  ]);
+  const wcMetadata = computeWalletConnectMetaData({ appName, appDescription, appUrl, appIcon });
+  const paraConnectorInstance = para ? paraConnector({
+    para,
+    chains: [...chains],
+    disableModal: paraDisableModal != null ? paraDisableModal : true,
+    appName,
+    options: paraOptions != null ? paraOptions : {}
+  }) : void 0;
+  const allConnectors = useMemo(() => {
+    const baseConnectors = connectorsForWallets(wallets, {
+      projectId,
+      appName,
+      appDescription,
+      appUrl,
+      appIcon,
+      walletConnectParameters: { metadata: wcMetadata }
+    });
+    return paraConnectorInstance ? [...baseConnectors, paraConnectorInstance] : baseConnectors;
+  }, [wallets, projectId, appName, appDescription, appUrl, appIcon, wcMetadata, paraConnectorInstance]);
+  const config = useMemo(
+    () => createConfig(__spreadProps(__spreadValues({}, wagmiConfigParams), {
+      chains,
+      transports: transports || createDefaultTransports(chains),
+      connectors: allConnectors
+    })),
+    [wagmiConfigParams, chains, transports, allConnectors]
+  );
+  const connectParaEvmWallet = useCallback(() => __async(this, null, function* () {
+    if (!paraConnectorInstance) {
+      return { error: "No para connector instance" };
+    }
+    try {
+      const result = yield connect(config, { connector: paraConnectorInstance });
+      return { result };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : "Unknown error";
+      return { error };
+    }
+  }), [paraConnectorInstance, config, connect]);
+  useEffect(() => {
+    if (!evmContext || !EvmProvider) {
+      updateExternalWalletProviderState({
+        EvmProvider: EvmExternalWalletProvider,
+        evmContext: EvmExternalWalletContext
+      });
+    }
+  }, []);
+  useEffect(() => {
+    updateExternalWalletProviderState({
+      connectParaEvmWallet: paraConnectorInstance ? connectParaEvmWallet : void 0
+    });
+  }, [paraConnectorInstance]);
+  if (!evmContext || !EvmProvider) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(WagmiProvider, __spreadProps(__spreadValues({ config }, wagmiProviderProps), { 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.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,63 @@
+"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 === "") {
+    throw new Error(
+      "No projectId found. Every dApp must now provide a WalletConnect Cloud projectId to enable WalletConnect v2. Sign up for your free key at https://cloud.walletconnect.com/sign-in"
+    );
+  }
+  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
+};