@talken/talkenkit 2.4.15 → 2.4.17

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

@@ -0,0 +1,75 @@
+"use client";
+import {
+  SigningApi
+} from "./chunk-QB5GDLRU.js";
+import {
+  TransactionApi
+} from "./chunk-LHV22375.js";
+import {
+  TronApi
+} from "./chunk-DM5NLSWD.js";
+import {
+  WalletApi
+} from "./chunk-YTPAWPCA.js";
+import {
+  WalletscanApi
+} from "./chunk-UXNEBBUV.js";
+import {
+  AuthApi
+} from "./chunk-PWWSAM4G.js";
+import {
+  BitcoinApi
+} from "./chunk-X6A2FSHK.js";
+import {
+  GasApi
+} from "./chunk-A4WR3CFN.js";
+import {
+  SolanaApi
+} from "./chunk-5K45TCAM.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);
+    this.tron = new TronApi(config);
+    this.walletscan = new WalletscanApi(config);
+    this.gas = new GasApi(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-HO5Z2CTL.js

@@ -0,0 +1,280 @@
+"use client";
+import {
+  loadAuthState,
+  saveAuthState
+} from "./chunk-BLEKTKBN.js";
+
+// src/wallets/walletConnectors/abcWallet/abcBitcoinConnector.ts
+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.client = config.client;
+    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);
+      this.provider.setRequestPinCallback(async () => {
+        if (!authState.pin) {
+          console.error("[BitcoinConnector] \u274C PIN not available in authState");
+          throw new Error("PIN not available");
+        }
+        return authState.pin;
+      });
+      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
+      });
+      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;
+      }
+      return !this.client.auth.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-I3GFVK5O.js

@@ -0,0 +1,151 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-25V3FW3O.js";
+
+// src/wallets/walletConnectors/abcWallet/api/WalletscanApi.ts
+import { getTalkenApiClient, networkNameToChainKey } from "@talken/talkenkit";
+var WalletscanApi = class extends BaseApiClient {
+  /**
+   * Get token metadata via TalkenApiClient walletscan endpoint
+   *
+   * @param params - Contract address and networks
+   * @returns Token metadata or null if not found/failed
+   */
+  async getContractToken(params) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    try {
+      const tokens = await api.walletscan.getToken({
+        contractAddress: params.contractAddress,
+        chainKeys: networkNameToChainKey(params.networks)
+      });
+      return tokens.length > 0 ? tokens[0] : null;
+    } catch (error) {
+      console.warn(
+        "[WalletscanApi] TalkenApi getToken failed:",
+        params.contractAddress,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Get token metadata with timeout
+   *
+   * @param params - Contract address and networks
+   * @param timeoutMs - Timeout in milliseconds (default: 3000)
+   * @returns Token metadata or null if timeout/failed
+   */
+  async getContractTokenWithTimeout(params, timeoutMs = 3e3) {
+    try {
+      const result = await Promise.race([
+        this.getContractToken(params),
+        new Promise(
+          (resolve) => setTimeout(() => resolve(null), timeoutMs)
+        )
+      ]);
+      return result;
+    } catch (_error) {
+      console.warn(
+        "[WalletscanApi] Token metadata request timed out:",
+        params.contractAddress
+      );
+      return null;
+    }
+  }
+  /**
+   * Get native coin info via TalkenApiClient walletscan endpoint
+   *
+   * @param params - Wallet address and networks
+   * @returns Array of native coins or empty array if failed
+   */
+  async getNativeToken(params) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    try {
+      return await api.walletscan.getNativeTokens({
+        walletAddress: params.walletAddress,
+        chainKeys: networkNameToChainKey(params.networks)
+      });
+    } catch (error) {
+      console.warn("[WalletscanApi] TalkenApi getNativeTokens failed:", error);
+      return [];
+    }
+  }
+  /**
+   * Get native coin info with timeout
+   *
+   * @param params - Wallet address and networks
+   * @param timeoutMs - Timeout in milliseconds (default: 3000)
+   * @returns First native coin or null if timeout/failed
+   */
+  async getNativeTokenWithTimeout(params, timeoutMs = 3e3) {
+    try {
+      const natives = await Promise.race([
+        this.getNativeToken(params),
+        new Promise(
+          (resolve) => setTimeout(() => resolve([]), timeoutMs)
+        )
+      ]);
+      return natives.length > 0 ? natives[0] : null;
+    } catch (_error) {
+      console.warn("[WalletscanApi] Native coin request timed out");
+      return null;
+    }
+  }
+  /**
+   * Get NFT metadata via TalkenApiClient walletscan endpoint
+   *
+   * @param params - Contract address, wallet address, and networks
+   * @returns Array of NFT metadata or empty array if failed
+   */
+  async getNFT(params) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    try {
+      return await api.walletscan.getNfts({
+        chainKeys: networkNameToChainKey(params.networks),
+        walletAddress: params.walletAddress
+      });
+    } catch (error) {
+      console.warn(
+        "[WalletscanApi] TalkenApi getNfts failed:",
+        params.contractAddress,
+        error
+      );
+      return [];
+    }
+  }
+  /**
+   * Get NFT metadata with timeout
+   *
+   * @param params - Contract address, wallet address, and networks
+   * @param timeoutMs - Timeout in milliseconds (default: 3000)
+   * @returns First NFT or null if timeout/failed/empty
+   */
+  async getNFTWithTimeout(params, timeoutMs = 3e3) {
+    try {
+      const nfts = await Promise.race([
+        this.getNFT(params),
+        new Promise(
+          (resolve) => setTimeout(() => resolve([]), timeoutMs)
+        )
+      ]);
+      return nfts.length > 0 ? nfts[0] : null;
+    } catch (_error) {
+      console.warn(
+        "[WalletscanApi] NFT metadata request timed out:",
+        params.contractAddress
+      );
+      return null;
+    }
+  }
+};
+
+export {
+  WalletscanApi
+};

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

@@ -0,0 +1,121 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-25V3FW3O.js";
+import {
+  getSolanaNetwork
+} from "./chunk-O4AU63LK.js";
+import {
+  createAbcError
+} from "./chunk-GO6OLTNF.js";
+import {
+  DEFAULT_HEADERS
+} from "./chunk-YJH4BHSB.js";
+
+// src/wallets/walletConnectors/abcWallet/api/WalletApi.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var WalletApi = class extends BaseApiClient {
+  /**
+   * Generate or recover EVM wallet
+   * Delegates to TalkenApiClient unified wallet API
+   */
+  async generateOrRecoverWallet(params) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    const response = await api.wallet.generate(params.pin);
+    const evm = response.evm;
+    return {
+      address: evm.address || "",
+      keyId: evm.keyId || "",
+      encryptedShare: evm.encryptedShare || "",
+      uid: evm.uid,
+      sid: evm.sid,
+      wid: evm.wid,
+      pvencstr: evm.pvencstr,
+      encryptDevicePassword: evm.encryptDevicePassword,
+      pubkey: evm.pubkey || null
+    };
+  }
+  /**
+   * Get wallet info
+   * Uses TalkenApiClient unified wallet info endpoint
+   */
+  async getWalletInfo(_uid) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    return api.wallet.getInfo();
+  }
+  /**
+   * Generate or recover Solana wallet (Ed25519)
+   */
+  async generateSolanaWallet(pin, isRecover = false) {
+    const url = `${this.baseURL}/v3/wallet/${isRecover ? "recover" : "generate"}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        curve: "ed25519",
+        password: pin
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Failed to generate Solana wallet",
+        data
+      );
+    }
+    const result = data.result;
+    const solanaNetwork = getSolanaNetwork();
+    const addressResult = await this.getSolanaAddress(
+      result.public_key,
+      solanaNetwork
+    );
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address: addressResult,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || "",
+      network: solanaNetwork
+    };
+  }
+  /**
+   * Get Solana address from Ed25519 public key
+   */
+  async getSolanaAddress(publicKey, network) {
+    const url = `${this.baseURL}/wapi/v2/solana/wallet/getAddress`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        network,
+        publicKey
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to get Solana address",
+        data
+      );
+    }
+    return data.result?.data?.address;
+  }
+};
+
+export {
+  WalletApi
+};