@talken/talkenkit 2.4.17 → 2.4.19

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

@@ -1,1541 +0,0 @@
-"use client";
-import {
-  secure_default
-} from "./chunk-NG7PSAPX.js";
-import {
-  getSolanaNetwork
-} from "./chunk-O4AU63LK.js";
-import {
-  getNetworkName
-} from "./chunk-7QHCSJDN.js";
-import {
-  calculateExpiryTimestamp,
-  createAbcError,
-  isTokenExpired,
-  loadFromStorage,
-  parseApiError,
-  removeFromStorage,
-  saveToStorage
-} from "./chunk-GO6OLTNF.js";
-import {
-  ABC_AUDIENCE,
-  ABC_ENDPOINTS,
-  DEFAULT_HEADERS,
-  REQUEST_TIMEOUT
-} from "./chunk-YJH4BHSB.js";
-
-// src/wallets/walletConnectors/abcWallet/abcApi.ts
-import { getTalkenApiClient } from "@talken/talkenkit";
-import { parseGwei } from "viem";
-import { getAddress } from "viem";
-var AbcWaasClient = class {
-  constructor(config) {
-    this.accessToken = null;
-    this.refreshToken = null;
-    this.expiresAt = null;
-    this.isRefreshing = false;
-    this.refreshPromise = null;
-    this.talkenAuthPath = "/api/v1/wallet/auth";
-    this.config = config;
-    this.baseURL = config.waasUrl;
-    this.secure = new secure_default(this.baseURL);
-    this.loadTokens();
-  }
-  getTalkenApiUrl() {
-    return process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
-  }
-  async requestWalletAuth(body) {
-    const response = await fetch(
-      `${this.getTalkenApiUrl()}${this.talkenAuthPath}`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json"
-        },
-        credentials: "include",
-        body: JSON.stringify(body)
-      }
-    );
-    const text = await response.text();
-    const data = text ? JSON.parse(text) : {};
-    if (!response.ok) {
-      throw parseApiError({
-        response: {
-          status: response.status,
-          data
-        }
-      });
-    }
-    return data;
-  }
-  /**
-   * 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 */);
-  }
-  /**
-   * 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;
-  }
-  /**
-   * 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 response = await this.requestWalletAuth({
-          action: "token.refresh",
-          refreshToken: this.refreshToken || "",
-          isIframe
-        });
-        const data = response?.data || {};
-        if (response?.success && data.access_token) {
-          const expiresIn = data.expires_in || data.expire_in || 3600;
-          this.saveTokens(
-            data.access_token,
-            data.refresh_token || this.refreshToken,
-            // Keep old if not provided
-            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
-   */
-  async request(endpoint, options = {}) {
-    const {
-      method = "GET",
-      body,
-      headers = {},
-      skipAuth = false,
-      isRetry = false
-    } = options;
-    if (!skipAuth && this.isTokenExpired() && this.refreshToken) {
-      await this.refreshAccessToken();
-    }
-    const url = `${this.baseURL}${endpoint}`;
-    const requestHeaders = {
-      ...DEFAULT_HEADERS,
-      ...headers
-    };
-    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 ? 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("[AbcWaasClient] \u274C JSON parse error:", {
-            url,
-            method,
-            status: response.status,
-            responseText: text.substring(0, 200)
-            // Log first 200 chars
-          });
-          throw createAbcError(
-            "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-            "Invalid JSON response from server",
-            { text, parseError }
-          );
-        }
-      } else {
-        console.log("[AbcWaasClient] \u2139\uFE0F Empty response received:", {
-          url,
-          method,
-          status: response.status
-        });
-        data = { status: "success" };
-      }
-      if (response.status === 401 && !skipAuth && this.refreshToken && !isRetry) {
-        try {
-          await this.refreshAccessToken();
-          return await this.request(endpoint, {
-            ...options,
-            isRetry: true
-            // Prevent infinite retry loop
-          });
-        } catch (refreshError) {
-          console.error("Token refresh failed:", refreshError);
-          throw parseApiError({
-            response: {
-              status: response.status,
-              data
-            }
-          });
-        }
-      }
-      if (!response.ok) {
-        console.error("[AbcWaasClient] \u274C API Error:", {
-          url,
-          method,
-          status: response.status,
-          statusText: response.statusText,
-          data
-        });
-        throw parseApiError({
-          response: {
-            status: response.status,
-            data
-          }
-        });
-      }
-      return data;
-    } catch (error) {
-      console.error("[AbcWaasClient] \u274C Request failed:", {
-        url,
-        method,
-        error: error.message,
-        errorName: error.name,
-        errorType: error.constructor.name,
-        stack: error.stack
-      });
-      if (error.name === "AbortError") {
-        throw createAbcError(
-          "NETWORK_ERROR" /* NETWORK_ERROR */,
-          "Request timeout",
-          error
-        );
-      }
-      if (error.code && error.message) {
-        throw error;
-      }
-      throw parseApiError(error);
-    }
-  }
-  /**
-   * Login with email and password
-   * NOTE: Tokens are stored in memory only. Call persistTokens() after PIN verification to save to localStorage.
-   */
-  async loginWithEmail(email, password) {
-    const response = await this.request(
-      ABC_ENDPOINTS.SNS_LOGIN,
-      {
-        method: "POST",
-        body: {
-          email,
-          token: password,
-          // Use password as token
-          service: "email",
-          audience: ABC_AUDIENCE
-        },
-        skipAuth: true
-      }
-    );
-    if (response.status === "success" && response.data) {
-      this.accessToken = response.data.accessToken;
-      this.refreshToken = response.data.refreshToken;
-      this.expiresAt = calculateExpiryTimestamp(response.data.expiresIn);
-      console.log(
-        "[AbcWaasClient] \u2705 Login successful, tokens stored in memory (not persisted yet)"
-      );
-      return response.data;
-    }
-    throw createAbcError(
-      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
-      "Email login failed",
-      response
-    );
-  }
-  /**
-   * Login with email and OTP (for PIN recovery)
-   * NOTE: Tokens are stored in memory only. Call persistTokens() after PIN verification to save to localStorage.
-   */
-  async loginWithOtp(email, otpCode) {
-    const response = await this.request(
-      ABC_ENDPOINTS.SNS_LOGIN,
-      {
-        method: "POST",
-        body: {
-          email,
-          token: otpCode,
-          service: "email",
-          audience: ABC_AUDIENCE
-        },
-        skipAuth: true
-      }
-    );
-    if (response.status === "success" && response.data) {
-      this.accessToken = response.data.accessToken;
-      this.refreshToken = response.data.refreshToken;
-      this.expiresAt = calculateExpiryTimestamp(response.data.expiresIn);
-      console.log(
-        "[AbcWaasClient] \u2705 OTP login successful, tokens stored in memory (not persisted yet)"
-      );
-      return response.data;
-    }
-    throw createAbcError(
-      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
-      "OTP login failed",
-      response
-    );
-  }
-  /**
-   * Login with social provider
-   * NOTE: Tokens are stored in memory only. Call persistTokens() after PIN verification to save to localStorage.
-   */
-  async loginWithSocial(provider, token, email) {
-    const response = await this.request(
-      ABC_ENDPOINTS.SNS_LOGIN,
-      {
-        method: "POST",
-        body: {
-          token,
-          service: provider,
-          audience: ABC_AUDIENCE,
-          email
-        },
-        skipAuth: true
-      }
-    );
-    if (response.status === "success" && response.data) {
-      this.accessToken = response.data.accessToken;
-      this.refreshToken = response.data.refreshToken;
-      this.expiresAt = calculateExpiryTimestamp(response.data.expiresIn);
-      console.log(
-        "[AbcWaasClient] \u2705 Social login successful, tokens stored in memory (not persisted yet)"
-      );
-      return response.data;
-    }
-    throw createAbcError(
-      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
-      "Social login failed",
-      response
-    );
-  }
-  /**
-   * Refresh access token using refresh token (public wrapper)
-   */
-  async refreshTokens(refreshTokenValue) {
-    const oldRefreshToken = this.refreshToken;
-    this.refreshToken = refreshTokenValue;
-    try {
-      await this.refreshAccessToken();
-      return {
-        accessToken: this.accessToken,
-        refreshToken: this.refreshToken,
-        expiresIn: Math.floor((this.expiresAt - Date.now()) / 1e3)
-      };
-    } catch (error) {
-      this.refreshToken = oldRefreshToken;
-      throw error;
-    }
-  }
-  /**
-   * Request OTP code for email
-   */
-  async requestOtpCode(email) {
-    const response = await this.request(
-      ABC_ENDPOINTS.SEND_OTP,
-      {
-        method: "POST",
-        body: { email },
-        skipAuth: true
-      }
-    );
-    if (response.status === "success" && response.data) {
-      return response.data;
-    }
-    throw createAbcError(
-      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-      "Failed to request OTP",
-      response
-    );
-  }
-  /**
-   * Verify OTP code
-   */
-  async verifyOtpCode(email, code) {
-    const response = await this.request(ABC_ENDPOINTS.VERIFY_OTP, {
-      method: "POST",
-      body: { email, code },
-      skipAuth: true
-    });
-    return response.status === "success";
-  }
-  /**
-   * Check if email already exists
-   * Reference: tg-wallet-frontend src/features/user/api/index.ts:63-69
-   */
-  async emailCheck(email) {
-    const result = await this.requestWalletAuth({
-      action: "email.check",
-      email
-    });
-    return result?.data || result;
-  }
-  /**
-   * Send OTP code to email for signup
-   * Reference: tg-wallet-frontend src/features/user/api/index.ts:105-110
-   * Note: Uses ABC WaaS endpoint, not Talken API
-   */
-  async sendOtpCode(email) {
-    const result = await this.requestWalletAuth({
-      action: "otp.send",
-      email
-    });
-    return result?.data || result;
-  }
-  /**
-   * Verify OTP code for signup
-   * Reference: tg-wallet-frontend src/features/user/api/index.ts:112-123
-   * Note: Uses ABC WaaS endpoint, not Talken API
-   */
-  async verifyOtpCodeSignup(email, code) {
-    const result = await this.requestWalletAuth({
-      action: "otp.verify",
-      email,
-      otpCode: code
-    });
-    return result?.data || result;
-  }
-  /**
-   * SNS (Social) Login via Google/Apple/Kakao
-   * Reference: tg-wallet-frontend src/features/user/api/index.ts:43-51
-   * Note: Uses Talken API server, not ABC WaaS
-   */
-  async snsLogin(params) {
-    try {
-      const result = await this.requestWalletAuth({
-        action: "login",
-        method: "sns",
-        token: params.token,
-        service: params.service,
-        audience: params.audience
-      });
-      const data = result?.data || {};
-      if (!data.access_token) {
-        throw createAbcError(
-          "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
-          "SNS login failed: Invalid response from server",
-          { service: params.service, response: data }
-        );
-      }
-      console.log("[AbcWaasClient] \u2705 SNS login successful");
-      return {
-        uid: "",
-        // Will be fetched later via info() API
-        email: params.email,
-        access_token: data.access_token,
-        refresh_token: data.refresh_token,
-        user_type: "existing"
-        // Default to existing, will be determined later
-      };
-    } catch (error) {
-      if (error.name === "AbortError") {
-        throw createAbcError(
-          "NETWORK_ERROR" /* NETWORK_ERROR */,
-          "SNS login request timeout",
-          error
-        );
-      }
-      throw error;
-    }
-  }
-  /**
-   * Register new user
-   * Reference: tg-wallet-frontend src/features/user/api/index.ts:71-78
-   * Note: Uses Talken API server, not ABC WaaS
-   */
-  async registerUser(params) {
-    const result = await this.requestWalletAuth({
-      action: "register",
-      email: params.username,
-      otpCode: params.emailCode,
-      password: params.password,
-      name: params.name
-    });
-    return result?.data || result;
-  }
-  /**
-   * Register new SNS user (email-based registration with OTP)
-   * Reference: tg-wallet-frontend src/features/user/api/index.ts:80-87
-   * Note: Uses Talken API server, not ABC WaaS
-   */
-  async registerSnsUser(params) {
-    const talkenApiUrl = this.getTalkenApiUrl();
-    const response = await fetch(`${talkenApiUrl}/abc/snsAdduser`, {
-      method: "POST",
-      headers: {
-        ...DEFAULT_HEADERS
-      },
-      credentials: "include",
-      body: new URLSearchParams(params).toString()
-    });
-    const text = await response.text();
-    const data = text ? JSON.parse(text) : { status: "success" };
-    if (!response.ok) {
-      throw parseApiError({
-        response: {
-          status: response.status,
-          data
-        }
-      });
-    }
-    return data;
-  }
-  /**
-   * Reset/Set password for existing user
-   * Reference: tg-wallet-frontend src/features/user/api/index.ts:89-95
-   * Note: Uses Talken API server, not ABC WaaS
-   */
-  async resetPassword(params) {
-    const result = await this.requestWalletAuth({
-      action: "password.reset",
-      email: params.username,
-      newPassword: params.password,
-      emailCode: params.emailCode
-    });
-    return result?.data || result;
-  }
-  /**
-   * Generate or recover wallet
-   */
-  async generateOrRecoverWallet(params) {
-    const response = await this.request(
-      // Use 'any' to get raw API response
-      ABC_ENDPOINTS.MPC_WALLETS,
-      // Use correct EVM endpoint, not WALLETS_V3 (Solana only)
-      {
-        method: "POST",
-        body: {
-          uid: params.uid,
-          pin: params.pin,
-          chainId: params.chainId,
-          network: params.network || "mainnet"
-        }
-      }
-    );
-    if (response.status === "success" && response.data) {
-      const raw = response.data;
-      console.log("[AbcWaasClient] Raw wallet API response:", {
-        hasUid: !!raw.uid,
-        hasSid: !!raw.sid,
-        hasKeyId: !!raw.key_id,
-        hasWid: !!raw.wid,
-        hasPvencstr: !!raw.pvencstr,
-        hasEncryptDevicePassword: !!raw.encryptDevicePassword,
-        hasEncryptedShare: !!raw.encrypted_share,
-        hasPubkey: !!raw.pubkey,
-        allKeys: Object.keys(raw)
-      });
-      return {
-        address: raw.sid || "",
-        // FIX: sid is the EVM address
-        keyId: raw.key_id || raw.keyId || raw.sid,
-        encryptedShare: raw.encrypted_share || raw.key_id || "",
-        // Use key_id as fallback
-        uid: raw.uid,
-        sid: raw.sid,
-        wid: raw.wid,
-        // Preserve for Bitcoin signing
-        pvencstr: raw.pvencstr,
-        // Preserve for Bitcoin signing
-        encryptDevicePassword: raw.encryptDevicePassword,
-        // Preserve for Bitcoin signing
-        pubkey: raw.pubkey || null
-      };
-    }
-    throw createAbcError(
-      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-      "Failed to generate wallet",
-      response
-    );
-  }
-  /**
-   * Sign EVM transaction (EIP-1559)
-   * Based on ABC WaaS official documentation
-   */
-  async signTransaction(params) {
-    this.loadTokens();
-    const wallet = loadFromStorage("wallet" /* WALLET */);
-    if (!wallet) {
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Wallet information not found in storage"
-      );
-    }
-    const encryptedDevicePassword = await this.secure.getEncryptPlain(
-      wallet.encryptDevicePassword
-    );
-    const encryptedPvencstr = await this.secure.getEncryptPlain(
-      wallet.pvencstr
-    );
-    const encryptedWid = await this.secure.getEncryptPlain(wallet.wid);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const network = getNetworkName(params.chainId);
-    const tx = params.transaction;
-    if (!tx.maxFeePerGas || !tx.maxPriorityFeePerGas || !tx.gasLimit || !tx.gas) {
-      try {
-        const api = getTalkenApiClient();
-        if (api && (!tx.maxFeePerGas || !tx.maxPriorityFeePerGas)) {
-          try {
-            const gasData = await api.evm.getGasSuggested(network);
-            if (gasData.medium) {
-              if (!tx.maxFeePerGas) {
-                tx.maxFeePerGas = parseGwei(
-                  gasData.medium.suggestedMaxFeePerGas
-                ).toString();
-              }
-              if (!tx.maxPriorityFeePerGas) {
-                tx.maxPriorityFeePerGas = parseGwei(
-                  gasData.medium.suggestedMaxPriorityFeePerGas
-                ).toString();
-              }
-            }
-          } catch (gasError) {
-            console.warn("[AbcWaasClient] Failed to fetch gas fees:", gasError);
-          }
-        }
-        if (api && !tx.gasLimit && !tx.gas) {
-          try {
-            const estimateResult = await api.evm.estimateGas({
-              network,
-              from: tx.from || "",
-              to: tx.to || "0x",
-              value: tx.value,
-              data: tx.data && tx.data !== "0x" ? tx.data : void 0
-            });
-            if (estimateResult.result) {
-              tx.gasLimit = estimateResult.result;
-            } else {
-              tx.gasLimit = "0x2dc6c0";
-            }
-          } catch (estimateError) {
-            console.warn(
-              "[AbcWaasClient] Failed to estimate gas:",
-              estimateError
-            );
-            tx.gasLimit = "0x2dc6c0";
-          }
-        }
-      } catch (error) {
-        console.warn("[AbcWaasClient] Failed to fetch gas parameters:", error);
-      }
-    }
-    const bodyData = {
-      network,
-      encryptDevicePassword: encryptedDevicePassword,
-      pvencstr: encryptedPvencstr,
-      uid: wallet.uid,
-      wid: encryptedWid,
-      sid: getAddress(wallet.address),
-      // EIP-55 checksum format
-      // For contract deployment, 'to' is '0x' (ABC WaaS convention)
-      // Reference: talken-nft-drops/src/libs/abc-waas-provider/index.ts:800 - to: to ?? '0x'
-      to: tx.to === "0x" ? "0x" : getAddress(tx.to),
-      // Required by ABC WaaS API
-      // Always use EIP1559 type (ABC WaaS handles network-specific conversion)
-      type: "EIP1559",
-      // ourpubkey and ucpubkey are required by ABC WaaS (empty strings for now)
-      // Based on successful tg-wallet payload analysis
-      ourpubkey: "",
-      ucpubkey: ""
-    };
-    bodyData.from = getAddress(tx.from || wallet.address);
-    if (tx.value) {
-      let hexValue = tx.value.startsWith("0x") ? tx.value.slice(2) : tx.value;
-      if (hexValue.length % 2 !== 0) {
-        hexValue = `0${hexValue}`;
-      }
-      bodyData.value = `0x${hexValue}`;
-    } else {
-      bodyData.value = "0x0";
-    }
-    if (tx.gasLimit || tx.gas) {
-      const gasLimitValue = tx.gasLimit || tx.gas;
-      if (gasLimitValue.toString().startsWith("0x")) {
-        bodyData.gasLimit = gasLimitValue.toString();
-      } else {
-        bodyData.gasLimit = `0x${BigInt(gasLimitValue).toString(16)}`;
-      }
-    }
-    if (tx.maxFeePerGas) {
-      if (tx.maxFeePerGas.toString().startsWith("0x")) {
-        bodyData.maxFeePerGas = tx.maxFeePerGas.toString();
-      } else {
-        bodyData.maxFeePerGas = `0x${BigInt(tx.maxFeePerGas).toString(16)}`;
-      }
-    }
-    if (tx.maxPriorityFeePerGas) {
-      if (tx.maxPriorityFeePerGas.toString().startsWith("0x")) {
-        bodyData.maxPriorityFeePerGas = tx.maxPriorityFeePerGas.toString();
-      } else {
-        bodyData.maxPriorityFeePerGas = `0x${BigInt(tx.maxPriorityFeePerGas).toString(16)}`;
-      }
-    }
-    if (tx.gasPrice) {
-      if (tx.gasPrice.toString().startsWith("0x")) {
-        bodyData.gasPrice = tx.gasPrice.toString();
-      } else {
-        bodyData.gasPrice = `0x${BigInt(tx.gasPrice).toString(16)}`;
-      }
-    }
-    if (tx.data !== void 0 && tx.data !== null) {
-      bodyData.data = tx.data || "0x";
-    } else {
-      bodyData.data = "0x";
-    }
-    const bodyString = new URLSearchParams(bodyData).toString();
-    const url = `${this.baseURL}${ABC_ENDPOINTS.SIGN_TRANSACTION}`;
-    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: bodyString
-    });
-    const res = await response.json();
-    console.log("\u{1F4E1} ABC WaaS /sign response:", {
-      status: response.status,
-      ok: response.ok,
-      response: res
-    });
-    if (!response.ok) {
-      console.error("\u274C ABC WaaS API error details:", {
-        status: response.status,
-        statusText: response.statusText,
-        errorCode: res.code,
-        errorMessage: res.msg || res.message || res.detail,
-        fullResponse: res
-      });
-    }
-    if (response.status === 401 && this.refreshToken) {
-      try {
-        await this.refreshAccessToken();
-        const retryResponse = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Secure-Channel": secureChannelId,
-            ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-          },
-          body: bodyString
-        });
-        const retryRes = await retryResponse.json();
-        if (retryRes.serializedTx && retryRes.rawTx) {
-          return {
-            signature: retryRes.serializedTx,
-            txHash: retryRes.rawTx
-          };
-        }
-        throw createAbcError(
-          "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-          "Failed to sign transaction after token refresh",
-          retryRes
-        );
-      } catch (refreshError) {
-        console.error("Token refresh failed in signTransaction:", refreshError);
-        throw refreshError;
-      }
-    }
-    if (res.serializedTx && res.rawTx) {
-      return {
-        signature: res.serializedTx,
-        txHash: res.rawTx
-      };
-    }
-    throw createAbcError(
-      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-      "Failed to sign transaction",
-      res
-    );
-  }
-  /**
-   * Sign message (Personal Sign - EIP-191)
-   * Based on tg-wallet-frontend reference implementation
-   */
-  async signMessage(params) {
-    this.loadTokens();
-    const wallet = loadFromStorage("wallet" /* WALLET */);
-    if (!wallet) {
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Wallet information not found in storage"
-      );
-    }
-    const ethers = await import("ethers");
-    const messageHash = ethers.utils.hashMessage(params.message);
-    const hash = messageHash.startsWith("0x") ? messageHash.slice(2) : messageHash;
-    const encryptedDevicePassword = await this.secure.getEncryptPlain(
-      wallet.encryptDevicePassword
-    );
-    const encryptedPvencstr = await this.secure.getEncryptPlain(
-      wallet.pvencstr
-    );
-    const encryptedWid = await this.secure.getEncryptPlain(wallet.wid);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const bodyData = {
-      hash,
-      encryptDevicePassword: encryptedDevicePassword,
-      pvencstr: encryptedPvencstr,
-      wid: encryptedWid,
-      uid: wallet.uid,
-      sid: wallet.sid
-    };
-    const bodyString = new URLSearchParams(bodyData).toString();
-    const url = `${this.baseURL}${ABC_ENDPOINTS.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: bodyString
-    });
-    const text = await response.text();
-    if (!text) {
-      throw createAbcError(
-        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        `Empty response from sign API (status: ${response.status})`,
-        { status: response.status }
-      );
-    }
-    const res = JSON.parse(text);
-    if (response.status === 401) {
-      if (!this.refreshToken) {
-        this.loadTokens();
-      }
-      if (this.refreshToken) {
-        try {
-          await this.refreshAccessToken();
-          const retryResponse = await fetch(url, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/x-www-form-urlencoded",
-              "Secure-Channel": secureChannelId,
-              ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-            },
-            body: bodyString
-          });
-          const retryText = await retryResponse.text();
-          if (!retryText) {
-            throw createAbcError(
-              "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-              `Empty response from retry (status: ${retryResponse.status})`,
-              { status: retryResponse.status }
-            );
-          }
-          const retryRes = JSON.parse(retryText);
-          if (retryRes.status === "success" && retryRes.result?.signstr) {
-            return { signature: retryRes.result.signstr };
-          }
-          throw createAbcError(
-            "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-            "Failed to sign message after token refresh",
-            retryRes
-          );
-        } catch (refreshError) {
-          console.error("Token refresh failed in signMessage:", refreshError);
-          throw refreshError;
-        }
-      }
-    }
-    if (res.signstr) {
-      const signData = JSON.parse(res.signstr);
-      const sigList = signData.sig_list?.[0];
-      if (!sigList || !sigList.r || !sigList.s) {
-        throw createAbcError(
-          "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-          "Invalid signature format",
-          res
-        );
-      }
-      const v = (sigList.vsource || 0) + 27;
-      const signature = sigList.r + sigList.s.slice(2) + v.toString(16).padStart(2, "0");
-      return { signature };
-    }
-    throw createAbcError(
-      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-      "Failed to sign message",
-      res
-    );
-  }
-  /**
-   * Sign typed data (EIP-712)
-   * Reference: tg-wallet-frontend src/features/wallet/api/index.ts sign_typed_data()
-   */
-  async signTypedData(params) {
-    this.loadTokens();
-    const wallet = loadFromStorage("wallet" /* WALLET */);
-    if (!wallet) {
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Wallet information not found in storage"
-      );
-    }
-    const encryptedDevicePassword = await this.secure.getEncryptPlain(
-      wallet.encryptDevicePassword
-    );
-    const encryptedPvencstr = await this.secure.getEncryptPlain(
-      wallet.pvencstr
-    );
-    const encryptedWid = await this.secure.getEncryptPlain(wallet.wid);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const network = getNetworkName(wallet.chainId);
-    const bodyData = {
-      messageJson: params.typedData,
-      // Server expects "messageJson" field
-      version: "v4",
-      // EIP-712 version
-      network,
-      // Network name (required for JSON-RPC)
-      encryptDevicePassword: encryptedDevicePassword,
-      pvencstr: encryptedPvencstr,
-      wid: encryptedWid,
-      uid: wallet.uid,
-      sid: wallet.sid
-    };
-    const bodyString = new URLSearchParams(bodyData).toString();
-    const url = `${this.baseURL}${ABC_ENDPOINTS.SIGN_TYPED}`;
-    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: bodyString
-    });
-    const text = await response.text();
-    if (!text) {
-      throw createAbcError(
-        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        `Empty response from signTypedData API (status: ${response.status})`,
-        { status: response.status }
-      );
-    }
-    const res = JSON.parse(text);
-    if (response.status === 401 && this.refreshToken) {
-      try {
-        await this.refreshAccessToken();
-        const retryResponse = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Secure-Channel": secureChannelId,
-            ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-          },
-          body: bodyString
-        });
-        const retryText = await retryResponse.text();
-        if (!retryText) {
-          throw createAbcError(
-            "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-            `Empty response after retry (status: ${retryResponse.status})`,
-            { status: retryResponse.status }
-          );
-        }
-        const retryRes = JSON.parse(retryText);
-        if (retryRes.serializedTx) {
-          return { signature: retryRes.serializedTx };
-        }
-        throw createAbcError(
-          "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-          "Failed to sign typed data after token refresh",
-          retryRes
-        );
-      } catch (refreshError) {
-        console.error("Token refresh failed in signTypedData:", refreshError);
-        throw refreshError;
-      }
-    }
-    if (res.serializedTx) {
-      return { signature: res.serializedTx };
-    }
-    throw createAbcError(
-      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-      "Failed to sign typed data",
-      res
-    );
-  }
-  /**
-   * Send raw transaction
-   * Reference: tg-wallet-frontend src/features/wallet/api/index.ts sendRawTx()
-   */
-  async sendRawTransaction(chainId, signedTransaction) {
-    const wallet = loadFromStorage("wallet" /* WALLET */);
-    if (!wallet) {
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Wallet information not found in storage"
-      );
-    }
-    const network = getNetworkName(chainId);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const bodyData = {
-      signedSerializeTx: signedTransaction,
-      network
-      // rpc parameter
-    };
-    const bodyString = new URLSearchParams(bodyData).toString();
-    const url = `${this.baseURL}${ABC_ENDPOINTS.SEND_RAW_TX}`;
-    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: bodyString
-    });
-    const text = await response.text();
-    if (!text) {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        `Empty response from sendRawTx API (status: ${response.status})`,
-        { status: response.status }
-      );
-    }
-    const res = JSON.parse(text);
-    console.log("\u{1F4E1} sendRawTransaction response:", {
-      status: response.status,
-      ok: response.ok,
-      response: res
-    });
-    if (!response.ok) {
-      console.error("\u274C sendRawTransaction error:", {
-        status: response.status,
-        errorMessage: res.errorMessage || res.msg || res.message,
-        fullResponse: res
-      });
-    }
-    if (response.status === 401 && this.refreshToken) {
-      try {
-        await this.refreshAccessToken();
-        const retryResponse = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Secure-Channel": secureChannelId,
-            ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-          },
-          body: bodyString
-        });
-        const retryText = await retryResponse.text();
-        if (!retryText) {
-          throw createAbcError(
-            "NETWORK_ERROR" /* NETWORK_ERROR */,
-            `Empty response after retry (status: ${retryResponse.status})`,
-            { status: retryResponse.status }
-          );
-        }
-        const retryRes = JSON.parse(retryText);
-        if (retryRes.item || retryRes.txHash || retryRes.result?.txHash) {
-          const txHash = retryRes.item || retryRes.txHash || retryRes.result.txHash;
-          return { txHash };
-        }
-        throw createAbcError(
-          "NETWORK_ERROR" /* NETWORK_ERROR */,
-          "Failed to send transaction after token refresh",
-          retryRes
-        );
-      } catch (refreshError) {
-        console.error(
-          "Token refresh failed in sendRawTransaction:",
-          refreshError
-        );
-        throw refreshError;
-      }
-    }
-    if (res.result) {
-      if (typeof res.result === "string") {
-        console.log("\u2705 Transaction hash from result:", res.result);
-        return { txHash: res.result };
-      }
-      if (res.result.txHash) {
-        return { txHash: res.result.txHash };
-      }
-    }
-    if (res.item) {
-      return { txHash: res.item };
-    }
-    if (res.txHash) {
-      return { txHash: res.txHash };
-    }
-    throw createAbcError(
-      "NETWORK_ERROR" /* NETWORK_ERROR */,
-      "Failed to send transaction",
-      res
-    );
-  }
-  /**
-   * Estimate gas for EIP-1559 transaction
-   * Routes through TalkenApiClient (talken-api proxy)
-   */
-  async estimateGas(params) {
-    const network = getNetworkName(params.chainId);
-    const api = getTalkenApiClient();
-    if (!api) {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "TalkenApiClient not initialized"
-      );
-    }
-    try {
-      const result = await api.evm.estimateGas({
-        network,
-        from: params.from || "",
-        to: params.to,
-        value: params.value,
-        data: params.data
-      });
-      if (result.result) {
-        return result.result;
-      }
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "No result in gas estimate response"
-      );
-    } catch (error) {
-      if (error?.code === "NETWORK_ERROR" /* NETWORK_ERROR */) {
-        throw error;
-      }
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        error.message || "Failed to estimate gas"
-      );
-    }
-  }
-  /**
-   * Get transaction count (nonce)
-   * Reference: ABC WaaS API - /wapi/v2/transactions/count
-   */
-  async getTransactionCount(params) {
-    const network = getNetworkName(params.chainId);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const bodyData = {
-      network,
-      address: params.address
-    };
-    const bodyString = new URLSearchParams(bodyData).toString();
-    const url = `${this.baseURL}${ABC_ENDPOINTS.TRANSACTION_COUNT}`;
-    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: bodyString
-    });
-    const text = await response.text();
-    if (!text) {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        `Empty response from transaction count API (status: ${response.status})`,
-        { status: response.status }
-      );
-    }
-    const res = JSON.parse(text);
-    if (response.status === 401 && this.refreshToken) {
-      try {
-        await this.refreshAccessToken();
-        const retryResponse = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Secure-Channel": secureChannelId,
-            ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-          },
-          body: bodyString
-        });
-        const retryText = await retryResponse.text();
-        if (!retryText) {
-          throw createAbcError(
-            "NETWORK_ERROR" /* NETWORK_ERROR */,
-            `Empty response after retry (status: ${retryResponse.status})`,
-            { status: retryResponse.status }
-          );
-        }
-        const retryRes = JSON.parse(retryText);
-        if (retryRes.result !== void 0) {
-          return typeof retryRes.result === "number" ? `0x${retryRes.result.toString(16)}` : retryRes.result;
-        }
-        throw createAbcError(
-          "NETWORK_ERROR" /* NETWORK_ERROR */,
-          "Failed to get transaction count after token refresh",
-          retryRes
-        );
-      } catch (refreshError) {
-        console.error(
-          "Token refresh failed in getTransactionCount:",
-          refreshError
-        );
-        throw refreshError;
-      }
-    }
-    if (res.result !== void 0) {
-      return typeof res.result === "number" ? `0x${res.result.toString(16)}` : res.result;
-    }
-    throw createAbcError(
-      "NETWORK_ERROR" /* NETWORK_ERROR */,
-      res.errorMessage || res.msg || "Failed to get transaction count",
-      res
-    );
-  }
-  /**
-   * Get wallet info
-   */
-  async getWalletInfo(uid) {
-    const response = await this.request(ABC_ENDPOINTS.INFO, {
-      method: "POST",
-      body: { uid }
-    });
-    if (response.status === "success") {
-      return response.data;
-    }
-    throw createAbcError(
-      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-      "Failed to get wallet info",
-      response
-    );
-  }
-  /**
-   * Logout (clear tokens)
-   */
-  async logout() {
-    this.clearTokens();
-  }
-  /**
-   * Check if user is authenticated
-   */
-  isAuthenticated() {
-    return !!this.accessToken && !this.isTokenExpired();
-  }
-  /**
-   * Set tokens in client instance (useful when restoring from storage or state)
-   * Call this before persistTokens() if you need to set tokens from external source
-   */
-  setTokens(accessToken, refreshToken, expiresAt) {
-    this.accessToken = accessToken;
-    this.refreshToken = refreshToken;
-    this.expiresAt = expiresAt;
-  }
-  /**
-   * Persist tokens to localStorage
-   * Call this after PIN verification is complete
-   *
-   * SECURITY NOTE: This should only be called after full authentication (password + PIN)
-   * to ensure tokens are only persisted after the user has proven ownership of both credentials.
-   */
-  persistTokens() {
-    if (!this.accessToken || !this.refreshToken || !this.expiresAt) {
-      console.warn(
-        "[AbcWaasClient] \u26A0\uFE0F No tokens to persist - ensure login was successful first"
-      );
-      return;
-    }
-    console.log(
-      "[AbcWaasClient] \u{1F4BE} Persisting tokens to localStorage after PIN verification"
-    );
-    saveToStorage("access_token" /* ACCESS_TOKEN */, this.accessToken);
-    saveToStorage("refresh_token" /* REFRESH_TOKEN */, this.refreshToken);
-    saveToStorage("expires_at" /* EXPIRES_AT */, this.expiresAt);
-  }
-  // ==========================================================================
-  // Solana Methods
-  // ==========================================================================
-  /**
-   * Generate or recover Solana wallet (Ed25519)
-   * Reference: SigningService.ts:56-72, wallet/api/index.ts:56-72
-   */
-  async generateSolanaWallet(pin, isRecover = false) {
-    const url = `${this.baseURL}/v3/wallet/${isRecover ? "recover" : "generate"}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        // V3 API requires JSON, not form-urlencoded
-        Accept: "application/json",
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify({
-        curve: "ed25519",
-        password: pin
-        // PIN will be encrypted by Secure Channel
-        // Note: network parameter not needed for v3 API
-      })
-    });
-    let data;
-    try {
-      data = await response.json();
-    } catch (e) {
-      console.error(`[AbcWaasClient] Failed to parse response from ${url}:`, e);
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        `Failed to ${isRecover ? "recover" : "generate"} Solana wallet - invalid response`,
-        { status: response.status }
-      );
-    }
-    if (!response.ok) {
-      if (!isRecover && response.status === 409) {
-        const error = createAbcError(
-          "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-          "Wallet already exists",
-          data
-        );
-        error.response = { status: 409 };
-        throw error;
-      }
-      console.error(
-        `[AbcWaasClient] ${isRecover ? "Recover" : "Generate"} failed:`,
-        data
-      );
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        `Failed to ${isRecover ? "recover" : "generate"} Solana wallet`,
-        data
-      );
-    }
-    const result = data.result || data;
-    if (!result.key_id || !result.public_key || !result.encrypted_share) {
-      console.error(
-        "[AbcWaasClient] Invalid wallet response, missing required fields:",
-        result
-      );
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        `Invalid wallet response from ${isRecover ? "recover" : "generate"}`,
-        data
-      );
-    }
-    const solanaNetwork = getSolanaNetwork();
-    const addressResult = await this.getSolanaAddress(
-      result.public_key,
-      solanaNetwork
-    );
-    return {
-      uid: result.uid || "",
-      sessionId: result.share_id || result.key_id,
-      shareId: result.share_id || result.key_id,
-      publicKey: result.public_key,
-      address: addressResult,
-      keyId: result.key_id,
-      encryptedShare: result.encrypted_share || "",
-      secretStore: result.secret_store || "",
-      network: solanaNetwork
-    };
-  }
-  /**
-   * Get Solana address from Ed25519 public key
-   * Reference: wallet/api/index.ts:74-82
-   */
-  async getSolanaAddress(publicKey, network) {
-    const url = `${this.baseURL}/wapi/v2/solana/wallet/getAddress`;
-    const body = new URLSearchParams({
-      network,
-      publicKey
-    }).toString();
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...DEFAULT_HEADERS,
-        // Contains 'Content-Type': 'application/x-www-form-urlencoded'
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body
-    });
-    const data = await response.json();
-    if (!response.ok || data.status !== "success") {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Failed to get Solana address",
-        data
-      );
-    }
-    return data.result?.data?.address;
-  }
-  /**
-   * Sign Solana transaction with Ed25519
-   * Reference: SigningService.ts:587-626, wallet/api/index.ts:114-122
-   */
-  async signSolanaTransaction(params) {
-    const url = `${this.baseURL}/v3/wallet/sign`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify({
-        uid: params.uid,
-        share_id: params.shareId,
-        key_id: params.keyId,
-        encrypted_share: params.encryptedShare,
-        public_key: params.publicKey,
-        message: params.message,
-        // Hex-encoded transaction
-        password: params.pin,
-        // PIN will be encrypted
-        network: params.network
-        // Required: 'solana' or 'solana_devnet'
-      })
-    });
-    const data = await response.json();
-    if (!response.ok || data.status !== "success") {
-      throw createAbcError(
-        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        "Failed to sign Solana transaction",
-        data
-      );
-    }
-    return {
-      signature: data.result?.signature
-    };
-  }
-  /**
-   * Sign Solana message with Ed25519
-   * Reference: SigningService.ts:546-579
-   */
-  async signSolanaMessage(params) {
-    const url = `${this.baseURL}/v3/wallet/sign`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify({
-        uid: params.uid,
-        share_id: params.shareId,
-        key_id: params.keyId,
-        encrypted_share: params.encryptedShare,
-        public_key: params.publicKey,
-        message: params.message,
-        // Hex-encoded message
-        password: params.pin,
-        network: params.network
-        // Required: 'solana' or 'solana_devnet'
-      })
-    });
-    const data = await response.json();
-    if (!response.ok || data.status !== "success") {
-      throw createAbcError(
-        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        "Failed to sign Solana message",
-        data
-      );
-    }
-    return {
-      signature: data.result?.signature
-    };
-  }
-  /**
-   * Send Solana transaction
-   * Reference: SigningService.ts:418, wallet/api/index.ts:124-132
-   */
-  async sendSolanaTransaction(params) {
-    const url = `${this.baseURL}/wapi/v2/solana/tx/sendTransaction`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...DEFAULT_HEADERS,
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify({
-        network: params.network,
-        serializedTX: params.serializedTX,
-        signatures: params.signatures
-      })
-    });
-    const data = await response.json();
-    if (!response.ok || data.status !== "success") {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Failed to send Solana transaction",
-        data
-      );
-    }
-    return {
-      txHash: data.result?.data
-    };
-  }
-};
-function createAbcWaasClient(config) {
-  return new AbcWaasClient(config);
-}
-
-export {
-  AbcWaasClient,
-  createAbcWaasClient
-};