@talken/talkenkit 2.4.23 → 2.4.25

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

@@ -0,0 +1,54 @@
+"use client";
+import {
+  abcConnector
+} from "./chunk-SU6LV3EO.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-VB5IZDY7.js

@@ -0,0 +1,300 @@
+"use client";
+import {
+  setTalkenApiClient
+} from "./chunk-R6ZE7JAZ.js";
+import {
+  setGlobalDefaultBitcoinNetwork,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork
+} from "./chunk-O4AU63LK.js";
+import {
+  createAbcEvmProvider
+} from "./chunk-54KVT46V.js";
+import {
+  clearAuthState,
+  clearStorage,
+  loadAuthState,
+  loadFromStorage,
+  saveAuthState
+} from "./chunk-NISMGNEE.js";
+import {
+  resolveTalkenApiUrl
+} from "./chunk-GFWUFYT2.js";
+import {
+  createTalkenApiClient
+} from "./chunk-XG2R64B7.js";
+import {
+  getCredentialManager
+} from "./chunk-QHUBLT7N.js";
+
+// src/wallets/walletConnectors/abcWallet/abcConnector.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+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 talkenApi = getTalkenApiClient() || createTalkenApiClient({
+      baseUrl: resolveTalkenApiUrl(config.talkenApiUrl),
+      environment: config.environment,
+      debug: config.environment === "development",
+      defaultChainId: config.defaultChainId
+    });
+    setTalkenApiClient(talkenApi);
+    const provider = createAbcEvmProvider(talkenApi);
+    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) {
+            talkenApi.setTokens(
+              authState.accessToken,
+              authState.refreshToken,
+              authState.expiresAt
+            );
+          }
+          const accounts = await provider.request({
+            method: "eth_requestAccounts"
+          });
+          let currentChainId = await provider.request({
+            method: "eth_chainId"
+          });
+          const currentChainIdNumber = Number(currentChainId);
+          const isChainSupported = wagmiConfig.chains.some(
+            (c) => c.id === currentChainIdNumber
+          );
+          if (!isChainSupported && wagmiConfig.chains.length > 0) {
+            const fallbackChainId = wagmiConfig.chains[0].id;
+            await provider.request({
+              method: "wallet_switchEthereumChain",
+              params: [{ chainId: `0x${fallbackChainId.toString(16)}` }]
+            });
+            currentChainId = `0x${fallbackChainId.toString(16)}`;
+            if (authState.wallet) {
+              authState.wallet.chainId = fallbackChainId;
+              saveAuthState(authState);
+            }
+          }
+          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();
+        talkenApi.auth.logout();
+        clearAuthState();
+        getCredentialManager().clear();
+      },
+      /**
+       * 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 (talkenApi.isAuthenticated()) {
+            return true;
+          }
+          const refreshToken = loadFromStorage(
+            "refresh_token" /* REFRESH_TOKEN */
+          );
+          if (!refreshToken) {
+            clearStorage();
+            return false;
+          }
+          try {
+            const api = getTalkenApiClient();
+            if (!api) {
+              clearStorage();
+              return false;
+            }
+            const res = await api.auth.refresh();
+            talkenApi.setTokens(
+              res.accessToken,
+              res.refreshToken,
+              Date.now() + res.expiresIn * 1e3
+            );
+            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-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
+};

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

@@ -0,0 +1,219 @@
+"use client";
+import {
+  AbcError
+} from "./chunk-4P3SPC44.js";
+import {
+  PIN_CONFIG,
+  STORAGE_PREFIX,
+  TOKEN_EXPIRY
+} from "./chunk-TQXCRSMS.js";
+
+// src/wallets/walletConnectors/abcWallet/utils.ts
+async function hashPin(pin) {
+  if (typeof window === "undefined" || !window.crypto?.subtle) {
+    return btoa(pin);
+  }
+  const encoder = new TextEncoder();
+  const data = encoder.encode(pin);
+  const hashBuffer = await window.crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+function validatePin(pin) {
+  if (!pin || typeof pin !== "string") {
+    return false;
+  }
+  const pinLength = pin.length;
+  if (pinLength < PIN_CONFIG.MIN_LENGTH || pinLength > PIN_CONFIG.MAX_LENGTH) {
+    return false;
+  }
+  return /^\d+$/.test(pin);
+}
+function validateEmail(email) {
+  if (!email || typeof email !== "string") {
+    return false;
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+function getStorageKey(key) {
+  return `${STORAGE_PREFIX}${key}`;
+}
+function saveToStorage(key, value) {
+  if (typeof window === "undefined")
+    return;
+  try {
+    const storageKey = getStorageKey(key);
+    const serialized = JSON.stringify(value);
+    localStorage.setItem(storageKey, serialized);
+  } catch (error) {
+    console.error("Failed to save to storage:", error);
+  }
+}
+function loadFromStorage(key) {
+  if (typeof window === "undefined")
+    return null;
+  try {
+    const storageKey = getStorageKey(key);
+    const serialized = localStorage.getItem(storageKey);
+    if (!serialized)
+      return null;
+    try {
+      return JSON.parse(serialized);
+    } catch {
+      return serialized;
+    }
+  } catch (error) {
+    console.error("Failed to load from storage:", error);
+    return null;
+  }
+}
+function removeFromStorage(key) {
+  if (typeof window === "undefined")
+    return;
+  try {
+    const storageKey = getStorageKey(key);
+    localStorage.removeItem(storageKey);
+  } catch (error) {
+    console.error("Failed to remove from storage:", error);
+  }
+}
+function clearStorage() {
+  if (typeof window === "undefined")
+    return;
+  const keysToRemove = [];
+  for (let i = 0; i < localStorage.length; i++) {
+    const key = localStorage.key(i);
+    if (key?.startsWith(STORAGE_PREFIX)) {
+      keysToRemove.push(key);
+    }
+  }
+  for (const key of keysToRemove) {
+    localStorage.removeItem(key);
+  }
+}
+function isTokenExpired(expiresAt) {
+  if (!expiresAt)
+    return true;
+  return Date.now() >= expiresAt - TOKEN_EXPIRY.REFRESH_BUFFER;
+}
+function calculateExpiryTimestamp(expiresIn) {
+  return Date.now() + expiresIn * 1e3;
+}
+function saveAuthState(state) {
+  saveToStorage("auth_state" /* AUTH_STATE */, state);
+  if (state.user) {
+    saveToStorage("user" /* USER */, state.user);
+  }
+  if (state.wallet) {
+    saveToStorage("wallet" /* WALLET */, state.wallet);
+  }
+  if (state.solanaWallet) {
+    saveToStorage("solana_wallet" /* SOLANA_WALLET */, state.solanaWallet);
+  }
+  if (state.bitcoinWallet) {
+    saveToStorage("bitcoin_wallet" /* BITCOIN_WALLET */, state.bitcoinWallet);
+  }
+  if (state.tronWallet) {
+    saveToStorage("tron_wallet" /* TRON_WALLET */, state.tronWallet);
+  }
+  if (state.accessToken) {
+    saveToStorage("access_token" /* ACCESS_TOKEN */, state.accessToken);
+  }
+  if (state.refreshToken) {
+    saveToStorage("refresh_token" /* REFRESH_TOKEN */, state.refreshToken);
+  }
+  if (state.expiresAt) {
+    saveToStorage("expires_at" /* EXPIRES_AT */, state.expiresAt);
+  }
+}
+function hydrateAuthStateFromIndividualStorage(state) {
+  const user = loadFromStorage("user" /* USER */);
+  const wallet = loadFromStorage("wallet" /* WALLET */);
+  const solanaWallet = loadFromStorage("solana_wallet" /* SOLANA_WALLET */);
+  const bitcoinWallet = loadFromStorage("bitcoin_wallet" /* BITCOIN_WALLET */);
+  const tronWallet = loadFromStorage("tron_wallet" /* TRON_WALLET */);
+  const accessToken = loadFromStorage("access_token" /* ACCESS_TOKEN */);
+  const refreshToken = loadFromStorage("refresh_token" /* REFRESH_TOKEN */);
+  const expiresAt = loadFromStorage("expires_at" /* EXPIRES_AT */);
+  const nextState = {
+    ...state,
+    user: state.user || user || null,
+    wallet: state.wallet || wallet || null,
+    solanaWallet: state.solanaWallet || solanaWallet || null,
+    bitcoinWallet: state.bitcoinWallet || bitcoinWallet || null,
+    tronWallet: state.tronWallet || tronWallet || null,
+    accessToken: state.accessToken || accessToken || null,
+    refreshToken: state.refreshToken || refreshToken || null,
+    expiresAt: state.expiresAt || expiresAt || null
+  };
+  const wasHydrated = nextState.user !== state.user || nextState.wallet !== state.wallet || nextState.solanaWallet !== state.solanaWallet || nextState.bitcoinWallet !== state.bitcoinWallet || nextState.tronWallet !== state.tronWallet || nextState.accessToken !== state.accessToken || nextState.refreshToken !== state.refreshToken || nextState.expiresAt !== state.expiresAt;
+  if (wasHydrated) {
+    saveToStorage("auth_state" /* AUTH_STATE */, nextState);
+  }
+  return nextState;
+}
+function loadAuthState() {
+  const state = loadFromStorage("auth_state" /* AUTH_STATE */);
+  if (state) {
+    if (state.accessToken && isTokenExpired(state.expiresAt)) {
+      clearStorage();
+      return null;
+    }
+    return hydrateAuthStateFromIndividualStorage(state);
+  }
+  const user = loadFromStorage("user" /* USER */);
+  const wallet = loadFromStorage("wallet" /* WALLET */);
+  const solanaWallet = loadFromStorage("solana_wallet" /* SOLANA_WALLET */);
+  const accessToken = loadFromStorage("access_token" /* ACCESS_TOKEN */);
+  const refreshToken = loadFromStorage("refresh_token" /* REFRESH_TOKEN */);
+  const expiresAt = loadFromStorage("expires_at" /* EXPIRES_AT */);
+  if (!user || !accessToken) {
+    return null;
+  }
+  const bitcoinWallet = loadFromStorage("bitcoin_wallet" /* BITCOIN_WALLET */);
+  const tronWallet = loadFromStorage("tron_wallet" /* TRON_WALLET */);
+  return {
+    isAuthenticated: true,
+    user,
+    wallet,
+    solanaWallet,
+    bitcoinWallet,
+    tronWallet,
+    accessToken,
+    refreshToken,
+    expiresAt
+  };
+}
+function clearAuthState() {
+  clearStorage();
+}
+function createAbcError(code, message, details, statusCode) {
+  return new AbcError(code, message, details, statusCode);
+}
+function hexToNumber(hex) {
+  return Number.parseInt(hex, 16);
+}
+function numberToHex(num) {
+  return `0x${num.toString(16)}`;
+}
+
+export {
+  hashPin,
+  validatePin,
+  validateEmail,
+  getStorageKey,
+  saveToStorage,
+  loadFromStorage,
+  removeFromStorage,
+  clearStorage,
+  isTokenExpired,
+  calculateExpiryTimestamp,
+  saveAuthState,
+  loadAuthState,
+  clearAuthState,
+  createAbcError,
+  hexToNumber,
+  numberToHex
+};