@talken/talkenkit 2.4.16 → 2.4.17

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

@@ -0,0 +1,306 @@
+"use client";
+import {
+  secure_default
+} from "./chunk-ON4U54WO.js";
+import {
+  calculateExpiryTimestamp,
+  createAbcError,
+  isTokenExpired,
+  loadFromStorage,
+  parseApiError,
+  removeFromStorage,
+  saveToStorage
+} from "./chunk-BLEKTKBN.js";
+import {
+  ABC_ENDPOINTS,
+  DEFAULT_HEADERS,
+  REQUEST_TIMEOUT
+} from "./chunk-OBS74J5N.js";
+
+// src/wallets/walletConnectors/abcWallet/api/BaseApiClient.ts
+var BaseApiClient = class {
+  constructor(config) {
+    this.accessToken = null;
+    this.refreshToken = null;
+    this.expiresAt = null;
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+    this.config = config;
+    this.baseURL = config.waasUrl;
+    this.secure = new secure_default(this.baseURL);
+    this.loadTokens();
+  }
+  /**
+   * Load tokens from storage
+   */
+  loadTokens() {
+    this.accessToken = loadFromStorage("access_token" /* ACCESS_TOKEN */);
+    this.refreshToken = loadFromStorage("refresh_token" /* REFRESH_TOKEN */);
+    this.expiresAt = loadFromStorage("expires_at" /* EXPIRES_AT */);
+  }
+  /**
+   * Set tokens in client instance (useful when restoring from storage or state)
+   * Call this before making API requests if tokens are managed externally
+   */
+  setTokens(accessToken, refreshToken, expiresAt) {
+    this.accessToken = accessToken;
+    this.refreshToken = refreshToken;
+    this.expiresAt = expiresAt;
+  }
+  /**
+   * Save tokens to storage
+   */
+  saveTokens(accessToken, refreshToken, expiresIn) {
+    this.accessToken = accessToken;
+    this.refreshToken = refreshToken;
+    this.expiresAt = calculateExpiryTimestamp(expiresIn);
+    saveToStorage("access_token" /* ACCESS_TOKEN */, accessToken);
+    saveToStorage("refresh_token" /* REFRESH_TOKEN */, refreshToken);
+    saveToStorage("expires_at" /* EXPIRES_AT */, this.expiresAt);
+  }
+  /**
+   * Clear tokens
+   */
+  clearTokens() {
+    this.accessToken = null;
+    this.refreshToken = null;
+    this.expiresAt = null;
+    removeFromStorage("access_token" /* ACCESS_TOKEN */);
+    removeFromStorage("refresh_token" /* REFRESH_TOKEN */);
+    removeFromStorage("expires_at" /* EXPIRES_AT */);
+  }
+  /**
+   * Check if access token is expired
+   */
+  isTokenExpired() {
+    return isTokenExpired(this.expiresAt);
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  /**
+   * Set access token manually
+   */
+  setAccessToken(token) {
+    this.accessToken = token;
+  }
+  /**
+   * Get base URL
+   */
+  getBaseURL() {
+    return this.baseURL;
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Refresh access token
+   */
+  async refreshAccessToken() {
+    if (this.isRefreshing) {
+      if (this.refreshPromise) {
+        await this.refreshPromise;
+      }
+      return;
+    }
+    if (!this.refreshToken) {
+      throw createAbcError(
+        "TOKEN_EXPIRED" /* TOKEN_EXPIRED */,
+        "No refresh token available"
+      );
+    }
+    this.isRefreshing = true;
+    this.refreshPromise = (async () => {
+      try {
+        const isIframe = typeof window !== "undefined" && window.self !== window.top;
+        const talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+        const isProd = this.config.environment === "production";
+        const headers = { ...DEFAULT_HEADERS };
+        if (isProd) {
+          headers["User-Agent"] = "Android";
+        }
+        const response = await fetch(
+          `${talkenApiUrl}${ABC_ENDPOINTS.REFRESH_TOKEN}`,
+          {
+            method: "POST",
+            headers,
+            credentials: "include",
+            body: new URLSearchParams({
+              refresh_token: this.refreshToken || "",
+              isIframe: String(isIframe)
+            }).toString()
+          }
+        );
+        const text = await response.text();
+        const data = text ? JSON.parse(text) : {};
+        if (response.ok && data.access_token) {
+          const expiresIn = data.expire_in || 3600;
+          this.saveTokens(
+            data.access_token,
+            data.refresh_token || this.refreshToken,
+            expiresIn
+          );
+        } else {
+          throw createAbcError(
+            "TOKEN_EXPIRED" /* TOKEN_EXPIRED */,
+            "Failed to refresh token"
+          );
+        }
+      } finally {
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+      }
+    })();
+    await this.refreshPromise;
+  }
+  /**
+   * Make HTTP request with automatic token refresh
+   */
+  async request(endpoint, options = {}) {
+    const {
+      method = "GET",
+      body,
+      headers = {},
+      skipAuth = false,
+      isRetry = false,
+      contentType = "form"
+      // Default to form-encoded for backward compatibility
+    } = options;
+    if (!skipAuth && this.isTokenExpired() && this.refreshToken) {
+      await this.refreshAccessToken();
+    }
+    const url = `${this.baseURL}${endpoint}`;
+    const requestHeaders = {
+      ...DEFAULT_HEADERS,
+      ...headers
+    };
+    if (contentType === "json") {
+      requestHeaders["Content-Type"] = "application/json";
+      requestHeaders["Accept"] = "application/json";
+    }
+    if (this.config.environment === "production") {
+      requestHeaders["User-Agent"] = "Android";
+    }
+    if (!skipAuth && this.accessToken) {
+      requestHeaders.Authorization = `Bearer ${this.accessToken}`;
+    }
+    if (this.config.apiKey) {
+      requestHeaders["X-API-Key"] = this.config.apiKey;
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+      const requestBody = body ? contentType === "json" ? JSON.stringify(body) : new URLSearchParams(body).toString() : void 0;
+      const response = await fetch(url, {
+        method,
+        headers: requestHeaders,
+        body: requestBody,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const text = await response.text();
+      let data;
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch (parseError) {
+          console.error("[BaseApiClient] \u274C JSON parse error:", {
+            url,
+            method,
+            status: response.status,
+            responseText: text.substring(0, 200)
+          });
+          throw createAbcError(
+            "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+            "Invalid JSON response from server",
+            { text, parseError }
+          );
+        }
+      } else {
+        data = { status: "success" };
+      }
+      if (response.status === 401 && !skipAuth && this.refreshToken && !isRetry) {
+        try {
+          await this.refreshAccessToken();
+          return await this.request(endpoint, {
+            ...options,
+            isRetry: true
+          });
+        } catch (refreshError) {
+          console.error("Token refresh failed:", refreshError);
+          throw parseApiError({
+            response: {
+              status: response.status,
+              data
+            }
+          });
+        }
+      }
+      if (!response.ok) {
+        if (response.status !== 409) {
+          console.error("[BaseApiClient] \u274C API Error:", {
+            url,
+            method,
+            status: response.status,
+            statusText: response.statusText,
+            data
+          });
+        }
+        throw parseApiError({
+          response: {
+            status: response.status,
+            data
+          }
+        });
+      }
+      return data;
+    } catch (error) {
+      if (error.response?.status !== 409 && error.code !== "WALLET_ALREADY_EXISTS") {
+        console.error("[BaseApiClient] \u274C Request failed:", {
+          url,
+          method,
+          error: error.message
+        });
+      }
+      if (error.name === "AbortError") {
+        throw createAbcError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Request timeout",
+          error
+        );
+      }
+      if (error.code && error.message) {
+        throw error;
+      }
+      throw parseApiError(error);
+    }
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return !!this.accessToken && !this.isTokenExpired();
+  }
+  /**
+   * Logout (clear tokens)
+   */
+  async logout() {
+    this.clearTokens();
+  }
+  /**
+   * Get secure service instance
+   */
+  getSecureService() {
+    return this.secure;
+  }
+};
+
+export {
+  BaseApiClient
+};

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

@@ -0,0 +1,328 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-25V3FW3O.js";
+import {
+  createAbcError
+} from "./chunk-GO6OLTNF.js";
+
+// src/wallets/walletConnectors/abcWallet/api/TronApi.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var TronApi = class extends BaseApiClient {
+  /**
+   * Get TRON address from TalkenApiClient unified addresses endpoint.
+   *
+   * @param _publicKey - Compressed public key (unused, TalkenApiClient resolves internally)
+   * @param _network - TRON network (unused, TalkenApiClient resolves internally)
+   * @returns TRON address (starts with 'T')
+   */
+  async getTronAddress(_publicKey, _network) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    const addresses = await api.wallet.getAddresses();
+    if (!addresses.tron) {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "TRON address not found in TalkenApiClient response"
+      );
+    }
+    return addresses.tron;
+  }
+  /**
+   * Create unsigned TRX native transfer transaction
+   *
+   * @param params - Transfer parameters
+   * @returns Unsigned transaction with raw_data and txID
+   */
+  async transfer(params) {
+    const url = `${this.baseURL}/wapi/v2/tron/transfer`;
+    console.log("[TronApi] \u{1F4B8} Creating TRX transfer...", {
+      from: `${params.fromAddress.substring(0, 6)}...`,
+      to: `${params.toAddress.substring(0, 6)}...`,
+      amount: params.amount
+    });
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        network: params.network,
+        from_address: params.fromAddress,
+        to_address: params.toAddress,
+        amount: params.amount
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.status && data.status !== "success") {
+      console.error("[TronApi] \u274C Transfer creation failed:", data);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to create TRX transfer",
+        data
+      );
+    }
+    const result = data.result || data;
+    const txData = result.transaction || result;
+    const rawData = txData.raw_data;
+    const txID = txData.txID;
+    if (!rawData || !txID) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Invalid TRX transfer response: missing raw_data or txID",
+        data
+      );
+    }
+    console.log(
+      "[TronApi] \u2705 TRX transfer created:",
+      `${txID.substring(0, 16)}...`
+    );
+    return { txID, rawData };
+  }
+  /**
+   * Create unsigned TRC20 token transfer transaction
+   *
+   * @param params - TRC20 transfer parameters
+   * @returns Unsigned transaction with raw_data and txID
+   */
+  async trc20Transfer(params) {
+    const url = `${this.baseURL}/wapi/v2/tron/trc20/transfer`;
+    console.log("[TronApi] \u{1F4B8} Creating TRC20 transfer...", {
+      from: `${params.fromAddress.substring(0, 6)}...`,
+      to: `${params.toAddress.substring(0, 6)}...`,
+      contract: `${params.contractAddress.substring(0, 6)}...`
+    });
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        network: params.network,
+        from_address: params.fromAddress,
+        to_address: params.toAddress,
+        amount: params.amount,
+        contract_address: params.contractAddress,
+        fee_limit: params.feeLimit || 1e8
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.status && data.status !== "success") {
+      console.error("[TronApi] \u274C TRC20 transfer creation failed:", data);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to create TRC20 transfer",
+        data
+      );
+    }
+    const result = data.result || data;
+    const txData = result.transaction || result;
+    const rawData = txData.raw_data;
+    const txID = txData.txID;
+    if (!rawData || !txID) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Invalid TRC20 transfer response: missing raw_data or txID",
+        data
+      );
+    }
+    console.log(
+      "[TronApi] \u2705 TRC20 transfer created:",
+      `${txID.substring(0, 16)}...`
+    );
+    return { txID, rawData };
+  }
+  /**
+   * Sign transaction hash using Secure Channel (V2 sign/hash API)
+   * Same signing flow as Bitcoin - uses EVM wallet credentials via Secure Channel encryption
+   *
+   * @param hash - Transaction hash (txID) to sign
+   * @param wallet - EVM wallet credentials (uid, sid, wid, pvencstr, encryptDevicePassword)
+   * @param pinHash - Hashed PIN (SHA-256)
+   * @param secureService - SecureService instance for ECDH encryption
+   * @returns Array of signature strings (r + s without 0x prefix)
+   */
+  async signHash(hash, wallet, pinHash, secureService) {
+    console.log(
+      "[TronApi] \u{1F510} Signing hash:",
+      `${hash.substring(0, 20)}...`
+    );
+    if (!wallet.wid || !wallet.pvencstr) {
+      console.error("[TronApi] \u274C Missing signing fields:", {
+        hasWid: !!wallet.wid,
+        hasPvencstr: !!wallet.pvencstr,
+        hasSid: !!wallet.sid,
+        hasUid: !!wallet.uid
+      });
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Wallet missing required fields for TRON signing (wid, pvencstr)",
+        { hasWid: !!wallet.wid, hasPvencstr: !!wallet.pvencstr }
+      );
+    }
+    const encryptDevicePassword = await secureService.getEncryptPlain(
+      wallet.encryptDevicePassword || pinHash
+    );
+    const pvencstr = await secureService.getEncryptPlain(wallet.pvencstr);
+    const wid = await secureService.getEncryptPlain(wallet.wid);
+    const secureChannelId = await secureService.getSecureChannelId();
+    const params = new URLSearchParams({
+      uid: wallet.uid,
+      sid: wallet.sid || "",
+      hash,
+      pvencstr,
+      wid,
+      encryptDevicePassword,
+      network: "tron"
+    });
+    const url = `${this.baseURL}/wapi/v2/sign/hash`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Secure-Channel": secureChannelId,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: params.toString()
+    });
+    const responseText = await response.text();
+    if (!responseText) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Empty response from sign hash API",
+        { status: response.status }
+      );
+    }
+    let data;
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseError) {
+      console.error("[TronApi] \u274C JSON parse error:", parseError);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Invalid JSON response from sign hash API",
+        { responseText, parseError }
+      );
+    }
+    if (!response.ok || data.iserr === true || !data.signstr) {
+      const errorDetails = data.errmsg || data.errors?.[0] || data.message || data;
+      console.error("[TronApi] \u274C Sign failed:", errorDetails);
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        `Failed to sign hash: ${JSON.stringify(errorDetails)}`,
+        data
+      );
+    }
+    const signstr = JSON.parse(data.signstr);
+    const sigList = signstr.sig_list;
+    const signatures = [];
+    for (const sig of sigList) {
+      const r = sig.r.startsWith("0x") ? sig.r.substring(2) : sig.r;
+      const s = sig.s.startsWith("0x") ? sig.s.substring(2) : sig.s;
+      const v = (27 + (sig.vsource || 0)).toString(16);
+      signatures.push(r + s + v);
+    }
+    console.log(
+      "[TronApi] \u2705 Signature generated:",
+      `${signatures[0].length / 2} bytes,`,
+      `${signatures[0].substring(0, 16)}...${signatures[0].substring(signatures[0].length - 4)}`
+    );
+    return signatures;
+  }
+  /**
+   * Broadcast signed TRON transaction
+   *
+   * @param rawData - Raw transaction data from transfer/trc20Transfer
+   * @param signatures - Signatures from signHash
+   * @param network - TRON network
+   * @returns Transaction hash (txid)
+   */
+  async broadcast(rawData, signatures, network) {
+    const url = `${this.baseURL}/wapi/v2/tron/send/transaction`;
+    console.log("[TronApi] \u{1F4E1} Broadcasting TRON transaction...");
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        network,
+        raw_data: rawData,
+        signature: signatures
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.status && data.status !== "success") {
+      console.error("[TronApi] \u274C Broadcast failed:", data);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to broadcast TRON transaction",
+        data
+      );
+    }
+    const txHash = data.txid || data.txID || data.tx_hash;
+    if (!txHash) {
+      console.error("[TronApi] \u274C No txid in response:", data);
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Transaction hash not found in broadcast response",
+        data
+      );
+    }
+    console.log("[TronApi] \u2705 Transaction broadcasted:", txHash);
+    return txHash;
+  }
+  /**
+   * Send TRON transaction (Complete flow: transfer/trc20Transfer -> signHash -> broadcast)
+   * High-level API that handles all 3 steps
+   *
+   * @param params - Transaction parameters
+   * @param wallet - EVM wallet credentials
+   * @param pinHash - Hashed PIN
+   * @param secureService - SecureService instance
+   * @returns Transaction hash
+   */
+  async sendTransaction(params, wallet, pinHash, secureService) {
+    console.log("[TronApi] \u{1F4B8} Starting TRON transaction flow...");
+    let txID;
+    let rawData;
+    if (params.type === "TRC20" && params.contractAddress) {
+      const result = await this.trc20Transfer({
+        fromAddress: params.fromAddress,
+        toAddress: params.toAddress,
+        amount: params.amount,
+        contractAddress: params.contractAddress,
+        feeLimit: params.feeLimit,
+        network: params.network
+      });
+      txID = result.txID;
+      rawData = result.rawData;
+    } else {
+      const result = await this.transfer({
+        fromAddress: params.fromAddress,
+        toAddress: params.toAddress,
+        amount: Number(params.amount),
+        network: params.network
+      });
+      txID = result.txID;
+      rawData = result.rawData;
+    }
+    const signatures = await this.signHash(
+      txID,
+      wallet,
+      pinHash,
+      secureService
+    );
+    const txHash = await this.broadcast(rawData, signatures, params.network);
+    console.log("[TronApi] \u2705 Transaction complete:", txHash);
+    return txHash;
+  }
+};
+
+export {
+  TronApi
+};