@talken/talkenkit 2.4.28 → 2.4.29

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

@@ -0,0 +1,71 @@
+"use client";
+import {
+  WalletApi
+} from "./chunk-QHCLOJYA.js";
+import {
+  WalletscanApi
+} from "./chunk-7MDXHYMB.js";
+import {
+  TronApi
+} from "./chunk-RS36ZX4P.js";
+import {
+  TransactionApi
+} from "./chunk-NBEDPUHX.js";
+import {
+  AuthApi
+} from "./chunk-O47OQDRJ.js";
+import {
+  BitcoinApi
+} from "./chunk-CPAYLZZL.js";
+import {
+  GasApi
+} from "./chunk-IX6DQDRE.js";
+import {
+  SolanaApi
+} from "./chunk-C4L5XI6N.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.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-NBEDPUHX.js

@@ -0,0 +1,91 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-7ZCM4DCC.js";
+import {
+  createAbcError
+} from "./chunk-6LH6ZME2.js";
+import {
+  ABC_ENDPOINTS
+} from "./chunk-DHHVIM22.js";
+
+// src/wallets/walletConnectors/abcWallet/api/TransactionApi.ts
+var TransactionApi = class extends BaseApiClient {
+  /**
+   * Get transaction count (nonce)
+   */
+  async getTransactionCount(address, network, block = "latest") {
+    const nonceUrl = `${this.baseURL}${ABC_ENDPOINTS.TRANSACTION_COUNT}?address=${address}&network=${network}&block=${block}`;
+    const response = await fetch(nonceUrl, {
+      method: "GET",
+      headers: {
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return Number.parseInt(data.result, 16);
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "Failed to get transaction count"
+    );
+  }
+  /**
+   * Get suggested gas fees for EIP-1559
+   */
+  async getSuggestedGasFees(network) {
+    const url = `${this.baseURL}${ABC_ENDPOINTS.GAS_SUGGESTED_FEES}?network=${network}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return data;
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "Failed to get suggested gas fees"
+    );
+  }
+  /**
+   * Estimate gas limit for EIP-1559 transaction
+   */
+  async estimateGas(params) {
+    const estimateBody = new URLSearchParams({
+      network: params.network,
+      to: params.to || "0x",
+      ...params.from ? { from: params.from } : {},
+      ...params.value ? { value: params.value } : {},
+      ...params.data && params.data !== "0x" ? { data: params.data } : {},
+      ...params.maxFeePerGas ? { maxFeePerGas: params.maxFeePerGas } : {},
+      ...params.maxPriorityFeePerGas ? { maxPriorityFeePerGas: params.maxPriorityFeePerGas } : {}
+    });
+    const url = `${this.baseURL}${ABC_ENDPOINTS.GAS_ESTIMATE_EIP1559}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: estimateBody.toString()
+    });
+    const data = await response.json();
+    if (response.ok && data.result) {
+      return data.result;
+    }
+    const fallbackGasLimit = "0x2dc6c0";
+    console.warn("\u26A0\uFE0F Gas estimate failed, using fallback:", {
+      error: data.errorMessage || data.msg,
+      fallbackGasLimit
+    });
+    return fallbackGasLimit;
+  }
+};
+
+export {
+  TransactionApi
+};

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

@@ -0,0 +1,192 @@
+"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 writeBackfillDebug(payload) {
+  try {
+    localStorage.setItem(
+      `${STORAGE_PREFIX}backfill_debug`,
+      JSON.stringify({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ...payload
+      })
+    );
+  } catch {
+  }
+}
+function hasMissingBackfillableWallets(authState) {
+  if (!authState?.wallet?.address) {
+    return false;
+  }
+  return !authState.solanaWallet || !authState.bitcoinWallet || !authState.tronWallet;
+}
+async function backfillMissingWallets(authState) {
+  if (!hasMissingBackfillableWallets(authState)) {
+    writeBackfillDebug({
+      status: "skipped",
+      reason: "nothing-missing"
+    });
+    return authState;
+  }
+  const hashedPin = localStorage.getItem(`${STORAGE_PREFIX}pin_hash`);
+  const email = authState.user?.email || authState.wallet?.email || localStorage.getItem(`${STORAGE_PREFIX}saved_email`);
+  writeBackfillDebug({
+    status: "started",
+    hasHashedPin: !!hashedPin,
+    hasEmail: !!email,
+    hasWallet: !!authState.wallet?.address,
+    hasSolanaWallet: !!authState.solanaWallet,
+    hasBitcoinWallet: !!authState.bitcoinWallet,
+    hasTronWallet: !!authState.tronWallet
+  });
+  if (!hashedPin || !email) {
+    writeBackfillDebug({
+      status: "blocked",
+      reason: !hashedPin ? "missing-pin-hash" : "missing-email",
+      hasHashedPin: !!hashedPin,
+      hasEmail: !!email
+    });
+    return null;
+  }
+  const api = getTalkenApiClient();
+  if (!api) {
+    writeBackfillDebug({
+      status: "blocked",
+      reason: "missing-api-client",
+      hasHashedPin: true,
+      hasEmail: true
+    });
+    return null;
+  }
+  try {
+    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"));
+    writeBackfillDebug({
+      status: "completed",
+      hasSolanaWallet: !!nextAuthState.solanaWallet,
+      hasBitcoinWallet: !!nextAuthState.bitcoinWallet,
+      hasTronWallet: !!nextAuthState.tronWallet,
+      generatedSolAddress: genResponse.solAddress || null,
+      generatedBtcAddress: genResponse.btcAddress || null,
+      generatedTrxAddress: genResponse.trxAddress || null
+    });
+    return nextAuthState;
+  } catch (error) {
+    writeBackfillDebug({
+      status: "failed",
+      reason: error instanceof Error ? error.message : "unknown-error"
+    });
+    throw error;
+  }
+}
+
+export {
+  hasMissingBackfillableWallets,
+  backfillMissingWallets
+};

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

@@ -0,0 +1,223 @@
+"use client";
+import {
+  AbcError
+} from "./chunk-4P3SPC44.js";
+import {
+  PIN_CONFIG,
+  STORAGE_PREFIX,
+  TOKEN_EXPIRY
+} from "./chunk-TQXCRSMS.js";
+
+// src/wallets/walletConnectors/abcWallet/utils.ts
+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;
+  const keysToRemove = [];
+  for (let i = 0; i < localStorage.length; i++) {
+    const key = localStorage.key(i);
+    if (key?.startsWith(STORAGE_PREFIX)) {
+      keysToRemove.push(key);
+    }
+  }
+  for (const key of keysToRemove) {
+    localStorage.removeItem(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.tronWallet) {
+    saveToStorage("tron_wallet" /* TRON_WALLET */, state.tronWallet);
+  }
+  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 hydrateAuthStateFromIndividualStorage(state) {
+  const user = loadFromStorage("user" /* USER */);
+  const wallet = loadFromStorage("wallet" /* WALLET */);
+  const solanaWallet = loadFromStorage(
+    "solana_wallet" /* SOLANA_WALLET */
+  );
+  const bitcoinWallet = loadFromStorage(
+    "bitcoin_wallet" /* BITCOIN_WALLET */
+  );
+  const tronWallet = loadFromStorage("tron_wallet" /* TRON_WALLET */);
+  const accessToken = loadFromStorage("access_token" /* ACCESS_TOKEN */);
+  const refreshToken = loadFromStorage("refresh_token" /* REFRESH_TOKEN */);
+  const expiresAt = loadFromStorage("expires_at" /* EXPIRES_AT */);
+  const nextState = {
+    ...state,
+    user: state.user || user || null,
+    wallet: state.wallet || wallet || null,
+    solanaWallet: state.solanaWallet || solanaWallet || null,
+    bitcoinWallet: state.bitcoinWallet || bitcoinWallet || null,
+    tronWallet: state.tronWallet || tronWallet || null,
+    accessToken: state.accessToken || accessToken || null,
+    refreshToken: state.refreshToken || refreshToken || null,
+    expiresAt: state.expiresAt || expiresAt || null
+  };
+  const wasHydrated = nextState.user !== state.user || nextState.wallet !== state.wallet || nextState.solanaWallet !== state.solanaWallet || nextState.bitcoinWallet !== state.bitcoinWallet || nextState.tronWallet !== state.tronWallet || nextState.accessToken !== state.accessToken || nextState.refreshToken !== state.refreshToken || nextState.expiresAt !== state.expiresAt;
+  if (wasHydrated) {
+    saveToStorage("auth_state" /* AUTH_STATE */, nextState);
+  }
+  return nextState;
+}
+function loadAuthState() {
+  const state = loadFromStorage("auth_state" /* AUTH_STATE */);
+  if (state) {
+    if (state.accessToken && isTokenExpired(state.expiresAt)) {
+      clearStorage();
+      return null;
+    }
+    return hydrateAuthStateFromIndividualStorage(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 createAbcError(code, message, details, statusCode) {
+  return new AbcError(code, message, details, statusCode);
+}
+function hexToNumber(hex) {
+  return Number.parseInt(hex, 16);
+}
+function numberToHex(num) {
+  return `0x${num.toString(16)}`;
+}
+
+export {
+  hashPin,
+  validatePin,
+  validateEmail,
+  getStorageKey,
+  saveToStorage,
+  loadFromStorage,
+  removeFromStorage,
+  clearStorage,
+  isTokenExpired,
+  calculateExpiryTimestamp,
+  saveAuthState,
+  loadAuthState,
+  clearAuthState,
+  createAbcError,
+  hexToNumber,
+  numberToHex
+};