@talken/talkenkit 2.3.15 → 2.4.5

package/dist/wallets/walletConnectors/{chunk-PPIFAF7N.js → chunk-7MOCKWA7.js}

@@ -1,10 +1,10 @@
 "use client";
 import {
   secure_default
-} from "./chunk-G2LI5MVX.js";
+} from "./chunk-NDYGTKP5.js";
 import {
   getSolanaNetwork
-} from "./chunk-A7FIBI6X.js";
+} from "./chunk-2GNL2GNB.js";
 import {
   calculateExpiryTimestamp,
   createAbcError,
@@ -13,7 +13,7 @@ import {
   parseApiError,
   removeFromStorage,
   saveToStorage
-} from "./chunk-UV5HHESJ.js";
+} from "./chunk-5RSS3SRV.js";
 import {
   ABC_AUDIENCE,
   ABC_ENDPOINTS,
@@ -1516,24 +1516,55 @@ var AbcWaasClient = class {
     const response = await fetch(url, {
       method: "POST",
       headers: {
-        ...DEFAULT_HEADERS,
+        "Content-Type": "application/json",
+        // V3 API requires JSON, not form-urlencoded
+        "Accept": "application/json",
         ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
       },
       body: JSON.stringify({
         curve: "ed25519",
         password: pin
         // PIN will be encrypted by Secure Channel
+        // Note: network parameter not needed for v3 API
       })
     });
-    const data = await response.json();
-    if (!response.ok || data.status !== "success") {
+    let data;
+    try {
+      data = await response.json();
+    } catch (e) {
+      console.error(`[AbcWaasClient] Failed to parse response from ${url}:`, e);
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        `Failed to ${isRecover ? "recover" : "generate"} Solana wallet - invalid response`,
+        { status: response.status }
+      );
+    }
+    if (!response.ok) {
+      if (!isRecover && response.status === 409) {
+        const error = createAbcError(
+          "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+          "Wallet already exists",
+          data
+        );
+        error.response = { status: 409 };
+        throw error;
+      }
+      console.error(`[AbcWaasClient] ${isRecover ? "Recover" : "Generate"} failed:`, data);
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        `Failed to ${isRecover ? "recover" : "generate"} Solana wallet`,
+        data
+      );
+    }
+    const result = data.result || data;
+    if (!result.key_id || !result.public_key || !result.encrypted_share) {
+      console.error("[AbcWaasClient] Invalid wallet response, missing required fields:", result);
       throw createAbcError(
         "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Failed to generate Solana wallet",
+        `Invalid wallet response from ${isRecover ? "recover" : "generate"}`,
         data
       );
     }
-    const result = data.result;
     const solanaNetwork = getSolanaNetwork();
     const addressResult = await this.getSolanaAddress(
       result.public_key,
@@ -1541,12 +1572,13 @@ var AbcWaasClient = class {
     );
     return {
       uid: result.uid || "",
-      sessionId: result.share_id,
-      shareId: result.share_id,
+      sessionId: result.share_id || result.key_id,
+      shareId: result.share_id || result.key_id,
       publicKey: result.public_key,
       address: addressResult,
-      keyId: result.key_id || result.share_id,
+      keyId: result.key_id,
       encryptedShare: result.encrypted_share || "",
+      secretStore: result.secret_store || "",
       network: solanaNetwork
     };
   }
@@ -1556,16 +1588,18 @@ var AbcWaasClient = class {
    */
   async getSolanaAddress(publicKey, network) {
     const url = `${this.baseURL}/wapi/v2/solana/wallet/getAddress`;
+    const body = new URLSearchParams({
+      network,
+      publicKey
+    }).toString();
     const response = await fetch(url, {
       method: "POST",
       headers: {
         ...DEFAULT_HEADERS,
+        // Contains 'Content-Type': 'application/x-www-form-urlencoded'
         ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
       },
-      body: JSON.stringify({
-        network,
-        publicKey
-      })
+      body
     });
     const data = await response.json();
     if (!response.ok || data.status !== "success") {
@@ -1586,16 +1620,22 @@ var AbcWaasClient = class {
     const response = await fetch(url, {
       method: "POST",
       headers: {
-        ...DEFAULT_HEADERS,
+        "Content-Type": "application/json",
+        Accept: "application/json",
         ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
       },
       body: JSON.stringify({
         uid: params.uid,
         share_id: params.shareId,
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        public_key: params.publicKey,
         message: params.message,
         // Hex-encoded transaction
-        password: params.pin
+        password: params.pin,
         // PIN will be encrypted
+        network: params.network
+        // Required: 'solana' or 'solana_devnet'
       })
     });
     const data = await response.json();
@@ -1619,15 +1659,21 @@ var AbcWaasClient = class {
     const response = await fetch(url, {
       method: "POST",
       headers: {
-        ...DEFAULT_HEADERS,
+        "Content-Type": "application/json",
+        Accept: "application/json",
         ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
       },
       body: JSON.stringify({
         uid: params.uid,
         share_id: params.shareId,
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        public_key: params.publicKey,
         message: params.message,
         // Hex-encoded message
-        password: params.pin
+        password: params.pin,
+        network: params.network
+        // Required: 'solana' or 'solana_devnet'
       })
     });
     const data = await response.json();

package/dist/wallets/walletConnectors/{chunk-75RN2RLT.js → chunk-7TYZCXIR.js}

@@ -1,22 +1,22 @@
 "use client";
 import {
-  WalletApi
-} from "./chunk-EGOIRXTV.js";
-import {
-  TransactionApi
-} from "./chunk-ISAMATTH.js";
+  AuthApi
+} from "./chunk-53LPTQ6J.js";
 import {
   BitcoinApi
-} from "./chunk-QKUFFUM5.js";
+} from "./chunk-DA5J6GHZ.js";
 import {
-  AuthApi
-} from "./chunk-YEHCPL4R.js";
+  SigningApi
+} from "./chunk-COPAK5YT.js";
 import {
-  SolanaApi
-} from "./chunk-7DEZCGNV.js";
+  TransactionApi
+} from "./chunk-AIKTQX6B.js";
 import {
-  SigningApi
-} from "./chunk-KKPINUPY.js";
+  WalletApi
+} from "./chunk-ZNVFM2J2.js";
+import {
+  SolanaApi
+} from "./chunk-XFGVJOQL.js";
 
 // src/wallets/walletConnectors/abcWallet/api/index.ts
 var AbcWaasApiClient = class {

package/dist/wallets/walletConnectors/{chunk-HVPQO6ZG.js → chunk-7UIXGYOT.js}

@@ -1,15 +1,15 @@
 "use client";
 import {
   createAbcWaasClient
-} from "./chunk-JR2C4XXX.js";
-import {
-  createAbcEvmProvider
-} from "./chunk-ZIYAL44B.js";
+} from "./chunk-NPF7NOA7.js";
 import {
   setGlobalDefaultBitcoinNetwork,
   setGlobalDefaultChainId,
   setGlobalDefaultSolanaNetwork
 } from "./chunk-A7FIBI6X.js";
+import {
+  createAbcEvmProvider
+} from "./chunk-2NVHWZUE.js";
 import {
   clearAuthState,
   clearEncryptedTokens,
@@ -17,7 +17,7 @@ import {
   loadAuthState,
   loadFromStorage,
   saveAuthState
-} from "./chunk-UV5HHESJ.js";
+} from "./chunk-5RSS3SRV.js";
 
 // src/wallets/walletConnectors/abcWallet/abcConnector.ts
 import { createConnector } from "wagmi";
@@ -48,21 +48,10 @@ function abcConnector(options) {
       async connect() {
         try {
           const authState = loadAuthState();
-          console.log("\u{1F527} ABC Connector connect() called:", {
-            hasAuthState: !!authState,
-            isAuthenticated: authState?.isAuthenticated,
-            hasWallet: !!authState?.wallet,
-            walletAddress: authState?.wallet?.address
-          });
           if (!authState || !authState.isAuthenticated || !authState.wallet) {
             throw new Error("ABC_LOGIN_REQUIRED");
           }
           provider.setWallet(authState.wallet);
-          console.log("\u2705 Provider wallet set:", {
-            address: authState.wallet.address,
-            chainId: authState.wallet.chainId,
-            hasPIN: !!authState.pin
-          });
           const accounts = await provider.request({
             method: "eth_requestAccounts"
           });
@@ -95,10 +84,6 @@ function abcConnector(options) {
             this.onDisconnect();
           };
           provider.on("disconnect", disconnectHandler);
-          console.log("\u2705 ABC Connector connected successfully:", {
-            accounts: accounts.length,
-            chainId: Number(currentChainId)
-          });
           wagmiConfig.emitter.emit("connect", {
             accounts,
             chainId: Number(currentChainId)

package/dist/wallets/walletConnectors/{chunk-BL57XWJY.js → chunk-7UQQKSV7.js}

@@ -1,7 +1,7 @@
 "use client";
 import {
   abcConnector
-} from "./chunk-BJHGC546.js";
+} from "./chunk-36J4NGMW.js";
 import {
   ABC_WALLET_METADATA
 } from "./chunk-VETRBBA2.js";

package/dist/wallets/walletConnectors/{chunk-FGBDWBWQ.js → chunk-AIKTQX6B.js}

@@ -1,10 +1,10 @@
 "use client";
 import {
   BaseApiClient
-} from "./chunk-KJHOGJ3A.js";
+} from "./chunk-J6VUIOSE.js";
 import {
   createAbcError
-} from "./chunk-UV5HHESJ.js";
+} from "./chunk-5RSS3SRV.js";
 
 // src/wallets/walletConnectors/abcWallet/api/TransactionApi.ts
 var TransactionApi = class extends BaseApiClient {

package/dist/wallets/walletConnectors/chunk-AO24PU7X.js

@@ -0,0 +1,104 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/sessionUtils.ts
+var SessionExpiredError = class extends Error {
+  constructor(message = "Session expired. Please reconnect your wallet.") {
+    super(message);
+    this.name = "SessionExpiredError";
+  }
+};
+function dispatchSessionExpired() {
+  if (typeof window !== "undefined") {
+    console.warn("[SessionUtils] \u{1F6A8} dispatchSessionExpired called from:");
+    console.trace();
+    window.dispatchEvent(new CustomEvent("talkenkit:session_expired"));
+  }
+}
+function handleUnauthorizedResponse(response) {
+  if (response.status === 401) {
+    dispatchSessionExpired();
+    throw new SessionExpiredError(
+      "Session expired. Please reconnect your wallet."
+    );
+  }
+}
+async function fetchWithSessionCheck(url, options) {
+  const response = await fetch(url, options);
+  if (!response.ok && response.status === 401) {
+    const errorText = await response.text();
+    console.error("[ABC WaaS] \u274C Unauthorized (401):", errorText);
+    dispatchSessionExpired();
+    throw new SessionExpiredError(
+      "Session expired. Please reconnect your wallet."
+    );
+  }
+  return response;
+}
+async function refreshAccessToken(pinCallback) {
+  if (pinCallback) {
+    await pinCallback();
+  }
+  const refreshToken = localStorage.getItem("talkenkit_abc_refresh_token");
+  if (!refreshToken) {
+    console.warn("[SessionUtils] No refresh token - opening connect modal");
+    dispatchSessionExpired();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    throw new SessionExpiredError(
+      "Session expired. Please reconnect your wallet."
+    );
+  }
+  const talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+  const refreshResponse = await fetch(`${talkenApiUrl}/abc/abcRefresh`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    credentials: "include",
+    body: new URLSearchParams({
+      refresh_token: refreshToken,
+      isIframe: String(
+        typeof window !== "undefined" && window.self !== window.top
+      )
+    }).toString()
+  });
+  if (!refreshResponse.ok) {
+    console.error(
+      "[SessionUtils] Token refresh failed:",
+      refreshResponse.status
+    );
+    dispatchSessionExpired();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    throw new SessionExpiredError(
+      "Session expired. Please reconnect your wallet."
+    );
+  }
+  const refreshData = await refreshResponse.json();
+  if (!refreshData.access_token) {
+    throw new Error("No access token in refresh response");
+  }
+  const accessToken = refreshData.access_token;
+  const expiresIn = (refreshData.expire_in || 3600) * 1e3;
+  const expiresAt = Date.now() + expiresIn;
+  localStorage.setItem("talkenkit_abc_access_token", accessToken);
+  if (refreshData.refresh_token) {
+    localStorage.setItem(
+      "talkenkit_abc_refresh_token",
+      refreshData.refresh_token
+    );
+  }
+  localStorage.setItem("talkenkit_abc_expires_at", String(expiresAt));
+  console.log(
+    "[SessionUtils] \u2705 Token refreshed - expires in:",
+    (expiresIn / 1e3 / 60 / 60).toFixed(2),
+    "hours"
+  );
+  return accessToken;
+}
+
+export {
+  SessionExpiredError,
+  dispatchSessionExpired,
+  handleUnauthorizedResponse,
+  fetchWithSessionCheck,
+  refreshAccessToken
+};

package/dist/wallets/walletConnectors/{chunk-4YJWX7I3.js → chunk-APLOMU6R.js}

@@ -1,7 +1,7 @@
 "use client";
 import {
   abcConnector
-} from "./chunk-P2GV6NQG.js";
+} from "./chunk-BV3DCJXA.js";
 import {
   ABC_WALLET_METADATA
 } from "./chunk-VETRBBA2.js";

package/dist/wallets/walletConnectors/chunk-AZAV5URB.js

@@ -0,0 +1,267 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-CNRPEVLV.js";
+import {
+  getSolanaNetwork
+} from "./chunk-A7FIBI6X.js";
+import {
+  createAbcError
+} from "./chunk-5RSS3SRV.js";
+
+// src/wallets/walletConnectors/abcWallet/api/SolanaApi.ts
+import { PublicKey } from "@solana/web3.js";
+var SolanaApi = class extends BaseApiClient {
+  /**
+   * Generate Solana wallet (Ed25519)
+   * Uses V3 API with Ed25519 curve
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @param isRecover - Whether to recover existing wallet (default: false)
+   * @returns Solana wallet information
+   */
+  async generateSolanaWallet(pin, isRecover = false) {
+    const endpoint = `/v3/wallet/${isRecover ? "recover" : "generate"}`;
+    const network = getSolanaNetwork();
+    console.log(`[SolanaApi] ${isRecover ? "Recovering" : "Generating"} Solana wallet...`, {
+      endpoint,
+      network
+    });
+    const response = await this.request(endpoint, {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        password: pin,
+        network
+      }
+    });
+    console.log("[SolanaApi] API response received:", {
+      status: response.status,
+      hasResult: !!response.result,
+      resultKeys: response.result ? Object.keys(response.result) : []
+    });
+    let result;
+    if (response.status === "success" && response.result) {
+      result = response.result;
+    } else if (response.encrypted_share && response.key_id) {
+      result = response;
+    } else {
+      console.error("[SolanaApi] API returned error:", {
+        status: response.status,
+        result: response.result,
+        endpoint,
+        fullResponse: response
+      });
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        `Failed to ${isRecover ? "recover" : "generate"} Solana wallet`,
+        response
+      );
+    }
+    console.log("[SolanaApi] generateSolanaWallet API response:", {
+      hasKeyId: "key_id" in result,
+      hasEncryptedShare: "encrypted_share" in result,
+      hasSecretStore: "secret_store" in result,
+      fields: Object.keys(result)
+    });
+    let address;
+    try {
+      address = this.deriveAddressFromPublicKey(result.public_key);
+    } catch (error) {
+      console.warn("[SolanaApi] Base58 conversion failed, using hex address:", error);
+      address = result.public_key.startsWith("0x") ? result.public_key.slice(2) : result.public_key;
+    }
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address,
+      keyId: result.key_id || result.share_id,
+      // API returns snake_case key_id
+      encryptedShare: result.encrypted_share || "",
+      // API returns snake_case encrypted_share
+      secretStore: result.secret_store || "",
+      // API returns snake_case secret_store
+      network
+      // Use network from request (already has correct value)
+    };
+  }
+  /**
+   * Recover Solana wallet (alias for generateSolanaWallet with isRecover=true)
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @returns Recovered Solana wallet information
+   */
+  async recoverSolanaWallet(pin) {
+    return this.generateSolanaWallet(pin, true);
+  }
+  /**
+   * Derive Solana address from Ed25519 public key
+   * Converts hex public key to base58-encoded Solana address
+   *
+   * @param publicKey - Ed25519 public key (hex)
+   * @returns Solana address (base58)
+   */
+  deriveAddressFromPublicKey(publicKey) {
+    const cleanKey = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+    const bytes = new Uint8Array(
+      cleanKey.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    try {
+      const pubkey = new PublicKey(bytes);
+      return pubkey.toBase58();
+    } catch (error) {
+      console.error("[SolanaApi] Failed to encode address:", error);
+      return cleanKey;
+    }
+  }
+  /**
+   * Sign Solana transaction with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
+   */
+  async signSolanaTransaction(params) {
+    const network = getSolanaNetwork();
+    console.log("[SolanaApi] signSolanaTransaction - start:", {
+      network,
+      messageLength: params.message.length,
+      messagePreview: params.message.substring(0, 40) + "..."
+    });
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        network,
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
+      }
+    });
+    console.log("[SolanaApi] signSolanaTransaction - response:", {
+      status: response.status,
+      hasResult: !!response.result,
+      hasDirectSignature: !!response.signature,
+      signature: response.signature || response.result?.signature
+    });
+    let signature;
+    if (response.status === "success" && response.result?.signature) {
+      signature = response.result.signature;
+    } else if (response.signature) {
+      signature = response.signature;
+    } else {
+      console.error("[SolanaApi] \u274C signSolanaTransaction failed:", response);
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana transaction",
+        response
+      );
+    }
+    console.log("[SolanaApi] \u2705 signSolanaTransaction success:", {
+      signatureLength: signature.length,
+      signatureFormat: signature.length === 128 ? "hex" : signature.length === 88 ? "base64" : "unknown"
+    });
+    return {
+      signature
+    };
+  }
+  /**
+   * Sign Solana message with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
+   */
+  async signSolanaMessage(params) {
+    console.log("[SolanaApi] signSolanaMessage params:", {
+      hasKeyId: !!params.keyId,
+      hasEncryptedShare: !!params.encryptedShare,
+      hasMessage: !!params.message,
+      keyId: params.keyId
+    });
+    const network = getSolanaNetwork();
+    console.log("[SolanaApi] Signing message with:", {
+      network,
+      messageLength: params.message.length,
+      messagePreview: params.message.substring(0, 20) + "..."
+    });
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        network,
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
+      }
+    });
+    console.log("[SolanaApi] Sign response:", {
+      status: response.status,
+      hasResult: !!response.result,
+      hasSignature: !!response.result?.signature,
+      directSignature: !!response.signature,
+      error: response.error
+    });
+    let signature;
+    if (response.status === "success" && response.result?.signature) {
+      signature = response.result.signature;
+    } else if (response.signature) {
+      signature = response.signature;
+    } else {
+      console.error("[SolanaApi] \u274C Sign failed:", response);
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana message",
+        response
+      );
+    }
+    return {
+      signature
+    };
+  }
+  /**
+   * Send Solana transaction
+   */
+  async sendSolanaTransaction(params) {
+    console.log("[SolanaApi] sendSolanaTransaction - request:", {
+      network: params.network,
+      serializedTXLength: params.serializedTX.length,
+      serializedTXPreview: params.serializedTX.substring(0, 40) + "...",
+      signaturesCount: params.signatures.length,
+      signaturesLengths: params.signatures.map((s) => s.length)
+    });
+    const response = await this.request("/wapi/v2/solana/tx/sendTransaction", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        network: params.network,
+        serializedTX: params.serializedTX,
+        signatures: params.signatures
+      }
+    });
+    console.log("[SolanaApi] sendSolanaTransaction - response:", {
+      status: response.status,
+      hasResult: !!response.result,
+      resultData: response.result?.data
+    });
+    if (response.status !== "success" || !response.result?.data) {
+      console.error("[SolanaApi] \u274C sendSolanaTransaction failed:", response);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to send Solana transaction",
+        response
+      );
+    }
+    console.log("[SolanaApi] \u2705 sendSolanaTransaction success:", {
+      txHash: response.result.data
+    });
+    return {
+      txHash: response.result.data
+    };
+  }
+};
+
+export {
+  SolanaApi
+};