@talken/talkenkit 2.3.12 → 2.3.14

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

@@ -0,0 +1,1683 @@
+"use client";
+import {
+  calculateExpiryTimestamp,
+  createAbcError,
+  isTokenExpired,
+  loadFromStorage,
+  parseApiError,
+  removeFromStorage,
+  saveToStorage
+} from "./chunk-UV5HHESJ.js";
+import {
+  secure_default
+} from "./chunk-G2LI5MVX.js";
+import {
+  getSolanaNetwork
+} from "./chunk-ZX6LABEF.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.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: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        curve: "ed25519",
+        password: pin
+        // PIN will be encrypted by Secure Channel
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Failed to generate Solana wallet",
+        data
+      );
+    }
+    const result = data.result;
+    const solanaNetwork = getSolanaNetwork();
+    const addressResult = await this.getSolanaAddress(
+      result.public_key,
+      solanaNetwork
+    );
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address: addressResult,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || "",
+      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 response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        network,
+        publicKey
+      })
+    });
+    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: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        uid: params.uid,
+        share_id: params.shareId,
+        message: params.message,
+        // Hex-encoded transaction
+        password: params.pin
+        // PIN will be encrypted
+      })
+    });
+    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: {
+        ...DEFAULT_HEADERS,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: JSON.stringify({
+        uid: params.uid,
+        share_id: params.shareId,
+        message: params.message,
+        // Hex-encoded message
+        password: params.pin
+      })
+    });
+    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
+};