@talken/talkenkit 2.4.24 → 2.4.25

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

@@ -0,0 +1,194 @@
+"use client";
+import {
+  getBitcoinNetwork,
+  getEvmNetwork,
+  getSolanaNetwork,
+  getTronNetwork
+} from "./chunk-O4AU63LK.js";
+import {
+  getCredentialManager
+} from "./chunk-6WF4SXLB.js";
+import {
+  AbcError
+} from "./chunk-4P3SPC44.js";
+
+// src/wallets/walletConnectors/abcWallet/walletGeneration.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+async function mapApiResponseToWallets(genResponse, infoResponse, email) {
+  const accounts = infoResponse?.accounts || [];
+  const evmAccount = accounts[0] || infoResponse || {};
+  const uid = String(genResponse.uid || evmAccount.uid || "");
+  const wid = String(genResponse.wid || evmAccount.wid || "");
+  const sid = String(
+    evmAccount.sid || evmAccount.ethAddress || genResponse.evmAddress || ""
+  );
+  const pubkey = String(evmAccount.pubkey || genResponse.pubkey || "");
+  const solMaterial = genResponse.solana || {};
+  let btcAddress = genResponse.btcAddress || "";
+  let trxAddress = genResponse.trxAddress || "";
+  if ((!btcAddress || !trxAddress) && pubkey) {
+    try {
+      const api = getTalkenApiClient();
+      if (api) {
+        const addrResponse = await api.wallet.getAddressForChain("all");
+        if (!btcAddress)
+          btcAddress = addrResponse?.btc || addrResponse?.btcAddress || "";
+        if (!trxAddress)
+          trxAddress = addrResponse?.trx || addrResponse?.trxAddress || "";
+      }
+    } catch (err) {
+      console.warn(
+        "[walletGeneration] Failed to derive BTC/TRX addresses:",
+        err
+      );
+    }
+  }
+  const pvencstr = String(evmAccount.pvencstr || "");
+  const edp = String(evmAccount.encryptDevicePassword || "");
+  if (uid && wid && sid && pvencstr && edp) {
+    getCredentialManager().setEvmSigningCredentials({
+      uid,
+      wid,
+      sid,
+      pvencstr,
+      encryptDevicePassword: edp
+    });
+  }
+  const evmWallet = {
+    uid,
+    sessionId: sid,
+    keyId: wid,
+    encryptedShare: pvencstr,
+    secretStore: edp,
+    address: genResponse.evmAddress || sid,
+    chainId: getEvmNetwork(),
+    sid,
+    type: "evm",
+    email,
+    pubkey
+  };
+  const solanaWallet = {
+    uid,
+    sessionId: String(solMaterial.shareId || ""),
+    keyId: String(solMaterial.keyId || ""),
+    encryptedShare: String(solMaterial.encryptedShare || ""),
+    secretStore: String(solMaterial.secretStore || ""),
+    shareId: String(solMaterial.shareId || ""),
+    publicKey: String(solMaterial.publicKey || ""),
+    address: genResponse.solAddress || solMaterial.address || "",
+    network: getSolanaNetwork()
+  };
+  const bitcoinWallet = {
+    uid,
+    sessionId: sid,
+    keyId: wid,
+    encryptedShare: String(evmAccount.pvencstr || ""),
+    shareId: sid,
+    publicKey: pubkey,
+    address: btcAddress,
+    addressType: "bech32",
+    network: getBitcoinNetwork()
+  };
+  const tronWallet = {
+    uid,
+    sessionId: sid,
+    keyId: wid,
+    encryptedShare: String(evmAccount.pvencstr || ""),
+    shareId: sid,
+    publicKey: pubkey,
+    address: trxAddress,
+    network: getTronNetwork()
+  };
+  return { evmWallet, solanaWallet, bitcoinWallet, tronWallet };
+}
+async function generateMpcWallets(hashedPin, email) {
+  const api = getTalkenApiClient();
+  if (!api) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  try {
+    const genResponse = await api.wallet.generate(hashedPin, email);
+    const infoResponse = await api.wallet.getInfo().catch(() => ({}));
+    return await mapApiResponseToWallets(
+      genResponse,
+      infoResponse,
+      email || ""
+    );
+  } catch (error) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Failed to generate MPC wallets: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+async function recoverMpcWallets(hashedPin, email) {
+  const api = getTalkenApiClient();
+  if (!api) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  try {
+    const genResponse = await api.wallet.recover(hashedPin, email);
+    const infoResponse = await api.wallet.getInfo().catch(() => ({}));
+    return await mapApiResponseToWallets(
+      genResponse,
+      infoResponse,
+      email || ""
+    );
+  } catch (error) {
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Failed to recover MPC wallets: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+function validateMpcWallets(result) {
+  const errors = [];
+  if (!result.evmWallet) {
+    errors.push("EVM wallet is missing");
+  } else {
+    if (!result.evmWallet.address || !result.evmWallet.address.startsWith("0x")) {
+      errors.push("Invalid EVM wallet address");
+    }
+  }
+  if (!result.solanaWallet) {
+    errors.push("Solana wallet is missing");
+  } else {
+    if (!result.solanaWallet.address) {
+      errors.push("Invalid Solana wallet address");
+    }
+  }
+  if (!result.bitcoinWallet) {
+    errors.push("Bitcoin wallet is missing");
+  } else {
+    if (!result.bitcoinWallet.address) {
+      errors.push("Invalid Bitcoin wallet address");
+    }
+  }
+  if (!result.tronWallet) {
+    errors.push("TRON wallet is missing");
+  } else {
+    if (!result.tronWallet.address) {
+      errors.push("Invalid TRON wallet address");
+    } else if (!result.tronWallet.address.startsWith("T")) {
+      errors.push("Invalid TRON address format (expected T prefix)");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+export {
+  generateMpcWallets,
+  recoverMpcWallets,
+  validateMpcWallets
+};

package/dist/wallets/walletConnectors/chunk-CE37VZAR.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-GWYZ2IPP.js";
+import {
+  clearAuthState,
+  clearStorage,
+  loadAuthState,
+  loadFromStorage,
+  saveAuthState
+} from "./chunk-A66MTFML.js";
+import {
+  resolveTalkenApiUrl
+} from "./chunk-GFWUFYT2.js";
+import {
+  createTalkenApiClient
+} from "./chunk-KZS2C73S.js";
+import {
+  getCredentialManager
+} from "./chunk-6WF4SXLB.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-DPTDOCWL.js

@@ -0,0 +1,205 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/constants.ts
+var DEFAULT_ABC_CONFIG = {
+  environment: "development",
+  talkenApiUrl: ""
+};
+var TOKEN_EXPIRY = {
+  ACCESS_TOKEN: 10 * 60 * 1e3,
+  // 10 minutes
+  REFRESH_TOKEN: 60 * 60 * 1e3,
+  // 60 minutes
+  REFRESH_BUFFER: 60 * 1e3
+  // Refresh 60s before expiry (increased for network latency tolerance)
+};
+var AUTH_PROVIDERS = {
+  EMAIL: "email",
+  GOOGLE: "google",
+  APPLE: "apple",
+  TELEGRAM: "telegram",
+  TWITTER: "twitter"
+};
+var CHAIN_TYPES = {
+  EVM: "evm",
+  SOLANA: "solana",
+  BITCOIN: "bitcoin"
+};
+var SOLANA_CHAIN_ID = 900;
+var BITCOIN_CHAIN_ID = 800;
+var EVM_CHAINS = {
+  ETHEREUM_MAINNET: 1,
+  ETHEREUM_GOERLI: 5,
+  ETHEREUM_SEPOLIA: 11155111,
+  POLYGON_MAINNET: 137,
+  POLYGON_MUMBAI: 80001,
+  BSC_MAINNET: 56,
+  BSC_TESTNET: 97,
+  ARBITRUM_MAINNET: 42161,
+  ARBITRUM_GOERLI: 421613,
+  OPTIMISM_MAINNET: 10,
+  OPTIMISM_GOERLI: 420,
+  AVALANCHE_MAINNET: 43114,
+  AVALANCHE_FUJI: 43113,
+  KLAYTN_MAINNET: 8217,
+  KLAYTN_BAOBAB: 1001
+};
+var PIN_CONFIG = {
+  MIN_LENGTH: 6,
+  MAX_LENGTH: 6,
+  MAX_ATTEMPTS: 5,
+  LOCKOUT_DURATION: 15 * 60 * 1e3
+  // 15 minutes
+};
+var STORAGE_VERSION = "1.0.0";
+var REQUEST_TIMEOUT = 3e4;
+var RETRY_CONFIG = {
+  MAX_RETRIES: 3,
+  RETRY_DELAY: 1e3,
+  // 1 second
+  BACKOFF_MULTIPLIER: 2
+};
+var ABC_WALLET_METADATA = {
+  id: "abc",
+  name: "ABC Wallet",
+  iconBackground: "#ffffff",
+  rdns: "com.abcwallet"
+};
+var MODAL_CONFIG = {
+  WIDTH: 400,
+  MAX_WIDTH: "90vw",
+  BORDER_RADIUS: 16,
+  PADDING: 24
+};
+var SOCIAL_BUTTONS = [
+  {
+    provider: AUTH_PROVIDERS.GOOGLE,
+    label: "Google",
+    iconName: "google"
+  },
+  {
+    provider: AUTH_PROVIDERS.APPLE,
+    label: "Apple",
+    iconName: "apple"
+  },
+  {
+    provider: AUTH_PROVIDERS.TELEGRAM,
+    label: "Telegram",
+    iconName: "telegram"
+  },
+  {
+    provider: AUTH_PROVIDERS.TWITTER,
+    label: "X (Twitter)",
+    iconName: "twitter"
+  }
+];
+var ERROR_MESSAGES = {
+  INVALID_CREDENTIALS: "Invalid email or password",
+  TOKEN_EXPIRED: "Your session has expired. Please login again.",
+  WALLET_NOT_FOUND: "Wallet not found. Please create a new wallet.",
+  INVALID_PIN: "Invalid PIN code",
+  NETWORK_ERROR: "Network error. Please check your connection.",
+  SIGNATURE_FAILED: "Failed to sign transaction",
+  USER_CANCELLED: "User cancelled the operation",
+  UNKNOWN_ERROR: "An unknown error occurred",
+  INVALID_OTP: "Invalid or expired OTP code",
+  EMAIL_REQUIRED: "Email address is required",
+  PIN_REQUIRED: "PIN code is required",
+  WALLET_GENERATION_FAILED: "Failed to generate wallet"
+};
+var SUCCESS_MESSAGES = {
+  LOGIN_SUCCESS: "Successfully logged in",
+  WALLET_CREATED: "Wallet created successfully",
+  TRANSACTION_SENT: "Transaction sent successfully",
+  OTP_SENT: "OTP code sent to your email"
+};
+var ABC_EVENTS = {
+  CONNECT: "abc:connect",
+  DISCONNECT: "abc:disconnect",
+  ACCOUNTS_CHANGED: "abc:accountsChanged",
+  CHAIN_CHANGED: "abc:chainChanged",
+  ERROR: "abc:error",
+  AUTH_STATE_CHANGED: "abc:authStateChanged"
+};
+var STORAGE_PREFIX = "talkenkit_abc_";
+var DEBUG_MODE = true;
+var ABC_FEATURES = {
+  EMAIL_LOGIN: true,
+  SOCIAL_LOGIN: true,
+  MULTI_CHAIN: true,
+  EVM_SUPPORT: true,
+  SOLANA_SUPPORT: true,
+  BITCOIN_SUPPORT: false,
+  // Future feature
+  GASLESS_TRANSACTIONS: false,
+  // Future feature
+  SOCIAL_RECOVERY: false
+  // Future feature
+};
+var DEFAULT_TALKEN_API_CONFIG = {
+  baseUrl: void 0,
+  timeout: REQUEST_TIMEOUT
+};
+var TALKEN_API_ENDPOINTS = {
+  // ── Auth (single action-based endpoint) ─────────────────────────────
+  AUTH: "/wallet/auth",
+  // ── Wallet ──────────────────────────────────────────────────────────
+  WALLET_MPC: "/wallet/mpc",
+  WALLET_ADDRESS: "/wallet/address",
+  WALLET_SCAN: "/wallet/scan",
+  WALLET_BTC: "/wallet/btc",
+  // ── EVM Sign (WaaS proxy) ───────────────────────────────────────────
+  SIGN_EVM: "/wallet/sign/evm",
+  SIGN_TYPED: "/wallet/sign/evm/typed",
+  SIGN_PERSONAL: "/wallet/sign/evm/personal",
+  SIGN_AUTHORIZATION: "/wallet/sign/authorization",
+  // ── Hash Sign (secp256k1, universal: EVM/BTC/TVM) ───────────────────
+  SIGN_HASH: "/wallet/sign/hash",
+  // ── SOL Sign (WaaS proxy) ───────────────────────────────────────────
+  SIGN_SVM: "/wallet/sign/sol",
+  // ── TX ──────────────────────────────────────────────────────────────
+  TX_RAW: "/wallet/tx/raw",
+  TX_EVM: "/wallet/tx/evm",
+  TX_SOL: "/wallet/tx/sol",
+  SOLANA_LATEST_BLOCKHASH: "/wallet/solana/latest-blockhash",
+  SOLANA_TX_STATUS: "/wallet/solana/tx-status",
+  TX_BTC: "/wallet/tx/btc",
+  TX_TVM: "/wallet/tx/tvm",
+  // ── Gas (WaaS proxy) ───────────────────────────────────────────────
+  GAS_PRICE: "/wallet/gas/price",
+  GAS_SUGGESTED: "/wallet/gas/suggested",
+  GAS_ESTIMATE: "/wallet/gas/estimate",
+  // ── Nonce (WaaS proxy) ─────────────────────────────────────────────
+  NONCE: "/wallet/nonce",
+  // ── Relayer ────────────────────────────────────────────────────────
+  RELAYER_FEE_ESTIMATE: "/relayer/estimate-fee",
+  // ── Config / Runtime ───────────────────────────────────────────────
+  CONFIG_TX_STATUS: "/config/tx-status",
+  // ── Tokens ─────────────────────────────────────────────────────────
+  TOKENS_BALANCES: "/tokens/balances"
+};
+
+export {
+  DEFAULT_ABC_CONFIG,
+  TOKEN_EXPIRY,
+  AUTH_PROVIDERS,
+  CHAIN_TYPES,
+  SOLANA_CHAIN_ID,
+  BITCOIN_CHAIN_ID,
+  EVM_CHAINS,
+  PIN_CONFIG,
+  STORAGE_VERSION,
+  REQUEST_TIMEOUT,
+  RETRY_CONFIG,
+  ABC_WALLET_METADATA,
+  MODAL_CONFIG,
+  SOCIAL_BUTTONS,
+  ERROR_MESSAGES,
+  SUCCESS_MESSAGES,
+  ABC_EVENTS,
+  STORAGE_PREFIX,
+  DEBUG_MODE,
+  ABC_FEATURES,
+  DEFAULT_TALKEN_API_CONFIG,
+  TALKEN_API_ENDPOINTS
+};