@talken/talkenkit 2.4.23 → 2.4.25

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

@@ -0,0 +1,194 @@
+"use client";
+import {
+  getBitcoinNetwork,
+  getEvmNetwork,
+  getSolanaNetwork,
+  getTronNetwork
+} from "./chunk-O4AU63LK.js";
+import {
+  AbcError
+} from "./chunk-4P3SPC44.js";
+import {
+  getCredentialManager
+} from "./chunk-QHUBLT7N.js";
+
+// src/wallets/walletConnectors/abcWallet/walletGeneration.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+async function mapApiResponseToWallets(genResponse, infoResponse, email) {
+  const accounts = infoResponse?.accounts || [];
+  const evmAccount = accounts[0] || infoResponse || {};
+  const uid = String(genResponse.uid || evmAccount.uid || "");
+  const wid = String(genResponse.wid || evmAccount.wid || "");
+  const sid = String(
+    evmAccount.sid || evmAccount.ethAddress || genResponse.evmAddress || ""
+  );
+  const pubkey = String(evmAccount.pubkey || genResponse.pubkey || "");
+  const solMaterial = genResponse.solana || {};
+  let btcAddress = genResponse.btcAddress || "";
+  let trxAddress = genResponse.trxAddress || "";
+  if ((!btcAddress || !trxAddress) && pubkey) {
+    try {
+      const api = getTalkenApiClient();
+      if (api) {
+        const addrResponse = await api.wallet.getAddressForChain("all");
+        if (!btcAddress)
+          btcAddress = addrResponse?.btc || addrResponse?.btcAddress || "";
+        if (!trxAddress)
+          trxAddress = addrResponse?.trx || addrResponse?.trxAddress || "";
+      }
+    } catch (err) {
+      console.warn(
+        "[walletGeneration] Failed to derive BTC/TRX addresses:",
+        err
+      );
+    }
+  }
+  const pvencstr = String(evmAccount.pvencstr || "");
+  const edp = String(evmAccount.encryptDevicePassword || "");
+  if (uid && wid && sid && pvencstr && edp) {
+    getCredentialManager().setEvmSigningCredentials({
+      uid,
+      wid,
+      sid,
+      pvencstr,
+      encryptDevicePassword: edp
+    });
+  }
+  const evmWallet = {
+    uid,
+    sessionId: sid,
+    keyId: wid,
+    encryptedShare: pvencstr,
+    secretStore: edp,
+    address: genResponse.evmAddress || sid,
+    chainId: getEvmNetwork(),
+    sid,
+    type: "evm",
+    email,
+    pubkey
+  };
+  const solanaWallet = {
+    uid,
+    sessionId: String(solMaterial.shareId || ""),
+    keyId: String(solMaterial.keyId || ""),
+    encryptedShare: String(solMaterial.encryptedShare || ""),
+    secretStore: String(solMaterial.secretStore || ""),
+    shareId: String(solMaterial.shareId || ""),
+    publicKey: String(solMaterial.publicKey || ""),
+    address: genResponse.solAddress || solMaterial.address || "",
+    network: getSolanaNetwork()
+  };
+  const bitcoinWallet = {
+    uid,
+    sessionId: sid,
+    keyId: wid,
+    encryptedShare: String(evmAccount.pvencstr || ""),
+    shareId: sid,
+    publicKey: pubkey,
+    address: btcAddress,
+    addressType: "bech32",
+    network: getBitcoinNetwork()
+  };
+  const tronWallet = {
+    uid,
+    sessionId: sid,
+    keyId: wid,
+    encryptedShare: String(evmAccount.pvencstr || ""),
+    shareId: sid,
+    publicKey: pubkey,
+    address: trxAddress,
+    network: getTronNetwork()
+  };
+  return { evmWallet, solanaWallet, bitcoinWallet, tronWallet };
+}
+async function generateMpcWallets(hashedPin, email) {
+  const api = getTalkenApiClient();
+  if (!api) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  try {
+    const genResponse = await api.wallet.generate(hashedPin, email);
+    const infoResponse = await api.wallet.getInfo().catch(() => ({}));
+    return await mapApiResponseToWallets(
+      genResponse,
+      infoResponse,
+      email || ""
+    );
+  } catch (error) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Failed to generate MPC wallets: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+async function recoverMpcWallets(hashedPin, email) {
+  const api = getTalkenApiClient();
+  if (!api) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  try {
+    const genResponse = await api.wallet.recover(hashedPin, email);
+    const infoResponse = await api.wallet.getInfo().catch(() => ({}));
+    return await mapApiResponseToWallets(
+      genResponse,
+      infoResponse,
+      email || ""
+    );
+  } catch (error) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Failed to recover MPC wallets: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+function validateMpcWallets(result) {
+  const errors = [];
+  if (!result.evmWallet) {
+    errors.push("EVM wallet is missing");
+  } else {
+    if (!result.evmWallet.address || !result.evmWallet.address.startsWith("0x")) {
+      errors.push("Invalid EVM wallet address");
+    }
+  }
+  if (!result.solanaWallet) {
+    errors.push("Solana wallet is missing");
+  } else {
+    if (!result.solanaWallet.address) {
+      errors.push("Invalid Solana wallet address");
+    }
+  }
+  if (!result.bitcoinWallet) {
+    errors.push("Bitcoin wallet is missing");
+  } else {
+    if (!result.bitcoinWallet.address) {
+      errors.push("Invalid Bitcoin wallet address");
+    }
+  }
+  if (!result.tronWallet) {
+    errors.push("TRON wallet is missing");
+  } else {
+    if (!result.tronWallet.address) {
+      errors.push("Invalid TRON wallet address");
+    } else if (!result.tronWallet.address.startsWith("T")) {
+      errors.push("Invalid TRON address format (expected T prefix)");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+export {
+  generateMpcWallets,
+  recoverMpcWallets,
+  validateMpcWallets
+};

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

@@ -0,0 +1,273 @@
+"use client";
+import {
+  loadAuthState,
+  saveAuthState
+} from "./chunk-A66MTFML.js";
+
+// src/wallets/walletConnectors/abcWallet/abcBitcoinConnector.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var AbcBitcoinConnector = class {
+  constructor(config) {
+    this.wallet = null;
+    this.connected = false;
+    // Event listeners
+    this.connectListeners = /* @__PURE__ */ new Set();
+    this.disconnectListeners = /* @__PURE__ */ new Set();
+    this.accountsChangedListeners = /* @__PURE__ */ new Set();
+    this.networkChangedListeners = /* @__PURE__ */ new Set();
+    this.provider = config.provider;
+    this.setupProviderListeners();
+  }
+  /**
+   * Setup provider event listeners
+   */
+  setupProviderListeners() {
+    this.provider.on("connect", () => {
+      this.connected = true;
+      if (this.wallet) {
+        for (const listener of this.connectListeners) {
+          listener(this.wallet);
+        }
+      }
+    });
+    this.provider.on("disconnect", () => {
+      this.connected = false;
+      this.wallet = null;
+      for (const listener of this.disconnectListeners) {
+        listener();
+      }
+    });
+    this.provider.on("accountsChanged", (accounts) => {
+      for (const listener of this.accountsChangedListeners) {
+        listener(accounts);
+      }
+    });
+    this.provider.on("networkChanged", (network) => {
+      for (const listener of this.networkChangedListeners) {
+        listener(network);
+      }
+    });
+  }
+  /**
+   * Connect Bitcoin wallet
+   */
+  async connect() {
+    try {
+      const authState = loadAuthState();
+      console.log("[BitcoinConnector] \u{1F527} connect() called:", {
+        hasAuthState: !!authState,
+        isAuthenticated: authState?.isAuthenticated,
+        hasBitcoinWallet: !!authState?.bitcoinWallet,
+        bitcoinAddress: authState?.bitcoinWallet?.address
+      });
+      if (!authState || !authState.isAuthenticated || !authState.bitcoinWallet) {
+        throw new Error("BITCOIN_LOGIN_REQUIRED");
+      }
+      this.wallet = authState.bitcoinWallet;
+      this.provider.setWallet(authState.bitcoinWallet);
+      console.log("[BitcoinConnector] \u2705 Wallet set:", {
+        address: authState.bitcoinWallet.address,
+        publicKey: authState.bitcoinWallet.publicKey,
+        addressType: authState.bitcoinWallet.addressType,
+        network: authState.bitcoinWallet.network
+      });
+      this.connected = true;
+      return {
+        address: authState.bitcoinWallet.address,
+        publicKey: authState.bitcoinWallet.publicKey,
+        network: authState.bitcoinWallet.network
+      };
+    } catch (error) {
+      if (error.message === "BITCOIN_LOGIN_REQUIRED") {
+        throw error;
+      }
+      console.error("[BitcoinConnector] \u274C connect error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Disconnect Bitcoin wallet
+   */
+  async disconnect() {
+    try {
+      this.provider.clearWallet();
+      this.wallet = null;
+      this.connected = false;
+      console.log("[BitcoinConnector] \u2705 Wallet disconnected");
+    } catch (error) {
+      console.error("[BitcoinConnector] \u274C disconnect error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get Bitcoin address
+   */
+  async getAddress() {
+    return this.provider.getAddress();
+  }
+  /**
+   * Get compressed public key (33 bytes)
+   */
+  async getPublicKey() {
+    return this.provider.getPublicKey();
+  }
+  /**
+   * Get address type (bech32, p2pkh, etc.)
+   */
+  getAddressType() {
+    return this.provider.getAddressType();
+  }
+  /**
+   * Get UTXOs
+   */
+  async getUtxos(forceRefresh = false) {
+    return this.provider.getUtxos(forceRefresh);
+  }
+  /**
+   * Get balance (in satoshis)
+   */
+  async getBalance(forceRefresh = false) {
+    return this.provider.getBalance(forceRefresh);
+  }
+  /**
+   * Estimate transaction fee
+   */
+  async estimateFee(targetBlocks = 6) {
+    return this.provider.estimateFee(targetBlocks);
+  }
+  /**
+   * Sign Bitcoin message (BIP-322)
+   * NOTE: Currently not supported - Bitcoin uses v2 API which doesn't have message signing endpoint
+   */
+  async signMessage(message) {
+    return this.provider.signMessage(message);
+  }
+  /**
+   * Send Bitcoin transaction (high-level API)
+   * Creates, signs, and broadcasts transaction
+   */
+  async sendTransaction(params) {
+    return this.provider.sendTransaction(params);
+  }
+  /**
+   * Broadcast signed transaction to network (low-level API)
+   */
+  async broadcastTransaction(rawTransaction, psbt) {
+    return this.provider.broadcastTransaction(rawTransaction, psbt);
+  }
+  /**
+   * Check if authorized (has valid session)
+   */
+  async isAuthorized() {
+    try {
+      const authState = loadAuthState();
+      if (!authState || !authState.isAuthenticated) {
+        return false;
+      }
+      if (!authState.bitcoinWallet) {
+        return false;
+      }
+      const api = getTalkenApiClient();
+      return !!api && !api.isTokenExpired();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected && this.provider.isConnected();
+  }
+  /**
+   * Get current wallet
+   */
+  getWallet() {
+    return this.wallet;
+  }
+  /**
+   * Get provider
+   */
+  getProvider() {
+    return this.provider;
+  }
+  /**
+   * Get wallet info
+   */
+  getWalletInfo() {
+    return this.provider.getWalletInfo();
+  }
+  /**
+   * Switch network
+   */
+  async switchNetwork(network) {
+    this.provider.setNetwork(network);
+    const authState = loadAuthState();
+    if (authState?.bitcoinWallet) {
+      authState.bitcoinWallet.network = network === "mainnet" ? "bitcoin" /* Mainnet */ : "bitcoin_testnet" /* Testnet */;
+      saveAuthState(authState);
+    }
+    console.log("[BitcoinConnector] \u{1F504} Network switched to:", network);
+  }
+  /**
+   * Get current network
+   */
+  getNetwork() {
+    return this.provider.getNetwork().type;
+  }
+  /**
+   * Refresh UTXO cache
+   */
+  async refreshUtxos() {
+    return this.provider.refreshUtxos();
+  }
+  on(event, listener) {
+    switch (event) {
+      case "connect":
+        this.connectListeners.add(listener);
+        break;
+      case "disconnect":
+        this.disconnectListeners.add(listener);
+        break;
+      case "accountsChanged":
+        this.accountsChangedListeners.add(listener);
+        break;
+      case "networkChanged":
+        this.networkChangedListeners.add(listener);
+        break;
+    }
+  }
+  off(event, listener) {
+    switch (event) {
+      case "connect":
+        this.connectListeners.delete(listener);
+        break;
+      case "disconnect":
+        this.disconnectListeners.delete(listener);
+        break;
+      case "accountsChanged":
+        this.accountsChangedListeners.delete(listener);
+        break;
+      case "networkChanged":
+        this.networkChangedListeners.delete(listener);
+        break;
+    }
+  }
+  /**
+   * Remove all listeners
+   */
+  removeAllListeners() {
+    this.connectListeners.clear();
+    this.disconnectListeners.clear();
+    this.accountsChangedListeners.clear();
+    this.networkChangedListeners.clear();
+  }
+};
+function createAbcBitcoinConnector(config) {
+  return new AbcBitcoinConnector(config);
+}
+
+export {
+  AbcBitcoinConnector,
+  createAbcBitcoinConnector
+};

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

@@ -0,0 +1,213 @@
+"use client";
+import {
+  encryptWithPin
+} from "./chunk-Q42NO7WB.js";
+import {
+  getTalkenApiClient
+} from "./chunk-R6ZE7JAZ.js";
+import {
+  getBitcoinNetwork,
+  getEvmNetwork,
+  getSolanaNetwork,
+  getTronNetwork
+} from "./chunk-O4AU63LK.js";
+import {
+  saveAuthState
+} from "./chunk-GMAYKJEI.js";
+import {
+  getCredentialManager
+} from "./chunk-MTC2HJPF.js";
+
+// src/wallets/walletConnectors/abcWallet/backfillMissingWallets.ts
+var STORAGE_PREFIX = "talkenkit_abc_";
+function writeBackfillDebug(payload) {
+  try {
+    localStorage.setItem(
+      `${STORAGE_PREFIX}backfill_debug`,
+      JSON.stringify({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ...payload
+      })
+    );
+  } catch {
+  }
+}
+function pickAddress(source, keys) {
+  if (!source) {
+    return null;
+  }
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "string" && value.trim()) {
+      return value;
+    }
+  }
+  return null;
+}
+function hasMissingBackfillableWallets(authState) {
+  if (!authState?.wallet?.address) {
+    return false;
+  }
+  return !authState.solanaWallet || !authState.bitcoinWallet || !authState.tronWallet;
+}
+async function backfillMissingWallets(authState) {
+  if (!hasMissingBackfillableWallets(authState)) {
+    writeBackfillDebug({
+      status: "skipped",
+      reason: "nothing-missing"
+    });
+    return authState;
+  }
+  const credMgr = getCredentialManager();
+  const hashedPin = credMgr.getPinHash();
+  const email = authState.user?.email || authState.wallet?.email || credMgr.getEmail();
+  writeBackfillDebug({
+    status: "started",
+    hasHashedPin: !!hashedPin,
+    hasEmail: !!email,
+    hasWallet: !!authState.wallet?.address,
+    hasSolanaWallet: !!authState.solanaWallet,
+    hasBitcoinWallet: !!authState.bitcoinWallet,
+    hasTronWallet: !!authState.tronWallet
+  });
+  if (!hashedPin || !email) {
+    writeBackfillDebug({
+      status: "blocked",
+      reason: !hashedPin ? "missing-pin-hash" : "missing-email",
+      hasHashedPin: !!hashedPin,
+      hasEmail: !!email
+    });
+    return null;
+  }
+  const api = getTalkenApiClient();
+  if (!api) {
+    writeBackfillDebug({
+      status: "blocked",
+      reason: "missing-api-client",
+      hasHashedPin: true,
+      hasEmail: true
+    });
+    return null;
+  }
+  try {
+    api.setTokens(
+      authState.accessToken || "",
+      authState.refreshToken || "",
+      authState.expiresAt || 0
+    );
+    const genResponse = await api.wallet.generate(hashedPin, email);
+    const infoResponse = await api.wallet.getInfo();
+    const addressResponse = await api.wallet.getAddresses().catch(() => null);
+    const uid = authState.user?.uid || genResponse.uid;
+    const accounts = infoResponse?.accounts || [];
+    const evmAccount = accounts[0] || infoResponse || {};
+    const pubkey = authState.wallet?.pubkey || evmAccount.pubkey || genResponse.pubkey || pickAddress(addressResponse, ["pubkey", "publicKey"]) || "";
+    const sid = authState.wallet?.sid || evmAccount.sid || authState.wallet?.address;
+    const generatedSolAddress = genResponse.solAddress || pickAddress(addressResponse, ["sol", "solana", "solAddress"]);
+    const generatedBtcAddress = genResponse.btcAddress || pickAddress(addressResponse, ["btc", "bitcoin", "btcAddress", "bitcoinAddress"]);
+    const generatedTrxAddress = genResponse.trxAddress || pickAddress(addressResponse, ["trx", "tron", "trxAddress", "tronAddress"]);
+    const nextAuthState = {
+      ...authState,
+      isAuthenticated: true,
+      user: authState.user || {
+        uid,
+        email,
+        provider: "email"
+      },
+      wallet: authState.wallet || {
+        address: sid,
+        chainId: getEvmNetwork(),
+        uid,
+        sid,
+        type: "evm",
+        email,
+        encryptedShare: "",
+        keyId: "0",
+        sessionId: sid
+      },
+      solanaWallet: authState.solanaWallet || (generatedSolAddress ? {
+        uid,
+        sessionId: genResponse.solana?.keyId || "",
+        shareId: genResponse.solana?.keyId || "",
+        publicKey: genResponse.solana?.publicKey || "",
+        address: generatedSolAddress,
+        keyId: genResponse.solana?.keyId || "",
+        encryptedShare: genResponse.solana?.encryptedShare || "",
+        secretStore: genResponse.solana?.secretStore || "",
+        network: getSolanaNetwork()
+      } : null),
+      bitcoinWallet: authState.bitcoinWallet || (generatedBtcAddress ? {
+        uid,
+        sessionId: "",
+        shareId: "",
+        publicKey: pubkey,
+        address: generatedBtcAddress,
+        keyId: "",
+        encryptedShare: "",
+        addressType: "bech32",
+        network: getBitcoinNetwork()
+      } : null),
+      tronWallet: authState.tronWallet || (generatedTrxAddress ? {
+        uid,
+        sessionId: "",
+        shareId: "",
+        publicKey: pubkey,
+        address: generatedTrxAddress,
+        keyId: "",
+        encryptedShare: "",
+        network: getTronNetwork()
+      } : null)
+    };
+    saveAuthState(nextAuthState);
+    const saltHex = localStorage.getItem(`${STORAGE_PREFIX}enc_salt`);
+    const salt = saltHex ? new Uint8Array(
+      saltHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    ) : crypto.getRandomValues(new Uint8Array(16));
+    const encryptedSensitiveData = await encryptWithPin(
+      JSON.stringify({
+        accessToken: nextAuthState.accessToken,
+        refreshToken: nextAuthState.refreshToken,
+        expiresAt: nextAuthState.expiresAt,
+        solanaWallet: nextAuthState.solanaWallet,
+        bitcoinWallet: nextAuthState.bitcoinWallet,
+        tronWallet: nextAuthState.tronWallet
+      }),
+      hashedPin,
+      salt
+    );
+    localStorage.setItem(
+      `${STORAGE_PREFIX}enc_salt`,
+      Array.from(salt).map((byte) => byte.toString(16).padStart(2, "0")).join("")
+    );
+    localStorage.setItem(`${STORAGE_PREFIX}enc_tokens`, encryptedSensitiveData);
+    localStorage.setItem(`${STORAGE_PREFIX}saved_email`, email);
+    window.dispatchEvent(
+      new CustomEvent("talkenkit:token_updated", {
+        detail: { expiresAt: nextAuthState.expiresAt }
+      })
+    );
+    window.dispatchEvent(new Event("talkenkit_storage_update"));
+    writeBackfillDebug({
+      status: "completed",
+      hasSolanaWallet: !!nextAuthState.solanaWallet,
+      hasBitcoinWallet: !!nextAuthState.bitcoinWallet,
+      hasTronWallet: !!nextAuthState.tronWallet,
+      generatedSolAddress: generatedSolAddress || null,
+      generatedBtcAddress: generatedBtcAddress || null,
+      generatedTrxAddress: generatedTrxAddress || null,
+      addressResponseKeys: addressResponse && typeof addressResponse === "object" ? Object.keys(addressResponse) : []
+    });
+    return nextAuthState;
+  } catch (error) {
+    writeBackfillDebug({
+      status: "failed",
+      reason: error instanceof Error ? error.message : "unknown-error"
+    });
+    throw error;
+  }
+}
+
+export {
+  hasMissingBackfillableWallets,
+  backfillMissingWallets
+};