@talken/talkenkit 2.4.22 → 2.4.24

package/dist/wallets/walletConnectors/chunk-4LIJB776.js

@@ -0,0 +1,273 @@
+"use client";
+import {
+  loadAuthState,
+  saveAuthState
+} from "./chunk-UAV4SI4Y.js";
+
+// src/wallets/walletConnectors/abcWallet/abcBitcoinConnector.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var AbcBitcoinConnector = class {
+  constructor(config) {
+    this.wallet = null;
+    this.connected = false;
+    // Event listeners
+    this.connectListeners = /* @__PURE__ */ new Set();
+    this.disconnectListeners = /* @__PURE__ */ new Set();
+    this.accountsChangedListeners = /* @__PURE__ */ new Set();
+    this.networkChangedListeners = /* @__PURE__ */ new Set();
+    this.provider = config.provider;
+    this.setupProviderListeners();
+  }
+  /**
+   * Setup provider event listeners
+   */
+  setupProviderListeners() {
+    this.provider.on("connect", () => {
+      this.connected = true;
+      if (this.wallet) {
+        for (const listener of this.connectListeners) {
+          listener(this.wallet);
+        }
+      }
+    });
+    this.provider.on("disconnect", () => {
+      this.connected = false;
+      this.wallet = null;
+      for (const listener of this.disconnectListeners) {
+        listener();
+      }
+    });
+    this.provider.on("accountsChanged", (accounts) => {
+      for (const listener of this.accountsChangedListeners) {
+        listener(accounts);
+      }
+    });
+    this.provider.on("networkChanged", (network) => {
+      for (const listener of this.networkChangedListeners) {
+        listener(network);
+      }
+    });
+  }
+  /**
+   * Connect Bitcoin wallet
+   */
+  async connect() {
+    try {
+      const authState = loadAuthState();
+      console.log("[BitcoinConnector] \u{1F527} connect() called:", {
+        hasAuthState: !!authState,
+        isAuthenticated: authState?.isAuthenticated,
+        hasBitcoinWallet: !!authState?.bitcoinWallet,
+        bitcoinAddress: authState?.bitcoinWallet?.address
+      });
+      if (!authState || !authState.isAuthenticated || !authState.bitcoinWallet) {
+        throw new Error("BITCOIN_LOGIN_REQUIRED");
+      }
+      this.wallet = authState.bitcoinWallet;
+      this.provider.setWallet(authState.bitcoinWallet);
+      console.log("[BitcoinConnector] \u2705 Wallet set:", {
+        address: authState.bitcoinWallet.address,
+        publicKey: authState.bitcoinWallet.publicKey,
+        addressType: authState.bitcoinWallet.addressType,
+        network: authState.bitcoinWallet.network
+      });
+      this.connected = true;
+      return {
+        address: authState.bitcoinWallet.address,
+        publicKey: authState.bitcoinWallet.publicKey,
+        network: authState.bitcoinWallet.network
+      };
+    } catch (error) {
+      if (error.message === "BITCOIN_LOGIN_REQUIRED") {
+        throw error;
+      }
+      console.error("[BitcoinConnector] \u274C connect error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Disconnect Bitcoin wallet
+   */
+  async disconnect() {
+    try {
+      this.provider.clearWallet();
+      this.wallet = null;
+      this.connected = false;
+      console.log("[BitcoinConnector] \u2705 Wallet disconnected");
+    } catch (error) {
+      console.error("[BitcoinConnector] \u274C disconnect error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get Bitcoin address
+   */
+  async getAddress() {
+    return this.provider.getAddress();
+  }
+  /**
+   * Get compressed public key (33 bytes)
+   */
+  async getPublicKey() {
+    return this.provider.getPublicKey();
+  }
+  /**
+   * Get address type (bech32, p2pkh, etc.)
+   */
+  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)
+   */
+  async isAuthorized() {
+    try {
+      const authState = loadAuthState();
+      if (!authState || !authState.isAuthenticated) {
+        return false;
+      }
+      if (!authState.bitcoinWallet) {
+        return false;
+      }
+      const api = getTalkenApiClient();
+      return !!api && !api.isTokenExpired();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected && this.provider.isConnected();
+  }
+  /**
+   * Get current wallet
+   */
+  getWallet() {
+    return this.wallet;
+  }
+  /**
+   * Get provider
+   */
+  getProvider() {
+    return this.provider;
+  }
+  /**
+   * Get wallet info
+   */
+  getWalletInfo() {
+    return this.provider.getWalletInfo();
+  }
+  /**
+   * Switch network
+   */
+  async switchNetwork(network) {
+    this.provider.setNetwork(network);
+    const authState = loadAuthState();
+    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().type;
+  }
+  /**
+   * Refresh UTXO cache
+   */
+  async refreshUtxos() {
+    return this.provider.refreshUtxos();
+  }
+  on(event, listener) {
+    switch (event) {
+      case "connect":
+        this.connectListeners.add(listener);
+        break;
+      case "disconnect":
+        this.disconnectListeners.add(listener);
+        break;
+      case "accountsChanged":
+        this.accountsChangedListeners.add(listener);
+        break;
+      case "networkChanged":
+        this.networkChangedListeners.add(listener);
+        break;
+    }
+  }
+  off(event, listener) {
+    switch (event) {
+      case "connect":
+        this.connectListeners.delete(listener);
+        break;
+      case "disconnect":
+        this.disconnectListeners.delete(listener);
+        break;
+      case "accountsChanged":
+        this.accountsChangedListeners.delete(listener);
+        break;
+      case "networkChanged":
+        this.networkChangedListeners.delete(listener);
+        break;
+    }
+  }
+  /**
+   * Remove all listeners
+   */
+  removeAllListeners() {
+    this.connectListeners.clear();
+    this.disconnectListeners.clear();
+    this.accountsChangedListeners.clear();
+    this.networkChangedListeners.clear();
+  }
+};
+function createAbcBitcoinConnector(config) {
+  return new AbcBitcoinConnector(config);
+}
+
+export {
+  AbcBitcoinConnector,
+  createAbcBitcoinConnector
+};

package/dist/wallets/walletConnectors/chunk-4P3SPC44.js

@@ -0,0 +1,51 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/types.ts
+var AbcStorageKey = /* @__PURE__ */ ((AbcStorageKey2) => {
+  AbcStorageKey2["USER"] = "user";
+  AbcStorageKey2["WALLET"] = "wallet";
+  AbcStorageKey2["SOLANA_WALLET"] = "solana_wallet";
+  AbcStorageKey2["BITCOIN_WALLET"] = "bitcoin_wallet";
+  AbcStorageKey2["TRON_WALLET"] = "tron_wallet";
+  AbcStorageKey2["ACCESS_TOKEN"] = "access_token";
+  AbcStorageKey2["REFRESH_TOKEN"] = "refresh_token";
+  AbcStorageKey2["EXPIRES_AT"] = "expires_at";
+  AbcStorageKey2["AUTH_STATE"] = "auth_state";
+  return AbcStorageKey2;
+})(AbcStorageKey || {});
+var AbcErrorCode = /* @__PURE__ */ ((AbcErrorCode2) => {
+  AbcErrorCode2["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
+  AbcErrorCode2["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+  AbcErrorCode2["WALLET_NOT_FOUND"] = "WALLET_NOT_FOUND";
+  AbcErrorCode2["INVALID_PIN"] = "INVALID_PIN";
+  AbcErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  AbcErrorCode2["SIGNATURE_FAILED"] = "SIGNATURE_FAILED";
+  AbcErrorCode2["USER_CANCELLED"] = "USER_CANCELLED";
+  AbcErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return AbcErrorCode2;
+})(AbcErrorCode || {});
+var AbcError = class extends Error {
+  constructor(code, message, details, statusCode) {
+    super(message);
+    this.name = "AbcError";
+    this.code = code;
+    this.details = details;
+    this.statusCode = statusCode;
+  }
+};
+var TalkenApiError = class extends Error {
+  constructor(code, message, statusCode, details) {
+    super(message);
+    this.name = "TalkenApiError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+};
+
+export {
+  AbcStorageKey,
+  AbcErrorCode,
+  AbcError,
+  TalkenApiError
+};