@talken/talkenkit 2.4.24 → 2.4.25

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

@@ -0,0 +1,54 @@
+"use client";
+import {
+  abcConnector
+} from "./chunk-Z5SBGIWT.js";
+import {
+  resolveTalkenApiUrl
+} from "./chunk-GFWUFYT2.js";
+import {
+  createTalkenApiClient
+} from "./chunk-VTOD7PXP.js";
+import {
+  ABC_WALLET_METADATA
+} from "./chunk-DPTDOCWL.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-IM7DEERX.js

@@ -0,0 +1,585 @@
+"use client";
+import {
+  getCredentialManager
+} from "./chunk-6WF4SXLB.js";
+
+// src/wallets/walletConnectors/abcWallet/abcBitcoinProvider.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+function isTalkenApiClient(client) {
+  return typeof client?.bitcoin?.getUtxos === "function";
+}
+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 BitcoinErrorCode = {
+  USER_REJECTED: 4001,
+  UNAUTHORIZED: 4100,
+  UNSUPPORTED_METHOD: 4200,
+  DISCONNECTED: 4900,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  INSUFFICIENT_FUNDS: 5001,
+  UTXO_NOT_FOUND: 5002
+};
+var BitcoinProviderError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "BitcoinProviderError";
+  }
+};
+var BITCOIN_NETWORKS = {
+  mainnet: {
+    name: "Bitcoin Mainnet",
+    type: "bitcoin",
+    explorer: "https://blockstream.info"
+  },
+  testnet: {
+    name: "Bitcoin Testnet",
+    type: "bitcoin_testnet",
+    explorer: "https://blockstream.info/testnet"
+  }
+};
+var AbcBitcoinProvider = class extends EventEmitter {
+  constructor(client) {
+    super();
+    this.wallet = null;
+    this.network = BITCOIN_NETWORKS.testnet;
+    this.connected = false;
+    this.utxoCache = /* @__PURE__ */ new Map();
+    this.cacheExpiry = /* @__PURE__ */ new Map();
+    this.CACHE_TTL = 6e4;
+    if (isTalkenApiClient(client)) {
+      this.talkenApi = client;
+    }
+  }
+  extractHashSignature(result) {
+    const data = result;
+    return data?.signatureHex || data?.signstr || data?.result?.signstr || data?.data?.signatureHex || data?.data?.signstr || data?.data?.result?.signstr || "";
+  }
+  getRecoveryEmail() {
+    return getCredentialManager().getEmail() || void 0;
+  }
+  /**
+   * 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 (wallet.network === "bitcoin") {
+      this.network = BITCOIN_NETWORKS.mainnet;
+    } else {
+      this.network = BITCOIN_NETWORKS.testnet;
+    }
+    if (previousAddress !== wallet.address) {
+      this.emit("accountsChanged", [wallet.address]);
+      this.clearUtxoCache();
+    }
+    this.emit("connect", {
+      address: wallet.address,
+      network: this.network.type
+    });
+    console.log(
+      "[BitcoinProvider] \u2705 Wallet connected:",
+      `${wallet.address.substring(0, 6)}...${wallet.address.substring(wallet.address.length - 6)}`
+    );
+  }
+  /**
+   * Clear wallet (disconnect)
+   */
+  clearWallet() {
+    this.wallet = null;
+    this.connected = false;
+    this.clearUtxoCache();
+    this.emit("disconnect");
+    this.emit("accountsChanged", []);
+    console.log("[BitcoinProvider] \u{1F50C} Wallet disconnected");
+  }
+  /**
+   * Set TalkenApiClient for backend-proxied transaction flow
+   * When set, sendTransaction will use a single API call instead of multi-step WaaS
+   */
+  setTalkenApi(talkenApi) {
+    this.talkenApi = talkenApi;
+  }
+  /**
+   * Set network
+   */
+  setNetwork(networkKey) {
+    const newNetwork = BITCOIN_NETWORKS[networkKey];
+    if (!newNetwork) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INVALID_PARAMS,
+        `Unknown network: ${networkKey}`
+      );
+    }
+    const previousType = this.network.type;
+    this.network = newNetwork;
+    if (previousType !== newNetwork.type) {
+      this.emit("networkChanged", newNetwork.type);
+      this.clearUtxoCache();
+    }
+  }
+  /**
+   * Get current network
+   */
+  getNetwork() {
+    return this.network;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected && this.wallet !== null;
+  }
+  /**
+   * Get Bitcoin address
+   */
+  async getAddress() {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.address;
+  }
+  /**
+   * Get compressed public key (33 bytes)
+   */
+  async getPublicKey() {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.publicKey;
+  }
+  /**
+   * Get address type (bech32, p2pkh, etc.)
+   */
+  getAddressType() {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.addressType;
+  }
+  /**
+   * Clear UTXO cache
+   */
+  clearUtxoCache() {
+    this.utxoCache.clear();
+    this.cacheExpiry.clear();
+  }
+  /**
+   * Check if cache is valid
+   */
+  isCacheValid(address) {
+    const expiry = this.cacheExpiry.get(address);
+    if (!expiry)
+      return false;
+    return Date.now() < expiry;
+  }
+  normalizeUtxos(rawUtxos) {
+    return rawUtxos.map((u) => ({
+      txid: String(u?.txid ?? u?.tx_hash ?? ""),
+      vout: Number(u?.vout ?? u?.output_index ?? 0),
+      value: Number(u?.value ?? u?.satoshis ?? 0),
+      scriptPubKey: String(
+        u?.scriptPubKey ?? u?.script_pub_key ?? u?.script ?? ""
+      ),
+      confirmations: Number(u?.confirmations ?? 0)
+    })).filter(
+      (u) => Boolean(u.txid) && Number.isFinite(u.vout) && Number.isFinite(u.value) && Number.isFinite(u.confirmations)
+    );
+  }
+  /**
+   * Get UTXOs for address (with caching)
+   */
+  async getUtxos(forceRefresh = false) {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    const address = this.wallet.address;
+    if (!forceRefresh && this.isCacheValid(address)) {
+      const cached = this.utxoCache.get(address);
+      if (cached) {
+        console.log(
+          `[BitcoinProvider] \u{1F4E6} Using cached UTXOs (${cached.length} items)`
+        );
+        return cached;
+      }
+    }
+    try {
+      console.log("[BitcoinProvider] \u{1F50D} Fetching UTXOs from network...");
+      const api = this.talkenApi || getTalkenApiClient();
+      const result = await api.bitcoin.getUtxos(this.network.type, address);
+      const utxos = this.normalizeUtxos(result.utxos || []);
+      this.utxoCache.set(address, utxos);
+      this.cacheExpiry.set(address, Date.now() + this.CACHE_TTL);
+      console.log(`[BitcoinProvider] \u2705 Fetched ${utxos.length} UTXOs`);
+      return utxos;
+    } catch (error) {
+      console.error(
+        "[BitcoinProvider] \u274C Failed to fetch UTXOs:",
+        error.message
+      );
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INTERNAL_ERROR,
+        "Failed to fetch UTXOs",
+        error
+      );
+    }
+  }
+  /**
+   * Get total balance (sum of all UTXOs)
+   * Returns balance in satoshis
+   */
+  async getBalance(forceRefresh = false) {
+    const utxos = await this.getUtxos(forceRefresh);
+    const balance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
+    console.log(
+      `[BitcoinProvider] \u{1F4B0} Balance: ${balance} satoshis (${balance / 1e8} BTC)`
+    );
+    return balance;
+  }
+  /**
+   * Estimate transaction fee
+   * Returns fee rate in satoshis per byte
+   */
+  async estimateFee(targetBlocks = 6) {
+    try {
+      const api = this.talkenApi || getTalkenApiClient();
+      const result = await api.bitcoin.getFeeRate(
+        this.network.type,
+        targetBlocks
+      );
+      const feeRate = Number(result.feeRate);
+      if (!Number.isFinite(feeRate) || feeRate <= 0) {
+        throw new Error("Invalid fee rate");
+      }
+      console.log(`[BitcoinProvider] \u26FD Fee rate: ${feeRate} sat/byte`);
+      return feeRate;
+    } catch (_error) {
+      console.error("[BitcoinProvider] \u26A0\uFE0F Fee estimation failed, using default");
+      return 1;
+    }
+  }
+  /**
+   * Sign Bitcoin message (Bitcoin Signed Message format)
+   * Uses secp256k1 sign/hash endpoint with double-SHA256 of prefixed message.
+   *
+   * Format: SHA256(SHA256("\x18Bitcoin Signed Message:\n" + varint(len) + message))
+   *
+   * @param message - Message to sign (string)
+   * @returns Signature in hex format (compact: r + s + v)
+   */
+  async signMessage(message) {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    await this.callInterceptor({
+      chain: "bitcoin",
+      method: "signMessage",
+      address: this.wallet.address,
+      network: this.network.type,
+      message
+    });
+    console.log("[BitcoinProvider] \u{1F4DD} Signing Bitcoin message...");
+    const prefix = "Bitcoin Signed Message:\n";
+    const msgBytes = new TextEncoder().encode(message);
+    const varint = this.encodeVarint(msgBytes.length);
+    const prefixBytes = new TextEncoder().encode(prefix);
+    const preimage = new Uint8Array(
+      prefixBytes.length + varint.length + msgBytes.length
+    );
+    preimage.set(prefixBytes, 0);
+    preimage.set(varint, prefixBytes.length);
+    preimage.set(msgBytes, prefixBytes.length + varint.length);
+    const hash1 = await crypto.subtle.digest("SHA-256", preimage);
+    const hash2 = await crypto.subtle.digest("SHA-256", hash1);
+    const hashHex = Array.from(new Uint8Array(hash2)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const api = getTalkenApiClient();
+    if (!api) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INTERNAL_ERROR,
+        "TalkenApiClient not initialized"
+      );
+    }
+    const pinHash = getCredentialManager().getPinHash() || "";
+    const email = this.getRecoveryEmail();
+    let signstr = "";
+    try {
+      const result = await api.bitcoin.execute({
+        action: "signHash",
+        hash: hashHex,
+        pin: pinHash,
+        network: this.network.type,
+        ...email && { email }
+      });
+      signstr = this.extractHashSignature(result);
+    } catch (error) {
+      console.warn(
+        "[BitcoinProvider] BTC signHash endpoint failed, falling back to generic sign/hash:",
+        error
+      );
+    }
+    if (!signstr) {
+      signstr = this.extractHashSignature(
+        await api.bitcoin.signHash({
+          hash: hashHex,
+          pin: pinHash,
+          network: this.network.type,
+          ...email && { email }
+        })
+      );
+    }
+    if (!signstr) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INTERNAL_ERROR,
+        "Empty signature from sign/hash"
+      );
+    }
+    console.log("[BitcoinProvider] \u2705 Message signed successfully");
+    return signstr;
+  }
+  /** Encode integer as Bitcoin varint */
+  encodeVarint(n) {
+    if (n < 253)
+      return new Uint8Array([n]);
+    if (n <= 65535) {
+      const buf2 = new Uint8Array(3);
+      buf2[0] = 253;
+      buf2[1] = n & 255;
+      buf2[2] = n >> 8 & 255;
+      return buf2;
+    }
+    const buf = new Uint8Array(5);
+    buf[0] = 254;
+    buf[1] = n & 255;
+    buf[2] = n >> 8 & 255;
+    buf[3] = n >> 16 & 255;
+    buf[4] = n >> 24 & 255;
+    return buf;
+  }
+  /**
+   * High-level transaction sending (like Solana pattern)
+   * Creates, signs, and broadcasts transaction
+   *
+   * @param params - Transaction parameters
+   * @param params.toAddress - Recipient Bitcoin address
+   * @param params.amount - Amount in BTC (will be converted to satoshis)
+   * @returns Transaction hash
+   */
+  async sendTransaction(params) {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      await this.callInterceptor({
+        chain: "bitcoin",
+        method: "sendTransaction",
+        fromAddress: this.wallet.address,
+        toAddress: params.toAddress,
+        amount: String(params.amount),
+        symbol: "BTC",
+        network: this.network.type,
+        isNativeToken: true,
+        feeSymbol: "BTC"
+      });
+      console.log("[BitcoinProvider] \u{1F4B8} Starting high-level transaction...");
+      const pinHash = getCredentialManager().getPinHash();
+      if (!pinHash) {
+        throw new BitcoinProviderError(
+          BitcoinErrorCode.INTERNAL_ERROR,
+          "PIN hash not found. Please login again."
+        );
+      }
+      const email = this.getRecoveryEmail();
+      const satoshis = Math.floor(params.amount * 1e8);
+      const api = this.talkenApi || getTalkenApiClient();
+      const result = await api.bitcoin.sendTransaction({
+        toAddress: params.toAddress,
+        amountSats: satoshis.toString(),
+        pin: pinHash,
+        ...email && { email }
+      });
+      console.log(
+        "[BitcoinProvider] \u2705 BTC transaction complete via TalkenApiClient:",
+        result.txHash
+      );
+      this.emit("transactionBroadcasted", {
+        txHash: result.txHash,
+        explorerUrl: `${this.network.explorer}/tx/${result.txHash}`
+      });
+      this.clearUtxoCache();
+      return result.txHash;
+    } catch (error) {
+      if (error.message?.includes("cancelled") || error.message?.includes("rejected")) {
+        console.log("[BitcoinProvider] \u2139\uFE0F User cancelled transaction");
+        throw new BitcoinProviderError(
+          BitcoinErrorCode.USER_REJECTED,
+          "User rejected transaction",
+          error
+        );
+      }
+      console.error("[BitcoinProvider] \u274C Transaction failed:", error.message);
+      if (error.message?.includes("insufficient")) {
+        throw new BitcoinProviderError(
+          BitcoinErrorCode.INSUFFICIENT_FUNDS,
+          "Insufficient BTC balance",
+          error
+        );
+      }
+      this.emit("error", error);
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INTERNAL_ERROR,
+        "Failed to send transaction",
+        error
+      );
+    }
+  }
+  /**
+   * Broadcast signed transaction to network
+   *
+   * @param rawTransaction - Raw transaction in hex format
+   * @param psbt - Optional finalized PSBT
+   * @returns Transaction hash
+   */
+  async broadcastTransaction(rawTransaction, psbt) {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      console.log("[BitcoinProvider] \u{1F4E1} Broadcasting transaction...");
+      if (psbt) {
+        console.log(
+          "[BitcoinProvider] \u2139\uFE0F PSBT argument provided; raw tx broadcast uses rawTransaction only via talken-api"
+        );
+      }
+      const api = this.talkenApi || getTalkenApiClient();
+      const result = await api.bitcoin.broadcastRawTransaction({
+        network: this.network.type,
+        rawTransaction
+      });
+      console.log(
+        "[BitcoinProvider] \u2705 Transaction broadcasted:",
+        result.txHash
+      );
+      this.emit("transactionBroadcasted", {
+        txHash: result.txHash,
+        explorerUrl: `${this.network.explorer}/tx/${result.txHash}`
+      });
+      this.clearUtxoCache();
+      return result.txHash;
+    } catch (error) {
+      console.error(
+        "[BitcoinProvider] \u274C Transaction broadcast failed:",
+        error.message
+      );
+      this.emit("error", error);
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INTERNAL_ERROR,
+        "Failed to broadcast transaction",
+        error
+      );
+    }
+  }
+  /**
+   * Get wallet info
+   */
+  getWalletInfo() {
+    if (!this.wallet)
+      return null;
+    return {
+      address: this.wallet.address,
+      publicKey: this.wallet.publicKey,
+      addressType: this.wallet.addressType,
+      network: this.network.type
+    };
+  }
+  /**
+   * Refresh UTXO cache
+   */
+  async refreshUtxos() {
+    return this.getUtxos(true);
+  }
+};
+
+export {
+  BitcoinProviderError,
+  BITCOIN_NETWORKS,
+  AbcBitcoinProvider
+};