@talken/talkenkit 2.4.16 → 2.4.18

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

@@ -0,0 +1,761 @@
+"use client";
+import {
+  TalkenApiError
+} from "./chunk-D5EFTEOM.js";
+import {
+  DEFAULT_TALKEN_API_CONFIG,
+  TALKEN_API_ENDPOINTS,
+  TOKEN_EXPIRY
+} from "./chunk-DHHVIM22.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/svm
+   * - kind='native': { toAddress, amountLamports, pin }
+   * - kind='spl':    { toAddress, mintAddress, amount, decimals, network, pin }
+   */
+  async transfer(params) {
+    return this.client.post(
+      TALKEN_API_ENDPOINTS.TX_SVM,
+      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
+};