@talken/talkenkit 2.4.23 → 2.4.25

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

@@ -0,0 +1,273 @@
+"use client";
+import {
+  loadAuthState,
+  saveAuthState
+} from "./chunk-VIKJNKJZ.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-W2YIRNMB.js

@@ -0,0 +1,300 @@
+"use client";
+import {
+  setTalkenApiClient
+} from "./chunk-R6ZE7JAZ.js";
+import {
+  setGlobalDefaultBitcoinNetwork,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork
+} from "./chunk-O4AU63LK.js";
+import {
+  createAbcEvmProvider
+} from "./chunk-54KVT46V.js";
+import {
+  clearAuthState,
+  clearStorage,
+  loadAuthState,
+  loadFromStorage,
+  saveAuthState
+} from "./chunk-NISMGNEE.js";
+import {
+  resolveTalkenApiUrl
+} from "./chunk-GFWUFYT2.js";
+import {
+  createTalkenApiClient
+} from "./chunk-DULGAYBU.js";
+import {
+  getCredentialManager
+} from "./chunk-QHUBLT7N.js";
+
+// src/wallets/walletConnectors/abcWallet/abcConnector.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+import { createConnector } from "wagmi";
+function abcConnector(options) {
+  const { config } = options;
+  if (config.defaultChainId) {
+    setGlobalDefaultChainId(config.defaultChainId);
+  }
+  if (config.defaultSolanaNetwork) {
+    setGlobalDefaultSolanaNetwork(config.defaultSolanaNetwork);
+  }
+  if (config.defaultBitcoinNetwork) {
+    setGlobalDefaultBitcoinNetwork(config.defaultBitcoinNetwork);
+  }
+  return createConnector((wagmiConfig) => {
+    const talkenApi = getTalkenApiClient() || createTalkenApiClient({
+      baseUrl: resolveTalkenApiUrl(config.talkenApiUrl),
+      environment: config.environment,
+      debug: config.environment === "development",
+      defaultChainId: config.defaultChainId
+    });
+    setTalkenApiClient(talkenApi);
+    const provider = createAbcEvmProvider(talkenApi);
+    let accountsChangedHandler;
+    let chainChangedHandler;
+    let disconnectHandler;
+    return {
+      id: "abc",
+      name: "ABC Wallet",
+      type: "abc",
+      /**
+       * Connect wallet
+       */
+      async connect() {
+        try {
+          const authState = loadAuthState();
+          if (!authState || !authState.isAuthenticated || !authState.wallet) {
+            throw new Error("ABC_LOGIN_REQUIRED");
+          }
+          provider.setWallet(authState.wallet);
+          if (authState.accessToken && authState.refreshToken && authState.expiresAt) {
+            talkenApi.setTokens(
+              authState.accessToken,
+              authState.refreshToken,
+              authState.expiresAt
+            );
+          }
+          const accounts = await provider.request({
+            method: "eth_requestAccounts"
+          });
+          let currentChainId = await provider.request({
+            method: "eth_chainId"
+          });
+          const currentChainIdNumber = Number(currentChainId);
+          const isChainSupported = wagmiConfig.chains.some(
+            (c) => c.id === currentChainIdNumber
+          );
+          if (!isChainSupported && wagmiConfig.chains.length > 0) {
+            const fallbackChainId = wagmiConfig.chains[0].id;
+            await provider.request({
+              method: "wallet_switchEthereumChain",
+              params: [{ chainId: `0x${fallbackChainId.toString(16)}` }]
+            });
+            currentChainId = `0x${fallbackChainId.toString(16)}`;
+            if (authState.wallet) {
+              authState.wallet.chainId = fallbackChainId;
+              saveAuthState(authState);
+            }
+          }
+          if (accountsChangedHandler) {
+            provider.removeListener("accountsChanged", accountsChangedHandler);
+          }
+          accountsChangedHandler = (accounts2) => {
+            wagmiConfig.emitter.emit("change", {
+              accounts: accounts2
+            });
+          };
+          provider.on("accountsChanged", accountsChangedHandler);
+          if (chainChangedHandler) {
+            provider.removeListener("chainChanged", chainChangedHandler);
+          }
+          chainChangedHandler = (chainId) => {
+            wagmiConfig.emitter.emit("change", {
+              chainId: Number(chainId)
+            });
+          };
+          provider.on("chainChanged", chainChangedHandler);
+          if (disconnectHandler) {
+            provider.removeListener("disconnect", disconnectHandler);
+          }
+          disconnectHandler = () => {
+            wagmiConfig.emitter.emit("disconnect");
+            this.onDisconnect();
+          };
+          provider.on("disconnect", disconnectHandler);
+          wagmiConfig.emitter.emit("connect", {
+            accounts,
+            chainId: Number(currentChainId)
+          });
+          return {
+            accounts,
+            chainId: Number(currentChainId)
+          };
+        } catch (error) {
+          console.error("\u274C ABC Connector connect() failed:", {
+            message: error.message,
+            code: error.code,
+            error
+          });
+          if (error.message === "ABC_LOGIN_REQUIRED") {
+            throw error;
+          }
+          throw error;
+        }
+      },
+      /**
+       * Disconnect wallet
+       */
+      async disconnect() {
+        if (accountsChangedHandler) {
+          provider.removeListener("accountsChanged", accountsChangedHandler);
+          accountsChangedHandler = void 0;
+        }
+        if (chainChangedHandler) {
+          provider.removeListener("chainChanged", chainChangedHandler);
+          chainChangedHandler = void 0;
+        }
+        if (disconnectHandler) {
+          provider.removeListener("disconnect", disconnectHandler);
+          disconnectHandler = void 0;
+        }
+        provider.clearWallet();
+        talkenApi.auth.logout();
+        clearAuthState();
+        getCredentialManager().clear();
+      },
+      /**
+       * Get accounts
+       */
+      async getAccounts() {
+        const accounts = await provider.request({
+          method: "eth_accounts"
+        });
+        return accounts.map((account) => account);
+      },
+      /**
+       * Get chain ID
+       */
+      async getChainId() {
+        const chainId = await provider.request({
+          method: "eth_chainId"
+        });
+        return Number(chainId);
+      },
+      /**
+       * Get provider
+       */
+      async getProvider() {
+        return provider;
+      },
+      /**
+       * Check if authorized (has valid session)
+       * Auto-refreshes access token if expired but refresh token is valid
+       */
+      async isAuthorized() {
+        try {
+          const authState = loadAuthState();
+          if (!authState || !authState.isAuthenticated) {
+            return false;
+          }
+          if (!authState.wallet) {
+            return false;
+          }
+          if (talkenApi.isAuthenticated()) {
+            return true;
+          }
+          const refreshToken = loadFromStorage(
+            "refresh_token" /* REFRESH_TOKEN */
+          );
+          if (!refreshToken) {
+            clearStorage();
+            return false;
+          }
+          try {
+            const api = getTalkenApiClient();
+            if (!api) {
+              clearStorage();
+              return false;
+            }
+            const res = await api.auth.refresh();
+            talkenApi.setTokens(
+              res.accessToken,
+              res.refreshToken,
+              Date.now() + res.expiresIn * 1e3
+            );
+            const updatedState = loadAuthState();
+            return updatedState?.isAuthenticated ?? false;
+          } catch (error) {
+            console.error("[AbcConnector] Token refresh failed:", error);
+            clearStorage();
+            return false;
+          }
+        } catch (error) {
+          console.error(
+            "[AbcConnector] Unexpected error in isAuthorized:",
+            error
+          );
+          return false;
+        }
+      },
+      /**
+       * Switch chain
+       */
+      async switchChain({ chainId }) {
+        await provider.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId: `0x${chainId.toString(16)}` }]
+        });
+        const newChainId = await this.getChainId();
+        const authState = loadAuthState();
+        if (authState?.wallet) {
+          authState.wallet.chainId = newChainId;
+          saveAuthState(authState);
+        }
+        return wagmiConfig.chains.find((x) => x.id === chainId) ?? {
+          id: chainId,
+          name: `Chain ${chainId}`,
+          nativeCurrency: {
+            name: "Ether",
+            decimals: 18,
+            symbol: "ETH"
+          },
+          rpcUrls: {
+            default: { http: [""] }
+          }
+        };
+      },
+      /**
+       * Handle accounts changed
+       */
+      onAccountsChanged(accounts) {
+        if (accounts.length === 0) {
+          this.onDisconnect();
+        } else {
+          wagmiConfig.emitter.emit("change", {
+            accounts
+          });
+        }
+      },
+      /**
+       * Handle chain changed
+       */
+      onChainChanged(chain) {
+        const chainId = Number(chain);
+        wagmiConfig.emitter.emit("change", { chainId });
+      },
+      /**
+       * Handle disconnect
+       */
+      onDisconnect(_error) {
+        provider.clearWallet();
+        clearAuthState();
+        wagmiConfig.emitter.emit("disconnect");
+      }
+    };
+  });
+}
+
+export {
+  abcConnector
+};

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

@@ -0,0 +1,138 @@
+"use client";
+import {
+  encryptWithPin
+} from "./chunk-Q42NO7WB.js";
+import {
+  getTalkenApiClient
+} from "./chunk-R6ZE7JAZ.js";
+import {
+  getBitcoinNetwork,
+  getEvmNetwork,
+  getSolanaNetwork,
+  getTronNetwork
+} from "./chunk-O4AU63LK.js";
+import {
+  saveAuthState
+} from "./chunk-7EQNUYV2.js";
+
+// src/wallets/walletConnectors/abcWallet/backfillMissingWallets.ts
+var STORAGE_PREFIX = "talkenkit_abc_";
+function hasMissingBackfillableWallets(authState) {
+  if (!authState?.wallet?.address) {
+    return false;
+  }
+  return !authState.solanaWallet || !authState.bitcoinWallet || !authState.tronWallet;
+}
+async function backfillMissingWallets(authState) {
+  if (!hasMissingBackfillableWallets(authState)) {
+    return authState;
+  }
+  const hashedPin = localStorage.getItem(`${STORAGE_PREFIX}pin_hash`);
+  const email = authState.user?.email || authState.wallet?.email || localStorage.getItem(`${STORAGE_PREFIX}saved_email`);
+  if (!hashedPin || !email) {
+    return null;
+  }
+  const api = getTalkenApiClient();
+  if (!api) {
+    return null;
+  }
+  api.setTokens(
+    authState.accessToken || "",
+    authState.refreshToken || "",
+    authState.expiresAt || 0
+  );
+  const genResponse = await api.wallet.generate(hashedPin, email);
+  const infoResponse = await api.wallet.getInfo();
+  const uid = authState.user?.uid || genResponse.uid;
+  const accounts = infoResponse?.accounts || [];
+  const evmAccount = accounts[0] || infoResponse || {};
+  const pubkey = authState.wallet?.pubkey || evmAccount.pubkey || genResponse.pubkey || "";
+  const sid = authState.wallet?.sid || evmAccount.sid || authState.wallet?.address;
+  const nextAuthState = {
+    ...authState,
+    isAuthenticated: true,
+    user: authState.user || {
+      uid,
+      email,
+      provider: "email"
+    },
+    wallet: authState.wallet || {
+      address: sid,
+      chainId: getEvmNetwork(),
+      uid,
+      sid,
+      type: "evm",
+      email,
+      encryptedShare: "",
+      keyId: "0",
+      sessionId: sid
+    },
+    solanaWallet: authState.solanaWallet || (genResponse.solAddress ? {
+      uid,
+      sessionId: genResponse.solana?.keyId || "",
+      shareId: genResponse.solana?.keyId || "",
+      publicKey: genResponse.solana?.publicKey || "",
+      address: genResponse.solAddress,
+      keyId: genResponse.solana?.keyId || "",
+      encryptedShare: genResponse.solana?.encryptedShare || "",
+      secretStore: genResponse.solana?.secretStore || "",
+      network: getSolanaNetwork()
+    } : null),
+    bitcoinWallet: authState.bitcoinWallet || (genResponse.btcAddress ? {
+      uid,
+      sessionId: "",
+      shareId: "",
+      publicKey: pubkey,
+      address: genResponse.btcAddress,
+      keyId: "",
+      encryptedShare: "",
+      addressType: "bech32",
+      network: getBitcoinNetwork()
+    } : null),
+    tronWallet: authState.tronWallet || (genResponse.trxAddress ? {
+      uid,
+      sessionId: "",
+      shareId: "",
+      publicKey: pubkey,
+      address: genResponse.trxAddress,
+      keyId: "",
+      encryptedShare: "",
+      network: getTronNetwork()
+    } : null)
+  };
+  saveAuthState(nextAuthState);
+  const saltHex = localStorage.getItem(`${STORAGE_PREFIX}enc_salt`);
+  const salt = saltHex ? new Uint8Array(
+    saltHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+  ) : crypto.getRandomValues(new Uint8Array(16));
+  const encryptedSensitiveData = await encryptWithPin(
+    JSON.stringify({
+      accessToken: nextAuthState.accessToken,
+      refreshToken: nextAuthState.refreshToken,
+      expiresAt: nextAuthState.expiresAt,
+      solanaWallet: nextAuthState.solanaWallet,
+      bitcoinWallet: nextAuthState.bitcoinWallet,
+      tronWallet: nextAuthState.tronWallet
+    }),
+    hashedPin,
+    salt
+  );
+  localStorage.setItem(
+    `${STORAGE_PREFIX}enc_salt`,
+    Array.from(salt).map((byte) => byte.toString(16).padStart(2, "0")).join("")
+  );
+  localStorage.setItem(`${STORAGE_PREFIX}enc_tokens`, encryptedSensitiveData);
+  localStorage.setItem(`${STORAGE_PREFIX}saved_email`, email);
+  window.dispatchEvent(
+    new CustomEvent("talkenkit:token_updated", {
+      detail: { expiresAt: nextAuthState.expiresAt }
+    })
+  );
+  window.dispatchEvent(new Event("talkenkit_storage_update"));
+  return nextAuthState;
+}
+
+export {
+  hasMissingBackfillableWallets,
+  backfillMissingWallets
+};