@getpara/evm-wallet-connectors 2.0.0-dev.1 → 2.0.0-dev.3

package/dist/package.json

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

package/dist/providers/EvmExternalWalletContext.d.ts

@@ -1,38 +1,10 @@
 import { PropsWithChildren } from 'react';
-import type { CommonChain, CommonWallet, TExternalWallet } from '@getpara/react-common';
-import ParaWeb, { Wallet } from '@getpara/web-sdk';
-export type EvmExternalWalletContextType = {
-    wallets: CommonWallet[];
-    chains: CommonChain[];
-    chainId?: number;
+import { FarcasterMiniAppManagement, type BalanceManagement, type ChainManagement, type ConnectParaEmbedded, type ExternalWalletContextType, type ExternalWalletProviderConfigBase } from '@getpara/react-common';
+import { TExternalHooks } from './externalHooks.js';
+export type EvmExternalWalletContextType = ExternalWalletContextType & ChainManagement<number> & BalanceManagement & ConnectParaEmbedded & TExternalHooks & {
     username?: string;
     avatar?: string;
-    disconnect: () => Promise<void>;
-    switchChain: (chainId: number) => Promise<{
-        error?: string[];
-    }>;
-    connectParaEmbedded: () => Promise<{
-        result?: unknown;
-        error?: string;
-    }>;
-    signMessage: (message: string) => Promise<{
-        signature?: string;
-        error?: string;
-    }>;
-    signVerificationMessage: () => Promise<{
-        address?: string;
-        signature?: string;
-        error?: string;
-    }>;
-};
+} & FarcasterMiniAppManagement;
 export declare const EvmExternalWalletContext: import("react").Context<EvmExternalWalletContextType>;
-export type EvmExternalWalletProviderConfig = {
-    onSwitchWallet?: (args: {
-        address?: string;
-        error?: string;
-    }) => void;
-    para: ParaWeb;
-    walletsWithFullAuth: TExternalWallet[];
-    connectedWallet?: Omit<Wallet, 'signer'> | null;
-};
-export declare function EvmExternalWalletProvider({ children, onSwitchWallet, para, walletsWithFullAuth, connectedWallet, }: EvmExternalWalletProviderConfig & PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+export type EvmExternalWalletProviderConfig = ExternalWalletProviderConfigBase;
+export declare function EvmExternalWalletProvider({ children, onSwitchWallet, para, walletsWithFullAuth, connectedWallet, includeWalletVerification, connectionOnly, }: EvmExternalWalletProviderConfig & PropsWithChildren): import("react/jsx-runtime").JSX.Element;

package/dist/providers/EvmExternalWalletContext.js

@@ -0,0 +1,457 @@
+"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 {
+  defaultEvmExternalWallet
+} from "@getpara/react-common";
+import { isMobile } from "@getpara/web-sdk";
+import { etherUnits, formatUnits } from "viem";
+import { externalHooks } from "./externalHooks.js";
+const EvmExternalWalletContext = createContext(defaultEvmExternalWallet);
+function EvmExternalWalletProvider({
+  children,
+  onSwitchWallet,
+  para,
+  walletsWithFullAuth,
+  connectedWallet,
+  includeWalletVerification,
+  connectionOnly
+}) {
+  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 isLinkingAccount = useRef(false);
+  const verificationMessage = useRef();
+  const { refetch: getBalance } = useBalance({ address: wagmiAddress });
+  const connectors = untypedConnectors;
+  const connectionsRef = useRef(connections);
+  const connectorsRef = useRef(connectors);
+  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 findConnectorAndAccount = (externalWallet) => {
+    var _a;
+    let connector;
+    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;
+        }
+        break;
+    }
+    return { connector, account: externalWallet.address };
+  };
+  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" && !isLinkingAccount.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) {
+      switchWallet(wagmiAddress);
+    }
+  }, [isLocalConnecting, wagmiAddress, isConnected]);
+  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 reset = () => __async(this, null, function* () {
+    yield disconnectAsync();
+    yield para.logout();
+  });
+  const signMessage = (_0) => __async(this, [_0], function* ({ message, externalWallet }) {
+    let signOpts = {};
+    if (externalWallet) {
+      signOpts = findConnectorAndAccount(externalWallet);
+    }
+    try {
+      const address = signOpts.account ? typeof signOpts.account === "string" ? signOpts.account : signOpts.account.getAddress() : wagmiAddress;
+      const signature = yield signMessageAsync(__spreadValues({
+        message,
+        account: address
+      }, signOpts));
+      return {
+        address,
+        signature
+      };
+    } catch (e) {
+      console.error("Error signing message:", 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({ message: 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, withFullParaAuth = false, providerId, provider }) {
+    try {
+      refetchEnsName();
+      refetchEnsAvatar();
+      return yield para.loginExternalWallet({
+        externalWallet: {
+          address,
+          type: "EVM",
+          provider,
+          providerId,
+          withFullParaAuth,
+          ensName,
+          ensAvatar,
+          isConnectionOnly: connectionOnly,
+          withVerification: includeWalletVerification
+        }
+      });
+    } catch (err) {
+      yield disconnectAsync();
+      yield para.logout();
+      throw "Error logging you in. Please try again.";
+    }
+  });
+  const switchWallet = (address) => __async(this, null, function* () {
+    updateExternalWalletState({ isConnecting: true });
+    let error;
+    if (!address) {
+      yield para.logout();
+    } else {
+      if (para.isExternalWalletAuth || para.isExternalWalletWithVerification) {
+        yield reset();
+      } else {
+        try {
+          const loginInfo = getConnectorInfo(connectedConnector);
+          yield login(__spreadValues({
+            address
+          }, loginInfo));
+        } catch (err) {
+          error = err;
+        }
+      }
+    }
+    onSwitchWallet == null ? void 0 : onSwitchWallet({ address, error });
+    updateExternalWalletState({ isConnecting: false });
+  });
+  const connectBase = (connector) => __async(this, null, function* () {
+    var _a, _b, _c, _d;
+    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 : (
+        // Fall back to the first chain provided.
+        (_b = chains[0]) == null ? void 0 : _b.id
+      ),
+      connector
+    });
+    return (_d = data.accounts) == null ? void 0 : _d[0];
+  });
+  const connect = (connector) => __async(this, null, function* () {
+    updateExternalWalletState({ isConnecting: true });
+    yield disconnectAsync();
+    let authState;
+    let address;
+    let error;
+    try {
+      address = yield connectBase(connector);
+      if (address) {
+        try {
+          const loginInfo = getConnectorInfo(connector);
+          authState = yield login(__spreadValues({
+            address
+          }, loginInfo));
+          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": {
+          error = `${connector.name} not detected`;
+          break;
+        }
+        default: {
+          console.error("Wagmi connection error:", e.message);
+          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 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;
+    try {
+      const address = yield connectBase(connector);
+      return {
+        address,
+        type: "EVM",
+        providerId: (_a = connector.paraDetails) == null ? void 0 : _a.internalId,
+        provider: connector.name,
+        ensName,
+        ensAvatar
+      };
+    } catch (e) {
+      throw new Error((_b = e == null ? void 0 : e.message) != null ? _b : e);
+    }
+  });
+  const disconnectBase = (providerId) => __async(this, null, function* () {
+    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;
+    try {
+      yield connector.disconnect();
+    } catch (e) {
+      throw new Error((_a = e == null ? void 0 : e.message) != null ? _a : e);
+    }
+  });
+  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) => {
+    var _a, _b, _c;
+    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), {
+      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);
+    return {
+      type: "EVM",
+      providerId,
+      provider: paraDetails == null ? void 0 : paraDetails.name,
+      withFullParaAuth
+    };
+  };
+  const formattedChains = chains.map((c) => {
+    return {
+      id: c.id,
+      name: c.name
+    };
+  });
+  const username = useMemo(() => ensName != null ? ensName : wagmiAddress, [ensName, wagmiAddress]);
+  const farcasterStatus = useMemo(() => {
+    var _a;
+    const connection = connections.find(
+      (c) => {
+        var _a2;
+        return ((_a2 = c.connector.paraDetails) == null ? void 0 : _a2.internalId) === "FARCASTER";
+      }
+    );
+    if (!connection) {
+      return void 0;
+    }
+    const address = (_a = connection == null ? void 0 : connection.accounts) == null ? void 0 : _a[0];
+    return address ? { isConnected: true, address } : { isConnected: false };
+  }, [connections]);
+  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]);
+  useEffect(() => {
+    connectionsRef.current = connections;
+  }, [connections]);
+  useEffect(() => {
+    connectorsRef.current = connectors;
+  }, [connectors]);
+  return /* @__PURE__ */ jsx(
+    EvmExternalWalletContext.Provider,
+    {
+      value: __spreadValues({
+        wallets,
+        chains: formattedChains,
+        chainId,
+        username,
+        avatar: ensAvatar,
+        disconnect: disconnectAsync,
+        switchChain,
+        connectParaEmbedded,
+        signMessage,
+        signVerificationMessage,
+        getWalletBalance,
+        requestInfo,
+        disconnectBase,
+        farcasterStatus
+      }, externalHooks),
+      children
+    }
+  );
+}
+export {
+  EvmExternalWalletContext,
+  EvmExternalWalletProvider
+};

package/dist/providers/ParaEvmContext.d.ts

@@ -4,12 +4,13 @@ import { WalletList } from '../types/Wallet.js';
 import { Chain, Transport } from 'viem';
 import { EvmExternalWalletProviderConfig } from './EvmExternalWalletContext.js';
 import { InjectedParameters } from 'wagmi/connectors';
+import { TExternalWallet } from '@getpara/react-common';
 export interface ParaEvmProviderConfig<chains extends readonly [Chain, ...Chain[]], transports extends Record<chains[number]['id'], Transport>> extends Omit<CreateConfigParameters<chains, transports>, 'connectors'> {
     appName: string;
     appDescription?: string;
     appUrl?: string;
     appIcon?: string;
-    wallets?: WalletList;
+    wallets?: WalletList | TExternalWallet[];
     projectId: string;
     paraConnectorOptions?: InjectedParameters;
 }

package/dist/providers/ParaEvmContext.js

@@ -0,0 +1,123 @@
+"use client";
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { createConfig as createWagmiConfig, 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";
+import { setWagmiConfig, getWagmiConfig } from "../stores/wagmiConfigStore.js";
+import { resolveWalletList } from "../utils/resolveWalletList.js";
+import { farcasterWallet } from "../wallets/connectors/index.js";
+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: propsWallets,
+    chains,
+    transports,
+    paraConnectorOptions
+  } = _a, wagmiConfigParams = __objRest(_a, [
+    "projectId",
+    "appName",
+    "appDescription",
+    "appIcon",
+    "appUrl",
+    "wallets",
+    "chains",
+    "transports",
+    "paraConnectorOptions"
+  ]);
+  const propsWalletList = useMemo(() => {
+    return resolveWalletList(propsWallets != null ? propsWallets : []);
+  }, [propsWallets]);
+  const prevWallets = useRef(propsWalletList);
+  const paraConnectorInstance = useMemo(() => {
+    return paraConnector({
+      para,
+      chains: [...chains],
+      disableModal: true,
+      appName,
+      options: paraConnectorOptions != null ? paraConnectorOptions : {}
+    });
+  }, [para]);
+  const createConfig = (walletList, createFarcasterConnector) => {
+    const existing = getWagmiConfig();
+    if (existing && prevWallets.current === walletList) {
+      return existing;
+    }
+    prevWallets.current = walletList;
+    const wcMetadata = computeWalletConnectMetaData({ appName, appDescription, appUrl, appIcon });
+    const baseConnectors = connectorsForWallets(walletList, {
+      para,
+      createFarcasterConnector,
+      projectId,
+      appName,
+      appDescription,
+      appUrl,
+      appIcon,
+      walletConnectParameters: { metadata: wcMetadata }
+    });
+    const allConnectors = [...baseConnectors, paraConnectorInstance];
+    const createdConfig = createWagmiConfig(__spreadProps(__spreadValues({
+      ssr: true
+    }, wagmiConfigParams), {
+      chains,
+      transports: transports || createDefaultTransports(chains),
+      connectors: allConnectors
+    }));
+    setWagmiConfig(createdConfig);
+    return createdConfig;
+  };
+  const [config, setConfig] = useState(null);
+  useEffect(() => {
+    if (!para.isReady) {
+      return;
+    }
+    const initializeConfig = () => __async(this, null, function* () {
+      var _a2;
+      if (para.isFarcasterMiniApp) {
+        let createFarcasterConnector = null;
+        try {
+          createFarcasterConnector = (_a2 = (yield import("@farcaster/miniapp-wagmi-connector")).farcasterMiniApp) != null ? _a2 : void 0;
+        } catch (e) {
+        }
+        setConfig(createConfig([...propsWalletList, farcasterWallet], createFarcasterConnector));
+      } else {
+        setConfig(createConfig([...propsWalletList]));
+      }
+    });
+    initializeConfig();
+  }, [para.isFarcasterMiniApp, para.isReady, propsWalletList]);
+  if (!config) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(WagmiProvider, __spreadProps(__spreadValues({ config }, wagmiProviderProps), { children: /* @__PURE__ */ jsx(EvmExternalWalletProvider, __spreadProps(__spreadValues({}, internalConfig), { children })) }));
+}
+export {
+  ParaEvmProvider
+};

package/dist/providers/createParaWagmiConfig.d.ts

@@ -0,0 +1,10 @@
+import { Chain, Transport } from 'viem';
+import type { ParaEvmProviderConfig } from './ParaEvmContext.js';
+import ParaWeb from '@getpara/web-sdk';
+/**
+ * Creates a Wagmi configuration for the Para EVM provider.
+ * @param para - The ParaWeb instance to use.
+ * @param cfg - The configuration options for the Para EVM provider.
+ * @returns The created Wagmi configuration.
+ */
+export declare function createParaWagmiConfig<const chains extends readonly [Chain, ...Chain[]], transports extends Record<chains[number]['id'], Transport>>(para: ParaWeb, cfg: ParaEvmProviderConfig<chains, transports>): import("wagmi").Config<chains, transports, readonly import("wagmi").CreateConnectorFn[]>;