@talken/talkenkit 2.4.29 → 2.4.30

package/dist/wallets/walletConnectors/chunk-3AX66UHT.js

@@ -1,479 +0,0 @@
-"use client";
-import {
-  AbcError,
-  AbcStorageKey
-} from "./chunk-D5EFTEOM.js";
-import {
-  PIN_CONFIG,
-  STORAGE_PREFIX,
-  TOKEN_EXPIRY
-} from "./chunk-RCIABMG5.js";
-
-// src/wallets/walletConnectors/abcWallet/utils.ts
-import CryptoJS from "crypto-js";
-async function hashPin(pin) {
-  if (typeof window === "undefined" || !window.crypto?.subtle) {
-    return btoa(pin);
-  }
-  const encoder = new TextEncoder();
-  const data = encoder.encode(pin);
-  const hashBuffer = await window.crypto.subtle.digest("SHA-256", data);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  return hashHex;
-}
-function validatePin(pin) {
-  if (!pin || typeof pin !== "string") {
-    return false;
-  }
-  const pinLength = pin.length;
-  if (pinLength < PIN_CONFIG.MIN_LENGTH || pinLength > PIN_CONFIG.MAX_LENGTH) {
-    return false;
-  }
-  return /^\d+$/.test(pin);
-}
-function validateEmail(email) {
-  if (!email || typeof email !== "string") {
-    return false;
-  }
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailRegex.test(email);
-}
-function getStorageKey(key) {
-  return `${STORAGE_PREFIX}${key}`;
-}
-function saveToStorage(key, value) {
-  if (typeof window === "undefined")
-    return;
-  try {
-    const storageKey = getStorageKey(key);
-    const serialized = JSON.stringify(value);
-    localStorage.setItem(storageKey, serialized);
-  } catch (error) {
-    console.error("Failed to save to storage:", error);
-  }
-}
-function loadFromStorage(key) {
-  if (typeof window === "undefined")
-    return null;
-  try {
-    const storageKey = getStorageKey(key);
-    const serialized = localStorage.getItem(storageKey);
-    if (!serialized)
-      return null;
-    try {
-      return JSON.parse(serialized);
-    } catch {
-      return serialized;
-    }
-  } catch (error) {
-    console.error("Failed to load from storage:", error);
-    return null;
-  }
-}
-function removeFromStorage(key) {
-  if (typeof window === "undefined")
-    return;
-  try {
-    const storageKey = getStorageKey(key);
-    localStorage.removeItem(storageKey);
-  } catch (error) {
-    console.error("Failed to remove from storage:", error);
-  }
-}
-function clearStorage() {
-  if (typeof window === "undefined")
-    return;
-  for (const key of Object.values(AbcStorageKey)) {
-    removeFromStorage(key);
-  }
-}
-function isTokenExpired(expiresAt) {
-  if (!expiresAt)
-    return true;
-  return Date.now() >= expiresAt - TOKEN_EXPIRY.REFRESH_BUFFER;
-}
-function calculateExpiryTimestamp(expiresIn) {
-  return Date.now() + expiresIn * 1e3;
-}
-function saveAuthState(state) {
-  saveToStorage("auth_state" /* AUTH_STATE */, state);
-  if (state.user) {
-    saveToStorage("user" /* USER */, state.user);
-  }
-  if (state.wallet) {
-    saveToStorage("wallet" /* WALLET */, state.wallet);
-  }
-  if (state.solanaWallet) {
-    saveToStorage("solana_wallet" /* SOLANA_WALLET */, state.solanaWallet);
-  }
-  if (state.bitcoinWallet) {
-    saveToStorage("bitcoin_wallet" /* BITCOIN_WALLET */, state.bitcoinWallet);
-  }
-  if (state.accessToken) {
-    saveToStorage("access_token" /* ACCESS_TOKEN */, state.accessToken);
-  }
-  if (state.refreshToken) {
-    saveToStorage("refresh_token" /* REFRESH_TOKEN */, state.refreshToken);
-  }
-  if (state.expiresAt) {
-    saveToStorage("expires_at" /* EXPIRES_AT */, state.expiresAt);
-  }
-}
-function loadAuthState() {
-  const state = loadFromStorage("auth_state" /* AUTH_STATE */);
-  if (state) {
-    if (state.accessToken && isTokenExpired(state.expiresAt)) {
-      clearStorage();
-      return null;
-    }
-    return state;
-  }
-  const user = loadFromStorage("user" /* USER */);
-  const wallet = loadFromStorage("wallet" /* WALLET */);
-  const solanaWallet = loadFromStorage("solana_wallet" /* SOLANA_WALLET */);
-  const accessToken = loadFromStorage("access_token" /* ACCESS_TOKEN */);
-  const refreshToken = loadFromStorage("refresh_token" /* REFRESH_TOKEN */);
-  const expiresAt = loadFromStorage("expires_at" /* EXPIRES_AT */);
-  if (!user || !accessToken) {
-    return null;
-  }
-  const bitcoinWallet = loadFromStorage("bitcoin_wallet" /* BITCOIN_WALLET */);
-  const tronWallet = loadFromStorage("tron_wallet" /* TRON_WALLET */);
-  return {
-    isAuthenticated: true,
-    user,
-    wallet,
-    solanaWallet,
-    bitcoinWallet,
-    tronWallet,
-    accessToken,
-    refreshToken,
-    expiresAt
-  };
-}
-function clearAuthState() {
-  clearStorage();
-}
-function getChainType(chainId) {
-  if (chainId === 900)
-    return "solana";
-  if (chainId === 800)
-    return "bitcoin";
-  return "evm";
-}
-function formatAddress(address, startLength = 6, endLength = 4) {
-  if (!address || address.length <= startLength + endLength) {
-    return address;
-  }
-  const start = address.substring(0, startLength);
-  const end = address.substring(address.length - endLength);
-  return `${start}...${end}`;
-}
-function createAbcError(code, message, details, statusCode) {
-  return new AbcError(code, message, details, statusCode);
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function retry(fn, maxRetries = 3, delay = 1e3, backoffMultiplier = 2) {
-  let lastError = null;
-  for (let attempt = 0; attempt < maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (attempt < maxRetries - 1) {
-        const waitTime = delay * backoffMultiplier ** attempt;
-        await sleep(waitTime);
-      }
-    }
-  }
-  throw lastError || new Error("Retry failed");
-}
-function parseApiError(error) {
-  if (error instanceof AbcError) {
-    return error;
-  }
-  if (!error.response) {
-    return createAbcError(
-      "NETWORK_ERROR" /* NETWORK_ERROR */,
-      "Network error occurred",
-      error
-    );
-  }
-  const response = error.response;
-  const data = response.data;
-  const statusCode = response.status;
-  if (statusCode === 401) {
-    return createAbcError(
-      "TOKEN_EXPIRED" /* TOKEN_EXPIRED */,
-      "Authentication token expired",
-      data,
-      401
-    );
-  }
-  if (statusCode === 409) {
-    return createAbcError(
-      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-      // Will trigger recovery
-      data?.error || "Resource already exists",
-      data,
-      409
-    );
-  }
-  if (typeof data === "object" && "iserr" in data) {
-    const bitcoinData = data;
-    if (bitcoinData.iserr === true) {
-      return createAbcError(
-        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        bitcoinData.errmsg || "Bitcoin signature failed",
-        data,
-        statusCode
-      );
-    }
-    if (!bitcoinData.signstr) {
-      return createAbcError(
-        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        "Bitcoin signature missing in response",
-        data,
-        statusCode
-      );
-    }
-    return createAbcError(
-      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-      "Unexpected success response in error parser",
-      data,
-      statusCode
-    );
-  }
-  if (data?.error) {
-    return createAbcError(
-      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-      data.error.message || data.error || "API error occurred",
-      data,
-      statusCode
-    );
-  }
-  if (data?.message) {
-    return createAbcError(
-      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-      data.message.text || "API error occurred",
-      data,
-      statusCode
-    );
-  }
-  return createAbcError(
-    "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-    "An unknown error occurred",
-    error,
-    statusCode
-  );
-}
-function isBrowser() {
-  return typeof window !== "undefined";
-}
-function isWeb3Available() {
-  return isBrowser() && typeof window.ethereum !== "undefined";
-}
-function generateId() {
-  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
-function deepClone(obj) {
-  return JSON.parse(JSON.stringify(obj));
-}
-function isEmpty(obj) {
-  if (obj == null)
-    return true;
-  if (Array.isArray(obj))
-    return obj.length === 0;
-  if (typeof obj === "object")
-    return Object.keys(obj).length === 0;
-  return false;
-}
-function debounce(func, wait) {
-  let timeout = null;
-  return function(...args) {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-    timeout = setTimeout(() => {
-      func.apply(this, args);
-    }, wait);
-  };
-}
-function throttle(func, limit) {
-  let inThrottle = false;
-  return function(...args) {
-    if (!inThrottle) {
-      func.apply(this, args);
-      inThrottle = true;
-      setTimeout(() => {
-        inThrottle = false;
-      }, limit);
-    }
-  };
-}
-function hexToNumber(hex) {
-  return Number.parseInt(hex, 16);
-}
-function numberToHex(num) {
-  return `0x${num.toString(16)}`;
-}
-function isValidEthereumAddress(address) {
-  return /^0x[a-fA-F0-9]{40}$/.test(address);
-}
-function isValidSolanaAddress(address) {
-  return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
-}
-function getExplorerUrl(chainId, txHash) {
-  const explorers = {
-    1: "https://etherscan.io/tx/",
-    5: "https://goerli.etherscan.io/tx/",
-    137: "https://polygonscan.com/tx/",
-    56: "https://bscscan.com/tx/",
-    900: "https://explorer.solana.com/tx/"
-    // Solana
-  };
-  const baseUrl = explorers[chainId];
-  return baseUrl ? `${baseUrl}${txHash}` : null;
-}
-function generateSalt() {
-  const array = new Uint8Array(16);
-  crypto.getRandomValues(array);
-  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
-    ""
-  );
-}
-function deriveKeyFromPin(pin, salt) {
-  return CryptoJS.PBKDF2(pin, salt, {
-    keySize: 256 / 32,
-    iterations: 1e5
-  }).toString();
-}
-function encryptWithPin(data, pin, salt) {
-  const key = deriveKeyFromPin(pin, salt);
-  const encrypted = CryptoJS.AES.encrypt(data, key).toString();
-  return encrypted;
-}
-function decryptWithPin(encrypted, pin, salt) {
-  try {
-    const key = deriveKeyFromPin(pin, salt);
-    const decrypted = CryptoJS.AES.decrypt(encrypted, key);
-    const decryptedText = decrypted.toString(CryptoJS.enc.Utf8);
-    if (!decryptedText) {
-      return null;
-    }
-    return decryptedText;
-  } catch (error) {
-    console.error("Decryption failed:", error);
-    return null;
-  }
-}
-function hasEncryptedTokens() {
-  if (typeof window === "undefined")
-    return false;
-  const encrypted = loadFromStorage("encrypted_tokens" /* ENCRYPTED_TOKENS */);
-  const salt = loadFromStorage("token_salt" /* TOKEN_SALT */);
-  return !!encrypted && !!salt;
-}
-function saveEncryptedTokens(accessToken, refreshToken, expiresIn, hashedPin) {
-  if (typeof window === "undefined")
-    return;
-  try {
-    let salt = loadFromStorage("token_salt" /* TOKEN_SALT */);
-    if (!salt) {
-      salt = generateSalt();
-      saveToStorage("token_salt" /* TOKEN_SALT */, salt);
-    }
-    const expiresAt = Date.now() + expiresIn * 1e3;
-    const tokenData = {
-      accessToken,
-      refreshToken,
-      expiresAt
-    };
-    const encrypted = encryptWithPin(
-      JSON.stringify(tokenData),
-      hashedPin,
-      salt
-    );
-    saveToStorage("encrypted_tokens" /* ENCRYPTED_TOKENS */, encrypted);
-    removeFromStorage("access_token" /* ACCESS_TOKEN */);
-    removeFromStorage("refresh_token" /* REFRESH_TOKEN */);
-    removeFromStorage("expires_at" /* EXPIRES_AT */);
-  } catch (error) {
-    console.error("Failed to save encrypted tokens:", error);
-    throw new AbcError(
-      "ENCRYPTION_FAILED" /* ENCRYPTION_FAILED */,
-      "Failed to encrypt tokens"
-    );
-  }
-}
-function loadEncryptedTokens(hashedPin) {
-  if (typeof window === "undefined")
-    return null;
-  try {
-    const encrypted = loadFromStorage("encrypted_tokens" /* ENCRYPTED_TOKENS */);
-    const salt = loadFromStorage("token_salt" /* TOKEN_SALT */);
-    if (!encrypted || !salt) {
-      return null;
-    }
-    const decrypted = decryptWithPin(encrypted, hashedPin, salt);
-    if (!decrypted) {
-      throw new AbcError("INVALID_PIN" /* INVALID_PIN */, "Incorrect PIN");
-    }
-    const tokenData = JSON.parse(decrypted);
-    return tokenData;
-  } catch (error) {
-    console.error("Failed to load encrypted tokens:", error);
-    if (error instanceof AbcError) {
-      throw error;
-    }
-    throw new AbcError(
-      "DECRYPTION_FAILED" /* DECRYPTION_FAILED */,
-      "Failed to decrypt tokens"
-    );
-  }
-}
-function clearEncryptedTokens() {
-  removeFromStorage("encrypted_tokens" /* ENCRYPTED_TOKENS */);
-  removeFromStorage("token_salt" /* TOKEN_SALT */);
-}
-
-export {
-  hashPin,
-  validatePin,
-  validateEmail,
-  getStorageKey,
-  saveToStorage,
-  loadFromStorage,
-  removeFromStorage,
-  clearStorage,
-  isTokenExpired,
-  calculateExpiryTimestamp,
-  saveAuthState,
-  loadAuthState,
-  clearAuthState,
-  getChainType,
-  formatAddress,
-  createAbcError,
-  sleep,
-  retry,
-  parseApiError,
-  isBrowser,
-  isWeb3Available,
-  generateId,
-  deepClone,
-  isEmpty,
-  debounce,
-  throttle,
-  hexToNumber,
-  numberToHex,
-  isValidEthereumAddress,
-  isValidSolanaAddress,
-  getExplorerUrl,
-  hasEncryptedTokens,
-  saveEncryptedTokens,
-  loadEncryptedTokens,
-  clearEncryptedTokens
-};

package/dist/wallets/walletConnectors/chunk-3BUGPUMD.js

@@ -1,151 +0,0 @@
-"use client";
-import {
-  getBitcoinNetwork,
-  getEvmNetwork,
-  getSolanaNetwork,
-  getTronNetwork
-} from "./chunk-O4AU63LK.js";
-import {
-  AbcError
-} from "./chunk-D5EFTEOM.js";
-
-// src/wallets/walletConnectors/abcWallet/walletGeneration.ts
-import { getTalkenApiClient } from "@talken/talkenkit";
-function mapApiResponseToWallets(genResponse, infoResponse, email) {
-  const accounts = infoResponse?.accounts || [];
-  const evmAccount = accounts[0] || infoResponse || {};
-  const uid = String(genResponse.uid || evmAccount.uid || "");
-  const wid = String(genResponse.wid || evmAccount.wid || "");
-  const sid = String(evmAccount.sid || evmAccount.ethAddress || genResponse.evmAddress || "");
-  const pubkey = String(evmAccount.pubkey || genResponse.pubkey || "");
-  const solMaterial = genResponse.solana || {};
-  const evmWallet = {
-    uid,
-    sessionId: sid,
-    keyId: wid,
-    encryptedShare: String(evmAccount.pvencstr || ""),
-    secretStore: String(evmAccount.encryptDevicePassword || ""),
-    address: genResponse.evmAddress || sid,
-    chainId: getEvmNetwork(),
-    sid,
-    type: "evm",
-    email,
-    pubkey
-  };
-  const solanaWallet = {
-    uid,
-    sessionId: String(solMaterial.shareId || ""),
-    keyId: String(solMaterial.keyId || ""),
-    encryptedShare: String(solMaterial.encryptedShare || ""),
-    secretStore: String(solMaterial.secretStore || ""),
-    shareId: String(solMaterial.shareId || ""),
-    publicKey: String(solMaterial.publicKey || ""),
-    address: genResponse.solAddress || solMaterial.address || "",
-    network: getSolanaNetwork()
-  };
-  const bitcoinWallet = {
-    uid,
-    sessionId: sid,
-    keyId: wid,
-    encryptedShare: String(evmAccount.pvencstr || ""),
-    shareId: sid,
-    publicKey: pubkey,
-    address: genResponse.btcAddress || "",
-    addressType: "bech32",
-    network: getBitcoinNetwork()
-  };
-  const tronWallet = {
-    uid,
-    sessionId: sid,
-    keyId: wid,
-    encryptedShare: String(evmAccount.pvencstr || ""),
-    shareId: sid,
-    publicKey: pubkey,
-    address: genResponse.trxAddress || "",
-    network: getTronNetwork()
-  };
-  return { evmWallet, solanaWallet, bitcoinWallet, tronWallet };
-}
-async function generateMpcWallets(hashedPin, email) {
-  const api = getTalkenApiClient();
-  if (!api) {
-    throw new AbcError(
-      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-      "TalkenApiClient not initialized"
-    );
-  }
-  try {
-    const genResponse = await api.wallet.generate(hashedPin, email);
-    const infoResponse = await api.wallet.getInfo().catch(() => ({}));
-    return mapApiResponseToWallets(genResponse, infoResponse, email || "");
-  } catch (error) {
-    throw new AbcError(
-      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-      `Failed to generate MPC wallets: ${error.message}`,
-      { originalError: error }
-    );
-  }
-}
-async function recoverMpcWallets(hashedPin, email) {
-  const api = getTalkenApiClient();
-  if (!api) {
-    throw new AbcError(
-      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-      "TalkenApiClient not initialized"
-    );
-  }
-  try {
-    const genResponse = await api.wallet.recover(hashedPin, email);
-    const infoResponse = await api.wallet.getInfo().catch(() => ({}));
-    return mapApiResponseToWallets(genResponse, infoResponse, email || "");
-  } 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.solanaWallet) {
-    errors.push("Solana wallet is missing");
-  } else {
-    if (!result.solanaWallet.address) {
-      errors.push("Invalid Solana wallet address");
-    }
-  }
-  if (!result.bitcoinWallet) {
-    errors.push("Bitcoin wallet is missing");
-  } else {
-    if (!result.bitcoinWallet.address) {
-      errors.push("Invalid Bitcoin wallet address");
-    }
-  }
-  if (!result.tronWallet) {
-    errors.push("TRON wallet is missing");
-  } else {
-    if (!result.tronWallet.address) {
-      errors.push("Invalid TRON wallet address");
-    } else if (!result.tronWallet.address.startsWith("T")) {
-      errors.push("Invalid TRON address format (expected T prefix)");
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-
-export {
-  generateMpcWallets,
-  recoverMpcWallets,
-  validateMpcWallets
-};

package/dist/wallets/walletConnectors/chunk-3BVPV64G.js

@@ -1,36 +0,0 @@
-"use client";
-import {
-  BaseApiClient
-} from "./chunk-QD3PPWTN.js";
-import {
-  createAbcError
-} from "./chunk-ZJDZJW55.js";
-
-// src/wallets/walletConnectors/abcWallet/api/TronApi.ts
-import { getTalkenApiClient } from "@talken/talkenkit";
-var TronApi = class extends BaseApiClient {
-  /**
-   * Get TRON address from TalkenApiClient unified addresses endpoint.
-   *
-   * @param _publicKey - Compressed public key (unused, TalkenApiClient resolves internally)
-   * @param _network - TRON network (unused, TalkenApiClient resolves internally)
-   * @returns TRON address (starts with 'T')
-   */
-  async getTronAddress(_publicKey, _network) {
-    const api = getTalkenApiClient();
-    if (!api)
-      throw new Error("TalkenApiClient not initialized");
-    const addresses = await api.wallet.getAddresses();
-    if (!addresses.tron) {
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "TRON address not found in TalkenApiClient response"
-      );
-    }
-    return addresses.tron;
-  }
-};
-
-export {
-  TronApi
-};