@talken/talkenkit 2.4.21 → 2.4.23

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

@@ -0,0 +1,272 @@
+"use client";
+import {
+  calculateExpiryTimestamp,
+  createAbcError,
+  isTokenExpired,
+  loadFromStorage,
+  parseApiError,
+  removeFromStorage,
+  saveToStorage
+} from "./chunk-ZJDZJW55.js";
+import {
+  DEFAULT_HEADERS,
+  REQUEST_TIMEOUT
+} from "./chunk-M2U5QGM7.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.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();
+  }
+};
+
+export {
+  BaseApiClient
+};

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

@@ -0,0 +1,54 @@
+"use client";
+import {
+  abcConnector
+} from "./chunk-AFM6KHDP.js";
+import {
+  createTalkenApiClient
+} from "./chunk-RIJTOH57.js";
+import {
+  resolveTalkenApiUrl
+} from "./chunk-GFWUFYT2.js";
+import {
+  ABC_WALLET_METADATA
+} from "./chunk-TQXCRSMS.js";
+
+// src/wallets/walletConnectors/abcWallet/abcWallet.ts
+import { setTalkenApiClient } from "@talken/talkenkit";
+var abcWallet = (specificOptions) => ({ projectId }) => {
+  const talkenApiUrl = resolveTalkenApiUrl(specificOptions?.talkenApiUrl);
+  const talkenApi = createTalkenApiClient({
+    baseUrl: talkenApiUrl,
+    debug: specificOptions?.environment === "development"
+  });
+  setTalkenApiClient(talkenApi);
+  const config = {
+    talkenApiUrl,
+    apiKey: specificOptions?.apiKey,
+    plain: specificOptions?.plain || "",
+    // Deprecated - not used (secure.ts uses random generation)
+    environment: specificOptions?.environment || "development",
+    defaultChainId: specificOptions?.defaultChainId,
+    defaultSolanaNetwork: specificOptions?.defaultSolanaNetwork,
+    defaultBitcoinNetwork: specificOptions?.defaultBitcoinNetwork,
+    projectId
+  };
+  return {
+    id: ABC_WALLET_METADATA.id,
+    name: ABC_WALLET_METADATA.name,
+    rdns: ABC_WALLET_METADATA.rdns,
+    iconUrl: async () => (await import("./abcWallet-AYWSIGAG.js")).default,
+    iconBackground: ABC_WALLET_METADATA.iconBackground,
+    // Embedded wallet - no installation required
+    installed: void 0,
+    // No download URLs for embedded wallet
+    downloadUrls: void 0,
+    // Create connector - wrapper function required by Wallet type
+    createConnector: (_walletDetails) => abcConnector({ config }),
+    // Embedded wallet always available
+    hidden: () => false
+  };
+};
+
+export {
+  abcWallet
+};

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

@@ -0,0 +1,15 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/api/TalkenApiSingleton.ts
+var _instance;
+function setTalkenApiClient(client) {
+  _instance = client;
+}
+function getTalkenApiClient() {
+  return _instance;
+}
+
+export {
+  setTalkenApiClient,
+  getTalkenApiClient
+};

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

@@ -0,0 +1,259 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/constants.ts
+var DEFAULT_ABC_CONFIG = {
+  environment: "development",
+  waasUrl: ""
+  // All operations routed through TalkenApiClient
+};
+var TOKEN_EXPIRY = {
+  ACCESS_TOKEN: 10 * 60 * 1e3,
+  // 10 minutes
+  REFRESH_TOKEN: 60 * 60 * 1e3,
+  // 60 minutes
+  REFRESH_BUFFER: 60 * 1e3
+  // Refresh 60s before expiry (increased for network latency tolerance)
+};
+var ABC_ENDPOINTS = {
+  // Authentication
+  SNS_LOGIN: "/abc/snsLogin",
+  // Legacy - may need to update
+  REGISTER_SNS_USER: "/abc/registerSnsUser",
+  // Legacy - may need to update
+  // Secure channel
+  SECURE_CHANNEL_CREATE: "/secure/channel/create",
+  // Email OTP
+  SEND_OTP: "/member/mail-service/{email}/sendcode",
+  // {email} placeholder
+  VERIFY_OTP: "/member/mail-service/{email}/verifycode",
+  // {email} placeholder
+  // Wallet operations (EVM)
+  // Based on tg-wallet-frontend reference
+  MPC_WALLETS: "/wapi/v2/mpc/wallets",
+  // EVM wallet generation/recovery
+  MPC_WALLETS_INFO: "/wapi/v2/mpc/wallets/info",
+  // Get wallet info
+  // Signing operations
+  // Based on tg-wallet-frontend reference implementation
+  SIGN_HASH: "/wapi/v2/sign/hash",
+  // Personal sign with hash (EIP-191)
+  SIGN_TYPED: "/wapi/v2/sign/typed-data",
+  // Typed data sign (EIP-712)
+  SIGN_TRANSACTION: "/wapi/v2/sign",
+  // EVM transaction sign (LEGACY, EIP1559, PERSONAL)
+  // Transaction operations
+  SEND_RAW_TX: "/wapi/v2/transactions/raw-tx/send",
+  // Send signed transaction
+  TRANSACTION_COUNT: "/wapi/v2/transactions/count",
+  // Get transaction count (nonce)
+  // Gas estimation and fee data
+  GAS_SUGGESTED_FEES: "/wapi/v2/gas/suggestedGasFees",
+  // Get suggested gas fees for EIP-1559
+  GAS_ESTIMATE_EIP1559: "/wapi/v2/gas/estimate/eip1559",
+  // Estimate gas limit for EIP-1559
+  // Token info (Walletscan)
+  WALLETSCAN_TOKEN: "/wapi/v2/walletscan/token",
+  // GET /{contractAddress}?networks=xxx
+  WALLETSCAN_NATIVES: "/wapi/v2/walletscan/natives",
+  // GET ?walletAddress=xxx&networks=xxx
+  WALLETSCAN_NFTS: "/wapi/v2/walletscan/nfts",
+  // GET /{contractAddress}?walletAddress=xxx&networks=xxx
+  // Token refresh (based on tg-wallet-frontend reference)
+  REFRESH_TOKEN: "/abc/abcRefresh",
+  // Token refresh endpoint
+  // Legacy endpoints (kept for compatibility)
+  WALLETS_V3: "/abc/wallets/v3",
+  // Solana only
+  INFO: "/abc/info"
+};
+var AUTH_PROVIDERS = {
+  EMAIL: "email",
+  GOOGLE: "google",
+  APPLE: "apple",
+  TELEGRAM: "telegram",
+  TWITTER: "twitter"
+};
+var CHAIN_TYPES = {
+  EVM: "evm",
+  SOLANA: "solana",
+  BITCOIN: "bitcoin"
+};
+var SOLANA_CHAIN_ID = 900;
+var BITCOIN_CHAIN_ID = 800;
+var EVM_CHAINS = {
+  ETHEREUM_MAINNET: 1,
+  ETHEREUM_GOERLI: 5,
+  ETHEREUM_SEPOLIA: 11155111,
+  POLYGON_MAINNET: 137,
+  POLYGON_MUMBAI: 80001,
+  BSC_MAINNET: 56,
+  BSC_TESTNET: 97,
+  ARBITRUM_MAINNET: 42161,
+  ARBITRUM_GOERLI: 421613,
+  OPTIMISM_MAINNET: 10,
+  OPTIMISM_GOERLI: 420,
+  AVALANCHE_MAINNET: 43114,
+  AVALANCHE_FUJI: 43113,
+  KLAYTN_MAINNET: 8217,
+  KLAYTN_BAOBAB: 1001
+};
+var ABC_AUDIENCE = "https://mw.myabcwallet.com";
+var PIN_CONFIG = {
+  MIN_LENGTH: 6,
+  MAX_LENGTH: 6,
+  MAX_ATTEMPTS: 5,
+  LOCKOUT_DURATION: 15 * 60 * 1e3
+  // 15 minutes
+};
+var STORAGE_VERSION = "1.0.0";
+var REQUEST_TIMEOUT = 3e4;
+var RETRY_CONFIG = {
+  MAX_RETRIES: 3,
+  RETRY_DELAY: 1e3,
+  // 1 second
+  BACKOFF_MULTIPLIER: 2
+};
+var ABC_WALLET_METADATA = {
+  id: "abc",
+  name: "ABC Wallet",
+  iconBackground: "#ffffff",
+  rdns: "com.abcwallet"
+};
+var MODAL_CONFIG = {
+  WIDTH: 400,
+  MAX_WIDTH: "90vw",
+  BORDER_RADIUS: 16,
+  PADDING: 24
+};
+var SOCIAL_BUTTONS = [
+  {
+    provider: AUTH_PROVIDERS.GOOGLE,
+    label: "Google",
+    iconName: "google"
+  },
+  {
+    provider: AUTH_PROVIDERS.APPLE,
+    label: "Apple",
+    iconName: "apple"
+  },
+  {
+    provider: AUTH_PROVIDERS.TELEGRAM,
+    label: "Telegram",
+    iconName: "telegram"
+  },
+  {
+    provider: AUTH_PROVIDERS.TWITTER,
+    label: "X (Twitter)",
+    iconName: "twitter"
+  }
+];
+var ERROR_MESSAGES = {
+  INVALID_CREDENTIALS: "Invalid email or password",
+  TOKEN_EXPIRED: "Your session has expired. Please login again.",
+  WALLET_NOT_FOUND: "Wallet not found. Please create a new wallet.",
+  INVALID_PIN: "Invalid PIN code",
+  NETWORK_ERROR: "Network error. Please check your connection.",
+  SIGNATURE_FAILED: "Failed to sign transaction",
+  USER_CANCELLED: "User cancelled the operation",
+  UNKNOWN_ERROR: "An unknown error occurred",
+  INVALID_OTP: "Invalid or expired OTP code",
+  EMAIL_REQUIRED: "Email address is required",
+  PIN_REQUIRED: "PIN code is required",
+  WALLET_GENERATION_FAILED: "Failed to generate wallet"
+};
+var SUCCESS_MESSAGES = {
+  LOGIN_SUCCESS: "Successfully logged in",
+  WALLET_CREATED: "Wallet created successfully",
+  TRANSACTION_SENT: "Transaction sent successfully",
+  OTP_SENT: "OTP code sent to your email"
+};
+var ABC_EVENTS = {
+  CONNECT: "abc:connect",
+  DISCONNECT: "abc:disconnect",
+  ACCOUNTS_CHANGED: "abc:accountsChanged",
+  CHAIN_CHANGED: "abc:chainChanged",
+  ERROR: "abc:error",
+  AUTH_STATE_CHANGED: "abc:authStateChanged"
+};
+var STORAGE_PREFIX = "talkenkit_abc_";
+var DEBUG_MODE = true;
+var DEFAULT_HEADERS = {
+  "Content-Type": "application/x-www-form-urlencoded",
+  Accept: "application/json"
+};
+var ABC_FEATURES = {
+  EMAIL_LOGIN: true,
+  SOCIAL_LOGIN: true,
+  MULTI_CHAIN: true,
+  EVM_SUPPORT: true,
+  SOLANA_SUPPORT: true,
+  BITCOIN_SUPPORT: false,
+  // Future feature
+  GASLESS_TRANSACTIONS: false,
+  // Future feature
+  SOCIAL_RECOVERY: false
+  // Future feature
+};
+var DEFAULT_TALKEN_API_CONFIG = {
+  baseUrl: void 0,
+  timeout: REQUEST_TIMEOUT
+};
+var TALKEN_API_ENDPOINTS = {
+  // ── Auth (single action-based endpoint) ─────────────────────────────
+  AUTH: "/wallet/auth",
+  // ── Wallet ──────────────────────────────────────────────────────────
+  WALLET_MPC: "/wallet/mpc",
+  WALLET_ADDRESS: "/wallet/address",
+  WALLET_SCAN: "/wallet/scan",
+  WALLET_BTC: "/wallet/btc",
+  // ── EVM Sign (WaaS proxy) ───────────────────────────────────────────
+  SIGN_EVM: "/wallet/sign/evm",
+  SIGN_TYPED: "/wallet/sign/typed",
+  SIGN_PERSONAL: "/wallet/sign/personal",
+  // ── Hash Sign (secp256k1, universal: EVM/BTC/TVM) ───────────────────
+  SIGN_HASH: "/wallet/sign/hash",
+  // ── SOL Sign (WaaS proxy) ───────────────────────────────────────────
+  SIGN_SVM: "/wallet/sign/sol",
+  // ── TX ──────────────────────────────────────────────────────────────
+  TX_RAW: "/wallet/tx/raw",
+  TX_EVM: "/wallet/tx/evm",
+  TX_SOL: "/wallet/tx/sol",
+  TX_BTC: "/wallet/tx/btc",
+  TX_TVM: "/wallet/tx/tvm",
+  // ── Gas (WaaS proxy) ───────────────────────────────────────────────
+  GAS_PRICE: "/wallet/gas/price",
+  GAS_SUGGESTED: "/wallet/gas/suggested",
+  GAS_ESTIMATE: "/wallet/gas/estimate",
+  // ── Nonce (WaaS proxy) ─────────────────────────────────────────────
+  NONCE: "/wallet/nonce",
+  // ── Relayer ────────────────────────────────────────────────────────
+  RELAYER_FEE_ESTIMATE: "/relayer/estimate-fee"
+};
+
+export {
+  DEFAULT_ABC_CONFIG,
+  TOKEN_EXPIRY,
+  ABC_ENDPOINTS,
+  AUTH_PROVIDERS,
+  CHAIN_TYPES,
+  SOLANA_CHAIN_ID,
+  BITCOIN_CHAIN_ID,
+  EVM_CHAINS,
+  ABC_AUDIENCE,
+  PIN_CONFIG,
+  STORAGE_VERSION,
+  REQUEST_TIMEOUT,
+  RETRY_CONFIG,
+  ABC_WALLET_METADATA,
+  MODAL_CONFIG,
+  SOCIAL_BUTTONS,
+  ERROR_MESSAGES,
+  SUCCESS_MESSAGES,
+  ABC_EVENTS,
+  STORAGE_PREFIX,
+  DEBUG_MODE,
+  DEFAULT_HEADERS,
+  ABC_FEATURES,
+  DEFAULT_TALKEN_API_CONFIG,
+  TALKEN_API_ENDPOINTS
+};

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

@@ -0,0 +1,71 @@
+"use client";
+import {
+  TransactionApi
+} from "./chunk-BXQ2UWJ3.js";
+import {
+  TronApi
+} from "./chunk-3BVPV64G.js";
+import {
+  WalletApi
+} from "./chunk-7EEPPULA.js";
+import {
+  WalletscanApi
+} from "./chunk-BOV5FXU6.js";
+import {
+  AuthApi
+} from "./chunk-FS2OOQYF.js";
+import {
+  GasApi
+} from "./chunk-M73AWLIV.js";
+import {
+  BitcoinApi
+} from "./chunk-G5X3COSW.js";
+import {
+  SolanaApi
+} from "./chunk-MNZZRFUC.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
+};