@talken/talkenkit 2.4.23 → 2.4.25

package/dist/index.js

@@ -1,4 +1,7 @@
 "use client";
+import {
+  en_US_default
+} from "./chunk-X4GSACNW.js";
 import {
   darkTheme
 } from "./chunk-RZWDCITT.js";
@@ -11,18 +14,27 @@ import {
 import "./chunk-DQLAW7KN.js";
 import {
   BitcoinNetwork,
+  ConfigApi,
   GasApi,
   NETWORK_BY_PARAM,
   NETWORK_CONFIGS,
   NetworkType,
   SessionExpiredError,
+  SolanaApi,
   SolanaNetwork,
   TalkenApiClient,
+  TokenApi,
   TronNetwork,
   WalletscanApi,
   chainIdToNetwork,
+  createConfigApi,
+  createGasApi,
+  createSolanaApi,
   createTalkenApiClient,
+  createTokenApi,
+  createWalletscanApi,
   getBitcoinNetwork,
+  getChainKey,
   getEvmNetwork,
   getExplorerAddressUrl,
   getExplorerTxUrl,
@@ -36,17 +48,19 @@ import {
   getTronNetwork,
   isEvmNetwork,
   isTestnet,
+  loadAuthState,
   networkNameToChainKey,
   networkToChainId,
   resolveTalkenApiUrl,
   setTalkenApiClient
-} from "./chunk-N7AWNQBH.js";
+} from "./chunk-UKIPSWEV.js";
 import {
-  en_US_default
-} from "./chunk-X4GSACNW.js";
+  STORAGE_PREFIX,
+  getCredentialManager
+} from "./chunk-ALBABQ53.js";
 
 // src/components/ConnectButton/ConnectButton.tsx
-import React100, { useContext as useContext29, useEffect as useEffect31, useState as useState38 } from "react";
+import React100, { useContext as useContext29, useEffect as useEffect32, useState as useState39 } from "react";
 
 // src/css/sprinkles.css.ts
 import { createMapValueFn as _51c72 } from "@vanilla-extract/sprinkles/createUtils";
@@ -81,90 +95,90 @@ function useNonEvmConfirmation() {
   return useContext(NonEvmConfirmationContext);
 }
 
+// src/hooks/internal/abcEmbeddedWallet.ts
+function hasAbcEmbeddedSession(evmConnected, connector) {
+  return evmConnected && connector?.id === "abc";
+}
+function subscribeToAbcStorageUpdates(refresh) {
+  const handleStorageUpdate = () => {
+    void refresh();
+  };
+  window.addEventListener("talkenkit_storage_update", handleStorageUpdate);
+  return () => {
+    window.removeEventListener("talkenkit_storage_update", handleStorageUpdate);
+  };
+}
+function loadEmbeddedWalletFromAuthState(walletKey) {
+  const authState = loadAuthState();
+  return authState?.[walletKey] ?? null;
+}
+async function restoreEmbeddedWalletState(params) {
+  const {
+    enabled,
+    wallet,
+    emptyState,
+    requestInterceptor,
+    importProvider,
+    mapState
+  } = params;
+  if (!enabled || !wallet?.address) {
+    return emptyState;
+  }
+  const Provider = await importProvider();
+  const provider = new Provider();
+  provider.setWallet(wallet);
+  if (requestInterceptor) {
+    provider.setRequestInterceptor?.(requestInterceptor);
+  }
+  return mapState(wallet, provider);
+}
+
 // src/hooks/useBitcoinWallet.ts
 function useBitcoinWallet() {
   const { isConnected: evmConnected, connector } = useAccount();
   const { requestInterceptor } = useNonEvmConfirmation();
-  const [wallet, setWallet] = useState({
+  const emptyWalletState = {
     address: null,
     publicKey: null,
     network: null,
     addressType: null,
     isConnected: false,
     provider: null
-  });
+  };
+  const [wallet, setWallet] = useState(emptyWalletState);
   const [isLoading, setIsLoading] = useState(false);
   const [error2, setError] = useState(null);
   const refresh = async () => {
-    if (!evmConnected || !connector || connector.id !== "abc") {
-      setWallet({
-        address: null,
-        publicKey: null,
-        network: null,
-        addressType: null,
-        isConnected: false,
-        provider: null
-      });
-      return;
-    }
     try {
       setIsLoading(true);
       setError(null);
-      const authState = localStorage.getItem("talkenkit_abc_auth_state");
-      if (!authState) {
-        setWallet({
-          address: null,
-          publicKey: null,
-          network: null,
-          addressType: null,
-          isConnected: false,
-          provider: null
-        });
-        return;
-      }
-      const authData = JSON.parse(authState);
-      const bitcoinWallet = authData.bitcoinWallet;
-      if (!bitcoinWallet || !bitcoinWallet.address) {
-        setWallet({
-          address: null,
-          publicKey: null,
-          network: null,
-          addressType: null,
-          isConnected: false,
-          provider: null
-        });
-        return;
-      }
-      const { AbcBitcoinProvider } = await import("./abcWallet-O4GH6RHS.js");
-      const bitcoinProvider = new AbcBitcoinProvider();
-      bitcoinProvider.setWallet(bitcoinWallet);
-      if (requestInterceptor) {
-        bitcoinProvider.setRequestInterceptor(requestInterceptor);
-      }
-      setWallet({
-        address: bitcoinWallet.address,
-        publicKey: bitcoinWallet.publicKey,
-        network: bitcoinWallet.network || "bitcoin_testnet",
-        addressType: bitcoinWallet.addressType || "bech32",
-        isConnected: true,
-        provider: bitcoinProvider
+      const bitcoinWallet = loadEmbeddedWalletFromAuthState("bitcoinWallet");
+      const nextState = await restoreEmbeddedWalletState({
+        enabled: hasAbcEmbeddedSession(evmConnected, connector),
+        wallet: bitcoinWallet,
+        emptyState: emptyWalletState,
+        requestInterceptor,
+        importProvider: async () => (await import("./abcWallet-MWUFO3JQ.js")).AbcBitcoinProvider,
+        mapState: (nextWallet, provider) => ({
+          address: nextWallet.address,
+          publicKey: nextWallet.publicKey,
+          network: nextWallet.network || "bitcoin_testnet",
+          addressType: nextWallet.addressType || "bech32",
+          isConnected: true,
+          provider
+        })
       });
+      setWallet(nextState);
     } catch (err) {
       setError(err);
-      setWallet({
-        address: null,
-        publicKey: null,
-        network: null,
-        addressType: null,
-        isConnected: false,
-        provider: null
-      });
+      setWallet(emptyWalletState);
     } finally {
       setIsLoading(false);
     }
   };
   useEffect(() => {
-    refresh();
+    void refresh();
+    return subscribeToAbcStorageUpdates(refresh);
   }, [evmConnected, connector?.id]);
   useEffect(() => {
     if (wallet.provider) {
@@ -1203,251 +1217,654 @@ var useShowBalance = () => useContext5(ShowBalanceContext);
 
 // src/components/ConnectButton/ConnectButtonRenderer.tsx
 import React99, { useContext as useContext28 } from "react";
-import { useAccount as useAccount17, useConfig as useConfig4 } from "wagmi";
+import { useAccount as useAccount18, useConfig as useConfig4 } from "wagmi";
 
 // src/contexts/MultiChainContext.tsx
-import { useWallet } from "@solana/wallet-adapter-react";
+import { useWallet as useWallet2 } from "@solana/wallet-adapter-react";
 import React11, {
   createContext as createContext7,
   useCallback,
   useContext as useContext6,
-  useEffect as useEffect6,
-  useState as useState6
+  useEffect as useEffect7,
+  useState as useState7
 } from "react";
-import { useAccount as useAccount4, useDisconnect as useWagmiDisconnect } from "wagmi";
-var MultiChainContext = createContext7(null);
-function useMultiChain() {
-  const context = useContext6(MultiChainContext);
-  if (!context) {
-    throw new Error("useMultiChain must be used within MultiChainProvider");
-  }
-  return context;
-}
-function MultiChainProvider({
-  children,
-  defaultChain = "evm",
-  enableSolana = false
-}) {
-  const {
-    address: evmAddress,
-    chainId: evmChainId,
-    isConnected: evmConnected
-  } = useAccount4();
-  const solanaWallet = enableSolana ? useWallet() : null;
-  const solanaAddress = solanaWallet?.publicKey?.toBase58();
-  const solanaConnected = solanaWallet?.connected ?? false;
-  const { disconnect: wagmiDisconnect } = useWagmiDisconnect();
-  const solanaDisconnect = solanaWallet?.disconnect;
-  const [activeChain, setActiveChain] = useState6(defaultChain);
-  useEffect6(() => {
-    const stored = localStorage.getItem("talkenkit_active_chain");
-    if (stored && (stored === "evm" || stored === "solana")) {
-      setActiveChain(stored);
-    }
-  }, []);
-  useEffect6(() => {
-    localStorage.setItem("talkenkit_active_chain", activeChain);
-  }, [activeChain]);
-  const disconnectAll = useCallback(async () => {
-    try {
-      if (evmConnected) {
-        wagmiDisconnect();
-      }
-      if (solanaConnected && solanaDisconnect) {
-        await solanaDisconnect();
-      }
-    } catch (error2) {
-      console.error("[MultiChainContext] Failed to disconnect:", error2);
-    }
-  }, [evmConnected, solanaConnected, wagmiDisconnect, solanaDisconnect]);
-  const state = {
-    evmAddress,
-    evmChainId,
-    evmConnected,
-    solanaAddress,
-    solanaConnected,
-    solanaWallet,
-    activeChain,
-    setActiveChain,
-    disconnectAll
-  };
-  return /* @__PURE__ */ React11.createElement(MultiChainContext.Provider, { value: state }, children);
-}
-
-// src/hooks/useIsMounted.ts
-import { useCallback as useCallback2, useEffect as useEffect7, useState as useState7 } from "react";
-function useIsMounted() {
-  const [isMounted, setIsMounted] = useState7(false);
-  useEffect7(() => {
-    setIsMounted(true);
-    return () => {
-      setIsMounted(false);
-    };
-  }, []);
-  return useCallback2(() => isMounted, [isMounted]);
-}
-
-// src/hooks/useProfile.ts
-import { useBalance } from "wagmi";
+import { useAccount as useAccount5, useDisconnect as useWagmiDisconnect } from "wagmi";
 
-// src/hooks/useMainnetEnsAvatar.ts
-import { normalize } from "viem/ens";
-import { useEnsAvatar } from "wagmi";
-import { mainnet as mainnet2 } from "wagmi/chains";
+// src/hooks/useSolanaWallet.ts
+import { useConnection, useWallet } from "@solana/wallet-adapter-react";
+import { useEffect as useEffect6, useState as useState6 } from "react";
+import { useAccount as useAccount4 } from "wagmi";
 
-// src/hooks/useIsMainnetConfigured.ts
-import { mainnet } from "wagmi/chains";
-function useIsMainnetConfigured() {
-  const rainbowKitChains = useRainbowKitChains();
-  const chainId = mainnet.id;
-  const configured = rainbowKitChains.some(
-    (rainbowKitChain) => rainbowKitChain.id === chainId
+// src/solana/connectExternalWallet.ts
+async function connectExternalSolanaWallet({
+  walletName: walletName2,
+  wallets,
+  selectedWalletName,
+  selectWallet
+}) {
+  const wallet = wallets.find(
+    (candidate) => candidate.adapter.name === walletName2
   );
-  return configured;
-}
-
-// src/hooks/useMainnetEnsAvatar.ts
-function useMainnetEnsAvatar(name) {
-  const mainnetConfigured = useIsMainnetConfigured();
-  const safeNormalize = (ensName) => {
-    try {
-      return normalize(ensName);
-    } catch {
-    }
-  };
-  const { data: ensAvatar } = useEnsAvatar({
-    chainId: mainnet2.id,
-    name: name ? safeNormalize(name) : void 0,
-    query: {
-      enabled: mainnetConfigured
-    }
-  });
-  return ensAvatar;
+  if (!wallet) {
+    throw new Error(`Solana wallet adapter not found: ${walletName2}`);
+  }
+  if (wallet.adapter.connected) {
+    return wallet;
+  }
+  if (selectedWalletName !== wallet.adapter.name) {
+    selectWallet(wallet.adapter.name);
+  }
+  await wallet.adapter.connect();
+  return wallet;
 }
 
-// src/hooks/useMainnetEnsName.ts
-import { useQuery } from "@tanstack/react-query";
-import { useEnsName } from "wagmi";
-import { mainnet as mainnet3 } from "wagmi/chains";
-
-// src/core/network/internal/rainbowFetch.ts
-async function rainbowFetch(url, opts) {
-  opts = {
-    headers: {},
-    method: "get",
-    ...opts,
-    // Any other fetch options
-    timeout: opts.timeout ?? 1e4
-    // 10 secs
-  };
-  if (!url)
-    throw new Error("rainbowFetch: Missing url argument");
-  const controller = new AbortController();
-  const id = setTimeout(() => controller.abort(), opts.timeout);
-  const { body, params, headers, ...otherOpts } = opts;
-  const requestBody = body && typeof body === "object" ? JSON.stringify(opts.body) : opts.body;
-  const response = await fetch(`${url}${createParams(params)}`, {
-    ...otherOpts,
-    body: requestBody,
-    headers: {
-      Accept: "application/json",
-      "Content-Type": "application/json",
-      ...headers
-    },
-    signal: controller.signal
-  });
-  clearTimeout(id);
-  const responseBody = await getBody(response);
-  if (response.ok) {
-    const { headers: headers2, status } = response;
-    return { data: responseBody, headers: headers2, status };
+// src/hooks/useSolanaWallet.ts
+async function sendExternalSolanaTransaction(params) {
+  const { transaction, connection, externalWallet, options } = params;
+  if (externalWallet.sendTransaction) {
+    const rawSignature = await externalWallet.sendTransaction(
+      transaction,
+      connection,
+      options
+    );
+    return await normalizeSolanaSignature(rawSignature);
   }
-  const errorResponseBody = typeof responseBody === "string" ? { error: responseBody } : responseBody;
-  const error2 = generateError({
-    requestBody: body,
-    response,
-    responseBody: errorResponseBody
-  });
-  throw error2;
-}
-function getBody(response) {
-  const contentType = response.headers.get("Content-Type");
-  if (contentType?.startsWith("application/json")) {
-    return response.json();
+  if (!externalWallet.signTransaction) {
+    throw new Error("Wallet does not support transactions");
   }
-  return response.text();
-}
-function createParams(params) {
-  return params && Object.keys(params).length ? `?${new URLSearchParams(params)}` : "";
-}
-function generateError({
-  requestBody,
-  response,
-  responseBody
-}) {
-  const message = responseBody?.error || response?.statusText || "There was an error with the request.";
-  const error2 = new Error(message);
-  error2.response = response;
-  error2.responseBody = responseBody;
-  error2.requestBody = requestBody;
-  return error2;
+  const signedTransaction = await externalWallet.signTransaction(transaction);
+  const rawTransaction = signedTransaction.serialize();
+  return await connection.sendRawTransaction(rawTransaction, options);
 }
-var RainbowFetchClient = class {
-  constructor(opts = {}) {
-    const { baseUrl = "", ...otherOpts } = opts;
-    this.baseUrl = baseUrl;
-    this.opts = otherOpts;
-  }
-  /**
-   * Perform a GET request with the RainbowFetchClient.
-   */
-  get(url, opts) {
-    return rainbowFetch(`${this.baseUrl}${url}`, {
-      ...this.opts,
-      ...opts || {},
-      method: "get"
-    });
+async function normalizeSolanaSignature(signature) {
+  if (typeof signature === "string") {
+    return signature;
   }
-  /**
-   * Perform a DELETE request with the RainbowFetchClient.
-   */
-  delete(url, opts) {
-    return rainbowFetch(`${this.baseUrl}${url}`, {
-      ...this.opts,
-      ...opts || {},
-      method: "delete"
-    });
+  if (signature && typeof signature === "object" && "signature" in signature) {
+    return normalizeSolanaSignature(signature.signature);
   }
-  /**
-   * Perform a HEAD request with the RainbowFetchClient.
-   */
-  head(url, opts) {
-    return rainbowFetch(`${this.baseUrl}${url}`, {
-      ...this.opts,
-      ...opts || {},
-      method: "head"
-    });
+  const bs58 = (await import("bs58")).default;
+  if (signature instanceof Uint8Array) {
+    return bs58.encode(signature);
   }
-  /**
-   * Perform a OPTIONS request with the RainbowFetchClient.
-   */
-  options(url, opts) {
-    return rainbowFetch(`${this.baseUrl}${url}`, {
-      ...this.opts,
-      ...opts || {},
-      method: "options"
-    });
+  if (ArrayBuffer.isView(signature)) {
+    return bs58.encode(
+      new Uint8Array(
+        signature.buffer,
+        signature.byteOffset,
+        signature.byteLength
+      )
+    );
   }
-  /**
-   * Perform a POST request with the RainbowFetchClient.
-   */
-  post(url, body, opts) {
-    return rainbowFetch(`${this.baseUrl}${url}`, {
-      ...this.opts,
-      ...opts || {},
-      body,
-      method: "post"
-    });
+  if (Array.isArray(signature) && signature.every((value) => typeof value === "number")) {
+    return bs58.encode(Uint8Array.from(signature));
+  }
+  throw new Error(
+    `Unsupported Solana transaction signature shape: ${Object.prototype.toString.call(signature)}`
+  );
+}
+function useSolanaWallet() {
+  const { isConnected: evmConnected, connector } = useAccount4();
+  const { requestInterceptor } = useNonEvmConfirmation();
+  const emptyWalletState = {
+    address: null,
+    publicKey: null,
+    network: null,
+    isConnected: false,
+    provider: null
+  };
+  const { connection } = useConnection();
+  const solanaApiNetwork = process.env.NEXT_PUBLIC_ENVIRONMENT === "production" ? "solana" : "solana_devnet";
+  const externalWallet = useWallet();
+  const [abcWallet, setAbcWallet] = useState6(emptyWalletState);
+  const [isLoading, setIsLoading] = useState6(false);
+  const [error2, setError] = useState6(null);
+  const refreshAbcWallet = async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const solanaWallet = loadEmbeddedWalletFromAuthState("solanaWallet");
+      const nextState = await restoreEmbeddedWalletState({
+        enabled: hasAbcEmbeddedSession(evmConnected, connector),
+        wallet: solanaWallet,
+        emptyState: emptyWalletState,
+        requestInterceptor,
+        importProvider: async () => (await import("./abcWallet-MWUFO3JQ.js")).AbcSolanaProvider,
+        mapState: (nextWallet, provider) => ({
+          address: nextWallet.address,
+          publicKey: nextWallet.publicKey,
+          network: nextWallet.network || "solana_devnet",
+          isConnected: true,
+          provider
+        })
+      });
+      setAbcWallet(nextState);
+    } catch (err) {
+      setError(err);
+      setAbcWallet(emptyWalletState);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const refresh = refreshAbcWallet;
+  const getWalletscanNetwork = () => process.env.NEXT_PUBLIC_ENVIRONMENT === "production" ? "solana" : "solana_devnet";
+  useEffect6(() => {
+    void refreshAbcWallet();
+    return subscribeToAbcStorageUpdates(refreshAbcWallet);
+  }, [evmConnected, connector?.id]);
+  useEffect6(() => {
+    if (abcWallet.provider) {
+      abcWallet.provider.setRequestInterceptor(requestInterceptor ?? void 0);
+    }
+  }, [requestInterceptor]);
+  const activeWallet = abcWallet.isConnected ? {
+    ...abcWallet,
+    type: "abc",
+    walletName: "ABC Wallet"
+  } : externalWallet.connected ? {
+    address: externalWallet.publicKey?.toBase58() || null,
+    publicKey: externalWallet.publicKey?.toBase58() || null,
+    network: process.env.NEXT_PUBLIC_ENVIRONMENT === "production" ? "solana" : "solana_devnet",
+    isConnected: true,
+    type: "external",
+    walletName: externalWallet.wallet?.adapter.name || "External Wallet",
+    provider: null
+  } : {
+    address: null,
+    publicKey: null,
+    network: null,
+    isConnected: false,
+    type: null,
+    walletName: null,
+    provider: null
+  };
+  const connect = async (walletName2 = "ABC Wallet") => {
+    if (activeWallet.isConnected && activeWallet.walletName === walletName2) {
+      return;
+    }
+    await connectExternalSolanaWallet({
+      walletName: walletName2,
+      wallets: externalWallet.wallets,
+      selectedWalletName: externalWallet.wallet?.adapter.name,
+      selectWallet: externalWallet.select
+    });
+  };
+  const signMessage = async (params) => {
+    if (activeWallet.type === "abc") {
+      if (!abcWallet.provider) {
+        throw new Error("ABC Solana provider not available");
+      }
+      const encodedMessage = new TextEncoder().encode(params.message);
+      const result = await abcWallet.provider.signMessage(
+        encodedMessage,
+        "utf8"
+      );
+      const signatureHex = Array.from(result.signature).map((b) => b.toString(16).padStart(2, "0")).join("");
+      return { signature: signatureHex };
+    }
+    if (activeWallet.type === "external") {
+      if (!externalWallet.signMessage) {
+        throw new Error("Wallet does not support message signing");
+      }
+      const encodedMessage = new TextEncoder().encode(params.message);
+      const signature = await externalWallet.signMessage(encodedMessage);
+      const bs58 = await import("bs58");
+      const signatureBase58 = bs58.default.encode(signature);
+      return { signature: signatureBase58 };
+    }
+    throw new Error("No Solana wallet connected");
+  };
+  const transfer = async (params) => {
+    if (activeWallet.type === "abc") {
+      if (!abcWallet.provider) {
+        throw new Error("ABC Solana provider not available");
+      }
+      return await abcWallet.provider.transfer(params);
+    }
+    if (activeWallet.type === "external") {
+      if (!externalWallet.publicKey || !externalWallet.sendTransaction) {
+        throw new Error("Wallet does not support transactions");
+      }
+      const solanaApi = createSolanaApi();
+      const { blockhash } = await solanaApi.getLatestBlockhash(solanaApiNetwork);
+      if (params.mintAddress) {
+        const { PublicKey: PublicKey3, Transaction: Transaction3 } = await import("@solana/web3.js");
+        const {
+          getAssociatedTokenAddress,
+          createAssociatedTokenAccountIdempotentInstruction,
+          createTransferInstruction,
+          TOKEN_PROGRAM_ID
+        } = await import("@solana/spl-token");
+        const mintPubkey = new PublicKey3(params.mintAddress);
+        const fromPubkey2 = externalWallet.publicKey;
+        const toPubkey2 = new PublicKey3(params.toAddress);
+        const walletscanApi = createWalletscanApi();
+        const tokenInfo = await walletscanApi.getContractTokenWithTimeout({
+          contractAddress: params.mintAddress,
+          networks: solanaApiNetwork
+        });
+        const decimals = tokenInfo?.decimals ?? 0;
+        const fromTokenAccount = await getAssociatedTokenAddress(
+          mintPubkey,
+          fromPubkey2,
+          false,
+          TOKEN_PROGRAM_ID
+        );
+        const toTokenAccount = await getAssociatedTokenAddress(
+          mintPubkey,
+          toPubkey2,
+          false,
+          TOKEN_PROGRAM_ID
+        );
+        const transaction2 = new Transaction3();
+        transaction2.add(
+          createAssociatedTokenAccountIdempotentInstruction(
+            fromPubkey2,
+            toTokenAccount,
+            toPubkey2,
+            mintPubkey,
+            TOKEN_PROGRAM_ID
+          )
+        );
+        const rawAmount = Math.floor(params.amount * 10 ** decimals);
+        transaction2.add(
+          createTransferInstruction(
+            fromTokenAccount,
+            toTokenAccount,
+            fromPubkey2,
+            rawAmount,
+            [],
+            TOKEN_PROGRAM_ID
+          )
+        );
+        transaction2.recentBlockhash = blockhash;
+        transaction2.feePayer = fromPubkey2;
+        const signature2 = await sendExternalSolanaTransaction({
+          transaction: transaction2,
+          connection,
+          externalWallet
+        });
+        await solanaApi.waitForTransactionStatus({
+          network: solanaApiNetwork,
+          signature: signature2
+        });
+        return { signature: signature2 };
+      }
+      const { PublicKey: PublicKey2, SystemProgram, Transaction: Transaction2, LAMPORTS_PER_SOL } = await import("@solana/web3.js");
+      const fromPubkey = externalWallet.publicKey;
+      const toPubkey = new PublicKey2(params.toAddress);
+      const transaction = new Transaction2().add(
+        SystemProgram.transfer({
+          fromPubkey,
+          toPubkey,
+          lamports: params.amount * LAMPORTS_PER_SOL
+        })
+      );
+      transaction.recentBlockhash = blockhash;
+      transaction.feePayer = fromPubkey;
+      const signature = await sendExternalSolanaTransaction({
+        transaction,
+        connection,
+        externalWallet
+      });
+      await solanaApi.waitForTransactionStatus({
+        network: solanaApiNetwork,
+        signature
+      });
+      return { signature };
+    }
+    throw new Error("No Solana wallet connected");
+  };
+  const getTokenBalance = async (mintAddress) => {
+    if (activeWallet.type === "abc") {
+      if (!abcWallet.provider) {
+        throw new Error("ABC Solana provider not available");
+      }
+      return await abcWallet.provider.getTokenBalance(mintAddress);
+    }
+    if (activeWallet.type === "external") {
+      if (!externalWallet.publicKey) {
+        throw new Error("Wallet not connected");
+      }
+      const walletscanApi = createWalletscanApi();
+      const balance = await walletscanApi.getWalletTokenBalanceWithTimeout({
+        walletAddress: externalWallet.publicKey.toBase58(),
+        networks: getWalletscanNetwork(),
+        contractAddress: mintAddress
+      });
+      if (!balance) {
+        return {
+          amount: "0",
+          decimals: 0,
+          uiAmount: 0
+        };
+      }
+      return {
+        amount: String(balance.balance ?? 0),
+        decimals: balance.decimals ?? 0,
+        uiAmount: balance.hrBalance ?? 0
+      };
+    }
+    throw new Error("No Solana wallet connected");
+  };
+  const signTransaction = async (transaction) => {
+    if (activeWallet.type === "abc") {
+      if (!abcWallet.provider) {
+        throw new Error("ABC Solana provider not available");
+      }
+      return await abcWallet.provider.signTransaction(transaction);
+    }
+    if (activeWallet.type === "external") {
+      if (!externalWallet.signTransaction) {
+        throw new Error("Wallet does not support transaction signing");
+      }
+      return await externalWallet.signTransaction(transaction);
+    }
+    throw new Error("No Solana wallet connected");
+  };
+  const signAllTransactions = async (transactions) => {
+    if (activeWallet.type === "abc") {
+      if (!abcWallet.provider) {
+        throw new Error("ABC Solana provider not available");
+      }
+      return await abcWallet.provider.signAllTransactions(transactions);
+    }
+    if (activeWallet.type === "external") {
+      if (!externalWallet.signAllTransactions) {
+        throw new Error("Wallet does not support batch signing");
+      }
+      return await externalWallet.signAllTransactions(transactions);
+    }
+    throw new Error("No Solana wallet connected");
+  };
+  const sendTransactionUniversal = async (transaction, options) => {
+    if (activeWallet.type === "abc") {
+      throw new Error(
+        "sendTransactionUniversal for ABC Wallet not yet implemented. Use sendTransaction for SOL transfers."
+      );
+    }
+    if (activeWallet.type === "external") {
+      if (!externalWallet.sendTransaction && !externalWallet.signTransaction) {
+        throw new Error("Wallet does not support transactions");
+      }
+      return await sendExternalSolanaTransaction({
+        transaction,
+        connection,
+        externalWallet,
+        options
+      });
+    }
+    throw new Error("No Solana wallet connected");
+  };
+  return {
+    address: activeWallet.address,
+    publicKey: activeWallet.publicKey,
+    network: activeWallet.network,
+    isConnected: activeWallet.isConnected,
+    type: activeWallet.type,
+    walletName: activeWallet.walletName,
+    isLoading,
+    connecting: externalWallet.connecting,
+    error: error2,
+    connect,
+    signMessage,
+    transfer,
+    getTokenBalance,
+    signTransaction,
+    signAllTransactions,
+    sendTransactionUniversal,
+    refresh
+  };
+}
+
+// src/contexts/MultiChainContext.tsx
+var MultiChainContext = createContext7(null);
+function useMultiChain() {
+  const context = useContext6(MultiChainContext);
+  if (!context) {
+    throw new Error("useMultiChain must be used within MultiChainProvider");
+  }
+  return context;
+}
+function MultiChainProvider({
+  children,
+  defaultChain = "evm",
+  enableSolana = false
+}) {
+  const {
+    address: evmAddress,
+    chainId: evmChainId,
+    isConnected: evmConnected
+  } = useAccount5();
+  const solanaWallet = enableSolana ? useSolanaWallet() : null;
+  const solanaAddress = solanaWallet?.address ?? void 0;
+  const solanaConnected = solanaWallet?.isConnected ?? false;
+  const { disconnect: wagmiDisconnect } = useWagmiDisconnect();
+  const solanaAdapterWallet = enableSolana ? useWallet2() : null;
+  const solanaDisconnect = solanaAdapterWallet?.disconnect;
+  const [activeChain, setActiveChain] = useState7(defaultChain);
+  useEffect7(() => {
+    const stored = localStorage.getItem("talkenkit_active_chain");
+    if (stored && (stored === "evm" || stored === "solana")) {
+      setActiveChain(stored);
+    }
+  }, []);
+  useEffect7(() => {
+    localStorage.setItem("talkenkit_active_chain", activeChain);
+  }, [activeChain]);
+  const disconnectAll = useCallback(async () => {
+    try {
+      if (evmConnected) {
+        wagmiDisconnect();
+      }
+      if (solanaConnected && solanaDisconnect) {
+        await solanaDisconnect();
+      }
+    } catch (error2) {
+      console.error("[MultiChainContext] Failed to disconnect:", error2);
+    }
+  }, [evmConnected, solanaConnected, wagmiDisconnect, solanaDisconnect]);
+  const state = {
+    evmAddress,
+    evmChainId,
+    evmConnected,
+    solanaAddress,
+    solanaConnected,
+    solanaWallet,
+    activeChain,
+    setActiveChain,
+    disconnectAll
+  };
+  return /* @__PURE__ */ React11.createElement(MultiChainContext.Provider, { value: state }, children);
+}
+
+// src/hooks/useIsMounted.ts
+import { useCallback as useCallback2, useEffect as useEffect8, useState as useState8 } from "react";
+function useIsMounted() {
+  const [isMounted, setIsMounted] = useState8(false);
+  useEffect8(() => {
+    setIsMounted(true);
+    return () => {
+      setIsMounted(false);
+    };
+  }, []);
+  return useCallback2(() => isMounted, [isMounted]);
+}
+
+// src/hooks/useProfile.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+import { formatUnits } from "viem";
+
+// src/core/react-query/createQuery.ts
+function createQueryKey(key, args, config2 = {}) {
+  return [key, args, config2];
+}
+
+// src/hooks/useChainId.ts
+import { useAccount as useAccount6 } from "wagmi";
+function useChainId() {
+  const { chain: activeChain } = useAccount6();
+  return activeChain?.id ?? null;
+}
+
+// src/hooks/useMainnetEnsAvatar.ts
+import { normalize } from "viem/ens";
+import { useEnsAvatar } from "wagmi";
+import { mainnet as mainnet2 } from "wagmi/chains";
+
+// src/hooks/useIsMainnetConfigured.ts
+import { mainnet } from "wagmi/chains";
+function useIsMainnetConfigured() {
+  const rainbowKitChains = useRainbowKitChains();
+  const chainId = mainnet.id;
+  const configured = rainbowKitChains.some(
+    (rainbowKitChain) => rainbowKitChain.id === chainId
+  );
+  return configured;
+}
+
+// src/hooks/useMainnetEnsAvatar.ts
+function useMainnetEnsAvatar(name) {
+  const mainnetConfigured = useIsMainnetConfigured();
+  const safeNormalize = (ensName) => {
+    try {
+      return normalize(ensName);
+    } catch {
+    }
+  };
+  const { data: ensAvatar } = useEnsAvatar({
+    chainId: mainnet2.id,
+    name: name ? safeNormalize(name) : void 0,
+    query: {
+      enabled: mainnetConfigured
+    }
+  });
+  return ensAvatar;
+}
+
+// src/hooks/useMainnetEnsName.ts
+import { useQuery } from "@tanstack/react-query";
+import { useEnsName } from "wagmi";
+import { mainnet as mainnet3 } from "wagmi/chains";
+
+// src/core/network/internal/rainbowFetch.ts
+async function rainbowFetch(url, opts) {
+  opts = {
+    headers: {},
+    method: "get",
+    ...opts,
+    // Any other fetch options
+    timeout: opts.timeout ?? 1e4
+    // 10 secs
+  };
+  if (!url)
+    throw new Error("rainbowFetch: Missing url argument");
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), opts.timeout);
+  const { body, params, headers, ...otherOpts } = opts;
+  const requestBody = body && typeof body === "object" ? JSON.stringify(opts.body) : opts.body;
+  const response = await fetch(`${url}${createParams(params)}`, {
+    ...otherOpts,
+    body: requestBody,
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: controller.signal
+  });
+  clearTimeout(id);
+  const responseBody = await getBody(response);
+  if (response.ok) {
+    const { headers: headers2, status } = response;
+    return { data: responseBody, headers: headers2, status };
+  }
+  const errorResponseBody = typeof responseBody === "string" ? { error: responseBody } : responseBody;
+  const error2 = generateError({
+    requestBody: body,
+    response,
+    responseBody: errorResponseBody
+  });
+  throw error2;
+}
+function getBody(response) {
+  const contentType = response.headers.get("Content-Type");
+  if (contentType?.startsWith("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+function createParams(params) {
+  return params && Object.keys(params).length ? `?${new URLSearchParams(params)}` : "";
+}
+function generateError({
+  requestBody,
+  response,
+  responseBody
+}) {
+  const message = responseBody?.error || response?.statusText || "There was an error with the request.";
+  const error2 = new Error(message);
+  error2.response = response;
+  error2.responseBody = responseBody;
+  error2.requestBody = requestBody;
+  return error2;
+}
+var RainbowFetchClient = class {
+  constructor(opts = {}) {
+    const { baseUrl = "", ...otherOpts } = opts;
+    this.baseUrl = baseUrl;
+    this.opts = otherOpts;
+  }
+  /**
+   * Perform a GET request with the RainbowFetchClient.
+   */
+  get(url, opts) {
+    return rainbowFetch(`${this.baseUrl}${url}`, {
+      ...this.opts,
+      ...opts || {},
+      method: "get"
+    });
+  }
+  /**
+   * Perform a DELETE request with the RainbowFetchClient.
+   */
+  delete(url, opts) {
+    return rainbowFetch(`${this.baseUrl}${url}`, {
+      ...this.opts,
+      ...opts || {},
+      method: "delete"
+    });
+  }
+  /**
+   * Perform a HEAD request with the RainbowFetchClient.
+   */
+  head(url, opts) {
+    return rainbowFetch(`${this.baseUrl}${url}`, {
+      ...this.opts,
+      ...opts || {},
+      method: "head"
+    });
+  }
+  /**
+   * Perform a OPTIONS request with the RainbowFetchClient.
+   */
+  options(url, opts) {
+    return rainbowFetch(`${this.baseUrl}${url}`, {
+      ...this.opts,
+      ...opts || {},
+      method: "options"
+    });
+  }
+  /**
+   * Perform a POST request with the RainbowFetchClient.
+   */
+  post(url, body, opts) {
+    return rainbowFetch(`${this.baseUrl}${url}`, {
+      ...this.opts,
+      ...opts || {},
+      body,
+      method: "post"
+    });
   }
   /**
    * Perform a PUT request with the RainbowFetchClient.
@@ -1494,11 +1911,6 @@ var enhancedProviderHttp = createHttpClient({
   }
 });
 
-// src/core/react-query/createQuery.ts
-function createQueryKey(key, args, config2 = {}) {
-  return [key, args, config2];
-}
-
 // src/utils/ens.ts
 import { isAddress } from "viem";
 function getStorageEnsNameKey(address) {
@@ -1578,29 +1990,54 @@ function useMainnetEnsName(address) {
 }
 
 // src/hooks/useProfile.ts
+var createNativeBalanceQueryKey = (address, chainId) => createQueryKey("nativeBalance", {
+  address,
+  chainId: chainId ?? void 0
+});
 function useProfile({ address, includeBalance }) {
+  const chainId = useChainId();
   const ensName = useMainnetEnsName(address);
   const ensAvatar = useMainnetEnsAvatar(ensName);
-  const { data: balance } = useBalance({
-    address: includeBalance ? address : void 0
+  const { data: balance } = useQuery2({
+    queryKey: createNativeBalanceQueryKey(address, chainId),
+    queryFn: async () => {
+      if (!address || !chainId)
+        return void 0;
+      const walletscanApi = createWalletscanApi();
+      const nativeToken = await walletscanApi.getNativeTokenWithTimeout(
+        {
+          walletAddress: address,
+          networks: getNetworkName(chainId),
+          minimalInfo: false
+        },
+        3e3
+      );
+      if (!nativeToken)
+        return void 0;
+      const decimals = nativeToken.decimals ?? 18;
+      const rawBalance = nativeToken.balance ?? 0;
+      const value = BigInt(String(rawBalance));
+      return {
+        decimals,
+        formatted: formatUnits(value, decimals),
+        symbol: nativeToken.symbol,
+        value
+      };
+    },
+    enabled: Boolean(includeBalance && address && chainId),
+    staleTime: 3e4
   });
   return { ensName, ensAvatar, balance };
 }
 
 // src/transactions/useRecentTransactions.ts
-import { useEffect as useEffect8, useState as useState8 } from "react";
-import { useAccount as useAccount7 } from "wagmi";
-
-// src/hooks/useChainId.ts
-import { useAccount as useAccount5 } from "wagmi";
-function useChainId() {
-  const { chain: activeChain } = useAccount5();
-  return activeChain?.id ?? null;
-}
+import { useEffect as useEffect9, useState as useState9 } from "react";
+import { useAccount as useAccount8 } from "wagmi";
 
 // src/transactions/TransactionStoreContext.tsx
+import { useQueryClient } from "@tanstack/react-query";
 import React12 from "react";
-import { useAccount as useAccount6, useBalance as useBalance2, usePublicClient } from "wagmi";
+import { useAccount as useAccount7 } from "wagmi";
 
 // src/transactions/transactionStore.ts
 var storageKey = "rk-transactions";
@@ -1631,17 +2068,11 @@ function validateTransaction(transaction) {
   }
   return errors;
 }
-function createTransactionStore({
-  provider: initialProvider
-}) {
+function createTransactionStore() {
   let data = loadData();
-  let provider = initialProvider;
   const listeners = /* @__PURE__ */ new Set();
   const transactionListeners = /* @__PURE__ */ new Set();
   const transactionRequestCache = /* @__PURE__ */ new Map();
-  function setProvider(newProvider) {
-    provider = newProvider;
-  }
   function getTransactions(account, chainId) {
     return data[account]?.[chainId] ?? [];
   }
@@ -1674,34 +2105,31 @@ function createTransactionStore({
   async function waitForPendingTransactions(account, chainId) {
     await Promise.all(
       getTransactions(account, chainId).filter((transaction) => transaction.status === "pending").map(async (transaction) => {
-        const { confirmations, hash } = transaction;
+        const { hash } = transaction;
         const existingRequest = transactionRequestCache.get(hash);
         if (existingRequest) {
           return await existingRequest;
         }
-        const requestPromise = provider.waitForTransactionReceipt({
-          confirmations,
-          hash,
-          timeout: 3e5
-          // 5 minutes
-        }).then(({ status }) => {
-          transactionRequestCache.delete(hash);
-          if (status === void 0) {
-            return;
+        const requestResult = (async () => {
+          try {
+            const chainKey = getChainKey(chainId);
+            const configApi = createConfigApi();
+            const status = await configApi.waitForTxStatus(chainKey, hash, {
+              timeoutMs: 3e5,
+              pollIntervalMs: 3e3
+            });
+            transactionRequestCache.delete(hash);
+            setTransactionStatus(account, chainId, hash, "confirmed");
+            notifyTransactionListeners(
+              status.status === "success" ? "success" : 1
+            );
+          } catch {
+            transactionRequestCache.delete(hash);
+            setTransactionStatus(account, chainId, hash, "failed");
           }
-          setTransactionStatus(
-            account,
-            chainId,
-            hash,
-            // @ts-ignore - types changed with viem@1.1.0
-            status === 0 || status === "reverted" ? "failed" : "confirmed"
-          );
-          notifyTransactionListeners(status);
-        }).catch(() => {
-          setTransactionStatus(account, chainId, hash, "failed");
-        });
-        transactionRequestCache.set(hash, requestPromise);
-        return await requestPromise;
+        })();
+        transactionRequestCache.set(hash, requestResult);
+        return await requestResult;
       })
     );
   }
@@ -1749,7 +2177,6 @@ function createTransactionStore({
     getTransactions,
     onTransactionStatus,
     onChange,
-    setProvider,
     waitForPendingTransactions
   };
 }
@@ -1762,28 +2189,22 @@ var TransactionStoreContext = React12.createContext(
 function TransactionStoreProvider({
   children
 }) {
-  const provider = usePublicClient();
-  const { address } = useAccount6();
+  const { address } = useAccount7();
   const chainId = useChainId();
-  const { refetch } = useBalance2({
-    address,
-    query: {
-      enabled: false
-    }
-  });
+  const queryClient = useQueryClient();
   const [store] = React12.useState(
-    () => storeSingleton ?? (storeSingleton = createTransactionStore({ provider }))
+    () => storeSingleton ?? (storeSingleton = createTransactionStore())
   );
   const onTransactionStatus = React12.useCallback(
     (txStatus) => {
-      if (txStatus === "success")
-        refetch();
+      if (txStatus === "success" && address && chainId) {
+        queryClient.invalidateQueries({
+          queryKey: createNativeBalanceQueryKey(address, chainId)
+        });
+      }
     },
-    [refetch]
+    [address, chainId, queryClient]
   );
-  React12.useEffect(() => {
-    store.setProvider(provider);
-  }, [store, provider]);
   React12.useEffect(() => {
     if (address && chainId) {
       store.waitForPendingTransactions(address, chainId);
@@ -1807,12 +2228,12 @@ function useTransactionStore() {
 // src/transactions/useRecentTransactions.ts
 function useRecentTransactions() {
   const store = useTransactionStore();
-  const { address } = useAccount7();
+  const { address } = useAccount8();
   const chainId = useChainId();
-  const [transactions, setTransactions] = useState8(
+  const [transactions, setTransactions] = useState9(
     () => store && address && chainId ? store.getTransactions(address, chainId) : []
   );
-  useEffect8(() => {
+  useEffect9(() => {
     if (store && address && chainId) {
       setTransactions(store.getTransactions(address, chainId));
       return store.onChange(() => {
@@ -1828,21 +2249,21 @@ import React98, {
   createContext as createContext16,
   useCallback as useCallback25,
   useContext as useContext27,
-  useEffect as useEffect30,
+  useEffect as useEffect31,
   useMemo as useMemo19,
-  useState as useState37
+  useState as useState38
 } from "react";
-import { useAccount as useAccount16, useAccountEffect as useAccountEffect3, useConfig as useConfig3 } from "wagmi";
+import { useAccount as useAccount17, useAccountEffect as useAccountEffect3, useConfig as useConfig3 } from "wagmi";
 
 // src/components/AccountModal/AccountModal.tsx
 import React62, { useContext as useContext15 } from "react";
-import { useAccount as useAccount13, useDisconnect } from "wagmi";
+import { useAccount as useAccount14, useDisconnect } from "wagmi";
 
 // src/components/Dialog/Dialog.tsx
 import React50, {
   useCallback as useCallback18,
-  useEffect as useEffect21,
-  useState as useState20
+  useEffect as useEffect22,
+  useState as useState21
 } from "react";
 import { createPortal } from "react-dom";
 import { RemoveScroll } from "react-remove-scroll";
@@ -1891,21 +2312,21 @@ function cssStringFromTheme(theme, options = {}) {
 }
 
 // src/providers/SignConfirmationProvider/SignConfirmationProvider.tsx
-import { useWallet as useWallet2 } from "@solana/wallet-adapter-react";
+import { useWallet as useWallet3 } from "@solana/wallet-adapter-react";
 import React35, {
   createContext as createContext8,
   useContext as useContext7,
-  useState as useState17,
+  useState as useState18,
   useCallback as useCallback13,
-  useEffect as useEffect15
+  useEffect as useEffect16
 } from "react";
-import { useAccount as useAccount8 } from "wagmi";
+import { useAccount as useAccount9 } from "wagmi";
 
 // src/components/ConfirmationModal/SignConfirmationModal.tsx
 import React17, {
-  useEffect as useEffect9,
+  useEffect as useEffect10,
   useRef,
-  useState as useState10,
+  useState as useState11,
   useCallback as useCallback4,
   useMemo as useMemo6
 } from "react";
@@ -2026,11 +2447,11 @@ function Toast({ message, isVisible }) {
 }
 
 // src/components/Toast/useToast.ts
-import { useCallback as useCallback3, useState as useState9 } from "react";
+import { useCallback as useCallback3, useState as useState10 } from "react";
 function useToast(options = {}) {
   const { duration = 1500 } = options;
-  const [isVisible, setIsVisible] = useState9(false);
-  const [message, setMessage] = useState9("");
+  const [isVisible, setIsVisible] = useState10(false);
+  const [message, setMessage] = useState10("");
   const showToast = useCallback3(
     (msg) => {
       setMessage(msg);
@@ -2204,7 +2625,7 @@ function SignConfirmationModal({
   defaultExpanded = true
 }) {
   const modalRef = useRef(null);
-  const [isExpanded, setIsExpanded] = useState10(defaultExpanded);
+  const [isExpanded, setIsExpanded] = useState11(defaultExpanded);
   const {
     isVisible: toastVisible2,
     message: toastMessage,
@@ -2227,7 +2648,7 @@ function SignConfirmationModal({
       console.error("[SignConfirmationModal] Failed to copy message:", err);
     }
   }, [message, showToast]);
-  useEffect9(() => {
+  useEffect10(() => {
     const handleEscape = (e) => {
       if (e.key === "Escape" && isOpen) {
         onClose();
@@ -2236,7 +2657,7 @@ function SignConfirmationModal({
     document.addEventListener("keydown", handleEscape);
     return () => document.removeEventListener("keydown", handleEscape);
   }, [isOpen, onClose]);
-  useEffect9(() => {
+  useEffect10(() => {
     if (isOpen) {
       document.body.style.overflow = "hidden";
     } else {
@@ -2246,7 +2667,7 @@ function SignConfirmationModal({
       document.body.style.overflow = "";
     };
   }, [isOpen]);
-  useEffect9(() => {
+  useEffect10(() => {
     if (isOpen) {
       setIsExpanded(defaultExpanded);
     }
@@ -2378,9 +2799,9 @@ function SignConfirmationModal({
 
 // src/components/ConfirmationModal/TransactionConfirmationModal.tsx
 import React32, {
-  useEffect as useEffect12,
+  useEffect as useEffect13,
   useRef as useRef6,
-  useState as useState15,
+  useState as useState16,
   useCallback as useCallback9,
   useMemo as useMemo11
 } from "react";
@@ -2408,10 +2829,10 @@ function createBlockiesDataUrl(address, size = 8, scale = 4) {
 // src/components/GasFeeModal/GasFeeEditModal.tsx
 import React25, {
   useCallback as useCallback5,
-  useEffect as useEffect10,
+  useEffect as useEffect11,
   useMemo as useMemo7,
   useRef as useRef2,
-  useState as useState11
+  useState as useState12
 } from "react";
 
 // src/components/Icons/Close2.tsx
@@ -2843,10 +3264,10 @@ function GasFeeEditModal({
   currentPriorityFee = "",
   nativeSymbol = "ETH"
 }) {
-  const [selectedPriority, setSelectedPriority] = useState11(currentOption);
-  const [customGasLimit, setCustomGasLimit] = useState11(currentGasLimit);
-  const [customMaxFee, setCustomMaxFee] = useState11(currentMaxFee);
-  const [customPriorityFee, setCustomPriorityFee] = useState11(currentPriorityFee);
+  const [selectedPriority, setSelectedPriority] = useState12(currentOption);
+  const [customGasLimit, setCustomGasLimit] = useState12(currentGasLimit);
+  const [customMaxFee, setCustomMaxFee] = useState12(currentMaxFee);
+  const [customPriorityFee, setCustomPriorityFee] = useState12(currentPriorityFee);
   const modalRef = useRef2(null);
   const handleTooltipMouseEnter2 = useCallback5(
     (e) => {
@@ -2870,7 +3291,7 @@ function GasFeeEditModal({
     },
     []
   );
-  useEffect10(() => {
+  useEffect11(() => {
     if (isOpen) {
       setSelectedPriority(currentOption);
       setCustomGasLimit(currentGasLimit);
@@ -2884,7 +3305,7 @@ function GasFeeEditModal({
     currentMaxFee,
     currentPriorityFee
   ]);
-  useEffect10(() => {
+  useEffect11(() => {
     const handleEscape = (e) => {
       if (e.key === "Escape" && isOpen) {
         onClose();
@@ -3200,7 +3621,7 @@ var EditIcon = ({ size = 18 }) => /* @__PURE__ */ React26.createElement(
 );
 
 // src/components/ConfirmationModal/NftApprovalSection.tsx
-import React28, { useCallback as useCallback6, useMemo as useMemo8, useRef as useRef3, useState as useState12 } from "react";
+import React28, { useCallback as useCallback6, useMemo as useMemo8, useRef as useRef3, useState as useState13 } from "react";
 
 // src/components/ConfirmationModal/NFTPlaceholder.tsx
 import React27 from "react";
@@ -3333,7 +3754,7 @@ function NftApprovalSection({
   nftApprovalInfo
 }) {
   const sectionRef = useRef3(null);
-  const [imageError, setImageError] = useState12(false);
+  const [imageError, setImageError] = useState13(false);
   const handleTooltipPosition = useCallback6(
     (e) => handleTooltipMouseEnter(e, sectionRef),
     []
@@ -3427,10 +3848,10 @@ var MAX_UINT256 = BigInt(
 // src/components/ConfirmationModal/ApproveSection.tsx
 import React29, {
   useCallback as useCallback7,
-  useEffect as useEffect11,
+  useEffect as useEffect12,
   useMemo as useMemo9,
   useRef as useRef4,
-  useState as useState13
+  useState as useState14
 } from "react";
 
 // src/utils/tokenMapper.ts
@@ -3552,9 +3973,9 @@ function ApproveSection({
     }
     return formatTokenAmount(approveInfo.amount, tokenDecimals);
   }, [approveInfo.amount, tokenDecimals]);
-  const [inputValue, setInputValue] = useState13(formattedAmount);
+  const [inputValue, setInputValue] = useState14(formattedAmount);
   const isUserEditing = useRef4(false);
-  useEffect11(() => {
+  useEffect12(() => {
     if (!isUserEditing.current) {
       setInputValue(formattedAmount);
     }
@@ -3701,7 +4122,7 @@ function ApproveSection({
 }
 
 // src/components/ConfirmationModal/TransferSection.tsx
-import React30, { useState as useState14 } from "react";
+import React30, { useState as useState15 } from "react";
 
 // src/components/ConfirmationModal/TransferSection.css.ts
 var addressColumn = "_1gau5ng9";
@@ -3735,7 +4156,7 @@ function isNftToken(token) {
 }
 function TransferSection({ transferInfo }) {
   const { from, to, token, amount, amountUsd } = transferInfo;
-  const [imageError, setImageError] = useState14(false);
+  const [imageError, setImageError] = useState15(false);
   const isNft = isNftToken(token);
   return /* @__PURE__ */ React30.createElement("div", { className: transferSection }, isNft ? (
     // NFT Display
@@ -4310,7 +4731,7 @@ function TransactionConfirmationModal({
   defaultDataExpanded = false
 }) {
   const modalRef = useRef6(null);
-  const [isDataExpanded, setIsDataExpanded] = useState15(defaultDataExpanded);
+  const [isDataExpanded, setIsDataExpanded] = useState16(defaultDataExpanded);
   const {
     isVisible: toastVisible2,
     message: toastMessage,
@@ -4346,11 +4767,11 @@ function TransactionConfirmationModal({
     return void 0;
   }, [gasLimit, maxFee]);
   const estimatedGasUsd = void 0;
-  const [isGasFeeEditOpen, setIsGasFeeEditOpen] = useState15(false);
-  const [selectedGasOption, setSelectedGasOption] = useState15(
+  const [isGasFeeEditOpen, setIsGasFeeEditOpen] = useState16(false);
+  const [selectedGasOption, setSelectedGasOption] = useState16(
     null
   );
-  const [localApproveInfo, setLocalApproveInfo] = useState15(approveInfo);
+  const [localApproveInfo, setLocalApproveInfo] = useState16(approveInfo);
   const displayedGasSpeed = useMemo11(() => {
     if (!selectedGasOption)
       return gasSpeed || "--";
@@ -4512,7 +4933,7 @@ function TransactionConfirmationModal({
     },
     [localApproveInfo, approveInfo]
   );
-  useEffect12(() => {
+  useEffect13(() => {
     setLocalApproveInfo(approveInfo);
   }, [approveInfo]);
   const hasData = data && data !== "0x" && data.length > 2;
@@ -4536,7 +4957,7 @@ function TransactionConfirmationModal({
       console.error("[TransactionConfirmationModal] Failed to copy data:", err);
     }
   }, [data, showToast]);
-  useEffect12(() => {
+  useEffect13(() => {
     const handleEscape = (e) => {
       if (e.key === "Escape" && isOpen) {
         onClose();
@@ -4545,7 +4966,7 @@ function TransactionConfirmationModal({
     document.addEventListener("keydown", handleEscape);
     return () => document.removeEventListener("keydown", handleEscape);
   }, [isOpen, onClose]);
-  useEffect12(() => {
+  useEffect13(() => {
     if (isOpen) {
       document.body.style.overflow = "hidden";
     } else {
@@ -4555,7 +4976,7 @@ function TransactionConfirmationModal({
       document.body.style.overflow = "";
     };
   }, [isOpen]);
-  useEffect12(() => {
+  useEffect13(() => {
     if (isOpen) {
       setIsDataExpanded(defaultDataExpanded);
     }
@@ -4748,7 +5169,7 @@ function TransactionConfirmationModal({
 }
 
 // src/components/ConfirmationModal/NonEvmSignConfirmationModal.tsx
-import React33, { useCallback as useCallback10, useEffect as useEffect13, useRef as useRef7, useState as useState16 } from "react";
+import React33, { useCallback as useCallback10, useEffect as useEffect14, useRef as useRef7, useState as useState17 } from "react";
 
 // src/components/ConfirmationModal/NonEvmConfirmationModal.css.ts
 var actions3 = "_1i4xtnq1b";
@@ -4890,7 +5311,7 @@ function NonEvmSignConfirmationModal({
   request
 }) {
   const modalRef = useRef7(null);
-  const [isExpanded, setIsExpanded] = useState16(true);
+  const [isExpanded, setIsExpanded] = useState17(true);
   const {
     isVisible: toastVisible2,
     message: toastMessage,
@@ -4909,7 +5330,7 @@ function NonEvmSignConfirmationModal({
       console.error("[NonEvmSignModal] Failed to copy:", err);
     }
   }, [request.message, showToast]);
-  useEffect13(() => {
+  useEffect14(() => {
     const handleEscape = (e) => {
       if (e.key === "Escape" && isOpen)
         onClose();
@@ -4917,7 +5338,7 @@ function NonEvmSignConfirmationModal({
     document.addEventListener("keydown", handleEscape);
     return () => document.removeEventListener("keydown", handleEscape);
   }, [isOpen, onClose]);
-  useEffect13(() => {
+  useEffect14(() => {
     if (isOpen) {
       document.body.style.overflow = "hidden";
     } else {
@@ -4927,7 +5348,7 @@ function NonEvmSignConfirmationModal({
       document.body.style.overflow = "";
     };
   }, [isOpen]);
-  useEffect13(() => {
+  useEffect14(() => {
     if (isOpen)
       setIsExpanded(true);
   }, [isOpen]);
@@ -5026,7 +5447,7 @@ function NonEvmSignConfirmationModal({
 }
 
 // src/components/ConfirmationModal/NonEvmTransferConfirmationModal.tsx
-import React34, { useEffect as useEffect14, useRef as useRef8 } from "react";
+import React34, { useEffect as useEffect15, useRef as useRef8 } from "react";
 
 // src/components/ConfirmationModal/commonStyles.css.ts
 var sendAmountNegative = "_1i4xtnqu";
@@ -5053,7 +5474,7 @@ function NonEvmTransferConfirmationModal({
   const { isVisible: toastVisible2, message: toastMessage } = useToast();
   const chainName2 = getChainDisplayName2(request.chain, request.network);
   const modalTitle = "Transfer request";
-  useEffect14(() => {
+  useEffect15(() => {
     const handleEscape = (e) => {
       if (e.key === "Escape" && isOpen)
         onClose();
@@ -5061,7 +5482,7 @@ function NonEvmTransferConfirmationModal({
     document.addEventListener("keydown", handleEscape);
     return () => document.removeEventListener("keydown", handleEscape);
   }, [isOpen, onClose]);
-  useEffect14(() => {
+  useEffect15(() => {
     if (isOpen) {
       document.body.style.overflow = "hidden";
     } else {
@@ -5664,22 +6085,10 @@ function parseTransactionParams(params) {
 
 // src/providers/SignConfirmationProvider/useTransactionResolver.ts
 import { useCallback as useCallback12 } from "react";
-import { erc20Abi as erc20Abi2 } from "viem";
-import { usePublicClient as usePublicClient2 } from "wagmi";
 
 // src/providers/SignConfirmationProvider/useApiClient.ts
 import { useCallback as useCallback11 } from "react";
 import { toHex } from "viem";
-
-// src/utils/apiClientFactory.ts
-function createWalletscanApi() {
-  return new WalletscanApi();
-}
-function createGasApi() {
-  return new GasApi();
-}
-
-// src/providers/SignConfirmationProvider/useApiClient.ts
 function useApiClient() {
   const fetchGasFees = useCallback11(
     async (chainId) => {
@@ -5770,6 +6179,22 @@ function useApiClient() {
     },
     []
   );
+  const fetchTokenBalance = useCallback11(
+    async (ownerAddress, tokenAddress, chainId) => {
+      try {
+        const tokenApi = createTokenApi();
+        return await tokenApi.getTokenBalance(
+          ownerAddress,
+          getChainKey(chainId),
+          tokenAddress
+        );
+      } catch (error2) {
+        console.warn("[useApiClient] Failed to fetch token balance:", error2);
+        return null;
+      }
+    },
+    []
+  );
   const fetchNFTMetadata = useCallback11(
     async (contractAddress, walletAddress, chainId) => {
       try {
@@ -5793,9 +6218,11 @@ function useApiClient() {
     []
   );
   return {
+    createConfigApi,
     fetchGasFees,
     fetchGasLimit,
     fetchNativeTokenMetadata,
+    fetchTokenBalance,
     fetchTokenMetadata,
     fetchNFTMetadata
   };
@@ -5803,12 +6230,12 @@ function useApiClient() {
 
 // src/providers/SignConfirmationProvider/useTransactionResolver.ts
 function useTransactionResolver() {
-  const publicClient = usePublicClient2();
   const rainbowKitChainsById = useRainbowKitChainsById();
   const {
     fetchGasFees,
     fetchGasLimit,
     fetchNativeTokenMetadata,
+    fetchTokenBalance,
     fetchTokenMetadata,
     fetchNFTMetadata
   } = useApiClient();
@@ -6035,20 +6462,17 @@ function useTransactionResolver() {
         const metadata = await fetchTokenMetadata(parsed.to, request.chainId);
         const token = metadata ? { ...toFungibleToken(metadata), contractAddress: parsed.to } : createFallbackFungibleToken(parsed.to);
         let balance;
-        if (publicClient) {
-          try {
-            balance = await publicClient.readContract({
-              address: parsed.to,
-              abi: erc20Abi2,
-              functionName: "balanceOf",
-              args: [request.address]
-            });
-          } catch (balanceError) {
-            console.warn(
-              "[useTransactionResolver] Failed to fetch token balance:",
-              balanceError
-            );
-          }
+        try {
+          balance = await fetchTokenBalance(
+            request.address,
+            parsed.to,
+            request.chainId
+          ) ?? void 0;
+        } catch (balanceError) {
+          console.warn(
+            "[useTransactionResolver] Failed to fetch token balance:",
+            balanceError
+          );
         }
         parsed.approveInfo = {
           spender: decoded.spender,
@@ -6081,7 +6505,7 @@ function useTransactionResolver() {
         }
       }
     },
-    [publicClient, fetchTokenMetadata]
+    [fetchTokenBalance, fetchTokenMetadata]
   );
   const resolveSwapInfo = useCallback12(
     async (parsed, request) => {
@@ -6269,24 +6693,24 @@ function SignConfirmationProvider({
   children,
   disabled = false
 }) {
-  const [isModalOpen, setIsModalOpen] = useState17(false);
-  const [requestType, setRequestType] = useState17(null);
-  const [currentRequest, setCurrentRequest] = useState17(null);
-  const [parsedSign, setParsedSign] = useState17(null);
-  const [parsedTypedData, setParsedTypedData] = useState17(null);
-  const [parsedAuthorization, setParsedAuthorization] = useState17(null);
-  const [parsedTransaction, setParsedTransaction] = useState17(null);
-  const [nonEvmRequest, setNonEvmRequest] = useState17(null);
-  const [resolver, setResolver] = useState17(null);
-  const [rejecter, setRejecter] = useState17(
+  const [isModalOpen, setIsModalOpen] = useState18(false);
+  const [requestType, setRequestType] = useState18(null);
+  const [currentRequest, setCurrentRequest] = useState18(null);
+  const [parsedSign, setParsedSign] = useState18(null);
+  const [parsedTypedData, setParsedTypedData] = useState18(null);
+  const [parsedAuthorization, setParsedAuthorization] = useState18(null);
+  const [parsedTransaction, setParsedTransaction] = useState18(null);
+  const [nonEvmRequest, setNonEvmRequest] = useState18(null);
+  const [resolver, setResolver] = useState18(null);
+  const [rejecter, setRejecter] = useState18(
     null
   );
-  const [nonEvmResolver, setNonEvmResolver] = useState17(
+  const [nonEvmResolver, setNonEvmResolver] = useState18(
     null
   );
-  const [nonEvmRejecter, setNonEvmRejecter] = useState17(null);
-  const { connector, isConnected } = useAccount8();
-  const { wallets: solanaWallets } = useWallet2();
+  const [nonEvmRejecter, setNonEvmRejecter] = useState18(null);
+  const { connector, isConnected } = useAccount9();
+  const { wallets: solanaWallets } = useWallet3();
   const { resolveTransaction } = useTransactionResolver();
   const rainbowKitChainsById = useRainbowKitChainsById();
   const resetState = useCallback13(() => {
@@ -6387,7 +6811,7 @@ function SignConfirmationProvider({
     },
     [disabled]
   );
-  useEffect15(() => {
+  useEffect16(() => {
     if (disabled || !connector || !isConnected) {
       return;
     }
@@ -6420,7 +6844,7 @@ function SignConfirmationProvider({
       cleanup();
     };
   }, [connector, isConnected, requestConfirmation, disabled]);
-  useEffect15(() => {
+  useEffect16(() => {
     if (disabled)
       return;
     const abcWalletInfo = solanaWallets.find(
@@ -6440,8 +6864,8 @@ function SignConfirmationProvider({
   }, [solanaWallets, requestNonEvmConfirmation, disabled]);
   const chainName2 = currentRequest ? getNetworkName(currentRequest.chainId) : "Unknown";
   const displayChainName = chainName2.charAt(0).toUpperCase() + chainName2.slice(1);
-  const [_chainIcon, setChainIcon] = useState17(void 0);
-  useEffect15(() => {
+  const [_chainIcon, setChainIcon] = useState18(void 0);
+  useEffect16(() => {
     if (currentRequest?.chainId) {
       const chain = rainbowKitChainsById[currentRequest.chainId];
       if (chain?.iconUrl) {
@@ -6627,10 +7051,6 @@ async function decryptWithPin(encryptedHex, hashedPin, saltHex) {
     throw new Error("Failed to decrypt data. Invalid PIN or corrupted data.");
   }
 }
-async function verifyPin(pin, storedPinHash) {
-  const hashedPin = await hashPin(pin);
-  return hashedPin === storedPinHash;
-}
 
 // src/wallets/walletConnectors/abcWallet/abcSolanaWalletAdapter.ts
 var AbcWalletName = "ABC Wallet";
@@ -6852,7 +7272,7 @@ var AbcSolanaWalletAdapter = class extends BaseMessageSignerWalletAdapter {
         return;
       }
       this._connecting = true;
-      const authState = localStorage.getItem("talkenkit_abc_auth_state");
+      const authState = localStorage.getItem(`${STORAGE_PREFIX}auth_state`);
       if (authState) {
         try {
           const authData = JSON.parse(authState);
@@ -6897,7 +7317,7 @@ var AbcSolanaWalletAdapter = class extends BaseMessageSignerWalletAdapter {
             console.log(
               "[AbcSolanaWalletAdapter] Token expired, clearing session"
             );
-            localStorage.removeItem("talkenkit_abc_auth_state");
+            localStorage.removeItem(`${STORAGE_PREFIX}auth_state`);
           }
         } catch (error2) {
           console.error(
@@ -7038,7 +7458,7 @@ var AbcSolanaWalletAdapter = class extends BaseMessageSignerWalletAdapter {
         message: messageText
       });
       const messageHex = Buffer.from(message).toString("hex");
-      const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || "";
+      const pinHash = getCredentialManager().getPinHash() || "";
       const signatureResponse = await this._talkenApi.solana.sign({
         keyId: this._wallet.keyId || "",
         encryptedShare: this._wallet.encryptedShare || "",
@@ -7175,7 +7595,7 @@ var AbcSolanaWalletAdapter = class extends BaseMessageSignerWalletAdapter {
     if (this.connected || this.connecting) {
       return;
     }
-    const authState = localStorage.getItem("talkenkit_abc_auth_state");
+    const authState = localStorage.getItem(`${STORAGE_PREFIX}auth_state`);
     if (!authState) {
       return;
     }
@@ -7337,8 +7757,8 @@ var AbcSolanaWalletAdapter = class extends BaseMessageSignerWalletAdapter {
 var abcSolanaWalletAdapter_default = AbcSolanaWalletAdapter;
 
 // src/solana/AbcSolanaAutoConnector.tsx
-import { useWallet as useWallet3 } from "@solana/wallet-adapter-react";
-import { useEffect as useEffect16, useRef as useRef9 } from "react";
+import { useWallet as useWallet4 } from "@solana/wallet-adapter-react";
+import { useEffect as useEffect17, useRef as useRef9 } from "react";
 
 // src/solana/recentSolanaWalletIds.ts
 var RECENT_SOLANA_WALLET_STORAGE_KEY = "talkenkit.recent_solana_wallet";
@@ -7362,15 +7782,15 @@ function setRecentSolanaWallet(walletName2) {
 
 // src/solana/AbcSolanaAutoConnector.tsx
 function AbcSolanaAutoConnector() {
-  const { wallets, select, connected, wallet } = useWallet3();
+  const { wallets, select, connected, wallet } = useWallet4();
   const isConnectingRef = useRef9(false);
   const hasAttemptedRef = useRef9(false);
-  useEffect16(() => {
+  useEffect17(() => {
     if (connected && wallet?.adapter.name) {
       setRecentSolanaWallet(wallet.adapter.name);
     }
   }, [connected, wallet?.adapter.name]);
-  useEffect16(() => {
+  useEffect17(() => {
     let retryCount = 0;
     const maxRetries = 3;
     const retryDelay = 500;
@@ -7381,14 +7801,13 @@ function AbcSolanaAutoConnector() {
       if (isConnectingRef.current) {
         return;
       }
-      const authState = localStorage.getItem("talkenkit_abc_auth_state");
-      if (authState) {
+      const authData = loadAuthState();
+      if (authData) {
         try {
-          const authData = JSON.parse(authState);
           if (authData.solanaWallet?.address) {
             const solWallet = authData.solanaWallet;
-            const keyId = solWallet.keyId || solWallet.key_id;
-            const encryptedShare = solWallet.encryptedShare || solWallet.encrypted_share;
+            const keyId = solWallet.keyId;
+            const encryptedShare = solWallet.encryptedShare;
             if (keyId && encryptedShare) {
               const abcWallet = wallets.find(
                 (w) => w.adapter.name === "ABC Wallet"
@@ -7409,7 +7828,7 @@ function AbcSolanaAutoConnector() {
                 return;
               } catch (error2) {
                 if (error2?.message?.includes("requires authentication")) {
-                  localStorage.removeItem("talkenkit_abc_auth_state");
+                  localStorage.removeItem(`${STORAGE_PREFIX}auth_state`);
                 }
                 if (retryCount < maxRetries) {
                   retryCount++;
@@ -7498,7 +7917,7 @@ function InternalPinProvider({ children }) {
 import React40, { createContext as createContext13, useContext as useContext9 } from "react";
 
 // src/hooks/useWindowSize.ts
-import { useEffect as useEffect17, useState as useState18 } from "react";
+import { useEffect as useEffect18, useState as useState19 } from "react";
 
 // src/utils/debounce.ts
 function debounce(fn, ms) {
@@ -7516,11 +7935,11 @@ function debounce(fn, ms) {
 
 // src/hooks/useWindowSize.ts
 var useWindowSize = () => {
-  const [windowSize, setWindowSize] = useState18({
+  const [windowSize, setWindowSize] = useState19({
     height: void 0,
     width: void 0
   });
-  useEffect17(() => {
+  useEffect18(() => {
     const handleResize = debounce(() => {
       setWindowSize({
         height: window.innerHeight,
@@ -7554,14 +7973,14 @@ function useRainbowKitConfig() {
 }
 
 // src/components/RainbowKitProvider/WalletButtonContext.tsx
-import React39, { createContext as createContext12, useMemo as useMemo13, useState as useState19 } from "react";
+import React39, { createContext as createContext12, useMemo as useMemo13, useState as useState20 } from "react";
 var WalletButtonContext = createContext12({
   connector: null,
   setConnector: () => {
   }
 });
 function WalletButtonProvider({ children }) {
-  const [connector, setConnector] = useState19(null);
+  const [connector, setConnector] = useState20(null);
   return /* @__PURE__ */ React39.createElement(
     WalletButtonContext.Provider,
     {
@@ -7607,22 +8026,22 @@ import { createContext as createContext14 } from "react";
 var ShowRecentTransactionsContext = createContext14(false);
 
 // src/components/RainbowKitProvider/useFingerprint.ts
-import { useCallback as useCallback14, useEffect as useEffect18 } from "react";
+import { useCallback as useCallback14, useEffect as useEffect19 } from "react";
 var storageKey2 = "rk-version";
 function setRainbowKitVersion({ version }) {
   localStorage.setItem(storageKey2, version);
 }
 function useFingerprint() {
   const fingerprint = useCallback14(() => {
-    setRainbowKitVersion({ version: "2.4.23" });
+    setRainbowKitVersion({ version: "2.4.25" });
   }, []);
-  useEffect18(() => {
+  useEffect19(() => {
     fingerprint();
   }, [fingerprint]);
 }
 
 // src/components/RainbowKitProvider/usePreloadImages.ts
-import { useCallback as useCallback16, useEffect as useEffect19 } from "react";
+import { useCallback as useCallback16, useEffect as useEffect20 } from "react";
 
 // src/wallets/useWalletConnectors.ts
 import { useConnect } from "wagmi";
@@ -7930,7 +8349,7 @@ var LoginIcon = () => /* @__PURE__ */ React42.createElement(
 // src/components/SignIn/SignIn.tsx
 import React47, { useCallback as useCallback15, useContext as useContext10, useRef as useRef10 } from "react";
 import { UserRejectedRequestError } from "viem";
-import { useAccount as useAccount9, useSignMessage } from "wagmi";
+import { useAccount as useAccount10, useSignMessage } from "wagmi";
 
 // src/components/Button/ActionButton.tsx
 import React44 from "react";
@@ -8152,7 +8571,7 @@ function SignIn({
     getNonce();
   }, [getNonce]);
   const mobile = isMobile();
-  const { address, chain: activeChain } = useAccount9();
+  const { address, chain: activeChain } = useAccount10();
   const { signMessageAsync } = useSignMessage();
   const signIn = async () => {
     try {
@@ -8360,7 +8779,7 @@ function usePreloadImages() {
       loadImages(signInIcon);
     }
   }, [walletConnectors, rainbowKitChains, isUnauthenticated]);
-  useEffect19(() => {
+  useEffect20(() => {
     preloadImages();
   }, [preloadImages]);
 }
@@ -8527,7 +8946,7 @@ var overlay5 = "qjzye43 kwh1ip9h kwh1ipb3 kwh1ipa kwh1ip2q kwh1ip8q";
 
 // src/components/Dialog/FocusTrap.tsx
 import React49 from "react";
-import { useCallback as useCallback17, useEffect as useEffect20, useRef as useRef11 } from "react";
+import { useCallback as useCallback17, useEffect as useEffect21, useRef as useRef11 } from "react";
 var moveFocusWithin = (element2, position) => {
   const focusableElements = element2.querySelectorAll(
     "button:not(:disabled), a[href]"
@@ -8538,13 +8957,13 @@ var moveFocusWithin = (element2, position) => {
 };
 function FocusTrap(props) {
   const contentRef = useRef11(null);
-  useEffect20(() => {
+  useEffect21(() => {
     const previouslyActiveElement = document.activeElement;
     return () => {
       previouslyActiveElement.focus?.();
     };
   }, []);
-  useEffect20(() => {
+  useEffect21(() => {
     if (contentRef.current) {
       const elementToFocus = contentRef.current.querySelector("[data-auto-focus]");
       if (elementToFocus) {
@@ -8586,13 +9005,13 @@ function FocusTrap(props) {
 // src/components/Dialog/Dialog.tsx
 var stopPropagation = (event) => event.stopPropagation();
 function Dialog({ children, onClose, open, titleId }) {
-  useEffect21(() => {
+  useEffect22(() => {
     const handleEscape = (event) => open && event.key === "Escape" && onClose();
     document.addEventListener("keydown", handleEscape);
     return () => document.removeEventListener("keydown", handleEscape);
   }, [open, onClose]);
-  const [bodyScrollable, setBodyScrollable] = useState20(true);
-  useEffect21(() => {
+  const [bodyScrollable, setBodyScrollable] = useState21(true);
+  useEffect22(() => {
     setBodyScrollable(
       getComputedStyle(window.document.body).overflow !== "hidden"
     );
@@ -8670,7 +9089,7 @@ function DialogContent({
 }
 
 // src/components/ProfileDetails/ProfileDetails.tsx
-import React61, { useCallback as useCallback20, useContext as useContext14, useEffect as useEffect22, useState as useState21 } from "react";
+import React61, { useCallback as useCallback20, useContext as useContext14, useEffect as useEffect23, useState as useState22 } from "react";
 
 // src/components/ConnectButton/abbreviateETHBalance.ts
 var units = ["k", "m", "b", "t"];
@@ -8785,14 +9204,14 @@ var DisconnectIcon = () => /* @__PURE__ */ React54.createElement(
 
 // src/components/Txs/TxList.tsx
 import React59, { useContext as useContext13 } from "react";
-import { useAccount as useAccount12 } from "wagmi";
+import { useAccount as useAccount13 } from "wagmi";
 
 // src/transactions/useClearRecentTransactions.ts
 import { useCallback as useCallback19 } from "react";
-import { useAccount as useAccount10 } from "wagmi";
+import { useAccount as useAccount11 } from "wagmi";
 function useClearRecentTransactions() {
   const store = useTransactionStore();
-  const { address } = useAccount10();
+  const { address } = useAccount11();
   const chainId = useChainId();
   return useCallback19(() => {
     if (!address || !chainId) {
@@ -8828,7 +9247,7 @@ var ExternalLinkIcon = () => /* @__PURE__ */ React55.createElement(
 
 // src/components/Txs/TxItem.tsx
 import React58 from "react";
-import { useAccount as useAccount11 } from "wagmi";
+import { useAccount as useAccount12 } from "wagmi";
 
 // src/components/Icons/Cancel.tsx
 import React56 from "react";
@@ -8889,7 +9308,7 @@ function TxItem({ tx }) {
   const mobile = isMobile();
   const Icon = getTxStatusIcon(tx.status);
   const color = tx.status === "failed" ? "error" : "accentColor";
-  const { chain: activeChain } = useAccount11();
+  const { chain: activeChain } = useAccount12();
   const confirmationStatus = tx.status === "confirmed" ? "Confirmed" : tx.status === "failed" ? "Failed" : "Pending";
   const explorerLink = chainToExplorerUrl(activeChain);
   return /* @__PURE__ */ React58.createElement(React58.Fragment, null, /* @__PURE__ */ React58.createElement(
@@ -8950,7 +9369,7 @@ var NUMBER_OF_VISIBLE_TXS = 3;
 function TxList({ address }) {
   const recentTransactions = useRecentTransactions();
   const clearRecentTransactions = useClearRecentTransactions();
-  const { chain: activeChain } = useAccount12();
+  const { chain: activeChain } = useAccount13();
   const explorerLink = chainToExplorerUrl(activeChain);
   const visibleTxs = recentTransactions.slice(0, NUMBER_OF_VISIBLE_TXS);
   const hasTransactions = visibleTxs.length > 0;
@@ -9133,14 +9552,14 @@ function ProfileDetails({
   onDisconnect
 }) {
   const showRecentTransactions = useContext14(ShowRecentTransactionsContext);
-  const [copiedAddress, setCopiedAddress] = useState21(false);
+  const [copiedAddress, setCopiedAddress] = useState22(false);
   const copyAddressAction = useCallback20(() => {
     if (address) {
       navigator.clipboard.writeText(address);
       setCopiedAddress(true);
     }
   }, [address]);
-  useEffect22(() => {
+  useEffect23(() => {
     if (copiedAddress) {
       const timer = setTimeout(() => {
         setCopiedAddress(false);
@@ -9253,7 +9672,7 @@ function ProfileDetails({
 
 // src/components/AccountModal/AccountModal.tsx
 function AccountModal({ onClose, open }) {
-  const { address } = useAccount13();
+  const { address } = useAccount14();
   const { balance, ensAvatar, ensName } = useProfile({
     address,
     includeBalance: open
@@ -9287,8 +9706,8 @@ function AccountModal({ onClose, open }) {
 }
 
 // src/components/ChainModal/ChainModal.tsx
-import React66, { useContext as useContext17, useState as useState22 } from "react";
-import { useAccount as useAccount14, useDisconnect as useDisconnect2, useSwitchChain } from "wagmi";
+import React66, { useContext as useContext17, useState as useState23 } from "react";
+import { useAccount as useAccount15, useDisconnect as useDisconnect2, useSwitchChain } from "wagmi";
 import { useConfig as useConfig2 } from "wagmi";
 
 // src/components/Icons/DisconnectSq.tsx
@@ -9481,9 +9900,9 @@ var MobileScrollClassName = "ty310n1";
 
 // src/components/ChainModal/ChainModal.tsx
 function ChainModal({ onClose, open }) {
-  const { chainId } = useAccount14();
+  const { chainId } = useAccount15();
   const { chains } = useConfig2();
-  const [pendingChainId, setPendingChainId] = useState22(null);
+  const [pendingChainId, setPendingChainId] = useState23(null);
   const { switchChain } = useSwitchChain({
     mutation: {
       onMutate: ({ chainId: _chainId }) => {
@@ -9613,13 +10032,13 @@ function ChainModal({ onClose, open }) {
 
 // src/components/ConnectModal/ConnectModal.tsx
 import React97, { useContext as useContext26 } from "react";
-import { useAccount as useAccount15, useDisconnect as useDisconnect3 } from "wagmi";
+import { useAccount as useAccount16, useDisconnect as useDisconnect3 } from "wagmi";
 
 // src/components/ConnectOptions/ConnectOptions.tsx
 import {
   WalletContext
 } from "@solana/wallet-adapter-react";
-import React93, { useCallback as useCallback22, useContext as useContext24, useMemo as useMemo18, useState as useState34 } from "react";
+import React93, { useCallback as useCallback22, useContext as useContext24, useMemo as useMemo18, useState as useState35 } from "react";
 
 // src/wallets/recentSolanaWalletIds.ts
 var storageKey5 = "rk-recent-solana";
@@ -9643,7 +10062,7 @@ function addRecentSolanaWalletId(walletName2) {
 }
 
 // src/components/ConnectOptions/ConnectOptionsModal.tsx
-import React90, { useContext as useContext21, useEffect as useEffect28, useRef as useRef13, useState as useState32 } from "react";
+import React90, { useContext as useContext21, useEffect as useEffect29, useRef as useRef13, useState as useState33 } from "react";
 import { useConnect as useConnect2, useConnectors } from "wagmi";
 
 // src/components/ConnectModal/ConnectModalIntro.tsx
@@ -9818,7 +10237,7 @@ var InfoButton = ({
 import React77 from "react";
 
 // src/components/ConnectOptions/AbcWaasAuth/AbcWaasAuthSections.tsx
-import React76, { useState as useState23 } from "react";
+import React76, { useState as useState24 } from "react";
 
 // src/components/Icons/Apple.tsx
 import React73 from "react";
@@ -9948,7 +10367,7 @@ function AbcWaasAuthSections(props) {
     setAbcWaasNewPassword,
     setAbcWaasConfirmPassword
   } = props;
-  const [email, setEmail] = useState23("");
+  const [email, setEmail] = useState24("");
   const isGoogleEnabled = typeof process !== "undefined" && process.env && process.env.NEXT_PUBLIC_GOOGLE_OAUTH_ENABLED === "true" && !!process.env.NEXT_PUBLIC_FIREBASE_API_KEY;
   const isAppleEnabled = typeof process !== "undefined" && process.env && process.env.NEXT_PUBLIC_APPLE_OAUTH_ENABLED === "true" && !!process.env.NEXT_PUBLIC_APPLE_OAUTH_CLIENT_ID;
   const isKakaoEnabled = typeof process !== "undefined" && process.env && process.env.NEXT_PUBLIC_KAKAO_OAUTH_ENABLED === "true" && !!process.env.NEXT_PUBLIC_KAKAO_JS_KEY;
@@ -10350,37 +10769,37 @@ function AbcWaasAuthSections(props) {
 
 // src/components/ConnectOptions/AbcWaasAuth/hooks/useAbcWaasAuth.ts
 import { getTalkenApiClient as getTalkenApiClient2 } from "@talken/talkenkit";
-import { useState as useState24 } from "react";
+import { useState as useState25 } from "react";
 function useAbcWaasAuth(props) {
   const { onAuthSuccess, onPinRequired } = props || {};
-  const [step, setStep] = useState24("MAIN" /* Main */);
-  const [email, setEmail] = useState24("");
-  const [password, setPassword] = useState24("");
-  const [newPassword, setNewPassword] = useState24("");
-  const [confirmPassword, setConfirmPassword] = useState24("");
-  const [otp, setOtp] = useState24("");
-  const [_userType, setUserType] = useState24("new");
-  const [error2, setError] = useState24("");
-  const [isLoading, setIsLoading] = useState24(false);
-  const [loginData, setLoginData] = useState24(null);
-  const STORAGE_PREFIX2 = "talkenkit_abc_";
+  const [step, setStep] = useState25("MAIN" /* Main */);
+  const [email, setEmail] = useState25("");
+  const [password, setPassword] = useState25("");
+  const [newPassword, setNewPassword] = useState25("");
+  const [confirmPassword, setConfirmPassword] = useState25("");
+  const [otp, setOtp] = useState25("");
+  const [_userType, setUserType] = useState25("new");
+  const [error2, setError] = useState25("");
+  const [isLoading, setIsLoading] = useState25(false);
+  const [loginData, setLoginData] = useState25(null);
+  const STORAGE_PREFIX3 = "talkenkit_abc_";
   const clearExpiredEncryptedData = () => {
-    const expiresAtStr = localStorage.getItem(`${STORAGE_PREFIX2}expires_at`);
+    const expiresAtStr = localStorage.getItem(`${STORAGE_PREFIX3}expires_at`);
     const hasEncryptedTokens = localStorage.getItem(
-      `${STORAGE_PREFIX2}enc_tokens`
+      `${STORAGE_PREFIX3}enc_tokens`
     );
     if (!hasEncryptedTokens)
       return;
     const expiresAt = expiresAtStr ? Number(expiresAtStr) : 0;
     const isExpired = Date.now() >= expiresAt;
     if (isExpired) {
-      localStorage.removeItem(`${STORAGE_PREFIX2}enc_tokens`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}enc_salt`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}auth_state`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}user`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}wallet`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}solana_wallet`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}bitcoin_wallet`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}enc_tokens`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}enc_salt`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}auth_state`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}user`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}wallet`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}solana_wallet`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}bitcoin_wallet`);
     }
   };
   const getApi = () => {
@@ -10408,6 +10827,11 @@ function useAbcWaasAuth(props) {
           "[useAbcWaasAuth] Email check failed:",
           checkError.message
         );
+        setError(
+          "Failed to verify email. Please check your network and try again."
+        );
+        setIsLoading(false);
+        return;
       }
       if (isExistingUser) {
         setUserType("existing");
@@ -10438,13 +10862,12 @@ function useAbcWaasAuth(props) {
     setError("");
     try {
       clearExpiredEncryptedData();
-      localStorage.removeItem(`${STORAGE_PREFIX2}auth_state`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}user`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}wallet`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}access_token`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}refresh_token`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}expires_at`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}pin_hash`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}auth_state`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}user`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}wallet`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}access_token`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}refresh_token`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}expires_at`);
       const api = getApi();
       const data = await api.auth.loginWithPassword(email, password);
       const legacyData = {
@@ -10470,16 +10893,16 @@ function useAbcWaasAuth(props) {
         expiresAt
       };
       localStorage.setItem(
-        `${STORAGE_PREFIX2}auth_state`,
+        `${STORAGE_PREFIX3}auth_state`,
         JSON.stringify(authState)
       );
       localStorage.setItem(
-        `${STORAGE_PREFIX2}user`,
+        `${STORAGE_PREFIX3}user`,
         JSON.stringify(authState.user)
       );
-      localStorage.setItem(`${STORAGE_PREFIX2}access_token`, data.accessToken);
-      localStorage.setItem(`${STORAGE_PREFIX2}refresh_token`, data.refreshToken);
-      localStorage.setItem(`${STORAGE_PREFIX2}expires_at`, String(expiresAt));
+      localStorage.setItem(`${STORAGE_PREFIX3}access_token`, data.accessToken);
+      localStorage.setItem(`${STORAGE_PREFIX3}refresh_token`, data.refreshToken);
+      localStorage.setItem(`${STORAGE_PREFIX3}expires_at`, String(expiresAt));
       if (onPinRequired) {
         onPinRequired(legacyData);
       } else if (onAuthSuccess) {
@@ -10606,7 +11029,7 @@ function useAbcWaasAuth(props) {
 }
 
 // src/components/ConnectOptions/AbcWaasAuth/hooks/useAbcWaasSocial.ts
-import { useState as useState25 } from "react";
+import { useState as useState26 } from "react";
 
 // src/services/AbcAuthService.ts
 import { getTalkenApiClient as getTalkenApiClient3 } from "@talken/talkenkit";
@@ -11115,20 +11538,14 @@ async function performSnsLogin(token, service, email) {
   if (!api) {
     throw new Error("TalkenApiClient not initialized");
   }
-  try {
-    const res = await api.auth.loginWithSns({ token, service });
-    return {
-      uid: res.uid,
-      access_token: res.accessToken,
-      refresh_token: res.refreshToken,
-      email: res.email || email,
-      user_type: res.isNewUser ? "new" : "existing"
-    };
-  } catch (err) {
-    if (err.name === "TalkenApiError" && err.details?.code === 618) {
-    }
-    throw err;
-  }
+  const res = await api.auth.loginWithSns({ token, service });
+  return {
+    uid: res.uid,
+    access_token: res.accessToken,
+    refresh_token: res.refreshToken,
+    email: res.email || email,
+    user_type: res.isNewUser ? "new" : "existing"
+  };
 }
 async function googleLogin2(_config) {
   initializeFirebase();
@@ -11154,26 +11571,26 @@ async function kakaoLogin2(_config) {
 // src/components/ConnectOptions/AbcWaasAuth/hooks/useAbcWaasSocial.ts
 function useAbcWaasSocial(props) {
   const { onPinRequired, onEmailSet } = props;
-  const [isLoading, setIsLoading] = useState25(false);
-  const [error2, setError] = useState25("");
-  const STORAGE_PREFIX2 = "talkenkit_abc_";
+  const [isLoading, setIsLoading] = useState26(false);
+  const [error2, setError] = useState26("");
+  const STORAGE_PREFIX3 = "talkenkit_abc_";
   const clearExpiredEncryptedData = () => {
-    const expiresAtStr = localStorage.getItem(`${STORAGE_PREFIX2}expires_at`);
+    const expiresAtStr = localStorage.getItem(`${STORAGE_PREFIX3}expires_at`);
     const hasEncryptedTokens = localStorage.getItem(
-      `${STORAGE_PREFIX2}enc_tokens`
+      `${STORAGE_PREFIX3}enc_tokens`
     );
     if (!hasEncryptedTokens)
       return;
     const expiresAt = expiresAtStr ? Number(expiresAtStr) : 0;
     const isExpired = Date.now() >= expiresAt;
     if (isExpired) {
-      localStorage.removeItem(`${STORAGE_PREFIX2}enc_tokens`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}enc_salt`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}auth_state`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}user`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}wallet`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}solana_wallet`);
-      localStorage.removeItem(`${STORAGE_PREFIX2}bitcoin_wallet`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}enc_tokens`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}enc_salt`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}auth_state`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}user`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}wallet`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}solana_wallet`);
+      localStorage.removeItem(`${STORAGE_PREFIX3}bitcoin_wallet`);
     }
   };
   const saveAuthState = (response, provider) => {
@@ -11191,23 +11608,23 @@ function useAbcWaasSocial(props) {
       expiresAt: Date.now() + ((response.expires_in || response.expiresIn || 3600) > 0 ? response.expires_in || response.expiresIn || 3600 : 3600) * 1e3
     };
     localStorage.setItem(
-      `${STORAGE_PREFIX2}auth_state`,
+      `${STORAGE_PREFIX3}auth_state`,
       JSON.stringify(authState)
     );
     localStorage.setItem(
-      `${STORAGE_PREFIX2}user`,
+      `${STORAGE_PREFIX3}user`,
       JSON.stringify(authState.user)
     );
     localStorage.setItem(
-      `${STORAGE_PREFIX2}access_token`,
+      `${STORAGE_PREFIX3}access_token`,
       response.access_token
     );
     localStorage.setItem(
-      `${STORAGE_PREFIX2}refresh_token`,
+      `${STORAGE_PREFIX3}refresh_token`,
       response.refresh_token
     );
     localStorage.setItem(
-      `${STORAGE_PREFIX2}expires_at`,
+      `${STORAGE_PREFIX3}expires_at`,
       String(authState.expiresAt)
     );
   };
@@ -11215,11 +11632,8 @@ function useAbcWaasSocial(props) {
     onEmailSet?.(response.email);
     clearExpiredEncryptedData();
     saveAuthState(response, provider);
-    const pinMapStr = localStorage.getItem(`${STORAGE_PREFIX2}pin_map`) || "{}";
-    const pinMap = JSON.parse(pinMapStr);
-    const hasPinInMap = !!pinMap[response.email];
-    const hasEncryptedTokens = !!(localStorage.getItem(`${STORAGE_PREFIX2}enc_tokens`) && localStorage.getItem(`${STORAGE_PREFIX2}enc_salt`));
-    onPinRequired(response, response.email, hasPinInMap && hasEncryptedTokens);
+    const hasEncryptedTokens = !!(localStorage.getItem(`${STORAGE_PREFIX3}enc_tokens`) && localStorage.getItem(`${STORAGE_PREFIX3}enc_salt`));
+    onPinRequired(response, response.email, hasEncryptedTokens);
   };
   const handleGoogleLogin = async () => {
     setIsLoading(true);
@@ -11284,15 +11698,11 @@ function AbcWaasAuthFlow({
   onPinVerifyRequired,
   compact = false
 }) {
-  const STORAGE_PREFIX2 = "talkenkit_abc_";
+  const STORAGE_PREFIX3 = "talkenkit_abc_";
   const abcAuth = useAbcWaasAuth({
-    onPinRequired: (loginData) => {
+    onPinRequired: async (loginData) => {
       console.log("[AbcWaasAuthFlow] \u{1F510} PIN required for email login");
-      const pinMapStr = localStorage.getItem(`${STORAGE_PREFIX2}pin_map`) || "{}";
-      const pinMap = JSON.parse(pinMapStr);
-      const hasPinInMap = !!pinMap[abcAuth.email];
-      const hasEncryptedTokens = !!(localStorage.getItem(`${STORAGE_PREFIX2}enc_tokens`) && localStorage.getItem(`${STORAGE_PREFIX2}enc_salt`));
-      const canVerifyPin = hasPinInMap && hasEncryptedTokens;
+      const canVerifyPin = !!(localStorage.getItem(`${STORAGE_PREFIX3}enc_tokens`) && localStorage.getItem(`${STORAGE_PREFIX3}enc_salt`));
       console.log("[AbcWaasAuthFlow] \u{1F50D} PIN verification check:", {
         result: canVerifyPin ? "Verify PIN" : "Create new PIN"
       });
@@ -11300,11 +11710,8 @@ function AbcWaasAuthFlow({
         console.log(
           "[AbcWaasAuthFlow] \u2705 PIN verification possible - routing to verify modal"
         );
-        localStorage.setItem(
-          `${STORAGE_PREFIX2}pin_hash`,
-          pinMap[abcAuth.email]
-        );
-        localStorage.setItem(`${STORAGE_PREFIX2}saved_email`, abcAuth.email);
+        const { getCredentialManager: getCredentialManager2 } = await import("./AbcCredentialManager-DDHLW2IH.js");
+        getCredentialManager2().setEmail(abcAuth.email);
         onPinVerifyRequired(loginData);
       } else {
         console.log(
@@ -11373,7 +11780,7 @@ function AbcWaasAuthFlow({
 }
 
 // src/components/ConnectOptions/ConnectDetails.tsx
-import React83, { useContext as useContext19, useEffect as useEffect23 } from "react";
+import React83, { useContext as useContext19, useEffect as useEffect24 } from "react";
 
 // src/utils/colors.ts
 var convertHexToRGBA = (hexCode, opacity = 1) => {
@@ -11792,7 +12199,7 @@ function ConnectDetail({
   } : null;
   const { width: windowWidth } = useWindowSize();
   const smallWindow = windowWidth && windowWidth < 768;
-  useEffect23(() => {
+  useEffect24(() => {
     preloadBrowserIcon();
     preloadPlatformIcon();
   }, []);
@@ -12149,7 +12556,7 @@ function DownloadOptionsDetail({
     mobileDownloadUrl
   } = wallet;
   const { i18n: i18n2 } = useContext19(I18nContext);
-  useEffect23(() => {
+  useEffect24(() => {
     preloadCreateIcon();
     preloadScanIcon();
     preloadRefreshIcon();
@@ -12245,7 +12652,7 @@ function DownloadDetail({
 }) {
   const { downloadUrls, qrCode } = wallet;
   const { i18n: i18n2 } = useContext19(I18nContext);
-  useEffect23(() => {
+  useEffect24(() => {
     preloadCreateIcon();
     preloadScanIcon();
   }, []);
@@ -12577,12 +12984,12 @@ import React85, { Fragment as Fragment2 } from "react";
 import React84 from "react";
 
 // src/components/RainbowKitProvider/useCoolMode.ts
-import { useContext as useContext20, useEffect as useEffect24, useRef as useRef12 } from "react";
+import { useContext as useContext20, useEffect as useEffect25, useRef as useRef12 } from "react";
 var useCoolMode = (imageUrl) => {
   const ref = useRef12(null);
   const coolModeEnabled = useContext20(CoolModeContext);
   const resolvedImageUrl = useAsyncImage(imageUrl);
-  useEffect24(() => {
+  useEffect25(() => {
     if (coolModeEnabled && ref.current && resolvedImageUrl) {
       return makeElementCool(ref.current, resolvedImageUrl);
     }
@@ -13024,7 +13431,7 @@ function PopularWalletList({
 PopularWalletList.displayName = "PopularWalletList";
 
 // src/components/ConnectOptions/ExternalWallets/hooks/useWalletConnection.ts
-import { useEffect as useEffect25, useState as useState26 } from "react";
+import { useEffect as useEffect26, useState as useState27 } from "react";
 
 // src/wallets/latestWalletId.ts
 var storageKey6 = "rk-latest-id";
@@ -13043,10 +13450,10 @@ function useWalletConnection({
   onSuccess,
   initialWallet
 }) {
-  const [selectedWallet, setSelectedWallet] = useState26(initialWallet);
-  const [qrCodeUri, setQrCodeUri] = useState26();
-  const [connectionError, setConnectionError] = useState26(false);
-  useEffect25(() => {
+  const [selectedWallet, setSelectedWallet] = useState27(initialWallet);
+  const [qrCodeUri, setQrCodeUri] = useState27();
+  const [connectionError, setConnectionError] = useState27(false);
+  useEffect26(() => {
     setConnectionError(false);
   }, []);
   const getQrCode = async (wallet) => {
@@ -13115,13 +13522,13 @@ function useWalletConnection({
 
 // src/components/ConnectOptions/PinAuth/PinAuthFlow.tsx
 import React89, {
-  useState as useState31,
+  useState as useState32,
   forwardRef,
   useImperativeHandle
 } from "react";
 
 // src/components/AbcAuth/PinInputModal.tsx
-import React88, { useState as useState27, useEffect as useEffect26, useMemo as useMemo17 } from "react";
+import React88, { useState as useState28, useEffect as useEffect27, useMemo as useMemo17 } from "react";
 
 // src/components/AbcAuth/PinInputModal.css.ts
 var actions4 = "_1qacwvac";
@@ -13175,14 +13582,14 @@ function PinInputModal({
   loadingMessage: loadingMessage2 = "Creating wallet...",
   progressSteps: progressSteps2
 }) {
-  const [pin, setPin] = useState27("");
-  const [error2, setError] = useState27("");
-  const [isLoading, setIsLoading] = useState27(false);
+  const [pin, setPin] = useState28("");
+  const [error2, setError] = useState28("");
+  const [isLoading, setIsLoading] = useState28(false);
   const _isActuallyLoading = isLoading || externalLoading;
   const keypadNumbers = useMemo17(() => {
     return shuffleArray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
   }, []);
-  useEffect26(() => {
+  useEffect27(() => {
     if (isOpen) {
       setPin("");
       setIsLoading(false);
@@ -13190,7 +13597,7 @@ function PinInputModal({
       setError("");
     }
   }, [isOpen]);
-  useEffect26(() => {
+  useEffect27(() => {
     if (errorMessage) {
       setError(errorMessage);
     }
@@ -13381,13 +13788,13 @@ function PinInputModal({
 }
 
 // src/components/ConnectOptions/PinAuth/hooks/usePinCreation.ts
-import { useState as useState28 } from "react";
+import { useState as useState29 } from "react";
 function usePinCreation(props) {
   const { onPinConfirmed, onShowConfirmModal } = props;
-  const [pin, setPin] = useState28("");
-  const [confirmPin, setConfirmPin] = useState28("");
-  const [error2, setError] = useState28("");
-  const [isCreating, setIsCreating] = useState28(false);
+  const [pin, setPin] = useState29("");
+  const [confirmPin, setConfirmPin] = useState29("");
+  const [error2, setError] = useState29("");
+  const [isCreating, setIsCreating] = useState29(false);
   const handlePinCreate = async (createdPin) => {
     console.log("[PinCreation] = Creating PIN");
     setPin(createdPin);
@@ -13436,7 +13843,7 @@ function usePinCreation(props) {
 }
 
 // src/components/ConnectOptions/PinAuth/hooks/usePinVerification.ts
-import { useState as useState29 } from "react";
+import { useState as useState30 } from "react";
 function usePinVerification(props) {
   const {
     email,
@@ -13444,9 +13851,9 @@ function usePinVerification(props) {
     onSessionExpired,
     storagePrefix = "talkenkit_abc_"
   } = props;
-  const [isVerifying, setIsVerifying] = useState29(false);
-  const [error2, setError] = useState29("");
-  const [progress, setProgress] = useState29([]);
+  const [isVerifying, setIsVerifying] = useState30(false);
+  const [error2, setError] = useState30("");
+  const [progress, setProgress] = useState30([]);
   const handlePinVerify = async (pin) => {
     console.log("[PinVerification] = Verifying PIN");
     setProgress([
@@ -13542,7 +13949,10 @@ function usePinVerification(props) {
           const newSensitiveData = {
             accessToken: newAccessToken,
             refreshToken: newRefreshToken,
-            expiresAt: newExpiresAt
+            expiresAt: newExpiresAt,
+            solanaWallet: sensitiveData.solanaWallet,
+            bitcoinWallet: sensitiveData.bitcoinWallet,
+            tronWallet: sensitiveData.tronWallet
           };
           const saltBytes = new Uint8Array(
             (saltHex || "").match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
@@ -13582,7 +13992,6 @@ function usePinVerification(props) {
             localStorage.removeItem(`${storagePrefix}enc_salt`);
             localStorage.removeItem(`${storagePrefix}user`);
             localStorage.removeItem(`${storagePrefix}wallet`);
-            localStorage.removeItem(`${storagePrefix}pin_hash`);
             localStorage.removeItem(`${storagePrefix}access_token`);
             localStorage.removeItem(`${storagePrefix}refresh_token`);
             onSessionExpired?.();
@@ -13594,27 +14003,24 @@ function usePinVerification(props) {
         }
       }
       const userStr = localStorage.getItem(`${storagePrefix}user`);
+      if (sensitiveData.solanaWallet)
+        authState.solanaWallet = sensitiveData.solanaWallet;
+      if (sensitiveData.bitcoinWallet)
+        authState.bitcoinWallet = sensitiveData.bitcoinWallet;
+      if (sensitiveData.tronWallet)
+        authState.tronWallet = sensitiveData.tronWallet;
       const walletStr = localStorage.getItem(`${storagePrefix}wallet`);
-      const solanaWalletStr = localStorage.getItem(
-        `${storagePrefix}solana_wallet`
-      );
-      const bitcoinWalletStr = localStorage.getItem(
-        `${storagePrefix}bitcoin_wallet`
-      );
-      if (userStr)
-        authState.user = JSON.parse(userStr);
       if (walletStr)
         authState.wallet = JSON.parse(walletStr);
-      if (solanaWalletStr)
-        authState.solanaWallet = JSON.parse(solanaWalletStr);
-      if (bitcoinWalletStr)
-        authState.bitcoinWallet = JSON.parse(bitcoinWalletStr);
+      if (userStr)
+        authState.user = JSON.parse(userStr);
       localStorage.setItem(
         `${storagePrefix}auth_state`,
         JSON.stringify(authState)
       );
-      localStorage.setItem(`${storagePrefix}pin_hash`, hashedPin);
-      localStorage.setItem(`${storagePrefix}saved_email`, email);
+      const credMgr = getCredentialManager();
+      credMgr.setPinHash(hashedPin);
+      credMgr.setEmail(email);
       setProgress([
         { label: "Verifying PIN...", status: "completed" },
         { label: "Restoring wallet data...", status: "completed" }
@@ -13645,7 +14051,7 @@ function usePinVerification(props) {
 }
 
 // src/components/ConnectOptions/PinAuth/hooks/useWalletGeneration.ts
-import { useState as useState30 } from "react";
+import { useState as useState31 } from "react";
 function useWalletGeneration(props) {
   const {
     connectors,
@@ -13653,9 +14059,9 @@ function useWalletGeneration(props) {
     onSuccess,
     storagePrefix: _storagePrefix = "talkenkit_abc_"
   } = props;
-  const [isGenerating, setIsGenerating] = useState30(false);
-  const [progress, setProgress] = useState30([]);
-  const [statusMessage, setStatusMessage] = useState30("");
+  const [isGenerating, setIsGenerating] = useState31(false);
+  const [progress, setProgress] = useState31([]);
+  const [statusMessage, setStatusMessage] = useState31("");
   const generateWallets = async ({
     hashedPin,
     email,
@@ -13715,6 +14121,22 @@ function useWalletGeneration(props) {
       const evmAccount = accounts[0] || infoResponse || {};
       const pubkey = evmAccount.pubkey || genResponse.pubkey || "";
       const sid = evmAccount.sid || evmAddress;
+      let btcAddress = genResponse.btcAddress || "";
+      let trxAddress = genResponse.trxAddress || "";
+      if ((!btcAddress || !trxAddress) && pubkey) {
+        try {
+          const addrResponse = await api.wallet.getAddressForChain("all");
+          if (!btcAddress)
+            btcAddress = addrResponse?.btc || addrResponse?.btcAddress || "";
+          if (!trxAddress)
+            trxAddress = addrResponse?.trx || addrResponse?.trxAddress || "";
+        } catch (err) {
+          console.warn(
+            "[useWalletGeneration] Failed to derive BTC/TRX addresses:",
+            err
+          );
+        }
+      }
       const solMaterial = genResponse.solana;
       const solanaWallet = genResponse.solAddress ? {
         uid,
@@ -13727,32 +14149,39 @@ function useWalletGeneration(props) {
         secretStore: solMaterial?.secretStore || "",
         network: getSolanaNetwork()
       } : null;
-      const bitcoinWallet = genResponse.btcAddress ? {
+      const bitcoinWallet = btcAddress ? {
         uid,
         sessionId: "",
         shareId: "",
         publicKey: pubkey,
-        address: genResponse.btcAddress,
+        address: btcAddress,
         keyId: "",
         encryptedShare: "",
         addressType: "bech32",
         network: getBitcoinNetwork()
       } : null;
-      const tronWallet = genResponse.trxAddress ? {
+      const tronWallet = trxAddress ? {
         uid,
         sessionId: "",
         shareId: "",
         publicKey: pubkey,
-        address: genResponse.trxAddress,
+        address: trxAddress,
         keyId: "",
         encryptedShare: "",
         network: getTronNetwork()
       } : null;
-      const pinMapStr = localStorage.getItem(`${storagePrefix}pin_map`) || "{}";
-      const pinMap = JSON.parse(pinMapStr);
-      pinMap[email] = hashedPin;
-      localStorage.setItem(`${storagePrefix}pin_map`, JSON.stringify(pinMap));
-      localStorage.setItem(`${storagePrefix}pin_hash`, hashedPin);
+      getCredentialManager().setPinHash(hashedPin);
+      const pvencstr = evmAccount.pvencstr || "";
+      const encryptDevicePassword = evmAccount.encryptDevicePassword || "";
+      if (uid && genResponse.wid && sid && pvencstr && encryptDevicePassword) {
+        getCredentialManager().setEvmSigningCredentials({
+          uid,
+          wid: String(genResponse.wid),
+          sid,
+          pvencstr: String(pvencstr),
+          encryptDevicePassword: String(encryptDevicePassword)
+        });
+      }
       const authState = {
         isAuthenticated: true,
         user: {
@@ -13773,7 +14202,6 @@ function useWalletGeneration(props) {
         solanaWallet,
         bitcoinWallet,
         tronWallet,
-        pin: hashedPin,
         accessToken: loginData.access_token,
         refreshToken: loginData.refresh_token,
         expiresAt
@@ -13813,7 +14241,9 @@ function useWalletGeneration(props) {
         accessToken: loginData.access_token,
         refreshToken: loginData.refresh_token || "",
         expiresAt: authState.expiresAt,
-        solanaWallet: authState.solanaWallet
+        solanaWallet: authState.solanaWallet,
+        bitcoinWallet: authState.bitcoinWallet,
+        tronWallet: authState.tronWallet
       });
       const encrypted = await encryptWithPin(sensitiveData, hashedPin, salt);
       localStorage.setItem(
@@ -13858,9 +14288,9 @@ var PinAuthFlow = forwardRef(
       connect,
       storagePrefix = "talkenkit_abc_"
     } = props;
-    const [isPinCreateModalOpen, setIsPinCreateModalOpen] = useState31(false);
-    const [isPinConfirmModalOpen, setIsPinConfirmModalOpen] = useState31(false);
-    const [isPinVerifyModalOpen, setIsPinVerifyModalOpen] = useState31(false);
+    const [isPinCreateModalOpen, setIsPinCreateModalOpen] = useState32(false);
+    const [isPinConfirmModalOpen, setIsPinConfirmModalOpen] = useState32(false);
+    const [isPinVerifyModalOpen, setIsPinVerifyModalOpen] = useState32(false);
     const walletGeneration = useWalletGeneration({
       connectors,
       connect,
@@ -13891,9 +14321,10 @@ var PinAuthFlow = forwardRef(
         setIsPinVerifyModalOpen(false);
         const authStateStr = localStorage.getItem(`${storagePrefix}auth_state`);
         const authState = authStateStr ? JSON.parse(authStateStr) : null;
-        const needsWalletGeneration = authState && (!authState.wallet || !authState.solanaWallet);
+        const needsWalletGeneration = authState && (!authState.wallet || !authState.solanaWallet || !authState.bitcoinWallet || !authState.tronWallet);
         if (needsWalletGeneration) {
-          const pinHash = localStorage.getItem(`${storagePrefix}pin_hash`);
+          const { getCredentialManager: getCredentialManager2 } = await import("./AbcCredentialManager-DDHLW2IH.js");
+          const pinHash = getCredentialManager2().getPinHash();
           if (pinHash) {
             await walletGeneration.generateWallets({
               hashedPin: pinHash,
@@ -13997,9 +14428,9 @@ function ConnectOptionsModal({
   const compactModeEnabled = modalSize === ModalSizeOptions.COMPACT;
   const { disclaimer: Disclaimer } = useContext21(AppContext);
   const { i18n: i18n2 } = useContext21(I18nContext);
-  const STORAGE_PREFIX2 = "talkenkit_abc_";
-  const [abcWaasLoginData, setAbcWaasLoginData] = useState32(null);
-  const [email, setEmail] = useState32("");
+  const STORAGE_PREFIX3 = "talkenkit_abc_";
+  const [abcWaasLoginData, setAbcWaasLoginData] = useState33(null);
+  const [email, setEmail] = useState33("");
   const initialized = useRef13(false);
   const pinAuthFlowRef = useRef13(null);
   const { connector } = useContext21(WalletButtonContext);
@@ -14023,7 +14454,7 @@ function ConnectOptionsModal({
     "Others",
     "Installed"
   ];
-  useEffect28(() => {
+  useEffect29(() => {
     if (connector && !initialized.current) {
       changeWalletStep("CONNECT" /* Connect */);
       walletConnection.selectWallet(connector);
@@ -14061,10 +14492,10 @@ function ConnectOptionsModal({
     }
     setWalletStep(newWalletStep);
   };
-  const [initialWalletStep, setInitialWalletStep] = useState32(
+  const [initialWalletStep, setInitialWalletStep] = useState33(
     compactModeEnabled ? "NONE" /* None */ : "LEARN_COMPACT" /* LearnCompact */
   );
-  const [walletStep, setWalletStep] = useState32(
+  const [walletStep, setWalletStep] = useState33(
     compactModeEnabled ? "NONE" /* None */ : "LEARN_COMPACT" /* LearnCompact */
   );
   let walletContent = null;
@@ -14212,7 +14643,7 @@ function ConnectOptionsModal({
         },
         connectors,
         connect,
-        storagePrefix: STORAGE_PREFIX2
+        storagePrefix: STORAGE_PREFIX3
       }
     ));
   }
@@ -14437,7 +14868,7 @@ function ConnectOptionsModal({
         },
         connectors,
         connect,
-        storagePrefix: STORAGE_PREFIX2
+        storagePrefix: STORAGE_PREFIX3
       }
     )
   );
@@ -14447,9 +14878,9 @@ function ConnectOptionsModal({
 import React91, {
   useCallback as useCallback21,
   useContext as useContext22,
-  useEffect as useEffect29,
+  useEffect as useEffect30,
   useRef as useRef14,
-  useState as useState33
+  useState as useState34
 } from "react";
 
 // src/components/ConnectOptions/MobileOptions.css.ts
@@ -14530,7 +14961,7 @@ function WalletButton({
     }
     connect?.();
   }, [connect, getMobileUri, showWalletConnectModal, onClose, name, id]);
-  useEffect29(() => {
+  useEffect30(() => {
     if (connecting && !initialized.current) {
       onConnect();
       initialized.current = true;
@@ -14605,7 +15036,7 @@ function MobileOptions({ onClose }) {
   let walletContent = null;
   let headerBackgroundContrast = false;
   let headerBackButtonLink = null;
-  const [walletStep, setWalletStep] = useState33(
+  const [walletStep, setWalletStep] = useState34(
     "CONNECT" /* Connect */
   );
   const { i18n: i18n2 } = useContext22(I18nContext);
@@ -14923,8 +15354,8 @@ function ConnectOptions({ onClose }) {
       };
     }
   }, [walletContext, multiChainContext]);
-  const [connectingWallet, setConnectingWallet] = useState34(null);
-  const [shouldCloseOnConnect, setShouldCloseOnConnect] = useState34(false);
+  const [connectingWallet, setConnectingWallet] = useState35(null);
+  const [shouldCloseOnConnect, setShouldCloseOnConnect] = useState35(false);
   React93.useEffect(() => {
     if (shouldCloseOnConnect && multiChainContext?.solanaConnected) {
       setShouldCloseOnConnect(false);
@@ -15028,8 +15459,8 @@ function ConnectOptions({ onClose }) {
 }
 
 // src/components/ConnectOptions/MultiChainConnectOptions.tsx
-import { useWallet as useWallet5 } from "@solana/wallet-adapter-react";
-import React96, { useContext as useContext25, useCallback as useCallback24, useState as useState36 } from "react";
+import { useWallet as useWallet6 } from "@solana/wallet-adapter-react";
+import React96, { useContext as useContext25, useCallback as useCallback24, useState as useState37 } from "react";
 
 // src/components/ChainSelector/ChainSelector.tsx
 import clsx3 from "clsx";
@@ -15094,8 +15525,8 @@ function ChainSelector({
 }
 
 // src/components/SolanaWalletList/SolanaWalletList.tsx
-import { useWallet as useWallet4 } from "@solana/wallet-adapter-react";
-import React95, { useCallback as useCallback23, useState as useState35 } from "react";
+import { useWallet as useWallet5 } from "@solana/wallet-adapter-react";
+import React95, { useCallback as useCallback23, useState as useState36 } from "react";
 
 // src/components/SolanaWalletList/SolanaWalletList.css.ts
 var installButton = "lkxkyzc kwh1ip19 kwh1ip1f";
@@ -15111,8 +15542,8 @@ function SolanaWalletList2({
   onConnect,
   onError
 }) {
-  const { wallets, select, connect, connecting } = useWallet4();
-  const [connectingWallet, setConnectingWallet] = useState35(null);
+  const { wallets, select, connect, connecting } = useWallet5();
+  const [connectingWallet, setConnectingWallet] = useState36(null);
   const handleWalletClick = useCallback23(
     async (walletName2) => {
       try {
@@ -15214,9 +15645,9 @@ function MultiChainConnectOptions({
   return /* @__PURE__ */ React96.createElement(UnifiedWalletList, { onClose });
 }
 function UnifiedWalletList({ onClose }) {
-  const { wallets: solanaWallets, select, connecting } = useWallet5();
+  const { wallets: solanaWallets, select, connecting } = useWallet6();
   const _multiChainContext = useContext25(MultiChainContext);
-  const [connectingWallet, setConnectingWallet] = useState36(null);
+  const [connectingWallet, setConnectingWallet] = useState37(null);
   const handleSolanaWalletClick = useCallback24(
     async (walletName2) => {
       try {
@@ -15301,7 +15732,7 @@ function ConnectModal({ onClose, open }) {
   const connectionStatus = useConnectionStatus();
   const multiChainContext = useContext26(MultiChainContext);
   const { disconnect } = useDisconnect3();
-  const { isConnecting, isConnected } = useAccount15();
+  const { isConnecting, isConnected } = useAccount16();
   React97.useEffect(() => {
     if (isConnected && open) {
       onClose();
@@ -15339,7 +15770,7 @@ function ConnectModal({ onClose, open }) {
 
 // src/components/RainbowKitProvider/ModalContext.tsx
 function useModalStateValue() {
-  const [isModalOpen, setModalOpen] = useState37(false);
+  const [isModalOpen, setModalOpen] = useState38(false);
   return {
     closeModal: useCallback25(() => setModalOpen(false), []),
     isModalOpen,
@@ -15370,9 +15801,9 @@ function ModalProvider({ children }) {
     isModalOpen: chainModalOpen,
     openModal: openChainModal
   } = useModalStateValue();
-  const [isWalletConnectModalOpen, setIsWalletConnectModalOpen] = useState37(false);
+  const [isWalletConnectModalOpen, setIsWalletConnectModalOpen] = useState38(false);
   const connectionStatus = useConnectionStatus();
-  const { chainId } = useAccount16();
+  const { chainId } = useAccount17();
   const { chains } = useConfig3();
   const isCurrentChainSupported = chains.some((chain) => chain.id === chainId);
   const multiChainContext = useContext27(MultiChainContext);
@@ -15392,7 +15823,7 @@ function ModalProvider({ children }) {
     onConnect: () => closeModals({ keepConnectModalOpen: isUnauthenticated }),
     onDisconnect: () => closeModals()
   });
-  useEffect30(() => {
+  useEffect31(() => {
     if (isUnauthenticated)
       closeModals();
   }, [isUnauthenticated, closeModals]);
@@ -15466,8 +15897,8 @@ function ConnectButtonRenderer({
   children
 }) {
   const isMounted = useIsMounted();
-  const { address } = useAccount17();
-  const { chainId } = useAccount17();
+  const { address } = useAccount18();
+  const { chainId } = useAccount18();
   const { chains: wagmiChains } = useConfig4();
   const isCurrentChainSupported = wagmiChains.some(
     (chain) => chain.id === chainId
@@ -15559,21 +15990,21 @@ function ConnectButton({
   const chains = useRainbowKitChains();
   const connectionStatus = useConnectionStatus();
   const { setShowBalance } = useShowBalance();
-  const [ready, setReady] = useState38(false);
+  const [ready, setReady] = useState39(false);
   const { i18n: i18n2 } = useContext29(I18nContext);
   const bitcoinWallet = useBitcoinWallet();
-  const [rollingChainIndex, setRollingChainIndex] = useState38(0);
+  const [rollingChainIndex, setRollingChainIndex] = useState39(0);
   const chainTypes = [
     "evm",
     "bitcoin",
     "solana"
   ];
-  useEffect31(() => {
+  useEffect32(() => {
     setShowBalance(showBalance);
     if (!ready)
       setReady(true);
   }, [showBalance, setShowBalance]);
-  useEffect31(() => {
+  useEffect32(() => {
     const interval = setInterval(() => {
       setRollingChainIndex((prev) => (prev + 1) % chainTypes.length);
     }, 1e4);
@@ -15855,11 +16286,11 @@ var maxWidth = "hk857q1";
 // src/components/WalletButton/WalletButtonRenderer.tsx
 import React101, {
   useContext as useContext30,
-  useEffect as useEffect32,
+  useEffect as useEffect33,
   useMemo as useMemo20,
-  useState as useState39
+  useState as useState40
 } from "react";
-import { useAccount as useAccount18, useAccountEffect as useAccountEffect4 } from "wagmi";
+import { useAccount as useAccount19, useAccountEffect as useAccountEffect4 } from "wagmi";
 function WalletButtonRenderer({
   // Wallet is the same as `connector.id` which is injected into
   // wagmi connectors
@@ -15875,14 +16306,14 @@ function WalletButtonRenderer({
     throw new Error("Connector not found");
   }
   const connectionStatus = useConnectionStatus();
-  const [loading, setLoading] = useState39(false);
-  const [isError, setIsError] = useState39(false);
+  const [loading, setLoading] = useState40(false);
+  const [isError, setIsError] = useState40(false);
   const mobile = isMobile();
-  useEffect32(() => {
+  useEffect33(() => {
     if (!connectModalOpen && connector)
       setConnector(null);
   }, [connectModalOpen, connector, setConnector]);
-  const { isConnected, isConnecting } = useAccount18();
+  const { isConnected, isConnecting } = useAccount19();
   useAccountEffect4({
     onConnect: () => {
       if (isError)
@@ -16782,10 +17213,10 @@ function getDefaultWallets(parameters) {
 
 // src/transactions/useAddRecentTransaction.ts
 import { useCallback as useCallback26 } from "react";
-import { useAccount as useAccount19 } from "wagmi";
+import { useAccount as useAccount20 } from "wagmi";
 function useAddRecentTransaction() {
   const store = useTransactionStore();
-  const { address } = useAccount19();
+  const { address } = useAccount20();
   const chainId = useChainId();
   return useCallback26(
     (transaction) => {
@@ -16807,7 +17238,7 @@ var __private__ = {
 };
 
 // src/hooks/useDeviceType.ts
-import { useEffect as useEffect33, useState as useState40 } from "react";
+import { useEffect as useEffect34, useState as useState41 } from "react";
 var BREAKPOINTS = {
   mobile: 1024,
   // 0-1024px (includes phones and tablets)
@@ -16826,13 +17257,13 @@ function getDeviceState(width) {
   };
 }
 function useDeviceType() {
-  const [state, setState] = useState40(() => {
+  const [state, setState] = useState41(() => {
     if (typeof window === "undefined") {
       return getDeviceState(1920);
     }
     return getDeviceState(window.innerWidth);
   });
-  useEffect33(() => {
+  useEffect34(() => {
     setState(getDeviceState(window.innerWidth));
     function handleResize() {
       setState(getDeviceState(window.innerWidth));
@@ -16844,8 +17275,8 @@ function useDeviceType() {
 }
 
 // src/hooks/useWalletCapabilities.ts
-import { useCallback as useCallback27, useEffect as useEffect34, useState as useState41 } from "react";
-import { useAccount as useAccount20, useWalletClient } from "wagmi";
+import { useCallback as useCallback27, useEffect as useEffect35, useState as useState42 } from "react";
+import { useAccount as useAccount21, useWalletClient } from "wagmi";
 
 // src/wallets/capabilities/requestWalletAction.ts
 import { parseSignature, toHex as toHex2 } from "viem";
@@ -17028,10 +17459,10 @@ async function detectCapabilities(params) {
 
 // src/hooks/useWalletCapabilities.ts
 function useWalletCapabilities() {
-  const { connector, address, isConnected } = useAccount20();
+  const { connector, address, isConnected } = useAccount21();
   const { data: walletClient } = useWalletClient();
-  const [capabilities, setCapabilities] = useState41(null);
-  const [isLoading, setIsLoading] = useState41(false);
+  const [capabilities, setCapabilities] = useState42(null);
+  const [isLoading, setIsLoading] = useState42(false);
   const refresh = useCallback27(async () => {
     if (!isConnected || !walletClient) {
       setCapabilities(null);
@@ -17049,7 +17480,7 @@ function useWalletCapabilities() {
       setIsLoading(false);
     }
   }, [connector?.id, connector?.name, isConnected, walletClient]);
-  useEffect34(() => {
+  useEffect35(() => {
     void refresh();
   }, [refresh]);
   const signAuthorization = useCallback27(
@@ -17140,34 +17571,26 @@ function getSolanaConfig(options = {}) {
 }
 
 // src/wallets/walletConnectors/abcWallet/AbcEvmAutoConnector.tsx
-import { useEffect as useEffect35, useRef as useRef15 } from "react";
-import { useAccount as useAccount21, useConnect as useConnect3 } from "wagmi";
+import { useEffect as useEffect36, useRef as useRef15 } from "react";
+import { useAccount as useAccount22, useConnect as useConnect3 } from "wagmi";
 function AbcEvmAutoConnector() {
   const { connectors, connect } = useConnect3();
-  const { isConnected } = useAccount21();
+  const { isConnected } = useAccount22();
   const hasAttemptedRef = useRef15(false);
-  useEffect35(() => {
+  useEffect36(() => {
     if (isConnected || hasAttemptedRef.current) {
       return;
     }
-    const authState = localStorage.getItem("talkenkit_abc_auth_state");
-    if (!authState) {
+    const authData = loadAuthState();
+    if (!authData?.wallet?.address) {
       return;
     }
-    try {
-      const authData = JSON.parse(authState);
-      if (!authData.wallet || !authData.wallet.address) {
-        return;
-      }
-      const abcConnector = connectors.find((c) => c.name === "ABC Wallet");
-      if (!abcConnector) {
-        return;
-      }
-      hasAttemptedRef.current = true;
-      connect({ connector: abcConnector });
-    } catch (error2) {
-      console.error("[AbcEvmAutoConnector] Failed to auto-connect:", error2);
+    const abcConnector = connectors.find((c) => c.name === "ABC Wallet");
+    if (!abcConnector) {
+      return;
     }
+    hasAttemptedRef.current = true;
+    connect({ connector: abcConnector });
   }, [connectors, connect, isConnected]);
   return null;
 }
@@ -17217,12 +17640,12 @@ function ChainIndicator({
 import React104, {
   createContext as createContext17,
   useContext as useContext32,
-  useState as useState42,
-  useEffect as useEffect36,
+  useState as useState43,
+  useEffect as useEffect37,
   useCallback as useCallback28
 } from "react";
 var DEBUG = true;
-var STORAGE_PREFIX = "talkenkit_abc_";
+var STORAGE_PREFIX2 = "talkenkit_abc_";
 var AbcAuthContext = createContext17(null);
 function useAbcAuth() {
   const context = useContext32(AbcAuthContext);
@@ -17232,7 +17655,7 @@ function useAbcAuth() {
   return context;
 }
 function AbcAuthProvider({ children }) {
-  const [state, setState] = useState42({
+  const [state, setState] = useState43({
     isAuthenticated: false,
     user: {
       email: null,
@@ -17245,7 +17668,9 @@ function AbcAuthProvider({ children }) {
     },
     wallets: {
       evm: null,
-      solana: null
+      solana: null,
+      bitcoin: null,
+      tron: null
     },
     pinHash: null
   });
@@ -17281,14 +17706,14 @@ function AbcAuthProvider({ children }) {
           expiresAt
         }
       }));
-      localStorage.setItem(`${STORAGE_PREFIX}access_token`, res.accessToken);
+      localStorage.setItem(`${STORAGE_PREFIX2}access_token`, res.accessToken);
       if (res.refreshToken) {
         localStorage.setItem(
-          `${STORAGE_PREFIX}refresh_token`,
+          `${STORAGE_PREFIX2}refresh_token`,
           res.refreshToken
         );
       }
-      localStorage.setItem(`${STORAGE_PREFIX}expires_at`, String(expiresAt));
+      localStorage.setItem(`${STORAGE_PREFIX2}expires_at`, String(expiresAt));
       if (DEBUG)
         console.log("[AbcAuthProvider] \u2705 Token refreshed");
       return true;
@@ -17304,10 +17729,11 @@ function AbcAuthProvider({ children }) {
   const unlockWithPin = useCallback28(async (pin) => {
     try {
       const encryptedTokens = localStorage.getItem(
-        `${STORAGE_PREFIX}enc_tokens`
+        `${STORAGE_PREFIX2}enc_tokens`
       );
-      const saltHex = localStorage.getItem(`${STORAGE_PREFIX}enc_salt`);
-      const storedPinHash = localStorage.getItem(`${STORAGE_PREFIX}pin_hash`);
+      const saltHex = localStorage.getItem(`${STORAGE_PREFIX2}enc_salt`);
+      const { getCredentialManager: getCredentialManager2 } = await import("./AbcCredentialManager-DDHLW2IH.js");
+      const storedPinHash = getCredentialManager2().getPinHash();
       if (!encryptedTokens || !saltHex || !storedPinHash) {
         throw new Error("No encrypted data found");
       }
@@ -17334,7 +17760,9 @@ function AbcAuthProvider({ children }) {
         },
         wallets: {
           evm: sensitiveData.evmWallet || null,
-          solana: sensitiveData.solanaWallet || null
+          solana: sensitiveData.solanaWallet || null,
+          bitcoin: sensitiveData.bitcoinWallet || null,
+          tron: sensitiveData.tronWallet || null
         },
         pinHash: hashedPin
       }));
@@ -17351,11 +17779,11 @@ function AbcAuthProvider({ children }) {
       isAuthenticated: false,
       user: { email: null, uid: null },
       tokens: { accessToken: null, refreshToken: null, expiresAt: null },
-      wallets: { evm: null, solana: null },
+      wallets: { evm: null, solana: null, bitcoin: null, tron: null },
       pinHash: null
     });
     const keys = Object.keys(localStorage).filter(
-      (key) => key.startsWith(STORAGE_PREFIX)
+      (key) => key.startsWith(STORAGE_PREFIX2)
     );
     for (const key of keys) {
       localStorage.removeItem(key);
@@ -17366,23 +17794,22 @@ function AbcAuthProvider({ children }) {
   const setAuthState = useCallback28((partial) => {
     setState((prev) => ({ ...prev, ...partial }));
   }, []);
-  useEffect36(() => {
+  useEffect37(() => {
     const restoreSession = async () => {
       try {
         const authStateStr = localStorage.getItem(
-          `${STORAGE_PREFIX}auth_state`
+          `${STORAGE_PREFIX2}auth_state`
         );
         const accessToken = localStorage.getItem(
-          `${STORAGE_PREFIX}access_token`
+          `${STORAGE_PREFIX2}access_token`
         );
         const refreshToken2 = localStorage.getItem(
-          `${STORAGE_PREFIX}refresh_token`
+          `${STORAGE_PREFIX2}refresh_token`
         );
         const expiresAtStr = localStorage.getItem(
-          `${STORAGE_PREFIX}expires_at`
+          `${STORAGE_PREFIX2}expires_at`
         );
-        const pinHash = localStorage.getItem(`${STORAGE_PREFIX}pin_hash`);
-        if (authStateStr && accessToken && pinHash) {
+        if (authStateStr && accessToken) {
           const authState = JSON.parse(authStateStr);
           const expiresAt = expiresAtStr ? Number(expiresAtStr) : null;
           setState({
@@ -17398,9 +17825,11 @@ function AbcAuthProvider({ children }) {
             },
             wallets: {
               evm: authState.evmWallet || authState.wallet || null,
-              solana: authState.solanaWallet || null
+              solana: authState.solanaWallet || null,
+              bitcoin: authState.bitcoinWallet || null,
+              tron: authState.tronWallet || null
             },
-            pinHash
+            pinHash: null
           });
           if (DEBUG)
             console.log("[AbcAuthProvider] \u2705 Session restored", {
@@ -17426,7 +17855,7 @@ function AbcAuthProvider({ children }) {
       );
     };
   }, []);
-  useEffect36(() => {
+  useEffect37(() => {
     if (!state.tokens.refreshToken || !state.tokens.expiresAt)
       return;
     const checkAndRefresh = () => {
@@ -17455,16 +17884,16 @@ function AbcAuthProvider({ children }) {
 import React105, {
   createContext as createContext18,
   useContext as useContext33,
-  useState as useState43,
+  useState as useState44,
   useCallback as useCallback29
 } from "react";
 var PinContext = createContext18(null);
 function PinProvider({ children }) {
-  const [isModalOpen, setIsModalOpen] = useState43(false);
-  const [purpose, setPurpose] = useState43("transaction");
-  const [pinResolver, setPinResolver] = useState43(null);
-  const [pinRejecter, setPinRejecter] = useState43(null);
-  const [error2, setError] = useState43("");
+  const [isModalOpen, setIsModalOpen] = useState44(false);
+  const [purpose, setPurpose] = useState44("transaction");
+  const [pinResolver, setPinResolver] = useState44(null);
+  const [pinRejecter, setPinRejecter] = useState44(null);
+  const [error2, setError] = useState44("");
   const requestPin = useCallback29(
     (requestPurpose = "transaction") => {
       return new Promise((resolve, reject) => {
@@ -17482,8 +17911,8 @@ function PinProvider({ children }) {
       if (!pinResolver) {
         return;
       }
-      const STORAGE_PREFIX2 = "talkenkit_abc_";
-      const storedPinHash = localStorage.getItem(`${STORAGE_PREFIX2}pin_hash`);
+      const { getCredentialManager: getCredentialManager2 } = await import("./AbcCredentialManager-DDHLW2IH.js");
+      const storedPinHash = getCredentialManager2().getPinHash();
       if (!storedPinHash) {
         throw new Error("PIN not set. Please login again.");
       }
@@ -17542,430 +17971,52 @@ function usePin() {
   return context;
 }
 
-// src/hooks/useSolanaWallet.ts
-import { useWallet as useWallet6 } from "@solana/wallet-adapter-react";
-import { useEffect as useEffect37, useState as useState44 } from "react";
-import { useAccount as useAccount22 } from "wagmi";
-function useSolanaWallet() {
-  const { isConnected: evmConnected, connector } = useAccount22();
-  const { requestInterceptor } = useNonEvmConfirmation();
-  const externalWallet = useWallet6();
-  const [abcWallet, setAbcWallet] = useState44({
-    address: null,
-    publicKey: null,
-    network: null,
-    isConnected: false,
-    provider: null
-  });
-  const [isLoading, setIsLoading] = useState44(false);
-  const [error2, setError] = useState44(null);
-  const refreshAbcWallet = async () => {
-    if (!evmConnected || !connector || connector.id !== "abc") {
-      setAbcWallet({
-        address: null,
-        publicKey: null,
-        network: null,
-        isConnected: false,
-        provider: null
-      });
-      return;
-    }
-    try {
-      setIsLoading(true);
-      setError(null);
-      const authState = localStorage.getItem("talkenkit_abc_auth_state");
-      if (!authState) {
-        setAbcWallet({
-          address: null,
-          publicKey: null,
-          network: null,
-          isConnected: false,
-          provider: null
-        });
-        return;
-      }
-      const authData = JSON.parse(authState);
-      const solanaWallet = authData.solanaWallet;
-      if (!solanaWallet || !solanaWallet.address) {
-        setAbcWallet({
-          address: null,
-          publicKey: null,
-          network: null,
-          isConnected: false,
-          provider: null
-        });
-        return;
-      }
-      const { AbcSolanaProvider } = await import("./abcWallet-O4GH6RHS.js");
-      const solanaProvider = new AbcSolanaProvider();
-      solanaProvider.setWallet(solanaWallet);
-      if (requestInterceptor) {
-        solanaProvider.setRequestInterceptor(requestInterceptor);
-      }
-      setAbcWallet({
-        address: solanaWallet.address,
-        publicKey: solanaWallet.publicKey,
-        network: solanaWallet.network || "solana_devnet",
-        isConnected: true,
-        provider: solanaProvider
-      });
-    } catch (err) {
-      setError(err);
-      setAbcWallet({
-        address: null,
-        publicKey: null,
-        network: null,
-        isConnected: false,
-        provider: null
-      });
-    } finally {
-      setIsLoading(false);
-    }
-  };
-  const refresh = refreshAbcWallet;
-  useEffect37(() => {
-    refreshAbcWallet();
-  }, [evmConnected, connector?.id]);
-  useEffect37(() => {
-    if (abcWallet.provider) {
-      abcWallet.provider.setRequestInterceptor(requestInterceptor ?? void 0);
-    }
-  }, [requestInterceptor]);
-  const activeWallet = abcWallet.isConnected ? {
-    ...abcWallet,
-    type: "abc",
-    walletName: "ABC Wallet"
-  } : externalWallet.connected ? {
-    address: externalWallet.publicKey?.toBase58() || null,
-    publicKey: externalWallet.publicKey?.toBase58() || null,
-    network: process.env.NEXT_PUBLIC_ENVIRONMENT === "production" ? "solana" : "solana_devnet",
-    isConnected: true,
-    type: "external",
-    walletName: externalWallet.wallet?.adapter.name || "External Wallet",
-    provider: null
-  } : {
-    address: null,
-    publicKey: null,
-    network: null,
-    isConnected: false,
-    type: null,
-    walletName: null,
-    provider: null
-  };
-  const signMessage = async (params) => {
-    if (activeWallet.type === "abc") {
-      if (!abcWallet.provider) {
-        throw new Error("ABC Solana provider not available");
-      }
-      const encodedMessage = new TextEncoder().encode(params.message);
-      const result = await abcWallet.provider.signMessage(
-        encodedMessage,
-        "utf8"
-      );
-      const signatureHex = Array.from(result.signature).map((b) => b.toString(16).padStart(2, "0")).join("");
-      return { signature: signatureHex };
-    }
-    if (activeWallet.type === "external") {
-      if (!externalWallet.signMessage) {
-        throw new Error("Wallet does not support message signing");
-      }
-      const encodedMessage = new TextEncoder().encode(params.message);
-      const signature = await externalWallet.signMessage(encodedMessage);
-      const bs58 = await import("bs58");
-      const signatureBase58 = bs58.default.encode(signature);
-      return { signature: signatureBase58 };
-    }
-    throw new Error("No Solana wallet connected");
-  };
-  const transfer = async (params) => {
-    if (activeWallet.type === "abc") {
-      if (!abcWallet.provider) {
-        throw new Error("ABC Solana provider not available");
-      }
-      return await abcWallet.provider.transfer(params);
-    }
-    if (activeWallet.type === "external") {
-      if (!externalWallet.publicKey || !externalWallet.sendTransaction) {
-        throw new Error("Wallet does not support transactions");
-      }
-      const isMainnet = process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
-      const rpcUrl = isMainnet ? process.env.NEXT_PUBLIC_SOLANA_RPC_MAINNET || "https://api.mainnet-beta.solana.com" : process.env.NEXT_PUBLIC_SOLANA_RPC_DEVNET || "https://api.devnet.solana.com";
-      if (params.mintAddress) {
-        const { Connection: Connection3, PublicKey: PublicKey3, Transaction: Transaction3 } = await import("@solana/web3.js");
-        const {
-          getAssociatedTokenAddress,
-          createAssociatedTokenAccountInstruction,
-          createTransferInstruction,
-          TOKEN_PROGRAM_ID
-        } = await import("@solana/spl-token");
-        const connection2 = new Connection3(rpcUrl, "confirmed");
-        const mintPubkey = new PublicKey3(params.mintAddress);
-        const fromPubkey2 = externalWallet.publicKey;
-        const toPubkey2 = new PublicKey3(params.toAddress);
-        const mintInfo = await connection2.getParsedAccountInfo(mintPubkey);
-        const decimals = mintInfo.value?.data?.parsed?.info?.decimals || 0;
-        const fromTokenAccount = await getAssociatedTokenAddress(
-          mintPubkey,
-          fromPubkey2,
-          false,
-          TOKEN_PROGRAM_ID
-        );
-        const toTokenAccount = await getAssociatedTokenAddress(
-          mintPubkey,
-          toPubkey2,
-          false,
-          TOKEN_PROGRAM_ID
-        );
-        const transaction2 = new Transaction3();
-        const accountInfo = await connection2.getAccountInfo(toTokenAccount);
-        if (!accountInfo) {
-          transaction2.add(
-            createAssociatedTokenAccountInstruction(
-              fromPubkey2,
-              toTokenAccount,
-              toPubkey2,
-              mintPubkey,
-              TOKEN_PROGRAM_ID
-            )
-          );
-        }
-        const rawAmount = Math.floor(params.amount * 10 ** decimals);
-        transaction2.add(
-          createTransferInstruction(
-            fromTokenAccount,
-            toTokenAccount,
-            fromPubkey2,
-            rawAmount,
-            [],
-            TOKEN_PROGRAM_ID
-          )
-        );
-        const { blockhash: blockhash2, lastValidBlockHeight: lastValidBlockHeight2 } = await connection2.getLatestBlockhash();
-        transaction2.recentBlockhash = blockhash2;
-        transaction2.feePayer = fromPubkey2;
-        const signature2 = await externalWallet.sendTransaction(
-          transaction2,
-          connection2
-        );
-        await connection2.confirmTransaction({
-          signature: signature2,
-          blockhash: blockhash2,
-          lastValidBlockHeight: lastValidBlockHeight2
-        });
-        return { signature: signature2 };
-      }
-      const {
-        Connection: Connection2,
-        PublicKey: PublicKey2,
-        SystemProgram,
-        Transaction: Transaction2,
-        LAMPORTS_PER_SOL
-      } = await import("@solana/web3.js");
-      const connection = new Connection2(rpcUrl, "confirmed");
-      const fromPubkey = externalWallet.publicKey;
-      const toPubkey = new PublicKey2(params.toAddress);
-      const transaction = new Transaction2().add(
-        SystemProgram.transfer({
-          fromPubkey,
-          toPubkey,
-          lamports: params.amount * LAMPORTS_PER_SOL
-        })
-      );
-      const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
-      transaction.recentBlockhash = blockhash;
-      transaction.feePayer = fromPubkey;
-      const signature = await externalWallet.sendTransaction(
-        transaction,
-        connection
-      );
-      await connection.confirmTransaction({
-        signature,
-        blockhash,
-        lastValidBlockHeight
-      });
-      return { signature };
-    }
-    throw new Error("No Solana wallet connected");
-  };
-  const getTokenBalance = async (mintAddress) => {
-    if (activeWallet.type === "abc") {
-      if (!abcWallet.provider) {
-        throw new Error("ABC Solana provider not available");
-      }
-      return await abcWallet.provider.getTokenBalance(mintAddress);
-    }
-    if (activeWallet.type === "external") {
-      if (!externalWallet.publicKey) {
-        throw new Error("Wallet not connected");
-      }
-      const { Connection: Connection2, PublicKey: PublicKey2 } = await import("@solana/web3.js");
-      const { getAssociatedTokenAddress, TOKEN_PROGRAM_ID } = await import("@solana/spl-token");
-      const isMainnet = process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
-      const rpcUrl = isMainnet ? process.env.NEXT_PUBLIC_SOLANA_RPC_MAINNET || "https://api.mainnet-beta.solana.com" : process.env.NEXT_PUBLIC_SOLANA_RPC_DEVNET || "https://api.devnet.solana.com";
-      const connection = new Connection2(rpcUrl, "confirmed");
-      const mintPubkey = new PublicKey2(mintAddress);
-      const tokenAccount = await getAssociatedTokenAddress(
-        mintPubkey,
-        externalWallet.publicKey,
-        false,
-        TOKEN_PROGRAM_ID
-      );
-      const balance = await connection.getTokenAccountBalance(tokenAccount);
-      return {
-        amount: balance.value.amount,
-        decimals: balance.value.decimals,
-        uiAmount: balance.value.uiAmount || 0
-      };
-    }
-    throw new Error("No Solana wallet connected");
-  };
-  const signTransaction = async (transaction) => {
-    if (activeWallet.type === "abc") {
-      if (!abcWallet.provider) {
-        throw new Error("ABC Solana provider not available");
-      }
-      return await abcWallet.provider.signTransaction(transaction);
-    }
-    if (activeWallet.type === "external") {
-      if (!externalWallet.signTransaction) {
-        throw new Error("Wallet does not support transaction signing");
-      }
-      return await externalWallet.signTransaction(transaction);
-    }
-    throw new Error("No Solana wallet connected");
-  };
-  const signAllTransactions = async (transactions) => {
-    if (activeWallet.type === "abc") {
-      if (!abcWallet.provider) {
-        throw new Error("ABC Solana provider not available");
-      }
-      return await abcWallet.provider.signAllTransactions(transactions);
-    }
-    if (activeWallet.type === "external") {
-      if (!externalWallet.signAllTransactions) {
-        throw new Error("Wallet does not support batch signing");
-      }
-      return await externalWallet.signAllTransactions(transactions);
-    }
-    throw new Error("No Solana wallet connected");
-  };
-  const sendTransactionUniversal = async (transaction, connection, options) => {
-    if (activeWallet.type === "abc") {
-      throw new Error(
-        "sendTransactionUniversal for ABC Wallet not yet implemented. Use sendTransaction for SOL transfers."
-      );
-    }
-    if (activeWallet.type === "external") {
-      if (!externalWallet.sendTransaction) {
-        throw new Error("Wallet does not support transactions");
-      }
-      return await externalWallet.sendTransaction(
-        transaction,
-        connection,
-        options
-      );
-    }
-    throw new Error("No Solana wallet connected");
-  };
-  return {
-    address: activeWallet.address,
-    publicKey: activeWallet.publicKey,
-    network: activeWallet.network,
-    isConnected: activeWallet.isConnected,
-    type: activeWallet.type,
-    walletName: activeWallet.walletName,
-    isLoading,
-    error: error2,
-    signMessage,
-    transfer,
-    getTokenBalance,
-    signTransaction,
-    signAllTransactions,
-    sendTransactionUniversal,
-    refresh
-  };
-}
-
 // src/hooks/useTronWallet.ts
 import { useEffect as useEffect38, useState as useState45 } from "react";
 import { useAccount as useAccount23 } from "wagmi";
 function useTronWallet() {
   const { isConnected: evmConnected, connector } = useAccount23();
   const { requestInterceptor } = useNonEvmConfirmation();
-  const [wallet, setWallet] = useState45({
+  const emptyWalletState = {
     address: null,
     publicKey: null,
     network: null,
     isConnected: false,
     provider: null
-  });
+  };
+  const [wallet, setWallet] = useState45(emptyWalletState);
   const [isLoading, setIsLoading] = useState45(false);
   const [error2, setError] = useState45(null);
   const refresh = async () => {
-    if (!evmConnected || !connector || connector.id !== "abc") {
-      setWallet({
-        address: null,
-        publicKey: null,
-        network: null,
-        isConnected: false,
-        provider: null
-      });
-      return;
-    }
     try {
       setIsLoading(true);
       setError(null);
-      const authState = localStorage.getItem("talkenkit_abc_auth_state");
-      if (!authState) {
-        setWallet({
-          address: null,
-          publicKey: null,
-          network: null,
-          isConnected: false,
-          provider: null
-        });
-        return;
-      }
-      const authData = JSON.parse(authState);
-      const tronWallet = authData.tronWallet;
-      if (!tronWallet || !tronWallet.address) {
-        setWallet({
-          address: null,
-          publicKey: null,
-          network: null,
-          isConnected: false,
-          provider: null
-        });
-        return;
-      }
-      const { AbcTronProvider } = await import("./abcWallet-O4GH6RHS.js");
-      const tronProvider = new AbcTronProvider();
-      tronProvider.setWallet(tronWallet);
-      if (requestInterceptor) {
-        tronProvider.setRequestInterceptor(requestInterceptor);
-      }
-      setWallet({
-        address: tronWallet.address,
-        publicKey: tronWallet.publicKey,
-        network: tronWallet.network || "tron",
-        isConnected: true,
-        provider: tronProvider
+      const tronWallet = loadEmbeddedWalletFromAuthState("tronWallet");
+      const nextState = await restoreEmbeddedWalletState({
+        enabled: hasAbcEmbeddedSession(evmConnected, connector),
+        wallet: tronWallet,
+        emptyState: emptyWalletState,
+        requestInterceptor,
+        importProvider: async () => (await import("./abcWallet-MWUFO3JQ.js")).AbcTronProvider,
+        mapState: (nextWallet, provider) => ({
+          address: nextWallet.address,
+          publicKey: nextWallet.publicKey,
+          network: nextWallet.network || "tron",
+          isConnected: true,
+          provider
+        })
       });
+      setWallet(nextState);
     } catch (err) {
       setError(err);
-      setWallet({
-        address: null,
-        publicKey: null,
-        network: null,
-        isConnected: false,
-        provider: null
-      });
+      setWallet(emptyWalletState);
     } finally {
       setIsLoading(false);
     }
   };
   useEffect38(() => {
-    refresh();
+    void refresh();
+    return subscribeToAbcStorageUpdates(refresh);
   }, [evmConnected, connector?.id]);
   useEffect38(() => {
     if (wallet.provider) {
@@ -18179,6 +18230,7 @@ export {
   AbcWalletName,
   ChainIndicator,
   ChainSelector,
+  ConfigApi,
   ConnectButton,
   GasApi,
   Logger,
@@ -18193,9 +18245,11 @@ export {
   RainbowKitProvider,
   SessionExpiredError,
   SignConfirmationProvider,
+  SolanaApi,
   SolanaWalletList2 as SolanaWalletList,
   TalkenApiClient,
   RainbowKitProvider as TalkenKitProvider,
+  TokenApi,
   WalletButton2 as WalletButton,
   WalletscanApi,
   __private__,
@@ -18264,6 +18318,5 @@ export {
   useTronWallet,
   useWalletCapabilities,
   verifyOtpCode,
-  verifyPin,
   wagmiToEmbeddedTx
 };