@talken/talkenkit 2.4.28 → 2.4.29

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

@@ -0,0 +1,445 @@
+"use client";
+import {
+  WalletscanApi
+} from "./chunk-LJNUFDGO.js";
+import {
+  getCredentialManager
+} from "./chunk-6WF4SXLB.js";
+
+// src/wallets/walletConnectors/abcWallet/abcSolanaProvider.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+
+// src/utils/apiClientFactory.ts
+function createWalletscanApi() {
+  return new WalletscanApi();
+}
+
+// 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(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();
+      const apiNetwork = this.wallet.network === "solana" ? "solana" : "solana_devnet";
+      if (params.mintAddress) {
+        const walletscanApi = createWalletscanApi();
+        const tokenMeta = await walletscanApi.getContractTokenWithTimeout({
+          contractAddress: params.mintAddress,
+          networks: apiNetwork
+        });
+        const decimals = tokenMeta?.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),
+        network: apiNetwork,
+        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 walletscanApi = createWalletscanApi();
+      const balance = await walletscanApi.getWalletTokenBalanceWithTimeout({
+        walletAddress: this.wallet.address,
+        networks: this.wallet.network,
+        contractAddress: mintAddress
+      });
+      if (!balance) {
+        return {
+          amount: "0",
+          decimals: 0,
+          uiAmount: 0
+        };
+      }
+      return {
+        amount: String(balance.balance ?? 0),
+        decimals: balance.decimals ?? 0,
+        uiAmount: balance.hrBalance ?? 0
+      };
+    } catch (error) {
+      this.emit("error", error);
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "Failed to get token balance",
+        error
+      );
+    }
+  }
+};
+
+export {
+  SolanaProviderError,
+  AbcSolanaProvider
+};

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

@@ -0,0 +1,205 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-MBRXYEQC.js";
+import {
+  createAbcError
+} from "./chunk-LOSXI36Y.js";
+import {
+  DEFAULT_HEADERS
+} from "./chunk-BR25RFNF.js";
+
+// src/wallets/walletConnectors/abcWallet/api/BitcoinApi.ts
+var BitcoinApi = class extends BaseApiClient {
+  /**
+   * Generate Bitcoin wallet
+   * Uses V3 API with secp256k1 curve (same as EVM but compressed public key)
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @param network - Bitcoin network (mainnet or testnet)
+   * @param addressType - Bitcoin address type (bech32 recommended)
+   * @returns Bitcoin wallet information
+   */
+  async generateBitcoinWallet(pin, network = "bitcoin", addressType = "bech32") {
+    console.log("[BitcoinApi] Generating Bitcoin wallet...", {
+      network,
+      addressType
+    });
+    const response = await this.request("/v3/wallet/generate", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "secp256k1",
+        // Same as EVM but compressed public key
+        password: pin,
+        network
+      }
+    });
+    if (response.status !== "success" || !response.result) {
+      console.error("[BitcoinApi] Generation failed:", response);
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Failed to generate Bitcoin wallet",
+        response
+      );
+    }
+    const result = response.result;
+    const addressResult = await this.getBitcoinAddress(
+      result.public_key,
+      network,
+      addressType
+    );
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      // Compressed (33 bytes, 0x02 or 0x03 prefix)
+      address: addressResult,
+      addressType,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || "",
+      network
+    };
+  }
+  /**
+   * Recover Bitcoin wallet
+   * Uses V3 API wallet recovery endpoint
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @param network - Bitcoin network
+   * @param addressType - Bitcoin address type
+   * @returns Recovered Bitcoin wallet information
+   */
+  async recoverBitcoinWallet(pin, network = "bitcoin", addressType = "bech32") {
+    console.log("[BitcoinApi] Recovering Bitcoin wallet...", {
+      network,
+      addressType
+    });
+    const response = await this.request("/v3/wallet/recover", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "secp256k1",
+        password: pin,
+        network
+      }
+    });
+    if (response.status !== "success" || !response.result) {
+      console.error("[BitcoinApi] Recovery failed:", response);
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Failed to recover Bitcoin wallet",
+        response
+      );
+    }
+    const result = response.result;
+    const addressResult = await this.getBitcoinAddress(
+      result.public_key,
+      network,
+      addressType
+    );
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address: addressResult,
+      addressType,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || "",
+      network
+    };
+  }
+  /**
+   * Get Bitcoin address from compressed public key
+   *
+   * @param publicKey - Compressed public key (33 bytes, hex)
+   * @param network - Bitcoin network
+   * @param addressType - Address format type (currently not used by API)
+   * @returns Bitcoin address
+   */
+  async getBitcoinAddress(publicKey, network, _addressType = "bech32") {
+    const url = `${this.baseURL}/wapi/v2/btc/address`;
+    const params = new URLSearchParams({
+      pubkey: publicKey,
+      network
+    });
+    const response = await fetch(`${url}?${params}`, {
+      method: "GET",
+      headers: {
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      }
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to get Bitcoin address",
+        data
+      );
+    }
+    return data.address;
+  }
+  /**
+   * Get UTXOs (Unspent Transaction Outputs) for address
+   *
+   * @param address - Bitcoin address
+   * @param network - Bitcoin network
+   * @returns Array of UTXOs
+   */
+  async getUtxos(address, network) {
+    const url = `${this.baseURL}/wapi/v2/bitcoin/utxo/list`;
+    const params = new URLSearchParams({ network, address });
+    const response = await fetch(`${url}?${params}`, {
+      method: "GET",
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      }
+    });
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to get UTXOs",
+        data
+      );
+    }
+    return data.result?.utxos || [];
+  }
+  /**
+   * Broadcast signed Bitcoin transaction
+   *
+   * @param params - Transaction broadcast parameters
+   * @returns Transaction hash
+   */
+  async sendBitcoinTransaction(params) {
+    const url = `${this.baseURL}/wapi/v2/bitcoin/tx/sendTransaction`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        network: params.network,
+        rawTransaction: params.rawTransaction,
+        ...params.psbt && { psbt: params.psbt }
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to send Bitcoin transaction",
+        data
+      );
+    }
+    return { txHash: data.result?.data };
+  }
+};
+
+export {
+  BitcoinApi
+};