@talken/talkenkit 2.3.14 → 2.4.4

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

@@ -0,0 +1,272 @@
+"use client";
+import {
+  createAbcEvmProvider
+} from "./chunk-2NVHWZUE.js";
+import {
+  createAbcWaasClient
+} from "./chunk-7MOCKWA7.js";
+import {
+  setGlobalDefaultBitcoinNetwork,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork
+} from "./chunk-2GNL2GNB.js";
+import {
+  clearAuthState,
+  clearEncryptedTokens,
+  clearStorage,
+  loadAuthState,
+  loadFromStorage,
+  saveAuthState
+} from "./chunk-5RSS3SRV.js";
+
+// src/wallets/walletConnectors/abcWallet/abcConnector.ts
+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);
+    let accountsChangedHandler;
+    let chainChangedHandler;
+    let disconnectHandler;
+    return {
+      id: "abc",
+      name: "ABC Wallet",
+      type: "abc",
+      /**
+       * Connect wallet
+       */
+      async connect() {
+        try {
+          const authState = loadAuthState();
+          if (!authState || !authState.isAuthenticated || !authState.wallet) {
+            throw new Error("ABC_LOGIN_REQUIRED");
+          }
+          provider.setWallet(authState.wallet);
+          if (authState.accessToken && authState.refreshToken && authState.expiresAt) {
+            client.setTokens(authState.accessToken, authState.refreshToken, authState.expiresAt);
+          }
+          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);
+          wagmiConfig.emitter.emit("connect", {
+            accounts,
+            chainId: Number(currentChainId)
+          });
+          return {
+            accounts,
+            chainId: Number(currentChainId)
+          };
+        } catch (error) {
+          console.error("\u274C ABC Connector connect() failed:", {
+            message: error.message,
+            code: error.code,
+            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)
+       * Auto-refreshes access token if expired but refresh token is valid
+       */
+      async isAuthorized() {
+        try {
+          const authState = loadAuthState();
+          if (!authState || !authState.isAuthenticated) {
+            return false;
+          }
+          if (!authState.wallet) {
+            return false;
+          }
+          if (client.isAuthenticated()) {
+            return true;
+          }
+          const refreshToken = loadFromStorage(
+            "refresh_token" /* REFRESH_TOKEN */
+          );
+          if (!refreshToken) {
+            clearStorage();
+            return false;
+          }
+          try {
+            await client.refreshTokens(refreshToken);
+            const updatedState = loadAuthState();
+            return updatedState?.isAuthenticated ?? false;
+          } catch (error) {
+            console.error("[AbcConnector] Token refresh failed:", error);
+            clearStorage();
+            return false;
+          }
+        } catch (error) {
+          console.error(
+            "[AbcConnector] Unexpected error in isAuthorized:",
+            error
+          );
+          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
+};

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

@@ -0,0 +1,306 @@
+"use client";
+import {
+  secure_default
+} from "./chunk-NDYGTKP5.js";
+import {
+  calculateExpiryTimestamp,
+  createAbcError,
+  isTokenExpired,
+  loadFromStorage,
+  parseApiError,
+  removeFromStorage,
+  saveToStorage
+} from "./chunk-5RSS3SRV.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 */);
+  }
+  /**
+   * 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
+   */
+  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["User-Agent"] = "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["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();
+  }
+  /**
+   * Get secure service instance
+   */
+  getSecureService() {
+    return this.secure;
+  }
+};
+
+export {
+  BaseApiClient
+};

package/dist/wallets/walletConnectors/{chunk-6KO5WQ5C.js → chunk-MPNSYA4E.js}

@@ -1,13 +1,13 @@
 "use client";
 import {
   BaseApiClient
-} from "./chunk-WAO3KL5U.js";
+} from "./chunk-LQ2U33WM.js";
 import {
   getSolanaNetwork
-} from "./chunk-VZCI2K6Y.js";
+} from "./chunk-A7FIBI6X.js";
 import {
   createAbcError
-} from "./chunk-W2VDZD74.js";
+} from "./chunk-TYUEB4VT.js";
 import {
   ABC_ENDPOINTS,
   DEFAULT_HEADERS

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

@@ -0,0 +1,63 @@
+"use client";
+import {
+  TransactionApi
+} from "./chunk-HFC4AK72.js";
+import {
+  AuthApi
+} from "./chunk-ZQLQELFC.js";
+import {
+  BitcoinApi
+} from "./chunk-M7KXDTM6.js";
+import {
+  SigningApi
+} from "./chunk-HTD7IRKM.js";
+import {
+  WalletApi
+} from "./chunk-MKAXMNZM.js";
+import {
+  SolanaApi
+} from "./chunk-NUJ6VD2U.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.signing = new SigningApi(config);
+    this.solana = new SolanaApi(config);
+    this.bitcoin = new BitcoinApi(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-G2LI5MVX.js → chunk-NDYGTKP5.js}

@@ -24,7 +24,6 @@ var SecureService = class {
     const pubkey = myKey.getPublic().encode("hex", false);
     const url = `${this.baseURL}${ABC_ENDPOINTS.SECURE_CHANNEL_CREATE}`;
     const bodyString = new URLSearchParams({ pubkey, plain }).toString();
-    console.log("[SecureChannel] Creating secure channel:", url);
     const response = await fetch(url, {
       method: "POST",
       headers: {
@@ -43,7 +42,6 @@ var SecureService = class {
       );
     }
     const res = await response.json();
-    console.log("[SecureChannel] API Response:", res);
     const resData = res;
     if (resData.channelid && resData.publickey) {
       const serverKey = ec.keyFromPublic(resData.publickey, "hex");