@talken/talkenkit 2.4.23 → 2.4.25

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

@@ -0,0 +1,54 @@
+"use client";
+import {
+  abcConnector
+} from "./chunk-7S4N4DRT.js";
+import {
+  resolveTalkenApiUrl
+} from "./chunk-GFWUFYT2.js";
+import {
+  createTalkenApiClient
+} from "./chunk-RIJTOH57.js";
+import {
+  ABC_WALLET_METADATA
+} from "./chunk-TQXCRSMS.js";
+
+// src/wallets/walletConnectors/abcWallet/abcWallet.ts
+import { setTalkenApiClient } from "@talken/talkenkit";
+var abcWallet = (specificOptions) => ({ projectId }) => {
+  const talkenApiUrl = resolveTalkenApiUrl(specificOptions?.talkenApiUrl);
+  const talkenApi = createTalkenApiClient({
+    baseUrl: talkenApiUrl,
+    debug: specificOptions?.environment === "development"
+  });
+  setTalkenApiClient(talkenApi);
+  const config = {
+    talkenApiUrl,
+    apiKey: specificOptions?.apiKey,
+    plain: specificOptions?.plain || "",
+    // Deprecated - not used (secure.ts uses random generation)
+    environment: specificOptions?.environment || "development",
+    defaultChainId: specificOptions?.defaultChainId,
+    defaultSolanaNetwork: specificOptions?.defaultSolanaNetwork,
+    defaultBitcoinNetwork: specificOptions?.defaultBitcoinNetwork,
+    projectId
+  };
+  return {
+    id: ABC_WALLET_METADATA.id,
+    name: ABC_WALLET_METADATA.name,
+    rdns: ABC_WALLET_METADATA.rdns,
+    iconUrl: async () => (await import("./abcWallet-AYWSIGAG.js")).default,
+    iconBackground: ABC_WALLET_METADATA.iconBackground,
+    // Embedded wallet - no installation required
+    installed: void 0,
+    // No download URLs for embedded wallet
+    downloadUrls: void 0,
+    // Create connector - wrapper function required by Wallet type
+    createConnector: (_walletDetails) => abcConnector({ config }),
+    // Embedded wallet always available
+    hidden: () => false
+  };
+};
+
+export {
+  abcWallet
+};

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

@@ -0,0 +1,205 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/api/WalletscanApi.ts
+import { getTalkenApiClient, networkNameToChainKey } from "@talken/talkenkit";
+var WalletscanApi = class {
+  /**
+   * 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");
+    try {
+      return await api.walletscan.getNativeTokens({
+        walletAddress: params.walletAddress,
+        chainKeys: networkNameToChainKey(params.networks)
+      });
+    } catch (error) {
+      console.warn("[WalletscanApi] TalkenApi getNativeTokens failed:", error);
+      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-EVJIFLSY.js

@@ -0,0 +1,93 @@
+"use client";
+import {
+  STORAGE_PREFIX
+} from "./chunk-TQXCRSMS.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 refreshToken = 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 api = getTalkenApiClient();
+    if (!api) {
+      throw new Error("TalkenApiClient not initialized");
+    }
+    api.setTokens(
+      localStorage.getItem(`${STORAGE_PREFIX}access_token`) || "",
+      refreshToken,
+      Number(localStorage.getItem(`${STORAGE_PREFIX}expires_at`) || "0")
+    );
+    const res = await api.auth.refresh();
+    const expiresAt = Date.now() + res.expiresIn * 1e3;
+    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
+};