@talken/talkenkit 2.4.16 → 2.4.18

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

@@ -0,0 +1,874 @@
+"use client";
+import {
+  getNetworkName
+} from "./chunk-7QHCSJDN.js";
+import {
+  calculateExpiryTimestamp,
+  createAbcError,
+  isTokenExpired,
+  loadFromStorage,
+  parseApiError,
+  removeFromStorage,
+  saveToStorage
+} from "./chunk-6LH6ZME2.js";
+import {
+  ABC_AUDIENCE,
+  ABC_ENDPOINTS,
+  DEFAULT_HEADERS,
+  REQUEST_TIMEOUT
+} from "./chunk-DHHVIM22.js";
+
+// src/wallets/walletConnectors/abcWallet/abcApi.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var AbcWaasClient = class {
+  constructor(config) {
+    this.accessToken = null;
+    this.refreshToken = null;
+    this.expiresAt = null;
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+    this.talkenAuthPath = "/wallet/auth";
+    this.config = config;
+    this.baseURL = config.waasUrl;
+    this.loadTokens();
+  }
+  getTalkenApiUrl() {
+    return process.env.NEXT_PUBLIC_API_URL || "http://localhost:3001/api/v1";
+  }
+  async requestWalletAuth(body) {
+    const response = await fetch(
+      `${this.getTalkenApiUrl()}${this.talkenAuthPath}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        credentials: "include",
+        body: JSON.stringify(body)
+      }
+    );
+    const text = await response.text();
+    const data = text ? JSON.parse(text) : {};
+    if (!response.ok) {
+      throw parseApiError({
+        response: {
+          status: response.status,
+          data
+        }
+      });
+    }
+    return data;
+  }
+  /**
+   * Load tokens from storage
+   */
+  loadTokens() {
+    this.accessToken = loadFromStorage("access_token" /* ACCESS_TOKEN */);
+    this.refreshToken = loadFromStorage("refresh_token" /* REFRESH_TOKEN */);
+    this.expiresAt = loadFromStorage("expires_at" /* EXPIRES_AT */);
+  }
+  /**
+   * Save tokens to storage
+   */
+  saveTokens(accessToken, refreshToken, expiresIn) {
+    this.accessToken = accessToken;
+    this.refreshToken = refreshToken;
+    this.expiresAt = calculateExpiryTimestamp(expiresIn);
+    saveToStorage("access_token" /* ACCESS_TOKEN */, accessToken);
+    saveToStorage("refresh_token" /* REFRESH_TOKEN */, refreshToken);
+    saveToStorage("expires_at" /* EXPIRES_AT */, this.expiresAt);
+  }
+  /**
+   * Clear tokens
+   */
+  clearTokens() {
+    this.accessToken = null;
+    this.refreshToken = null;
+    this.expiresAt = null;
+    removeFromStorage("access_token" /* ACCESS_TOKEN */);
+    removeFromStorage("refresh_token" /* REFRESH_TOKEN */);
+    removeFromStorage("expires_at" /* EXPIRES_AT */);
+  }
+  /**
+   * Check if access token is expired
+   */
+  isTokenExpired() {
+    return isTokenExpired(this.expiresAt);
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  /**
+   * Refresh access token
+   */
+  async refreshAccessToken() {
+    if (this.isRefreshing) {
+      if (this.refreshPromise) {
+        await this.refreshPromise;
+      }
+      return;
+    }
+    if (!this.refreshToken) {
+      throw createAbcError(
+        "TOKEN_EXPIRED" /* TOKEN_EXPIRED */,
+        "No refresh token available"
+      );
+    }
+    this.isRefreshing = true;
+    this.refreshPromise = (async () => {
+      try {
+        const isIframe = typeof window !== "undefined" && window.self !== window.top;
+        const response = await this.requestWalletAuth({
+          action: "token.refresh",
+          refreshToken: this.refreshToken || "",
+          isIframe
+        });
+        const data = response?.data || {};
+        if (response?.success && data.access_token) {
+          const expiresIn = data.expires_in || data.expire_in || 3600;
+          this.saveTokens(
+            data.access_token,
+            data.refresh_token || this.refreshToken,
+            // Keep old if not provided
+            expiresIn
+          );
+        } else {
+          throw createAbcError(
+            "TOKEN_EXPIRED" /* TOKEN_EXPIRED */,
+            "Failed to refresh token"
+          );
+        }
+      } finally {
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+      }
+    })();
+    await this.refreshPromise;
+  }
+  /**
+   * Make HTTP request
+   */
+  async request(endpoint, options = {}) {
+    const {
+      method = "GET",
+      body,
+      headers = {},
+      skipAuth = false,
+      isRetry = false
+    } = options;
+    if (!skipAuth && this.isTokenExpired() && this.refreshToken) {
+      await this.refreshAccessToken();
+    }
+    const url = `${this.baseURL}${endpoint}`;
+    const requestHeaders = {
+      ...DEFAULT_HEADERS,
+      ...headers
+    };
+    if (!skipAuth && this.accessToken) {
+      requestHeaders.Authorization = `Bearer ${this.accessToken}`;
+    }
+    if (this.config.apiKey) {
+      requestHeaders["X-API-Key"] = this.config.apiKey;
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+      const requestBody = body ? new URLSearchParams(body).toString() : void 0;
+      const response = await fetch(url, {
+        method,
+        headers: requestHeaders,
+        body: requestBody,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const text = await response.text();
+      let data;
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch (parseError) {
+          console.error("[AbcWaasClient] \u274C JSON parse error:", {
+            url,
+            method,
+            status: response.status,
+            responseText: text.substring(0, 200)
+            // Log first 200 chars
+          });
+          throw createAbcError(
+            "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+            "Invalid JSON response from server",
+            { text, parseError }
+          );
+        }
+      } else {
+        console.log("[AbcWaasClient] \u2139\uFE0F Empty response received:", {
+          url,
+          method,
+          status: response.status
+        });
+        data = { status: "success" };
+      }
+      if (response.status === 401 && !skipAuth && this.refreshToken && !isRetry) {
+        try {
+          await this.refreshAccessToken();
+          return await this.request(endpoint, {
+            ...options,
+            isRetry: true
+            // Prevent infinite retry loop
+          });
+        } catch (refreshError) {
+          console.error("Token refresh failed:", refreshError);
+          throw parseApiError({
+            response: {
+              status: response.status,
+              data
+            }
+          });
+        }
+      }
+      if (!response.ok) {
+        console.error("[AbcWaasClient] \u274C API Error:", {
+          url,
+          method,
+          status: response.status,
+          statusText: response.statusText,
+          data
+        });
+        throw parseApiError({
+          response: {
+            status: response.status,
+            data
+          }
+        });
+      }
+      return data;
+    } catch (error) {
+      console.error("[AbcWaasClient] \u274C Request failed:", {
+        url,
+        method,
+        error: error.message,
+        errorName: error.name,
+        errorType: error.constructor.name,
+        stack: error.stack
+      });
+      if (error.name === "AbortError") {
+        throw createAbcError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Request timeout",
+          error
+        );
+      }
+      if (error.code && error.message) {
+        throw error;
+      }
+      throw parseApiError(error);
+    }
+  }
+  /**
+   * Login with email and password
+   * NOTE: Tokens are stored in memory only. Call persistTokens() after PIN verification to save to localStorage.
+   */
+  async loginWithEmail(email, password) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SNS_LOGIN,
+      {
+        method: "POST",
+        body: {
+          email,
+          token: password,
+          // Use password as token
+          service: "email",
+          audience: ABC_AUDIENCE
+        },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      this.accessToken = response.data.accessToken;
+      this.refreshToken = response.data.refreshToken;
+      this.expiresAt = calculateExpiryTimestamp(response.data.expiresIn);
+      console.log(
+        "[AbcWaasClient] \u2705 Login successful, tokens stored in memory (not persisted yet)"
+      );
+      return response.data;
+    }
+    throw createAbcError(
+      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+      "Email login failed",
+      response
+    );
+  }
+  /**
+   * Login with email and OTP (for PIN recovery)
+   * NOTE: Tokens are stored in memory only. Call persistTokens() after PIN verification to save to localStorage.
+   */
+  async loginWithOtp(email, otpCode) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SNS_LOGIN,
+      {
+        method: "POST",
+        body: {
+          email,
+          token: otpCode,
+          service: "email",
+          audience: ABC_AUDIENCE
+        },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      this.accessToken = response.data.accessToken;
+      this.refreshToken = response.data.refreshToken;
+      this.expiresAt = calculateExpiryTimestamp(response.data.expiresIn);
+      console.log(
+        "[AbcWaasClient] \u2705 OTP login successful, tokens stored in memory (not persisted yet)"
+      );
+      return response.data;
+    }
+    throw createAbcError(
+      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+      "OTP login failed",
+      response
+    );
+  }
+  /**
+   * Login with social provider
+   * NOTE: Tokens are stored in memory only. Call persistTokens() after PIN verification to save to localStorage.
+   */
+  async loginWithSocial(provider, token, email) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SNS_LOGIN,
+      {
+        method: "POST",
+        body: {
+          token,
+          service: provider,
+          audience: ABC_AUDIENCE,
+          email
+        },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      this.accessToken = response.data.accessToken;
+      this.refreshToken = response.data.refreshToken;
+      this.expiresAt = calculateExpiryTimestamp(response.data.expiresIn);
+      console.log(
+        "[AbcWaasClient] \u2705 Social login successful, tokens stored in memory (not persisted yet)"
+      );
+      return response.data;
+    }
+    throw createAbcError(
+      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+      "Social login failed",
+      response
+    );
+  }
+  /**
+   * Refresh access token using refresh token (public wrapper)
+   */
+  async refreshTokens(refreshTokenValue) {
+    const oldRefreshToken = this.refreshToken;
+    this.refreshToken = refreshTokenValue;
+    try {
+      await this.refreshAccessToken();
+      return {
+        accessToken: this.accessToken,
+        refreshToken: this.refreshToken,
+        expiresIn: Math.floor((this.expiresAt - Date.now()) / 1e3)
+      };
+    } catch (error) {
+      this.refreshToken = oldRefreshToken;
+      throw error;
+    }
+  }
+  /**
+   * Request OTP code for email
+   */
+  async requestOtpCode(email) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SEND_OTP,
+      {
+        method: "POST",
+        body: { email },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      return response.data;
+    }
+    throw createAbcError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      "Failed to request OTP",
+      response
+    );
+  }
+  /**
+   * Verify OTP code
+   */
+  async verifyOtpCode(email, code) {
+    const response = await this.request(ABC_ENDPOINTS.VERIFY_OTP, {
+      method: "POST",
+      body: { email, code },
+      skipAuth: true
+    });
+    return response.status === "success";
+  }
+  /**
+   * Check if email already exists
+   * Reference: tg-wallet-frontend src/features/user/api/index.ts:63-69
+   */
+  async emailCheck(email) {
+    const result = await this.requestWalletAuth({
+      action: "email.check",
+      email
+    });
+    return result?.data || result;
+  }
+  /**
+   * Send OTP code to email for signup
+   * Reference: tg-wallet-frontend src/features/user/api/index.ts:105-110
+   * Note: Uses ABC WaaS endpoint, not Talken API
+   */
+  async sendOtpCode(email) {
+    const result = await this.requestWalletAuth({
+      action: "otp.send",
+      email
+    });
+    return result?.data || result;
+  }
+  /**
+   * Verify OTP code for signup
+   * Reference: tg-wallet-frontend src/features/user/api/index.ts:112-123
+   * Note: Uses ABC WaaS endpoint, not Talken API
+   */
+  async verifyOtpCodeSignup(email, code) {
+    const result = await this.requestWalletAuth({
+      action: "otp.verify",
+      email,
+      otpCode: code
+    });
+    return result?.data || result;
+  }
+  /**
+   * SNS (Social) Login via Google/Apple/Kakao
+   * Reference: tg-wallet-frontend src/features/user/api/index.ts:43-51
+   * Note: Uses Talken API server, not ABC WaaS
+   */
+  async snsLogin(params) {
+    try {
+      const result = await this.requestWalletAuth({
+        action: "login",
+        method: "sns",
+        token: params.token,
+        service: params.service,
+        audience: params.audience
+      });
+      const data = result?.data || {};
+      if (!data.access_token) {
+        throw createAbcError(
+          "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+          "SNS login failed: Invalid response from server",
+          { service: params.service, response: data }
+        );
+      }
+      console.log("[AbcWaasClient] \u2705 SNS login successful");
+      return {
+        uid: "",
+        // Will be fetched later via info() API
+        email: params.email,
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        user_type: "existing"
+        // Default to existing, will be determined later
+      };
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw createAbcError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "SNS login request timeout",
+          error
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Register new user
+   * Reference: tg-wallet-frontend src/features/user/api/index.ts:71-78
+   * Note: Uses Talken API server, not ABC WaaS
+   */
+  async registerUser(params) {
+    const result = await this.requestWalletAuth({
+      action: "register",
+      email: params.username,
+      otpCode: params.emailCode,
+      password: params.password,
+      name: params.name
+    });
+    return result?.data || result;
+  }
+  /**
+   * Register new SNS user (email-based registration with OTP)
+   * Reference: tg-wallet-frontend src/features/user/api/index.ts:80-87
+   * Note: Uses Talken API server, not ABC WaaS
+   */
+  async registerSnsUser(params) {
+    const talkenApiUrl = this.getTalkenApiUrl();
+    const response = await fetch(`${talkenApiUrl}/auth/signup`, {
+      method: "POST",
+      headers: {
+        ...DEFAULT_HEADERS
+      },
+      credentials: "include",
+      body: new URLSearchParams(params).toString()
+    });
+    const text = await response.text();
+    const data = text ? JSON.parse(text) : { status: "success" };
+    if (!response.ok) {
+      throw parseApiError({
+        response: {
+          status: response.status,
+          data
+        }
+      });
+    }
+    return data;
+  }
+  /**
+   * Reset/Set password for existing user
+   * Reference: tg-wallet-frontend src/features/user/api/index.ts:89-95
+   * Note: Uses Talken API server, not ABC WaaS
+   */
+  async resetPassword(params) {
+    const result = await this.requestWalletAuth({
+      action: "password.reset",
+      email: params.username,
+      newPassword: params.password,
+      emailCode: params.emailCode
+    });
+    return result?.data || result;
+  }
+  /**
+   * Generate or recover wallet
+   */
+  async generateOrRecoverWallet(params) {
+    const response = await this.request(
+      // Use 'any' to get raw API response
+      ABC_ENDPOINTS.MPC_WALLETS,
+      // Use correct EVM endpoint, not WALLETS_V3 (Solana only)
+      {
+        method: "POST",
+        body: {
+          uid: params.uid,
+          pin: params.pin,
+          chainId: params.chainId,
+          network: params.network || "mainnet"
+        }
+      }
+    );
+    if (response.status === "success" && response.data) {
+      const raw = response.data;
+      return {
+        address: raw.sid || "",
+        // sid is the EVM address
+        keyId: raw.key_id || raw.keyId || raw.sid,
+        encryptedShare: raw.encrypted_share || raw.key_id || "",
+        uid: raw.uid,
+        sid: raw.sid,
+        pubkey: raw.pubkey || null
+      };
+    }
+    throw createAbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      "Failed to generate wallet",
+      response
+    );
+  }
+  // v2 signing methods removed (signTransaction, signMessage, signTypedData, sendRawTransaction)
+  // All signing now routes through TalkenApiClient → talken-api backend.
+  /**
+   * @deprecated v2 signing removed. Use TalkenApiClient.evm.sendTransaction() instead.
+   */
+  async signTransaction(_params) {
+    throw createAbcError(
+      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+      "v2 signing removed. Use TalkenApiClient.evm.sendTransaction() instead."
+    );
+  }
+  /**
+   * @deprecated v2 signing removed. Use TalkenApiClient.evm.personalSign() instead.
+   */
+  async signMessage(_params) {
+    throw createAbcError(
+      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+      "v2 signing removed. Use TalkenApiClient.evm.personalSign() instead."
+    );
+  }
+  /**
+   * @deprecated v2 signing removed. Use TalkenApiClient.evm.signTypedData() instead.
+   */
+  async signTypedData(_params) {
+    throw createAbcError(
+      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+      "v2 signing removed. Use TalkenApiClient.evm.signTypedData() instead."
+    );
+  }
+  /**
+   * @deprecated v2 sendRawTransaction removed. Use TalkenApiClient.evm.sendRawTransaction() instead.
+   */
+  async sendRawTransaction(_chainId, _signedTransaction) {
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "v2 sendRawTransaction removed. Use TalkenApiClient.evm.sendRawTransaction() instead."
+    );
+  }
+  /**
+   * Estimate gas for EIP-1559 transaction
+   * Routes through TalkenApiClient (talken-api proxy)
+   */
+  async estimateGas(params) {
+    const network = getNetworkName(params.chainId);
+    const api = getTalkenApiClient();
+    if (!api) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "TalkenApiClient not initialized"
+      );
+    }
+    try {
+      const result = await api.evm.estimateGas({
+        network,
+        from: params.from || "",
+        to: params.to,
+        value: params.value,
+        data: params.data
+      });
+      if (result.result) {
+        return result.result;
+      }
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "No result in gas estimate response"
+      );
+    } catch (error) {
+      if (error?.code === "NETWORK_ERROR" /* NETWORK_ERROR */) {
+        throw error;
+      }
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        error.message || "Failed to estimate gas"
+      );
+    }
+  }
+  /**
+   * Get transaction count (nonce) via TalkenApiClient
+   */
+  async getTransactionCount(params) {
+    const network = getNetworkName(params.chainId);
+    const api = getTalkenApiClient();
+    if (!api) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "TalkenApiClient not initialized"
+      );
+    }
+    try {
+      const res = await api.evm.getNonce(network, params.address);
+      if (res.result !== void 0) {
+        return typeof res.result === "number" ? `0x${res.result.toString(16)}` : res.result;
+      }
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "No result in nonce response"
+      );
+    } catch (error) {
+      if (error?.code === "NETWORK_ERROR" /* NETWORK_ERROR */) {
+        throw error;
+      }
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        error.message || "Failed to get transaction count"
+      );
+    }
+  }
+  /**
+   * 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 api = getTalkenApiClient();
+    if (!api) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "TalkenApiClient not initialized"
+      );
+    }
+    const response = isRecover ? await api.wallet.recover(pin) : await api.wallet.generate(pin);
+    if (!response.solana) {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        `Solana wallet not returned from ${isRecover ? "recovery" : "generation"}`
+      );
+    }
+    return response.solana;
+  }
+  /**
+   * Get Solana address from Ed25519 public key
+   * Reference: wallet/api/index.ts:74-82
+   */
+  async getSolanaAddress(publicKey, _network) {
+    const api = getTalkenApiClient();
+    if (!api) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "TalkenApiClient not initialized"
+      );
+    }
+    const addresses = await api.wallet.getAddresses();
+    if (!addresses.solana) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Solana address not available"
+      );
+    }
+    return addresses.solana;
+  }
+  /**
+   * Sign Solana transaction with Ed25519 (via talken-api proxy)
+   */
+  async signSolanaTransaction(params) {
+    const api = getTalkenApiClient();
+    if (!api) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "TalkenApiClient not initialized"
+      );
+    }
+    const result = await api.solana.sign({
+      message: params.message,
+      pin: params.pin,
+      keyId: params.keyId,
+      encryptedShare: params.encryptedShare,
+      secretStore: params.secretStore,
+      network: params.network
+    });
+    if (!result.signature) {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana transaction"
+      );
+    }
+    return { signature: result.signature };
+  }
+  /**
+   * Sign Solana message with Ed25519 (via talken-api proxy)
+   */
+  async signSolanaMessage(params) {
+    const api = getTalkenApiClient();
+    if (!api) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "TalkenApiClient not initialized"
+      );
+    }
+    const result = await api.solana.sign({
+      message: params.message,
+      keyId: params.keyId,
+      encryptedShare: params.encryptedShare,
+      secretStore: params.secretStore,
+      network: params.network
+    });
+    if (!result.signature) {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana message"
+      );
+    }
+    return { signature: result.signature };
+  }
+  /**
+   * Send Solana transaction (via talken-api proxy)
+   * @deprecated Use TalkenApiClient.solana.transfer() for integrated flow
+   */
+  async sendSolanaTransaction(_params) {
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "sendSolanaTransaction is deprecated. Use TalkenApiClient.solana.transfer() instead."
+    );
+  }
+};
+function createAbcWaasClient(config) {
+  return new AbcWaasClient(config);
+}
+
+export {
+  AbcWaasClient,
+  createAbcWaasClient
+};