@talken/talkenkit 2.3.12 → 2.3.14

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

@@ -0,0 +1,365 @@
+"use client";
+import {
+  secure_default
+} from "./chunk-G2LI5MVX.js";
+import {
+  getSolanaNetwork
+} from "./chunk-ZX6LABEF.js";
+
+// src/wallets/walletConnectors/abcWallet/abcSolProvider.ts
+import { Transaction, PublicKey } from "@solana/web3.js";
+
+// src/utils/encryption.ts
+async function hashPin(pin) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(pin);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/wallets/walletConnectors/abcWallet/abcSolProvider.ts
+var AbcSolProvider = class {
+  constructor(address, walletData) {
+    this.name = "ABC WaaS";
+    this.publicKey = null;
+    this.walletData = null;
+    if (address) {
+      this.publicKey = new PublicKey(address);
+    }
+    if (walletData) {
+      this.walletData = walletData;
+    } else if (address) {
+      this.loadWalletDataFromStorage();
+    }
+    const baseURL = process.env.NEXT_PUBLIC_ABC_WAAS_URL || "";
+    this.secure = new secure_default(baseURL);
+  }
+  /**
+   * Set PIN request callback
+   */
+  setRequestPinCallback(callback) {
+    this.requestPinCallback = callback;
+  }
+  /**
+   * Request PIN from user via callback or global callback
+   */
+  async requestPin() {
+    if (this.requestPinCallback) {
+      return this.requestPinCallback();
+    }
+    const globalCallback = window.__TALKENKIT_REQUEST_PIN__;
+    if (globalCallback) {
+      return globalCallback("transaction");
+    }
+    throw new Error("PIN request callback not configured");
+  }
+  /**
+   * Load wallet data from localStorage
+   */
+  loadWalletDataFromStorage() {
+    try {
+      const authState = localStorage.getItem("talkenkit_abc_auth_state");
+      if (authState) {
+        const parsed = JSON.parse(authState);
+        if (parsed.solanaWallet) {
+          this.walletData = parsed.solanaWallet;
+        }
+      }
+    } catch (_error) {
+    }
+  }
+  /**
+   * Get wallet data (from internal storage or localStorage)
+   */
+  getWalletData() {
+    if (this.walletData) {
+      return this.walletData;
+    }
+    const authState = localStorage.getItem("talkenkit_abc_auth_state");
+    if (authState) {
+      const parsed = JSON.parse(authState);
+      if (parsed.solanaWallet) {
+        this.walletData = parsed.solanaWallet;
+        return this.walletData;
+      }
+    }
+    throw new Error("No Solana wallet data available");
+  }
+  async signMessage(message, _encoding) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    const messageHex = Buffer.from(message).toString("hex");
+    const signBody = {
+      curve: walletData.curve,
+      encrypted_share: walletData.encrypted_share,
+      key_id: walletData.key_id,
+      message: messageHex,
+      secret_store: walletData.secret_store
+    };
+    const response = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(signBody)
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`ABC WaaS sign failed: ${errorText}`);
+    }
+    const result = await response.json();
+    const signatureHex = result.result?.signature || result.signature || result.data?.signature;
+    if (!signatureHex) {
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const signatureBytes = new Uint8Array(
+      signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    return { signature: signatureBytes };
+  }
+  async signTransaction(transaction, params) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    let toAddress;
+    let amount;
+    if (params) {
+      toAddress = params.toAddress;
+      amount = params.amount * 1e9;
+    } else {
+      const transferInstruction = transaction.instructions[0];
+      toAddress = transferInstruction.keys[1]?.pubkey.toString();
+      amount = 1e5;
+    }
+    const solanaNetwork = getSolanaNetwork();
+    const requestBody = {
+      network: solanaNetwork,
+      fromAddress: walletData.address,
+      toAddress,
+      amount,
+      feePayerAddress: walletData.address
+    };
+    const txResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/generateTransferSOLTransaction`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      }
+    );
+    if (!txResponse.ok) {
+      const errorText = await txResponse.text();
+      console.error("[AbcSolProvider] \u274C API error:", errorText);
+      throw new Error(
+        `Transaction generation failed (${txResponse.status}): ${errorText}`
+      );
+    }
+    const txData = await txResponse.json();
+    const serializedTxHex = txData.result?.data?.serialized_tx || txData.data?.serialized_tx;
+    if (!serializedTxHex) {
+      console.error(
+        "[AbcSolProvider] \u274C No serialized_tx in response:",
+        txData
+      );
+      throw new Error("No serialized transaction in response");
+    }
+    const signResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          curve: walletData.curve,
+          encrypted_share: walletData.encrypted_share,
+          key_id: walletData.key_id,
+          message: serializedTxHex,
+          secret_store: walletData.secret_store
+        })
+      }
+    );
+    if (!signResponse.ok) {
+      const errorText = await signResponse.text();
+      console.error("[AbcSolProvider] \u274C Sign API error:", errorText);
+      throw new Error(`Sign failed: ${errorText}`);
+    }
+    const signResult = await signResponse.json();
+    const signatureHex = signResult.signature || signResult.result?.signature;
+    if (!signatureHex) {
+      console.error(
+        "[AbcSolProvider] \u274C No signature in response:",
+        signResult
+      );
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const signatureBytes = new Uint8Array(
+      signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    const serializedTxBytes = new Uint8Array(
+      serializedTxHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    const signedTransaction = Transaction.from(serializedTxBytes);
+    if (!signedTransaction.signatures || signedTransaction.signatures.length === 0) {
+      signedTransaction.addSignature(
+        this.publicKey,
+        Buffer.from(signatureBytes)
+      );
+    }
+    return signedTransaction;
+  }
+  /**
+   * Send (broadcast) signed Solana transaction to network
+   * - Transaction generation: v2 API (application/json)
+   * - Transaction signing: v3 API (Ed25519 MPC)
+   * - Transaction broadcast: v2 API
+   */
+  async sendTransaction(params) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    const pin = await this.requestPin();
+    const STORAGE_PREFIX = "talkenkit_abc_";
+    const storedPinHash = localStorage.getItem(`${STORAGE_PREFIX}pin_hash`);
+    if (!storedPinHash) {
+      throw new Error("PIN not set. Please login again.");
+    }
+    const enteredPinHash = await hashPin(pin);
+    if (enteredPinHash !== storedPinHash) {
+      throw new Error("Incorrect PIN. Transaction cancelled.");
+    }
+    const solanaNetwork = getSolanaNetwork();
+    const generateBody = {
+      network: solanaNetwork,
+      fromAddress: walletData.address,
+      toAddress: params.toAddress,
+      amount: params.amount * 1e9,
+      // Convert SOL to lamports
+      feePayerAddress: walletData.address
+      // Fee payer is the sender
+    };
+    const generateResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/generateTransferSOLTransaction`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(generateBody)
+      }
+    );
+    if (!generateResponse.ok) {
+      const errorText = await generateResponse.text();
+      console.error("[AbcSolProvider] \u274C Generate TX error:", errorText);
+      throw new Error(`Transaction generation failed: ${errorText}`);
+    }
+    const txData = await generateResponse.json();
+    const serializedTxHex = txData.result?.data?.serialized_tx || txData.data?.serialized_tx || txData.result?.serialized_tx || txData.serialized_tx || txData.result?.data?.serializedTX || txData.data?.serializedTX;
+    if (!serializedTxHex) {
+      console.error(
+        "[AbcSolProvider] \u274C Cannot find serialized_tx in response:",
+        {
+          hasResult: !!txData.result,
+          hasData: !!txData.data,
+          hasResultData: !!txData.result?.data,
+          resultKeys: txData.result ? Object.keys(txData.result) : [],
+          dataKeys: txData.data ? Object.keys(txData.data) : [],
+          topLevelKeys: Object.keys(txData),
+          fullResponse: txData
+        }
+      );
+      throw new Error("No serialized transaction in response");
+    }
+    const signBody = {
+      curve: walletData.curve,
+      encrypted_share: walletData.encrypted_share,
+      key_id: walletData.key_id,
+      message: serializedTxHex,
+      secret_store: walletData.secret_store
+    };
+    const signResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(signBody)
+      }
+    );
+    if (!signResponse.ok) {
+      const errorText = await signResponse.text();
+      console.error("[AbcSolProvider] \u274C Sign error:", errorText);
+      throw new Error(`Sign failed: ${errorText}`);
+    }
+    const signResult = await signResponse.json();
+    const signatureHex = signResult.signature || signResult.result?.signature || signResult.data?.signature;
+    if (!signatureHex) {
+      console.error(
+        "[AbcSolProvider] \u274C No signature in response:",
+        signResult
+      );
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const sendResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/sendTransaction`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          network: solanaNetwork,
+          serializedTX: serializedTxHex,
+          signatures: [signatureHex]
+        })
+      }
+    );
+    if (!sendResponse.ok) {
+      const errorText = await sendResponse.text();
+      console.error("[AbcSolProvider] \u274C Broadcast error:", {
+        status: sendResponse.status,
+        statusText: sendResponse.statusText,
+        error: errorText
+      });
+      try {
+        const errorData = JSON.parse(errorText);
+        if (errorData.message?.includes("insufficient") || errorData.message?.includes("InsufficientFunds")) {
+          throw new Error("Insufficient SOL balance to send transaction");
+        }
+      } catch (_parseError) {
+      }
+      throw new Error(
+        `Transaction broadcast failed (${sendResponse.status}): ${errorText}`
+      );
+    }
+    const sendResult = await sendResponse.json();
+    const txHash = sendResult.result?.data || sendResult.data || sendResult.txHash;
+    return {
+      signature: signatureHex,
+      txHash: txHash || signatureHex
+    };
+  }
+};
+
+export {
+  AbcSolProvider
+};

package/dist/wallets/walletConnectors/{chunk-GLPRLW3S.js → chunk-JNKT32C7.js}

@@ -1,19 +1,19 @@
 "use client";
 import {
-  WalletApi
-} from "./chunk-ESRU5KCF.js";
+  SigningApi
+} from "./chunk-TUUNSVKZ.js";
 import {
-  BitcoinApi
-} from "./chunk-IA4EQFSS.js";
+  WalletApi
+} from "./chunk-6KO5WQ5C.js";
 import {
   AuthApi
 } from "./chunk-RLBGBBIO.js";
 import {
-  SigningApi
-} from "./chunk-TUUNSVKZ.js";
+  BitcoinApi
+} from "./chunk-IA4EQFSS.js";
 import {
   SolanaApi
-} from "./chunk-2J66VMY5.js";
+} from "./chunk-43LPUTHW.js";
 import {
   TransactionApi
 } from "./chunk-HDYBRMYW.js";

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

@@ -0,0 +1,156 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-NX5MQHSQ.js";
+import {
+  getSolanaNetwork
+} from "./chunk-ZX6LABEF.js";
+import {
+  createAbcError
+} from "./chunk-UV5HHESJ.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-JXPLBYVW.js

@@ -0,0 +1,157 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-NX5MQHSQ.js";
+import {
+  getSolanaNetwork
+} from "./chunk-AL7R7JQU.js";
+import {
+  createAbcError
+} from "./chunk-UV5HHESJ.js";
+
+// src/wallets/walletConnectors/abcWallet/api/SolanaApi.ts
+var SolanaApi = class extends BaseApiClient {
+  /**
+   * Generate Solana wallet (Ed25519)
+   * Uses V3 API with Ed25519 curve
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @param isRecover - Whether to recover existing wallet (default: false)
+   * @returns Solana wallet information
+   */
+  async generateSolanaWallet(pin, isRecover = false) {
+    const endpoint = `/v3/wallet/${isRecover ? "recover" : "generate"}`;
+    const response = await this.request(endpoint, {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        password: pin,
+        network: "solana"
+      }
+    });
+    if (response.status !== "success" || !response.result) {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        `Failed to ${isRecover ? "recover" : "generate"} Solana wallet`,
+        response
+      );
+    }
+    const result = response.result;
+    const address = this.deriveAddressFromPublicKey(result.public_key);
+    const network = getSolanaNetwork();
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || "",
+      secretStore: result.secret_store || "",
+      network
+    };
+  }
+  /**
+   * Recover Solana wallet (alias for generateSolanaWallet with isRecover=true)
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @returns Recovered Solana wallet information
+   */
+  async recoverSolanaWallet(pin) {
+    return this.generateSolanaWallet(pin, true);
+  }
+  /**
+   * Derive Solana address from Ed25519 public key
+   * Converts hex public key to base58-encoded Solana address
+   *
+   * @param publicKey - Ed25519 public key (hex)
+   * @returns Solana address (base58)
+   */
+  deriveAddressFromPublicKey(publicKey) {
+    const cleanKey = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+    return cleanKey;
+  }
+  /**
+   * Sign Solana transaction with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
+   */
+  async signSolanaTransaction(params) {
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
+      }
+    });
+    if (response.status !== "success" || !response.result?.signature) {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana transaction",
+        response
+      );
+    }
+    return {
+      signature: response.result.signature
+    };
+  }
+  /**
+   * Sign Solana message with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
+   */
+  async signSolanaMessage(params) {
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
+      }
+    });
+    if (response.status !== "success" || !response.result?.signature) {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana message",
+        response
+      );
+    }
+    return {
+      signature: response.result.signature
+    };
+  }
+  /**
+   * Send Solana transaction
+   */
+  async sendSolanaTransaction(params) {
+    const response = await this.request("/wapi/v2/solana/tx/sendTransaction", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        network: params.network,
+        serializedTX: params.serializedTX,
+        signatures: params.signatures
+      }
+    });
+    if (response.status !== "success" || !response.result?.data) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to send Solana transaction",
+        response
+      );
+    }
+    return {
+      txHash: response.result.data
+    };
+  }
+};
+
+export {
+  SolanaApi
+};