@talken/talkenkit 2.4.16 → 2.4.18

package/dist/wallets/walletConnectors/chunk-7MOCKWA7.js

@@ -1,1729 +0,0 @@
-"use client";
-import {
-  secure_default
-} from "./chunk-NDYGTKP5.js";
-import {
-  getSolanaNetwork
-} from "./chunk-2GNL2GNB.js";
-import {
-  calculateExpiryTimestamp,
-  createAbcError,
-  isTokenExpired,
-  loadFromStorage,
-  parseApiError,
-  removeFromStorage,
-  saveToStorage
-} from "./chunk-5RSS3SRV.js";
-import {
-  ABC_AUDIENCE,
-  ABC_ENDPOINTS,
-  DEFAULT_HEADERS,
-  REQUEST_TIMEOUT
-} from "./chunk-VETRBBA2.js";
-
-// src/wallets/walletConnectors/abcWallet/abcApi.ts
-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.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 */);
-  }
-  /**
-   * 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 talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
-        const response = await fetch(
-          `${talkenApiUrl}${ABC_ENDPOINTS.REFRESH_TOKEN}`,
-          {
-            method: "POST",
-            headers: DEFAULT_HEADERS,
-            credentials: "include",
-            // Important: withCredentials from reference
-            body: new URLSearchParams({
-              refresh_token: this.refreshToken || "",
-              // Use snake_case (reference pattern)
-              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,
-            // 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 talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
-    const url = `${talkenApiUrl}/abc/emailCheck?email=${encodeURIComponent(email)}`;
-    const method = "GET";
-    console.log("[AbcWaasClient] \u{1F4EC} Checking email:", {
-      email,
-      url,
-      apiServer: talkenApiUrl
-    });
-    try {
-      const response = await fetch(url, {
-        method,
-        headers: DEFAULT_HEADERS
-      });
-      const text = await response.text();
-      const data = text ? JSON.parse(text) : { status: "success" };
-      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) {
-      if (error.name === "AbortError") {
-        throw createAbcError(
-          "NETWORK_ERROR" /* NETWORK_ERROR */,
-          "Request timeout",
-          error
-        );
-      }
-      throw parseApiError(error);
-    }
-  }
-  /**
-   * 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 endpoint = `/member/mail-service/${encodeURIComponent(email)}/sendcode`;
-    console.log("[AbcWaasClient] \u{1F4E7} Sending OTP code:", {
-      email,
-      endpoint,
-      fullUrl: `${this.baseURL}${endpoint}`
-    });
-    const response = await this.request(endpoint, {
-      method: "GET",
-      skipAuth: true
-    });
-    if (response.status === "success") {
-      return response;
-    }
-    throw createAbcError(
-      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-      "Failed to send OTP code",
-      response
-    );
-  }
-  /**
-   * 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 endpoint = `/member/mail-service/${encodeURIComponent(email)}/verifycode`;
-    const requestBody = {
-      email,
-      code,
-      serviceid: ABC_AUDIENCE
-      // 'https://mw.myabcwallet.com'
-    };
-    console.log("[AbcWaasClient] \u{1F510} Verifying OTP code:", {
-      email,
-      code: `${code.substring(0, 2)}****`,
-      // Mask OTP for security
-      serviceid: ABC_AUDIENCE,
-      endpoint,
-      fullUrl: `${this.baseURL}${endpoint}`,
-      requestBody
-    });
-    const response = await this.request(endpoint, {
-      method: "POST",
-      body: requestBody,
-      skipAuth: true
-    });
-    console.log("[verifyOtpCodeSignup] Response:", response);
-    const isSuccess = response.status === "success" || response.status === 200 || response.message === "success";
-    if (isSuccess) {
-      return response;
-    }
-    console.error("[verifyOtpCodeSignup] Failed:", response);
-    throw createAbcError(
-      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-      "Invalid or expired OTP code",
-      response
-    );
-  }
-  /**
-   * 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) {
-    const talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
-    const url = `${talkenApiUrl}/abc/snsLogin`;
-    console.log("[AbcWaasClient] \u{1F510} SNS Login:", {
-      service: params.service,
-      email: params.email,
-      audience: params.audience,
-      hasToken: !!params.token,
-      url
-    });
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          ...DEFAULT_HEADERS
-        },
-        credentials: "include",
-        // withCredentials from reference
-        body: new URLSearchParams(params).toString()
-      });
-      const data = await response.json();
-      if (!response.ok) {
-        console.error("[AbcWaasClient] \u274C SNS Login failed:", {
-          url,
-          status: response.status,
-          statusText: response.statusText,
-          data
-        });
-        throw parseApiError({
-          response: {
-            status: response.status,
-            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:", params.email);
-      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 talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
-    const url = `${talkenApiUrl}/abc/adduser`;
-    const method = "POST";
-    console.log("[AbcWaasClient] \u{1F4DD} Registering user:", {
-      username: params.username,
-      name: params.name,
-      hasPassword: !!params.password,
-      hasSecureChannel: !!params.secureChannel,
-      hasEmailCode: !!params.emailCode,
-      url
-    });
-    try {
-      const response = await fetch(url, {
-        method,
-        headers: {
-          ...DEFAULT_HEADERS
-        },
-        credentials: "include",
-        // withCredentials from reference
-        body: new URLSearchParams(params).toString()
-      });
-      const text = await response.text();
-      const data = text ? JSON.parse(text) : { status: "success" };
-      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) {
-      if (error.name === "AbortError") {
-        throw createAbcError(
-          "NETWORK_ERROR" /* NETWORK_ERROR */,
-          "Request timeout",
-          error
-        );
-      }
-      throw parseApiError(error);
-    }
-  }
-  /**
-   * 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 = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
-    const url = `${talkenApiUrl}/abc/snsAdduser`;
-    const method = "POST";
-    console.log("[AbcWaasClient] \u{1F4DD} Registering SNS user:", {
-      username: params.username,
-      name: params.name,
-      hasOtp: !!params.sixCode,
-      url
-    });
-    try {
-      const response = await fetch(url, {
-        method,
-        headers: {
-          ...DEFAULT_HEADERS
-        },
-        credentials: "include",
-        // withCredentials from reference
-        body: new URLSearchParams(params).toString()
-      });
-      const text = await response.text();
-      const data = text ? JSON.parse(text) : { status: "success" };
-      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
-          }
-        });
-      }
-      console.log("[AbcWaasClient] \u2705 SNS user registered successfully");
-      return data;
-    } catch (error) {
-      if (error.name === "AbortError") {
-        throw createAbcError(
-          "NETWORK_ERROR" /* NETWORK_ERROR */,
-          "Request timeout",
-          error
-        );
-      }
-      throw parseApiError(error);
-    }
-  }
-  /**
-   * 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 talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
-    const url = `${talkenApiUrl}/abc/initpassword`;
-    const method = "POST";
-    console.log("[AbcWaasClient] \u{1F510} Setting password:", {
-      username: params.username,
-      hasPassword: !!params.password,
-      hasSecureChannel: !!params.secureChannel,
-      hasEmailCode: !!params.emailCode,
-      url
-    });
-    try {
-      const response = await fetch(url, {
-        method,
-        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) {
-        console.error("[AbcWaasClient] \u274C API Error:", {
-          url,
-          method,
-          status: response.status,
-          statusText: response.statusText,
-          data
-        });
-        throw parseApiError({
-          response: {
-            status: response.status,
-            data
-          }
-        });
-      }
-      console.log("[AbcWaasClient] \u2705 Password set successfully");
-      return data;
-    } catch (error) {
-      if (error.name === "AbortError") {
-        throw createAbcError(
-          "NETWORK_ERROR" /* NETWORK_ERROR */,
-          "Request timeout",
-          error
-        );
-      }
-      throw parseApiError(error);
-    }
-  }
-  /**
-   * 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 networkMap = {
-      // Ethereum Networks
-      1: "ethereum",
-      // Ethereum Mainnet
-      11155111: "ethereum_sepolia",
-      // Ethereum Sepolia Testnet
-      17e3: "ethereum_holesky",
-      // Ethereum Holesky Testnet
-      // Polygon Networks
-      137: "polygon",
-      // Polygon Mainnet
-      80001: "polygon_amoy",
-      // Polygon Amoy Testnet
-      // Arbitrum Networks
-      42161: "arbitrum",
-      // Arbitrum One
-      421614: "arbitrum_sepolia",
-      // Arbitrum Sepolia
-      // Optimism Networks
-      10: "optimism",
-      // Optimism Mainnet
-      420: "optimism_sepolia",
-      // Optimism Sepolia
-      // Binance Smart Chain
-      56: "binance",
-      // BSC Mainnet
-      97: "binance_testnet",
-      // BSC Testnet
-      // Avalanche
-      43114: "avalanche",
-      // Avalanche C-Chain
-      43113: "avalanche_fuji",
-      // Avalanche Fuji Testnet
-      // Kaia (formerly Klaytn)
-      8217: "kaia",
-      // Kaia Mainnet
-      1001: "kaia_kairos",
-      // Kaia Kairos Testnet
-      // Other EVM Networks
-      5e3: "mantle",
-      // Mantle Mainnet
-      5001: "mantle_testnet",
-      // Mantle Testnet
-      1284: "moonbeam",
-      // Moonbeam
-      1285: "moonriver",
-      // Moonriver
-      534352: "scroll",
-      // Scroll Mainnet
-      534351: "scroll_testnet",
-      // Scroll Testnet
-      2355: "silicon",
-      // Silicon
-      1722641160: "silicon_sepolia",
-      // Silicon Sepolia
-      // Note: Taiko Mainnet has same Chain ID as Ethereum Holesky (17000)
-      // 17000: 'taiko',                // Taiko Mainnet (conflicts with ethereum_holesky)
-      167009: "taiko_hekla",
-      // Taiko Hekla Testnet
-      1111: "wemix",
-      // Wemix Mainnet
-      1112: "wemix_testnet",
-      // Wemix Testnet
-      51828: "chainbounty",
-      // ChainBounty
-      56580: "chainbounty_testnet"
-      // ChainBounty Testnet
-    };
-    const network = networkMap[params.chainId] || "ethereum";
-    const tx = params.transaction;
-    if (!tx.maxFeePerGas || !tx.maxPriorityFeePerGas || !tx.gasLimit || !tx.gas) {
-      try {
-        if (!tx.maxFeePerGas || !tx.maxPriorityFeePerGas) {
-          const gasFeeUrl = `${this.baseURL}${ABC_ENDPOINTS.GAS_SUGGESTED_FEES}?network=${network}`;
-          const gasFeeResponse = await fetch(gasFeeUrl, {
-            method: "GET",
-            headers: {
-              ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-            }
-          });
-          if (gasFeeResponse.ok) {
-            const gasData = await gasFeeResponse.json();
-            if (gasData.medium) {
-              if (!tx.maxFeePerGas) {
-                const maxFeeGwei = Number.parseFloat(
-                  gasData.medium.suggestedMaxFeePerGas
-                );
-                tx.maxFeePerGas = Math.floor(maxFeeGwei * 1e9).toString();
-              }
-              if (!tx.maxPriorityFeePerGas) {
-                const priorityFeeGwei = Number.parseFloat(
-                  gasData.medium.suggestedMaxPriorityFeePerGas
-                );
-                tx.maxPriorityFeePerGas = Math.floor(
-                  priorityFeeGwei * 1e9
-                ).toString();
-              }
-            }
-          }
-        }
-        if (!tx.gasLimit && !tx.gas) {
-          const estimateBody = new URLSearchParams({
-            network,
-            to: tx.to || "0x",
-            // Use '0x' for contract deployment
-            ...tx.from ? { from: tx.from } : {},
-            ...tx.value ? { value: tx.value } : {},
-            ...tx.data && tx.data !== "0x" ? { data: tx.data } : {},
-            ...tx.maxFeePerGas ? { maxFeePerGas: tx.maxFeePerGas } : {},
-            ...tx.maxPriorityFeePerGas ? { maxPriorityFeePerGas: tx.maxPriorityFeePerGas } : {}
-          });
-          const estimateUrl = `${this.baseURL}${ABC_ENDPOINTS.GAS_ESTIMATE_EIP1559}`;
-          const estimateResponse = await fetch(estimateUrl, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/x-www-form-urlencoded",
-              ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-            },
-            body: estimateBody.toString()
-          });
-          const estimateData = await estimateResponse.json();
-          if (estimateResponse.ok && estimateData.result) {
-            tx.gasLimit = estimateData.result;
-          } else {
-            const fallbackGasLimit = "0x2dc6c0";
-            tx.gasLimit = fallbackGasLimit;
-          }
-        }
-      } catch (error) {
-        console.warn("Failed to fetch gas parameters from ABC WaaS:", 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 getNetworkName = (chainId) => {
-      const networkMap = {
-        1: "ethereum",
-        // Ethereum Mainnet
-        11155111: "ethereum_sepolia",
-        // Sepolia Testnet
-        8217: "klaytn",
-        // Klaytn Mainnet
-        1001: "klaytn_baobab",
-        // Klaytn Baobab Testnet
-        137: "polygon",
-        // Polygon Mainnet
-        80002: "polygon_amoy",
-        // Polygon Amoy Testnet
-        42161: "arbitrum",
-        // Arbitrum One
-        421614: "arbitrum_sepolia",
-        // Arbitrum Sepolia
-        5e3: "mantle",
-        // Mantle Mainnet
-        5003: "mantle_testnet"
-        // Mantle Testnet
-      };
-      return networkMap[chainId] || "ethereum";
-    };
-    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 getNetworkName = (chainId2) => {
-      const networkMap = {
-        1: "ethereum",
-        11155111: "ethereum_sepolia",
-        8217: "klaytn",
-        1001: "klaytn_baobab",
-        137: "polygon",
-        80002: "polygon_amoy",
-        42161: "arbitrum",
-        421614: "arbitrum_sepolia",
-        5e3: "mantle",
-        5003: "mantle_testnet"
-      };
-      return networkMap[chainId2] || "ethereum";
-    };
-    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
-    );
-  }
-  /**
-   * 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
-};