@talken/talkenkit 2.3.12 → 2.3.14

package/dist/index.js

@@ -2459,16 +2459,21 @@ function cssStringFromTheme(theme, options = {}) {
 }
 
 // src/solana/SolanaWalletProvider.tsx
-import { WalletProvider } from "@solana/wallet-adapter-react";
+import {
+  ConnectionProvider,
+  WalletProvider
+} from "@solana/wallet-adapter-react";
 import {
   PhantomWalletAdapter,
   SolflareWalletAdapter
 } from "@solana/wallet-adapter-wallets";
+import { clusterApiUrl } from "@solana/web3.js";
 import React13, { useMemo as useMemo6 } from "react";
 function SolanaWalletProvider({
   children,
   wallets: customWallets,
-  autoConnect = false
+  autoConnect = false,
+  endpoint
 }) {
   const wallets = useMemo6(() => {
     if (customWallets) {
@@ -2481,7 +2486,11 @@ function SolanaWalletProvider({
       // TODO: Add AbcSolanaWalletAdapter when ready
     ];
   }, [customWallets]);
-  return /* @__PURE__ */ React13.createElement(WalletProvider, { wallets, autoConnect }, children);
+  const rpcEndpoint = useMemo6(
+    () => endpoint || clusterApiUrl("devnet"),
+    [endpoint]
+  );
+  return /* @__PURE__ */ React13.createElement(ConnectionProvider, { endpoint: rpcEndpoint }, /* @__PURE__ */ React13.createElement(WalletProvider, { wallets, autoConnect }, children));
 }
 
 // src/components/RainbowKitProvider/AppContext.ts
@@ -2870,7 +2879,10 @@ function InternalPinProvider({
   );
   const handleModalClose = useCallback3(() => {
     if (pinRejecter) {
-      pinRejecter(new Error("User cancelled PIN request"));
+      const error3 = new Error("User cancelled PIN request");
+      error3.code = 4001;
+      error3.cancelled = true;
+      pinRejecter(error3);
       setIsModalOpen(false);
       setPinResolver(null);
       setPinRejecter(null);
@@ -2892,27 +2904,28 @@ function InternalPinProvider({
     }
     const setupPinCallback = async () => {
       try {
+        if (!connector || typeof connector.getProvider !== "function") {
+          return;
+        }
         const provider = await connector.getProvider();
         if (provider && typeof provider.setRequestPinCallback === "function") {
           provider.setRequestPinCallback(() => requestPin("transaction"));
         }
-      } catch (error3) {
-        console.error(
-          "[InternalPinProvider] Failed to setup PIN callback:",
-          error3
-        );
+      } catch (_error) {
       }
     };
     setupPinCallback();
     return () => {
       const cleanup = async () => {
         try {
+          if (!connector || typeof connector.getProvider !== "function") {
+            return;
+          }
           const provider = await connector.getProvider();
           if (provider && typeof provider.setRequestPinCallback === "function") {
             provider.setRequestPinCallback(void 0);
           }
-        } catch (error3) {
-          console.error("[InternalPinProvider] Failed to cleanup:", error3);
+        } catch (_error) {
         }
       };
       cleanup();
@@ -3051,7 +3064,7 @@ function setRainbowKitVersion({ version }) {
 }
 function useFingerprint() {
   const fingerprint = useCallback4(() => {
-    setRainbowKitVersion({ version: "2.3.12" });
+    setRainbowKitVersion({ version: "2.3.14" });
   }, []);
   useEffect11(() => {
     fingerprint();
@@ -3840,6 +3853,7 @@ function RainbowKitProvider({
   avatar,
   children,
   coolMode = false,
+  autoReconnect = true,
   disableAutoPinProvider = false,
   id,
   initialChain,
@@ -3911,7 +3925,15 @@ function RainbowKitProvider({
   if (!enableSolana) {
     return providerTree;
   }
-  return /* @__PURE__ */ React26.createElement(SolanaWalletProvider, { autoConnect: solanaConfig.autoConnect }, /* @__PURE__ */ React26.createElement(MultiChainProvider, { enableSolana: true, defaultChain: "evm" }, providerTree));
+  const solanaAutoConnect = autoReconnect ?? solanaConfig.autoConnect ?? true;
+  return /* @__PURE__ */ React26.createElement(
+    SolanaWalletProvider,
+    {
+      autoConnect: solanaAutoConnect,
+      endpoint: solanaConfig.rpcEndpoint
+    },
+    /* @__PURE__ */ React26.createElement(MultiChainProvider, { enableSolana: true, defaultChain: "evm" }, providerTree)
+  );
 }
 
 // src/components/Dialog/Dialog.css.ts
@@ -5696,6 +5718,39 @@ function AbcWaasAuthSections(props) {
 // src/components/ConnectOptions/AbcWaasAuth/hooks/useAbcWaasAuth.ts
 import { useState as useState16 } from "react";
 
+// src/wallets/walletConnectors/abcWallet/networkConfig.ts
+var DEFAULT_NETWORK_CONFIG = {
+  evm: {
+    mainnet: 1,
+    // Ethereum Mainnet
+    testnet: 11155111
+    // Sepolia Testnet
+  },
+  solana: {
+    mainnet: "solana" /* Mainnet */,
+    devnet: "solana_devnet" /* Devnet */
+  },
+  bitcoin: {
+    mainnet: "bitcoin" /* Mainnet */,
+    testnet: "bitcoin_testnet" /* Testnet */
+  }
+};
+function getEnvironment() {
+  if (typeof process === "undefined") {
+    return "development";
+  }
+  const env = process.env.NEXT_PUBLIC_ENVIRONMENT;
+  return env === "production" ? "production" : "development";
+}
+function getSolanaNetwork() {
+  const environment = getEnvironment();
+  return environment === "production" ? DEFAULT_NETWORK_CONFIG.solana.mainnet : DEFAULT_NETWORK_CONFIG.solana.devnet;
+}
+function getBitcoinNetwork() {
+  const environment = getEnvironment();
+  return environment === "production" ? DEFAULT_NETWORK_CONFIG.bitcoin.mainnet : DEFAULT_NETWORK_CONFIG.bitcoin.testnet;
+}
+
 // src/wallets/walletConnectors/abcWallet/types.ts
 var AbcError = class extends Error {
   constructor(code, message, details) {
@@ -7552,9 +7607,10 @@ var AbcWaasClient = class {
       );
     }
     const result = data.result;
+    const solanaNetwork = getSolanaNetwork();
     const addressResult = await this.getSolanaAddress(
       result.public_key,
-      this.config.environment === "production" ? "solana" : "solana_devnet"
+      solanaNetwork
     );
     return {
       uid: result.uid || "",
@@ -7563,7 +7619,8 @@ var AbcWaasClient = class {
       publicKey: result.public_key,
       address: addressResult,
       keyId: result.key_id || result.share_id,
-      encryptedShare: result.encrypted_share || ""
+      encryptedShare: result.encrypted_share || "",
+      network: solanaNetwork
     };
   }
   /**
@@ -10289,7 +10346,6 @@ function useWalletConnection({
       const isUserRejection = error2?.name === "UserRejectedRequestError" || error2?.code === 4001 || // EIP-1193 user rejection code
       error2?.message?.includes("User rejected") || error2?.message?.includes("User denied");
       if (isUserRejection) {
-        console.log("[useWalletConnection] User cancelled connection");
         return;
       }
       console.error("[useWalletConnection] Connection failed:", error2);
@@ -10444,18 +10500,104 @@ function usePinVerification(props) {
       authState.expiresAt = sensitiveData.expiresAt;
       const isExpired = authState.expiresAt ? Date.now() >= authState.expiresAt : true;
       if (isExpired) {
-        console.log("[PinVerification] Access token expired");
-        localStorage.removeItem(`${storagePrefix}auth_state`);
-        localStorage.removeItem(`${storagePrefix}enc_tokens`);
-        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?.();
-        throw new Error("Session expired. Please login again.");
+        console.log(
+          "[PinVerification] \u23F0 Access token expired, attempting refresh..."
+        );
+        try {
+          const refreshToken = sensitiveData.refreshToken;
+          if (!refreshToken) {
+            throw new Error("No refresh token available");
+          }
+          const apiServerUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+          const isIframe = typeof window !== "undefined" && window.self !== window.top;
+          const isProd = process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+          const headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+            Accept: "application/json"
+          };
+          if (isProd) {
+            headers["User-Agent"] = "Android";
+          }
+          const response = await fetch(`${apiServerUrl}/abc/abcRefresh`, {
+            method: "POST",
+            headers,
+            credentials: "include",
+            body: new URLSearchParams({
+              refresh_token: refreshToken,
+              isIframe: String(isIframe)
+            }).toString()
+          });
+          const text = await response.text();
+          const data = text ? JSON.parse(text) : {};
+          if (!response.ok || !data.access_token) {
+            throw new Error("Token refresh failed");
+          }
+          console.log("[PinVerification] \u2705 Token refreshed successfully");
+          const newAccessToken = data.access_token;
+          const newRefreshToken = data.refresh_token || refreshToken;
+          const expiresIn = data.expire_in || 600;
+          const newExpiresAt = Date.now() + expiresIn * 1e3;
+          authState.accessToken = newAccessToken;
+          authState.refreshToken = newRefreshToken;
+          authState.expiresAt = newExpiresAt;
+          const newSensitiveData = {
+            accessToken: newAccessToken,
+            refreshToken: newRefreshToken,
+            expiresAt: newExpiresAt
+          };
+          const saltBytes = new Uint8Array(
+            (saltHex || "").match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+          );
+          const encryptedTokens = await encryptWithPin(
+            JSON.stringify(newSensitiveData),
+            hashedPin,
+            saltBytes
+          );
+          localStorage.setItem(`${storagePrefix}enc_tokens`, encryptedTokens);
+          localStorage.setItem(
+            `${storagePrefix}auth_state`,
+            JSON.stringify(authState)
+          );
+          console.log("[PinVerification] \u{1F504} Encrypted tokens updated");
+        } catch (refreshError) {
+          console.error(
+            "[PinVerification] \u274C Token refresh failed:",
+            refreshError
+          );
+          localStorage.removeItem(`${storagePrefix}auth_state`);
+          localStorage.removeItem(`${storagePrefix}enc_tokens`);
+          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?.();
+          throw new Error(
+            "\uC138\uC158\uC774 \uB9CC\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uB2E4\uC2DC \uB85C\uADF8\uC778\uD574 \uC8FC\uC138\uC694.\n\nYour session has expired. Please login again."
+          );
+        }
       }
+      const userStr = localStorage.getItem(`${storagePrefix}user`);
+      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);
+      localStorage.setItem(
+        `${storagePrefix}auth_state`,
+        JSON.stringify(authState)
+      );
       localStorage.setItem(`${storagePrefix}pin_hash`, hashedPin);
       localStorage.setItem(`${storagePrefix}saved_email`, email);
       setProgress([
@@ -10615,6 +10757,7 @@ function useWalletGeneration(props) {
       if (solanaResponse.ok) {
         const solanaData = await solanaResponse.json();
         const solanaResult = solanaData.result || solanaData;
+        const solanaNetwork = getSolanaNetwork();
         const addressResponse = await fetch(
           `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/wallet/getAddress`,
           {
@@ -10624,20 +10767,41 @@ function useWalletGeneration(props) {
               "Content-Type": "application/json"
             },
             body: JSON.stringify({
-              network: "solana_devnet",
+              network: solanaNetwork,
               publicKey: solanaResult.public_key
             })
           }
         );
         if (addressResponse.ok) {
           const addressData = await addressResponse.json();
+          console.log(
+            "[useWalletGeneration] Solana address response:",
+            addressData
+          );
           const solanaAddress = addressData.result?.data?.address || addressData.data?.address || addressData.address;
-          solanaWallet = {
-            ...solanaResult,
-            address: solanaAddress,
-            network: "devnet"
-          };
-          console.log("[useWalletGeneration]  Solana wallet created");
+          if (!solanaAddress) {
+            console.error(
+              "[useWalletGeneration] \u274C Solana address not found in response:",
+              addressData
+            );
+          } else {
+            solanaWallet = {
+              ...solanaResult,
+              address: solanaAddress,
+              network: solanaNetwork
+            };
+            console.log(
+              "[useWalletGeneration]  Solana wallet created:",
+              solanaAddress
+            );
+          }
+        } else {
+          const errorData = await addressResponse.json().catch(() => ({}));
+          console.error("[useWalletGeneration] \u274C Solana address API error:", {
+            status: addressResponse.status,
+            statusText: addressResponse.statusText,
+            error: errorData
+          });
         }
       }
       setProgress([
@@ -10660,8 +10824,9 @@ function useWalletGeneration(props) {
         );
       } else {
         try {
+          const bitcoinNetwork = getBitcoinNetwork();
           const btcAddressResponse = await fetch(
-            `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/btc/address?pubkey=${evmPublicKey}&network=bitcoin_testnet`,
+            `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/btc/address?pubkey=${evmPublicKey}&network=${bitcoinNetwork}`,
             {
               method: "GET",
               headers: {
@@ -10682,7 +10847,7 @@ function useWalletGeneration(props) {
                 uid: evmWallet.uid,
                 publicKey: evmPublicKey,
                 address: bitcoinAddress,
-                network: "bitcoin_testnet",
+                network: bitcoinNetwork,
                 addressType: "bech32"
               };
               console.log(
@@ -10877,9 +11042,37 @@ var PinAuthFlow = forwardRef(
     });
     const pinVerification = usePinVerification({
       email,
-      onVerified: () => {
+      onVerified: async () => {
         console.log("[PinAuthFlow] \u2705 PIN verified successfully");
         setIsPinVerifyModalOpen(false);
+        const authStateStr = localStorage.getItem(`${storagePrefix}auth_state`);
+        const authState = authStateStr ? JSON.parse(authStateStr) : null;
+        const needsWalletGeneration = authState && (!authState.wallet || !authState.solanaWallet);
+        if (needsWalletGeneration) {
+          console.log(
+            "[PinAuthFlow] \u26A0\uFE0F Missing wallets detected, generating..."
+          );
+          const pinHash = localStorage.getItem(`${storagePrefix}pin_hash`);
+          if (pinHash) {
+            await walletGeneration.generateWallets({
+              hashedPin: pinHash,
+              email,
+              loginData
+            });
+            return;
+          }
+        }
+        const abcConnector = connectors.find(
+          (c) => c.id === "abc" || c.name === "ABC Wallet"
+        );
+        if (abcConnector) {
+          console.log(
+            "[PinAuthFlow] \u{1F50C} Connecting ABC Wallet after PIN verification..."
+          );
+          connect({ connector: abcConnector });
+        } else {
+          console.error("[PinAuthFlow] \u274C ABC Wallet connector not found");
+        }
         onComplete();
       },
       onSessionExpired: () => {
@@ -10986,7 +11179,8 @@ function ConnectOptionsModal({
   const { connect } = useConnect2();
   const connectors = useConnectors();
   const walletConnection = useWalletConnection({
-    onSuccess: () => onClose(),
+    onSuccess: () => {
+    },
     initialWallet: connector || void 0
   });
   const { selectedWallet, qrCodeUri, connectionError } = walletConnection;
@@ -12223,15 +12417,8 @@ function MultiChainConnectOptions({
 }
 function UnifiedWalletList({ onClose }) {
   const { wallets: solanaWallets, select, connecting } = useWallet3();
-  const multiChainContext = useContext23(MultiChainContext);
+  const _multiChainContext = useContext23(MultiChainContext);
   const [connectingWallet, setConnectingWallet] = useState28(null);
-  const [shouldCloseOnConnect, setShouldCloseOnConnect] = useState28(false);
-  React72.useEffect(() => {
-    if (shouldCloseOnConnect && multiChainContext?.solanaConnected) {
-      setShouldCloseOnConnect(false);
-      onClose();
-    }
-  }, [shouldCloseOnConnect, multiChainContext?.solanaConnected, onClose]);
   const handleSolanaWalletClick = useCallback14(
     async (walletName2) => {
       try {
@@ -12241,11 +12428,6 @@ function UnifiedWalletList({ onClose }) {
           throw new Error(`Wallet ${walletName2} not found`);
         }
         if (wallet.adapter.connected) {
-          if (multiChainContext?.solanaConnected) {
-            onClose();
-          } else {
-            setShouldCloseOnConnect(true);
-          }
           return;
         }
         select(wallet.adapter.name);
@@ -12253,16 +12435,14 @@ function UnifiedWalletList({ onClose }) {
         const handleConnect = () => {
           wallet.adapter.off("connect", handleConnect);
           addRecentSolanaWalletId(walletName2);
-          setShouldCloseOnConnect(true);
         };
         wallet.adapter.on("connect", handleConnect);
         await wallet.adapter.connect();
         if (wallet.adapter.connected && wallet.adapter.publicKey) {
           addRecentSolanaWalletId(walletName2);
-          setShouldCloseOnConnect(true);
         }
       } catch (err) {
-        console.error("[UnifiedWalletList] \u274C Solana connection error:", err);
+        console.error("[MultiChain] Solana connection error:", err);
         const isUserRejection = err?.name === "WalletConnectionError" || err?.name === "WalletNotReadyError" || err?.message?.includes("User rejected") || err?.message?.includes("User canceled");
         if (!isUserRejection) {
           alert(
@@ -12273,7 +12453,7 @@ function UnifiedWalletList({ onClose }) {
         setConnectingWallet(null);
       }
     },
-    [solanaWallets, select, multiChainContext?.solanaConnected, onClose]
+    [solanaWallets, select]
   );
   const groupedSolanaWallets = React72.useMemo(() => {
     const groups = {
@@ -12323,16 +12503,27 @@ function ConnectModal({ onClose, open }) {
   const connectionStatus = useConnectionStatus();
   const multiChainContext = useContext24(MultiChainContext);
   const { disconnect } = useDisconnect3();
-  const { isConnecting } = useAccount14();
+  const { isConnecting, isConnected } = useAccount14();
+  React73.useEffect(() => {
+    if (isConnected && open) {
+      onClose();
+    }
+  }, [isConnected, open, onClose]);
+  React73.useEffect(() => {
+    if (multiChainContext?.solanaConnected && open) {
+      onClose();
+    }
+  }, [multiChainContext?.solanaConnected, open, onClose]);
   const onAuthCancel = React73.useCallback(() => {
     onClose();
     disconnect();
   }, [onClose, disconnect]);
   const onConnectModalCancel = React73.useCallback(() => {
-    if (isConnecting)
+    if (isConnecting && !isConnected) {
       disconnect();
+    }
     onClose();
-  }, [onClose, disconnect, isConnecting]);
+  }, [onClose, disconnect, isConnecting, isConnected]);
   if (connectionStatus === "disconnected") {
     return /* @__PURE__ */ React73.createElement(Dialog, { onClose: onConnectModalCancel, open, titleId }, /* @__PURE__ */ React73.createElement(DialogContent, { bottomSheetOnMobile: true, padding: "0", wide: true }, multiChainContext ? /* @__PURE__ */ React73.createElement(
       MultiChainConnectOptions,
@@ -12858,11 +13049,14 @@ function WalletButtonRenderer({
   }, [isConnected, firstConnector]);
   const connectWallet = async () => {
     try {
+      console.log("[WalletButton] Connecting wallet:", firstConnector?.id);
       setLoading(true);
       if (isError)
         setIsError(false);
       await firstConnector?.connect?.();
-    } catch {
+      console.log("[WalletButton] Wallet connected successfully");
+    } catch (error2) {
+      console.error("[WalletButton] Connection failed:", error2);
       setIsError(true);
     } finally {
       setLoading(false);
@@ -12996,7 +13190,7 @@ WalletButton2.Custom = WalletButtonRenderer;
 
 // src/config/getDefaultConfig.ts
 import { http } from "wagmi";
-import { createConfig } from "wagmi";
+import { createConfig, createStorage } from "wagmi";
 
 // src/wallets/computeWalletConnectMetaData.ts
 var computeWalletConnectMetaData = ({
@@ -13702,6 +13896,9 @@ var getDefaultConfig = ({
     connectors,
     chains,
     transports: transports || createDefaultTransports(chains),
+    storage: createStorage({
+      storage: typeof window !== "undefined" ? window.localStorage : void 0
+    }),
     ...restWagmiParameters
   });
 };
@@ -13757,12 +13954,709 @@ var __private__ = {
   MobileOptions
 };
 
+// src/solana/hooks/useSolanaAccount.ts
+import { useWallet as useWallet4 } from "@solana/wallet-adapter-react";
+import { useContext as useContext30, useMemo as useMemo14 } from "react";
+function useSolanaAccount() {
+  const { publicKey, connected, connecting, disconnecting, wallet } = useWallet4();
+  const multiChainContext = useContext30(MultiChainContext);
+  const accountInfo = useMemo14(() => {
+    if (wallet) {
+      const status = connected && publicKey ? "connected" : connecting ? "connecting" : "disconnected";
+      return {
+        address: publicKey?.toBase58() || null,
+        isConnected: connected && !!publicKey,
+        walletType: "external",
+        walletName: wallet.adapter.name || "Unknown Wallet",
+        publicKey,
+        // Add publicKey for external wallets
+        isConnecting: connecting,
+        isDisconnecting: disconnecting,
+        isReconnecting: false,
+        status
+      };
+    }
+    if (multiChainContext?.solanaConnected && multiChainContext?.solanaAddress) {
+      return {
+        address: multiChainContext.solanaAddress,
+        isConnected: true,
+        walletType: "abc",
+        walletName: "ABC Wallet",
+        publicKey: null,
+        // ABC Wallet doesn't use wallet-adapter publicKey
+        isConnecting: false,
+        isDisconnecting: false,
+        isReconnecting: false,
+        status: "connected"
+      };
+    }
+    try {
+      const authState = localStorage.getItem("talkenkit_abc_auth_state");
+      if (authState) {
+        const parsed = JSON.parse(authState);
+        if (parsed.isAuthenticated && parsed.solanaWallet?.address) {
+          return {
+            address: parsed.solanaWallet.address,
+            isConnected: true,
+            walletType: "abc",
+            walletName: "ABC Wallet",
+            publicKey: null,
+            // ABC Wallet doesn't use wallet-adapter publicKey
+            isConnecting: false,
+            isDisconnecting: false,
+            isReconnecting: false,
+            status: "connected"
+          };
+        }
+      }
+    } catch (_error) {
+    }
+    if (connecting) {
+      return {
+        address: null,
+        isConnected: false,
+        walletType: null,
+        walletName: null,
+        publicKey: null,
+        isConnecting: true,
+        isDisconnecting: false,
+        isReconnecting: false,
+        status: "connecting"
+      };
+    }
+    return {
+      address: null,
+      isConnected: false,
+      walletType: null,
+      walletName: null,
+      publicKey: null,
+      isConnecting: false,
+      isDisconnecting: disconnecting,
+      isReconnecting: false,
+      status: "disconnected"
+    };
+  }, [
+    connected,
+    publicKey,
+    connecting,
+    disconnecting,
+    wallet,
+    multiChainContext?.solanaConnected,
+    multiChainContext?.solanaAddress
+  ]);
+  return accountInfo;
+}
+
+// src/solana/hooks/useSolanaSignMessage.ts
+import { useWallet as useWallet5 } from "@solana/wallet-adapter-react";
+import { useCallback as useCallback17, useState as useState32 } from "react";
+
+// src/wallets/walletConnectors/abcWallet/abcSolProvider.ts
+import { PublicKey, Transaction } from "@solana/web3.js";
+var AbcSolProvider = class {
+  constructor(address, walletData) {
+    this.name = "ABC WaaS";
+    this.publicKey = null;
+    this.walletData = null;
+    if (address) {
+      this.publicKey = new PublicKey(address);
+    }
+    if (walletData) {
+      this.walletData = walletData;
+    } else if (address) {
+      this.loadWalletDataFromStorage();
+    }
+    const baseURL = process.env.NEXT_PUBLIC_ABC_WAAS_URL || "";
+    this.secure = new secure_default(baseURL);
+  }
+  /**
+   * Set PIN request callback
+   */
+  setRequestPinCallback(callback) {
+    this.requestPinCallback = callback;
+  }
+  /**
+   * Request PIN from user via callback or global callback
+   */
+  async requestPin() {
+    if (this.requestPinCallback) {
+      return this.requestPinCallback();
+    }
+    const globalCallback = window.__TALKENKIT_REQUEST_PIN__;
+    if (globalCallback) {
+      return globalCallback("transaction");
+    }
+    throw new Error("PIN request callback not configured");
+  }
+  /**
+   * Load wallet data from localStorage
+   */
+  loadWalletDataFromStorage() {
+    try {
+      const authState = localStorage.getItem("talkenkit_abc_auth_state");
+      if (authState) {
+        const parsed = JSON.parse(authState);
+        if (parsed.solanaWallet) {
+          this.walletData = parsed.solanaWallet;
+        }
+      }
+    } catch (_error) {
+    }
+  }
+  /**
+   * Get wallet data (from internal storage or localStorage)
+   */
+  getWalletData() {
+    if (this.walletData) {
+      return this.walletData;
+    }
+    const authState = localStorage.getItem("talkenkit_abc_auth_state");
+    if (authState) {
+      const parsed = JSON.parse(authState);
+      if (parsed.solanaWallet) {
+        const wallet = { ...parsed.solanaWallet };
+        if (!wallet.uid && parsed.user?.uid) {
+          wallet.uid = parsed.user.uid;
+        }
+        if (!wallet.shareId && wallet.key_id) {
+          wallet.shareId = wallet.key_id;
+        }
+        this.walletData = wallet;
+        return this.walletData;
+      }
+    }
+    throw new Error("No Solana wallet data available");
+  }
+  async signMessage(message, _encoding) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    const messageHex = Buffer.from(message).toString("hex");
+    const signBody = {
+      curve: walletData.curve,
+      encrypted_share: walletData.encrypted_share,
+      key_id: walletData.key_id,
+      message: messageHex,
+      secret_store: walletData.secret_store
+    };
+    const response = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(signBody)
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`ABC WaaS sign failed: ${errorText}`);
+    }
+    const result = await response.json();
+    const signatureHex = result.result?.signature || result.signature || result.data?.signature;
+    if (!signatureHex) {
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const signatureBytes = new Uint8Array(
+      signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    return { signature: signatureBytes };
+  }
+  async signTransaction(transaction, params) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    let toAddress;
+    let amount;
+    if (params) {
+      toAddress = params.toAddress;
+      amount = params.amount * 1e9;
+    } else {
+      const transferInstruction = transaction.instructions[0];
+      toAddress = transferInstruction.keys[1]?.pubkey.toString();
+      amount = 1e5;
+    }
+    const solanaNetwork = getSolanaNetwork();
+    const requestBody = {
+      network: solanaNetwork,
+      fromAddress: walletData.address,
+      toAddress,
+      amount,
+      feePayerAddress: walletData.address
+    };
+    const txResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/generateTransferSOLTransaction`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      }
+    );
+    if (!txResponse.ok) {
+      const errorText = await txResponse.text();
+      console.error("[AbcSolProvider] \u274C API error:", errorText);
+      throw new Error(
+        `Transaction generation failed (${txResponse.status}): ${errorText}`
+      );
+    }
+    const txData = await txResponse.json();
+    const serializedTxHex = txData.result?.data?.serialized_tx || txData.data?.serialized_tx;
+    if (!serializedTxHex) {
+      console.error(
+        "[AbcSolProvider] \u274C No serialized_tx in response:",
+        txData
+      );
+      throw new Error("No serialized transaction in response");
+    }
+    const signResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          curve: walletData.curve,
+          encrypted_share: walletData.encrypted_share,
+          key_id: walletData.key_id,
+          message: serializedTxHex,
+          secret_store: walletData.secret_store
+        })
+      }
+    );
+    if (!signResponse.ok) {
+      const errorText = await signResponse.text();
+      console.error("[AbcSolProvider] \u274C Sign API error:", errorText);
+      throw new Error(`Sign failed: ${errorText}`);
+    }
+    const signResult = await signResponse.json();
+    const signatureHex = signResult.signature || signResult.result?.signature;
+    if (!signatureHex) {
+      console.error(
+        "[AbcSolProvider] \u274C No signature in response:",
+        signResult
+      );
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const signatureBytes = new Uint8Array(
+      signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    const serializedTxBytes = new Uint8Array(
+      serializedTxHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    const signedTransaction = Transaction.from(serializedTxBytes);
+    if (!signedTransaction.signatures || signedTransaction.signatures.length === 0) {
+      signedTransaction.addSignature(
+        this.publicKey,
+        Buffer.from(signatureBytes)
+      );
+    }
+    return signedTransaction;
+  }
+  /**
+   * Send (broadcast) signed Solana transaction to network
+   * - Transaction generation: v2 API (application/json)
+   * - Transaction signing: v3 API (Ed25519 MPC)
+   * - Transaction broadcast: v2 API
+   */
+  async sendTransaction(params) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    const pin = await this.requestPin();
+    const STORAGE_PREFIX3 = "talkenkit_abc_";
+    const storedPinHash = localStorage.getItem(`${STORAGE_PREFIX3}pin_hash`);
+    if (!storedPinHash) {
+      throw new Error("PIN not set. Please login again.");
+    }
+    const enteredPinHash = await hashPin(pin);
+    if (enteredPinHash !== storedPinHash) {
+      throw new Error("Incorrect PIN. Transaction cancelled.");
+    }
+    const solanaNetwork = getSolanaNetwork();
+    const generateBody = {
+      network: solanaNetwork,
+      fromAddress: walletData.address,
+      toAddress: params.toAddress,
+      amount: params.amount * 1e9,
+      // Convert SOL to lamports
+      feePayerAddress: walletData.address
+      // Fee payer is the sender
+    };
+    const generateResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/generateTransferSOLTransaction`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(generateBody)
+      }
+    );
+    if (!generateResponse.ok) {
+      const errorText = await generateResponse.text();
+      console.error("[AbcSolProvider] \u274C Generate TX error:", errorText);
+      throw new Error(`Transaction generation failed: ${errorText}`);
+    }
+    const txData = await generateResponse.json();
+    const serializedTxHex = txData.result?.data?.serialized_tx || txData.data?.serialized_tx || txData.result?.serialized_tx || txData.serialized_tx || txData.result?.data?.serializedTX || txData.data?.serializedTX;
+    if (!serializedTxHex) {
+      console.error(
+        "[AbcSolProvider] \u274C Cannot find serialized_tx in response:",
+        {
+          hasResult: !!txData.result,
+          hasData: !!txData.data,
+          hasResultData: !!txData.result?.data,
+          resultKeys: txData.result ? Object.keys(txData.result) : [],
+          dataKeys: txData.data ? Object.keys(txData.data) : [],
+          topLevelKeys: Object.keys(txData),
+          fullResponse: txData
+        }
+      );
+      throw new Error("No serialized transaction in response");
+    }
+    const signBody = {
+      curve: walletData.curve,
+      encrypted_share: walletData.encrypted_share,
+      key_id: walletData.key_id,
+      message: serializedTxHex,
+      secret_store: walletData.secret_store
+    };
+    const signResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(signBody)
+      }
+    );
+    if (!signResponse.ok) {
+      const errorText = await signResponse.text();
+      console.error("[AbcSolProvider] \u274C Sign error:", errorText);
+      throw new Error(`Sign failed: ${errorText}`);
+    }
+    const signResult = await signResponse.json();
+    const signatureHex = signResult.signature || signResult.result?.signature || signResult.data?.signature;
+    if (!signatureHex) {
+      console.error(
+        "[AbcSolProvider] \u274C No signature in response:",
+        signResult
+      );
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const sendResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/sendTransaction`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          network: solanaNetwork,
+          serializedTX: serializedTxHex,
+          signatures: [signatureHex]
+        })
+      }
+    );
+    if (!sendResponse.ok) {
+      const errorText = await sendResponse.text();
+      console.error("[AbcSolProvider] \u274C Broadcast error:", {
+        status: sendResponse.status,
+        statusText: sendResponse.statusText,
+        error: errorText
+      });
+      try {
+        const errorData = JSON.parse(errorText);
+        if (errorData.message?.includes("insufficient") || errorData.message?.includes("InsufficientFunds")) {
+          throw new Error("Insufficient SOL balance to send transaction");
+        }
+      } catch (_parseError) {
+      }
+      throw new Error(
+        `Transaction broadcast failed (${sendResponse.status}): ${errorText}`
+      );
+    }
+    const sendResult = await sendResponse.json();
+    const txHash = sendResult.result?.data || sendResult.data || sendResult.txHash;
+    return {
+      signature: signatureHex,
+      txHash: txHash || signatureHex
+    };
+  }
+};
+
+// src/solana/hooks/useSolanaSignMessage.ts
+function useSolanaSignMessage() {
+  const { address, walletType, isConnected } = useSolanaAccount();
+  const { signMessage: externalSignMessage } = useWallet5();
+  const [signature, setSignature] = useState32(null);
+  const [isPending, setIsPending] = useState32(false);
+  const [isSuccess, setIsSuccess] = useState32(false);
+  const [isError, setIsError] = useState32(false);
+  const [error2, setError] = useState32(null);
+  const reset = useCallback17(() => {
+    setSignature(null);
+    setIsPending(false);
+    setIsSuccess(false);
+    setIsError(false);
+    setError(null);
+  }, []);
+  const signMessage = useCallback17(
+    async ({ message }) => {
+      setIsPending(true);
+      setIsSuccess(false);
+      setIsError(false);
+      setError(null);
+      setSignature(null);
+      try {
+        if (!isConnected || !address) {
+          throw new Error("Solana wallet not connected");
+        }
+        const messageBytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+        let signatureBytes;
+        if (walletType === "external") {
+          if (!externalSignMessage) {
+            throw new Error("External wallet does not support message signing");
+          }
+          signatureBytes = await externalSignMessage(messageBytes);
+        } else if (walletType === "abc") {
+          const authState = localStorage.getItem("talkenkit_abc_auth_state");
+          if (!authState) {
+            throw new Error("ABC Wallet auth state not found");
+          }
+          const parsed = JSON.parse(authState);
+          if (!parsed.solanaWallet?.address) {
+            throw new Error("ABC Solana wallet not found");
+          }
+          const provider = new AbcSolProvider(parsed.solanaWallet.address);
+          const result = await provider.signMessage(messageBytes);
+          signatureBytes = result.signature;
+        } else {
+          throw new Error("No Solana wallet connected");
+        }
+        setSignature(signatureBytes);
+        setIsSuccess(true);
+        setIsPending(false);
+        return signatureBytes;
+      } catch (err) {
+        const isUserRejection = err?.code === 4001 || err?.cancelled === true || err?.name === "WalletSignMessageError" || err?.message?.includes("User rejected") || err?.message?.includes("User canceled") || err?.message?.includes("User cancelled") || err?.message?.includes("User denied");
+        if (isUserRejection) {
+          const cancelError = err instanceof Error ? err : new Error(String(err));
+          cancelError.code = 4001;
+          cancelError.cancelled = true;
+          setError(cancelError);
+          setIsError(true);
+          setIsPending(false);
+          throw cancelError;
+        }
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        setIsError(true);
+        setIsPending(false);
+        throw errorObj;
+      }
+    },
+    [isConnected, address, walletType, externalSignMessage]
+  );
+  return {
+    signMessage,
+    signature,
+    isPending,
+    isSuccess,
+    isError,
+    error: error2,
+    reset
+  };
+}
+
+// src/solana/hooks/useSolanaSendTransaction.ts
+import { useConnection, useWallet as useWallet6 } from "@solana/wallet-adapter-react";
+import {
+  LAMPORTS_PER_SOL,
+  PublicKey as PublicKey2,
+  SystemProgram,
+  Transaction as Transaction2
+} from "@solana/web3.js";
+import { useCallback as useCallback18, useState as useState33 } from "react";
+function useSolanaSendTransaction() {
+  const {
+    address,
+    walletType,
+    isConnected,
+    publicKey: accountPublicKey
+  } = useSolanaAccount();
+  const { sendTransaction: externalSendTransaction } = useWallet6();
+  const { connection } = useConnection();
+  const [txHash, setTxHash] = useState33(null);
+  const [isPending, setIsPending] = useState33(false);
+  const [isSuccess, setIsSuccess] = useState33(false);
+  const [isError, setIsError] = useState33(false);
+  const [error2, setError] = useState33(null);
+  const reset = useCallback18(() => {
+    setTxHash(null);
+    setIsPending(false);
+    setIsSuccess(false);
+    setIsError(false);
+    setError(null);
+  }, []);
+  const sendTransaction = useCallback18(
+    async ({
+      toAddress,
+      amount
+    }) => {
+      setIsPending(true);
+      setIsSuccess(false);
+      setIsError(false);
+      setError(null);
+      setTxHash(null);
+      try {
+        if (!isConnected || !address) {
+          throw new Error("Solana wallet not connected");
+        }
+        let signature;
+        if (walletType === "external") {
+          if (!externalSendTransaction) {
+            throw new Error(
+              "External wallet does not support sending transactions"
+            );
+          }
+          if (!accountPublicKey) {
+            throw new Error(
+              "Wallet public key not available. Please reconnect your wallet."
+            );
+          }
+          const transaction = new Transaction2().add(
+            SystemProgram.transfer({
+              fromPubkey: accountPublicKey,
+              toPubkey: new PublicKey2(toAddress),
+              lamports: Math.floor(amount * LAMPORTS_PER_SOL)
+            })
+          );
+          const { blockhash } = await connection.getLatestBlockhash();
+          transaction.recentBlockhash = blockhash;
+          transaction.feePayer = accountPublicKey;
+          try {
+            signature = await externalSendTransaction(transaction, connection);
+          } catch (sendError) {
+            if (sendError?.name === "WalletSendTransactionError" && (!sendError?.message || sendError?.message === "")) {
+              throw new Error(
+                "Transaction failed. This may be due to insufficient SOL balance. Please ensure you have enough SOL for the transaction and gas fees."
+              );
+            }
+            throw sendError;
+          }
+        } else if (walletType === "abc") {
+          const authState = localStorage.getItem("talkenkit_abc_auth_state");
+          if (!authState) {
+            throw new Error("ABC Wallet auth state not found");
+          }
+          const parsed = JSON.parse(authState);
+          if (!parsed.solanaWallet?.address) {
+            throw new Error("ABC Solana wallet not found");
+          }
+          const provider = new AbcSolProvider(parsed.solanaWallet.address);
+          const result = await provider.sendTransaction({
+            toAddress,
+            amount
+          });
+          signature = result.txHash;
+        } else {
+          throw new Error("No Solana wallet connected");
+        }
+        setTxHash(signature);
+        setIsSuccess(true);
+        setIsPending(false);
+        return signature;
+      } catch (err) {
+        const isUserRejection = err?.code === 4001 || err?.cancelled === true || err?.name === "WalletSendTransactionError" || err?.message?.includes("User rejected") || err?.message?.includes("User canceled") || err?.message?.includes("User cancelled") || err?.message?.includes("User denied");
+        if (isUserRejection) {
+          const cancelError = err instanceof Error ? err : new Error(String(err));
+          cancelError.code = 4001;
+          cancelError.cancelled = true;
+          setError(cancelError);
+          setIsError(true);
+          setIsPending(false);
+          throw cancelError;
+        }
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        setIsError(true);
+        setIsPending(false);
+        throw errorObj;
+      }
+    },
+    [
+      isConnected,
+      address,
+      walletType,
+      accountPublicKey,
+      externalSendTransaction,
+      connection
+    ]
+  );
+  return {
+    sendTransaction,
+    txHash,
+    isPending,
+    isSuccess,
+    isError,
+    error: error2,
+    reset
+  };
+}
+
+// src/solana/hooks/useSolanaConnection.ts
+import { useConnection as useConnection2 } from "@solana/wallet-adapter-react";
+import { useMemo as useMemo15 } from "react";
+function detectNetwork(endpoint) {
+  const url = endpoint.toLowerCase();
+  if (url.includes("mainnet"))
+    return "mainnet-beta";
+  if (url.includes("devnet"))
+    return "devnet";
+  if (url.includes("testnet"))
+    return "testnet";
+  if (url.includes("localhost") || url.includes("127.0.0.1"))
+    return "localnet";
+  return "mainnet-beta";
+}
+function useSolanaConnection() {
+  const { connection } = useConnection2();
+  const connectionInfo = useMemo15(() => {
+    const endpoint = connection._rpcEndpoint || connection.rpcEndpoint || "";
+    const network = detectNetwork(endpoint);
+    return {
+      connection,
+      endpoint,
+      network
+    };
+  }, [connection]);
+  return connectionInfo;
+}
+
 // src/hooks/useSolSignMessage.ts
-import { useState as useState32 } from "react";
+import { useState as useState34 } from "react";
 function useSolSignMessage(solanaWallet) {
-  const [isLoading, setIsLoading] = useState32(false);
-  const [error2, setError] = useState32(null);
-  const [data, setData] = useState32(null);
+  const [isLoading, setIsLoading] = useState34(false);
+  const [error2, setError] = useState34(null);
+  const [data, setData] = useState34(null);
   const signMessage = async (params) => {
     setIsLoading(true);
     setError(null);
@@ -13802,16 +14696,16 @@ function useSolSignMessage(solanaWallet) {
 // src/hooks/useSolSignTransaction.ts
 import {
   Connection,
-  LAMPORTS_PER_SOL,
-  PublicKey,
-  SystemProgram,
-  Transaction
+  LAMPORTS_PER_SOL as LAMPORTS_PER_SOL2,
+  PublicKey as PublicKey3,
+  SystemProgram as SystemProgram2,
+  Transaction as Transaction3
 } from "@solana/web3.js";
-import { useState as useState33 } from "react";
+import { useState as useState35 } from "react";
 function useSolSignTransaction(solanaWallet) {
-  const [isLoading, setIsLoading] = useState33(false);
-  const [error2, setError] = useState33(null);
-  const [data, setData] = useState33(null);
+  const [isLoading, setIsLoading] = useState35(false);
+  const [error2, setError] = useState35(null);
+  const [data, setData] = useState35(null);
   const signTransaction = async (params) => {
     setIsLoading(true);
     setError(null);
@@ -13870,13 +14764,13 @@ async function buildTransaction(params, solanaWallet) {
   }
   const rpcUrl = solanaWallet.network === "mainnet" ? "https://api.mainnet-beta.solana.com" : "https://api.devnet.solana.com";
   const connection = new Connection(rpcUrl, "confirmed");
-  const fromPubkey = new PublicKey(provider.publicKey.toString());
-  const toPubkey = new PublicKey(params.toAddress);
-  const transaction = new Transaction().add(
-    SystemProgram.transfer({
+  const fromPubkey = new PublicKey3(provider.publicKey.toString());
+  const toPubkey = new PublicKey3(params.toAddress);
+  const transaction = new Transaction3().add(
+    SystemProgram2.transfer({
       fromPubkey,
       toPubkey,
-      lamports: params.amount * LAMPORTS_PER_SOL
+      lamports: params.amount * LAMPORTS_PER_SOL2
     })
   );
   const { blockhash } = await connection.getLatestBlockhash();
@@ -13957,23 +14851,23 @@ function ChainIndicator({
 // src/providers/AbcAuthProvider.tsx
 import React80, {
   createContext as createContext15,
-  useContext as useContext30,
-  useState as useState34,
+  useContext as useContext31,
+  useState as useState36,
   useEffect as useEffect26,
-  useCallback as useCallback17
+  useCallback as useCallback19
 } from "react";
 var DEBUG2 = true;
 var STORAGE_PREFIX2 = "talkenkit_abc_";
 var AbcAuthContext = createContext15(null);
 function useAbcAuth() {
-  const context = useContext30(AbcAuthContext);
+  const context = useContext31(AbcAuthContext);
   if (!context) {
     throw new Error("useAbcAuth must be used within AbcAuthProvider");
   }
   return context;
 }
 function AbcAuthProvider({ children }) {
-  const [state, setState] = useState34({
+  const [state, setState] = useState36({
     isAuthenticated: false,
     user: {
       email: null,
@@ -13990,12 +14884,12 @@ function AbcAuthProvider({ children }) {
     },
     pinHash: null
   });
-  const isTokenExpired2 = useCallback17(() => {
+  const isTokenExpired2 = useCallback19(() => {
     if (!state.tokens.expiresAt)
       return true;
     return Date.now() >= state.tokens.expiresAt;
   }, [state.tokens.expiresAt]);
-  const refreshToken = useCallback17(async () => {
+  const refreshToken = useCallback19(async () => {
     if (!state.tokens.refreshToken) {
       if (DEBUG2)
         console.log("[AbcAuthProvider] No refresh token available");
@@ -14054,7 +14948,7 @@ function AbcAuthProvider({ children }) {
       return false;
     }
   }, [state.tokens.refreshToken]);
-  const unlockWithPin = useCallback17(async (pin) => {
+  const unlockWithPin = useCallback19(async (pin) => {
     try {
       const encryptedTokens = localStorage.getItem(
         `${STORAGE_PREFIX2}enc_tokens`
@@ -14099,7 +14993,7 @@ function AbcAuthProvider({ children }) {
       return false;
     }
   }, []);
-  const logout = useCallback17(async () => {
+  const logout = useCallback19(async () => {
     setState({
       isAuthenticated: false,
       user: { email: null, uid: null },
@@ -14116,7 +15010,7 @@ function AbcAuthProvider({ children }) {
     if (DEBUG2)
       console.log("[AbcAuthProvider] \u2705 Logged out");
   }, []);
-  const setAuthState = useCallback17((partial) => {
+  const setAuthState = useCallback19((partial) => {
     setState((prev) => ({ ...prev, ...partial }));
   }, []);
   useEffect26(() => {
@@ -14189,21 +15083,21 @@ function AbcAuthProvider({ children }) {
 // src/components/AbcAuth/PinProvider.tsx
 import React81, {
   createContext as createContext16,
-  useContext as useContext31,
-  useState as useState35,
-  useCallback as useCallback18,
+  useContext as useContext32,
+  useState as useState37,
+  useCallback as useCallback20,
   useEffect as useEffect27
 } from "react";
 import { useAccount as useAccount19 } from "wagmi";
 var PinContext = createContext16(null);
 function PinProvider({ children }) {
-  const [isModalOpen, setIsModalOpen] = useState35(false);
-  const [purpose, setPurpose] = useState35("transaction");
-  const [pinResolver, setPinResolver] = useState35(null);
-  const [pinRejecter, setPinRejecter] = useState35(null);
-  const [error2, setError] = useState35("");
+  const [isModalOpen, setIsModalOpen] = useState37(false);
+  const [purpose, setPurpose] = useState37("transaction");
+  const [pinResolver, setPinResolver] = useState37(null);
+  const [pinRejecter, setPinRejecter] = useState37(null);
+  const [error2, setError] = useState37("");
   const { connector, isConnected } = useAccount19();
-  const requestPin = useCallback18(
+  const requestPin = useCallback20(
     (requestPurpose = "transaction") => {
       return new Promise((resolve, reject) => {
         setPurpose(requestPurpose);
@@ -14215,7 +15109,7 @@ function PinProvider({ children }) {
     },
     []
   );
-  const handlePinSubmit = useCallback18(
+  const handlePinSubmit = useCallback20(
     async (pin) => {
       if (!pinResolver) {
         return;
@@ -14239,9 +15133,12 @@ function PinProvider({ children }) {
     },
     [pinResolver]
   );
-  const handleModalClose = useCallback18(() => {
+  const handleModalClose = useCallback20(() => {
     if (pinRejecter) {
-      pinRejecter(new Error("User cancelled PIN request"));
+      const error3 = new Error("User cancelled PIN request");
+      error3.code = 4001;
+      error3.cancelled = true;
+      pinRejecter(error3);
       setIsModalOpen(false);
       setPinResolver(null);
       setPinRejecter(null);
@@ -14294,7 +15191,7 @@ function PinProvider({ children }) {
   ));
 }
 function usePin() {
-  const context = useContext31(PinContext);
+  const context = useContext32(PinContext);
   if (!context) {
     throw new Error("usePin must be used within PinProvider");
   }
@@ -14512,11 +15409,16 @@ var BaseApiClient = class {
       try {
         const isIframe = typeof window !== "undefined" && window.self !== window.top;
         const talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+        const isProd = this.config.environment === "production";
+        const headers = { ...DEFAULT_HEADERS };
+        if (isProd) {
+          headers["User-Agent"] = "Android";
+        }
         const response = await fetch(
           `${talkenApiUrl}${ABC_ENDPOINTS.REFRESH_TOKEN}`,
           {
             method: "POST",
-            headers: DEFAULT_HEADERS,
+            headers,
             credentials: "include",
             body: new URLSearchParams({
               refresh_token: this.refreshToken || "",
@@ -14571,6 +15473,9 @@ var BaseApiClient = class {
       requestHeaders["Content-Type"] = "application/json";
       requestHeaders["Accept"] = "application/json";
     }
+    if (this.config.environment === "production") {
+      requestHeaders["User-Agent"] = "Android";
+    }
     if (!skipAuth && this.accessToken) {
       requestHeaders.Authorization = `Bearer ${this.accessToken}`;
     }
@@ -15069,9 +15974,10 @@ var WalletApi = class extends BaseApiClient {
       );
     }
     const result = data.result;
+    const solanaNetwork = getSolanaNetwork();
     const addressResult = await this.getSolanaAddress(
       result.public_key,
-      this.config.environment === "production" ? "solana" : "solana_devnet"
+      solanaNetwork
     );
     return {
       uid: result.uid || "",
@@ -15080,7 +15986,8 @@ var WalletApi = class extends BaseApiClient {
       publicKey: result.public_key,
       address: addressResult,
       keyId: result.key_id || result.share_id,
-      encryptedShare: result.encrypted_share || ""
+      encryptedShare: result.encrypted_share || "",
+      network: solanaNetwork
     };
   }
   /**
@@ -15636,9 +16543,6 @@ var SolanaApi = class extends BaseApiClient {
    */
   async generateSolanaWallet(pin, isRecover = false) {
     const endpoint = `/v3/wallet/${isRecover ? "recover" : "generate"}`;
-    console.log(
-      `[SolanaApi] \u{1F527} ${isRecover ? "Recovering" : "Generating"} Solana wallet...`
-    );
     const response = await this.request(endpoint, {
       method: "POST",
       contentType: "json",
@@ -15649,7 +16553,6 @@ var SolanaApi = class extends BaseApiClient {
       }
     });
     if (response.status !== "success" || !response.result) {
-      console.error("[SolanaApi] \u274C Operation failed:", response);
       throw createAbcError(
         "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
         `Failed to ${isRecover ? "recover" : "generate"} Solana wallet`,
@@ -15658,7 +16561,7 @@ var SolanaApi = class extends BaseApiClient {
     }
     const result = response.result;
     const address = this.deriveAddressFromPublicKey(result.public_key);
-    console.log("[SolanaApi] \u2705 Wallet ready:", address);
+    const network = getSolanaNetwork();
     return {
       uid: result.uid || "",
       sessionId: result.share_id,
@@ -15666,7 +16569,9 @@ var SolanaApi = class extends BaseApiClient {
       publicKey: result.public_key,
       address,
       keyId: result.key_id || result.share_id,
-      encryptedShare: result.encrypted_share || ""
+      encryptedShare: result.encrypted_share || "",
+      secretStore: result.secret_store || "",
+      network
     };
   }
   /**
@@ -15691,16 +16596,18 @@ var SolanaApi = class extends BaseApiClient {
   }
   /**
    * Sign Solana transaction with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
    */
   async signSolanaTransaction(params) {
     const response = await this.request("/v3/wallet/sign", {
       method: "POST",
       contentType: "json",
       body: {
-        uid: params.uid,
-        share_id: params.shareId,
-        message: params.message,
-        password: params.pin
+        curve: "ed25519",
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
       }
     });
     if (response.status !== "success" || !response.result?.signature) {
@@ -15716,16 +16623,18 @@ var SolanaApi = class extends BaseApiClient {
   }
   /**
    * Sign Solana message with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
    */
   async signSolanaMessage(params) {
     const response = await this.request("/v3/wallet/sign", {
       method: "POST",
       contentType: "json",
       body: {
-        uid: params.uid,
-        share_id: params.shareId,
-        message: params.message,
-        password: params.pin
+        curve: "ed25519",
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
       }
     });
     if (response.status !== "success" || !response.result?.signature) {
@@ -16415,6 +17324,10 @@ export {
   useRainbowKitConfig,
   useSolSignMessage,
   useSolSignTransaction,
+  useSolanaAccount,
+  useSolanaConnection,
+  useSolanaSendTransaction,
+  useSolanaSignMessage,
   verifyOtpCode,
   verifyPin,
   wagmiToAbcWaas