@particle-network/connectkit 2.1.2 → 2.1.3

package/dist/esm/chunk-4TIAGANX.mjs

@@ -0,0 +1,2345 @@
+"use client";
+import {
+  getLocale,
+  init_locales
+} from "./chunk-ZBMASWYL.mjs";
+import {
+  PasskeyIcon_default,
+  init_PasskeyIcon
+} from "./chunk-WYWSNAPC.mjs";
+import {
+  Zerion_default,
+  init_Zerion
+} from "./chunk-X3AHMJH4.mjs";
+import {
+  Rabby_default,
+  init_Rabby
+} from "./chunk-VM42Y624.mjs";
+import {
+  Rainbow_default,
+  init_Rainbow
+} from "./chunk-3CZRO6RQ.mjs";
+import {
+  SafePal_default,
+  init_SafePal
+} from "./chunk-2LQKVNKI.mjs";
+import {
+  Slope_default,
+  init_Slope
+} from "./chunk-CNE7WI2P.mjs";
+import {
+  Talisman_default,
+  init_Talisman
+} from "./chunk-HKMLJP4P.mjs";
+import {
+  TokenPocket_default,
+  init_TokenPocket
+} from "./chunk-VW7L52Q6.mjs";
+import {
+  WalletConnect_default,
+  init_WalletConnect
+} from "./chunk-BG2VLRRD.mjs";
+import {
+  Injected_default,
+  init_Injected
+} from "./chunk-5TAT3MVW.mjs";
+import {
+  Ledger_default,
+  init_Ledger
+} from "./chunk-AOBFG4R6.mjs";
+import {
+  MetaMask_default,
+  init_MetaMask
+} from "./chunk-KD3UOOP5.mjs";
+import {
+  OKX_default,
+  init_OKX
+} from "./chunk-VYUWVCC2.mjs";
+import {
+  ONTO_default,
+  init_ONTO
+} from "./chunk-HHHJM4FL.mjs";
+import {
+  Onekey_default,
+  init_Onekey
+} from "./chunk-743HT6GA.mjs";
+import {
+  Phantom_default,
+  init_Phantom
+} from "./chunk-3JW6NUP7.mjs";
+import {
+  BitKeep_default,
+  init_BitKeep
+} from "./chunk-Y2AM7F32.mjs";
+import {
+  Brave_default,
+  init_Brave
+} from "./chunk-4EX26J4C.mjs";
+import {
+  Bybit_default,
+  init_Bybit
+} from "./chunk-QT4CBCFK.mjs";
+import {
+  Coin98_default,
+  init_Coin98
+} from "./chunk-3OVTLX5O.mjs";
+import {
+  Coinbase_default,
+  init_Coinbase
+} from "./chunk-5VTAF6IK.mjs";
+import {
+  Frontier_default,
+  init_Frontier
+} from "./chunk-5KG67Q3H.mjs";
+import {
+  ImToken_default,
+  init_ImToken
+} from "./chunk-PSUGDD7L.mjs";
+import {
+  InfinityWallet_default,
+  init_InfinityWallet
+} from "./chunk-MEE5TGUN.mjs";
+import {
+  __esm
+} from "./chunk-Y7A564BU.mjs";
+
+// src/utils/theme.ts
+function getSystemMode() {
+  if (typeof window !== "undefined" && window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches) {
+    return "dark";
+  } else {
+    return "light";
+  }
+}
+var init_theme = __esm({
+  "src/utils/theme.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/deepEqual.ts
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    if (a.constructor !== b.constructor)
+      return false;
+    let length;
+    let i;
+    if (Array.isArray(a) && Array.isArray(b)) {
+      length = a.length;
+      if (length !== b.length)
+        return false;
+      for (i = length; i-- !== 0; )
+        if (!deepEqual(a[i], b[i]))
+          return false;
+      return true;
+    }
+    if (a.valueOf !== Object.prototype.valueOf)
+      return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString)
+      return a.toString() === b.toString();
+    const keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length)
+      return false;
+    for (i = length; i-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+        return false;
+    for (i = length; i-- !== 0; ) {
+      const key = keys[i];
+      if (key && !deepEqual(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+var init_deepEqual = __esm({
+  "src/utils/deepEqual.ts"() {
+    "use strict";
+  }
+});
+
+// src/actions/getAccount.ts
+import { checksumAddress, isAddress } from "viem";
+function getAccount(config) {
+  const state = config.state;
+  if (deepEqual(previousState, state))
+    return previousAccount;
+  const uid = config.state.current;
+  const connection = config.state.connections.get(uid);
+  let addresses = connection?.accounts;
+  if (addresses?.length && addresses.every((account) => isAddress(account, { strict: false }))) {
+    addresses = addresses.map((item) => checksumAddress(item));
+  }
+  const address = addresses?.[0];
+  const chain = config.chains.find((chain2) => chain2.id === connection?.chainId);
+  const status = config.state.status;
+  let result;
+  switch (status) {
+    case "connected":
+      result = {
+        address,
+        addresses,
+        chain,
+        chainId: connection?.chainId,
+        connector: connection?.connector,
+        isConnected: true,
+        isConnecting: false,
+        isDisconnected: false,
+        isReconnecting: false,
+        status
+      };
+      break;
+    case "reconnecting":
+      result = {
+        address,
+        addresses,
+        chain,
+        chainId: connection?.chainId,
+        connector: connection?.connector,
+        isConnected: !!address,
+        isConnecting: false,
+        isDisconnected: false,
+        isReconnecting: true,
+        status
+      };
+      break;
+    case "connecting":
+      result = {
+        address,
+        addresses,
+        chain,
+        chainId: connection?.chainId,
+        connector: connection?.connector,
+        isConnected: false,
+        isConnecting: true,
+        isDisconnected: false,
+        isReconnecting: false,
+        status
+      };
+      break;
+    case "disconnected":
+      result = {
+        address: void 0,
+        addresses: void 0,
+        chain: void 0,
+        chainId: void 0,
+        connector: void 0,
+        isConnected: false,
+        isConnecting: false,
+        isDisconnected: true,
+        isReconnecting: false,
+        status
+      };
+      break;
+  }
+  previousAccount = result;
+  return result;
+}
+var previousAccount, previousState;
+var init_getAccount = __esm({
+  "src/actions/getAccount.ts"() {
+    "use strict";
+    init_deepEqual();
+  }
+});
+
+// src/actions/watchAccount.ts
+function watchAccount(config, parameters) {
+  const { onChange } = parameters;
+  return config.subscribe(() => getAccount(config), onChange, {
+    equalityFn(a, b) {
+      const { connector: aConnector, ...aRest } = a;
+      const { connector: bConnector, ...bRest } = b;
+      return deepEqual(aRest, bRest) && aConnector?.id === bConnector?.id && aConnector?.uid === bConnector?.uid;
+    }
+  });
+}
+var init_watchAccount = __esm({
+  "src/actions/watchAccount.ts"() {
+    "use strict";
+    init_deepEqual();
+    init_getAccount();
+  }
+});
+
+// src/hooks/useSyncExternalStoreWithTracked.ts
+import { useRef } from "react";
+import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector.js";
+function useSyncExternalStoreWithTracked(subscribe, getSnapshot, getServerSnapshot = getSnapshot, isEqual = deepEqual) {
+  const trackedKeys = useRef([]);
+  const result = useSyncExternalStoreWithSelector(
+    subscribe,
+    getSnapshot,
+    getServerSnapshot,
+    (x) => x,
+    (a, b) => {
+      if (isPlainObject(a) && isPlainObject(b) && trackedKeys.current.length) {
+        for (const key of trackedKeys.current) {
+          const equal = isEqual(a[key], b[key]);
+          if (!equal)
+            return false;
+        }
+        return true;
+      }
+      return isEqual(a, b);
+    }
+  );
+  if (isPlainObject(result)) {
+    const trackedResult = { ...result };
+    let properties = {};
+    for (const [key, value] of Object.entries(trackedResult)) {
+      properties = {
+        ...properties,
+        [key]: {
+          configurable: false,
+          enumerable: true,
+          get: () => {
+            if (!trackedKeys.current.includes(key)) {
+              trackedKeys.current.push(key);
+            }
+            return value;
+          }
+        }
+      };
+    }
+    Object.defineProperties(trackedResult, properties);
+    return trackedResult;
+  }
+  return result;
+}
+var isPlainObject;
+var init_useSyncExternalStoreWithTracked = __esm({
+  "src/hooks/useSyncExternalStoreWithTracked.ts"() {
+    "use strict";
+    init_deepEqual();
+    isPlainObject = (obj) => typeof obj === "object" && !Array.isArray(obj);
+  }
+});
+
+// src/hooks/useAccount.ts
+function useAccount() {
+  const { config } = useContext();
+  return useSyncExternalStoreWithTracked(
+    (onChange) => watchAccount(config, { onChange }),
+    () => getAccount(config)
+  );
+}
+var init_useAccount = __esm({
+  "src/hooks/useAccount.ts"() {
+    "use strict";
+    init_getAccount();
+    init_watchAccount();
+    init_context();
+    init_useSyncExternalStoreWithTracked();
+  }
+});
+
+// src/hooks/useLocales.ts
+import { useMemo } from "react";
+function useLocales() {
+  const { appearance } = useAppearance();
+  const language = useMemo(() => {
+    return appearance?.language ?? "en-US";
+  }, [appearance.language]);
+  const overrideLocales = useMemo(() => {
+    return appearance.overrideLocales;
+  }, [appearance.overrideLocales]);
+  const translations = useMemo(() => {
+    const locales = getLocale(language);
+    const overrideLanguage = overrideLocales?.[language];
+    return { ...locales, ...overrideLanguage };
+  }, [language, overrideLocales]);
+  if (!translations) {
+    throw new Error(`Missing translations for ${language}`);
+  }
+  return translations;
+}
+var init_useLocales = __esm({
+  "src/hooks/useLocales.ts"() {
+    "use strict";
+    init_locales();
+    init_useAppearance();
+  }
+});
+
+// src/hooks/useModalError.ts
+import { create } from "zustand";
+var useModalError;
+var init_useModalError = __esm({
+  "src/hooks/useModalError.ts"() {
+    "use strict";
+    useModalError = create((set) => ({
+      showError: (value) => {
+        set({ error: value });
+      },
+      hideError: () => {
+        set({ error: void 0 });
+      }
+    }));
+  }
+});
+
+// src/hooks/useModalState.ts
+import { create as create2 } from "zustand";
+var useModalState;
+var init_useModalState = __esm({
+  "src/hooks/useModalState.ts"() {
+    "use strict";
+    useModalState = create2((set) => ({
+      open: false,
+      setOpen: (value) => set({ open: value })
+    }));
+  }
+});
+
+// src/pages/index.ts
+import { lazy } from "react";
+var Captcha, Connecting, Connectors, DownloadApp, LoginPasskey, PasskeySetup, Receive, SelectChain, Signup, WalletInfo, WalletInfoTitle, Walletconnect, safeRoutes, allRoutes, pages, getPage;
+var init_pages = __esm({
+  "src/pages/index.ts"() {
+    "use strict";
+    Captcha = lazy(() => import("./captcha-7K5YUOAC.mjs"));
+    Connecting = lazy(() => import("./connecting-2HGZOUZB.mjs"));
+    Connectors = lazy(() => import("./connectors-2V2JJ6S7.mjs"));
+    DownloadApp = lazy(() => import("./downloadApp-PIRCNQ4N.mjs"));
+    LoginPasskey = lazy(() => import("./loginPasskey-DD4FRFPW.mjs"));
+    PasskeySetup = lazy(() => import("./passkeySetup-KI2VBQ7A.mjs"));
+    Receive = lazy(() => import("./receive-GFC3GLIM.mjs"));
+    SelectChain = lazy(() => import("./selectChain-AJHYNQAM.mjs"));
+    Signup = lazy(() => import("./signup-SKBD6Z2Y.mjs"));
+    WalletInfo = lazy(() => import("./walletInfo-7RXQWOEM.mjs"));
+    WalletInfoTitle = lazy(() => import("./title-ZORJGTVO.mjs"));
+    Walletconnect = lazy(() => import("./walletconnect-WEP2CKGV.mjs"));
+    safeRoutes = {
+      connected: ["wallet-info" /* WalletInfo */, "receive" /* Receive */],
+      disconnected: [
+        "signup" /* Signup */,
+        "connectors" /* Connectors */,
+        "captcha" /* Captcha */,
+        "connecting" /* Connecting */,
+        "download-app" /* DownloadApp */,
+        "select-chain" /* SelectChain */,
+        "walletconnect" /* Walletconnect */,
+        "passkey-setup" /* PasskeySetup */,
+        "login-passkey" /* LoginPasskey */
+      ]
+    };
+    allRoutes = [...safeRoutes.connected, ...safeRoutes.disconnected];
+    pages = [
+      {
+        title: "signupTitle",
+        path: "signup" /* Signup */,
+        element: Signup
+      },
+      {
+        title: "connectorsTitle",
+        path: "connectors" /* Connectors */,
+        element: Connectors
+      },
+      {
+        title: "captchaTitle",
+        path: "captcha" /* Captcha */,
+        element: Captcha
+      },
+      {
+        path: "connecting" /* Connecting */,
+        element: Connecting
+      },
+      {
+        path: "download-app" /* DownloadApp */,
+        element: DownloadApp
+      },
+      {
+        title: "scanWithPhone",
+        path: "walletconnect" /* Walletconnect */,
+        element: Walletconnect
+      },
+      {
+        title: "selectChainTitle",
+        path: "select-chain" /* SelectChain */,
+        element: SelectChain
+      },
+      {
+        title: WalletInfoTitle,
+        path: "wallet-info" /* WalletInfo */,
+        element: WalletInfo
+      },
+      {
+        title: "receive",
+        path: "receive" /* Receive */,
+        element: Receive
+      },
+      {
+        title: "setupPasskey",
+        path: "passkey-setup" /* PasskeySetup */,
+        element: PasskeySetup
+      },
+      {
+        title: "usePasskeyToLogin",
+        path: "login-passkey" /* LoginPasskey */,
+        element: LoginPasskey
+      }
+    ];
+    getPage = (path) => {
+      const page = pages.find((item) => item.path === path);
+      if (!page) {
+        throw new Error("route path undefined");
+      }
+      return page;
+    };
+  }
+});
+
+// src/hooks/useRouteState.ts
+import { create as create3 } from "zustand";
+var initialState, useRouteState;
+var init_useRouteState = __esm({
+  "src/hooks/useRouteState.ts"() {
+    "use strict";
+    initialState = { path: "signup" /* Signup */ };
+    useRouteState = create3((set) => ({
+      route: initialState,
+      setRoute: (value) => {
+        if (typeof value === "string") {
+          set({
+            route: {
+              path: value
+            }
+          });
+        } else {
+          set({ route: value });
+        }
+      }
+    }));
+  }
+});
+
+// src/hooks/useRouter.ts
+import { useCallback } from "react";
+var useRouter;
+var init_useRouter = __esm({
+  "src/hooks/useRouter.ts"() {
+    "use strict";
+    init_pages();
+    init_useAccount();
+    init_useModalState();
+    init_useRouteState();
+    useRouter = () => {
+      const { setOpen, open } = useModalState();
+      const setRoute = useRouteState((state) => state.setRoute);
+      const { isConnected } = useAccount();
+      const navigate = (route, state) => {
+        let validRoute = route;
+        if (!allRoutes.includes(route)) {
+          validRoute = isConnected ? "wallet-info" /* WalletInfo */ : "signup" /* Signup */;
+        }
+        if (isConnected) {
+          if (!safeRoutes.connected.includes(route)) {
+            validRoute = "wallet-info" /* WalletInfo */;
+          }
+        } else {
+          if (!safeRoutes.disconnected.includes(route)) {
+            validRoute = "signup" /* Signup */;
+          }
+        }
+        if (!open) {
+          setOpen(true);
+        }
+        setRoute({ path: validRoute, state });
+      };
+      const close = useCallback(() => {
+        setOpen(false);
+      }, [setOpen]);
+      return {
+        navigate,
+        close,
+        isOpen: open
+      };
+    };
+  }
+});
+
+// src/components/connectModal/index.tsx
+import { lazy as lazy2, useCallback as useCallback2, useEffect, useMemo as useMemo2 } from "react";
+import { jsx } from "react/jsx-runtime";
+var Modal, ConnectModal, connectModal_default;
+var init_connectModal = __esm({
+  "src/components/connectModal/index.tsx"() {
+    "use strict";
+    init_useAccount();
+    init_useLocales();
+    init_useModalError();
+    init_useModalState();
+    init_useRouteState();
+    init_useRouter();
+    init_pages();
+    Modal = lazy2(() => import("./modal-LH7RATUT.mjs"));
+    ConnectModal = () => {
+      const { setOpen, open } = useModalState();
+      const { route } = useRouteState();
+      const { navigate } = useRouter();
+      const locales = useLocales();
+      const { hideError } = useModalError();
+      const { isConnected } = useAccount();
+      useEffect(() => {
+        setOpen(false);
+      }, [isConnected, setOpen]);
+      useEffect(() => {
+        hideError();
+      }, [route, hideError]);
+      const {
+        element: PageElement,
+        title,
+        state
+      } = useMemo2(() => {
+        const page = getPage(route.path);
+        return { ...page, state: route.state };
+      }, [route]);
+      const onClose = useCallback2(() => {
+        setOpen(false);
+      }, [setOpen]);
+      const onBack = useCallback2(() => {
+        navigate("signup" /* Signup */);
+      }, [navigate]);
+      const isCanBack = useMemo2(() => route.path !== "signup" /* Signup */ && route.path !== "wallet-info" /* WalletInfo */, [route.path]);
+      return /* @__PURE__ */ jsx(
+        Modal,
+        {
+          open,
+          onClose,
+          title: typeof title === "string" ? locales[title] : title,
+          onBack: isCanBack ? onBack : void 0,
+          children: /* @__PURE__ */ jsx(PageElement, { ...state })
+        }
+      );
+    };
+    connectModal_default = ConnectModal;
+  }
+});
+
+// src/utils/index.ts
+import { detect } from "detect-browser";
+import { formatUnits } from "viem/utils";
+function formatStringNumber(num, n) {
+  let [integerPart, decimalPart] = num.split(".");
+  if (!decimalPart) {
+    return integerPart;
+  }
+  decimalPart = decimalPart.slice(0, n);
+  decimalPart = decimalPart.replace(/0+$/, "");
+  if (decimalPart === "") {
+    return integerPart;
+  }
+  return `${integerPart}.${decimalPart}`;
+}
+function getElementDimensionsRelativeToParent(ref) {
+  if (!ref.current) {
+    return null;
+  }
+  const element = ref.current;
+  const parent = element.parentElement;
+  if (!parent) {
+    return null;
+  }
+  const elementRect = element.getBoundingClientRect();
+  const parentRect = parent.getBoundingClientRect();
+  const topDistance = elementRect.top - parentRect.top;
+  const bottomDistance = parentRect.bottom - elementRect.bottom;
+  const dimensions = {
+    width: elementRect.width,
+    height: elementRect.height,
+    topDistance,
+    bottomDistance
+  };
+  return dimensions;
+}
+function getBuyUrl(chainId, address, currency = "USD", theme = "light", language = "en-US") {
+  const RAMP_WEB_URL = "https://ramp.particle.network";
+  const supportedNetworks = {
+    "1": ["Ethereum", "ETH"],
+    "10": ["Optimism", "ETH"],
+    "56": ["Binance Smart Chain", "BNB"],
+    "101": ["Solana", "SOL"],
+    "137": ["Polygon", "MATIC"],
+    "204": ["opBNB", "BNB"],
+    "324": ["Zksync", "ETH"],
+    "5000": ["Mantle", "MNT"],
+    "8453": ["Base", "ETH"],
+    "42161": ["Arbitrum One", "ETH"],
+    "42220": ["Celo", "CELO"],
+    "43114": ["Avalanche", "AVAX"],
+    "728126428": ["Tron", "TRX"]
+  };
+  if (!chainId || !address || !supportedNetworks[chainId]) {
+    return "";
+  }
+  const chainName = supportedNetworks[chainId]?.[0] || "";
+  const cryptoCoin = supportedNetworks[chainId]?.[1] || "ETH";
+  const buyParams = {
+    walletAddress: address,
+    fiatCoin: currency,
+    cryptoCoin,
+    chainName,
+    showBackButton: false,
+    theme,
+    language
+  };
+  const queryString = new URLSearchParams(buyParams).toString();
+  return `${RAMP_WEB_URL}/?${queryString}`;
+}
+function popupWindow(url, title, w, h) {
+  const left = screen.width / 2 - w / 2;
+  const top = screen.height / 2 - h / 2;
+  return window.open(
+    url,
+    title,
+    "toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=no, resizable=no, copyhistory=no, width=" + w + ", height=" + h + ", top=" + top + ", left=" + left
+  );
+}
+function hexToRgbaColor(hex, alpha) {
+  if (!hex) {
+    return "";
+  }
+  hex = hex.replace(/^#/, "");
+  if (hex.length === 3) {
+    hex = hex.split("").map((char) => char + char).join("");
+  }
+  if (!/^[0-9A-Fa-f]{6}$/.test(hex)) {
+    throw new Error("Invalid hex color format");
+  }
+  if (typeof alpha !== "number" || alpha < 0 || alpha > 1) {
+    throw new Error("Alpha value must be a number between 0 and 1");
+  }
+  const r = parseInt(hex.slice(0, 2), 16);
+  const g = parseInt(hex.slice(2, 4), 16);
+  const b = parseInt(hex.slice(4, 6), 16);
+  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
+var detectOS, isIOS, isAndroid, isMobile, hexToRgba, shortAddress, openMobileUrl, hasPCDownloadUrl, formatTokenAmount, roundToEven, isFirstRegisterPasskey, setFirstRegisterPasskey;
+var init_utils = __esm({
+  "src/utils/index.ts"() {
+    "use strict";
+    detectOS = () => {
+      const browser = detect();
+      return browser?.os ?? "";
+    };
+    isIOS = () => {
+      const os = detectOS();
+      return os.toLowerCase().includes("ios");
+    };
+    isAndroid = () => {
+      const os = detectOS();
+      return os.toLowerCase().includes("android");
+    };
+    isMobile = () => {
+      return isAndroid() || isIOS();
+    };
+    hexToRgba = (hex, alpha) => {
+      let r = 0, g = 0, b = 0;
+      if (hex.length === 4) {
+        r = parseInt(hex[1] + hex[1], 16);
+        g = parseInt(hex[2] + hex[2], 16);
+        b = parseInt(hex[3] + hex[3], 16);
+      } else if (hex.length === 7) {
+        r = parseInt(hex[1] + hex[2], 16);
+        g = parseInt(hex[3] + hex[4], 16);
+        b = parseInt(hex[5] + hex[6], 16);
+      }
+      return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+    };
+    shortAddress = (address) => {
+      if (!address) {
+        return "";
+      }
+      if (address.length <= 10) {
+        return address;
+      }
+      return `${address.slice(0, 6)}...${address.slice(-4)}`;
+    };
+    openMobileUrl = (url) => {
+      if (url.startsWith("http")) {
+        const link = document.createElement("a");
+        link.href = url;
+        link.target = "_blank";
+        link.rel = "noreferrer noopener";
+        link.click();
+      } else {
+        window.location.href = url;
+      }
+    };
+    hasPCDownloadUrl = (walletProps) => {
+      return Boolean(
+        walletProps.downloadUrls?.chrome || walletProps.downloadUrls?.brave || walletProps.downloadUrls?.edge || walletProps.downloadUrls?.firefox || walletProps.downloadUrls?.safari
+      );
+    };
+    formatTokenAmount = (value, decimal, decimalPlaces = 9) => {
+      if (!value)
+        return "0";
+      if (typeof value === "string" || typeof value === "number") {
+        value = BigInt(value);
+      }
+      let result = formatUnits(value, decimal);
+      const [integerPart, decimalPart] = result.split(".");
+      if (decimalPlaces >= 5 && integerPart === "0" && decimalPart?.startsWith("".padEnd(decimalPlaces, "0"))) {
+        return "<0.".padEnd(decimalPlaces + 3 - 1, "0") + "1";
+      }
+      result = formatStringNumber(result, decimalPlaces);
+      return result;
+    };
+    roundToEven = (value) => {
+      return Math.floor(value / 2) * 2;
+    };
+    isFirstRegisterPasskey = () => {
+      return localStorage.getItem("passkeyRegistrationStatus") !== "completed";
+    };
+    setFirstRegisterPasskey = () => {
+      localStorage.setItem("passkeyRegistrationStatus", "completed");
+    };
+  }
+});
+
+// src/styles/themes/dark.ts
+var darkTheme, dark_default;
+var init_dark = __esm({
+  "src/styles/themes/dark.ts"() {
+    "use strict";
+    darkTheme = {
+      "--pcm-overlay-background": "rgba(0,0,0,0.4)",
+      "--pcm-modal-box-shadow": "0px 6px 20px 6px rgba(0, 0, 0, 0.1)",
+      "--pcm-body-background": "#1C1D22",
+      "--pcm-body-background-secondary": "#41424A",
+      "--pcm-body-background-tertiary": "#232529",
+      "--pcm-body-color": "#ffffff",
+      "--pcm-body-color-secondary": "#8B8EA1",
+      "--pcm-body-color-tertiary": "#42444B",
+      "--pcm-body-action-color": "#808080",
+      "--pcm-button-border-color": "#292B36",
+      "--pcm-accent-color": "#A257FA",
+      "--pcm-button-font-weight": "500",
+      "--pcm-button-hover-shadow": "0px 2px 4px rgba(255, 255, 255, 0.05)",
+      "--pcm-primary-button-color": "#000000",
+      "--pcm-primary-button-bankground": "#FFFFFF",
+      "--pcm-primary-button-hover-background": "#f5f5f5",
+      "--pcm-secondary-button-color": "#FFFFFF",
+      "--pcm-secondary-button-bankground": "#41424A",
+      "--pcm-secondary-button-hover-background": "#5A5B66"
+    };
+    dark_default = darkTheme;
+  }
+});
+
+// src/styles/themes/light.ts
+var lightTheme, light_default;
+var init_light = __esm({
+  "src/styles/themes/light.ts"() {
+    "use strict";
+    lightTheme = {
+      "--pcm-overlay-background": "rgba(71, 88, 107, 0.24)",
+      "--pcm-modal-box-shadow": "0px 2px 4px rgba(0, 0, 0, 0.1)",
+      "--pcm-body-background": "#ffffff",
+      "--pcm-body-background-secondary": "#EFF0F2",
+      "--pcm-body-background-tertiary": "#F9F9FA",
+      "--pcm-body-color": "#181B1E",
+      "--pcm-body-color-secondary": "#8B8EA1",
+      "--pcm-body-color-tertiary": "#DCDFE6",
+      "--pcm-body-action-color": "#999999",
+      "--pcm-button-border-color": "#EAECF0",
+      "--pcm-accent-color": "#A257FA",
+      "--pcm-button-font-weight": "500",
+      "--pcm-button-hover-shadow": "0px 2px 4px rgba(0, 0, 0, 0.05)",
+      "--pcm-primary-button-color": "#ffffff",
+      "--pcm-primary-button-bankground": "#181B1E",
+      "--pcm-primary-button-hover-background": "#353738",
+      "--pcm-secondary-button-color": "#181B1E",
+      "--pcm-secondary-button-bankground": "#EFF0F2",
+      "--pcm-secondary-button-hover-background": "#D9DBDD"
+    };
+    light_default = lightTheme;
+  }
+});
+
+// src/styles/themes/index.ts
+var base, themes_default;
+var init_themes = __esm({
+  "src/styles/themes/index.ts"() {
+    "use strict";
+    init_dark();
+    init_light();
+    base = {
+      dark: dark_default,
+      light: light_default
+    };
+    themes_default = { base };
+  }
+});
+
+// src/styles/index.ts
+import { motion } from "framer-motion";
+import { css, styled } from "styled-components";
+var getWalletOption, mergeThemes, getAuthCoreTheme, themeGlobals, themeColors, createCssVars, themes, mode, ThemeContainer;
+var init_styles = __esm({
+  "src/styles/index.ts"() {
+    "use strict";
+    init_utils();
+    init_theme();
+    init_themes();
+    init_dark();
+    init_light();
+    getWalletOption = (appearance) => {
+      let theme = appearance?.mode ?? getSystemMode();
+      if (theme === "auto") {
+        theme = getSystemMode();
+      }
+      let themeConfig = theme === "light" ? light_default : dark_default;
+      themeConfig = mergeThemes({ ...themeGlobals.default, ...themeConfig }, appearance?.theme || {});
+      const walletTheme = {};
+      walletTheme.colorAccent = themeConfig["--pcm-accent-color"];
+      walletTheme.colorPrimary = themeConfig["--pcm-body-background"];
+      walletTheme.colorOnPrimary = themeConfig["--pcm-primary-button-color"];
+      walletTheme.primaryButtonBackgroundColors = [
+        themeConfig["--pcm-primary-button-bankground"],
+        themeConfig["--pcm-primary-button-hover-background"]
+      ];
+      walletTheme.primaryIconButtonBackgroundColors = [
+        themeConfig["--pcm-accent-color"],
+        themeConfig["--pcm-accent-color"]
+      ];
+      walletTheme.primaryIconTextColor = themeConfig["--pcm-secondary-button-color"];
+      walletTheme.primaryButtonTextColor = themeConfig["--pcm-primary-button-color"];
+      walletTheme.cancelButtonBackgroundColor = themeConfig["--pcm-secondary-button-bankground"];
+      walletTheme.backgroundColors = [
+        themeConfig["--pcm-body-background-secondary"],
+        [
+          [themeConfig["--pcm-body-background"], themeConfig["--pcm-body-background"]],
+          [themeConfig["--pcm-body-background"], themeConfig["--pcm-body-background"]]
+        ]
+      ];
+      walletTheme.messageColors = [themeConfig["--pcm-success-color"], themeConfig["--pcm-error-color"]];
+      walletTheme.borderGlowColors = [themeConfig["--pcm-accent-color"], themeConfig["--pcm-body-color"]];
+      walletTheme.modalMaskBackgroundColor = themeConfig["--pcm-overlay-background"];
+      walletTheme.cardBorderRadius = parseInt(themeConfig["--pcm-rounded-xl"]);
+      const options = {
+        themeType: theme,
+        customStyle: {
+          [theme]: walletTheme
+        },
+        language: appearance?.language
+      };
+      return options;
+    };
+    mergeThemes = (base2, override) => {
+      const result = { ...base2 };
+      Object.keys(override).forEach((key) => {
+        if (Object.prototype.hasOwnProperty.call(override, key) && override[key] !== "") {
+          result[key] = override[key];
+        }
+      });
+      return result;
+    };
+    getAuthCoreTheme = (appearance) => {
+      let theme = appearance?.mode ?? getSystemMode();
+      if (theme === "auto") {
+        theme = getSystemMode();
+      }
+      let themeConfig = theme === "light" ? light_default : dark_default;
+      themeConfig = mergeThemes({ ...themeGlobals.default, ...themeConfig }, appearance?.theme || {});
+      const authTheme = {
+        primaryBtnColor: themeConfig["--pcm-primary-button-color"],
+        primaryBtnBackgroundColor: themeConfig["--pcm-primary-button-bankground"],
+        textColor: themeConfig["--pcm-body-color"],
+        secondaryTextColor: themeConfig["--pcm-body-color-secondary"],
+        themeBackgroundColor: themeConfig["--pcm-body-background"],
+        iconBorderColor: themeConfig["--pcm-button-border-color"],
+        accentColor: themeConfig["--pcm-accent-color"],
+        inputBackgroundColor: themeConfig["--pcm-body-background-secondary"],
+        inputBorderColor: themeConfig["--pcm-button-border-color"],
+        inputPlaceholderColor: themeConfig["--pcm-body-color-tertiary"],
+        cardBorderColor: themeConfig["--pcm-button-border-color"],
+        cardUnclickableBackgroundColor: themeConfig["--pcm-body-background-tertiary"],
+        cardUnclickableBorderColor: themeConfig["--pcm-button-border-color"],
+        cardDividerColor: themeConfig["--pcm-button-border-color"],
+        tagBackgroundColor: themeConfig["--pcm-body-background-secondary"],
+        modalBackgroundColor: themeConfig["--pcm-body-background"],
+        tipsBackgroundColor: themeConfig["--pcm-body-background-secondary"],
+        primaryBtnBorderRadius: themeConfig["--pcm-rounded-lg"],
+        cardBorderRadius: themeConfig["--pcm-rounded-md"],
+        modalBorderRadius: themeConfig["--pcm-rounded-lg"]
+      };
+      return authTheme;
+    };
+    themeGlobals = {
+      default: {
+        "--pcm-font-family": `-apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica,
+    'Apple Color Emoji', Arial, sans-serif, 'Segoe UI Emoji',
+    'Segoe UI Symbol'`,
+        "--pcm-overlay-backdrop-filter": "blur(6px)",
+        "--pcm-rounded-sm": "4px",
+        "--pcm-rounded-md": "8px",
+        "--pcm-rounded-lg": "11px",
+        "--pcm-rounded-xl": "22px",
+        "--pcm-rounded-full": "9999px",
+        "--pcm-error-color": "#EA4335",
+        "--pcm-error-background": hexToRgba("#EA4335", 0.2),
+        "--pcm-success-color": "#58C08F",
+        "--pcm-success-background": hexToRgba("#58C08F", 0.2),
+        "--pcm-warning-color": "#F59E0A",
+        "--pcm-warning-background": hexToRgba("#F59E0A", 0.2),
+        "--pcm-wallet-lable-color": "#33C759",
+        "--pcm-wallet-lable-background": hexToRgba("#33C759", 0.2)
+      }
+    };
+    themeColors = {
+      light: themes_default.base.light,
+      dark: themes_default.base.dark
+    };
+    createCssVars = (scheme, override) => {
+      const important = override ? " !important" : "";
+      return css`
+    ${Object.keys(scheme).map((key) => {
+        const value = scheme[key];
+        return value && `${key}:${value}${important};`;
+      })}
+  `;
+    };
+    themes = {
+      default: createCssVars(themeGlobals.default),
+      light: createCssVars(themeColors.light),
+      dark: createCssVars(themeColors.dark)
+    };
+    mode = "auto";
+    ThemeContainer = styled(motion.div)`
+  ${themes.default}
+
+  ${(props) => {
+      if (props.$useMode === "light") {
+        mode = "light";
+        return themes.light;
+      } else if (props.$useMode === "dark") {
+        mode = "dark";
+        return themes.dark;
+      } else {
+        return css`
+        @media (prefers-color-scheme: light) {
+          ${themes.light}
+        }
+        @media (prefers-color-scheme: dark) {
+          ${themes.dark}
+        }
+      `;
+      }
+    }}
+  
+
+  ${(props) => {
+      if (props.$useTheme) {
+        return createCssVars(props.$useTheme, true);
+      }
+      return void 0;
+    }}
+
+
+  ${(props) => {
+      if (props.$useTheme) {
+        const merge = {};
+        if (props.$useTheme["--pcm-success-color"]) {
+          merge["--pcm-success-background"] = hexToRgba(props.$useTheme["--pcm-success-color"], 0.2);
+        }
+        if (props.$useTheme["--pcm-warning-color"]) {
+          merge["--pcm-warning-background"] = hexToRgba(props.$useTheme["--pcm-warning-color"], 0.2);
+        }
+        if (props.$useTheme["--pcm-error-color"]) {
+          merge["--pcm-error-background"] = hexToRgba(props.$useTheme["--pcm-error-color"], 0.2);
+        }
+        if (props.$useTheme["--pcm-wallet-lable-color"]) {
+          merge["--pcm-wallet-lable-background"] = hexToRgba(props.$useTheme["--pcm-wallet-lable-color"], 0.2);
+        }
+        return createCssVars(merge, true);
+      }
+      return void 0;
+    }}
+
+
+  all: initial;
+  text-align: left;
+  text-direction: ltr;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: auto;
+  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+  -webkit-text-stroke: 0.001px transparent;
+  text-size-adjust: none;
+  font-size: 16px;
+  color: var(--pcm-body-color);
+
+  &,
+  * {
+    font-family: var(--pcm-font-family);
+    box-sizing: border-box;
+
+    &:after,
+    &:before {
+      box-sizing: border-box;
+      border: 0 solid #e5e7eb;
+    }
+  }
+
+  img,
+  svg {
+    max-width: 100%;
+    overflow: visible;
+  }
+  strong {
+    font-weight: 600;
+  }
+  input:focus-visible,
+  a:focus-visible,
+  button:focus-visible {
+    outline: 1px solid var(--pcm-focus-color, var(--pcm-accent-color));
+  }
+
+  input {
+    caret-color: var(--pcm-focus-color, var(--pcm-accent-color));
+  }
+
+  @keyframes spin {
+    0% {
+      transform: rotate(0deg);
+    }
+    100% {
+      transform: rotate(360deg);
+    }
+  }
+`;
+  }
+});
+
+// src/hooks/useAAPlugin.ts
+import { create as create4 } from "zustand";
+var useAAPlugin;
+var init_useAAPlugin = __esm({
+  "src/hooks/useAAPlugin.ts"() {
+    "use strict";
+    useAAPlugin = create4((set) => ({
+      smartAccount: null,
+      setSmartAccount: (value) => {
+        set({ smartAccount: value });
+      }
+    }));
+  }
+});
+
+// src/actions/getConnections.ts
+function getConnections(config) {
+  if (config.state.status === "reconnecting")
+    return previousConnections;
+  const connections = [...config.state.connections.values()];
+  const current = config.state.current;
+  connections.sort((a, b) => {
+    if (a.connector.uid === current) {
+      return -1;
+    }
+    if (b.connector.uid === current) {
+      return 1;
+    }
+    return 0;
+  });
+  if (deepEqual(previousConnections, connections))
+    return previousConnections;
+  previousConnections = connections;
+  return connections;
+}
+var previousConnections;
+var init_getConnections = __esm({
+  "src/actions/getConnections.ts"() {
+    "use strict";
+    init_deepEqual();
+    previousConnections = [];
+  }
+});
+
+// src/actions/watchConnections.ts
+function watchConnections(config, parameters) {
+  const { onChange } = parameters;
+  return config.subscribe(() => getConnections(config), onChange, {
+    equalityFn: deepEqual
+  });
+}
+var init_watchConnections = __esm({
+  "src/actions/watchConnections.ts"() {
+    "use strict";
+    init_deepEqual();
+    init_getConnections();
+  }
+});
+
+// src/hooks/useConnections.ts
+import { useSyncExternalStore } from "react";
+function useConnections() {
+  const { config } = useContext();
+  return useSyncExternalStore(
+    (onChange) => watchConnections(config, { onChange }),
+    () => getConnections(config),
+    () => getConnections(config)
+  );
+}
+var init_useConnections = __esm({
+  "src/hooks/useConnections.ts"() {
+    "use strict";
+    init_getConnections();
+    init_watchConnections();
+    init_context();
+  }
+});
+
+// src/config/wallet.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var walletConfigs, isCoinbase, isWalletConnect, isPasskeySmartWallet;
+var init_wallet = __esm({
+  "src/config/wallet.tsx"() {
+    "use strict";
+    init_PasskeyIcon();
+    init_BitKeep();
+    init_Brave();
+    init_Bybit();
+    init_Coin98();
+    init_Coinbase();
+    init_Frontier();
+    init_ImToken();
+    init_InfinityWallet();
+    init_Injected();
+    init_Ledger();
+    init_MetaMask();
+    init_OKX();
+    init_ONTO();
+    init_Onekey();
+    init_Phantom();
+    init_Rabby();
+    init_Rainbow();
+    init_SafePal();
+    init_Slope();
+    init_Talisman();
+    init_TokenPocket();
+    init_Trust();
+    init_WalletConnect();
+    init_Zerion();
+    init_utils();
+    walletConfigs = {
+      "particleEVM, particleSolana, network.particle": {
+        name: "Particle Auth",
+        iconShape: "circle"
+      },
+      "coinbaseWallet, coinbaseWalletSDK, com.coinbase.wallet": {
+        name: "Coinbase Wallet",
+        shortName: "Coinbase",
+        icon: /* @__PURE__ */ jsx2(Coinbase_default, {}),
+        iconShape: "squircle",
+        downloadUrls: {
+          website: "https://www.coinbase.com/wallet/getting-started-extension",
+          chrome: "https://chrome.google.com/webstore/detail/coinbase-wallet-extension/hnfanknocfeofbddgcijnmhnfnkdnaad",
+          brave: "https://chromewebstore.google.com/detail/coinbase-wallet-extension/hnfanknocfeofbddgcijnmhnfnkdnaad",
+          android: "https://play.google.com/store/apps/details?id=org.toshi",
+          ios: "https://apps.apple.com/app/coinbase-wallet-store-crypto/id1278383455"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return uri;
+        },
+        getDAppBrowserDeeplink: (uri) => {
+          return `https://go.cb-w.com/dapp?cb_url=${encodeURIComponent(uri)}`;
+        }
+      },
+      "metaMask, io.metamask, io.metamask.mobile": {
+        name: "MetaMask",
+        icon: /* @__PURE__ */ jsx2(MetaMask_default, {}),
+        iconShouldShrink: true,
+        downloadUrls: {
+          website: "https://metamask.io/download/",
+          chrome: "https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn",
+          firefox: "https://addons.mozilla.org/firefox/addon/ether-metamask/",
+          brave: "https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn",
+          edge: "https://microsoftedge.microsoft.com/addons/detail/metamask/ejbalbakoplchlghecdalmeeeajnimhm",
+          android: "https://play.google.com/store/apps/details?id=io.metamask",
+          ios: "https://apps.apple.com/app/metamask/id1438144202"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return isAndroid() || isIOS() ? `metamask://wc?uri=${encodeURIComponent(uri)}` : `https://metamask.app.link/wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      "phantom, app.phantom": {
+        name: "Phantom",
+        iconShape: "squircle",
+        icon: /* @__PURE__ */ jsx2(Phantom_default, {}),
+        downloadUrls: {
+          website: "https://phantom.app/download",
+          chrome: "https://chromewebstore.google.com/detail/phantom/bfnaelmomeimhlpmgjnjophhpkkoljpa",
+          brave: "https://chromewebstore.google.com/detail/phantom/bfnaelmomeimhlpmgjnjophhpkkoljpa",
+          firefox: "https://addons.mozilla.org/en-US/firefox/addon/phantom-app/",
+          android: "https://play.google.com/store/apps/details?id=app.phantom",
+          ios: "https://apps.apple.com/us/app/phantom-crypto-wallet/id1598432977"
+        },
+        getDAppBrowserDeeplink: (uri) => {
+          return `https://phantom.app/ul/browse/${encodeURIComponent(uri)}?ref=${encodeURIComponent(window.location.origin)}`;
+        }
+      },
+      "okxWallet, oKExWallet, com.okex.wallet": {
+        name: "OKX Wallet",
+        shortName: "OKX",
+        iconShape: "squircle",
+        icon: /* @__PURE__ */ jsx2(OKX_default, {}),
+        downloadUrls: {
+          website: "https://www.okx.com/download",
+          chrome: "https://chromewebstore.google.com/detail/%E6%AC%A7%E6%98%93-web3-%E9%92%B1%E5%8C%85/mcohilncbfahbmgdjkbpemcciiolgcge",
+          edge: "https://microsoftedge.microsoft.com/addons/detail/okx-wallet/pbpjkcldjiffchgbbndmhojiacbgflha",
+          brave: "https://chromewebstore.google.com/detail/%E6%AC%A7%E6%98%93-web3-%E9%92%B1%E5%8C%85/mcohilncbfahbmgdjkbpemcciiolgcge",
+          android: "https://play.google.com/store/apps/details?id=com.okinc.okex.gp",
+          ios: "https://apps.apple.com/us/app/okx-buy-bitcoin-btc-crypto/id1327268470"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return `okex://main/wc?uri=${encodeURIComponent(uri)}`;
+        },
+        getDAppBrowserDeeplink: (uri) => {
+          const deepLink = `okx://wallet/dapp/url?dappUrl=${encodeURIComponent(uri)}`;
+          return `https://www.okx.com/download?deeplink=${encodeURIComponent(deepLink)}`;
+        }
+      },
+      "bitKeep, bitget, com.bitget.web3": {
+        name: "Bitget Wallet",
+        shortName: "Bitget",
+        iconShape: "circle",
+        icon: /* @__PURE__ */ jsx2(BitKeep_default, {}),
+        downloadUrls: {
+          website: "https://web3.bitget.com/wallet-download",
+          chrome: "https://chromewebstore.google.com/detail/bitget-wallet-formerly-bi/jiidiaalihmmhddjgbnbgdfflelocpak",
+          android: "https://play.google.com/store/apps/details?id=com.bitkeep.wallet",
+          ios: "https://apps.apple.com/us/app/bitget-wallet-ex-bitkeep/id1395301115"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return `bitkeep://wc?uri=${encodeURIComponent(uri)}`;
+        },
+        getDAppBrowserDeeplink: (uri) => {
+          return `https://bkcode.vip?action=dapp&url=${encodeURIComponent(uri)}`;
+        }
+      },
+      "rabby, io.rabby": {
+        name: "Rabby Wallet",
+        shortName: "Rabby",
+        icon: /* @__PURE__ */ jsx2(Rabby_default, {}),
+        downloadUrls: {
+          website: "https://rabby.io",
+          chrome: "https://chrome.google.com/webstore/detail/rabby-wallet/acmacodkjbdgmoleebolmdjonilkdbch"
+        }
+      },
+      "rainbow, me.rainbow": {
+        name: "Rainbow Wallet",
+        shortName: "Rainbow",
+        icon: /* @__PURE__ */ jsx2(Rainbow_default, {}),
+        iconShape: "squircle",
+        downloadUrls: {
+          website: "https://rainbow.me/?utm_source=connectkit",
+          chrome: "https://chrome.google.com/webstore/detail/opfgelmcmbiajamepnmloijbpoleiama",
+          edge: "https://microsoftedge.microsoft.com/addons/detail/cpojfbodiccabbabgimdeohkkpjfpbnf",
+          firefox: "https://addons.mozilla.org/firefox/addon/rainbow-extension",
+          brave: "https://rainbow.me/extension?utm_source=connectkit",
+          android: "https://play.google.com/store/apps/details?id=me.rainbow",
+          ios: "https://apps.apple.com/app/id1457119021"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return isAndroid() || isIOS() ? `rainbow://wc?uri=${encodeURIComponent(uri)}&connector=rainbowkit` : `https://rnbwapp.com/wc?uri=${encodeURIComponent(uri)}&connector=rainbowkit`;
+        }
+      },
+      "talisman, xyz.talisman": {
+        name: "Talisman",
+        shortName: "Talisman",
+        icon: /* @__PURE__ */ jsx2(Talisman_default, {}),
+        iconShape: "squircle",
+        downloadUrls: {
+          website: "https://talisman.xyz",
+          chrome: "https://chrome.google.com/webstore/detail/talisman-polkadot-wallet/fijngjgcjhjmmpcmkeiomlglpeiijkld",
+          firefox: "https://addons.mozilla.org/en-US/firefox/addon/talisman-wallet-extension/",
+          brave: "https://chromewebstore.google.com/detail/talisman-ethereum-and-pol/fijngjgcjhjmmpcmkeiomlglpeiijkld"
+        }
+      },
+      "trust, trustWallet, com.trustwallet.app": {
+        name: "Trust Wallet",
+        shortName: "Trust",
+        icon: /* @__PURE__ */ jsx2(Trust_default, {}),
+        iconShouldShrink: true,
+        downloadUrls: {
+          website: "https://trustwallet.com/download",
+          chrome: "https://chromewebstore.google.com/detail/trust-wallet/egjidjbpglichdcondbcbdnbeeppgdph",
+          android: "https://play.google.com/store/apps/details?id=com.wallet.crypto.trustapp",
+          ios: "https://apps.apple.com/app/trust-crypto-bitcoin-wallet/id1288339409"
+        },
+        getWalletConnectDeeplink(uri) {
+          return isAndroid() || isIOS() ? `trust://wc?uri=${encodeURIComponent(uri)}` : `https://link.trustwallet.com/wc?uri=${encodeURIComponent(uri)}`;
+        },
+        getDAppBrowserDeeplink: (uri) => {
+          return `https://link.trustwallet.com/open_url?url=${encodeURIComponent(uri)}`;
+        }
+      },
+      "com.crypto.wallet": {
+        name: "Crypto.com",
+        shortName: "Crypto"
+      },
+      "frontier, xyz.frontier.wallet": {
+        name: "Frontier Wallet",
+        shortName: "Frontier",
+        icon: /* @__PURE__ */ jsx2(Frontier_default, {}),
+        downloadUrls: {
+          website: "https://www.frontier.xyz/download",
+          chrome: "https://chrome.google.com/webstore/detail/frontier-wallet/kppfdiipphfccemcignhifpjkapfbihd",
+          brave: "https://chromewebstore.google.com/detail/frontier-wallet/kppfdiipphfccemcignhifpjkapfbihd",
+          android: "https://play.google.com/store/apps/details?id=com.frontierwallet",
+          ios: "https://apps.apple.com/app/frontier-crypto-defi-wallet/id1482380988"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return `frontier://wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      infinityWallet: {
+        name: "Infinity Wallet",
+        icon: /* @__PURE__ */ jsx2(InfinityWallet_default, {}),
+        downloadUrls: {
+          website: "https://infinitywallet.io/download",
+          chrome: "https://infinitywallet.io/download",
+          firefox: "https://infinitywallet.io/download",
+          brave: "https://infinitywallet.io/download",
+          edge: "https://infinitywallet.io/download"
+        }
+      },
+      imToken: {
+        name: "imToken",
+        icon: /* @__PURE__ */ jsx2(ImToken_default, {}),
+        downloadUrls: {
+          website: "https://token.im/download",
+          android: "https://play.google.com/store/apps/details?id=im.token.app",
+          ios: "https://itunes.apple.com/us/app/imtoken2/id1384798940"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return `imtokenv2://wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      onto: {
+        name: "ONTO",
+        icon: /* @__PURE__ */ jsx2(ONTO_default, {}),
+        downloadUrls: {
+          website: "https://onto.app/en/download/",
+          chrome: "https://chromewebstore.google.com/detail/onto-wallet/ifckdpamphokdglkkdomedpdegcjhjdp",
+          ios: "https://apps.apple.com/app/onto-an-ontology-dapp/id1436009823",
+          android: "https://play.google.com/store/apps/details?id=com.github.ontio.onto"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return isAndroid() ? uri : `https://onto.app/wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      ledger: {
+        name: "Ledger Live",
+        shortName: "Ledger",
+        icon: /* @__PURE__ */ jsx2(Ledger_default, {}),
+        downloadUrls: {
+          website: "https://www.ledger.com/ledger-live/download#download-device-2",
+          android: "https://play.google.com/store/apps/details?id=com.ledger.live",
+          ios: "https://apps.apple.com/app/ledger-live-web3-wallet/id1361671700"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return `ledgerlive://wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      "zerion, io.zerion.wallet": {
+        name: "Zerion",
+        icon: /* @__PURE__ */ jsx2(Zerion_default, {}),
+        downloadUrls: {
+          website: "https://zerion.io/download",
+          chrome: "https://chromewebstore.google.com/detail/zerion-wallet-for-web3-nf/klghhnkeealcohjjanjjdaeeggmfmlpl",
+          brave: "https://chromewebstore.google.com/detail/zerion-wallet-for-web3-nf/klghhnkeealcohjjanjjdaeeggmfmlpl",
+          ios: "https://apps.apple.com/app/apple-store/id1456732565",
+          android: "https://play.google.com/store/apps/details?id=io.zerion.android"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return isAndroid() || isIOS() ? `zerion://wc?uri=${encodeURIComponent(uri)}` : `https://app.zerion.io/wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      slope: {
+        name: "Slope",
+        icon: /* @__PURE__ */ jsx2(Slope_default, {}),
+        downloadUrls: {
+          website: "https://slope.finance/",
+          chrome: "https://chrome.google.com/webstore/detail/slope-wallet/pocmplpaccanhmnllbbkpgfliimjljgo",
+          ios: "https://apps.apple.com/app/slope-wallet/id1574624530",
+          android: "https://play.google.com/store/apps/details?id=com.wd.wallet"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return isAndroid() ? uri : `https://slope.finance/app/wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      "tokenPocket, pro.tokenpocket": {
+        name: "TokenPocket",
+        icon: /* @__PURE__ */ jsx2(TokenPocket_default, {}),
+        downloadUrls: {
+          website: "https://www.tokenpocket.pro/en/download/app",
+          chrome: "https://chrome.google.com/webstore/detail/tokenpocket/mfgccjchihfkkindfppnaooecgfneiii",
+          android: "https://play.google.com/store/apps/details?id=vip.mytokenpocket",
+          ios: "https://apps.apple.com/us/app/tp-global-wallet/id6444625622"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return `tpoutside://wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      "safePal, https://www.safepal.com/download": {
+        name: "SafePal",
+        icon: /* @__PURE__ */ jsx2(SafePal_default, {}),
+        iconShape: "circle",
+        downloadUrls: {
+          website: "https://www.safepal.com/download",
+          chrome: "https://chrome.google.com/webstore/detail/lgmpcpglpngdoalbgeoldeajfclnhafa",
+          edge: "https://microsoftedge.microsoft.com/addons/detail/apenkfbbpmhihehmihndmmcdanacolnh",
+          firefox: "https://addons.mozilla.org/firefox/addon/safepal-extension-wallet",
+          android: "https://play.google.com/store/apps/details?id=io.safepal.wallet",
+          ios: "https://apps.apple.com/app/id1548297139"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return isAndroid() || isIOS() ? `safepalwallet://wc?uri=${encodeURIComponent(uri)}` : `https://link.safepal.io/wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      "coin98, coin98.com": {
+        name: "Coin98",
+        shortName: "Coin98",
+        icon: /* @__PURE__ */ jsx2(Coin98_default, {}),
+        iconShape: "circle",
+        downloadUrls: {
+          website: "https://coin98.com/wallet",
+          chrome: "https://chrome.google.com/webstore/detail/aeachknmefphepccionboohckonoeemg",
+          android: "https://play.google.com/store/apps/details?id=coin98.crypto.finance.media",
+          ios: "https://apps.apple.com/app/id1561969966"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return isAndroid() || isIOS() ? `coin98://wc?uri=${encodeURIComponent(uri)}` : `https://coin98.com/wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      "onekey, so.onekey.app.wallet": {
+        name: "OneKey",
+        icon: /* @__PURE__ */ jsx2(Onekey_default, {}),
+        iconShape: "squircle",
+        downloadUrls: {
+          website: "https://onekey.so/download/",
+          chrome: "https://chrome.google.com/webstore/detail/jnmbobjmhlngoefaiojfljckilhhlhcj",
+          android: "https://play.google.com/store/apps/details?id=so.onekey.app.wallet",
+          ios: "https://apps.apple.com/app/id1609559473"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return isAndroid() || isIOS() ? `onekey-wallet://wc?uri=${encodeURIComponent(uri)}` : `https://app.onekey.so/wc/connect/wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      "bybitWallet, com.bybit": {
+        name: "Bybit Wallet",
+        icon: /* @__PURE__ */ jsx2(Bybit_default, {}),
+        iconShape: "squircle",
+        downloadUrls: {
+          website: "https://www.bybit.com/en/download/",
+          chrome: "https://chrome.google.com/webstore/detail/pdliaogehgdbhbnmkklieghmmjkpigpa",
+          android: "https://play.google.com/store/apps/details?id=com.bybit.app",
+          ios: "https://apps.apple.com/app/id1488296980"
+        },
+        getWalletConnectDeeplink: (uri) => {
+          return `bybitapp://open/route?targetUrl=by://web3/walletconnect/wc?uri=${encodeURIComponent(uri)}`;
+        }
+      },
+      "braveWallet, com.brave.wallet": {
+        name: "Brave Wallet",
+        shortName: "Brave",
+        icon: /* @__PURE__ */ jsx2(Brave_default, {}),
+        iconShape: "squircle",
+        downloadUrls: {
+          website: "https://brave.com/download/"
+        },
+        getDAppBrowserDeeplink: (uri) => {
+          return `brave://open-url?url=${encodeURIComponent(uri)}`;
+        }
+      },
+      "mantaWallet,manta.network": {
+        name: "Manta Wallet",
+        iconShape: "circle"
+      },
+      walletConnect: {
+        name: "WalletConnect",
+        icon: /* @__PURE__ */ jsx2(WalletConnect_default, {}),
+        iconShape: "square",
+        getWalletConnectDeeplink: (uri) => uri
+      },
+      injected: {
+        name: "Browser Wallet",
+        shortName: "Browser",
+        icon: /* @__PURE__ */ jsx2(Injected_default, {})
+      },
+      passkeySmartWallet: {
+        name: "Passkey Smart Wallet",
+        shortName: "Passkey",
+        iconShape: "circle",
+        icon: /* @__PURE__ */ jsx2(PasskeyIcon_default, {})
+      }
+    };
+    isCoinbase = (id) => {
+      return ["coinbaseWallet", "coinbaseWalletSDK", "com.coinbase.wallet"].includes(id);
+    };
+    isWalletConnect = (id) => {
+      return "walletConnect" === id;
+    };
+    isPasskeySmartWallet = (id) => {
+      return "passkeySmartWallet" === id;
+    };
+  }
+});
+
+// src/actions/filterConnectors.ts
+var filterConnectors;
+var init_filterConnectors = __esm({
+  "src/actions/filterConnectors.ts"() {
+    "use strict";
+    init_wallet();
+    filterConnectors = (connectors) => {
+      return connectors.filter(
+        (connector, index, self) => self.findIndex((c) => c.id === connector.id && c.chainType === connector.chainType) === index
+      ).filter((connector, index, self) => {
+        if (connector.chainType === "solana") {
+          return true;
+        }
+        const isMipd = connector.id.includes(".");
+        if (isMipd) {
+          return true;
+        }
+        const groupId = Object.keys(walletConfigs).find(
+          (id) => id.split(",").map((i) => i.trim()).indexOf(connector.id) !== -1
+        );
+        if (groupId && groupId.includes(",")) {
+          const mipdIds = groupId.split(",").map((id) => id.trim()).filter((id) => id.includes("."));
+          const hasMipd = self.find((c) => mipdIds.includes(c.id));
+          return Boolean(!hasMipd);
+        }
+        return true;
+      });
+    };
+  }
+});
+
+// src/actions/reconnect.ts
+async function reconnect(config, parameters = {}) {
+  if (reconnectingConfigUid && reconnectingConfigUid === config.uid)
+    return [];
+  const status = reconnectingConfigUid ? "reconnecting" : void 0;
+  reconnectingConfigUid = config.uid;
+  config.setState((x) => ({
+    ...x,
+    status: x.current || status ? "reconnecting" : "connecting"
+  }));
+  const connectors = [];
+  if (parameters.connectors?.length) {
+    connectors.push(...parameters.connectors);
+  } else {
+    const configConnectors = config.connectors;
+    connectors.push(...filterConnectors(configConnectors));
+  }
+  let recentConnectorId;
+  try {
+    recentConnectorId = await config.storage?.getItem("recentConnectorId");
+  } catch {
+  }
+  const scores = {};
+  for (const [, connection] of config.state.connections) {
+    scores[connection.connector.id] = 1;
+  }
+  if (recentConnectorId)
+    scores[recentConnectorId] = 0;
+  const sorted = Object.keys(scores).length > 0 ? [...connectors].sort((a, b) => (scores[a.id] ?? 10) - (scores[b.id] ?? 10)) : connectors;
+  let connected = false;
+  const connections = [];
+  const providers = [];
+  for (const connector of sorted) {
+    const provider_ = await connector.getProvider().catch(() => void 0);
+    if (!provider_)
+      continue;
+    if (providers.some((provider) => provider === provider_))
+      continue;
+    const isAuthorized = await connector.isAuthorized();
+    if (!isAuthorized)
+      continue;
+    const data = await connector.connect({ isReconnecting: true }).catch(() => null);
+    if (!data)
+      continue;
+    connector.emitter.off("connect", config._internal.events.connect);
+    connector.emitter.on("change", config._internal.events.change);
+    connector.emitter.on("disconnect", config._internal.events.disconnect);
+    config.setState((x) => {
+      const connections2 = new Map(connected ? x.connections : /* @__PURE__ */ new Map()).set(connector.uid, {
+        accounts: data.accounts,
+        chainId: data.chainId,
+        connector
+      });
+      return {
+        ...x,
+        current: connected ? x.current : connector.uid,
+        connections: connections2
+      };
+    });
+    connections.push({
+      accounts: data.accounts,
+      chainId: data.chainId,
+      connector
+    });
+    providers.push(provider_);
+    connected = true;
+  }
+  if (config.state.status === "reconnecting" || config.state.status === "connecting") {
+    if (!connected) {
+      config.setState((x) => ({
+        ...x,
+        connections: /* @__PURE__ */ new Map(),
+        current: null,
+        status: "disconnected"
+      }));
+    } else {
+      config.setState((x) => ({ ...x, status: "connected" }));
+    }
+  }
+  reconnectingConfigUid = void 0;
+  return connections;
+}
+var reconnectingConfigUid;
+var init_reconnect = __esm({
+  "src/actions/reconnect.ts"() {
+    "use strict";
+    init_filterConnectors();
+  }
+});
+
+// src/utils/hydrate.ts
+function hydrate(config, parameters) {
+  const { reconnectOnMount } = parameters;
+  return {
+    async onMount() {
+      if (reconnectOnMount) {
+        reconnect(config);
+      } else if (config.storage) {
+        config.setState((x) => ({
+          ...x,
+          connections: /* @__PURE__ */ new Map()
+        }));
+      }
+    }
+  };
+}
+var init_hydrate = __esm({
+  "src/utils/hydrate.ts"() {
+    "use strict";
+    init_reconnect();
+  }
+});
+
+// src/context/modalProvider/index.tsx
+import React, { createContext, useEffect as useEffect2, useMemo as useMemo3, useRef as useRef2 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var ModalContext, reconnectConfigUid, ModalProvider;
+var init_modalProvider = __esm({
+  "src/context/modalProvider/index.tsx"() {
+    "use strict";
+    init_context();
+    init_useAAPlugin();
+    init_useAccount();
+    init_useAppearance();
+    init_useConnections();
+    init_styles();
+    init_hydrate();
+    ModalContext = createContext(null);
+    ModalProvider = (props) => {
+      const { reconnectOnMount } = props;
+      const { config } = useContext();
+      const connections = useConnections();
+      const account = useAccount();
+      const { appearance } = useAppearance();
+      const setSmartAccount = useAAPlugin((state) => state.setSmartAccount);
+      const handlePlugin = async (connections2, plugins) => {
+        const result = connections2.filter((connection) => connection.connector && connection.connector.getProvider);
+        for (const plugin of plugins) {
+          if (result.length) {
+            await plugin.onConnect?.(result);
+          } else {
+            await plugin.onDisconnect?.();
+          }
+        }
+        const aaPlugin = config.plugins.find((plugin) => plugin.id === "aa");
+        setSmartAccount(aaPlugin?.smartAccount ?? null);
+      };
+      useEffect2(() => {
+      }, [account]);
+      const reconnectRef = useRef2(false);
+      const { onMount } = hydrate(config, {
+        reconnectOnMount
+      });
+      if (!reconnectRef.current) {
+        reconnectRef.current = true;
+        reconnectConfigUid = config.uid;
+        onMount();
+      }
+      useEffect2(() => {
+        if (config.uid !== reconnectConfigUid) {
+          reconnectConfigUid = config.uid;
+          onMount();
+        }
+      }, [config.uid, onMount]);
+      const walletPlugin = useMemo3(() => {
+        const plugin = config.plugins.find((plugin2) => plugin2.id === "wallet");
+        if (plugin) {
+          return plugin;
+        }
+        return void 0;
+      }, [config.plugins]);
+      useEffect2(() => {
+        if (walletPlugin) {
+          const aaPlugin = config.plugins.find((plugin) => plugin.id === "aa");
+          const erc4337 = aaPlugin ? aaPlugin.erc4337 : void 0;
+          walletPlugin.init({
+            erc4337
+          });
+        }
+      }, [walletPlugin, config.plugins]);
+      useEffect2(() => {
+        if (walletPlugin) {
+          const walletOption = getWalletOption(appearance);
+          walletPlugin.overrideWalletOption({
+            ...walletOption,
+            language: appearance.language
+          });
+        }
+      }, [appearance, walletPlugin]);
+      useEffect2(() => {
+        handlePlugin(connections, config.plugins);
+      }, [connections, config.plugins]);
+      return /* @__PURE__ */ jsx3(ModalContext.Provider, { value: {}, children: props.children });
+    };
+  }
+});
+
+// src/actions/getSolanaWalletClient.ts
+import {
+  ChainTypeError,
+  ConnectorAccountNotFoundError,
+  ConnectorNotConnectedError,
+  sendSolanaTransaction
+} from "@particle-network/connector-core";
+var getSolanaWalletClient;
+var init_getSolanaWalletClient = __esm({
+  "src/actions/getSolanaWalletClient.ts"() {
+    "use strict";
+    getSolanaWalletClient = async (config, parameters = {}) => {
+      let connection;
+      if (parameters.connector) {
+        const { connector: connector2 } = parameters;
+        const [accounts, chainId2] = await Promise.all([connector2.getAccounts(), connector2.getChainId()]);
+        connection = {
+          accounts,
+          chainId: chainId2,
+          connector: connector2
+        };
+      } else
+        connection = config.state.connections.get(config.state.current);
+      if (!connection)
+        throw new ConnectorNotConnectedError();
+      const chainId = parameters.chainId ?? connection.chainId;
+      const connector = connection.connector;
+      if (connector.chainType !== "solana") {
+        throw new ChainTypeError();
+      }
+      const provider = await connector.getProvider();
+      const account = parameters.account ?? connection.accounts[0];
+      const chain = config.chains.find((chain2) => chain2.id === chainId);
+      const clientConnection = config.getWalletConnector(connector.walletConnectorType).getClient(chain?.id || 101);
+      if (parameters.account && !connection.accounts.some((x) => x.toLowerCase() === account.toLowerCase()))
+        throw new ConnectorAccountNotFoundError({
+          address: account,
+          connector
+        });
+      return {
+        publicKey: provider.publicKey,
+        chain,
+        async signTransaction(transaction) {
+          return await provider.signTransaction(transaction);
+        },
+        async signAllTransactions(transactions) {
+          return await provider.signAllTransactions(transactions);
+        },
+        async sendTransaction(transaction, options = {}) {
+          if (connector.walletConnectorType === "particleAuth") {
+            const result = await provider.signAndSendTransaction(transaction);
+            return result;
+          }
+          return await sendSolanaTransaction(provider, transaction, clientConnection, options);
+        },
+        async signMessage(message) {
+          const { signature } = await provider.signMessage(message);
+          return { signature };
+        },
+        async switchChain(chainId2) {
+          return await connector.switchChain({ chainId: chainId2 });
+        }
+      };
+    };
+  }
+});
+
+// src/actions/getConnectorClient.ts
+import {
+  ChainTypeError as ChainTypeError2,
+  ConnectorAccountNotFoundError as ConnectorAccountNotFoundError2,
+  ConnectorNotConnectedError as ConnectorNotConnectedError2
+} from "@particle-network/connector-core";
+import {
+  createClient,
+  custom
+} from "viem";
+import { getAddress, parseAccount } from "viem/utils";
+async function getConnectorClient(config, parameters = {}) {
+  let connection;
+  if (parameters.connector) {
+    const { connector: connector2 } = parameters;
+    const [accounts, chainId2] = await Promise.all([connector2.getAccounts(), connector2.getChainId()]);
+    connection = {
+      accounts,
+      chainId: chainId2,
+      connector: connector2
+    };
+  } else
+    connection = config.state.connections.get(config.state.current);
+  if (!connection)
+    throw new ConnectorNotConnectedError2();
+  const chainId = parameters.chainId ?? connection.chainId;
+  const connector = connection.connector;
+  if (connector.chainType !== "evm") {
+    throw new ChainTypeError2();
+  }
+  const account = parseAccount(parameters.account ?? connection.accounts[0]);
+  account.address = getAddress(account.address);
+  const chain = config.chains.find((chain2) => chain2.id === chainId);
+  const provider = await connection.connector.getProvider({ chainId });
+  if (parameters.account && !connection.accounts.some((x) => x.toLowerCase() === account.address.toLowerCase()))
+    throw new ConnectorAccountNotFoundError2({
+      address: account.address,
+      connector
+    });
+  return createClient({
+    account,
+    chain,
+    name: "Connector Client",
+    transport: (opts) => custom(provider)({ ...opts, retryCount: 0 })
+  });
+}
+var init_getConnectorClient = __esm({
+  "src/actions/getConnectorClient.ts"() {
+    "use strict";
+  }
+});
+
+// src/actions/getWalletClient.ts
+import { walletActions } from "viem";
+async function getWalletClient(config, parameters = {}) {
+  const client = await getConnectorClient(config, parameters);
+  client.extend(walletActions);
+  return client.extend(walletActions);
+}
+var init_getWalletClient = __esm({
+  "src/actions/getWalletClient.ts"() {
+    "use strict";
+    init_getConnectorClient();
+  }
+});
+
+// src/actions/mapWalletClient.ts
+var mapWalletClient;
+var init_mapWalletClient = __esm({
+  "src/actions/mapWalletClient.ts"() {
+    "use strict";
+    init_getSolanaWalletClient();
+    init_getWalletClient();
+    mapWalletClient = async (parameters) => {
+      const { connections, config } = parameters;
+      const wallets = [];
+      for (const connection of connections) {
+        if (!connection.connector.walletConnectorType) {
+          continue;
+        }
+        if (connection.connector.chainType === "evm") {
+          const client = await getWalletClient(config, { connector: connection.connector });
+          const wallet = {
+            ...connection,
+            getWalletClient: () => client
+          };
+          wallets.push(wallet);
+        } else {
+          const client = await getSolanaWalletClient(config, { connector: connection.connector });
+          const wallet = {
+            ...connection,
+            getWalletClient: () => client
+          };
+          wallets.push(wallet);
+        }
+      }
+      return wallets;
+    };
+  }
+});
+
+// src/hooks/useMutation.ts
+import { useCallback as useCallback3, useState } from "react";
+var useMutation;
+var init_useMutation = __esm({
+  "src/hooks/useMutation.ts"() {
+    "use strict";
+    useMutation = (mutationFn, options) => {
+      const [status, setStatus] = useState("idle");
+      const [data, setData] = useState(null);
+      const [error, setError] = useState(null);
+      const mutateAsync = useCallback3(
+        async (variables) => {
+          if (options?.onMutate) {
+            options.onMutate(variables);
+          }
+          setStatus("loading");
+          setData(null);
+          setError(null);
+          try {
+            const result = await mutationFn(variables);
+            setData(result);
+            setStatus("success");
+            if (options?.onSuccess) {
+              options.onSuccess(result);
+            }
+            if (options?.onSettled) {
+              options.onSettled(result, null);
+            }
+            return result;
+          } catch (err) {
+            setError(err);
+            setStatus("error");
+            if (options?.onError) {
+              options.onError(err);
+            }
+            if (options?.onSettled) {
+              options.onSettled(null, err);
+            }
+            throw err;
+          }
+        },
+        [mutationFn, options]
+      );
+      const mutate = useCallback3(
+        (variables) => {
+          mutateAsync(variables).catch(() => {
+          });
+        },
+        [mutateAsync]
+      );
+      return { status, data, error, mutate, mutateAsync };
+    };
+  }
+});
+
+// src/context/web3Provider/index.tsx
+import React2, { createContext as createContext2, useEffect as useEffect3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var Web3Context, Web3Provder, useWeb3Context;
+var init_web3Provider = __esm({
+  "src/context/web3Provider/index.tsx"() {
+    "use strict";
+    init_context();
+    init_mapWalletClient();
+    init_useConnections();
+    init_useMutation();
+    Web3Context = createContext2(null);
+    Web3Provder = ({ children }) => {
+      const connections = useConnections();
+      const { config } = useContext();
+      const { data: wallets, mutate: connectionMutate } = useMutation(mapWalletClient);
+      useEffect3(() => {
+        connectionMutate({ connections, config });
+      }, [connections]);
+      return /* @__PURE__ */ jsx4(
+        Web3Context.Provider,
+        {
+          value: {
+            wallets: wallets || []
+          },
+          children
+        }
+      );
+    };
+    useWeb3Context = () => {
+      const context = React2.useContext(Web3Context);
+      if (!context)
+        throw Error("Web3 Hook must be inside a Provider.");
+      return context;
+    };
+  }
+});
+
+// src/context/index.tsx
+import React3, { createContext as createContext3, useMemo as useMemo4 } from "react";
+import { jsx as jsx5, jsxs } from "react/jsx-runtime";
+var Context, ConnectKitProvider, useContext;
+var init_context = __esm({
+  "src/context/index.tsx"() {
+    "use strict";
+    init_connectModal();
+    init_useAppearance();
+    init_styles();
+    init_theme();
+    init_modalProvider();
+    init_web3Provider();
+    Context = createContext3(null);
+    ConnectKitProvider = (parameters) => {
+      if (React3.useContext(Context)) {
+        throw new Error("Multiple, nested usages of ConnectKitProvider detected. Please use only one.");
+      }
+      const { children, config, reconnectOnMount = true } = parameters;
+      const { appearance } = useAppearance(config);
+      const { AuthCoreContextProvider, authOptions } = useMemo4(() => {
+        const authWalletConnector = config.getWalletConnector("particleAuth");
+        const aaPlugin = config.plugins.find((plugin) => plugin.id === "aa");
+        const erc4337 = aaPlugin ? aaPlugin.erc4337 : void 0;
+        let theme = appearance?.mode ?? getSystemMode();
+        if (theme === "auto") {
+          theme = getSystemMode();
+        }
+        return {
+          AuthCoreContextProvider: authWalletConnector?.AuthCoreContextProvider ?? React3.Fragment,
+          authOptions: authWalletConnector ? {
+            options: {
+              themeType: theme,
+              ...authWalletConnector.authOptions,
+              customStyle: {
+                ...authWalletConnector.authOptions?.customStyle,
+                theme: {
+                  [theme]: getAuthCoreTheme(appearance)
+                }
+              },
+              erc4337
+            }
+          } : void 0
+        };
+      }, [config, appearance]);
+      return /* @__PURE__ */ jsx5(
+        Context.Provider,
+        {
+          value: {
+            options: config.options,
+            config
+          },
+          children: /* @__PURE__ */ jsx5(AuthCoreContextProvider, { ...authOptions, children: /* @__PURE__ */ jsxs(Web3Provder, { children: [
+            children,
+            /* @__PURE__ */ jsx5(ModalProvider, { reconnectOnMount, children: /* @__PURE__ */ jsx5(connectModal_default, {}) })
+          ] }) })
+        }
+      );
+    };
+    useContext = () => {
+      const context = React3.useContext(Context);
+      if (!context)
+        throw Error("ConnectKit Hook must be inside a Provider.");
+      return context;
+    };
+  }
+});
+
+// src/hooks/useAppearance.ts
+import { useCallback as useCallback4, useSyncExternalStore as useSyncExternalStore2 } from "react";
+function getAppearance(config) {
+  const appearance = { ...config.appearanceStore.getState() };
+  if (deepEqual(previousAppearance, appearance))
+    return previousAppearance;
+  previousAppearance = appearance;
+  return appearance;
+}
+function useAppearance(config) {
+  if (!config) {
+    const { config: globalConfig } = useContext();
+    config = globalConfig;
+  }
+  const setAppearance = useCallback4(
+    (value) => {
+      config.appearanceStore.setState(value || {}, true);
+    },
+    [config.appearanceStore]
+  );
+  const appearance = useSyncExternalStore2(
+    config.appearanceStore.subscribe,
+    () => getAppearance(config),
+    () => getAppearance(config)
+  );
+  return {
+    appearance,
+    setAppearance
+  };
+}
+var previousAppearance;
+var init_useAppearance = __esm({
+  "src/hooks/useAppearance.ts"() {
+    "use strict";
+    init_context();
+    init_deepEqual();
+    previousAppearance = {};
+  }
+});
+
+// src/hooks/useIconColor.ts
+import { useEffect as useEffect4, useMemo as useMemo5, useState as useState2 } from "react";
+var useIconColor, useIconColor_default;
+var init_useIconColor = __esm({
+  "src/hooks/useIconColor.ts"() {
+    "use strict";
+    init_theme();
+    init_useAppearance();
+    useIconColor = () => {
+      const [currentMode, setCurrentMode] = useState2();
+      const { appearance } = useAppearance();
+      useEffect4(() => {
+        if (appearance?.mode && appearance?.mode !== "auto") {
+          setCurrentMode(appearance?.mode);
+        } else {
+          setCurrentMode(getSystemMode());
+        }
+      }, [appearance?.mode]);
+      const foreground = useMemo5(() => {
+        if (currentMode === "dark") {
+          return "#000000";
+        } else {
+          return "#ffffff";
+        }
+      }, [currentMode]);
+      const background = useMemo5(() => {
+        if (currentMode === "dark") {
+          return "#ffffff";
+        } else {
+          return "#000000";
+        }
+      }, [currentMode]);
+      return { foreground, background, currentMode };
+    };
+    useIconColor_default = useIconColor;
+  }
+});
+
+// src/assets/wallets/Trust.tsx
+import { useMemo as useMemo6 } from "react";
+import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+var Trust, Trust_default;
+var init_Trust = __esm({
+  "src/assets/wallets/Trust.tsx"() {
+    init_useIconColor();
+    Trust = ({ ...props }) => {
+      const { currentMode } = useIconColor_default();
+      const id = useMemo6(() => {
+        return Math.random().toString(36).substring(7);
+      }, []);
+      const id2 = useMemo6(() => {
+        return Math.random().toString(36).substring(7);
+      }, []);
+      return currentMode === "light" ? /* @__PURE__ */ jsxs2("svg", { xmlns: "http://www.w3.org/2000/svg", width: "22", height: "24", viewBox: "0 0 22 24", fill: "none", ...props, children: [
+        /* @__PURE__ */ jsx6(
+          "path",
+          {
+            d: "M0.286133 3.46686L10.9995 0V24C3.34699 20.7997 0.286133 14.6664 0.286133 11.2003V3.46686Z",
+            fill: "#0500FF"
+          }
+        ),
+        /* @__PURE__ */ jsx6(
+          "path",
+          {
+            d: "M21.7137 3.46686L11.0004 0V24C18.6529 20.7997 21.7137 14.6664 21.7137 11.2003V3.46686Z",
+            fill: `url(#${id})`
+          }
+        ),
+        /* @__PURE__ */ jsx6("defs", { children: /* @__PURE__ */ jsxs2("linearGradient", { id, x1: "18.8679", y1: "-1.68063", x2: "10.8399", y2: "23.6925", gradientUnits: "userSpaceOnUse", children: [
+          /* @__PURE__ */ jsx6("stop", { offset: "0.02", stopColor: "#0000FF" }),
+          /* @__PURE__ */ jsx6("stop", { offset: "0.08", stopColor: "#0094FF" }),
+          /* @__PURE__ */ jsx6("stop", { offset: "0.16", stopColor: "#48FF91" }),
+          /* @__PURE__ */ jsx6("stop", { offset: "0.42", stopColor: "#0094FF" }),
+          /* @__PURE__ */ jsx6("stop", { offset: "0.68", stopColor: "#0038FF" }),
+          /* @__PURE__ */ jsx6("stop", { offset: "0.9", stopColor: "#0500FF" })
+        ] }) })
+      ] }) : /* @__PURE__ */ jsxs2("svg", { xmlns: "http://www.w3.org/2000/svg", width: "22", height: "24", viewBox: "0 0 22 24", fill: "none", ...props, children: [
+        /* @__PURE__ */ jsx6(
+          "path",
+          {
+            d: "M0.269531 3.46687L10.9994 0V24C3.33511 20.7997 0.269531 14.6664 0.269531 11.2003V3.46687Z",
+            fill: "#48FF91"
+          }
+        ),
+        /* @__PURE__ */ jsx6(
+          "path",
+          {
+            d: "M21.7305 3.46687L11.0006 0V24C18.6649 20.7997 21.7305 14.6664 21.7305 11.2003V3.46687Z",
+            fill: `url(#${id2})`
+          }
+        ),
+        /* @__PURE__ */ jsx6("defs", { children: /* @__PURE__ */ jsxs2("linearGradient", { id: id2, x1: "10.5475", y1: "27.0164", x2: "19.2341", y2: "-4.58841", gradientUnits: "userSpaceOnUse", children: [
+          /* @__PURE__ */ jsx6("stop", { offset: "0.26", stopColor: "#48FF91" }),
+          /* @__PURE__ */ jsx6("stop", { offset: "0.66", stopColor: "#0094FF" }),
+          /* @__PURE__ */ jsx6("stop", { offset: "0.8", stopColor: "#0038FF" }),
+          /* @__PURE__ */ jsx6("stop", { offset: "0.89", stopColor: "#0500FF" })
+        ] }) })
+      ] });
+    };
+    Trust_default = Trust;
+  }
+});
+
+export {
+  deepEqual,
+  init_deepEqual,
+  useAppearance,
+  init_useAppearance,
+  useLocales,
+  init_useLocales,
+  useModalError,
+  init_useModalError,
+  useMutation,
+  init_useMutation,
+  useRouter,
+  init_useRouter,
+  useIconColor_default,
+  init_useIconColor,
+  Trust_default,
+  init_Trust,
+  isMobile,
+  shortAddress,
+  openMobileUrl,
+  hasPCDownloadUrl,
+  formatTokenAmount,
+  getElementDimensionsRelativeToParent,
+  getBuyUrl,
+  popupWindow,
+  roundToEven,
+  hexToRgbaColor,
+  isFirstRegisterPasskey,
+  setFirstRegisterPasskey,
+  init_utils,
+  walletConfigs,
+  isCoinbase,
+  isWalletConnect,
+  isPasskeySmartWallet,
+  init_wallet,
+  useAAPlugin,
+  init_useAAPlugin,
+  ThemeContainer,
+  init_styles,
+  useConnections,
+  init_useConnections,
+  useWeb3Context,
+  init_web3Provider,
+  useRouteState,
+  init_useRouteState,
+  ConnectKitProvider,
+  useContext,
+  init_context,
+  useAccount,
+  init_useAccount
+};
+//# sourceMappingURL=chunk-4TIAGANX.mjs.map