@talken/talkenkit 2.4.23 → 2.4.25

package/dist/wallets/walletConnectors/chunk-JADQLTFW.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-6WF4SXLB.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-JAMJLNYQ.js

@@ -0,0 +1,54 @@
+"use client";
+import {
+  abcConnector
+} from "./chunk-Q7XBI5F6.js";
+import {
+  resolveTalkenApiUrl
+} from "./chunk-GFWUFYT2.js";
+import {
+  createTalkenApiClient
+} from "./chunk-XG2R64B7.js";
+import {
+  ABC_WALLET_METADATA
+} from "./chunk-TQXCRSMS.js";
+
+// src/wallets/walletConnectors/abcWallet/abcWallet.ts
+import { setTalkenApiClient } from "@talken/talkenkit";
+var abcWallet = (specificOptions) => ({ projectId }) => {
+  const talkenApiUrl = resolveTalkenApiUrl(specificOptions?.talkenApiUrl);
+  const talkenApi = createTalkenApiClient({
+    baseUrl: talkenApiUrl,
+    debug: specificOptions?.environment === "development"
+  });
+  setTalkenApiClient(talkenApi);
+  const config = {
+    talkenApiUrl,
+    apiKey: specificOptions?.apiKey,
+    plain: specificOptions?.plain || "",
+    // Deprecated - not used (secure.ts uses random generation)
+    environment: specificOptions?.environment || "development",
+    defaultChainId: specificOptions?.defaultChainId,
+    defaultSolanaNetwork: specificOptions?.defaultSolanaNetwork,
+    defaultBitcoinNetwork: specificOptions?.defaultBitcoinNetwork,
+    projectId
+  };
+  return {
+    id: ABC_WALLET_METADATA.id,
+    name: ABC_WALLET_METADATA.name,
+    rdns: ABC_WALLET_METADATA.rdns,
+    iconUrl: async () => (await import("./abcWallet-AYWSIGAG.js")).default,
+    iconBackground: ABC_WALLET_METADATA.iconBackground,
+    // Embedded wallet - no installation required
+    installed: void 0,
+    // No download URLs for embedded wallet
+    downloadUrls: void 0,
+    // Create connector - wrapper function required by Wallet type
+    createConnector: (_walletDetails) => abcConnector({ config }),
+    // Embedded wallet always available
+    hidden: () => false
+  };
+};
+
+export {
+  abcWallet
+};

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

@@ -0,0 +1,439 @@
+"use client";
+import {
+  getCredentialManager
+} from "./chunk-DSNVWCPD.js";
+
+// 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(talkenApi) {
+    super();
+    this.wallet = null;
+    this.connected = false;
+    this.talkenApi = talkenApi;
+  }
+  /**
+   * Set request interceptor for sign/transfer confirmation modals
+   */
+  setRequestInterceptor(interceptor) {
+    this.requestInterceptor = interceptor;
+  }
+  /**
+   * Call request interceptor if set (throws on user cancel)
+   */
+  async callInterceptor(request) {
+    if (this.requestInterceptor) {
+      await this.requestInterceptor(request);
+    }
+  }
+  /**
+   * 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;
+  }
+  getTalkenApiClientOrThrow() {
+    const api = this.talkenApi || getTalkenApiClient();
+    if (!api) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "TalkenApiClient not initialized"
+      );
+    }
+    return api;
+  }
+  getSigningNetwork() {
+    return this.wallet?.network === "solana" ? "solana" : "solana_devnet";
+  }
+  /**
+   * 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 decodedText = new TextDecoder().decode(encodedMessage);
+      await this.callInterceptor({
+        chain: "solana",
+        method: "signMessage",
+        address: this.wallet.address,
+        network: this.wallet.network,
+        message: decodedText
+      });
+      const messageHex = `0x${Array.from(encodedMessage).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+      const result = await this.getTalkenApiClientOrThrow().solana.sign({
+        message: messageHex,
+        encryptedShare: this.wallet.encryptedShare,
+        keyId: this.wallet.keyId,
+        secretStore: this.wallet.secretStore || "",
+        network: this.getSigningNetwork()
+      });
+      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 {
+      let txMessage = "";
+      try {
+        txMessage = JSON.stringify(transaction, null, 2);
+      } catch {
+        txMessage = String(transaction);
+      }
+      await this.callInterceptor({
+        chain: "solana",
+        method: "signTransaction",
+        address: this.wallet.address,
+        network: this.wallet.network,
+        message: txMessage,
+        isTransaction: true
+      });
+      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.getTalkenApiClientOrThrow().solana.sign({
+        keyId: this.wallet.keyId,
+        encryptedShare: this.wallet.encryptedShare,
+        secretStore: this.wallet.secretStore || "",
+        message: messageHex,
+        network: this.getSigningNetwork()
+      });
+      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 symbol = params.mintAddress ? "SPL" : "SOL";
+      await this.callInterceptor({
+        chain: "solana",
+        method: "transfer",
+        fromAddress: this.wallet.address,
+        toAddress: params.toAddress,
+        amount: String(params.amount),
+        symbol,
+        network: this.wallet.network,
+        tokenAddress: params.mintAddress,
+        isNativeToken: !params.mintAddress,
+        feeSymbol: "SOL"
+      });
+      const pinHash = getCredentialManager().getPinHash();
+      if (!pinHash) {
+        throw new SolanaProviderError(
+          SolanaErrorCode.INTERNAL_ERROR,
+          "PIN hash not found. Please login again."
+        );
+      }
+      console.log("[AbcSolanaProvider] transfer START", {
+        kind: params.mintAddress ? "spl" : "native",
+        toAddress: params.toAddress,
+        amount: params.amount,
+        mintAddress: params.mintAddress || null,
+        network: this.wallet.network,
+        hasPinHash: !!pinHash
+      });
+      const api = this.getTalkenApiClientOrThrow();
+      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
+        });
+        console.log("[AbcSolanaProvider] SPL transfer result:", result2);
+        return { signature: result2.txHash };
+      }
+      const { LAMPORTS_PER_SOL } = await import("@solana/web3.js");
+      const amountLamports = params.amount * LAMPORTS_PER_SOL;
+      console.log("[AbcSolanaProvider] native transfer request:", {
+        toAddress: params.toAddress,
+        amountLamports: String(amountLamports),
+        amountSOL: params.amount
+      });
+      const result = await api.solana.transfer({
+        kind: "native",
+        toAddress: params.toAddress,
+        amountLamports: String(amountLamports),
+        pin: pinHash
+      });
+      console.log("[AbcSolanaProvider] native transfer result:", result);
+      return { signature: result.txHash };
+    } catch (error) {
+      console.error("[AbcSolanaProvider] transfer FAILED:", {
+        message: error.message,
+        code: error.code,
+        status: error.status,
+        details: error.details || error.data
+      });
+      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
+};