@talken/talkenkit 2.4.21 → 2.4.23

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

@@ -0,0 +1,272 @@
+"use client";
+import {
+  calculateExpiryTimestamp,
+  createAbcError,
+  isTokenExpired,
+  loadFromStorage,
+  parseApiError,
+  removeFromStorage,
+  saveToStorage
+} from "./chunk-3AX66UHT.js";
+import {
+  DEFAULT_HEADERS,
+  REQUEST_TIMEOUT
+} from "./chunk-RCIABMG5.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-FGS2WHVA.js

@@ -0,0 +1,118 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-MBRXYEQC.js";
+import {
+  getSolanaNetwork
+} from "./chunk-O4AU63LK.js";
+import {
+  createAbcError
+} from "./chunk-LOSXI36Y.js";
+import {
+  DEFAULT_HEADERS
+} from "./chunk-BR25RFNF.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,
+      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
+};

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

@@ -0,0 +1,91 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-MBRXYEQC.js";
+import {
+  createAbcError
+} from "./chunk-LOSXI36Y.js";
+import {
+  ABC_ENDPOINTS
+} from "./chunk-BR25RFNF.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-FS2OOQYF.js

@@ -0,0 +1,204 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-QD3PPWTN.js";
+import {
+  createAbcError
+} from "./chunk-ZJDZJW55.js";
+
+// src/wallets/walletConnectors/abcWallet/api/AuthApi.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var AuthApi = class extends BaseApiClient {
+  /**
+   * Login with email and password
+   */
+  async loginWithEmail(email, password) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.loginWithPassword(email, password);
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return {
+        uid: res.uid,
+        email: res.email,
+        accessToken: res.accessToken,
+        refreshToken: res.refreshToken,
+        expiresIn: res.expiresIn
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Login with email and OTP
+   * NOTE: OTP login removed from server — use password login instead.
+   * This method kept for backward compatibility, delegates to loginWithEmail.
+   */
+  async loginWithOtp(email, otpCode) {
+    return this.loginWithEmail(email, otpCode);
+  }
+  /**
+   * Login with social provider (Google, Apple, Kakao)
+   * Routes through TalkenApiClient → POST /wallet/auth { action: 'login', method: 'sns' }
+   */
+  async loginWithSocial(provider, token, _email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.loginWithSns({
+        token,
+        service: provider
+      });
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return {
+        uid: res.uid,
+        email: res.email,
+        accessToken: res.accessToken,
+        refreshToken: res.refreshToken,
+        expiresIn: res.expiresIn
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Request OTP code for email
+   */
+  async requestOtpCode(email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.sendOtp(email);
+      return { sent: true, expiresIn: 300 };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Verify OTP code
+   */
+  async verifyOtpCode(email, code) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.verifyOtp(email, code);
+      return true;
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Check if email already exists
+   */
+  async emailCheck(_email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.checkEmail(_email);
+      return {
+        status: "success",
+        message: { code: res.code || 0, text: res.message || "" }
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Send OTP code to email for signup
+   */
+  async sendOtpCode(_email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.sendOtp(_email);
+      return { status: "success", data: { sent: true } };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Verify OTP code for signup
+   */
+  async verifyOtpCodeSignup(email, code) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.verifyOtp(email, code);
+      return {
+        status: "success",
+        data: { verified: true }
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Register new user with password
+   */
+  async registerUser(params) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.register({
+        email: params.username,
+        password: params.password,
+        otpCode: params.emailCode,
+        name: params.name
+      });
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return { status: "success", data: res };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Register new SNS user (email-based registration with OTP, no password)
+   */
+  async registerSnsUser(params) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.register({
+        email: params.username,
+        password: "",
+        otpCode: params.sixCode,
+        name: params.name
+      });
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return { status: "success", data: res };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Reset/Set password for existing user
+   */
+  async resetPassword(params) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.resetPassword(
+        params.username,
+        params.password,
+        params.emailCode
+      );
+      return { status: "success", data: res };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+};
+
+export {
+  AuthApi
+};