@talken/talkenkit 2.3.4 → 2.3.6

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

@@ -0,0 +1,285 @@
+"use client";
+import {
+  secure_default
+} from "./chunk-G2LI5MVX.js";
+import {
+  calculateExpiryTimestamp,
+  createAbcError,
+  isTokenExpired,
+  loadFromStorage,
+  parseApiError,
+  removeFromStorage,
+  saveToStorage
+} from "./chunk-W2VDZD74.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 response = await fetch(
+          `${talkenApiUrl}${ABC_ENDPOINTS.REFRESH_TOKEN}`,
+          {
+            method: "POST",
+            headers: DEFAULT_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 (!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-WPHTIILX.js

@@ -0,0 +1,228 @@
+"use client";
+import {
+  createAbcWaasClient
+} from "./chunk-R4UYVU5X.js";
+import {
+  createAbcEvmProvider
+} from "./chunk-XYPR4BAF.js";
+import {
+  clearAuthState,
+  clearEncryptedTokens,
+  loadAuthState,
+  saveAuthState
+} from "./chunk-W2VDZD74.js";
+
+// src/wallets/walletConnectors/abcWallet/abcConnector.ts
+import { createConnector } from "wagmi";
+function abcConnector(options) {
+  const { config } = options;
+  return createConnector((wagmiConfig) => {
+    const client = createAbcWaasClient(config);
+    const provider = createAbcEvmProvider(client);
+    let accountsChangedHandler;
+    let chainChangedHandler;
+    let disconnectHandler;
+    return {
+      id: "abc",
+      name: "ABC Wallet",
+      type: "abc",
+      /**
+       * Connect wallet
+       */
+      async connect() {
+        try {
+          const authState = loadAuthState();
+          console.log("\u{1F527} ABC Connector connect() called:", {
+            hasAuthState: !!authState,
+            isAuthenticated: authState?.isAuthenticated,
+            hasWallet: !!authState?.wallet,
+            walletAddress: authState?.wallet?.address
+          });
+          if (!authState || !authState.isAuthenticated || !authState.wallet) {
+            throw new Error("ABC_LOGIN_REQUIRED");
+          }
+          provider.setWallet(authState.wallet);
+          console.log("\u2705 Provider wallet set:", {
+            address: authState.wallet.address,
+            hasPIN: !!authState.pin
+          });
+          const accounts = await provider.request({
+            method: "eth_requestAccounts"
+          });
+          const currentChainId = await provider.request({
+            method: "eth_chainId"
+          });
+          if (accountsChangedHandler) {
+            provider.removeListener("accountsChanged", accountsChangedHandler);
+          }
+          accountsChangedHandler = (accounts2) => {
+            wagmiConfig.emitter.emit("change", {
+              accounts: accounts2
+            });
+          };
+          provider.on("accountsChanged", accountsChangedHandler);
+          if (chainChangedHandler) {
+            provider.removeListener("chainChanged", chainChangedHandler);
+          }
+          chainChangedHandler = (chainId) => {
+            wagmiConfig.emitter.emit("change", {
+              chainId: Number(chainId)
+            });
+          };
+          provider.on("chainChanged", chainChangedHandler);
+          if (disconnectHandler) {
+            provider.removeListener("disconnect", disconnectHandler);
+          }
+          disconnectHandler = () => {
+            wagmiConfig.emitter.emit("disconnect");
+            this.onDisconnect();
+          };
+          provider.on("disconnect", disconnectHandler);
+          return {
+            accounts,
+            chainId: Number(currentChainId)
+          };
+        } catch (error) {
+          if (error.message === "ABC_LOGIN_REQUIRED") {
+            throw error;
+          }
+          throw error;
+        }
+      },
+      /**
+       * Disconnect wallet
+       */
+      async disconnect() {
+        if (accountsChangedHandler) {
+          provider.removeListener("accountsChanged", accountsChangedHandler);
+          accountsChangedHandler = void 0;
+        }
+        if (chainChangedHandler) {
+          provider.removeListener("chainChanged", chainChangedHandler);
+          chainChangedHandler = void 0;
+        }
+        if (disconnectHandler) {
+          provider.removeListener("disconnect", disconnectHandler);
+          disconnectHandler = void 0;
+        }
+        provider.clearWallet();
+        await client.logout();
+        let savedPinHash = null;
+        let savedEmail = null;
+        if (typeof window !== "undefined") {
+          savedPinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+          savedEmail = localStorage.getItem("talkenkit_abc_saved_email");
+        }
+        clearAuthState();
+        clearEncryptedTokens();
+        if (typeof window !== "undefined") {
+          localStorage.removeItem("talkenkit_abc_enc_salt");
+          localStorage.removeItem("talkenkit_abc_enc_tokens");
+          if (savedPinHash) {
+            localStorage.setItem("talkenkit_abc_pin_hash", savedPinHash);
+          }
+          if (savedEmail) {
+            localStorage.setItem("talkenkit_abc_saved_email", savedEmail);
+          }
+        }
+        console.log("\u2705 ABC Wallet disconnected (PIN preserved)");
+      },
+      /**
+       * Get accounts
+       */
+      async getAccounts() {
+        const accounts = await provider.request({
+          method: "eth_accounts"
+        });
+        return accounts.map((account) => account);
+      },
+      /**
+       * Get chain ID
+       */
+      async getChainId() {
+        const chainId = await provider.request({
+          method: "eth_chainId"
+        });
+        return Number(chainId);
+      },
+      /**
+       * Get provider
+       */
+      async getProvider() {
+        return provider;
+      },
+      /**
+       * Check if authorized (has valid session)
+       */
+      async isAuthorized() {
+        try {
+          const authState = loadAuthState();
+          if (!authState || !authState.isAuthenticated) {
+            return false;
+          }
+          return client.isAuthenticated();
+        } catch {
+          return false;
+        }
+      },
+      /**
+       * Switch chain
+       */
+      async switchChain({ chainId }) {
+        await provider.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId: `0x${chainId.toString(16)}` }]
+        });
+        const newChainId = await this.getChainId();
+        const authState = loadAuthState();
+        if (authState?.wallet) {
+          authState.wallet.chainId = newChainId;
+          saveAuthState(authState);
+        }
+        return wagmiConfig.chains.find((x) => x.id === chainId) ?? {
+          id: chainId,
+          name: `Chain ${chainId}`,
+          nativeCurrency: {
+            name: "Ether",
+            decimals: 18,
+            symbol: "ETH"
+          },
+          rpcUrls: {
+            default: { http: [""] }
+          }
+        };
+      },
+      /**
+       * Handle accounts changed
+       */
+      onAccountsChanged(accounts) {
+        if (accounts.length === 0) {
+          this.onDisconnect();
+        } else {
+          wagmiConfig.emitter.emit("change", {
+            accounts
+          });
+        }
+      },
+      /**
+       * Handle chain changed
+       */
+      onChainChanged(chain) {
+        const chainId = Number(chain);
+        wagmiConfig.emitter.emit("change", { chainId });
+      },
+      /**
+       * Handle disconnect
+       */
+      onDisconnect(_error) {
+        provider.clearWallet();
+        clearAuthState();
+        wagmiConfig.emitter.emit("disconnect");
+      }
+    };
+  });
+}
+
+export {
+  abcConnector
+};