@talken/talkenkit 2.4.29 → 2.5.0

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

@@ -1,761 +0,0 @@
-"use client";
-import {
-  TalkenApiError
-} from "./chunk-D5EFTEOM.js";
-import {
-  DEFAULT_TALKEN_API_CONFIG,
-  TALKEN_API_ENDPOINTS,
-  TOKEN_EXPIRY
-} from "./chunk-RCIABMG5.js";
-
-// src/wallets/walletConnectors/abcWallet/api/TalkenApiClient.ts
-var STORAGE_KEY_PREFIX = "talken_api_";
-function loadToken(key) {
-  if (typeof window === "undefined")
-    return null;
-  try {
-    return localStorage.getItem(`${STORAGE_KEY_PREFIX}${key}`);
-  } catch {
-    return null;
-  }
-}
-function saveToken(key, value) {
-  if (typeof window === "undefined")
-    return;
-  try {
-    localStorage.setItem(`${STORAGE_KEY_PREFIX}${key}`, value);
-  } catch {
-  }
-}
-function removeToken(key) {
-  if (typeof window === "undefined")
-    return;
-  try {
-    localStorage.removeItem(`${STORAGE_KEY_PREFIX}${key}`);
-  } catch {
-  }
-}
-function normalizeAuthResponse(raw) {
-  const d = raw.data || raw;
-  const loginData = d.login || d;
-  return {
-    accessToken: loginData.access_token || loginData.accessToken || "",
-    refreshToken: loginData.refresh_token || loginData.refreshToken || "",
-    expiresIn: loginData.expires_in || loginData.expire_in || loginData.expiresIn || 3600,
-    uid: d.uid || loginData.uid || "",
-    email: d.email || loginData.email || "",
-    isNewUser: d.isNewUser
-  };
-}
-var TalkenAuthModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Login with email and password
-   * POST /wallet/auth { action: 'login', method: 'password', email, password }
-   */
-  async loginWithPassword(email, password) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "login", method: "password", email, password },
-      { skipAuth: true }
-    );
-    const res = normalizeAuthResponse(raw);
-    this.client.handleAuthResponse(res);
-    return res;
-  }
-  /**
-   * Send OTP code to email
-   * POST /wallet/auth { action: 'otp.send', email }
-   */
-  async sendOtp(email) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "otp.send", email },
-      { skipAuth: true }
-    );
-    return raw.data || raw;
-  }
-  /**
-   * Verify OTP code
-   * POST /wallet/auth { action: 'otp.verify', email, otpCode }
-   */
-  async verifyOtp(email, otpCode) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "otp.verify", email, otpCode },
-      { skipAuth: true }
-    );
-    return raw.data || raw;
-  }
-  /**
-   * Check if email is already registered
-   * POST /wallet/auth { action: 'email.check', email }
-   * Returns code 606 if email exists
-   */
-  async checkEmail(email) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "email.check", email },
-      { skipAuth: true }
-    );
-    const d = raw.data || raw;
-    return {
-      code: d.code,
-      message: d.message,
-      exists: d.code === 606
-    };
-  }
-  /**
-   * Register a new user (creates account + auto-login)
-   * POST /wallet/auth { action: 'register', email, otpCode, password, name? }
-   */
-  async register(params) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "register", ...params },
-      { skipAuth: true }
-    );
-    const res = normalizeAuthResponse(raw);
-    this.client.handleAuthResponse(res);
-    return res;
-  }
-  /**
-   * Reset password for existing user
-   * POST /wallet/auth { action: 'password.reset', email, newPassword, emailCode }
-   */
-  async resetPassword(email, newPassword, emailCode) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "password.reset", email, newPassword, emailCode },
-      { skipAuth: true }
-    );
-    return raw.data || raw;
-  }
-  /**
-   * Login with social provider (Google, Apple, Kakao, etc.)
-   * POST /wallet/auth { action: 'login', method: 'sns', token, service, audience? }
-   */
-  async loginWithSns(params) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      {
-        action: "login",
-        method: "sns",
-        token: params.token,
-        service: params.service,
-        ...params.audience && { audience: params.audience }
-      },
-      { skipAuth: true }
-    );
-    const res = normalizeAuthResponse(raw);
-    this.client.handleAuthResponse(res);
-    return res;
-  }
-  /**
-   * Refresh access token
-   * POST /wallet/auth { action: 'token.refresh', refreshToken }
-   */
-  async refresh() {
-    const refreshToken = this.client.getRefreshToken();
-    if (!refreshToken) {
-      throw new TalkenApiError(
-        "TOKEN_EXPIRED",
-        "No refresh token available",
-        401
-      );
-    }
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "token.refresh", refreshToken },
-      { skipAuth: true }
-    );
-    const res = normalizeAuthResponse(raw);
-    this.client.handleAuthResponse(res);
-    return res;
-  }
-  /**
-   * Logout (clear local session only — no server endpoint)
-   */
-  logout() {
-    this.client.clearSession();
-  }
-};
-var TalkenWalletModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Generate/recover MPC wallets (create = idempotent generate/recover)
-   * POST /wallet/mpc { action: 'create', email?, pin }
-   *
-   * @param pin - SHA-256 hashed PIN
-   * @param email - User email (optional; server resolves from bearer token if omitted)
-   */
-  async generate(pin, email) {
-    return this.client.post(TALKEN_API_ENDPOINTS.WALLET_MPC, {
-      action: "create",
-      ...email && { email },
-      pin
-    });
-  }
-  /**
-   * Recover is the same as generate (create is idempotent)
-   */
-  async recover(pin, email) {
-    return this.generate(pin, email);
-  }
-  /**
-   * Get wallet info
-   * POST /wallet/mpc { action: 'info' }
-   */
-  async getInfo() {
-    return this.client.post(TALKEN_API_ENDPOINTS.WALLET_MPC, {
-      action: "info"
-    });
-  }
-  /**
-   * Get addresses for all chains
-   * POST /wallet/address { chain: 'all' }
-   */
-  async getAddresses() {
-    return this.client.post(TALKEN_API_ENDPOINTS.WALLET_ADDRESS, {
-      chain: "all"
-    });
-  }
-  /**
-   * Get addresses for a specific chain
-   * POST /wallet/address { chain, publicKey?, pin? }
-   */
-  async getAddressForChain(chain, publicKey, pin) {
-    return this.client.post(TALKEN_API_ENDPOINTS.WALLET_ADDRESS, {
-      chain,
-      ...publicKey && { publicKey },
-      ...pin && { pin }
-    });
-  }
-};
-var TalkenEvmModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Sign EVM transaction (sign only, no broadcast)
-   * POST /wallet/sign/evm { network, to, from?, value?, data?, ... }
-   * Server handles SecureChannel internally
-   */
-  async signTransaction(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.SIGN_EVM,
-      params
-    );
-  }
-  /**
-   * Sign EIP-712 typed data
-   * POST /wallet/sign/typed { network, typedData }
-   */
-  async signTypedData(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.SIGN_TYPED,
-      params
-    );
-  }
-  /**
-   * Sign personal message (EIP-191)
-   * POST /wallet/sign/personal { network, message, address? }
-   */
-  async signPersonal(params) {
-    const res = await this.client.post(
-      TALKEN_API_ENDPOINTS.SIGN_PERSONAL,
-      params
-    );
-    return {
-      signature: res?.signature ?? res?.serializedTx ?? "",
-      txHash: res?.txHash ?? res?.rawTx
-    };
-  }
-  /**
-   * Broadcast signed transaction
-   * POST /wallet/tx/raw { network, signedSerializeTx }
-   */
-  async sendRawTransaction(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_RAW,
-      params
-    );
-  }
-  /**
-   * Integrated EVM transfer (sign + broadcast)
-   * POST /wallet/tx/evm { chainKey, to, amountWei, pin, ... }
-   */
-  async sendTransaction(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_EVM,
-      params
-    );
-  }
-  /**
-   * Get gas price
-   * GET /wallet/gas/price?network=
-   */
-  async getGasPrice(network) {
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.GAS_PRICE}?network=${encodeURIComponent(network)}`
-    );
-  }
-  /**
-   * Get suggested gas fees (EIP-1559)
-   * GET /wallet/gas/suggested?network=
-   */
-  async getGasSuggested(network) {
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.GAS_SUGGESTED}?network=${encodeURIComponent(network)}`
-    );
-  }
-  /**
-   * Estimate gas
-   * POST /wallet/gas/estimate { network, from, to, value?, data? }
-   */
-  async estimateGas(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.GAS_ESTIMATE,
-      params
-    );
-  }
-  /**
-   * Get nonce for address
-   * GET /wallet/nonce?network=&address=
-   */
-  async getNonce(network, address) {
-    const qs = new URLSearchParams({ network, address }).toString();
-    return this.client.get(`${TALKEN_API_ENDPOINTS.NONCE}?${qs}`);
-  }
-};
-var TalkenSolanaModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Transfer SOL or SPL token (integrated sign + broadcast)
-   * POST /wallet/tx/sol
-   * - kind='native': { toAddress, amountLamports, pin }
-   * - kind='spl':    { toAddress, mintAddress, amount, decimals, network, pin }
-   */
-  async transfer(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_SOL,
-      params
-    );
-  }
-  /**
-   * Sign Solana transaction or message (sign-only, no broadcast)
-   * POST /wallet/sign/sol
-   *
-   * Two modes:
-   * - PIN mode: { message, pin } — server resolves signing material
-   * - Share mode: { message, keyId, encryptedShare } — no PIN required (for signMessage)
-   *
-   * @returns Ed25519 signature (hex) and optionally public key
-   */
-  async sign(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.SIGN_SVM,
-      params
-    );
-  }
-};
-var TalkenBitcoinModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * BTC fee rate lookup
-   * GET /wallet/btc?mode=fee&network=&blocks=
-   */
-  async getFeeRate(network, blocks) {
-    const qs = new URLSearchParams({
-      mode: "fee",
-      network,
-      ...typeof blocks === "number" ? { blocks: String(blocks) } : {}
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_BTC}?${qs}`
-    );
-  }
-  /**
-   * BTC tx status by hash
-   * GET /wallet/btc?mode=txHash&network=&txHash=
-   */
-  async getTxByHash(txHash, network) {
-    const qs = new URLSearchParams({
-      mode: "txHash",
-      network,
-      txHash
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_BTC}?${qs}`
-    );
-  }
-  /**
-   * BTC UTXO list
-   * GET /wallet/btc?mode=utxos&network=&address=
-   */
-  async getUtxos(network, address) {
-    const qs = new URLSearchParams({
-      mode: "utxos",
-      network,
-      ...address ? { address } : {}
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_BTC}?${qs}`
-    );
-  }
-  /**
-   * BTC address validation
-   * GET /wallet/btc?mode=validateAddress&network=&address=
-   */
-  async validateAddress(address, network) {
-    const qs = new URLSearchParams({
-      mode: "validateAddress",
-      network,
-      address
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_BTC}?${qs}`
-    );
-  }
-  /**
-   * Send BTC (integrated sign + broadcast, action=transfer)
-   * POST /wallet/tx/btc
-   */
-  async sendTransaction(params) {
-    const payload = { action: "transfer", ...params };
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_BTC,
-      payload
-    );
-  }
-  /**
-   * Execute BTC action endpoint (transfer|generate|signHash|finalize)
-   * POST /wallet/tx/btc
-   */
-  async execute(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_BTC,
-      params
-    );
-  }
-  /**
-   * Sign raw hash via secp256k1 MPC (universal: EVM/BTC/TVM)
-   * POST /wallet/sign/hash { hash, pin, network? }
-   */
-  async signHash(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.SIGN_HASH,
-      params
-    );
-  }
-  /**
-   * Broadcast raw BTC transaction
-   * POST /wallet/tx/raw { network, signedSerializeTx }
-   */
-  async broadcastRawTransaction(params) {
-    return this.client.post(TALKEN_API_ENDPOINTS.TX_RAW, {
-      network: params.network,
-      signedSerializeTx: params.rawTransaction
-    });
-  }
-};
-var TalkenTronModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Execute TVM(TRON) transfer/call (integrated sign + broadcast)
-   * POST /wallet/tx/tvm
-   * - kind=native: TRX transfer (amountSun)
-   * - kind=trc20: TRC-20 transfer (contractAddress + amount)
-   * - kind=contract: arbitrary contract call (contractAddress + data)
-   */
-  async transferTrx(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_TVM,
-      params
-    );
-  }
-};
-var TalkenWalletscanModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Get token metadata by contract address
-   * GET /wallet/scan?type=tokens&chainKeys=...&contractAddress=...
-   */
-  async getToken(params) {
-    const qs = new URLSearchParams({
-      type: "tokens",
-      chainKeys: params.chainKeys,
-      contractAddress: params.contractAddress
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_SCAN}?${qs}`
-    );
-  }
-  /**
-   * Get native coin balances
-   * GET /wallet/scan?type=natives&chainKeys=...&walletAddress=...
-   */
-  async getNativeTokens(params) {
-    const qs = new URLSearchParams({
-      type: "natives",
-      chainKeys: params.chainKeys,
-      walletAddress: params.walletAddress
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_SCAN}?${qs}`
-    );
-  }
-  /**
-   * Get NFT metadata
-   * GET /wallet/scan?type=nfts&chainKeys=...&walletAddress=...
-   */
-  async getNfts(params) {
-    const qs = new URLSearchParams({
-      type: "nfts",
-      chainKeys: params.chainKeys,
-      walletAddress: params.walletAddress
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_SCAN}?${qs}`
-    );
-  }
-};
-var TalkenApiClient = class {
-  constructor(config) {
-    this.accessToken = null;
-    this.refreshToken_ = null;
-    this.expiresAt = null;
-    this.isRefreshing = false;
-    this.refreshPromise = null;
-    this.config = {
-      baseUrl: config?.baseUrl || DEFAULT_TALKEN_API_CONFIG.baseUrl || "",
-      timeout: config?.timeout || DEFAULT_TALKEN_API_CONFIG.timeout,
-      environment: config?.environment || "development",
-      defaultChainId: config?.defaultChainId,
-      debug: config?.debug || false
-    };
-    this.auth = new TalkenAuthModule(this);
-    this.wallet = new TalkenWalletModule(this);
-    this.evm = new TalkenEvmModule(this);
-    this.solana = new TalkenSolanaModule(this);
-    this.bitcoin = new TalkenBitcoinModule(this);
-    this.tron = new TalkenTronModule(this);
-    this.walletscan = new TalkenWalletscanModule(this);
-    this.restoreSession();
-  }
-  // ── Session Management ──────────────────────────────────────────────
-  restoreSession() {
-    this.accessToken = loadToken("access_token");
-    this.refreshToken_ = loadToken("refresh_token");
-    const expiresAtStr = loadToken("expires_at");
-    this.expiresAt = expiresAtStr ? Number(expiresAtStr) : null;
-  }
-  /** @internal Called by auth module after successful login/register */
-  handleAuthResponse(response) {
-    this.accessToken = response.accessToken;
-    this.refreshToken_ = response.refreshToken;
-    this.expiresAt = Date.now() + response.expiresIn * 1e3;
-    saveToken("access_token", response.accessToken);
-    saveToken("refresh_token", response.refreshToken);
-    saveToken("expires_at", String(this.expiresAt));
-  }
-  /** @internal Clear all session data */
-  clearSession() {
-    this.accessToken = null;
-    this.refreshToken_ = null;
-    this.expiresAt = null;
-    removeToken("access_token");
-    removeToken("refresh_token");
-    removeToken("expires_at");
-  }
-  /**
-   * Check if user is authenticated (has valid access token)
-   */
-  isAuthenticated() {
-    return !!this.accessToken && !this.isTokenExpired();
-  }
-  /**
-   * Check if current access token is expired
-   */
-  isTokenExpired() {
-    if (!this.expiresAt)
-      return true;
-    return Date.now() >= this.expiresAt - TOKEN_EXPIRY.REFRESH_BUFFER;
-  }
-  /**
-   * Get current access token
-   */
-  getAccessToken() {
-    return this.accessToken;
-  }
-  /**
-   * Get current refresh token
-   * @internal Used by auth module for token refresh
-   */
-  getRefreshToken() {
-    return this.refreshToken_;
-  }
-  /**
-   * Get client configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  /**
-   * Set tokens externally (useful for SSR or state management integration)
-   */
-  setTokens(accessToken, refreshToken, expiresAt) {
-    this.accessToken = accessToken;
-    this.refreshToken_ = refreshToken;
-    this.expiresAt = expiresAt;
-    saveToken("access_token", accessToken);
-    saveToken("refresh_token", refreshToken);
-    saveToken("expires_at", String(expiresAt));
-  }
-  // ── HTTP Methods (Internal) ─────────────────────────────────────────
-  /** @internal Make a GET request */
-  async get(endpoint, options) {
-    return this.request(endpoint, { method: "GET", ...options });
-  }
-  /** @internal Make a POST request */
-  async post(endpoint, body, options) {
-    return this.request(endpoint, { method: "POST", body, ...options });
-  }
-  /**
-   * Core HTTP request handler with automatic token refresh
-   * @internal
-   */
-  async request(endpoint, options) {
-    const { method, body, skipAuth = false } = options;
-    if (!skipAuth && this.isTokenExpired() && this.refreshToken_) {
-      await this.ensureTokenRefreshed();
-    }
-    const url = `${this.config.baseUrl}${endpoint}`;
-    const headers = {
-      "Content-Type": "application/json",
-      Accept: "application/json"
-    };
-    if (!skipAuth && this.accessToken) {
-      headers.Authorization = `Bearer ${this.accessToken}`;
-    }
-    if (this.config.debug) {
-      console.log(`[TalkenApiClient] ${method} ${url}`);
-    }
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(
-        () => controller.abort(),
-        this.config.timeout || 3e4
-      );
-      const response = await fetch(url, {
-        method,
-        headers,
-        body: body ? JSON.stringify(body) : void 0,
-        signal: controller.signal,
-        credentials: "include"
-      });
-      clearTimeout(timeoutId);
-      const text = await response.text();
-      let data;
-      if (text) {
-        try {
-          data = JSON.parse(text);
-        } catch {
-          throw new TalkenApiError(
-            "PARSE_ERROR",
-            "Invalid JSON response from server",
-            response.status,
-            { text: text.substring(0, 200) }
-          );
-        }
-      } else {
-        data = { success: true };
-      }
-      if (response.status === 401 && !skipAuth && this.refreshToken_) {
-        try {
-          await this.forceTokenRefresh();
-          return this.request(endpoint, { ...options, skipAuth: true });
-        } catch {
-          this.clearSession();
-          throw new TalkenApiError(
-            "TOKEN_EXPIRED",
-            "Session expired. Please login again.",
-            401
-          );
-        }
-      }
-      if (!response.ok) {
-        const errCode = data.error?.code || "UNKNOWN_ERROR";
-        const errMsg = data.error?.message || `Request failed with status ${response.status}`;
-        if (this.config.debug) {
-          console.error(`[TalkenApiClient] Error: ${errCode} - ${errMsg}`);
-        }
-        throw new TalkenApiError(
-          errCode,
-          errMsg,
-          response.status,
-          data.error?.details || data.details
-        );
-      }
-      return data.data ?? data;
-    } catch (error) {
-      if (error instanceof TalkenApiError) {
-        throw error;
-      }
-      if (error instanceof DOMException && error.name === "AbortError") {
-        throw new TalkenApiError("TIMEOUT", "Request timed out", 408);
-      }
-      const errorMessage = error instanceof Error ? error.message : "Network request failed";
-      throw new TalkenApiError("NETWORK_ERROR", errorMessage, 0);
-    }
-  }
-  /**
-   * Ensure token is refreshed (handles concurrent requests)
-   */
-  async ensureTokenRefreshed() {
-    if (this.isRefreshing && this.refreshPromise) {
-      await this.refreshPromise;
-      return;
-    }
-    await this.forceTokenRefresh();
-  }
-  /**
-   * Force a token refresh
-   */
-  async forceTokenRefresh() {
-    if (this.isRefreshing && this.refreshPromise) {
-      await this.refreshPromise;
-      return;
-    }
-    this.isRefreshing = true;
-    this.refreshPromise = (async () => {
-      try {
-        await this.auth.refresh();
-      } finally {
-        this.isRefreshing = false;
-        this.refreshPromise = null;
-      }
-    })();
-    await this.refreshPromise;
-  }
-};
-function createTalkenApiClient(config) {
-  return new TalkenApiClient(config);
-}
-
-export {
-  TalkenApiClient,
-  createTalkenApiClient
-};