@talken/talkenkit 2.3.14 → 2.4.4

package/dist/wallets/walletConnectors/{chunk-WTYSUOKN.js → chunk-UZXTNCDO.js}

@@ -1,7 +1,7 @@
 "use client";
 import {
   AbcError
-} from "./chunk-5UEBEMEE.js";
+} from "./chunk-RQIUWXDF.js";
 
 // src/wallets/walletConnectors/abcWallet/walletGeneration.ts
 async function generateMpcWallets(client, uid, hashedPin, evmChainId = 1, bitcoinNetwork = "bitcoin") {
@@ -134,7 +134,10 @@ async function generateBitcoinWallet(evmWallet, client, network) {
       "bech32"
       // Native SegWit (recommended)
     );
-    console.log("[Bitcoin] \u2705 Address generated:", bitcoinAddress);
+    console.log(
+      "[Bitcoin] \u2705 Address generated:",
+      `${bitcoinAddress.substring(0, 6)}...${bitcoinAddress.substring(bitcoinAddress.length - 4)}`
+    );
     return {
       uid: evmWallet.uid,
       sessionId: evmWallet.keyId,
@@ -178,7 +181,10 @@ async function recoverEvmWallet(client, uid, hashedPin, chainId) {
         chainId
       });
     }
-    console.log("\u2705 [EVM] Wallet recovered:", wallet.address);
+    console.log(
+      "\u2705 [EVM] Wallet recovered:",
+      `${wallet.address.substring(0, 6)}...${wallet.address.substring(wallet.address.length - 4)}`
+    );
     return wallet;
   } catch (error) {
     console.error("\u274C [EVM] Recovery failed:", error.message);
@@ -202,7 +208,10 @@ async function recoverSolanaWallet(client, hashedPin) {
       }
       wallet = await solanaApi.recoverSolanaWallet(hashedPin);
     }
-    console.log("\u2705 [Solana] Wallet recovered:", wallet.address);
+    console.log(
+      "\u2705 [Solana] Wallet recovered:",
+      `${wallet.address.substring(0, 6)}...${wallet.address.substring(wallet.address.length - 4)}`
+    );
     return wallet;
   } catch (error) {
     console.error("\u274C [Solana] Recovery failed:", error.message);
@@ -230,7 +239,10 @@ async function recoverBitcoinWallet(evmWallet, client, network) {
       "bech32"
       // Native SegWit (recommended)
     );
-    console.log("[Bitcoin] \u2705 Address recovered:", bitcoinAddress);
+    console.log(
+      "[Bitcoin] \u2705 Address recovered:",
+      `${bitcoinAddress.substring(0, 6)}...${bitcoinAddress.substring(bitcoinAddress.length - 4)}`
+    );
     return {
       uid: evmWallet.uid,
       sessionId: evmWallet.keyId,

package/dist/wallets/walletConnectors/{chunk-F5Q4VDER.js → chunk-V33I7JGZ.js}

@@ -1,13 +1,13 @@
 "use client";
 import {
   BaseApiClient
-} from "./chunk-NX5MQHSQ.js";
+} from "./chunk-MPFE6GP2.js";
 import {
   getSolanaNetwork
-} from "./chunk-VZCI2K6Y.js";
+} from "./chunk-A7FIBI6X.js";
 import {
   createAbcError
-} from "./chunk-UV5HHESJ.js";
+} from "./chunk-5RSS3SRV.js";
 import {
   ABC_ENDPOINTS,
   DEFAULT_HEADERS

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

@@ -0,0 +1,484 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-MPFE6GP2.js";
+import {
+  createAbcError
+} from "./chunk-5RSS3SRV.js";
+import {
+  DEFAULT_HEADERS
+} from "./chunk-VETRBBA2.js";
+
+// src/wallets/walletConnectors/abcWallet/api/BitcoinApi.ts
+var BitcoinApi = class extends BaseApiClient {
+  /**
+   * Generate Bitcoin wallet
+   * Uses V3 API with secp256k1 curve (same as EVM but compressed public key)
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @param network - Bitcoin network (mainnet or testnet)
+   * @param addressType - Bitcoin address type (bech32 recommended)
+   * @returns Bitcoin wallet information
+   */
+  async generateBitcoinWallet(pin, network = "bitcoin", addressType = "bech32") {
+    console.log("[BitcoinApi] \u{1F527} Generating Bitcoin wallet...", {
+      network,
+      addressType
+    });
+    const response = await this.request("/v3/wallet/generate", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "secp256k1",
+        // Same as EVM but compressed public key
+        password: pin,
+        network
+      }
+    });
+    if (response.status !== "success" || !response.result) {
+      console.error("[BitcoinApi] \u274C Generation failed:", response);
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Failed to generate Bitcoin wallet",
+        response
+      );
+    }
+    const result = response.result;
+    const addressResult = await this.getBitcoinAddress(
+      result.public_key,
+      network,
+      addressType
+    );
+    console.log(
+      "[BitcoinApi] \u2705 Bitcoin wallet generated:",
+      `${addressResult.substring(0, 6)}...${addressResult.substring(addressResult.length - 4)}`
+    );
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      // Compressed (33 bytes, 0x02 or 0x03 prefix)
+      address: addressResult,
+      addressType,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || "",
+      network
+    };
+  }
+  /**
+   * Recover Bitcoin wallet
+   * Uses V3 API wallet recovery endpoint
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @param network - Bitcoin network
+   * @param addressType - Bitcoin address type
+   * @returns Recovered Bitcoin wallet information
+   */
+  async recoverBitcoinWallet(pin, network = "bitcoin", addressType = "bech32") {
+    console.log("[BitcoinApi] \u{1F527} Recovering Bitcoin wallet...", {
+      network,
+      addressType
+    });
+    const response = await this.request("/v3/wallet/recover", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "secp256k1",
+        password: pin,
+        network
+      }
+    });
+    if (response.status !== "success" || !response.result) {
+      console.error("[BitcoinApi] \u274C Recovery failed:", response);
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Failed to recover Bitcoin wallet",
+        response
+      );
+    }
+    const result = response.result;
+    const addressResult = await this.getBitcoinAddress(
+      result.public_key,
+      network,
+      addressType
+    );
+    console.log(
+      "[BitcoinApi] \u2705 Bitcoin wallet recovered:",
+      `${addressResult.substring(0, 6)}...${addressResult.substring(addressResult.length - 4)}`
+    );
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address: addressResult,
+      addressType,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || "",
+      network
+    };
+  }
+  /**
+   * Get Bitcoin address from compressed public key
+   * Converts compressed public key to Bitcoin address based on address type
+   *
+   * @param publicKey - Compressed public key (33 bytes, hex)
+   * @param network - Bitcoin network
+   * @param addressType - Address format type (currently not used by API)
+   * @returns Bitcoin address
+   */
+  async getBitcoinAddress(publicKey, network, _addressType = "bech32") {
+    const url = `${this.baseURL}/wapi/v2/btc/address`;
+    const params = new URLSearchParams({
+      pubkey: publicKey,
+      network
+    });
+    const response = await fetch(`${url}?${params}`, {
+      method: "GET",
+      headers: {
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      }
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to get Bitcoin address",
+        data
+      );
+    }
+    return data.address;
+  }
+  /**
+   * Get UTXOs (Unspent Transaction Outputs) for address
+   * Bitcoin uses UTXO model unlike EVM/Solana account model
+   *
+   * @param address - Bitcoin address
+   * @param network - Bitcoin network
+   * @returns Array of UTXOs
+   */
+  async getUtxos(address, network) {
+    console.log(
+      "[BitcoinApi] \u{1F50D} Fetching UTXOs for:",
+      `${address.substring(0, 6)}...${address.substring(address.length - 4)}`
+    );
+    const url = `${this.baseURL}/wapi/v2/bitcoin/utxo/list`;
+    const params = new URLSearchParams({ network, address });
+    console.log("[BitcoinApi] \u{1F50D} Fetching UTXOs for:", address);
+    const response = await fetch(`${url}?${params}`, {
+      method: "GET",
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      }
+    });
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to get UTXOs",
+        data
+      );
+    }
+    const utxos = data.result?.utxos || [];
+    console.log(`[BitcoinApi] \u2705 Found ${utxos.length} UTXOs`);
+    return utxos;
+  }
+  /**
+   * Send Bitcoin transaction
+   * Broadcasts signed transaction to Bitcoin network
+   *
+   * @param params - Transaction broadcast parameters
+   * @returns Transaction hash
+   */
+  async sendBitcoinTransaction(params) {
+    const url = `${this.baseURL}/wapi/v2/bitcoin/tx/sendTransaction`;
+    console.log("[BitcoinApi] \u{1F4E1} Broadcasting Bitcoin transaction...");
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        network: params.network,
+        rawTransaction: params.rawTransaction,
+        ...params.psbt && { psbt: params.psbt }
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
+      console.error("[BitcoinApi] \u274C Transaction broadcast failed:", data);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to send Bitcoin transaction",
+        data
+      );
+    }
+    const txHash = data.result?.data;
+    console.log("[BitcoinApi] \u2705 Transaction broadcasted:", txHash);
+    return {
+      txHash
+    };
+  }
+  /**
+   * Generate Bitcoin transaction (Step 1 of 3)
+   * Creates PSBT and returns hashes to sign
+   *
+   * @param params - Transaction parameters
+   * @returns Transaction data with hashes to sign
+   */
+  async generateTransaction(params) {
+    const url = `${this.baseURL}/wapi/v2/btc/transaction/generate`;
+    console.log("[BitcoinApi] \u{1F527} Generating transaction...", params);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify(params)
+    });
+    const data = await response.json();
+    if (!response.ok || !data.hashes) {
+      const errorMsg = typeof data.error === "string" ? data.error : JSON.stringify(data.error || data);
+      console.error("[BitcoinApi] \u274C Generate failed:", errorMsg);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        `Failed to generate transaction: ${errorMsg}`,
+        data
+      );
+    }
+    console.log(
+      `[BitcoinApi] \u2705 Generated ${data.hashes.length} hashes to sign`
+    );
+    return data;
+  }
+  /**
+   * Sign transaction hash (Step 2 of 3)
+   * Uses Secure Channel encryption for signing
+   * Based on tg-wallet-frontend reference implementation
+   *
+   * @param hash - Transaction hash to sign
+   * @param wallet - Full wallet object with Bitcoin signing fields
+   * @param pinHash - Hashed PIN for device password
+   * @param secureService - Secure service instance for encryption
+   * @returns Signature hex string (r + s without 0x prefix on s)
+   */
+  async signHash(hash, wallet, pinHash, secureService) {
+    console.log("[BitcoinApi] \u{1F510} Signing hash:", `${hash.substring(0, 20)}...`);
+    if (!wallet.wid || !wallet.pvencstr) {
+      console.error("[BitcoinApi] \u274C Missing Bitcoin signing fields:", {
+        hasWid: !!wallet.wid,
+        hasPvencstr: !!wallet.pvencstr,
+        hasSid: !!wallet.sid,
+        hasUid: !!wallet.uid
+      });
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Wallet missing required fields for Bitcoin signing (wid, pvencstr)",
+        { hasWid: !!wallet.wid, hasPvencstr: !!wallet.pvencstr }
+      );
+    }
+    const encryptDevicePassword = await secureService.getEncryptPlain(
+      wallet.encryptDevicePassword || pinHash
+    );
+    const pvencstr = await secureService.getEncryptPlain(wallet.pvencstr);
+    const wid = await secureService.getEncryptPlain(wallet.wid);
+    const secureChannelId = await secureService.getSecureChannelId();
+    const params = new URLSearchParams({
+      uid: wallet.uid,
+      sid: wallet.sid || "",
+      // Handle optional sid
+      hash,
+      pvencstr,
+      wid,
+      encryptDevicePassword
+    });
+    const url = `${this.baseURL}/wapi/v2/sign/hash`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Secure-Channel": secureChannelId,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: params.toString()
+    });
+    const responseText = await response.text();
+    if (!responseText) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Empty response from sign hash API",
+        { status: response.status }
+      );
+    }
+    let data;
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseError) {
+      console.error("[BitcoinApi] \u274C JSON parse error:", parseError);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Invalid JSON response from sign hash API",
+        { responseText, parseError }
+      );
+    }
+    if (!response.ok || data.iserr === true || !data.signstr) {
+      const errorDetails = data.errmsg || data.errors?.[0] || data.message || data;
+      console.error("[BitcoinApi] \u274C Sign failed:", errorDetails);
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        `Failed to sign hash: ${JSON.stringify(errorDetails)}`,
+        data
+      );
+    }
+    const signstr = JSON.parse(data.signstr);
+    const sig_list = signstr.sig_list;
+    const signatures = [];
+    for (const sig of sig_list) {
+      const r = sig.r;
+      const s = sig.s.startsWith("0x") ? sig.s.substring(2) : sig.s;
+      const combinedSig = r + s;
+      signatures.push(combinedSig);
+    }
+    console.log(
+      "[BitcoinApi] \u2705 Signature generated:",
+      `${signatures[0].substring(0, 32)}...`
+    );
+    return signatures[0];
+  }
+  /**
+   * Finalize and broadcast transaction (Step 3 of 3)
+   * Broadcasts signed transaction to Bitcoin network
+   *
+   * @param params - Transaction parameters with signatures
+   * @returns Transaction hash
+   */
+  async finalizeTransaction(params) {
+    const url = `${this.baseURL}/wapi/v2/btc/transaction/finalize`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify(params)
+    });
+    const responseText = await response.text();
+    if (!responseText) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Empty response from finalize API",
+        { status: response.status }
+      );
+    }
+    let data;
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseError) {
+      console.error("[BitcoinApi] \u274C JSON parse error:", parseError);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Invalid JSON response from finalize API",
+        { responseText, parseError }
+      );
+    }
+    if (!response.ok) {
+      const errorMsg = data.error || data.message || data.errmsg || "Unknown error";
+      console.error("[BitcoinApi] \u274C Finalize failed:", errorMsg);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        `Failed to finalize transaction: ${errorMsg}`,
+        data
+      );
+    }
+    const txHash = data.result?.tx_hash || data.tx_hash || data.result?.txHash || data.txHash;
+    if (!txHash) {
+      console.error("[BitcoinApi] \u274C No tx_hash in response:", data);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Transaction hash not found in response",
+        data
+      );
+    }
+    console.log("[BitcoinApi] \u2705 Transaction sent:", txHash);
+    return txHash;
+  }
+  /**
+   * Send Bitcoin transaction (Complete flow: generate → sign → finalize)
+   * High-level API that handles all 3 steps
+   *
+   * @param params - Transaction parameters
+   * @param wallet - EVM wallet credentials
+   * @param pinHash - Hashed PIN
+   * @param secureService - Secure service instance
+   * @returns Transaction hash
+   */
+  async sendTransaction(params, wallet, pinHash, secureService) {
+    console.log("[BitcoinApi] \u{1F4B8} Starting Bitcoin transaction flow...");
+    const generateData = await this.generateTransaction({
+      amount: params.amount,
+      pubkey: params.pubkey,
+      to: params.to,
+      feeRate: "2"
+      // Default fee rate
+    });
+    const { hashes, fee_rate } = generateData;
+    const signatureHex = [];
+    for (let i = 0; i < hashes.length; i++) {
+      const signature = await this.signHash(
+        hashes[i],
+        wallet,
+        pinHash,
+        secureService
+      );
+      signatureHex.push(signature);
+    }
+    const txHash = await this.finalizeTransaction({
+      network: params.network,
+      signatureHex,
+      feeRate: fee_rate,
+      amount: params.amount,
+      pubkey: params.pubkey,
+      to: params.to
+    });
+    console.log("[BitcoinApi] \u2705 Transaction complete:", txHash);
+    return txHash;
+  }
+  /**
+   * Estimate Bitcoin transaction fee
+   * Gets recommended fee rate (satoshis per byte) for target confirmation blocks
+   *
+   * @param network - Bitcoin network
+   * @param targetBlocks - Target confirmation blocks (default: 6)
+   * @returns Fee rate in satoshis per byte
+   */
+  async estimateFee(network, targetBlocks = 6) {
+    const url = `${this.baseURL}/wapi/v2/bitcoin/fee/estimate`;
+    const params = new URLSearchParams({
+      network,
+      targetBlocks: targetBlocks.toString()
+    });
+    const response = await fetch(`${url}?${params}`, {
+      method: "GET",
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      }
+    });
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
+      console.warn("[BitcoinApi] \u26A0\uFE0F Fee estimation failed, using fallback");
+      return 1;
+    }
+    const feeRate = data.result?.feeRate || 1;
+    console.log(`[BitcoinApi] \u26FD Estimated fee rate: ${feeRate} sat/byte`);
+    return feeRate;
+  }
+};
+
+export {
+  BitcoinApi
+};

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

@@ -0,0 +1,63 @@
+"use client";
+import {
+  WalletApi
+} from "./chunk-MKAXMNZM.js";
+import {
+  AuthApi
+} from "./chunk-ZQLQELFC.js";
+import {
+  SigningApi
+} from "./chunk-HTD7IRKM.js";
+import {
+  BitcoinApi
+} from "./chunk-M7KXDTM6.js";
+import {
+  TransactionApi
+} from "./chunk-HFC4AK72.js";
+import {
+  SolanaApi
+} from "./chunk-HEQZLRTH.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
+};