@talken/talkenkit 2.3.12 → 2.3.13

package/dist/wallets/walletConnectors/chunk-5KCTAEQB.js

@@ -0,0 +1,391 @@
+"use client";
+import {
+  secure_default
+} from "./chunk-G2LI5MVX.js";
+import {
+  getSolanaNetwork
+} from "./chunk-VZCI2K6Y.js";
+
+// src/wallets/walletConnectors/abcWallet/abcSolProvider.ts
+import { PublicKey } from "@solana/web3.js";
+
+// src/utils/encryption.ts
+async function hashPin(pin) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(pin);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/wallets/walletConnectors/abcWallet/abcSolProvider.ts
+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) {
+        this.walletData = parsed.solanaWallet;
+        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 messageStr = new TextDecoder().decode(message);
+    const messageHex = Buffer.from(messageStr, "utf8").toString("hex");
+    const signBody = {
+      curve: "ed25519",
+      key_id: walletData.key_id,
+      encrypted_share: walletData.encrypted_share,
+      secret_store: walletData.secret_store || "",
+      message: messageHex
+    };
+    console.log("[AbcSolProvider] \u{1F680} Signing message with v3 API (5 explicit fields)");
+    console.log("[AbcSolProvider] \u{1F4E6} walletData from localStorage:", walletData);
+    console.log("[AbcSolProvider] \u{1F4E6} Request body (full):", signBody);
+    console.log("[AbcSolProvider] \u{1F4E6} Field details:", {
+      curve: signBody.curve,
+      key_id_length: signBody.key_id?.length,
+      key_id_sample: signBody.key_id?.substring(0, 50),
+      encrypted_share_length: signBody.encrypted_share?.length,
+      encrypted_share_sample: signBody.encrypted_share?.substring(0, 50),
+      secret_store_length: signBody.secret_store?.length,
+      secret_store_sample: signBody.secret_store?.substring(0, 50),
+      message_length: messageHex.length,
+      message_sample: messageHex.substring(0, 50)
+    });
+    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();
+      console.error("[AbcSolProvider] \u274C Sign API error:", errorText);
+      throw new Error(`ABC WaaS sign failed: ${errorText}`);
+    }
+    const result = await response.json();
+    console.log("[AbcSolProvider] \u{1F4E6} Sign API response:", result);
+    const signatureHex = result.result?.signature || result.signature || result.data?.signature;
+    if (!signatureHex) {
+      console.error("[AbcSolProvider] \u274C No signature in response:", result);
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const signatureBytes = new Uint8Array(
+      signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    console.log("[AbcSolProvider] \u2705 Message signed successfully");
+    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
+    };
+    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({
+          ...walletData,
+          message: serializedTxHex
+        })
+      }
+    );
+    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 mockTransaction = transaction;
+    mockTransaction.signatures = [
+      {
+        signature: Buffer.from(signatureBytes),
+        publicKey: this.publicKey
+      }
+    ];
+    const serializedTxBytes = new Uint8Array(
+      serializedTxHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    const serializedTxBase64 = Buffer.from(serializedTxBytes).toString("base64");
+    mockTransaction._abcSerializedTx = serializedTxBase64;
+    return mockTransaction;
+  }
+  /**
+   * 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_PREFIX = "talkenkit_abc_";
+    const storedPinHash = localStorage.getItem(`${STORAGE_PREFIX}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: "ed25519",
+      key_id: walletData.key_id,
+      encrypted_share: walletData.encrypted_share,
+      secret_store: walletData.secret_store || "",
+      message: serializedTxHex
+    };
+    console.log("[AbcSolProvider] \u{1F680} Signing transaction with v3 API (5 explicit fields)");
+    console.log("[AbcSolProvider] \u{1F4E6} Request body:", {
+      curve: signBody.curve,
+      hasKeyId: !!signBody.key_id,
+      hasEncryptedShare: !!signBody.encrypted_share,
+      hasSecretStore: !!signBody.secret_store,
+      messageLength: serializedTxHex.length
+    });
+    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();
+    console.log("[AbcSolProvider] \u{1F4E6} Sign API response:", signResult);
+    const signatureHex = signResult.result?.signature || signResult.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
+    };
+  }
+};
+
+export {
+  AbcSolProvider
+};

package/dist/wallets/walletConnectors/chunk-5OKJZU3F.js

@@ -0,0 +1,63 @@
+"use client";
+import {
+  WalletApi
+} from "./chunk-DHVD2NUK.js";
+import {
+  SigningApi
+} from "./chunk-V3XKL7AD.js";
+import {
+  AuthApi
+} from "./chunk-YEHCPL4R.js";
+import {
+  BitcoinApi
+} from "./chunk-QKUFFUM5.js";
+import {
+  SolanaApi
+} from "./chunk-JXPLBYVW.js";
+import {
+  TransactionApi
+} from "./chunk-ISAMATTH.js";
+
+// src/wallets/walletConnectors/abcWallet/api/index.ts
+var AbcWaasApiClient = class {
+  constructor(config) {
+    this.auth = new AuthApi(config);
+    this.wallet = new WalletApi(config);
+    this.transaction = new TransactionApi(config);
+    this.signing = new SigningApi(config);
+    this.solana = new SolanaApi(config);
+    this.bitcoin = new BitcoinApi(config);
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return this.auth.isAuthenticated();
+  }
+  /**
+   * Check if access token is expired
+   */
+  isTokenExpired() {
+    return this.auth.isTokenExpired();
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.auth.getAccessToken();
+  }
+  /**
+   * Logout (clear tokens)
+   */
+  async logout() {
+    await this.auth.logout();
+  }
+};
+function createAbcWaasApiClient(config) {
+  return new AbcWaasApiClient(config);
+}
+
+export {
+  AbcWaasApiClient,
+  createAbcWaasApiClient
+};

package/dist/wallets/walletConnectors/chunk-5PBZRTEM.js

@@ -0,0 +1,63 @@
+"use client";
+import {
+  WalletApi
+} from "./chunk-MT2QHWYE.js";
+import {
+  AuthApi
+} from "./chunk-YEHCPL4R.js";
+import {
+  BitcoinApi
+} from "./chunk-QKUFFUM5.js";
+import {
+  SigningApi
+} from "./chunk-V3XKL7AD.js";
+import {
+  SolanaApi
+} from "./chunk-WPEGBCDE.js";
+import {
+  TransactionApi
+} from "./chunk-ISAMATTH.js";
+
+// src/wallets/walletConnectors/abcWallet/api/index.ts
+var AbcWaasApiClient = class {
+  constructor(config) {
+    this.auth = new AuthApi(config);
+    this.wallet = new WalletApi(config);
+    this.transaction = new TransactionApi(config);
+    this.signing = new SigningApi(config);
+    this.solana = new SolanaApi(config);
+    this.bitcoin = new BitcoinApi(config);
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return this.auth.isAuthenticated();
+  }
+  /**
+   * Check if access token is expired
+   */
+  isTokenExpired() {
+    return this.auth.isTokenExpired();
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.auth.getAccessToken();
+  }
+  /**
+   * Logout (clear tokens)
+   */
+  async logout() {
+    await this.auth.logout();
+  }
+};
+function createAbcWaasApiClient(config) {
+  return new AbcWaasApiClient(config);
+}
+
+export {
+  AbcWaasApiClient,
+  createAbcWaasApiClient
+};

package/dist/wallets/walletConnectors/chunk-5SLXMCS2.js

@@ -0,0 +1,34 @@
+"use client";
+
+// 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;
+}
+
+export {
+  getSolanaNetwork
+};

package/dist/wallets/walletConnectors/{chunk-BHMMHU7Y.js → chunk-5VL7T6AY.js}

@@ -1,16 +1,18 @@
 "use client";
 import {
   createAbcWaasClient
-} from "./chunk-P2E4LSYH.js";
+} from "./chunk-AKYC5VZG.js";
 import {
   createAbcEvmProvider
-} from "./chunk-73B7HWCT.js";
+} from "./chunk-ZIYAL44B.js";
 import {
   clearAuthState,
   clearEncryptedTokens,
+  clearStorage,
   loadAuthState,
+  loadFromStorage,
   saveAuthState
-} from "./chunk-W23N7VC4.js";
+} from "./chunk-UV5HHESJ.js";
 
 // src/wallets/walletConnectors/abcWallet/abcConnector.ts
 import { createConnector } from "wagmi";
@@ -78,11 +80,24 @@ 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)
+          });
           return {
             accounts,
             chainId: Number(currentChainId)
           };
         } catch (error) {
+          console.error("\u274C ABC Connector connect() failed:", {
+            message: error.message,
+            code: error.code,
+            error
+          });
           if (error.message === "ABC_LOGIN_REQUIRED") {
             throw error;
           }
@@ -153,6 +168,7 @@ function abcConnector(options) {
       },
       /**
        * Check if authorized (has valid session)
+       * Auto-refreshes access token if expired but refresh token is valid
        */
       async isAuthorized() {
         try {
@@ -160,8 +176,33 @@ function abcConnector(options) {
           if (!authState || !authState.isAuthenticated) {
             return false;
           }
-          return client.isAuthenticated();
-        } catch {
+          if (!authState.wallet) {
+            return false;
+          }
+          if (client.isAuthenticated()) {
+            return true;
+          }
+          const refreshToken = loadFromStorage(
+            "refresh_token" /* REFRESH_TOKEN */
+          );
+          if (!refreshToken) {
+            clearStorage();
+            return false;
+          }
+          try {
+            await client.refreshTokens(refreshToken);
+            const updatedState = loadAuthState();
+            return updatedState?.isAuthenticated ?? false;
+          } catch (error) {
+            console.error("[AbcConnector] Token refresh failed:", error);
+            clearStorage();
+            return false;
+          }
+        } catch (error) {
+          console.error(
+            "[AbcConnector] Unexpected error in isAuthorized:",
+            error
+          );
           return false;
         }
       },

package/dist/wallets/walletConnectors/{chunk-NKJLO4QH.js → chunk-62ZC3BGR.js}

@@ -1,13 +1,13 @@
 "use client";
+import {
+  createAbcSolanaProvider
+} from "./chunk-FROV5VDF.js";
 import {
   createAbcSolanaConnector
 } from "./chunk-U2CUEL35.js";
-import {
-  createAbcSolanaProvider
-} from "./chunk-MY5YIDOB.js";
 import {
   createAbcWaasClient
-} from "./chunk-DAZZIITX.js";
+} from "./chunk-F5HCFRTK.js";
 
 // src/wallets/walletConnectors/abcWallet/abcSolanaWallet.ts
 var abcSolanaWallet = (options) => ({

package/dist/wallets/walletConnectors/{chunk-OHRTTVNJ.js → chunk-636QKXSN.js}

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