@talken/talkenkit 2.4.16 → 2.4.17

package/dist/wallets/walletConnectors/chunk-25V3FW3O.js

@@ -0,0 +1,282 @@
+"use client";
+import {
+  secure_default
+} from "./chunk-NG7PSAPX.js";
+import {
+  calculateExpiryTimestamp,
+  createAbcError,
+  isTokenExpired,
+  loadFromStorage,
+  parseApiError,
+  removeFromStorage,
+  saveToStorage
+} from "./chunk-GO6OLTNF.js";
+import {
+  DEFAULT_HEADERS,
+  REQUEST_TIMEOUT
+} from "./chunk-YJH4BHSB.js";
+
+// src/wallets/walletConnectors/abcWallet/api/BaseApiClient.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var BaseApiClient = class {
+  constructor(config) {
+    this.accessToken = null;
+    this.refreshToken = null;
+    this.expiresAt = null;
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+    this.config = config;
+    this.baseURL = config.waasUrl;
+    this.secure = new secure_default(this.baseURL);
+    this.loadTokens();
+  }
+  /**
+   * Load tokens from storage
+   */
+  loadTokens() {
+    this.accessToken = loadFromStorage("access_token" /* ACCESS_TOKEN */);
+    this.refreshToken = loadFromStorage("refresh_token" /* REFRESH_TOKEN */);
+    this.expiresAt = loadFromStorage("expires_at" /* EXPIRES_AT */);
+  }
+  /**
+   * Set tokens in client instance (useful when restoring from storage or state)
+   * Call this before making API requests if tokens are managed externally
+   */
+  setTokens(accessToken, refreshToken, expiresAt) {
+    this.accessToken = accessToken;
+    this.refreshToken = refreshToken;
+    this.expiresAt = expiresAt;
+  }
+  /**
+   * Save tokens to storage
+   */
+  saveTokens(accessToken, refreshToken, expiresIn) {
+    this.accessToken = accessToken;
+    this.refreshToken = refreshToken;
+    this.expiresAt = calculateExpiryTimestamp(expiresIn);
+    saveToStorage("access_token" /* ACCESS_TOKEN */, accessToken);
+    saveToStorage("refresh_token" /* REFRESH_TOKEN */, refreshToken);
+    saveToStorage("expires_at" /* EXPIRES_AT */, this.expiresAt);
+  }
+  /**
+   * Clear tokens
+   */
+  clearTokens() {
+    this.accessToken = null;
+    this.refreshToken = null;
+    this.expiresAt = null;
+    removeFromStorage("access_token" /* ACCESS_TOKEN */);
+    removeFromStorage("refresh_token" /* REFRESH_TOKEN */);
+    removeFromStorage("expires_at" /* EXPIRES_AT */);
+  }
+  /**
+   * Check if access token is expired
+   */
+  isTokenExpired() {
+    return isTokenExpired(this.expiresAt);
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  /**
+   * Set access token manually
+   */
+  setAccessToken(token) {
+    this.accessToken = token;
+  }
+  /**
+   * Get base URL
+   */
+  getBaseURL() {
+    return this.baseURL;
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Refresh access token via TalkenApiClient
+   */
+  async refreshAccessToken() {
+    if (this.isRefreshing) {
+      if (this.refreshPromise) {
+        await this.refreshPromise;
+      }
+      return;
+    }
+    const api = getTalkenApiClient();
+    if (api) {
+      this.isRefreshing = true;
+      this.refreshPromise = (async () => {
+        try {
+          const res = await api.auth.refresh();
+          this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+        } finally {
+          this.isRefreshing = false;
+          this.refreshPromise = null;
+        }
+      })();
+      await this.refreshPromise;
+      return;
+    }
+    if (!this.refreshToken) {
+      throw createAbcError(
+        "TOKEN_EXPIRED" /* TOKEN_EXPIRED */,
+        "No refresh token available"
+      );
+    }
+    throw createAbcError(
+      "TOKEN_EXPIRED" /* TOKEN_EXPIRED */,
+      "TalkenApiClient not initialized for token refresh"
+    );
+  }
+  /**
+   * Make HTTP request with automatic token refresh
+   */
+  async request(endpoint, options = {}) {
+    const {
+      method = "GET",
+      body,
+      headers = {},
+      skipAuth = false,
+      isRetry = false,
+      contentType = "form"
+      // Default to form-encoded for backward compatibility
+    } = options;
+    if (!skipAuth && this.isTokenExpired() && this.refreshToken) {
+      await this.refreshAccessToken();
+    }
+    const url = `${this.baseURL}${endpoint}`;
+    const requestHeaders = {
+      ...DEFAULT_HEADERS,
+      ...headers
+    };
+    if (contentType === "json") {
+      requestHeaders["Content-Type"] = "application/json";
+      requestHeaders["Accept"] = "application/json";
+    }
+    if (this.config.environment === "production") {
+      requestHeaders["User-Agent"] = "Android";
+    }
+    if (!skipAuth && this.accessToken) {
+      requestHeaders.Authorization = `Bearer ${this.accessToken}`;
+    }
+    if (this.config.apiKey) {
+      requestHeaders["X-API-Key"] = this.config.apiKey;
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+      const requestBody = body ? contentType === "json" ? JSON.stringify(body) : new URLSearchParams(body).toString() : void 0;
+      const response = await fetch(url, {
+        method,
+        headers: requestHeaders,
+        body: requestBody,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const text = await response.text();
+      let data;
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch (parseError) {
+          console.error("[BaseApiClient] \u274C JSON parse error:", {
+            url,
+            method,
+            status: response.status,
+            responseText: text.substring(0, 200)
+          });
+          throw createAbcError(
+            "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+            "Invalid JSON response from server",
+            { text, parseError }
+          );
+        }
+      } else {
+        data = { status: "success" };
+      }
+      if (response.status === 401 && !skipAuth && this.refreshToken && !isRetry) {
+        try {
+          await this.refreshAccessToken();
+          return await this.request(endpoint, {
+            ...options,
+            isRetry: true
+          });
+        } catch (refreshError) {
+          console.error("Token refresh failed:", refreshError);
+          throw parseApiError({
+            response: {
+              status: response.status,
+              data
+            }
+          });
+        }
+      }
+      if (!response.ok) {
+        if (response.status !== 409) {
+          console.error("[BaseApiClient] \u274C API Error:", {
+            url,
+            method,
+            status: response.status,
+            statusText: response.statusText,
+            data
+          });
+        }
+        throw parseApiError({
+          response: {
+            status: response.status,
+            data
+          }
+        });
+      }
+      return data;
+    } catch (error) {
+      if (error.response?.status !== 409 && error.code !== "WALLET_ALREADY_EXISTS") {
+        console.error("[BaseApiClient] \u274C Request failed:", {
+          url,
+          method,
+          error: error.message
+        });
+      }
+      if (error.name === "AbortError") {
+        throw createAbcError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Request timeout",
+          error
+        );
+      }
+      if (error.code && error.message) {
+        throw error;
+      }
+      throw parseApiError(error);
+    }
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return !!this.accessToken && !this.isTokenExpired();
+  }
+  /**
+   * Logout (clear tokens)
+   */
+  async logout() {
+    this.clearTokens();
+  }
+  /**
+   * Get secure service instance
+   */
+  getSecureService() {
+    return this.secure;
+  }
+};
+
+export {
+  BaseApiClient
+};

package/dist/wallets/walletConnectors/chunk-27346T3J.js

@@ -0,0 +1,134 @@
+"use client";
+import {
+  AbcError
+} from "./chunk-D5EFTEOM.js";
+
+// src/wallets/walletConnectors/abcWallet/walletGeneration.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+async function generateMpcWallets(hashedPin) {
+  const api = getTalkenApiClient();
+  if (!api) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  try {
+    const response = await api.wallet.generate(hashedPin);
+    return {
+      evmWallet: response.evm,
+      solanaWallet: response.solana,
+      bitcoinWallet: response.bitcoin,
+      tronWallet: response.tron
+    };
+  } catch (error) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Failed to generate MPC wallets: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+async function recoverMpcWallets(hashedPin) {
+  const api = getTalkenApiClient();
+  if (!api) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  try {
+    const response = await api.wallet.recover(hashedPin);
+    return {
+      evmWallet: response.evm,
+      solanaWallet: response.solana,
+      bitcoinWallet: response.bitcoin,
+      tronWallet: response.tron
+    };
+  } catch (error) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Failed to recover MPC wallets: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+function validateMpcWallets(result) {
+  const errors = [];
+  if (!result.evmWallet) {
+    errors.push("EVM wallet is missing");
+  } else {
+    if (!result.evmWallet.address || !result.evmWallet.address.startsWith("0x")) {
+      errors.push("Invalid EVM wallet address");
+    }
+    if (!result.evmWallet.keyId) {
+      errors.push("EVM wallet missing keyId");
+    }
+    if (!result.evmWallet.encryptedShare) {
+      errors.push("EVM wallet missing encryptedShare");
+    }
+  }
+  if (!result.solanaWallet) {
+    errors.push("Solana wallet is missing");
+  } else {
+    if (!result.solanaWallet.address) {
+      errors.push("Invalid Solana wallet address");
+    }
+    if (!result.solanaWallet.publicKey) {
+      errors.push("Solana wallet missing publicKey");
+    }
+    if (!result.solanaWallet.keyId) {
+      errors.push("Solana wallet missing keyId");
+    }
+  }
+  if (!result.bitcoinWallet) {
+    errors.push("Bitcoin wallet is missing");
+  } else {
+    const addr = result.bitcoinWallet.address;
+    const type = result.bitcoinWallet.addressType;
+    if (!addr) {
+      errors.push("Invalid Bitcoin wallet address");
+    }
+    if (!result.bitcoinWallet.publicKey) {
+      errors.push("Bitcoin wallet missing publicKey");
+    }
+    if (!result.bitcoinWallet.keyId) {
+      errors.push("Bitcoin wallet missing keyId");
+    }
+    if (type === "bech32" && !addr.startsWith("bc1q")) {
+      errors.push("Invalid Bech32 address format (expected bc1q prefix)");
+    } else if (type === "p2pkh" && !addr.startsWith("1")) {
+      errors.push("Invalid P2PKH address format (expected 1 prefix)");
+    } else if (type === "p2sh" && !addr.startsWith("3")) {
+      errors.push("Invalid P2SH address format (expected 3 prefix)");
+    } else if (type === "taproot" && !addr.startsWith("bc1p")) {
+      errors.push("Invalid Taproot address format (expected bc1p prefix)");
+    }
+  }
+  if (!result.tronWallet) {
+    errors.push("TRON wallet is missing");
+  } else {
+    const tronAddr = result.tronWallet.address;
+    if (!tronAddr) {
+      errors.push("Invalid TRON wallet address");
+    } else if (!tronAddr.startsWith("T")) {
+      errors.push("Invalid TRON address format (expected T prefix)");
+    }
+    if (!result.tronWallet.publicKey) {
+      errors.push("TRON wallet missing publicKey");
+    }
+    if (!result.tronWallet.keyId) {
+      errors.push("TRON wallet missing keyId");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+export {
+  generateMpcWallets,
+  recoverMpcWallets,
+  validateMpcWallets
+};

package/dist/wallets/walletConnectors/chunk-5CNLMOB2.js

@@ -0,0 +1,75 @@
+"use client";
+import {
+  GasApi
+} from "./chunk-QMLG7MAP.js";
+import {
+  SigningApi
+} from "./chunk-JODNZWWG.js";
+import {
+  TransactionApi
+} from "./chunk-AUGP2LJR.js";
+import {
+  TronApi
+} from "./chunk-XXG7ABSJ.js";
+import {
+  WalletApi
+} from "./chunk-IUHZ5ZCE.js";
+import {
+  WalletscanApi
+} from "./chunk-I3GFVK5O.js";
+import {
+  AuthApi
+} from "./chunk-NHP6D6AH.js";
+import {
+  BitcoinApi
+} from "./chunk-SOBJYYIX.js";
+import {
+  SolanaApi
+} from "./chunk-LZZE462U.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
+};