@talken/talkenkit 2.4.15 → 2.4.17

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

@@ -0,0 +1,351 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/abcSolanaProvider.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var EventEmitter = class {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    if (!this.events.has(event)) {
+      this.events.set(event, []);
+    }
+    this.events.get(event).push(listener);
+    return this;
+  }
+  off(event, listener) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      const index = listeners.indexOf(listener);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+    return this;
+  }
+  removeListener(event, listener) {
+    return this.off(event, listener);
+  }
+  emit(event, ...args) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(...args);
+      }
+      return true;
+    }
+    return false;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+    return this;
+  }
+};
+var SolanaErrorCode = {
+  USER_REJECTED: 4001,
+  UNAUTHORIZED: 4100,
+  UNSUPPORTED_METHOD: 4200,
+  DISCONNECTED: 4900,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603
+};
+var SolanaProviderError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "SolanaProviderError";
+  }
+};
+var AbcSolanaProvider = class extends EventEmitter {
+  constructor(client) {
+    super();
+    this.wallet = null;
+    this.connected = false;
+    this.client = client;
+  }
+  /**
+   * Set wallet information
+   */
+  setWallet(wallet) {
+    const previousAddress = this.wallet?.address;
+    this.wallet = wallet;
+    this.connected = true;
+    if (previousAddress !== wallet.address) {
+      this.emit("accountsChanged", [wallet.address]);
+    }
+    this.emit("connect", {
+      address: wallet.address,
+      network: wallet.network
+    });
+  }
+  /**
+   * Clear wallet (disconnect)
+   */
+  clearWallet() {
+    this.wallet = null;
+    this.connected = false;
+    this.emit("disconnect");
+    this.emit("accountsChanged", []);
+  }
+  /**
+   * Set TalkenApiClient for backend-proxied transaction flow
+   * When set, native SOL transfers will use a single API call instead of multi-step WaaS
+   */
+  setTalkenApi(talkenApi) {
+    this.talkenApi = talkenApi;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected && this.wallet !== null;
+  }
+  /**
+   * Get Solana address
+   */
+  async getAddress() {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.address;
+  }
+  /**
+   * Get public key
+   */
+  async getPublicKey() {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.publicKey;
+  }
+  /**
+   * Sign Solana message (no PIN required)
+   * Uses encrypted_share which doesn't require PIN
+   */
+  async signMessage(encodedMessage, _display) {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      const messageHex = `0x${Array.from(encodedMessage).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+      const result = await this.client.solana.signSolanaMessage({
+        message: messageHex,
+        encryptedShare: this.wallet.encryptedShare,
+        keyId: this.wallet.keyId,
+        secretStore: this.wallet.secretStore || ""
+      });
+      const signatureHex = result.signature.startsWith("0x") ? result.signature.slice(2) : result.signature;
+      const signatureBytes = new Uint8Array(
+        signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+      );
+      return { signature: signatureBytes };
+    } catch (error) {
+      this.emit("error", error);
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "Failed to sign message",
+        error
+      );
+    }
+  }
+  /**
+   * Sign arbitrary Solana transaction (requires PIN)
+   * Supports both Legacy Transaction and VersionedTransaction
+   * Used for custom transactions, dApp interactions, and protocol integrations
+   */
+  async signTransaction(transaction) {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      const { VersionedTransaction, PublicKey } = await import("@solana/web3.js");
+      const isVersioned = transaction instanceof VersionedTransaction;
+      let serialized;
+      if (isVersioned) {
+        serialized = transaction.message.serialize();
+      } else {
+        serialized = transaction.serializeMessage();
+      }
+      const messageHex = Buffer.from(serialized).toString("hex");
+      const signatureResponse = await this.client.solana.signSolanaTransaction({
+        keyId: this.wallet.keyId,
+        encryptedShare: this.wallet.encryptedShare,
+        secretStore: this.wallet.secretStore || "",
+        message: messageHex
+      });
+      const signatureHex = signatureResponse.signature.startsWith("0x") ? signatureResponse.signature.slice(2) : signatureResponse.signature;
+      const signatureBytes = Buffer.from(signatureHex, "hex");
+      const publicKey = new PublicKey(this.wallet.address);
+      if (isVersioned) {
+        transaction.addSignature(publicKey, signatureBytes);
+      } else {
+        transaction.addSignature(publicKey, signatureBytes);
+      }
+      return transaction;
+    } catch (error) {
+      if (error.code === 4001 || error.cancelled) {
+        throw error;
+      }
+      this.emit("error", error);
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "Failed to sign transaction",
+        error
+      );
+    }
+  }
+  /**
+   * Sign multiple transactions (batch signing)
+   */
+  async signAllTransactions(transactions) {
+    const signedTransactions = [];
+    for (const transaction of transactions) {
+      const signed = await this.signTransaction(transaction);
+      signedTransactions.push(signed);
+    }
+    return signedTransactions;
+  }
+  /**
+   * Unified transfer: SOL, SPL token, or NFT
+   * - No mintAddress → native SOL transfer (kind='native')
+   * - With mintAddress → SPL/NFT transfer (kind='spl')
+   * - NFT = transfer({ mintAddress, toAddress, amount: 1 })
+   */
+  async transfer(params) {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      const pinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+      if (!pinHash) {
+        throw new SolanaProviderError(
+          SolanaErrorCode.INTERNAL_ERROR,
+          "PIN hash not found. Please login again."
+        );
+      }
+      const api = this.talkenApi || getTalkenApiClient();
+      if (params.mintAddress) {
+        const apiNetwork = this.wallet.network === "solana" ? "solana_mainnet" : this.wallet.network;
+        const { PublicKey, Connection } = await import("@solana/web3.js");
+        const connection = new Connection(this.getRpcUrl(), "confirmed");
+        const mintPubkey = new PublicKey(params.mintAddress);
+        const mintInfo = await connection.getParsedAccountInfo(mintPubkey);
+        const decimals = mintInfo.value?.data?.parsed?.info?.decimals || 9;
+        const rawAmount = Math.floor(params.amount * 10 ** decimals);
+        const result2 = await api.solana.transfer({
+          kind: "spl",
+          toAddress: params.toAddress,
+          mintAddress: params.mintAddress,
+          amount: String(rawAmount),
+          decimals,
+          network: apiNetwork,
+          pin: pinHash
+        });
+        return { signature: result2.txHash };
+      }
+      const { LAMPORTS_PER_SOL } = await import("@solana/web3.js");
+      const amountLamports = params.amount * LAMPORTS_PER_SOL;
+      const result = await api.solana.transfer({
+        kind: "native",
+        toAddress: params.toAddress,
+        amountLamports: String(amountLamports),
+        pin: pinHash
+      });
+      return { signature: result.txHash };
+    } catch (error) {
+      if (error.code === 4001 || error.cancelled) {
+        throw error;
+      }
+      this.emit("error", error);
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "Failed to transfer",
+        error
+      );
+    }
+  }
+  /**
+   * Get wallet info
+   */
+  getWalletInfo() {
+    if (!this.wallet)
+      return null;
+    return {
+      address: this.wallet.address,
+      publicKey: this.wallet.publicKey,
+      network: this.wallet.network
+    };
+  }
+  /**
+   * Get SPL token balance
+   *
+   * @param mintAddress - Token mint address
+   * @returns Token balance information
+   */
+  async getTokenBalance(mintAddress) {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      const { PublicKey, Connection } = await import("@solana/web3.js");
+      const { getAssociatedTokenAddress, TOKEN_PROGRAM_ID } = await import("@solana/spl-token");
+      const connection = new Connection(this.getRpcUrl(), "confirmed");
+      const mintPubkey = new PublicKey(mintAddress);
+      const ownerPubkey = new PublicKey(this.wallet.address);
+      const tokenAccount = await getAssociatedTokenAddress(
+        mintPubkey,
+        ownerPubkey,
+        false,
+        TOKEN_PROGRAM_ID
+      );
+      const balance = await connection.getTokenAccountBalance(tokenAccount);
+      return {
+        amount: balance.value.amount,
+        decimals: balance.value.decimals,
+        uiAmount: balance.value.uiAmount || 0
+      };
+    } catch (error) {
+      this.emit("error", error);
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "Failed to get token balance",
+        error
+      );
+    }
+  }
+  /**
+   * Get RPC URL based on network
+   */
+  getRpcUrl() {
+    const isMainnet = this.wallet?.network === "solana";
+    return isMainnet ? process.env.NEXT_PUBLIC_SOLANA_RPC_MAINNET || "https://api.mainnet-beta.solana.com" : process.env.NEXT_PUBLIC_SOLANA_RPC_DEVNET || "https://api.devnet.solana.com";
+  }
+};
+
+export {
+  SolanaProviderError,
+  AbcSolanaProvider
+};

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

@@ -0,0 +1,326 @@
+"use client";
+import {
+  AbcError
+} from "./chunk-AF4OCS7N.js";
+
+// src/wallets/walletConnectors/abcWallet/walletGeneration.ts
+async function generateMpcWallets(client, uid, hashedPin, evmChainId = 1, bitcoinNetwork = "bitcoin", tronNetwork = "tron") {
+  try {
+    const evmWallet = await generateEvmWallet(
+      client,
+      uid,
+      hashedPin,
+      evmChainId
+    );
+    const [solanaWallet, bitcoinWallet, tronWallet] = await Promise.all([
+      // Solana wallet (Ed25519) - separate V3 wallet
+      generateSolanaWallet(client, hashedPin),
+      // Bitcoin wallet - converts EVM pubkey to Bitcoin address
+      deriveBitcoinWallet(evmWallet, client, bitcoinNetwork),
+      // TRON wallet - converts EVM pubkey to TRON address
+      deriveTronWallet(evmWallet, client, tronNetwork)
+    ]);
+    return { evmWallet, solanaWallet, bitcoinWallet, tronWallet };
+  } catch (error) {
+    console.error("[MpcWallets] \u274C Generation failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Failed to generate MPC wallets: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+async function recoverMpcWallets(client, uid, hashedPin, evmChainId = 1, bitcoinNetwork = "bitcoin", tronNetwork = "tron") {
+  try {
+    console.log("[MpcWallets] \u{1F527} Starting wallet recovery...");
+    const evmWallet = await recoverEvmWallet(
+      client,
+      uid,
+      hashedPin,
+      evmChainId
+    );
+    console.log("[MpcWallets] \u2705 EVM wallet recovered");
+    const [solanaWallet, bitcoinWallet, tronWallet] = await Promise.all([
+      // Solana wallet (Ed25519) - separate V3 wallet
+      recoverSolanaWallet(client, hashedPin),
+      // Bitcoin wallet - converts EVM pubkey to Bitcoin address
+      deriveBitcoinWallet(evmWallet, client, bitcoinNetwork),
+      // TRON wallet - converts EVM pubkey to TRON address
+      deriveTronWallet(evmWallet, client, tronNetwork)
+    ]);
+    console.log("[MpcWallets] \u2705 All wallets recovered successfully");
+    return { evmWallet, solanaWallet, bitcoinWallet, tronWallet };
+  } catch (error) {
+    console.error("[MpcWallets] \u274C Recovery failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Failed to recover MPC wallets: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+async function generateEvmWallet(client, uid, hashedPin, chainId) {
+  try {
+    let wallet;
+    if ("generateOrRecoverWallet" in client) {
+      wallet = await client.generateOrRecoverWallet({
+        uid,
+        pin: hashedPin,
+        chainId
+      });
+    } else {
+      const walletApi = client.wallet;
+      if (!walletApi) {
+        throw new Error("Wallet API not available in client");
+      }
+      wallet = await walletApi.generateOrRecoverWallet({
+        uid,
+        pin: hashedPin,
+        chainId
+      });
+    }
+    return wallet;
+  } catch (error) {
+    console.error("[EVM] Generation failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `EVM wallet generation failed: ${error.message}`,
+      { chainId, originalError: error }
+    );
+  }
+}
+async function generateSolanaWallet(client, hashedPin) {
+  try {
+    let wallet;
+    if ("generateSolanaWallet" in client) {
+      wallet = await client.generateSolanaWallet(hashedPin);
+    } else {
+      const solanaApi = client.solana;
+      if (!solanaApi) {
+        throw new Error("Solana API not available in client");
+      }
+      wallet = await solanaApi.generateSolanaWallet(hashedPin);
+    }
+    return wallet;
+  } catch (error) {
+    const errorMessage = error.message || "";
+    const errorDetails = JSON.stringify(error.details || {});
+    const isConflict = errorMessage.includes("409") || errorMessage.includes("already exists") || errorMessage.includes("duplicate key") || errorDetails.includes("409") || errorDetails.includes("already exists") || errorDetails.includes("duplicate key");
+    if (isConflict) {
+      console.log("[Solana] Wallet already exists, recovering...");
+      return recoverSolanaWallet(client, hashedPin);
+    }
+    console.error("[Solana] Generation failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Solana wallet generation failed: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+async function deriveBitcoinWallet(evmWallet, client, network) {
+  try {
+    const bitcoinApi = "bitcoin" in client ? client.bitcoin : null;
+    if (!bitcoinApi) {
+      throw new Error("Bitcoin API not available in client");
+    }
+    const publicKey = evmWallet.pubkey || "";
+    if (!publicKey) {
+      throw new Error("Public key not found in EVM wallet");
+    }
+    const bitcoinAddress = await bitcoinApi.getBitcoinAddress(
+      publicKey,
+      network,
+      "bech32"
+    );
+    return {
+      uid: evmWallet.uid,
+      sessionId: evmWallet.keyId,
+      shareId: evmWallet.keyId,
+      publicKey,
+      address: bitcoinAddress,
+      addressType: "bech32",
+      keyId: evmWallet.keyId,
+      encryptedShare: evmWallet.encryptedShare,
+      network
+    };
+  } catch (error) {
+    console.error("[Bitcoin] Address failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Bitcoin address failed: ${error.message}`,
+      { network, originalError: error }
+    );
+  }
+}
+async function recoverEvmWallet(client, uid, hashedPin, chainId) {
+  console.log("\u{1F527} [EVM] Recovering EVM wallet...");
+  try {
+    let wallet;
+    if ("generateOrRecoverWallet" in client) {
+      wallet = await client.generateOrRecoverWallet({
+        uid,
+        pin: hashedPin,
+        chainId
+      });
+    } else {
+      const walletApi = client.wallet;
+      if (!walletApi) {
+        throw new Error("Wallet API not available in client");
+      }
+      wallet = await walletApi.generateOrRecoverWallet({
+        uid,
+        pin: hashedPin,
+        chainId
+      });
+    }
+    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);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `EVM wallet recovery failed: ${error.message}`,
+      { chainId, originalError: error }
+    );
+  }
+}
+async function recoverSolanaWallet(client, hashedPin) {
+  console.log("\u{1F527} [Solana] Recovering Solana wallet...");
+  try {
+    let wallet;
+    if ("generateSolanaWallet" in client) {
+      wallet = await client.generateSolanaWallet(hashedPin, true);
+    } else {
+      const solanaApi = client.solana;
+      if (!solanaApi) {
+        throw new Error("Solana API not available in client");
+      }
+      wallet = await solanaApi.recoverSolanaWallet(hashedPin);
+    }
+    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);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Solana wallet recovery failed: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+async function deriveTronWallet(evmWallet, client, network) {
+  try {
+    const tronApi = "tron" in client ? client.tron : null;
+    if (!tronApi) {
+      throw new Error("TRON API not available in client");
+    }
+    const publicKey = evmWallet.pubkey || "";
+    if (!publicKey) {
+      throw new Error("Public key not found in EVM wallet");
+    }
+    const tronAddress = await tronApi.getTronAddress(publicKey, network);
+    return {
+      uid: evmWallet.uid,
+      sessionId: evmWallet.keyId,
+      shareId: evmWallet.keyId,
+      publicKey,
+      address: tronAddress,
+      keyId: evmWallet.keyId,
+      encryptedShare: evmWallet.encryptedShare,
+      network
+    };
+  } catch (error) {
+    console.error("[TRON] Address failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `TRON address failed: ${error.message}`,
+      { network, 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.evmWallet.keyId) {
+      errors.push("EVM wallet missing keyId");
+    }
+    if (!result.evmWallet.encryptedShare) {
+      errors.push("EVM wallet missing encryptedShare");
+    }
+  }
+  if (!result.solanaWallet) {
+    errors.push("Solana wallet is missing");
+  } else {
+    if (!result.solanaWallet.address) {
+      errors.push("Invalid Solana wallet address");
+    }
+    if (!result.solanaWallet.publicKey) {
+      errors.push("Solana wallet missing publicKey");
+    }
+    if (!result.solanaWallet.keyId) {
+      errors.push("Solana wallet missing keyId");
+    }
+  }
+  if (!result.bitcoinWallet) {
+    errors.push("Bitcoin wallet is missing");
+  } else {
+    const addr = result.bitcoinWallet.address;
+    const type = result.bitcoinWallet.addressType;
+    if (!addr) {
+      errors.push("Invalid Bitcoin wallet address");
+    }
+    if (!result.bitcoinWallet.publicKey) {
+      errors.push("Bitcoin wallet missing publicKey");
+    }
+    if (!result.bitcoinWallet.keyId) {
+      errors.push("Bitcoin wallet missing keyId");
+    }
+    if (type === "bech32" && !addr.startsWith("bc1q")) {
+      errors.push("Invalid Bech32 address format (expected bc1q prefix)");
+    } else if (type === "p2pkh" && !addr.startsWith("1")) {
+      errors.push("Invalid P2PKH address format (expected 1 prefix)");
+    } else if (type === "p2sh" && !addr.startsWith("3")) {
+      errors.push("Invalid P2SH address format (expected 3 prefix)");
+    } else if (type === "taproot" && !addr.startsWith("bc1p")) {
+      errors.push("Invalid Taproot address format (expected bc1p prefix)");
+    }
+  }
+  if (!result.tronWallet) {
+    errors.push("TRON wallet is missing");
+  } else {
+    const tronAddr = result.tronWallet.address;
+    if (!tronAddr) {
+      errors.push("Invalid TRON wallet address");
+    } else if (!tronAddr.startsWith("T")) {
+      errors.push("Invalid TRON address format (expected T prefix)");
+    }
+    if (!result.tronWallet.publicKey) {
+      errors.push("TRON wallet missing publicKey");
+    }
+    if (!result.tronWallet.keyId) {
+      errors.push("TRON wallet missing keyId");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+export {
+  generateMpcWallets,
+  recoverMpcWallets,
+  validateMpcWallets
+};