@talken/talkenkit 2.3.7 → 2.3.9

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

@@ -0,0 +1,646 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-IOLHAU7H.js";
+import {
+  createAbcError
+} from "./chunk-W23N7VC4.js";
+import {
+  DEFAULT_HEADERS
+} from "./chunk-VETRBBA2.js";
+import {
+  AbcErrorCode
+} from "./chunk-5UEBEMEE.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] \u{1F527} 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] \u274C 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
+    );
+    console.log("[BitcoinApi] \u2705 Bitcoin wallet generated:", addressResult);
+    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] \u{1F527} 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] \u274C 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
+    );
+    console.log("[BitcoinApi] \u2705 Bitcoin wallet recovered:", addressResult);
+    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
+   * Converts compressed public key to Bitcoin address based on address type
+   *
+   * @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
+   * Bitcoin uses UTXO model unlike EVM/Solana account model
+   *
+   * @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 });
+    console.log("[BitcoinApi] \u{1F50D} Fetching UTXOs for:", 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
+      );
+    }
+    const utxos = data.result?.utxos || [];
+    console.log(`[BitcoinApi] \u2705 Found ${utxos.length} UTXOs`);
+    return utxos;
+  }
+  /**
+   * Sign Bitcoin transaction (PSBT-based)
+   * @deprecated Bitcoin uses v2 API. Use sendTransaction() which uses the v2 flow (generate → signHash → finalize)
+   * This v3 API method is for Solana only
+   *
+   * @param params - Transaction signing parameters
+   * @returns Signed PSBT with multiple input signatures
+   */
+  async signBitcoinTransaction(params) {
+    console.warn("[BitcoinApi] \u26A0\uFE0F signBitcoinTransaction is deprecated. Bitcoin uses v2 API. Use sendTransaction() instead.");
+    const url = `${this.baseURL}/v3/wallet/sign`;
+    console.log("[BitcoinApi] \u{1F510} Signing Bitcoin transaction (PSBT)...");
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        uid: params.uid,
+        share_id: params.shareId,
+        message: params.psbt,
+        // PSBT in base64
+        password: params.pin,
+        network: params.network
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
+      console.error("[BitcoinApi] \u274C Transaction signing failed:", data);
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Bitcoin transaction",
+        data
+      );
+    }
+    console.log("[BitcoinApi] \u2705 Transaction signed successfully");
+    return {
+      signedPsbt: data.result?.signedPsbt,
+      signatures: data.result?.signatures || []
+    };
+  }
+  /**
+   * Sign Bitcoin message (BIP-322)
+   * @deprecated Not supported - v3 API is Solana-only. Bitcoin uses v2 API which doesn't support message signing.
+   * Bitcoin only supports transaction signing via v2 API.
+   *
+   * @param params - Message signing parameters
+   * @returns BIP-322 signature
+   */
+  async signBitcoinMessage(params) {
+    console.warn("[BitcoinApi] \u26A0\uFE0F signBitcoinMessage is not supported. v3 API is Solana-only.");
+    throw createAbcError(
+      AbcErrorCode.UNSUPPORTED_METHOD,
+      "Bitcoin message signing not supported - v3 API is Solana-only"
+    );
+    const url = `${this.baseURL}/v3/wallet/sign`;
+    console.log("[BitcoinApi] \u{1F510} Signing Bitcoin message (BIP-322)...");
+    console.log("[BitcoinApi] \u{1F4E4} Request params:", {
+      uid: params.uid,
+      shareId: params.shareId,
+      keyId: params.keyId,
+      hasKeyId: !!params.keyId,
+      messageLength: params.message?.length,
+      network: params.network
+    });
+    const requestBody = {
+      uid: params.uid,
+      share_id: params.shareId,
+      key_id: params.keyId,
+      message: params.message,
+      // Hex-encoded message
+      password: params.pin,
+      messageType: params.messageType || "bip322",
+      network: params.network
+    };
+    console.log("[BitcoinApi] \u{1F4CB} Request body:", JSON.stringify(requestBody, null, 2));
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify(requestBody)
+    });
+    const responseText = await response.text();
+    console.log("[BitcoinApi] \u{1F4E5} Sign message raw response:", {
+      status: response.status,
+      statusText: response.statusText,
+      contentType: response.headers.get("content-type"),
+      text: responseText.substring(0, 500)
+    });
+    if (!responseText) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Empty response from sign message API",
+        { status: response.status }
+      );
+    }
+    let data;
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseError) {
+      console.error("[BitcoinApi] \u274C JSON parse error:", parseError);
+      console.error("[BitcoinApi] \u{1F4C4} Full response text:", responseText);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        `Server returned non-JSON response: ${responseText}`,
+        { responseText, parseError, status: response.status }
+      );
+    }
+    if (!response.ok || data.status !== "success") {
+      console.error("[BitcoinApi] \u274C Message signing failed:", data);
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        data.error || data.message || "Failed to sign Bitcoin message",
+        data
+      );
+    }
+    console.log("[BitcoinApi] \u2705 Message signed successfully");
+    return {
+      signature: data.result?.signature,
+      messageHash: data.result?.messageHash,
+      address: data.result?.address,
+      network: params.network
+    };
+  }
+  /**
+   * Send Bitcoin transaction
+   * Broadcasts signed transaction to Bitcoin network
+   *
+   * @param params - Transaction broadcast parameters
+   * @returns Transaction hash
+   */
+  async sendBitcoinTransaction(params) {
+    const url = `${this.baseURL}/wapi/v2/bitcoin/tx/sendTransaction`;
+    console.log("[BitcoinApi] \u{1F4E1} Broadcasting Bitcoin transaction...");
+    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") {
+      console.error("[BitcoinApi] \u274C Transaction broadcast failed:", data);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to send Bitcoin transaction",
+        data
+      );
+    }
+    const txHash = data.result?.data;
+    console.log("[BitcoinApi] \u2705 Transaction broadcasted:", txHash);
+    return {
+      txHash
+    };
+  }
+  /**
+   * Generate Bitcoin transaction (Step 1 of 3)
+   * Creates PSBT and returns hashes to sign
+   *
+   * @param params - Transaction parameters
+   * @returns Transaction data with hashes to sign
+   */
+  async generateTransaction(params) {
+    const url = `${this.baseURL}/wapi/v2/btc/transaction/generate`;
+    console.log("[BitcoinApi] \u{1F527} Generating transaction...", params);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify(params)
+    });
+    const data = await response.json();
+    if (!response.ok || !data.hashes) {
+      const errorMsg = typeof data.error === "string" ? data.error : JSON.stringify(data.error || data);
+      console.error("[BitcoinApi] \u274C Generate failed:", errorMsg);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        `Failed to generate transaction: ${errorMsg}`,
+        data
+      );
+    }
+    console.log(
+      `[BitcoinApi] \u2705 Generated ${data.hashes.length} hashes to sign`
+    );
+    return data;
+  }
+  /**
+   * Sign transaction hash (Step 2 of 3)
+   * Uses Secure Channel encryption for signing
+   * Based on tg-wallet-frontend reference implementation
+   *
+   * @param hash - Transaction hash to sign
+   * @param wallet - Full wallet object with Bitcoin signing fields
+   * @param pinHash - Hashed PIN for device password
+   * @param secureService - Secure service instance for encryption
+   * @returns Signature hex string (r + s without 0x prefix on s)
+   */
+  async signHash(hash, wallet, pinHash, secureService) {
+    console.log("[BitcoinApi] \u{1F510} Signing hash:", `${hash.substring(0, 20)}...`);
+    if (!wallet.wid || !wallet.pvencstr) {
+      console.error("[BitcoinApi] \u274C Missing Bitcoin signing fields:", {
+        hasWid: !!wallet.wid,
+        hasPvencstr: !!wallet.pvencstr,
+        hasSid: !!wallet.sid,
+        hasUid: !!wallet.uid
+      });
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Wallet missing required fields for Bitcoin signing (wid, pvencstr)",
+        { hasWid: !!wallet.wid, hasPvencstr: !!wallet.pvencstr }
+      );
+    }
+    console.log("[BitcoinApi] \u2705 Wallet fields validated for Bitcoin signing");
+    console.log("[BitcoinApi] \u{1F4CB} Wallet PLAINTEXT values:", {
+      hasWid: !!wallet.wid,
+      widLength: wallet.wid?.length,
+      hasPvencstr: !!wallet.pvencstr,
+      pvencstrLength: wallet.pvencstr?.length,
+      hasEncryptDevicePassword: !!wallet.encryptDevicePassword,
+      encryptDevicePasswordLength: wallet.encryptDevicePassword?.length
+    });
+    const encryptDevicePassword = await secureService.getEncryptPlain(
+      wallet.encryptDevicePassword || pinHash
+    );
+    const pvencstr = await secureService.getEncryptPlain(wallet.pvencstr);
+    const wid = await secureService.getEncryptPlain(wallet.wid);
+    const secureChannelId = await secureService.getSecureChannelId();
+    console.log("[BitcoinApi] \u{1F510} Encrypted values:", {
+      encryptDevicePasswordLength: encryptDevicePassword.length,
+      pvencstrLength: pvencstr.length,
+      widLength: wid.length,
+      secureChannelId
+    });
+    const params = new URLSearchParams({
+      uid: wallet.uid,
+      sid: wallet.sid || "",
+      // Handle optional sid
+      hash,
+      pvencstr,
+      wid,
+      encryptDevicePassword
+    });
+    console.log("[BitcoinApi] \u{1F4E4} Request params:", {
+      uid: wallet.uid,
+      sid: wallet.sid || "",
+      hashLength: hash.length,
+      bodyLength: params.toString().length
+    });
+    const url = `${this.baseURL}/wapi/v2/sign/hash`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Secure-Channel": secureChannelId,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: params.toString()
+    });
+    const responseText = await response.text();
+    console.log("[BitcoinApi] \u{1F4E5} Raw response:", {
+      status: response.status,
+      statusText: response.statusText,
+      text: responseText.substring(0, 200)
+    });
+    if (!responseText) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Empty response from sign hash API",
+        { status: response.status }
+      );
+    }
+    let data;
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseError) {
+      console.error("[BitcoinApi] \u274C JSON parse error:", parseError);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Invalid JSON response from sign hash API",
+        { responseText, parseError }
+      );
+    }
+    if (!response.ok || data.iserr === true || !data.signstr) {
+      const errorDetails = data.errmsg || data.errors?.[0] || data.message || data;
+      console.error("[BitcoinApi] \u274C Sign failed:", errorDetails);
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        `Failed to sign hash: ${JSON.stringify(errorDetails)}`,
+        data
+      );
+    }
+    console.log("[BitcoinApi] \u2705 Sign successful, parsing signature...");
+    const signstr = JSON.parse(data.signstr);
+    const sig_list = signstr.sig_list;
+    const signatures = [];
+    for (const sig of sig_list) {
+      const r = sig.r;
+      const s = sig.s.startsWith("0x") ? sig.s.substring(2) : sig.s;
+      const combinedSig = r + s;
+      signatures.push(combinedSig);
+    }
+    console.log(
+      "[BitcoinApi] \u2705 Signature generated:",
+      `${signatures[0].substring(0, 32)}...`
+    );
+    return signatures[0];
+  }
+  /**
+   * Finalize and broadcast transaction (Step 3 of 3)
+   * Broadcasts signed transaction to Bitcoin network
+   *
+   * @param params - Transaction parameters with signatures
+   * @returns Transaction hash
+   */
+  async finalizeTransaction(params) {
+    const url = `${this.baseURL}/wapi/v2/btc/transaction/finalize`;
+    console.log("[BitcoinApi] \u{1F4E1} Broadcasting transaction...");
+    console.log("[BitcoinApi] \u{1F4E4} Finalize params:", {
+      signatureCount: params.signatureHex.length,
+      amount: params.amount,
+      to: params.to,
+      pubkey: `${params.pubkey.substring(0, 20)}...`
+    });
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify(params)
+    });
+    const responseText = await response.text();
+    console.log("[BitcoinApi] \u{1F4E5} Finalize raw response:", {
+      status: response.status,
+      statusText: response.statusText,
+      text: responseText.substring(0, 200)
+    });
+    if (!responseText) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Empty response from finalize API",
+        { status: response.status }
+      );
+    }
+    let data;
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseError) {
+      console.error("[BitcoinApi] \u274C JSON parse error:", parseError);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Invalid JSON response from finalize API",
+        { responseText, parseError }
+      );
+    }
+    console.log("[BitcoinApi] \u{1F4CB} Finalize parsed data:", data);
+    if (!response.ok) {
+      const errorMsg = data.error || data.message || data.errmsg || "Unknown error";
+      console.error("[BitcoinApi] \u274C Finalize failed:", errorMsg);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        `Failed to finalize transaction: ${errorMsg}`,
+        data
+      );
+    }
+    const txHash = data.result?.tx_hash || data.tx_hash || data.result?.txHash || data.txHash;
+    if (!txHash) {
+      console.error("[BitcoinApi] \u274C No tx_hash in response:", data);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Transaction hash not found in response",
+        data
+      );
+    }
+    console.log("[BitcoinApi] \u2705 Transaction sent:", txHash);
+    return txHash;
+  }
+  /**
+   * Send Bitcoin transaction (Complete flow: generate → sign → finalize)
+   * High-level API that handles all 3 steps
+   *
+   * @param params - Transaction parameters
+   * @param wallet - EVM wallet credentials
+   * @param pinHash - Hashed PIN
+   * @param secureService - Secure service instance
+   * @returns Transaction hash
+   */
+  async sendTransaction(params, wallet, pinHash, secureService) {
+    console.log("[BitcoinApi] \u{1F4B8} Starting Bitcoin transaction flow...");
+    const generateData = await this.generateTransaction({
+      amount: params.amount,
+      pubkey: params.pubkey,
+      to: params.to,
+      feeRate: "2"
+      // Default fee rate
+    });
+    const { hashes, fee_rate } = generateData;
+    const signatureHex = [];
+    for (let i = 0; i < hashes.length; i++) {
+      const signature = await this.signHash(
+        hashes[i],
+        wallet,
+        pinHash,
+        secureService
+      );
+      signatureHex.push(signature);
+    }
+    const txHash = await this.finalizeTransaction({
+      network: params.network,
+      signatureHex,
+      feeRate: fee_rate,
+      amount: params.amount,
+      pubkey: params.pubkey,
+      to: params.to
+    });
+    console.log("[BitcoinApi] \u2705 Transaction complete:", txHash);
+    return txHash;
+  }
+  /**
+   * Estimate Bitcoin transaction fee
+   * Gets recommended fee rate (satoshis per byte) for target confirmation blocks
+   *
+   * @param network - Bitcoin network
+   * @param targetBlocks - Target confirmation blocks (default: 6)
+   * @returns Fee rate in satoshis per byte
+   */
+  async estimateFee(network, targetBlocks = 6) {
+    const url = `${this.baseURL}/wapi/v2/bitcoin/fee/estimate`;
+    const params = new URLSearchParams({
+      network,
+      targetBlocks: targetBlocks.toString()
+    });
+    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") {
+      console.warn("[BitcoinApi] \u26A0\uFE0F Fee estimation failed, using fallback");
+      return 1;
+    }
+    const feeRate = data.result?.feeRate || 1;
+    console.log(`[BitcoinApi] \u26FD Estimated fee rate: ${feeRate} sat/byte`);
+    return feeRate;
+  }
+};
+
+export {
+  BitcoinApi
+};

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

@@ -0,0 +1,44 @@
+"use client";
+import {
+  abcConnector
+} from "./chunk-BKXPGZMQ.js";
+import {
+  ABC_WALLET_METADATA
+} from "./chunk-VETRBBA2.js";
+
+// src/wallets/walletConnectors/abcWallet/abcWallet.ts
+var abcWallet = (specificOptions) => ({ projectId }) => {
+  const waasUrl = specificOptions?.waasUrl || process.env.NEXT_PUBLIC_ABC_WAAS_URL || process.env.VITE_ABC_WAAS_URL;
+  if (!waasUrl) {
+    throw new Error(
+      'ABC WaaS URL is required. Please provide it via:\n1. abcWallet({ waasUrl: "..." }) options, or\n2. NEXT_PUBLIC_ABC_WAAS_URL environment variable, or\n3. VITE_ABC_WAAS_URL environment variable'
+    );
+  }
+  const config = {
+    waasUrl,
+    apiKey: specificOptions?.apiKey,
+    plain: specificOptions?.plain || "",
+    // Deprecated - not used (secure.ts uses random generation)
+    environment: specificOptions?.environment || "development",
+    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
+};