@talken/talkenkit 2.3.14 → 2.3.15

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

@@ -0,0 +1,309 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-H2MX4NAL.js";
+import {
+  createAbcError
+} from "./chunk-UV5HHESJ.js";
+import {
+  ABC_AUDIENCE,
+  ABC_ENDPOINTS
+} from "./chunk-VETRBBA2.js";
+
+// src/wallets/walletConnectors/abcWallet/api/AuthApi.ts
+var AuthApi = class extends BaseApiClient {
+  /**
+   * Login with email and password
+   */
+  async loginWithEmail(email, password) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SNS_LOGIN,
+      {
+        method: "POST",
+        body: {
+          email,
+          token: password,
+          service: "email",
+          audience: ABC_AUDIENCE
+        },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      this.saveTokens(
+        response.data.accessToken,
+        response.data.refreshToken,
+        response.data.expiresIn
+      );
+      return response.data;
+    }
+    throw createAbcError(
+      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+      "Email login failed",
+      response
+    );
+  }
+  /**
+   * Login with email and OTP (for PIN recovery)
+   */
+  async loginWithOtp(email, otpCode) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SNS_LOGIN,
+      {
+        method: "POST",
+        body: {
+          email,
+          token: otpCode,
+          service: "email",
+          audience: ABC_AUDIENCE
+        },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      this.saveTokens(
+        response.data.accessToken,
+        response.data.refreshToken,
+        response.data.expiresIn
+      );
+      return response.data;
+    }
+    throw createAbcError(
+      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+      "OTP login failed",
+      response
+    );
+  }
+  /**
+   * Login with social provider
+   */
+  async loginWithSocial(provider, token, email) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SNS_LOGIN,
+      {
+        method: "POST",
+        body: {
+          token,
+          service: provider,
+          audience: ABC_AUDIENCE,
+          email
+        },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      this.saveTokens(
+        response.data.accessToken,
+        response.data.refreshToken,
+        response.data.expiresIn
+      );
+      return response.data;
+    }
+    throw createAbcError(
+      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+      "Social login failed",
+      response
+    );
+  }
+  /**
+   * Request OTP code for email
+   */
+  async requestOtpCode(email) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SEND_OTP,
+      {
+        method: "POST",
+        body: { email },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      return response.data;
+    }
+    throw createAbcError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      "Failed to request OTP",
+      response
+    );
+  }
+  /**
+   * Verify OTP code
+   */
+  async verifyOtpCode(email, code) {
+    const response = await this.request(ABC_ENDPOINTS.VERIFY_OTP, {
+      method: "POST",
+      body: { email, code },
+      skipAuth: true
+    });
+    return response.status === "success";
+  }
+  /**
+   * Check if email already exists
+   */
+  async emailCheck(_email) {
+    const _talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+    const url = `${_talkenApiUrl}/abc/emailCheck?email=${encodeURIComponent(_email)}`;
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" }
+      });
+      const text = await response.text();
+      const data = text ? JSON.parse(text) : { status: "success" };
+      if (!response.ok) {
+        throw createAbcError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Email check failed",
+          data
+        );
+      }
+      return data;
+    } catch (error) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Email check failed",
+        error
+      );
+    }
+  }
+  /**
+   * Send OTP code to email for signup
+   */
+  async sendOtpCode(_email) {
+    const endpoint = "/member/mail-service/${encodeURIComponent(email)}/sendcode";
+    const response = await this.request(endpoint, {
+      method: "GET",
+      skipAuth: true
+    });
+    if (response.status === "success") {
+      return response;
+    }
+    throw createAbcError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      "Failed to send OTP code",
+      response
+    );
+  }
+  /**
+   * Verify OTP code for signup
+   */
+  async verifyOtpCodeSignup(email, code) {
+    const endpoint = "/member/mail-service/${encodeURIComponent(email)}/verifycode";
+    const requestBody = {
+      email,
+      code,
+      serviceid: ABC_AUDIENCE
+    };
+    const response = await this.request(endpoint, {
+      method: "POST",
+      body: requestBody,
+      skipAuth: true
+    });
+    const isSuccess = response.status === "success" || response.status === 200 || response.message === "success";
+    if (isSuccess) {
+      return response;
+    }
+    throw createAbcError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      "Invalid or expired OTP code",
+      response
+    );
+  }
+  /**
+   * Register new user
+   */
+  async registerUser(params) {
+    const _talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+    const url = "${talkenApiUrl}/abc/adduser";
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        credentials: "include",
+        body: new URLSearchParams(params).toString()
+      });
+      const text = await response.text();
+      const data = text ? JSON.parse(text) : { status: "success" };
+      if (!response.ok) {
+        throw createAbcError(
+          "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+          "User registration failed",
+          data
+        );
+      }
+      return data;
+    } catch (error) {
+      throw createAbcError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "User registration failed",
+        error
+      );
+    }
+  }
+  /**
+   * Register new SNS user (email-based registration with OTP)
+   */
+  async registerSnsUser(params) {
+    const _talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+    const url = "${talkenApiUrl}/abc/snsAdduser";
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        credentials: "include",
+        body: new URLSearchParams(params).toString()
+      });
+      const text = await response.text();
+      const data = text ? JSON.parse(text) : { status: "success" };
+      if (!response.ok) {
+        throw createAbcError(
+          "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+          "SNS user registration failed",
+          data
+        );
+      }
+      return data;
+    } catch (error) {
+      throw createAbcError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "SNS user registration failed",
+        error
+      );
+    }
+  }
+  /**
+   * Reset/Set password for existing user
+   */
+  async resetPassword(params) {
+    const _talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+    const url = "${talkenApiUrl}/abc/initpassword";
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        credentials: "include",
+        body: new URLSearchParams(params).toString()
+      });
+      const text = await response.text();
+      const data = text ? JSON.parse(text) : { status: "success" };
+      if (!response.ok) {
+        throw createAbcError(
+          "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+          "Password reset failed",
+          data
+        );
+      }
+      return data;
+    } catch (error) {
+      throw createAbcError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "Password reset failed",
+        error
+      );
+    }
+  }
+};
+
+export {
+  AuthApi
+};

package/dist/wallets/walletConnectors/{chunk-XZHB7HU4.js → chunk-GHLLVM7O.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-UV5HHESJ.js";
 import {
   getSolanaNetwork
-} from "./chunk-VZCI2K6Y.js";
+} from "./chunk-A7FIBI6X.js";
 
 // src/wallets/walletConnectors/abcWallet/api/SolanaApi.ts
 var SolanaApi = class extends BaseApiClient {

package/dist/wallets/walletConnectors/{chunk-2XFKRGDK.js → chunk-GXGRTWJM.js}

@@ -1,22 +1,22 @@
 "use client";
-import {
-  SolanaApi
-} from "./chunk-SGLHM6AU.js";
 import {
   WalletApi
-} from "./chunk-F5Q4VDER.js";
+} from "./chunk-EGOIRXTV.js";
 import {
-  TransactionApi
-} from "./chunk-ISAMATTH.js";
+  BitcoinApi
+} from "./chunk-QKUFFUM5.js";
 import {
   AuthApi
 } from "./chunk-YEHCPL4R.js";
-import {
-  BitcoinApi
-} from "./chunk-QKUFFUM5.js";
 import {
   SigningApi
-} from "./chunk-V3XKL7AD.js";
+} from "./chunk-KKPINUPY.js";
+import {
+  SolanaApi
+} from "./chunk-7DEZCGNV.js";
+import {
+  TransactionApi
+} from "./chunk-ISAMATTH.js";
 
 // src/wallets/walletConnectors/abcWallet/api/index.ts
 var AbcWaasApiClient = class {

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

@@ -0,0 +1,293 @@
+"use client";
+import {
+  secure_default
+} from "./chunk-G2LI5MVX.js";
+import {
+  calculateExpiryTimestamp,
+  createAbcError,
+  isTokenExpired,
+  loadFromStorage,
+  parseApiError,
+  removeFromStorage,
+  saveToStorage
+} from "./chunk-UV5HHESJ.js";
+import {
+  ABC_ENDPOINTS,
+  DEFAULT_HEADERS,
+  REQUEST_TIMEOUT
+} from "./chunk-VETRBBA2.js";
+
+// src/wallets/walletConnectors/abcWallet/api/BaseApiClient.ts
+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 */);
+  }
+  /**
+   * 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
+   */
+  async refreshAccessToken() {
+    if (this.isRefreshing) {
+      if (this.refreshPromise) {
+        await this.refreshPromise;
+      }
+      return;
+    }
+    if (!this.refreshToken) {
+      throw createAbcError(
+        "TOKEN_EXPIRED" /* TOKEN_EXPIRED */,
+        "No refresh token available"
+      );
+    }
+    this.isRefreshing = true;
+    this.refreshPromise = (async () => {
+      try {
+        const isIframe = typeof window !== "undefined" && window.self !== window.top;
+        const talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+        const isProd = this.config.environment === "production";
+        const headers = { ...DEFAULT_HEADERS };
+        if (isProd) {
+          headers["X-Client-Type"] = "Android";
+        }
+        const response = await fetch(
+          `${talkenApiUrl}${ABC_ENDPOINTS.REFRESH_TOKEN}`,
+          {
+            method: "POST",
+            headers,
+            credentials: "include",
+            body: new URLSearchParams({
+              refresh_token: this.refreshToken || "",
+              isIframe: String(isIframe)
+            }).toString()
+          }
+        );
+        const text = await response.text();
+        const data = text ? JSON.parse(text) : {};
+        if (response.ok && data.access_token) {
+          const expiresIn = data.expire_in || 3600;
+          this.saveTokens(
+            data.access_token,
+            data.refresh_token || this.refreshToken,
+            expiresIn
+          );
+        } else {
+          throw createAbcError(
+            "TOKEN_EXPIRED" /* TOKEN_EXPIRED */,
+            "Failed to refresh token"
+          );
+        }
+      } finally {
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+      }
+    })();
+    await this.refreshPromise;
+  }
+  /**
+   * 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["X-Client-Type"] = "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) {
+        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) {
+      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-75NE2OUD.js → chunk-HVPQO6ZG.js}

@@ -1,10 +1,15 @@
 "use client";
 import {
   createAbcWaasClient
-} from "./chunk-LOP2R3QJ.js";
+} from "./chunk-JR2C4XXX.js";
 import {
   createAbcEvmProvider
 } from "./chunk-ZIYAL44B.js";
+import {
+  setGlobalDefaultBitcoinNetwork,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork
+} from "./chunk-A7FIBI6X.js";
 import {
   clearAuthState,
   clearEncryptedTokens,
@@ -18,6 +23,15 @@ import {
 import { createConnector } from "wagmi";
 function abcConnector(options) {
   const { config } = options;
+  if (config.defaultChainId) {
+    setGlobalDefaultChainId(config.defaultChainId);
+  }
+  if (config.defaultSolanaNetwork) {
+    setGlobalDefaultSolanaNetwork(config.defaultSolanaNetwork);
+  }
+  if (config.defaultBitcoinNetwork) {
+    setGlobalDefaultBitcoinNetwork(config.defaultBitcoinNetwork);
+  }
   return createConnector((wagmiConfig) => {
     const client = createAbcWaasClient(config);
     const provider = createAbcEvmProvider(client);
@@ -46,6 +60,7 @@ function abcConnector(options) {
           provider.setWallet(authState.wallet);
           console.log("\u2705 Provider wallet set:", {
             address: authState.wallet.address,
+            chainId: authState.wallet.chainId,
             hasPIN: !!authState.pin
           });
           const accounts = await provider.request({