@talken/talkenkit 2.5.2 → 2.5.3

package/dist/wallets/walletConnectors/{chunk-2A5XTST5.js → chunk-OOCL4OPQ.js}

@@ -1,4 +1,7 @@
 "use client";
+import {
+  createTalkenApiClient
+} from "./chunk-5ERWBR7D.js";
 import {
   setTalkenApiClient
 } from "./chunk-R6ZE7JAZ.js";
@@ -7,7 +10,7 @@ import {
 } from "./chunk-GFWUFYT2.js";
 import {
   AbcAccessKeyProvider
-} from "./chunk-4JZPP3S7.js";
+} from "./chunk-2N244XPQ.js";
 import {
   setGlobalDefaultBitcoinNetwork,
   setGlobalDefaultChainId,
@@ -15,20 +18,20 @@ import {
 } from "./chunk-O4AU63LK.js";
 import {
   createAbcEvmProvider
-} from "./chunk-L6FCF3FH.js";
+} from "./chunk-L3HWFGTN.js";
 import {
   clearAuthState,
   clearStorage,
   loadAuthState,
   loadFromStorage,
   saveAuthState
-} from "./chunk-PF65YS3T.js";
-import {
-  createTalkenApiClient
-} from "./chunk-NP5PWUVU.js";
+} from "./chunk-EBTKWCIS.js";
 import {
   getCredentialManager
-} from "./chunk-QKK3OPQA.js";
+} from "./chunk-36BJXEBA.js";
+import {
+  loadTgAccessKey
+} from "./chunk-6KRX73ED.js";
 
 // src/wallets/walletConnectors/abcWallet/abcConnector.ts
 import { getTalkenApiClient } from "@talken/talkenkit";
@@ -52,9 +55,17 @@ function abcConnector(options) {
       defaultChainId: config.defaultChainId
     });
     setTalkenApiClient(talkenApi);
-    const isAccessKeyMode = !!config.accessKey;
+    const storedAccessKey = typeof window !== "undefined" ? (() => {
+      try {
+        return localStorage.getItem("talken_api_access_key_raw");
+      } catch {
+        return null;
+      }
+    })() : null;
+    const effectiveAccessKey = config.accessKey || storedAccessKey;
+    const isAccessKeyMode = !!effectiveAccessKey;
     const provider = isAccessKeyMode ? new AbcAccessKeyProvider(
-      config.accessKey,
+      effectiveAccessKey,
       resolveTalkenApiUrl(config.talkenApiUrl)
     ) : createAbcEvmProvider(talkenApi);
     let accountsChangedHandler;
@@ -82,7 +93,7 @@ function abcConnector(options) {
                   method: "POST",
                   headers: {
                     "Content-Type": "application/json",
-                    "X-Access-Key": config.accessKey
+                    "X-Access-Key": effectiveAccessKey
                   },
                   body: JSON.stringify({ action: "info" })
                 });
@@ -213,6 +224,10 @@ function abcConnector(options) {
         }
         provider.clearWallet();
         talkenApi.auth.logout();
+        try {
+          localStorage.removeItem("talken_api_access_key_raw");
+        } catch {
+        }
         clearAuthState();
         getCredentialManager().clear();
       },
@@ -249,7 +264,7 @@ function abcConnector(options) {
           if (isAccessKeyMode) {
             if (provider.isConnected())
               return true;
-            const hasKey = !!config.accessKey || typeof localStorage !== "undefined" && !!localStorage.getItem("talken_ak");
+            const hasKey = !!effectiveAccessKey || typeof localStorage !== "undefined" && (!!localStorage.getItem("talken_api_access_key_raw") || !!loadTgAccessKey());
             const authState2 = loadAuthState();
             return hasKey && !!authState2?.wallet?.address;
           }
@@ -263,6 +278,9 @@ function abcConnector(options) {
           if (talkenApi.isAuthenticated()) {
             return true;
           }
+          if (talkenApi.isAccessKeyMode()) {
+            return true;
+          }
           const refreshToken = loadFromStorage(
             "refresh_token" /* REFRESH_TOKEN */
           );

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

@@ -0,0 +1,96 @@
+"use client";
+import {
+  STORAGE_PREFIX
+} from "./chunk-6KRX73ED.js";
+
+// src/wallets/walletConnectors/abcWallet/sessionUtils.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var SessionExpiredError = class extends Error {
+  constructor(message = "Session expired. Please reconnect your wallet.") {
+    super(message);
+    this.name = "SessionExpiredError";
+  }
+};
+function dispatchSessionExpired() {
+  if (typeof window !== "undefined") {
+    console.warn("[SessionUtils] \u{1F6A8} dispatchSessionExpired called from:");
+    console.trace();
+    window.dispatchEvent(new CustomEvent("talkenkit:session_expired"));
+  }
+}
+function handleUnauthorizedResponse(response) {
+  if (response.status === 401) {
+    dispatchSessionExpired();
+    throw new SessionExpiredError(
+      "Session expired. Please reconnect your wallet."
+    );
+  }
+}
+async function fetchWithSessionCheck(url, options) {
+  const response = await fetch(url, options);
+  if (!response.ok && response.status === 401) {
+    const errorText = await response.text();
+    console.error("[ABC WaaS] \u274C Unauthorized (401):", errorText);
+    dispatchSessionExpired();
+    throw new SessionExpiredError(
+      "Session expired. Please reconnect your wallet."
+    );
+  }
+  return response;
+}
+async function refreshAccessToken(pinCallback) {
+  if (pinCallback) {
+    await pinCallback();
+  }
+  const api = getTalkenApiClient();
+  if (!api) {
+    console.warn(
+      "[SessionUtils] TalkenApiClient not initialized - opening connect modal"
+    );
+    dispatchSessionExpired();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    throw new SessionExpiredError(
+      "Session expired. Please reconnect your wallet."
+    );
+  }
+  const refreshToken = api.getRefreshToken() || localStorage.getItem(`${STORAGE_PREFIX}refresh_token`);
+  if (!refreshToken) {
+    console.warn("[SessionUtils] No refresh token - opening connect modal");
+    dispatchSessionExpired();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    throw new SessionExpiredError(
+      "Session expired. Please reconnect your wallet."
+    );
+  }
+  try {
+    const res = await api.auth.refresh();
+    const expiresAt = Date.now() + res.expiresIn * 1e3;
+    api.setTokens(res.accessToken, res.refreshToken || refreshToken, expiresAt);
+    localStorage.setItem(`${STORAGE_PREFIX}access_token`, res.accessToken);
+    if (res.refreshToken) {
+      localStorage.setItem(`${STORAGE_PREFIX}refresh_token`, res.refreshToken);
+    }
+    localStorage.setItem(`${STORAGE_PREFIX}expires_at`, String(expiresAt));
+    console.log(
+      "[SessionUtils] \u2705 Token refreshed - expires in:",
+      (res.expiresIn / 60 / 60).toFixed(2),
+      "hours"
+    );
+    return res.accessToken;
+  } catch (error) {
+    console.error("[SessionUtils] Token refresh failed:", error);
+    dispatchSessionExpired();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    throw new SessionExpiredError(
+      "Session expired. Please reconnect your wallet."
+    );
+  }
+}
+
+export {
+  SessionExpiredError,
+  dispatchSessionExpired,
+  handleUnauthorizedResponse,
+  fetchWithSessionCheck,
+  refreshAccessToken
+};

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

@@ -0,0 +1,241 @@
+"use client";
+import {
+  TokenApi
+} from "./chunk-3K3KYVRN.js";
+
+// src/wallets/walletConnectors/abcWallet/api/WalletscanApi.ts
+import { getTalkenApiClient, networkNameToChainKey } from "@talken/talkenkit";
+var WalletscanApi = class {
+  constructor() {
+    this.tokenApi = new TokenApi();
+  }
+  /**
+   * Get all wallet tokens with balances via TalkenApiClient walletscan endpoint
+   */
+  async getWalletTokens(params) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    try {
+      return await api.walletscan.getTokens({
+        walletAddress: params.walletAddress,
+        chainKeys: networkNameToChainKey(params.networks)
+      });
+    } catch (error) {
+      console.warn("[WalletscanApi] TalkenApi getTokens failed:", error);
+      return [];
+    }
+  }
+  /**
+   * Get all wallet tokens with balances with timeout
+   */
+  async getWalletTokensWithTimeout(params, timeoutMs = 3e3) {
+    try {
+      return await Promise.race([
+        this.getWalletTokens(params),
+        new Promise(
+          (resolve) => setTimeout(() => resolve([]), timeoutMs)
+        )
+      ]);
+    } catch (_error) {
+      console.warn("[WalletscanApi] Wallet token request timed out");
+      return [];
+    }
+  }
+  /**
+   * Get a specific wallet token balance by contract/mint address.
+   */
+  async getWalletTokenBalance(params) {
+    const tokens = await this.getWalletTokens(params);
+    const target = params.contractAddress.toLowerCase();
+    return tokens.find((token) => token.contractAddress?.toLowerCase() === target) ?? null;
+  }
+  /**
+   * Get a specific wallet token balance by contract/mint address with timeout.
+   */
+  async getWalletTokenBalanceWithTimeout(params, timeoutMs = 3e3) {
+    try {
+      return await Promise.race([
+        this.getWalletTokenBalance(params),
+        new Promise(
+          (resolve) => setTimeout(() => resolve(null), timeoutMs)
+        )
+      ]);
+    } catch (_error) {
+      console.warn("[WalletscanApi] Wallet token balance request timed out");
+      return null;
+    }
+  }
+  /**
+   * Get token metadata via TalkenApiClient walletscan endpoint
+   *
+   * @param params - Contract address and networks
+   * @returns Token metadata or null if not found/failed
+   */
+  async getContractToken(params) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    try {
+      const tokens = await api.walletscan.getToken({
+        contractAddress: params.contractAddress,
+        chainKeys: networkNameToChainKey(params.networks)
+      });
+      return tokens.length > 0 ? tokens[0] : null;
+    } catch (error) {
+      console.warn(
+        "[WalletscanApi] TalkenApi getToken failed:",
+        params.contractAddress,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Get token metadata with timeout
+   *
+   * @param params - Contract address and networks
+   * @param timeoutMs - Timeout in milliseconds (default: 3000)
+   * @returns Token metadata or null if timeout/failed
+   */
+  async getContractTokenWithTimeout(params, timeoutMs = 3e3) {
+    try {
+      const result = await Promise.race([
+        this.getContractToken(params),
+        new Promise(
+          (resolve) => setTimeout(() => resolve(null), timeoutMs)
+        )
+      ]);
+      return result;
+    } catch (_error) {
+      console.warn(
+        "[WalletscanApi] Token metadata request timed out:",
+        params.contractAddress
+      );
+      return null;
+    }
+  }
+  /**
+   * Get native coin info via TalkenApiClient walletscan endpoint
+   *
+   * @param params - Wallet address and networks
+   * @returns Array of native coins or empty array if failed
+   */
+  async getNativeToken(params) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    const chainKey = networkNameToChainKey(params.networks);
+    try {
+      return await api.walletscan.getNativeTokens({
+        walletAddress: params.walletAddress,
+        chainKeys: chainKey
+      });
+    } catch (error) {
+      console.warn("[WalletscanApi] TalkenApi getNativeTokens failed:", error);
+      try {
+        const balances = await this.tokenApi.getBalances(
+          params.walletAddress,
+          chainKey
+        );
+        const nativeToken = balances.find((token) => token?.isNative);
+        if (!nativeToken) {
+          return [];
+        }
+        const t = nativeToken;
+        return [
+          {
+            name: t.name,
+            symbol: t.symbol,
+            decimals: t.decimals ?? 18,
+            logo: t.logoUrl ?? void 0,
+            network: chainKey,
+            contractAddress: t.address ?? void 0,
+            isNative: true,
+            balance: t.balance,
+            hrBalance: t.balanceFormatted ? Number(t.balanceFormatted) : void 0
+          }
+        ];
+      } catch (fallbackError) {
+        console.warn(
+          "[WalletscanApi] TokenApi native fallback failed:",
+          fallbackError
+        );
+        return [];
+      }
+    }
+  }
+  /**
+   * Get native coin info with timeout
+   *
+   * @param params - Wallet address and networks
+   * @param timeoutMs - Timeout in milliseconds (default: 3000)
+   * @returns First native coin or null if timeout/failed
+   */
+  async getNativeTokenWithTimeout(params, timeoutMs = 3e3) {
+    try {
+      const natives = await Promise.race([
+        this.getNativeToken(params),
+        new Promise(
+          (resolve) => setTimeout(() => resolve([]), timeoutMs)
+        )
+      ]);
+      return natives.length > 0 ? natives[0] : null;
+    } catch (_error) {
+      console.warn("[WalletscanApi] Native coin request timed out");
+      return null;
+    }
+  }
+  /**
+   * Get NFT metadata via TalkenApiClient walletscan endpoint
+   *
+   * @param params - Contract address, wallet address, and networks
+   * @returns Array of NFT metadata or empty array if failed
+   */
+  async getNFT(params) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    try {
+      return await api.walletscan.getNfts({
+        chainKeys: networkNameToChainKey(params.networks),
+        walletAddress: params.walletAddress
+      });
+    } catch (error) {
+      console.warn(
+        "[WalletscanApi] TalkenApi getNfts failed:",
+        params.contractAddress,
+        error
+      );
+      return [];
+    }
+  }
+  /**
+   * Get NFT metadata with timeout
+   *
+   * @param params - Contract address, wallet address, and networks
+   * @param timeoutMs - Timeout in milliseconds (default: 3000)
+   * @returns First NFT or null if timeout/failed/empty
+   */
+  async getNFTWithTimeout(params, timeoutMs = 3e3) {
+    try {
+      const nfts = await Promise.race([
+        this.getNFT(params),
+        new Promise(
+          (resolve) => setTimeout(() => resolve([]), timeoutMs)
+        )
+      ]);
+      return nfts.length > 0 ? nfts[0] : null;
+    } catch (_error) {
+      console.warn(
+        "[WalletscanApi] NFT metadata request timed out:",
+        params.contractAddress
+      );
+      return null;
+    }
+  }
+};
+
+export {
+  WalletscanApi
+};

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

@@ -0,0 +1,52 @@
+"use client";
+import {
+  TALKEN_API_ENDPOINTS
+} from "./chunk-DPTDOCWL.js";
+
+// src/wallets/walletConnectors/abcWallet/api/ConfigApi.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var toStatusCode = (status) => {
+  if (typeof status === "number")
+    return status;
+  if (typeof status === "string") {
+    const normalized = status.trim().toLowerCase();
+    if (normalized === "success")
+      return 1;
+    if (normalized === "reverted" || normalized === "failed")
+      return 0;
+    const parsed = Number(status);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+};
+var ConfigApi = class {
+  async getTxStatus(chainKey, txHash) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    return api.get(
+      `${TALKEN_API_ENDPOINTS.CONFIG_TX_STATUS}/${encodeURIComponent(chainKey)}/${encodeURIComponent(txHash)}`
+    );
+  }
+  async waitForTxStatus(chainKey, txHash, options = {}) {
+    const { timeoutMs = 3e5, pollIntervalMs = 3e3 } = options;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const status = await this.getTxStatus(chainKey, txHash);
+      if (status.found) {
+        const code = toStatusCode(status.status);
+        if (code !== null && code !== 1) {
+          throw new Error(status.message || "Transaction reverted on-chain");
+        }
+        return status;
+      }
+      await sleep(pollIntervalMs);
+    }
+    throw new Error("Transaction confirmation timed out");
+  }
+};
+
+export {
+  ConfigApi
+};