@talken/talkenkit 2.4.25 → 2.4.28

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

@@ -1,874 +0,0 @@
-"use client";
-import {
-  getNetworkName
-} from "./chunk-7QHCSJDN.js";
-import {
-  calculateExpiryTimestamp,
-  createAbcError,
-  isTokenExpired,
-  loadFromStorage,
-  parseApiError,
-  removeFromStorage,
-  saveToStorage
-} from "./chunk-3AX66UHT.js";
-import {
-  ABC_AUDIENCE,
-  ABC_ENDPOINTS,
-  DEFAULT_HEADERS,
-  REQUEST_TIMEOUT
-} from "./chunk-RCIABMG5.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
-};