@talken/talkenkit 2.4.12 → 2.4.14

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

@@ -0,0 +1,63 @@
+"use client";
+import {
+  TransactionApi
+} from "./chunk-DJKN2MCI.js";
+import {
+  WalletApi
+} from "./chunk-V33I7JGZ.js";
+import {
+  AuthApi
+} from "./chunk-ZNBWRE3K.js";
+import {
+  BitcoinApi
+} from "./chunk-V4Q3GNBX.js";
+import {
+  SigningApi
+} from "./chunk-7VZDITAJ.js";
+import {
+  SolanaApi
+} from "./chunk-AB6IIS4Y.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-ZE3USY6D.js

@@ -0,0 +1,156 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-DSTCYPGN.js";
+import {
+  getSolanaNetwork
+} from "./chunk-A7FIBI6X.js";
+import {
+  createAbcError
+} from "./chunk-5RSS3SRV.js";
+import {
+  ABC_ENDPOINTS,
+  DEFAULT_HEADERS
+} from "./chunk-VETRBBA2.js";
+
+// src/wallets/walletConnectors/abcWallet/api/WalletApi.ts
+var WalletApi = class extends BaseApiClient {
+  /**
+   * Generate or recover EVM wallet
+   */
+  async generateOrRecoverWallet(params) {
+    const response = await this.request(
+      // Use 'any' to get raw API response
+      ABC_ENDPOINTS.MPC_WALLETS,
+      // Use correct EVM endpoint, not WALLETS_V3 (Solana only)
+      {
+        method: "POST",
+        body: {
+          uid: params.uid,
+          pin: params.pin,
+          chainId: params.chainId,
+          network: params.network || "mainnet"
+        }
+      }
+    );
+    if (response.status === "success" && response.data) {
+      const raw = response.data;
+      console.log("[WalletApi] Raw wallet API response:", {
+        hasUid: !!raw.uid,
+        hasSid: !!raw.sid,
+        hasWid: !!raw.wid,
+        hasPvencstr: !!raw.pvencstr,
+        hasEncryptDevicePassword: !!raw.encryptDevicePassword,
+        hasPubkey: !!raw.pubkey,
+        allKeys: Object.keys(raw)
+      });
+      return {
+        address: raw.address || "",
+        keyId: raw.keyId || raw.key_id || raw.sid,
+        encryptedShare: raw.encryptedShare || raw.encrypted_share || "",
+        uid: raw.uid,
+        sid: raw.sid,
+        wid: raw.wid,
+        // Preserve for Bitcoin signing
+        pvencstr: raw.pvencstr,
+        // Preserve for Bitcoin signing
+        encryptDevicePassword: raw.encryptDevicePassword,
+        // Preserve for Bitcoin signing
+        pubkey: raw.pubkey || null
+      };
+    }
+    throw createAbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      "Failed to generate wallet",
+      response
+    );
+  }
+  /**
+   * Get wallet info
+   */
+  async getWalletInfo(uid) {
+    const response = await this.request(ABC_ENDPOINTS.INFO, {
+      method: "POST",
+      body: { uid }
+    });
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw createAbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      "Failed to get wallet info",
+      response
+    );
+  }
+  /**
+   * Generate or recover Solana wallet (Ed25519)
+   */
+  async generateSolanaWallet(pin, _isRecover = false) {
+    const url = `\${this.baseURL}/v3/wallet/\${isRecover ? 'recover' : 'generate'}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+      },
+      body: JSON.stringify({
+        curve: "ed25519",
+        password: pin
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Failed to generate Solana wallet",
+        data
+      );
+    }
+    const result = data.result;
+    const solanaNetwork = getSolanaNetwork();
+    const addressResult = await this.getSolanaAddress(
+      result.public_key,
+      solanaNetwork
+    );
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address: addressResult,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || "",
+      network: solanaNetwork
+    };
+  }
+  /**
+   * Get Solana address from Ed25519 public key
+   */
+  async getSolanaAddress(publicKey, network) {
+    const url = "${this.baseURL}/wapi/v2/solana/wallet/getAddress";
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+      },
+      body: JSON.stringify({
+        network,
+        publicKey
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to get Solana address",
+        data
+      );
+    }
+    return data.result?.data?.address;
+  }
+};
+
+export {
+  WalletApi
+};

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

@@ -0,0 +1,489 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/abcSolanaProvider.ts
+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.requestPinCallback = null;
+    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 PIN request callback for transaction signing
+   */
+  setRequestPinCallback(callback) {
+    this.requestPinCallback = callback;
+  }
+  /**
+   * 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 Solana transaction (not used - ABC WaaS handles signing server-side)
+   * This method is kept for compatibility but not recommended for direct use
+   * Use the high-level sendTransaction() flow instead
+   */
+  async signTransaction(_transaction, _params) {
+    throw new SolanaProviderError(
+      SolanaErrorCode.UNSUPPORTED_METHOD,
+      "Direct transaction signing not supported. Use useSolanaWallet.sendTransaction() which handles the full flow via ABC WaaS API."
+    );
+  }
+  /**
+   * Send Solana transaction (with PIN verification)
+   */
+  async sendTransaction(params) {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    if (!this.requestPinCallback) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.UNAUTHORIZED,
+        "PIN callback not set"
+      );
+    }
+    try {
+      const pin = await this.requestPinCallback();
+      const encoder = new TextEncoder();
+      const data = encoder.encode(pin);
+      const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      const pinHash = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+      const storedPinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+      if (storedPinHash && pinHash !== storedPinHash) {
+        throw new SolanaProviderError(
+          SolanaErrorCode.UNAUTHORIZED,
+          "Incorrect PIN"
+        );
+      }
+      const { LAMPORTS_PER_SOL } = await import("@solana/web3.js");
+      const network = this.wallet.network || "solana_devnet";
+      const amountLamports = params.amount * LAMPORTS_PER_SOL;
+      const txGenResponse = await this.client.solana.generateTransferTransaction({
+        network,
+        amount: amountLamports,
+        fromAddress: this.wallet.address,
+        toAddress: params.toAddress,
+        feePayerAddress: this.wallet.address
+      });
+      const signatureResponse = await this.client.solana.signSolanaTransaction({
+        keyId: this.wallet.keyId,
+        encryptedShare: this.wallet.encryptedShare,
+        secretStore: this.wallet.secretStore || "",
+        message: txGenResponse.serialized_tx
+      });
+      const result = await this.client.solana.sendSolanaTransaction({
+        network,
+        serializedTX: txGenResponse.serialized_tx,
+        signatures: [signatureResponse.signature]
+      });
+      return {
+        signature: result.txHash,
+        serializedTx: txGenResponse.serialized_tx
+      };
+    } catch (error) {
+      if (error.code === 4001 || error.cancelled) {
+        throw error;
+      }
+      this.emit("error", error);
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "Failed to send transaction",
+        error
+      );
+    }
+  }
+  /**
+   * Get wallet info
+   */
+  getWalletInfo() {
+    if (!this.wallet)
+      return null;
+    return {
+      address: this.wallet.address,
+      publicKey: this.wallet.publicKey,
+      network: this.wallet.network
+    };
+  }
+  /**
+   * Transfer SPL token (requires PIN)
+   *
+   * @param params - Transfer parameters
+   * @returns Transaction signature and serialized transaction
+   */
+  async transferSPL(params) {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    if (!this.requestPinCallback) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.UNAUTHORIZED,
+        "PIN callback not set"
+      );
+    }
+    try {
+      const pin = await this.requestPinCallback();
+      const encoder = new TextEncoder();
+      const data = encoder.encode(pin);
+      const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      const pinHash = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+      const storedPinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+      if (storedPinHash && pinHash !== storedPinHash) {
+        throw new SolanaProviderError(
+          SolanaErrorCode.UNAUTHORIZED,
+          "Incorrect PIN"
+        );
+      }
+      const apiNetwork = this.wallet.network === "solana" ? "solana_mainnet" : this.wallet.network;
+      console.log("[AbcSolanaProvider] \u{1F680} Starting SPL transfer:", {
+        mintAddress: params.mintAddress,
+        toAddress: params.toAddress,
+        amount: params.amount,
+        network: this.wallet.network,
+        apiNetwork
+      });
+      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(params.mintAddress);
+      console.log("[AbcSolanaProvider] \u{1F4CA} Fetching token decimals...");
+      const mintInfo = await connection.getParsedAccountInfo(mintPubkey);
+      const decimals = mintInfo.value?.data?.parsed?.info?.decimals || 9;
+      console.log("[AbcSolanaProvider] \u2705 Token decimals:", decimals);
+      const rawAmount = Math.floor(params.amount * 10 ** decimals);
+      console.log("[AbcSolanaProvider] \u{1F4B0} Raw amount:", rawAmount);
+      const ownerPubkey = new PublicKey(this.wallet.address);
+      const toPubkey = new PublicKey(params.toAddress);
+      console.log("[AbcSolanaProvider] \u{1F511} Resolving ATAs...");
+      const fromTokenAccount = await getAssociatedTokenAddress(
+        mintPubkey,
+        ownerPubkey,
+        false,
+        TOKEN_PROGRAM_ID
+      );
+      console.log("[AbcSolanaProvider] From ATA:", fromTokenAccount.toBase58());
+      const toTokenAccount = await getAssociatedTokenAddress(
+        mintPubkey,
+        toPubkey,
+        false,
+        TOKEN_PROGRAM_ID
+      );
+      console.log("[AbcSolanaProvider] To ATA:", toTokenAccount.toBase58());
+      console.log("[AbcSolanaProvider] \u{1F50D} Checking token accounts...");
+      const fromAccountInfo = await connection.getAccountInfo(fromTokenAccount);
+      if (!fromAccountInfo) {
+        console.error("[AbcSolanaProvider] \u274C Source ATA does not exist");
+        throw new SolanaProviderError(
+          SolanaErrorCode.INTERNAL_ERROR,
+          "You do not have a token account for this token. Please receive some tokens first."
+        );
+      }
+      console.log("[AbcSolanaProvider] \u2705 Source ATA exists");
+      if (toTokenAccount.toBase58() !== fromTokenAccount.toBase58()) {
+        const toAccountInfo = await connection.getAccountInfo(toTokenAccount);
+        if (!toAccountInfo && !params.createAccountIfNeeded) {
+          console.error("[AbcSolanaProvider] \u274C Destination ATA does not exist");
+          throw new SolanaProviderError(
+            SolanaErrorCode.INTERNAL_ERROR,
+            "Destination token account does not exist. Auto-creation not yet implemented. Please create it manually first."
+          );
+        }
+        if (toAccountInfo) {
+          console.log("[AbcSolanaProvider] \u2705 Destination ATA exists");
+        } else {
+          console.log("[AbcSolanaProvider] \u26A0\uFE0F Destination ATA will be created (not implemented yet)");
+        }
+      } else {
+        console.log("[AbcSolanaProvider] \u2139\uFE0F Self-transfer: same ATA for source and destination");
+      }
+      console.log("[AbcSolanaProvider] \u{1F4DD} Building SPL transaction client-side...");
+      const {
+        Transaction,
+        PublicKey: SolanaPublicKey,
+        SystemProgram
+      } = await import("@solana/web3.js");
+      const { createTransferInstruction } = await import("@solana/spl-token");
+      const { blockhash } = await connection.getLatestBlockhash();
+      const transaction = new Transaction();
+      transaction.feePayer = new SolanaPublicKey(this.wallet.address);
+      transaction.recentBlockhash = blockhash;
+      transaction.add(
+        createTransferInstruction(
+          fromTokenAccount,
+          // Source ATA
+          toTokenAccount,
+          // Destination ATA
+          new SolanaPublicKey(this.wallet.address),
+          // Owner
+          rawAmount
+          // Amount in raw units
+        )
+      );
+      const serializedTxBuffer = transaction.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false
+      });
+      const serializedTxHex = Buffer.from(serializedTxBuffer).toString("hex");
+      console.log(
+        "[AbcSolanaProvider] \u2705 Transaction built (hex):",
+        serializedTxHex.substring(0, 50) + "..."
+      );
+      console.log("[AbcSolanaProvider] \u270D\uFE0F Signing transaction...");
+      const signatureResponse = await this.client.solana.signSolanaTransaction({
+        keyId: this.wallet.keyId,
+        encryptedShare: this.wallet.encryptedShare,
+        secretStore: this.wallet.secretStore || "",
+        message: serializedTxHex
+      });
+      console.log("[AbcSolanaProvider] \u2705 Transaction signed");
+      console.log("[AbcSolanaProvider] \u{1F510} Adding signature to transaction...");
+      const signatureBuffer = Buffer.from(signatureResponse.signature, "base64");
+      transaction.addSignature(
+        new SolanaPublicKey(this.wallet.address),
+        signatureBuffer
+      );
+      const signedTxBuffer = transaction.serialize();
+      const serializedTxBase64 = Buffer.from(signedTxBuffer).toString("base64");
+      console.log("[AbcSolanaProvider] \u2705 Signed transaction serialized");
+      console.log("[AbcSolanaProvider] \u{1F4E4} Sending transaction...");
+      const result = await this.client.solana.sendSolanaTransaction({
+        network: apiNetwork,
+        serializedTX: serializedTxBase64,
+        signatures: [signatureResponse.signature]
+      });
+      console.log("[AbcSolanaProvider] \u2705 Transaction sent:", result.txHash);
+      return {
+        signature: result.txHash,
+        serializedTx: serializedTxBase64
+      };
+    } catch (error) {
+      console.error("[AbcSolanaProvider] \u274C SPL transfer failed:", error);
+      if (error.code === 4001 || error.cancelled) {
+        throw error;
+      }
+      this.emit("error", error);
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "Failed to transfer SPL token",
+        error
+      );
+    }
+  }
+  /**
+   * Transfer NFT (Solana NFT = SPL token with decimals: 0, amount: 1)
+   *
+   * @param params - Transfer parameters
+   * @returns Transaction signature and serialized transaction
+   */
+  async transferNFT(params) {
+    return this.transferSPL({
+      mintAddress: params.mintAddress,
+      toAddress: params.toAddress,
+      amount: 1,
+      // NFTs always transfer 1 unit
+      createAccountIfNeeded: params.createAccountIfNeeded
+    });
+  }
+  /**
+   * 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
+};