@talken/talkenkit 2.3.15 → 2.4.5

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

@@ -0,0 +1,226 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-LQ2U33WM.js";
+import {
+  getSolanaNetwork
+} from "./chunk-A7FIBI6X.js";
+import {
+  createAbcError
+} from "./chunk-TYUEB4VT.js";
+
+// src/wallets/walletConnectors/abcWallet/api/SolanaApi.ts
+import { PublicKey } from "@solana/web3.js";
+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 network = getSolanaNetwork();
+    const response = await this.request(endpoint, {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        password: pin,
+        network
+      }
+    });
+    let result;
+    if (response.status === "success" && response.result) {
+      result = response.result;
+    } else if (response.encrypted_share && response.key_id) {
+      result = response;
+    } else {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        `Failed to ${isRecover ? "recover" : "generate"} Solana wallet`,
+        response
+      );
+    }
+    let address;
+    try {
+      address = this.deriveAddressFromPublicKey(result.public_key);
+    } catch (_error) {
+      address = result.public_key.startsWith("0x") ? result.public_key.slice(2) : result.public_key;
+    }
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address,
+      keyId: result.key_id || result.share_id,
+      // API returns snake_case key_id
+      encryptedShare: result.encrypted_share || "",
+      // API returns snake_case encrypted_share
+      secretStore: result.secret_store || "",
+      // API returns snake_case secret_store
+      network
+      // Use network from request (already has correct value)
+    };
+  }
+  /**
+   * 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
+   * @param publicKey - Ed25519 public key (hex)
+   * @returns Solana address (base58)
+   */
+  deriveAddressFromPublicKey(publicKey) {
+    const cleanKey = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+    const bytes = new Uint8Array(
+      cleanKey.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    try {
+      const pubkey = new PublicKey(bytes);
+      return pubkey.toBase58();
+    } catch (error) {
+      console.error("[SolanaApi] Failed to encode address:", error);
+      return cleanKey;
+    }
+  }
+  /**
+   * Sign Solana transaction with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
+   */
+  async signSolanaTransaction(params) {
+    const network = getSolanaNetwork();
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        network,
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
+      }
+    });
+    let signature;
+    if (response.status === "success" && response.result?.signature) {
+      signature = response.result.signature;
+    } else if (response.signature) {
+      signature = response.signature;
+    } else {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana transaction",
+        response
+      );
+    }
+    return {
+      signature
+    };
+  }
+  /**
+   * Sign Solana message with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
+   */
+  async signSolanaMessage(params) {
+    const network = getSolanaNetwork();
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        network,
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
+      }
+    });
+    let signature;
+    if (response.status === "success" && response.result?.signature) {
+      signature = response.result.signature;
+    } else if (response.signature) {
+      signature = response.signature;
+    } else {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana message",
+        response
+      );
+    }
+    return {
+      signature
+    };
+  }
+  /**
+   * Generate Solana transfer transaction via ABC WaaS API
+   * This ensures the transaction uses the same RPC and blockhash as the server
+   */
+  async generateTransferTransaction(params) {
+    const response = await this.request(
+      "/wapi/v2/solana/tx/generateTransferSOLTransaction",
+      {
+        method: "POST",
+        contentType: "json",
+        body: {
+          network: params.network,
+          amount: params.amount,
+          fromAddress: params.fromAddress,
+          toAddress: params.toAddress,
+          feePayerAddress: params.feePayerAddress
+        }
+      }
+    );
+    const responseData = response;
+    const serializedTx = responseData.data?.serialized_tx || response.status === "success" && response.result?.data?.serialized_tx;
+    if (!serializedTx) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to generate Solana transaction",
+        response
+      );
+    }
+    return {
+      serialized_tx: serializedTx
+    };
+  }
+  /**
+   * 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
+      }
+    });
+    const responseData = response;
+    const txHash = responseData.data || response.status === "success" && response.result?.data;
+    if (!txHash || typeof txHash !== "string") {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to send Solana transaction",
+        response
+      );
+    }
+    return {
+      txHash
+    };
+  }
+};
+
+export {
+  SolanaApi
+};

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

@@ -0,0 +1,63 @@
+"use client";
+import {
+  BitcoinApi
+} from "./chunk-M7KXDTM6.js";
+import {
+  SigningApi
+} from "./chunk-HTD7IRKM.js";
+import {
+  TransactionApi
+} from "./chunk-HFC4AK72.js";
+import {
+  AuthApi
+} from "./chunk-ZQLQELFC.js";
+import {
+  WalletApi
+} from "./chunk-MKAXMNZM.js";
+import {
+  SolanaApi
+} from "./chunk-JQ57SCY6.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-RY4RAB3D.js → chunk-YCZ4CZQ6.js}

@@ -2,10 +2,10 @@
 import {
   loadAuthState,
   saveAuthState
-} from "./chunk-UV5HHESJ.js";
+} from "./chunk-TYUEB4VT.js";
 
-// src/wallets/walletConnectors/abcWallet/abcSolanaConnector.ts
-var AbcSolanaConnector = class {
+// src/wallets/walletConnectors/abcWallet/abcBitcoinConnector.ts
+var AbcBitcoinConnector = class {
   constructor(config) {
     this.wallet = null;
     this.connected = false;
@@ -13,6 +13,7 @@ var AbcSolanaConnector = class {
     this.connectListeners = /* @__PURE__ */ new Set();
     this.disconnectListeners = /* @__PURE__ */ new Set();
     this.accountsChangedListeners = /* @__PURE__ */ new Set();
+    this.networkChangedListeners = /* @__PURE__ */ new Set();
     this.client = config.client;
     this.provider = config.provider;
     this.setupProviderListeners();
@@ -41,78 +42,126 @@ var AbcSolanaConnector = class {
         listener(accounts);
       }
     });
+    this.provider.on("networkChanged", (network) => {
+      for (const listener of this.networkChangedListeners) {
+        listener(network);
+      }
+    });
   }
   /**
-   * Connect Solana wallet
+   * Connect Bitcoin wallet
    */
   async connect() {
     try {
       const authState = loadAuthState();
-      console.log("\u{1F527} Solana Connector connect() called:", {
+      console.log("[BitcoinConnector] \u{1F527} connect() called:", {
         hasAuthState: !!authState,
         isAuthenticated: authState?.isAuthenticated,
-        hasSolanaWallet: !!authState?.solanaWallet,
-        solanaAddress: authState?.solanaWallet?.address
+        hasBitcoinWallet: !!authState?.bitcoinWallet,
+        bitcoinAddress: authState?.bitcoinWallet?.address
       });
-      if (!authState || !authState.isAuthenticated || !authState.solanaWallet) {
-        throw new Error("SOLANA_LOGIN_REQUIRED");
+      if (!authState || !authState.isAuthenticated || !authState.bitcoinWallet) {
+        throw new Error("BITCOIN_LOGIN_REQUIRED");
       }
-      this.wallet = authState.solanaWallet;
-      this.provider.setWallet(authState.solanaWallet);
+      this.wallet = authState.bitcoinWallet;
+      this.provider.setWallet(authState.bitcoinWallet);
       this.provider.setRequestPinCallback(async () => {
         if (!authState.pin) {
-          console.error("\u274C PIN not available in authState");
+          console.error("[BitcoinConnector] \u274C PIN not available in authState");
           throw new Error("PIN not available");
         }
         return authState.pin;
       });
-      console.log("\u2705 Solana Provider wallet and PIN callback set:", {
-        address: authState.solanaWallet.address,
-        publicKey: authState.solanaWallet.publicKey,
+      console.log("[BitcoinConnector] \u2705 Wallet and PIN callback set:", {
+        address: authState.bitcoinWallet.address,
+        publicKey: authState.bitcoinWallet.publicKey,
+        addressType: authState.bitcoinWallet.addressType,
+        network: authState.bitcoinWallet.network,
         hasPIN: !!authState.pin
       });
-      const result = await this.provider.connect();
       this.connected = true;
-      return result;
+      return {
+        address: authState.bitcoinWallet.address,
+        publicKey: authState.bitcoinWallet.publicKey,
+        network: authState.bitcoinWallet.network
+      };
     } catch (error) {
-      if (error.message === "SOLANA_LOGIN_REQUIRED") {
+      if (error.message === "BITCOIN_LOGIN_REQUIRED") {
         throw error;
       }
-      console.error("Solana connector connect error:", error);
+      console.error("[BitcoinConnector] \u274C connect error:", error);
       throw error;
     }
   }
   /**
-   * Disconnect Solana wallet
+   * Disconnect Bitcoin wallet
    */
   async disconnect() {
     try {
-      await this.provider.disconnect();
+      this.provider.clearWallet();
       this.wallet = null;
       this.connected = false;
-      console.log("\u2705 Solana wallet disconnected");
+      console.log("[BitcoinConnector] \u2705 Wallet disconnected");
     } catch (error) {
-      console.error("Solana connector disconnect error:", error);
+      console.error("[BitcoinConnector] \u274C disconnect error:", error);
       throw error;
     }
   }
   /**
-   * Get accounts
+   * Get Bitcoin address
    */
-  async getAccounts() {
-    return this.provider.getAccounts();
+  async getAddress() {
+    return this.provider.getAddress();
   }
   /**
-   * Get public key
+   * Get compressed public key (33 bytes)
    */
-  getPublicKey() {
+  async getPublicKey() {
     return this.provider.getPublicKey();
   }
   /**
-   * Get address
+   * Get address type (bech32, p2pkh, etc.)
    */
-  getAddress() {
-    return this.provider.getAddress();
+  getAddressType() {
+    return this.provider.getAddressType();
+  }
+  /**
+   * Get UTXOs
+   */
+  async getUtxos(forceRefresh = false) {
+    return this.provider.getUtxos(forceRefresh);
+  }
+  /**
+   * Get balance (in satoshis)
+   */
+  async getBalance(forceRefresh = false) {
+    return this.provider.getBalance(forceRefresh);
+  }
+  /**
+   * Estimate transaction fee
+   */
+  async estimateFee(targetBlocks = 6) {
+    return this.provider.estimateFee(targetBlocks);
+  }
+  /**
+   * Sign Bitcoin message (BIP-322)
+   * NOTE: Currently not supported - Bitcoin uses v2 API which doesn't have message signing endpoint
+   */
+  async signMessage(message) {
+    return this.provider.signMessage(message);
+  }
+  /**
+   * Send Bitcoin transaction (high-level API)
+   * Creates, signs, and broadcasts transaction
+   */
+  async sendTransaction(params) {
+    return this.provider.sendTransaction(params);
+  }
+  /**
+   * Broadcast signed transaction to network (low-level API)
+   */
+  async broadcastTransaction(rawTransaction, psbt) {
+    return this.provider.broadcastTransaction(rawTransaction, psbt);
   }
   /**
    * Check if authorized (has valid session)
@@ -123,10 +172,10 @@ var AbcSolanaConnector = class {
       if (!authState || !authState.isAuthenticated) {
         return false;
       }
-      if (!authState.solanaWallet) {
+      if (!authState.bitcoinWallet) {
         return false;
       }
-      return this.client.isAuthenticated();
+      return !this.client.auth.isTokenExpired();
     } catch {
       return false;
     }
@@ -150,34 +199,10 @@ var AbcSolanaConnector = class {
     return this.provider;
   }
   /**
-   * Sign transaction
-   */
-  async signTransaction(transaction) {
-    return this.provider.signTransaction(transaction);
-  }
-  /**
-   * Sign all transactions
+   * Get wallet info
    */
-  async signAllTransactions(transactions) {
-    return this.provider.signAllTransactions(transactions);
-  }
-  /**
-   * Sign message
-   */
-  async signMessage(message) {
-    return this.provider.signMessage(message);
-  }
-  /**
-   * Send transaction
-   */
-  async sendTransaction(transaction) {
-    return this.provider.sendTransaction(transaction);
-  }
-  /**
-   * Sign and send transaction
-   */
-  async signAndSendTransaction(transaction) {
-    return this.provider.signAndSendTransaction(transaction);
+  getWalletInfo() {
+    return this.provider.getWalletInfo();
   }
   /**
    * Switch network
@@ -185,15 +210,23 @@ var AbcSolanaConnector = class {
   async switchNetwork(network) {
     this.provider.setNetwork(network);
     const authState = loadAuthState();
-    if (authState?.solanaWallet) {
+    if (authState?.bitcoinWallet) {
+      authState.bitcoinWallet.network = network === "mainnet" ? "bitcoin" /* Mainnet */ : "bitcoin_testnet" /* Testnet */;
       saveAuthState(authState);
     }
+    console.log("[BitcoinConnector] \u{1F504} Network switched to:", network);
   }
   /**
    * Get current network
    */
   getNetwork() {
-    return this.provider.getNetwork().chainId;
+    return this.provider.getNetwork().type;
+  }
+  /**
+   * Refresh UTXO cache
+   */
+  async refreshUtxos() {
+    return this.provider.refreshUtxos();
   }
   on(event, listener) {
     switch (event) {
@@ -206,6 +239,9 @@ var AbcSolanaConnector = class {
       case "accountsChanged":
         this.accountsChangedListeners.add(listener);
         break;
+      case "networkChanged":
+        this.networkChangedListeners.add(listener);
+        break;
     }
   }
   off(event, listener) {
@@ -219,6 +255,9 @@ var AbcSolanaConnector = class {
       case "accountsChanged":
         this.accountsChangedListeners.delete(listener);
         break;
+      case "networkChanged":
+        this.networkChangedListeners.delete(listener);
+        break;
     }
   }
   /**
@@ -228,13 +267,14 @@ var AbcSolanaConnector = class {
     this.connectListeners.clear();
     this.disconnectListeners.clear();
     this.accountsChangedListeners.clear();
+    this.networkChangedListeners.clear();
   }
 };
-function createAbcSolanaConnector(config) {
-  return new AbcSolanaConnector(config);
+function createAbcBitcoinConnector(config) {
+  return new AbcBitcoinConnector(config);
 }
 
 export {
-  AbcSolanaConnector,
-  createAbcSolanaConnector
+  AbcBitcoinConnector,
+  createAbcBitcoinConnector
 };