@talken/talkenkit 2.4.17 → 2.4.19

package/dist/{chunk-5X3ROW3U.js → chunk-R4FDCYJX.js}

@@ -816,90 +816,6 @@ import { createConnector } from "wagmi";
 // src/wallets/walletConnectors/abcWallet/abcApi.ts
 init_networks();
 import { getTalkenApiClient } from "@talken/talkenkit";
-import { parseGwei } from "viem";
-
-// src/wallets/walletConnectors/abcWallet/networkConfig.ts
-var SolanaNetwork = /* @__PURE__ */ ((SolanaNetwork4) => {
-  SolanaNetwork4["Mainnet"] = "solana";
-  SolanaNetwork4["Devnet"] = "solana_devnet";
-  SolanaNetwork4["Testnet"] = "solana_testnet";
-  return SolanaNetwork4;
-})(SolanaNetwork || {});
-var BitcoinNetwork = /* @__PURE__ */ ((BitcoinNetwork2) => {
-  BitcoinNetwork2["Mainnet"] = "bitcoin";
-  BitcoinNetwork2["Testnet"] = "bitcoin_testnet";
-  return BitcoinNetwork2;
-})(BitcoinNetwork || {});
-var TronNetwork = /* @__PURE__ */ ((TronNetwork2) => {
-  TronNetwork2["Mainnet"] = "tron";
-  TronNetwork2["Nile"] = "tron_nile";
-  return TronNetwork2;
-})(TronNetwork || {});
-var DEFAULT_NETWORK_CONFIG = {
-  evm: {
-    mainnet: 1,
-    // Ethereum Mainnet
-    testnet: 11155111
-    // Sepolia Testnet
-  },
-  solana: {
-    mainnet: "solana" /* Mainnet */,
-    devnet: "solana_devnet" /* Devnet */
-  },
-  bitcoin: {
-    mainnet: "bitcoin" /* Mainnet */,
-    testnet: "bitcoin_testnet" /* Testnet */
-  },
-  tron: {
-    mainnet: "tron" /* Mainnet */,
-    testnet: "tron_nile" /* Nile */
-  }
-};
-var globalDefaultChainId;
-var globalDefaultSolanaNetwork;
-var globalDefaultBitcoinNetwork;
-var globalDefaultTronNetwork;
-function setGlobalDefaultChainId(chainId) {
-  globalDefaultChainId = chainId;
-}
-function setGlobalDefaultSolanaNetwork(network) {
-  globalDefaultSolanaNetwork = network;
-}
-function setGlobalDefaultBitcoinNetwork(network) {
-  globalDefaultBitcoinNetwork = network;
-}
-function getEvmNetwork(customChainId) {
-  if (customChainId !== void 0) {
-    return customChainId;
-  }
-  if (globalDefaultChainId !== void 0) {
-    return globalDefaultChainId;
-  }
-  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
-  const fallbackChainId = isProduction ? DEFAULT_NETWORK_CONFIG.evm.mainnet : DEFAULT_NETWORK_CONFIG.evm.testnet;
-  return fallbackChainId;
-}
-function getSolanaNetwork() {
-  if (globalDefaultSolanaNetwork !== void 0) {
-    return globalDefaultSolanaNetwork;
-  }
-  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
-  return isProduction ? DEFAULT_NETWORK_CONFIG.solana.mainnet : DEFAULT_NETWORK_CONFIG.solana.devnet;
-}
-function getBitcoinNetwork() {
-  if (globalDefaultBitcoinNetwork !== void 0) {
-    return globalDefaultBitcoinNetwork;
-  }
-  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
-  return isProduction ? DEFAULT_NETWORK_CONFIG.bitcoin.mainnet : DEFAULT_NETWORK_CONFIG.bitcoin.testnet;
-}
-function getTronNetwork() {
-  if (globalDefaultTronNetwork !== void 0) {
-    return globalDefaultTronNetwork;
-  }
-  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
-  return isProduction ? DEFAULT_NETWORK_CONFIG.tron.mainnet : DEFAULT_NETWORK_CONFIG.tron.testnet;
-}
 
 // src/wallets/walletConnectors/abcWallet/types.ts
 var AbcStorageKey = /* @__PURE__ */ ((AbcStorageKey2) => {
@@ -952,7 +868,8 @@ var TalkenApiError = class extends Error {
 // src/wallets/walletConnectors/abcWallet/constants.ts
 var DEFAULT_ABC_CONFIG = {
   environment: "development",
-  waasUrl: process.env.VITE_ABC_WAAS_URL || "https://api.abcwallet.com"
+  waasUrl: ""
+  // All operations routed through TalkenApiClient
 };
 var TOKEN_EXPIRY = {
   ACCESS_TOKEN: 10 * 60 * 1e3,
@@ -1158,6 +1075,10 @@ var TALKEN_API_ENDPOINTS = {
   SIGN_EVM: "/wallet/sign/evm",
   SIGN_TYPED: "/wallet/sign/typed",
   SIGN_PERSONAL: "/wallet/sign/personal",
+  // ── Hash Sign (secp256k1, universal: EVM/BTC/TVM) ───────────────────
+  SIGN_HASH: "/wallet/sign/hash",
+  // ── SOL Sign (WaaS proxy) ───────────────────────────────────────────
+  SIGN_SVM: "/wallet/sign/sol",
   // ── TX ──────────────────────────────────────────────────────────────
   TX_RAW: "/wallet/tx/raw",
   TX_EVM: "/wallet/tx/evm",
@@ -1508,116 +1429,6 @@ function clearEncryptedTokens() {
   removeFromStorage("token_salt" /* TOKEN_SALT */);
 }
 
-// src/wallets/walletConnectors/abcWallet/abcApi.ts
-import { getAddress } from "viem";
-
-// src/wallets/walletConnectors/abcWallet/secure.ts
-import CryptoJS2 from "crypto-js";
-import elliptic from "elliptic";
-var EC = elliptic.ec;
-var SecureService = class {
-  constructor(baseURL) {
-    this.secureChannel = null;
-    this.channelExpiry = 0;
-    this.baseURL = baseURL;
-  }
-  async getSecureChannel() {
-    if (this.secureChannel && Date.now() < this.channelExpiry) {
-      return this.secureChannel;
-    }
-    const result = {};
-    const plain = Array.from(crypto.getRandomValues(new Uint8Array(32))).map((b) => b.toString(16).padStart(2, "0")).join("");
-    const ec = new EC("p256");
-    const myKey = ec.genKeyPair();
-    const pubkey = myKey.getPublic().encode("hex", false);
-    const url = `${this.baseURL}${ABC_ENDPOINTS.SECURE_CHANNEL_CREATE}`;
-    const bodyString = new URLSearchParams({ pubkey, plain }).toString();
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: bodyString
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      console.error(
-        `\u274C Secure channel HTTP error: ${response.status} ${response.statusText}`
-      );
-      console.error("Response body:", errorText);
-      throw new Error(
-        `Failed to create secure channel: HTTP ${response.status} - ${errorText}`
-      );
-    }
-    const res = await response.json();
-    const resData = res;
-    if (resData.channelid && resData.publickey) {
-      const serverKey = ec.keyFromPublic(resData.publickey, "hex");
-      const sharedSecret = serverKey.getPublic().mul(myKey.getPrivate()).getX();
-      const secretKey = sharedSecret.toString(16).padStart(64, "0");
-      result.response = resData;
-      result.myKey = myKey;
-      result.secretKey = secretKey;
-      this.secureChannel = result;
-      this.channelExpiry = Date.now() + 20 * 60 * 1e3;
-    } else if (res.status === "success" && res.result) {
-      const result_data = res.result;
-      const serverKey = ec.keyFromPublic(result_data.publickey, "hex");
-      const sharedSecret = serverKey.getPublic().mul(myKey.getPrivate()).getX();
-      const secretKey = sharedSecret.toString(16).padStart(64, "0");
-      result.response = result_data;
-      result.myKey = myKey;
-      result.secretKey = secretKey;
-      this.secureChannel = result;
-      this.channelExpiry = Date.now() + 20 * 60 * 1e3;
-      console.log("\u2705 Secure channel created successfully (wrapped format)");
-    } else {
-      const errorMsg = res.message || res.detail || "Unknown error";
-      console.error("\u274C Failed to create secure channel:", res);
-      throw new Error(`Failed to create secure channel: ${errorMsg}`);
-    }
-    return result;
-  }
-  async encrypt(plain) {
-    const secureChannel = await this.getSecureChannel();
-    if (!secureChannel.secretKey || !secureChannel.response) {
-      throw new Error("Secure channel not established");
-    }
-    const secretKey = secureChannel.secretKey;
-    const key = secretKey.substring(0, 32);
-    const iv = secretKey.substring(32);
-    const encrypted = CryptoJS2.AES.encrypt(plain, CryptoJS2.enc.Hex.parse(key), {
-      iv: CryptoJS2.enc.Hex.parse(iv),
-      padding: CryptoJS2.pad.Pkcs7,
-      mode: CryptoJS2.mode.CBC
-    });
-    return {
-      encryptPlain: encrypted.toString(),
-      secureChannel: secureChannel.response.channelid
-    };
-  }
-  async getSecureChannelId() {
-    const channel = await this.getSecureChannel();
-    if (!channel.response?.channelid) {
-      throw new Error("Secure channel not established");
-    }
-    return channel.response.channelid;
-  }
-  async getEncryptPlain(plain) {
-    const result = await this.encrypt(plain);
-    return result.encryptPlain;
-  }
-  /**
-   * Clear cached secure channel (for testing or reset)
-   */
-  clearCache() {
-    this.secureChannel = null;
-    this.channelExpiry = 0;
-    console.log("\u{1F504} Secure channel cache cleared");
-  }
-};
-var secure_default = SecureService;
-
 // src/wallets/walletConnectors/abcWallet/abcApi.ts
 var AbcWaasClient = class {
   constructor(config) {
@@ -1626,14 +1437,13 @@ var AbcWaasClient = class {
     this.expiresAt = null;
     this.isRefreshing = false;
     this.refreshPromise = null;
-    this.talkenAuthPath = "/api/v1/wallet/auth";
+    this.talkenAuthPath = "/wallet/auth";
     this.config = config;
     this.baseURL = config.waasUrl;
-    this.secure = new secure_default(this.baseURL);
     this.loadTokens();
   }
   getTalkenApiUrl() {
-    return process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+    return process.env.NEXT_PUBLIC_API_URL || "http://localhost:3001/api/v1";
   }
   async requestWalletAuth(body) {
     const response = await fetch(
@@ -2119,7 +1929,7 @@ var AbcWaasClient = class {
    */
   async registerSnsUser(params) {
     const talkenApiUrl = this.getTalkenApiUrl();
-    const response = await fetch(`${talkenApiUrl}/abc/snsAdduser`, {
+    const response = await fetch(`${talkenApiUrl}/auth/signup`, {
       method: "POST",
       headers: {
         ...DEFAULT_HEADERS
@@ -2173,31 +1983,13 @@ var AbcWaasClient = class {
     );
     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
+        // 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
       };
     }
@@ -2207,553 +1999,102 @@ var AbcWaasClient = class {
       response
     );
   }
+  // v2 signing methods removed (signTransaction, signMessage, signTypedData, sendRawTransaction)
+  // All signing now routes through TalkenApiClient → talken-api backend.
   /**
-   * Sign EVM transaction (EIP-1559)
-   * Based on ABC WaaS official documentation
+   * @deprecated v2 signing removed. Use TalkenApiClient.evm.sendTransaction() instead.
    */
-  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
+  async signTransaction(_params) {
+    throw createAbcError(
+      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+      "v2 signing removed. Use TalkenApiClient.evm.sendTransaction() instead."
     );
-    const encryptedWid = await this.secure.getEncryptPlain(wallet.wid);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const network = getNetworkName(params.chainId);
-    const tx = params.transaction;
-    if (!tx.maxFeePerGas || !tx.maxPriorityFeePerGas || !tx.gasLimit || !tx.gas) {
-      try {
-        const api = getTalkenApiClient();
-        if (api && (!tx.maxFeePerGas || !tx.maxPriorityFeePerGas)) {
-          try {
-            const gasData = await api.evm.getGasSuggested(network);
-            if (gasData.medium) {
-              if (!tx.maxFeePerGas) {
-                tx.maxFeePerGas = parseGwei(
-                  gasData.medium.suggestedMaxFeePerGas
-                ).toString();
-              }
-              if (!tx.maxPriorityFeePerGas) {
-                tx.maxPriorityFeePerGas = parseGwei(
-                  gasData.medium.suggestedMaxPriorityFeePerGas
-                ).toString();
-              }
-            }
-          } catch (gasError) {
-            console.warn("[AbcWaasClient] Failed to fetch gas fees:", gasError);
-          }
-        }
-        if (api && !tx.gasLimit && !tx.gas) {
-          try {
-            const estimateResult = await api.evm.estimateGas({
-              network,
-              from: tx.from || "",
-              to: tx.to || "0x",
-              value: tx.value,
-              data: tx.data && tx.data !== "0x" ? tx.data : void 0
-            });
-            if (estimateResult.result) {
-              tx.gasLimit = estimateResult.result;
-            } else {
-              tx.gasLimit = "0x2dc6c0";
-            }
-          } catch (estimateError) {
-            console.warn(
-              "[AbcWaasClient] Failed to estimate gas:",
-              estimateError
-            );
-            tx.gasLimit = "0x2dc6c0";
-          }
-        }
-      } catch (error) {
-        console.warn("[AbcWaasClient] Failed to fetch gas parameters:", error);
-      }
-    }
-    const bodyData = {
-      network,
-      encryptDevicePassword: encryptedDevicePassword,
-      pvencstr: encryptedPvencstr,
-      uid: wallet.uid,
-      wid: encryptedWid,
-      sid: getAddress(wallet.address),
-      // EIP-55 checksum format
-      // For contract deployment, 'to' is '0x' (ABC WaaS convention)
-      // Reference: talken-nft-drops/src/libs/abc-waas-provider/index.ts:800 - to: to ?? '0x'
-      to: tx.to === "0x" ? "0x" : getAddress(tx.to),
-      // Required by ABC WaaS API
-      // Always use EIP1559 type (ABC WaaS handles network-specific conversion)
-      type: "EIP1559",
-      // ourpubkey and ucpubkey are required by ABC WaaS (empty strings for now)
-      // Based on successful tg-wallet payload analysis
-      ourpubkey: "",
-      ucpubkey: ""
-    };
-    bodyData.from = getAddress(tx.from || wallet.address);
-    if (tx.value) {
-      let hexValue = tx.value.startsWith("0x") ? tx.value.slice(2) : tx.value;
-      if (hexValue.length % 2 !== 0) {
-        hexValue = `0${hexValue}`;
-      }
-      bodyData.value = `0x${hexValue}`;
-    } else {
-      bodyData.value = "0x0";
-    }
-    if (tx.gasLimit || tx.gas) {
-      const gasLimitValue = tx.gasLimit || tx.gas;
-      if (gasLimitValue.toString().startsWith("0x")) {
-        bodyData.gasLimit = gasLimitValue.toString();
-      } else {
-        bodyData.gasLimit = `0x${BigInt(gasLimitValue).toString(16)}`;
-      }
-    }
-    if (tx.maxFeePerGas) {
-      if (tx.maxFeePerGas.toString().startsWith("0x")) {
-        bodyData.maxFeePerGas = tx.maxFeePerGas.toString();
-      } else {
-        bodyData.maxFeePerGas = `0x${BigInt(tx.maxFeePerGas).toString(16)}`;
-      }
-    }
-    if (tx.maxPriorityFeePerGas) {
-      if (tx.maxPriorityFeePerGas.toString().startsWith("0x")) {
-        bodyData.maxPriorityFeePerGas = tx.maxPriorityFeePerGas.toString();
-      } else {
-        bodyData.maxPriorityFeePerGas = `0x${BigInt(tx.maxPriorityFeePerGas).toString(16)}`;
-      }
-    }
-    if (tx.gasPrice) {
-      if (tx.gasPrice.toString().startsWith("0x")) {
-        bodyData.gasPrice = tx.gasPrice.toString();
-      } else {
-        bodyData.gasPrice = `0x${BigInt(tx.gasPrice).toString(16)}`;
-      }
-    }
-    if (tx.data !== void 0 && tx.data !== null) {
-      bodyData.data = tx.data || "0x";
-    } else {
-      bodyData.data = "0x";
-    }
-    const bodyString = new URLSearchParams(bodyData).toString();
-    const url = `${this.baseURL}${ABC_ENDPOINTS.SIGN_TRANSACTION}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        "Secure-Channel": secureChannelId,
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: bodyString
-    });
-    const res = await response.json();
-    console.log("\u{1F4E1} ABC WaaS /sign response:", {
-      status: response.status,
-      ok: response.ok,
-      response: res
-    });
-    if (!response.ok) {
-      console.error("\u274C ABC WaaS API error details:", {
-        status: response.status,
-        statusText: response.statusText,
-        errorCode: res.code,
-        errorMessage: res.msg || res.message || res.detail,
-        fullResponse: res
-      });
-    }
-    if (response.status === 401 && this.refreshToken) {
-      try {
-        await this.refreshAccessToken();
-        const retryResponse = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Secure-Channel": secureChannelId,
-            ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-          },
-          body: bodyString
-        });
-        const retryRes = await retryResponse.json();
-        if (retryRes.serializedTx && retryRes.rawTx) {
-          return {
-            signature: retryRes.serializedTx,
-            txHash: retryRes.rawTx
-          };
-        }
-        throw createAbcError(
-          "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-          "Failed to sign transaction after token refresh",
-          retryRes
-        );
-      } catch (refreshError) {
-        console.error("Token refresh failed in signTransaction:", refreshError);
-        throw refreshError;
-      }
-    }
-    if (res.serializedTx && res.rawTx) {
-      return {
-        signature: res.serializedTx,
-        txHash: res.rawTx
-      };
-    }
+  }
+  /**
+   * @deprecated v2 signing removed. Use TalkenApiClient.evm.personalSign() instead.
+   */
+  async signMessage(_params) {
     throw createAbcError(
       "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-      "Failed to sign transaction",
-      res
+      "v2 signing removed. Use TalkenApiClient.evm.personalSign() instead."
     );
   }
   /**
-   * Sign message (Personal Sign - EIP-191)
-   * Based on tg-wallet-frontend reference implementation
+   * @deprecated v2 signing removed. Use TalkenApiClient.evm.signTypedData() instead.
    */
-  async signMessage(params) {
-    this.loadTokens();
-    const wallet = loadFromStorage("wallet" /* WALLET */);
-    if (!wallet) {
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Wallet information not found in storage"
-      );
-    }
-    const ethers = await import("ethers");
-    const messageHash = ethers.utils.hashMessage(params.message);
-    const hash = messageHash.startsWith("0x") ? messageHash.slice(2) : messageHash;
-    const encryptedDevicePassword = await this.secure.getEncryptPlain(
-      wallet.encryptDevicePassword
+  async signTypedData(_params) {
+    throw createAbcError(
+      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+      "v2 signing removed. Use TalkenApiClient.evm.signTypedData() instead."
     );
-    const encryptedPvencstr = await this.secure.getEncryptPlain(
-      wallet.pvencstr
+  }
+  /**
+   * @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."
     );
-    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) {
+  }
+  /**
+   * 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(
-        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        `Empty response from sign API (status: ${response.status})`,
-        { status: response.status }
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "TalkenApiClient not initialized"
       );
     }
-    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;
-        }
+    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;
       }
-    }
-    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
-        );
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "No result in gas estimate response"
+      );
+    } catch (error) {
+      if (error?.code === "NETWORK_ERROR" /* NETWORK_ERROR */) {
+        throw error;
       }
-      const v = (sigList.vsource || 0) + 27;
-      const signature = sigList.r + sigList.s.slice(2) + v.toString(16).padStart(2, "0");
-      return { signature };
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        error.message || "Failed to estimate gas"
+      );
     }
-    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()
+   * Get transaction count (nonce) via TalkenApiClient
    */
-  async signTypedData(params) {
-    this.loadTokens();
-    const wallet = loadFromStorage("wallet" /* WALLET */);
-    if (!wallet) {
+  async getTransactionCount(params) {
+    const network = getNetworkName(params.chainId);
+    const api = getTalkenApiClient();
+    if (!api) {
       throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Wallet information not found in storage"
-      );
-    }
-    const encryptedDevicePassword = await this.secure.getEncryptPlain(
-      wallet.encryptDevicePassword
-    );
-    const encryptedPvencstr = await this.secure.getEncryptPlain(
-      wallet.pvencstr
-    );
-    const encryptedWid = await this.secure.getEncryptPlain(wallet.wid);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const network = getNetworkName(wallet.chainId);
-    const bodyData = {
-      messageJson: params.typedData,
-      // Server expects "messageJson" field
-      version: "v4",
-      // EIP-712 version
-      network,
-      // Network name (required for JSON-RPC)
-      encryptDevicePassword: encryptedDevicePassword,
-      pvencstr: encryptedPvencstr,
-      wid: encryptedWid,
-      uid: wallet.uid,
-      sid: wallet.sid
-    };
-    const bodyString = new URLSearchParams(bodyData).toString();
-    const url = `${this.baseURL}${ABC_ENDPOINTS.SIGN_TYPED}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        "Secure-Channel": secureChannelId,
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: bodyString
-    });
-    const text = await response.text();
-    if (!text) {
-      throw createAbcError(
-        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        `Empty response from signTypedData API (status: ${response.status})`,
-        { status: response.status }
-      );
-    }
-    const res = JSON.parse(text);
-    if (response.status === 401 && this.refreshToken) {
-      try {
-        await this.refreshAccessToken();
-        const retryResponse = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Secure-Channel": secureChannelId,
-            ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-          },
-          body: bodyString
-        });
-        const retryText = await retryResponse.text();
-        if (!retryText) {
-          throw createAbcError(
-            "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-            `Empty response after retry (status: ${retryResponse.status})`,
-            { status: retryResponse.status }
-          );
-        }
-        const retryRes = JSON.parse(retryText);
-        if (retryRes.serializedTx) {
-          return { signature: retryRes.serializedTx };
-        }
-        throw createAbcError(
-          "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-          "Failed to sign typed data after token refresh",
-          retryRes
-        );
-      } catch (refreshError) {
-        console.error("Token refresh failed in signTypedData:", refreshError);
-        throw refreshError;
-      }
-    }
-    if (res.serializedTx) {
-      return { signature: res.serializedTx };
-    }
-    throw createAbcError(
-      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-      "Failed to sign typed data",
-      res
-    );
-  }
-  /**
-   * Send raw transaction
-   * Reference: tg-wallet-frontend src/features/wallet/api/index.ts sendRawTx()
-   */
-  async sendRawTransaction(chainId, signedTransaction) {
-    const wallet = loadFromStorage("wallet" /* WALLET */);
-    if (!wallet) {
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Wallet information not found in storage"
-      );
-    }
-    const network = getNetworkName(chainId);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const bodyData = {
-      signedSerializeTx: signedTransaction,
-      network
-      // rpc parameter
-    };
-    const bodyString = new URLSearchParams(bodyData).toString();
-    const url = `${this.baseURL}${ABC_ENDPOINTS.SEND_RAW_TX}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        "Secure-Channel": secureChannelId,
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: bodyString
-    });
-    const text = await response.text();
-    if (!text) {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        `Empty response from sendRawTx API (status: ${response.status})`,
-        { status: response.status }
-      );
-    }
-    const res = JSON.parse(text);
-    console.log("\u{1F4E1} sendRawTransaction response:", {
-      status: response.status,
-      ok: response.ok,
-      response: res
-    });
-    if (!response.ok) {
-      console.error("\u274C sendRawTransaction error:", {
-        status: response.status,
-        errorMessage: res.errorMessage || res.msg || res.message,
-        fullResponse: res
-      });
-    }
-    if (response.status === 401 && this.refreshToken) {
-      try {
-        await this.refreshAccessToken();
-        const retryResponse = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Secure-Channel": secureChannelId,
-            ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-          },
-          body: bodyString
-        });
-        const retryText = await retryResponse.text();
-        if (!retryText) {
-          throw createAbcError(
-            "NETWORK_ERROR" /* NETWORK_ERROR */,
-            `Empty response after retry (status: ${retryResponse.status})`,
-            { status: retryResponse.status }
-          );
-        }
-        const retryRes = JSON.parse(retryText);
-        if (retryRes.item || retryRes.txHash || retryRes.result?.txHash) {
-          const txHash = retryRes.item || retryRes.txHash || retryRes.result.txHash;
-          return { txHash };
-        }
-        throw createAbcError(
-          "NETWORK_ERROR" /* NETWORK_ERROR */,
-          "Failed to send transaction after token refresh",
-          retryRes
-        );
-      } catch (refreshError) {
-        console.error(
-          "Token refresh failed in sendRawTransaction:",
-          refreshError
-        );
-        throw refreshError;
-      }
-    }
-    if (res.result) {
-      if (typeof res.result === "string") {
-        console.log("\u2705 Transaction hash from result:", res.result);
-        return { txHash: res.result };
-      }
-      if (res.result.txHash) {
-        return { txHash: res.result.txHash };
-      }
-    }
-    if (res.item) {
-      return { txHash: res.item };
-    }
-    if (res.txHash) {
-      return { txHash: res.txHash };
-    }
-    throw createAbcError(
-      "NETWORK_ERROR" /* NETWORK_ERROR */,
-      "Failed to send transaction",
-      res
-    );
-  }
-  /**
-   * Estimate gas for EIP-1559 transaction
-   * Routes through TalkenApiClient (talken-api proxy)
-   */
-  async estimateGas(params) {
-    const network = getNetworkName(params.chainId);
-    const api = getTalkenApiClient();
-    if (!api) {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "TalkenApiClient not initialized"
+        "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;
+      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 gas estimate response"
+        "No result in nonce response"
       );
     } catch (error) {
       if (error?.code === "NETWORK_ERROR" /* NETWORK_ERROR */) {
@@ -2761,86 +2102,9 @@ var AbcWaasClient = class {
       }
       throw createAbcError(
         "NETWORK_ERROR" /* NETWORK_ERROR */,
-        error.message || "Failed to estimate gas"
-      );
-    }
-  }
-  /**
-   * Get transaction count (nonce)
-   * Reference: ABC WaaS API - /wapi/v2/transactions/count
-   */
-  async getTransactionCount(params) {
-    const network = getNetworkName(params.chainId);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const bodyData = {
-      network,
-      address: params.address
-    };
-    const bodyString = new URLSearchParams(bodyData).toString();
-    const url = `${this.baseURL}${ABC_ENDPOINTS.TRANSACTION_COUNT}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        "Secure-Channel": secureChannelId,
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: bodyString
-    });
-    const text = await response.text();
-    if (!text) {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        `Empty response from transaction count API (status: ${response.status})`,
-        { status: response.status }
+        error.message || "Failed to get transaction count"
       );
     }
-    const res = JSON.parse(text);
-    if (response.status === 401 && this.refreshToken) {
-      try {
-        await this.refreshAccessToken();
-        const retryResponse = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Secure-Channel": secureChannelId,
-            ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-          },
-          body: bodyString
-        });
-        const retryText = await retryResponse.text();
-        if (!retryText) {
-          throw createAbcError(
-            "NETWORK_ERROR" /* NETWORK_ERROR */,
-            `Empty response after retry (status: ${retryResponse.status})`,
-            { status: retryResponse.status }
-          );
-        }
-        const retryRes = JSON.parse(retryText);
-        if (retryRes.result !== void 0) {
-          return typeof retryRes.result === "number" ? `0x${retryRes.result.toString(16)}` : retryRes.result;
-        }
-        throw createAbcError(
-          "NETWORK_ERROR" /* NETWORK_ERROR */,
-          "Failed to get transaction count after token refresh",
-          retryRes
-        );
-      } catch (refreshError) {
-        console.error(
-          "Token refresh failed in getTransactionCount:",
-          refreshError
-        );
-        throw refreshError;
-      }
-    }
-    if (res.result !== void 0) {
-      return typeof res.result === "number" ? `0x${res.result.toString(16)}` : res.result;
-    }
-    throw createAbcError(
-      "NETWORK_ERROR" /* NETWORK_ERROR */,
-      res.errorMessage || res.msg || "Failed to get transaction count",
-      res
-    );
   }
   /**
    * Get wallet info
@@ -2909,217 +2173,105 @@ var AbcWaasClient = class {
    * Reference: SigningService.ts:56-72, wallet/api/index.ts:56-72
    */
   async generateSolanaWallet(pin, isRecover = false) {
-    const url = `${this.baseURL}/v3/wallet/${isRecover ? "recover" : "generate"}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        // V3 API requires JSON, not form-urlencoded
-        Accept: "application/json",
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify({
-        curve: "ed25519",
-        password: pin
-        // PIN will be encrypted by Secure Channel
-        // Note: network parameter not needed for v3 API
-      })
-    });
-    let data;
-    try {
-      data = await response.json();
-    } catch (e) {
-      console.error(`[AbcWaasClient] Failed to parse response from ${url}:`, e);
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        `Failed to ${isRecover ? "recover" : "generate"} Solana wallet - invalid response`,
-        { status: response.status }
-      );
-    }
-    if (!response.ok) {
-      if (!isRecover && response.status === 409) {
-        const error = createAbcError(
-          "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-          "Wallet already exists",
-          data
-        );
-        error.response = { status: 409 };
-        throw error;
-      }
-      console.error(
-        `[AbcWaasClient] ${isRecover ? "Recover" : "Generate"} failed:`,
-        data
-      );
+    const api = getTalkenApiClient();
+    if (!api) {
       throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        `Failed to ${isRecover ? "recover" : "generate"} Solana wallet`,
-        data
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "TalkenApiClient not initialized"
       );
     }
-    const result = data.result || data;
-    if (!result.key_id || !result.public_key || !result.encrypted_share) {
-      console.error(
-        "[AbcWaasClient] Invalid wallet response, missing required fields:",
-        result
-      );
+    const response = isRecover ? await api.wallet.recover(pin) : await api.wallet.generate(pin);
+    if (!response.solana) {
       throw createAbcError(
         "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        `Invalid wallet response from ${isRecover ? "recover" : "generate"}`,
-        data
+        `Solana wallet not returned from ${isRecover ? "recovery" : "generation"}`
       );
     }
-    const solanaNetwork = getSolanaNetwork();
-    const addressResult = await this.getSolanaAddress(
-      result.public_key,
-      solanaNetwork
-    );
-    return {
-      uid: result.uid || "",
-      sessionId: result.share_id || result.key_id,
-      shareId: result.share_id || result.key_id,
-      publicKey: result.public_key,
-      address: addressResult,
-      keyId: result.key_id,
-      encryptedShare: result.encrypted_share || "",
-      secretStore: result.secret_store || "",
-      network: solanaNetwork
-    };
+    return response.solana;
   }
   /**
    * Get Solana address from Ed25519 public key
    * Reference: wallet/api/index.ts:74-82
    */
-  async getSolanaAddress(publicKey, network) {
-    const url = `${this.baseURL}/wapi/v2/solana/wallet/getAddress`;
-    const body = new URLSearchParams({
-      network,
-      publicKey
-    }).toString();
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...DEFAULT_HEADERS,
-        // Contains 'Content-Type': 'application/x-www-form-urlencoded'
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body
-    });
-    const data = await response.json();
-    if (!response.ok || data.status !== "success") {
+  async getSolanaAddress(publicKey, _network) {
+    const api = getTalkenApiClient();
+    if (!api) {
       throw createAbcError(
         "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Failed to get Solana address",
-        data
+        "TalkenApiClient not initialized"
       );
     }
-    return data.result?.data?.address;
+    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
-   * Reference: SigningService.ts:587-626, wallet/api/index.ts:114-122
+   * Sign Solana transaction with Ed25519 (via talken-api proxy)
    */
   async signSolanaTransaction(params) {
-    const url = `${this.baseURL}/v3/wallet/sign`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify({
-        uid: params.uid,
-        share_id: params.shareId,
-        key_id: params.keyId,
-        encrypted_share: params.encryptedShare,
-        public_key: params.publicKey,
-        message: params.message,
-        // Hex-encoded transaction
-        password: params.pin,
-        // PIN will be encrypted
-        network: params.network
-        // Required: 'solana' or 'solana_devnet'
-      })
+    const 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
     });
-    const data = await response.json();
-    if (!response.ok || data.status !== "success") {
+    if (!result.signature) {
       throw createAbcError(
         "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        "Failed to sign Solana transaction",
-        data
+        "Failed to sign Solana transaction"
       );
     }
-    return {
-      signature: data.result?.signature
-    };
+    return { signature: result.signature };
   }
   /**
-   * Sign Solana message with Ed25519
-   * Reference: SigningService.ts:546-579
+   * Sign Solana message with Ed25519 (via talken-api proxy)
    */
   async signSolanaMessage(params) {
-    const url = `${this.baseURL}/v3/wallet/sign`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify({
-        uid: params.uid,
-        share_id: params.shareId,
-        key_id: params.keyId,
-        encrypted_share: params.encryptedShare,
-        public_key: params.publicKey,
-        message: params.message,
-        // Hex-encoded message
-        password: params.pin,
-        network: params.network
-        // Required: 'solana' or 'solana_devnet'
-      })
+    const 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
     });
-    const data = await response.json();
-    if (!response.ok || data.status !== "success") {
+    if (!result.signature) {
       throw createAbcError(
         "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        "Failed to sign Solana message",
-        data
+        "Failed to sign Solana message"
       );
     }
-    return {
-      signature: data.result?.signature
-    };
+    return { signature: result.signature };
   }
   /**
-   * Send Solana transaction
-   * Reference: SigningService.ts:418, wallet/api/index.ts:124-132
+   * Send Solana transaction (via talken-api proxy)
+   * @deprecated Use TalkenApiClient.solana.transfer() for integrated flow
    */
-  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
-    };
+  async sendSolanaTransaction(_params) {
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "sendSolanaTransaction is deprecated. Use TalkenApiClient.solana.transfer() instead."
+    );
   }
 };
 function createAbcWaasClient(config) {
@@ -3129,7 +2281,7 @@ function createAbcWaasClient(config) {
 // src/wallets/walletConnectors/abcWallet/abcProvider.ts
 init_networks();
 import { getTalkenApiClient as getTalkenApiClient2 } from "@talken/talkenkit";
-import { parseGwei as parseGwei2 } from "viem";
+import { parseGwei } from "viem";
 var EventEmitter = class {
   constructor() {
     this.events = /* @__PURE__ */ new Map();
@@ -3366,7 +2518,7 @@ var AbcEvmProvider = class extends EventEmitter {
       }
       if (resolved.gasFee?.maxFeePerGas) {
         try {
-          const maxFeeWei = parseGwei2(resolved.gasFee.maxFeePerGas);
+          const maxFeeWei = parseGwei(resolved.gasFee.maxFeePerGas);
           tx.maxFeePerGas = `0x${maxFeeWei.toString(16)}`;
         } catch (error) {
           console.error(
@@ -3377,7 +2529,7 @@ var AbcEvmProvider = class extends EventEmitter {
       }
       if (resolved.gasFee?.maxPriorityFeePerGas) {
         try {
-          const priorityFeeWei = parseGwei2(
+          const priorityFeeWei = parseGwei(
             resolved.gasFee.maxPriorityFeePerGas
           );
           tx.maxPriorityFeePerGas = `0x${priorityFeeWei.toString(16)}`;
@@ -3410,7 +2562,7 @@ var AbcEvmProvider = class extends EventEmitter {
     const api = this.talkenApi || getTalkenApiClient2();
     const result = await api.evm.sendTransaction({
       chainKey: getChainKey(this.chainId),
-      toAddress: tx.to,
+      to: tx.to,
       amountWei,
       pin: pinHash,
       data: tx.data || "0x",
@@ -3444,7 +2596,7 @@ var AbcEvmProvider = class extends EventEmitter {
       }
       if (resolved.gasFee?.maxFeePerGas) {
         try {
-          const maxFeeWei = parseGwei2(resolved.gasFee.maxFeePerGas);
+          const maxFeeWei = parseGwei(resolved.gasFee.maxFeePerGas);
           tx.maxFeePerGas = `0x${maxFeeWei.toString(16)}`;
         } catch (error) {
           console.error(
@@ -3455,7 +2607,7 @@ var AbcEvmProvider = class extends EventEmitter {
       }
       if (resolved.gasFee?.maxPriorityFeePerGas) {
         try {
-          const priorityFeeWei = parseGwei2(
+          const priorityFeeWei = parseGwei(
             resolved.gasFee.maxPriorityFeePerGas
           );
           tx.maxPriorityFeePerGas = `0x${priorityFeeWei.toString(16)}`;
@@ -3508,10 +2660,13 @@ var AbcEvmProvider = class extends EventEmitter {
       );
     }
     const api = this.talkenApi || getTalkenApiClient2();
+    const network = getNetworkName(this.chainId);
+    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || void 0;
     const result = await api.evm.signPersonal({
-      network: getNetworkName(this.chainId),
+      network,
       message,
-      address: this.wallet.address
+      address,
+      pin: pinHash
     });
     return result.signature;
   }
@@ -3554,9 +2709,11 @@ var AbcEvmProvider = class extends EventEmitter {
     }
     const api = this.talkenApi || getTalkenApiClient2();
     const network = getNetworkName(this.chainId);
+    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || void 0;
     const result = await api.evm.signTypedData({
       network,
-      typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData)
+      typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData),
+      pin: pinHash
     });
     return result.signature;
   }
@@ -3684,6 +2841,89 @@ function createAbcEvmProvider(client, talkenApi) {
 }
 var createAbcProvider = createAbcEvmProvider;
 
+// src/wallets/walletConnectors/abcWallet/networkConfig.ts
+var SolanaNetwork = /* @__PURE__ */ ((SolanaNetwork3) => {
+  SolanaNetwork3["Mainnet"] = "solana";
+  SolanaNetwork3["Devnet"] = "solana_devnet";
+  SolanaNetwork3["Testnet"] = "solana_testnet";
+  return SolanaNetwork3;
+})(SolanaNetwork || {});
+var BitcoinNetwork = /* @__PURE__ */ ((BitcoinNetwork2) => {
+  BitcoinNetwork2["Mainnet"] = "bitcoin";
+  BitcoinNetwork2["Testnet"] = "bitcoin_testnet";
+  return BitcoinNetwork2;
+})(BitcoinNetwork || {});
+var TronNetwork = /* @__PURE__ */ ((TronNetwork2) => {
+  TronNetwork2["Mainnet"] = "tron";
+  TronNetwork2["Nile"] = "tron_nile";
+  return TronNetwork2;
+})(TronNetwork || {});
+var DEFAULT_NETWORK_CONFIG = {
+  evm: {
+    mainnet: 1,
+    // Ethereum Mainnet
+    testnet: 11155111
+    // Sepolia Testnet
+  },
+  solana: {
+    mainnet: "solana" /* Mainnet */,
+    devnet: "solana_devnet" /* Devnet */
+  },
+  bitcoin: {
+    mainnet: "bitcoin" /* Mainnet */,
+    testnet: "bitcoin_testnet" /* Testnet */
+  },
+  tron: {
+    mainnet: "tron" /* Mainnet */,
+    testnet: "tron_nile" /* Nile */
+  }
+};
+var globalDefaultChainId;
+var globalDefaultSolanaNetwork;
+var globalDefaultBitcoinNetwork;
+var globalDefaultTronNetwork;
+function setGlobalDefaultChainId(chainId) {
+  globalDefaultChainId = chainId;
+}
+function setGlobalDefaultSolanaNetwork(network) {
+  globalDefaultSolanaNetwork = network;
+}
+function setGlobalDefaultBitcoinNetwork(network) {
+  globalDefaultBitcoinNetwork = network;
+}
+function getEvmNetwork(customChainId) {
+  if (customChainId !== void 0) {
+    return customChainId;
+  }
+  if (globalDefaultChainId !== void 0) {
+    return globalDefaultChainId;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  const fallbackChainId = isProduction ? DEFAULT_NETWORK_CONFIG.evm.mainnet : DEFAULT_NETWORK_CONFIG.evm.testnet;
+  return fallbackChainId;
+}
+function getSolanaNetwork() {
+  if (globalDefaultSolanaNetwork !== void 0) {
+    return globalDefaultSolanaNetwork;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  return isProduction ? DEFAULT_NETWORK_CONFIG.solana.mainnet : DEFAULT_NETWORK_CONFIG.solana.devnet;
+}
+function getBitcoinNetwork() {
+  if (globalDefaultBitcoinNetwork !== void 0) {
+    return globalDefaultBitcoinNetwork;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  return isProduction ? DEFAULT_NETWORK_CONFIG.bitcoin.mainnet : DEFAULT_NETWORK_CONFIG.bitcoin.testnet;
+}
+function getTronNetwork() {
+  if (globalDefaultTronNetwork !== void 0) {
+    return globalDefaultTronNetwork;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  return isProduction ? DEFAULT_NETWORK_CONFIG.tron.mainnet : DEFAULT_NETWORK_CONFIG.tron.testnet;
+}
+
 // src/wallets/walletConnectors/abcWallet/abcConnector.ts
 function abcConnector(options) {
   const { config } = options;
@@ -4124,7 +3364,7 @@ var TalkenWalletModule = class {
   }
   /**
    * Generate/recover MPC wallets (create = idempotent generate/recover)
-   * POST /wallet/mpc { action: 'create', email?, devicePassword: pin }
+   * POST /wallet/mpc { action: 'create', email?, pin }
    *
    * @param pin - SHA-256 hashed PIN
    * @param email - User email (optional; server resolves from bearer token if omitted)
@@ -4133,7 +3373,7 @@ var TalkenWalletModule = class {
     return this.client.post(TALKEN_API_ENDPOINTS.WALLET_MPC, {
       action: "create",
       ...email && { email },
-      devicePassword: pin
+      pin
     });
   }
   /**
@@ -4223,7 +3463,7 @@ var TalkenEvmModule = class {
   }
   /**
    * Integrated EVM transfer (sign + broadcast)
-   * POST /wallet/tx/evm { chainKey, toAddress, amountWei, pin, ... }
+   * POST /wallet/tx/evm { chainKey, to, amountWei, pin, ... }
    */
   async sendTransaction(params) {
     return this.client.post(
@@ -4267,8 +3507,6 @@ var TalkenEvmModule = class {
     const qs = new URLSearchParams({ network, address }).toString();
     return this.client.get(`${TALKEN_API_ENDPOINTS.NONCE}?${qs}`);
   }
-  // NOTE: signPersonal (EIP-191) is NOT proxied by talken-api.
-  // Use the existing WaaS direct call in abcApi.ts.
 };
 var TalkenSolanaModule = class {
   constructor(client) {
@@ -4286,8 +3524,22 @@ var TalkenSolanaModule = class {
       params
     );
   }
-  // NOTE: signMessage, signTransaction are NOT proxied by talken-api.
-  // Use the existing WaaS direct calls in abcApi.ts.
+  /**
+   * Sign Solana transaction or message (sign-only, no broadcast)
+   * POST /wallet/sign/sol
+   *
+   * Two modes:
+   * - PIN mode: { message, pin } — server resolves signing material
+   * - Share mode: { message, keyId, encryptedShare } — no PIN required (for signMessage)
+   *
+   * @returns Ed25519 signature (hex) and optionally public key
+   */
+  async sign(params) {
+    return this.client.post(
+      TALKEN_API_ENDPOINTS.SIGN_SVM,
+      params
+    );
+  }
 };
 var TalkenBitcoinModule = class {
   constructor(client) {
@@ -4370,6 +3622,16 @@ var TalkenBitcoinModule = class {
       params
     );
   }
+  /**
+   * Sign raw hash via secp256k1 MPC (universal: EVM/BTC/TVM)
+   * POST /wallet/sign/hash { hash, pin, network? }
+   */
+  async signHash(params) {
+    return this.client.post(
+      TALKEN_API_ENDPOINTS.SIGN_HASH,
+      params
+    );
+  }
   /**
    * Broadcast raw BTC transaction
    * POST /wallet/tx/raw { network, signedSerializeTx }
@@ -4620,7 +3882,7 @@ var TalkenApiClient = class {
           errCode,
           errMsg,
           response.status,
-          data.error?.details
+          data.error?.details || data.details
         );
       }
       return data.data ?? data;
@@ -4671,19 +3933,13 @@ function createTalkenApiClient(config) {
 
 // src/wallets/walletConnectors/abcWallet/abcWallet.ts
 var abcWallet = (specificOptions) => ({ projectId }) => {
-  if (specificOptions?.talkenApiUrl) {
-    const talkenApi = createTalkenApiClient({
-      baseUrl: specificOptions.talkenApiUrl,
-      debug: specificOptions?.environment === "development"
-    });
-    setTalkenApiClient(talkenApi);
-  }
-  const waasUrl = specificOptions?.waasUrl || process.env.NEXT_PUBLIC_ABC_WAAS_URL || process.env.VITE_ABC_WAAS_URL;
-  if (!waasUrl) {
-    throw new Error(
-      'ABC WaaS URL is required. Please provide it via:\n1. abcWallet({ waasUrl: "..." }) options, or\n2. NEXT_PUBLIC_ABC_WAAS_URL environment variable, or\n3. VITE_ABC_WAAS_URL environment variable'
-    );
-  }
+  const talkenApiUrl = specificOptions?.talkenApiUrl || process.env.NEXT_PUBLIC_API_URL || "http://localhost:3001/api/v1";
+  const talkenApi = createTalkenApiClient({
+    baseUrl: talkenApiUrl,
+    debug: specificOptions?.environment === "development"
+  });
+  setTalkenApiClient(talkenApi);
+  const waasUrl = specificOptions?.waasUrl || process.env.NEXT_PUBLIC_ABC_WAAS_URL || process.env.VITE_ABC_WAAS_URL || "";
   const config = {
     waasUrl,
     apiKey: specificOptions?.apiKey,
@@ -4723,7 +3979,6 @@ var BaseApiClient = class {
     this.refreshPromise = null;
     this.config = config;
     this.baseURL = config.waasUrl;
-    this.secure = new secure_default(this.baseURL);
     this.loadTokens();
   }
   /**
@@ -4965,12 +4220,6 @@ var BaseApiClient = class {
   async logout() {
     this.clearTokens();
   }
-  /**
-   * Get secure service instance
-   */
-  getSecureService() {
-    return this.secure;
-  }
 };
 
 // src/wallets/walletConnectors/abcWallet/api/AuthApi.ts
@@ -5185,9 +4434,6 @@ var WalletApi = class extends BaseApiClient {
       encryptedShare: evm.encryptedShare || "",
       uid: evm.uid,
       sid: evm.sid,
-      wid: evm.wid,
-      pvencstr: evm.pvencstr,
-      encryptDevicePassword: evm.encryptDevicePassword,
       pubkey: evm.pubkey || null
     };
   }
@@ -5271,96 +4517,7 @@ var WalletApi = class extends BaseApiClient {
 };
 
 // src/wallets/walletConnectors/abcWallet/api/TransactionApi.ts
-init_networks();
 var TransactionApi = class extends BaseApiClient {
-  /**
-   * Send raw transaction
-   */
-  async sendRawTransaction(chainId, signedTransaction) {
-    const network = getNetworkName(chainId);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const bodyData = {
-      signedSerializeTx: signedTransaction,
-      network
-    };
-    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);
-    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") {
-        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 transaction count (nonce)
    */
@@ -5436,452 +4593,126 @@ var TransactionApi = class extends BaseApiClient {
   }
 };
 
-// src/wallets/walletConnectors/abcWallet/api/SigningApi.ts
-init_networks();
-import { getAddress as getAddress2 } from "viem";
-var SigningApi = class extends BaseApiClient {
+// src/wallets/walletConnectors/abcWallet/api/SolanaApi.ts
+import { PublicKey } from "@solana/web3.js";
+import { getTalkenApiClient as getTalkenApiClient7 } from "@talken/talkenkit";
+var SolanaApi = class extends BaseApiClient {
   /**
-   * Sign EVM transaction (EIP-1559)
+   * Generate Solana wallet (Ed25519)
+   * Delegates to TalkenApiClient unified wallet endpoint.
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @param isRecover - Whether to recover existing wallet (default: false)
+   * @returns Solana wallet information
    */
-  async signTransaction(params) {
-    this.loadTokens();
-    const wallet = loadFromStorage("wallet" /* WALLET */);
-    if (!wallet) {
+  async generateSolanaWallet(pin, isRecover = false) {
+    const api = getTalkenApiClient7();
+    if (!api)
+      throw new 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 */,
-        "Wallet information not found in storage"
+        `Solana wallet not returned from TalkenApiClient ${isRecover ? "recovery" : "generation"}`
       );
     }
-    const encryptedDevicePassword = await this.secure.getEncryptPlain(
-      wallet.encryptDevicePassword
-    );
-    const encryptedPvencstr = await this.secure.getEncryptPlain(
-      wallet.pvencstr
+    return response.solana;
+  }
+  /**
+   * Recover Solana wallet (alias for generateSolanaWallet with isRecover=true)
+   * When TalkenApiClient is available, delegates to the unified recovery endpoint.
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @returns Recovered Solana wallet information
+   */
+  async recoverSolanaWallet(pin) {
+    return this.generateSolanaWallet(pin, true);
+  }
+  /**
+   * Get Solana address from wallet addresses endpoint
+   * Retrieves from TalkenApiClient unified addresses endpoint.
+   *
+   * @returns Solana address string or null if not available
+   */
+  async getSolanaAddress() {
+    const api = getTalkenApiClient7();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    const addresses = await api.wallet.getAddresses();
+    return addresses.solana || null;
+  }
+  /**
+   * Derive Solana address from Ed25519 public key
+   * @param publicKey - Ed25519 public key (hex)
+   * @returns Solana address (base58)
+   */
+  deriveAddressFromPublicKey(publicKey) {
+    const cleanKey = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+    const bytes = new Uint8Array(
+      cleanKey.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
     );
-    const encryptedWid = await this.secure.getEncryptPlain(wallet.wid);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const network = getNetworkName(params.chainId);
-    const tx = params.transaction;
-    const _isContractDeployment = !params.transaction.to || params.transaction.to === "0x" || params.transaction.to === "0x0";
-    const bodyData = {
-      network,
-      encryptDevicePassword: encryptedDevicePassword,
-      pvencstr: encryptedPvencstr,
-      uid: wallet.uid,
-      wid: encryptedWid,
-      sid: getAddress2(wallet.address),
-      to: tx.to === "0x" ? "0x" : getAddress2(tx.to),
-      type: "EIP1559",
-      ourpubkey: "",
-      ucpubkey: ""
-    };
-    bodyData.from = getAddress2(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}`;
-    }
-    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)}`;
-      }
+    try {
+      const pubkey = new PublicKey(bytes);
+      return pubkey.toBase58();
+    } catch (error) {
+      console.error("[SolanaApi] Failed to encode address:", error);
+      return cleanKey;
     }
-    if (tx.maxPriorityFeePerGas) {
-      if (tx.maxPriorityFeePerGas.toString().startsWith("0x")) {
-        bodyData.maxPriorityFeePerGas = tx.maxPriorityFeePerGas.toString();
-      } else {
-        bodyData.maxPriorityFeePerGas = `0x${BigInt(tx.maxPriorityFeePerGas).toString(16)}`;
-      }
+  }
+  /**
+   * Sign Solana transaction with Ed25519 (via talken-api proxy, PIN mode)
+   */
+  async signSolanaTransaction(params) {
+    const api = getTalkenApiClient7();
+    if (!api) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "TalkenApiClient not initialized"
+      );
     }
-    bodyData.data = tx.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 network = getSolanaNetwork();
+    const result = await api.solana.sign({
+      message: params.message,
+      pin: params.pin,
+      keyId: params.keyId,
+      encryptedShare: params.encryptedShare,
+      secretStore: params.secretStore,
+      network
     });
-    const res = await response.json();
-    if (response.status === 401 && this.refreshToken) {
-      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
-      );
-    }
-    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)
-   */
-  async signMessage(params) {
-    this.loadTokens();
-    const wallet = loadFromStorage("wallet" /* WALLET */);
-    if (!wallet) {
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Wallet information not found in storage"
-      );
-    }
-    const ethers = await import("ethers");
-    const messageHash = ethers.utils.hashMessage(params.message);
-    const hash = messageHash.startsWith("0x") ? messageHash.slice(2) : messageHash;
-    const encryptedDevicePassword = await this.secure.getEncryptPlain(
-      wallet.encryptDevicePassword
-    );
-    const encryptedPvencstr = await this.secure.getEncryptPlain(
-      wallet.pvencstr
-    );
-    const encryptedWid = await this.secure.getEncryptPlain(wallet.wid);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const bodyData = {
-      hash,
-      encryptDevicePassword: encryptedDevicePassword,
-      pvencstr: encryptedPvencstr,
-      wid: encryptedWid,
-      uid: wallet.uid,
-      sid: wallet.sid
-    };
-    const bodyString = new URLSearchParams(bodyData).toString();
-    const url = `${this.baseURL}${ABC_ENDPOINTS.SIGN_HASH}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        "Secure-Channel": secureChannelId,
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: bodyString
-    });
-    const text = await response.text();
-    if (!text) {
+    if (!result.signature) {
       throw createAbcError(
         "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        `Empty response from sign API (status: ${response.status})`,
-        { status: response.status }
+        "Failed to sign Solana transaction"
       );
     }
-    const res = JSON.parse(text);
-    if (response.status === 401) {
-      if (!this.refreshToken) {
-        this.loadTokens();
-      }
-      if (this.refreshToken) {
-        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
-        );
-      }
-    }
-    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
-    );
+    return { signature: result.signature };
   }
   /**
-   * Sign typed data (EIP-712)
+   * Sign Solana message with Ed25519 (via talken-api proxy, Share mode — no PIN)
    */
-  async signTypedData(params) {
-    const wallet = loadFromStorage("wallet" /* WALLET */);
-    if (!wallet) {
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Wallet information not found in storage"
-      );
-    }
-    const encryptedDevicePassword = await this.secure.getEncryptPlain(
-      wallet.encryptDevicePassword
-    );
-    const encryptedPvencstr = await this.secure.getEncryptPlain(
-      wallet.pvencstr
-    );
-    const encryptedWid = await this.secure.getEncryptPlain(wallet.wid);
-    const secureChannelId = await this.secure.getSecureChannelId();
-    const network = getNetworkName(wallet.chainId);
-    const bodyData = {
-      messageJson: params.typedData,
-      version: "v4",
-      network,
-      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) {
-      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
-      );
-    }
-    if (res.serializedTx) {
-      return { signature: res.serializedTx };
-    }
-    throw createAbcError(
-      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-      "Failed to sign typed data",
-      res
-    );
-  }
-};
-
-// src/wallets/walletConnectors/abcWallet/api/SolanaApi.ts
-import { PublicKey } from "@solana/web3.js";
-import { getTalkenApiClient as getTalkenApiClient7 } from "@talken/talkenkit";
-var SolanaApi = class extends BaseApiClient {
-  /**
-   * Generate Solana wallet (Ed25519)
-   * Delegates to TalkenApiClient unified wallet endpoint.
-   *
-   * @param pin - Hashed PIN (SHA-256)
-   * @param isRecover - Whether to recover existing wallet (default: false)
-   * @returns Solana wallet information
-   */
-  async generateSolanaWallet(pin, isRecover = false) {
-    const api = getTalkenApiClient7();
-    if (!api)
-      throw new 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 TalkenApiClient ${isRecover ? "recovery" : "generation"}`
-      );
-    }
-    return response.solana;
-  }
-  /**
-   * Recover Solana wallet (alias for generateSolanaWallet with isRecover=true)
-   * When TalkenApiClient is available, delegates to the unified recovery endpoint.
-   *
-   * @param pin - Hashed PIN (SHA-256)
-   * @returns Recovered Solana wallet information
-   */
-  async recoverSolanaWallet(pin) {
-    return this.generateSolanaWallet(pin, true);
-  }
-  /**
-   * Get Solana address from wallet addresses endpoint
-   * Retrieves from TalkenApiClient unified addresses endpoint.
-   *
-   * @returns Solana address string or null if not available
-   */
-  async getSolanaAddress() {
+  async signSolanaMessage(params) {
     const api = getTalkenApiClient7();
-    if (!api)
-      throw new Error("TalkenApiClient not initialized");
-    const addresses = await api.wallet.getAddresses();
-    return addresses.solana || null;
-  }
-  /**
-   * Derive Solana address from Ed25519 public key
-   * @param publicKey - Ed25519 public key (hex)
-   * @returns Solana address (base58)
-   */
-  deriveAddressFromPublicKey(publicKey) {
-    const cleanKey = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
-    const bytes = new Uint8Array(
-      cleanKey.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
-    );
-    try {
-      const pubkey = new PublicKey(bytes);
-      return pubkey.toBase58();
-    } catch (error) {
-      console.error("[SolanaApi] Failed to encode address:", error);
-      return cleanKey;
-    }
-  }
-  /**
-   * Sign Solana transaction with Ed25519
-   * Reference: /v3/wallet/sign API requires only 5 fields
-   */
-  async signSolanaTransaction(params) {
-    const network = getSolanaNetwork();
-    const response = await this.request("/v3/wallet/sign", {
-      method: "POST",
-      contentType: "json",
-      body: {
-        curve: "ed25519",
-        network,
-        key_id: params.keyId,
-        encrypted_share: params.encryptedShare,
-        secret_store: params.secretStore || "",
-        message: params.message
-      }
-    });
-    let signature;
-    if (response.status === "success" && response.result?.signature) {
-      signature = response.result.signature;
-    } else if (response.signature) {
-      signature = response.signature;
-    } else {
+    if (!api) {
       throw createAbcError(
-        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        "Failed to sign Solana transaction",
-        response
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "TalkenApiClient not initialized"
       );
     }
-    return {
-      signature
-    };
-  }
-  /**
-   * Sign Solana message with Ed25519
-   * Reference: /v3/wallet/sign API requires only 5 fields
-   */
-  async signSolanaMessage(params) {
     const network = getSolanaNetwork();
-    const response = await this.request("/v3/wallet/sign", {
-      method: "POST",
-      contentType: "json",
-      body: {
-        curve: "ed25519",
-        network,
-        key_id: params.keyId,
-        encrypted_share: params.encryptedShare,
-        secret_store: params.secretStore || "",
-        message: params.message
-      }
+    const result = await api.solana.sign({
+      message: params.message,
+      keyId: params.keyId,
+      encryptedShare: params.encryptedShare,
+      secretStore: params.secretStore,
+      network
     });
-    let signature;
-    if (response.status === "success" && response.result?.signature) {
-      signature = response.result.signature;
-    } else if (response.signature) {
-      signature = response.signature;
-    } else {
+    if (!result.signature) {
       throw createAbcError(
         "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        "Failed to sign Solana message",
-        response
+        "Failed to sign Solana message"
       );
     }
-    return {
-      signature
-    };
+    return { signature: result.signature };
   }
   /**
    * Generate Solana transfer transaction via ABC WaaS API
@@ -6062,778 +4893,207 @@ var BitcoinApi = class extends BaseApiClient {
    * @returns Bitcoin wallet information
    */
   async generateBitcoinWallet(pin, network = "bitcoin", addressType = "bech32") {
-    console.log("[BitcoinApi] \u{1F527} Generating Bitcoin wallet...", {
-      network,
-      addressType
-    });
-    const response = await this.request("/v3/wallet/generate", {
-      method: "POST",
-      contentType: "json",
-      body: {
-        curve: "secp256k1",
-        // Same as EVM but compressed public key
-        password: pin,
-        network
-      }
-    });
-    if (response.status !== "success" || !response.result) {
-      console.error("[BitcoinApi] \u274C Generation failed:", response);
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Failed to generate Bitcoin wallet",
-        response
-      );
-    }
-    const result = response.result;
-    const addressResult = await this.getBitcoinAddress(
-      result.public_key,
+    console.log("[BitcoinApi] Generating Bitcoin wallet...", {
       network,
-      addressType
-    );
-    console.log(
-      "[BitcoinApi] \u2705 Bitcoin wallet generated:",
-      `${addressResult.substring(0, 6)}...${addressResult.substring(addressResult.length - 4)}`
-    );
-    return {
-      uid: result.uid || "",
-      sessionId: result.share_id,
-      shareId: result.share_id,
-      publicKey: result.public_key,
-      // Compressed (33 bytes, 0x02 or 0x03 prefix)
-      address: addressResult,
-      addressType,
-      keyId: result.key_id || result.share_id,
-      encryptedShare: result.encrypted_share || "",
-      network
-    };
-  }
-  /**
-   * Recover Bitcoin wallet
-   * Uses V3 API wallet recovery endpoint
-   *
-   * @param pin - Hashed PIN (SHA-256)
-   * @param network - Bitcoin network
-   * @param addressType - Bitcoin address type
-   * @returns Recovered Bitcoin wallet information
-   */
-  async recoverBitcoinWallet(pin, network = "bitcoin", addressType = "bech32") {
-    console.log("[BitcoinApi] \u{1F527} Recovering Bitcoin wallet...", {
-      network,
-      addressType
-    });
-    const response = await this.request("/v3/wallet/recover", {
-      method: "POST",
-      contentType: "json",
-      body: {
-        curve: "secp256k1",
-        password: pin,
-        network
-      }
-    });
-    if (response.status !== "success" || !response.result) {
-      console.error("[BitcoinApi] \u274C Recovery failed:", response);
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Failed to recover Bitcoin wallet",
-        response
-      );
-    }
-    const result = response.result;
-    const addressResult = await this.getBitcoinAddress(
-      result.public_key,
-      network,
-      addressType
-    );
-    console.log(
-      "[BitcoinApi] \u2705 Bitcoin wallet recovered:",
-      `${addressResult.substring(0, 6)}...${addressResult.substring(addressResult.length - 4)}`
-    );
-    return {
-      uid: result.uid || "",
-      sessionId: result.share_id,
-      shareId: result.share_id,
-      publicKey: result.public_key,
-      address: addressResult,
-      addressType,
-      keyId: result.key_id || result.share_id,
-      encryptedShare: result.encrypted_share || "",
-      network
-    };
-  }
-  /**
-   * Get Bitcoin address from compressed public key
-   * Converts compressed public key to Bitcoin address based on address type
-   *
-   * @param publicKey - Compressed public key (33 bytes, hex)
-   * @param network - Bitcoin network
-   * @param addressType - Address format type (currently not used by API)
-   * @returns Bitcoin address
-   */
-  async getBitcoinAddress(publicKey, network, _addressType = "bech32") {
-    const url = `${this.baseURL}/wapi/v2/btc/address`;
-    const params = new URLSearchParams({
-      pubkey: publicKey,
-      network
-    });
-    const response = await fetch(`${url}?${params}`, {
-      method: "GET",
-      headers: {
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      }
-    });
-    const data = await response.json();
-    if (!response.ok) {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Failed to get Bitcoin address",
-        data
-      );
-    }
-    return data.address;
-  }
-  /**
-   * Get UTXOs (Unspent Transaction Outputs) for address
-   * Bitcoin uses UTXO model unlike EVM/Solana account model
-   *
-   * @param address - Bitcoin address
-   * @param network - Bitcoin network
-   * @returns Array of UTXOs
-   */
-  async getUtxos(address, network) {
-    console.log(
-      "[BitcoinApi] \u{1F50D} Fetching UTXOs for:",
-      `${address.substring(0, 6)}...${address.substring(address.length - 4)}`
-    );
-    const url = `${this.baseURL}/wapi/v2/bitcoin/utxo/list`;
-    const params = new URLSearchParams({ network, address });
-    console.log("[BitcoinApi] \u{1F50D} Fetching UTXOs for:", address);
-    const response = await fetch(`${url}?${params}`, {
-      method: "GET",
-      headers: {
-        ...DEFAULT_HEADERS,
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      }
-    });
-    const data = await response.json();
-    if (!response.ok || data.status !== "success") {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Failed to get UTXOs",
-        data
-      );
-    }
-    const utxos = data.result?.utxos || [];
-    console.log(`[BitcoinApi] \u2705 Found ${utxos.length} UTXOs`);
-    return utxos;
-  }
-  /**
-   * Send Bitcoin transaction
-   * Broadcasts signed transaction to Bitcoin network
-   *
-   * @param params - Transaction broadcast parameters
-   * @returns Transaction hash
-   */
-  async sendBitcoinTransaction(params) {
-    const url = `${this.baseURL}/wapi/v2/bitcoin/tx/sendTransaction`;
-    console.log("[BitcoinApi] \u{1F4E1} Broadcasting Bitcoin transaction...");
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...DEFAULT_HEADERS,
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify({
-        network: params.network,
-        rawTransaction: params.rawTransaction,
-        ...params.psbt && { psbt: params.psbt }
-      })
-    });
-    const data = await response.json();
-    if (!response.ok || data.status !== "success") {
-      console.error("[BitcoinApi] \u274C Transaction broadcast failed:", data);
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Failed to send Bitcoin transaction",
-        data
-      );
-    }
-    const txHash = data.result?.data;
-    console.log("[BitcoinApi] \u2705 Transaction broadcasted:", txHash);
-    return {
-      txHash
-    };
-  }
-  /**
-   * Generate Bitcoin transaction (Step 1 of 3)
-   * Creates PSBT and returns hashes to sign
-   *
-   * @param params - Transaction parameters
-   * @returns Transaction data with hashes to sign
-   */
-  async generateTransaction(params) {
-    const url = `${this.baseURL}/wapi/v2/btc/transaction/generate`;
-    console.log("[BitcoinApi] \u{1F527} Generating transaction...", params);
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify(params)
-    });
-    const data = await response.json();
-    if (!response.ok || !data.hashes) {
-      const errorMsg = typeof data.error === "string" ? data.error : JSON.stringify(data.error || data);
-      console.error("[BitcoinApi] \u274C Generate failed:", errorMsg);
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        `Failed to generate transaction: ${errorMsg}`,
-        data
-      );
-    }
-    console.log(
-      `[BitcoinApi] \u2705 Generated ${data.hashes.length} hashes to sign`
-    );
-    return data;
-  }
-  /**
-   * Sign transaction hash (Step 2 of 3)
-   * Uses Secure Channel encryption for signing
-   * Based on tg-wallet-frontend reference implementation
-   *
-   * @param hash - Transaction hash to sign
-   * @param wallet - Full wallet object with Bitcoin signing fields
-   * @param pinHash - Hashed PIN for device password
-   * @param secureService - Secure service instance for encryption
-   * @returns Signature hex string (r + s without 0x prefix on s)
-   */
-  async signHash(hash, wallet, pinHash, secureService) {
-    console.log("[BitcoinApi] \u{1F510} Signing hash:", `${hash.substring(0, 20)}...`);
-    if (!wallet.wid || !wallet.pvencstr) {
-      console.error("[BitcoinApi] \u274C Missing Bitcoin signing fields:", {
-        hasWid: !!wallet.wid,
-        hasPvencstr: !!wallet.pvencstr,
-        hasSid: !!wallet.sid,
-        hasUid: !!wallet.uid
-      });
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Wallet missing required fields for Bitcoin signing (wid, pvencstr)",
-        { hasWid: !!wallet.wid, hasPvencstr: !!wallet.pvencstr }
-      );
-    }
-    const encryptDevicePassword = await secureService.getEncryptPlain(
-      wallet.encryptDevicePassword || pinHash
-    );
-    const pvencstr = await secureService.getEncryptPlain(wallet.pvencstr);
-    const wid = await secureService.getEncryptPlain(wallet.wid);
-    const secureChannelId = await secureService.getSecureChannelId();
-    const params = new URLSearchParams({
-      uid: wallet.uid,
-      sid: wallet.sid || "",
-      // Handle optional sid
-      hash,
-      pvencstr,
-      wid,
-      encryptDevicePassword
-    });
-    const url = `${this.baseURL}/wapi/v2/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: params.toString()
-    });
-    const responseText = await response.text();
-    if (!responseText) {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Empty response from sign hash API",
-        { status: response.status }
-      );
-    }
-    let data;
-    try {
-      data = JSON.parse(responseText);
-    } catch (parseError) {
-      console.error("[BitcoinApi] \u274C JSON parse error:", parseError);
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Invalid JSON response from sign hash API",
-        { responseText, parseError }
-      );
-    }
-    if (!response.ok || data.iserr === true || !data.signstr) {
-      const errorDetails = data.errmsg || data.errors?.[0] || data.message || data;
-      console.error("[BitcoinApi] \u274C Sign failed:", errorDetails);
-      throw createAbcError(
-        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        `Failed to sign hash: ${JSON.stringify(errorDetails)}`,
-        data
-      );
-    }
-    const signstr = JSON.parse(data.signstr);
-    const sig_list = signstr.sig_list;
-    const signatures = [];
-    for (const sig of sig_list) {
-      const r = sig.r;
-      const s = sig.s.startsWith("0x") ? sig.s.substring(2) : sig.s;
-      const combinedSig = r + s;
-      signatures.push(combinedSig);
-    }
-    console.log(
-      "[BitcoinApi] \u2705 Signature generated:",
-      `${signatures[0].substring(0, 32)}...`
-    );
-    return signatures[0];
-  }
-  /**
-   * Finalize and broadcast transaction (Step 3 of 3)
-   * Broadcasts signed transaction to Bitcoin network
-   *
-   * @param params - Transaction parameters with signatures
-   * @returns Transaction hash
-   */
-  async finalizeTransaction(params) {
-    const url = `${this.baseURL}/wapi/v2/btc/transaction/finalize`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify(params)
-    });
-    const responseText = await response.text();
-    if (!responseText) {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Empty response from finalize API",
-        { status: response.status }
-      );
-    }
-    let data;
-    try {
-      data = JSON.parse(responseText);
-    } catch (parseError) {
-      console.error("[BitcoinApi] \u274C JSON parse error:", parseError);
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Invalid JSON response from finalize API",
-        { responseText, parseError }
-      );
-    }
-    if (!response.ok) {
-      const errorMsg = data.error || data.message || data.errmsg || "Unknown error";
-      console.error("[BitcoinApi] \u274C Finalize failed:", errorMsg);
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        `Failed to finalize transaction: ${errorMsg}`,
-        data
-      );
-    }
-    const txHash = data.result?.tx_hash || data.tx_hash || data.result?.txHash || data.txHash;
-    if (!txHash) {
-      console.error("[BitcoinApi] \u274C No tx_hash in response:", data);
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Transaction hash not found in response",
-        data
-      );
-    }
-    console.log("[BitcoinApi] \u2705 Transaction sent:", txHash);
-    return txHash;
-  }
-  /**
-   * Send Bitcoin transaction (Complete flow: generate → sign → finalize)
-   * High-level API that handles all 3 steps
-   *
-   * @param params - Transaction parameters
-   * @param wallet - EVM wallet credentials
-   * @param pinHash - Hashed PIN
-   * @param secureService - Secure service instance
-   * @returns Transaction hash
-   */
-  async sendTransaction(params, wallet, pinHash, secureService) {
-    console.log("[BitcoinApi] \u{1F4B8} Starting Bitcoin transaction flow...");
-    const generateData = await this.generateTransaction({
-      amount: params.amount,
-      pubkey: params.pubkey,
-      to: params.to,
-      feeRate: "2"
-      // Default fee rate
-    });
-    const { hashes, fee_rate } = generateData;
-    const signatureHex = [];
-    for (let i = 0; i < hashes.length; i++) {
-      const signature = await this.signHash(
-        hashes[i],
-        wallet,
-        pinHash,
-        secureService
-      );
-      signatureHex.push(signature);
-    }
-    const txHash = await this.finalizeTransaction({
-      network: params.network,
-      signatureHex,
-      feeRate: fee_rate,
-      amount: params.amount,
-      pubkey: params.pubkey,
-      to: params.to
-    });
-    console.log("[BitcoinApi] \u2705 Transaction complete:", txHash);
-    return txHash;
-  }
-  /**
-   * Estimate Bitcoin transaction fee
-   * Gets recommended fee rate (satoshis per byte) for target confirmation blocks
-   *
-   * @param network - Bitcoin network
-   * @param targetBlocks - Target confirmation blocks (default: 6)
-   * @returns Fee rate in satoshis per byte
-   */
-  async estimateFee(network, targetBlocks = 6) {
-    const url = `${this.baseURL}/wapi/v2/bitcoin/fee/estimate`;
-    const params = new URLSearchParams({
-      network,
-      targetBlocks: targetBlocks.toString()
-    });
-    const response = await fetch(`${url}?${params}`, {
-      method: "GET",
-      headers: {
-        ...DEFAULT_HEADERS,
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      }
-    });
-    const data = await response.json();
-    if (!response.ok || data.status !== "success") {
-      console.warn("[BitcoinApi] \u26A0\uFE0F Fee estimation failed, using fallback");
-      return 1;
-    }
-    const feeRate = data.result?.feeRate || 1;
-    console.log(`[BitcoinApi] \u26FD Estimated fee rate: ${feeRate} sat/byte`);
-    return feeRate;
-  }
-};
-
-// src/wallets/walletConnectors/abcWallet/api/TronApi.ts
-import { getTalkenApiClient as getTalkenApiClient8 } from "@talken/talkenkit";
-var TronApi = class extends BaseApiClient {
-  /**
-   * Get TRON address from TalkenApiClient unified addresses endpoint.
-   *
-   * @param _publicKey - Compressed public key (unused, TalkenApiClient resolves internally)
-   * @param _network - TRON network (unused, TalkenApiClient resolves internally)
-   * @returns TRON address (starts with 'T')
-   */
-  async getTronAddress(_publicKey, _network) {
-    const api = getTalkenApiClient8();
-    if (!api)
-      throw new Error("TalkenApiClient not initialized");
-    const addresses = await api.wallet.getAddresses();
-    if (!addresses.tron) {
+      addressType
+    });
+    const response = await this.request("/v3/wallet/generate", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "secp256k1",
+        // Same as EVM but compressed public key
+        password: pin,
+        network
+      }
+    });
+    if (response.status !== "success" || !response.result) {
+      console.error("[BitcoinApi] Generation failed:", response);
       throw createAbcError(
         "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "TRON address not found in TalkenApiClient response"
+        "Failed to generate Bitcoin wallet",
+        response
       );
     }
-    return addresses.tron;
+    const result = response.result;
+    const addressResult = await this.getBitcoinAddress(
+      result.public_key,
+      network,
+      addressType
+    );
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      // Compressed (33 bytes, 0x02 or 0x03 prefix)
+      address: addressResult,
+      addressType,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || "",
+      network
+    };
   }
   /**
-   * Create unsigned TRX native transfer transaction
+   * Recover Bitcoin wallet
+   * Uses V3 API wallet recovery endpoint
    *
-   * @param params - Transfer parameters
-   * @returns Unsigned transaction with raw_data and txID
+   * @param pin - Hashed PIN (SHA-256)
+   * @param network - Bitcoin network
+   * @param addressType - Bitcoin address type
+   * @returns Recovered Bitcoin wallet information
    */
-  async transfer(params) {
-    const url = `${this.baseURL}/wapi/v2/tron/transfer`;
-    console.log("[TronApi] \u{1F4B8} Creating TRX transfer...", {
-      from: `${params.fromAddress.substring(0, 6)}...`,
-      to: `${params.toAddress.substring(0, 6)}...`,
-      amount: params.amount
+  async recoverBitcoinWallet(pin, network = "bitcoin", addressType = "bech32") {
+    console.log("[BitcoinApi] Recovering Bitcoin wallet...", {
+      network,
+      addressType
     });
-    const response = await fetch(url, {
+    const response = await this.request("/v3/wallet/recover", {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify({
-        network: params.network,
-        from_address: params.fromAddress,
-        to_address: params.toAddress,
-        amount: params.amount
-      })
+      contentType: "json",
+      body: {
+        curve: "secp256k1",
+        password: pin,
+        network
+      }
     });
-    const data = await response.json();
-    if (!response.ok || data.status && data.status !== "success") {
-      console.error("[TronApi] \u274C Transfer creation failed:", data);
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Failed to create TRX transfer",
-        data
-      );
-    }
-    const result = data.result || data;
-    const txData = result.transaction || result;
-    const rawData = txData.raw_data;
-    const txID = txData.txID;
-    if (!rawData || !txID) {
+    if (response.status !== "success" || !response.result) {
+      console.error("[BitcoinApi] Recovery failed:", response);
       throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Invalid TRX transfer response: missing raw_data or txID",
-        data
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Failed to recover Bitcoin wallet",
+        response
       );
     }
-    console.log(
-      "[TronApi] \u2705 TRX transfer created:",
-      `${txID.substring(0, 16)}...`
+    const result = response.result;
+    const addressResult = await this.getBitcoinAddress(
+      result.public_key,
+      network,
+      addressType
     );
-    return { txID, rawData };
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address: addressResult,
+      addressType,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || "",
+      network
+    };
   }
   /**
-   * Create unsigned TRC20 token transfer transaction
+   * Get Bitcoin address from compressed public key
    *
-   * @param params - TRC20 transfer parameters
-   * @returns Unsigned transaction with raw_data and txID
-   */
-  async trc20Transfer(params) {
-    const url = `${this.baseURL}/wapi/v2/tron/trc20/transfer`;
-    console.log("[TronApi] \u{1F4B8} Creating TRC20 transfer...", {
-      from: `${params.fromAddress.substring(0, 6)}...`,
-      to: `${params.toAddress.substring(0, 6)}...`,
-      contract: `${params.contractAddress.substring(0, 6)}...`
+   * @param publicKey - Compressed public key (33 bytes, hex)
+   * @param network - Bitcoin network
+   * @param addressType - Address format type (currently not used by API)
+   * @returns Bitcoin address
+   */
+  async getBitcoinAddress(publicKey, network, _addressType = "bech32") {
+    const url = `${this.baseURL}/wapi/v2/btc/address`;
+    const params = new URLSearchParams({
+      pubkey: publicKey,
+      network
     });
-    const response = await fetch(url, {
-      method: "POST",
+    const response = await fetch(`${url}?${params}`, {
+      method: "GET",
       headers: {
-        "Content-Type": "application/json",
         ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: JSON.stringify({
-        network: params.network,
-        from_address: params.fromAddress,
-        to_address: params.toAddress,
-        amount: params.amount,
-        contract_address: params.contractAddress,
-        fee_limit: params.feeLimit || 1e8
-      })
+      }
     });
     const data = await response.json();
-    if (!response.ok || data.status && data.status !== "success") {
-      console.error("[TronApi] \u274C TRC20 transfer creation failed:", data);
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Failed to create TRC20 transfer",
-        data
-      );
-    }
-    const result = data.result || data;
-    const txData = result.transaction || result;
-    const rawData = txData.raw_data;
-    const txID = txData.txID;
-    if (!rawData || !txID) {
+    if (!response.ok) {
       throw createAbcError(
         "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Invalid TRC20 transfer response: missing raw_data or txID",
+        "Failed to get Bitcoin address",
         data
       );
     }
-    console.log(
-      "[TronApi] \u2705 TRC20 transfer created:",
-      `${txID.substring(0, 16)}...`
-    );
-    return { txID, rawData };
+    return data.address;
   }
   /**
-   * Sign transaction hash using Secure Channel (V2 sign/hash API)
-   * Same signing flow as Bitcoin - uses EVM wallet credentials via Secure Channel encryption
+   * Get UTXOs (Unspent Transaction Outputs) for address
    *
-   * @param hash - Transaction hash (txID) to sign
-   * @param wallet - EVM wallet credentials (uid, sid, wid, pvencstr, encryptDevicePassword)
-   * @param pinHash - Hashed PIN (SHA-256)
-   * @param secureService - SecureService instance for ECDH encryption
-   * @returns Array of signature strings (r + s without 0x prefix)
+   * @param address - Bitcoin address
+   * @param network - Bitcoin network
+   * @returns Array of UTXOs
    */
-  async signHash(hash, wallet, pinHash, secureService) {
-    console.log(
-      "[TronApi] \u{1F510} Signing hash:",
-      `${hash.substring(0, 20)}...`
-    );
-    if (!wallet.wid || !wallet.pvencstr) {
-      console.error("[TronApi] \u274C Missing signing fields:", {
-        hasWid: !!wallet.wid,
-        hasPvencstr: !!wallet.pvencstr,
-        hasSid: !!wallet.sid,
-        hasUid: !!wallet.uid
-      });
-      throw createAbcError(
-        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        "Wallet missing required fields for TRON signing (wid, pvencstr)",
-        { hasWid: !!wallet.wid, hasPvencstr: !!wallet.pvencstr }
-      );
-    }
-    const encryptDevicePassword = await secureService.getEncryptPlain(
-      wallet.encryptDevicePassword || pinHash
-    );
-    const pvencstr = await secureService.getEncryptPlain(wallet.pvencstr);
-    const wid = await secureService.getEncryptPlain(wallet.wid);
-    const secureChannelId = await secureService.getSecureChannelId();
-    const params = new URLSearchParams({
-      uid: wallet.uid,
-      sid: wallet.sid || "",
-      hash,
-      pvencstr,
-      wid,
-      encryptDevicePassword,
-      network: "tron"
-    });
-    const url = `${this.baseURL}/wapi/v2/sign/hash`;
-    const response = await fetch(url, {
-      method: "POST",
+  async getUtxos(address, network) {
+    const url = `${this.baseURL}/wapi/v2/bitcoin/utxo/list`;
+    const params = new URLSearchParams({ network, address });
+    const response = await fetch(`${url}?${params}`, {
+      method: "GET",
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        "Secure-Channel": secureChannelId,
+        ...DEFAULT_HEADERS,
         ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
-      },
-      body: params.toString()
+      }
     });
-    const responseText = await response.text();
-    if (!responseText) {
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Empty response from sign hash API",
-        { status: response.status }
-      );
-    }
-    let data;
-    try {
-      data = JSON.parse(responseText);
-    } catch (parseError) {
-      console.error("[TronApi] \u274C JSON parse error:", parseError);
+    const data = await response.json();
+    if (!response.ok || data.status !== "success") {
       throw createAbcError(
         "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Invalid JSON response from sign hash API",
-        { responseText, parseError }
-      );
-    }
-    if (!response.ok || data.iserr === true || !data.signstr) {
-      const errorDetails = data.errmsg || data.errors?.[0] || data.message || data;
-      console.error("[TronApi] \u274C Sign failed:", errorDetails);
-      throw createAbcError(
-        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-        `Failed to sign hash: ${JSON.stringify(errorDetails)}`,
+        "Failed to get UTXOs",
         data
       );
     }
-    const signstr = JSON.parse(data.signstr);
-    const sigList = signstr.sig_list;
-    const signatures = [];
-    for (const sig of sigList) {
-      const r = sig.r.startsWith("0x") ? sig.r.substring(2) : sig.r;
-      const s = sig.s.startsWith("0x") ? sig.s.substring(2) : sig.s;
-      const v = (27 + (sig.vsource || 0)).toString(16);
-      signatures.push(r + s + v);
-    }
-    console.log(
-      "[TronApi] \u2705 Signature generated:",
-      `${signatures[0].length / 2} bytes,`,
-      `${signatures[0].substring(0, 16)}...${signatures[0].substring(signatures[0].length - 4)}`
-    );
-    return signatures;
+    return data.result?.utxos || [];
   }
   /**
-   * Broadcast signed TRON transaction
+   * Broadcast signed Bitcoin transaction
    *
-   * @param rawData - Raw transaction data from transfer/trc20Transfer
-   * @param signatures - Signatures from signHash
-   * @param network - TRON network
-   * @returns Transaction hash (txid)
-   */
-  async broadcast(rawData, signatures, network) {
-    const url = `${this.baseURL}/wapi/v2/tron/send/transaction`;
-    console.log("[TronApi] \u{1F4E1} Broadcasting TRON transaction...");
+   * @param params - Transaction broadcast parameters
+   * @returns Transaction hash
+   */
+  async sendBitcoinTransaction(params) {
+    const url = `${this.baseURL}/wapi/v2/bitcoin/tx/sendTransaction`;
     const response = await fetch(url, {
       method: "POST",
       headers: {
-        "Content-Type": "application/json",
+        ...DEFAULT_HEADERS,
         ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
       },
       body: JSON.stringify({
-        network,
-        raw_data: rawData,
-        signature: signatures
+        network: params.network,
+        rawTransaction: params.rawTransaction,
+        ...params.psbt && { psbt: params.psbt }
       })
     });
     const data = await response.json();
-    if (!response.ok || data.status && data.status !== "success") {
-      console.error("[TronApi] \u274C Broadcast failed:", data);
-      throw createAbcError(
-        "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Failed to broadcast TRON transaction",
-        data
-      );
-    }
-    const txHash = data.txid || data.txID || data.tx_hash;
-    if (!txHash) {
-      console.error("[TronApi] \u274C No txid in response:", data);
+    if (!response.ok || data.status !== "success") {
       throw createAbcError(
         "NETWORK_ERROR" /* NETWORK_ERROR */,
-        "Transaction hash not found in broadcast response",
+        "Failed to send Bitcoin transaction",
         data
       );
     }
-    console.log("[TronApi] \u2705 Transaction broadcasted:", txHash);
-    return txHash;
+    return { txHash: data.result?.data };
   }
+};
+
+// src/wallets/walletConnectors/abcWallet/api/TronApi.ts
+import { getTalkenApiClient as getTalkenApiClient8 } from "@talken/talkenkit";
+var TronApi = class extends BaseApiClient {
   /**
-   * Send TRON transaction (Complete flow: transfer/trc20Transfer -> signHash -> broadcast)
-   * High-level API that handles all 3 steps
+   * Get TRON address from TalkenApiClient unified addresses endpoint.
    *
-   * @param params - Transaction parameters
-   * @param wallet - EVM wallet credentials
-   * @param pinHash - Hashed PIN
-   * @param secureService - SecureService instance
-   * @returns Transaction hash
+   * @param _publicKey - Compressed public key (unused, TalkenApiClient resolves internally)
+   * @param _network - TRON network (unused, TalkenApiClient resolves internally)
+   * @returns TRON address (starts with 'T')
    */
-  async sendTransaction(params, wallet, pinHash, secureService) {
-    console.log("[TronApi] \u{1F4B8} Starting TRON transaction flow...");
-    let txID;
-    let rawData;
-    if (params.type === "TRC20" && params.contractAddress) {
-      const result = await this.trc20Transfer({
-        fromAddress: params.fromAddress,
-        toAddress: params.toAddress,
-        amount: params.amount,
-        contractAddress: params.contractAddress,
-        feeLimit: params.feeLimit,
-        network: params.network
-      });
-      txID = result.txID;
-      rawData = result.rawData;
-    } else {
-      const result = await this.transfer({
-        fromAddress: params.fromAddress,
-        toAddress: params.toAddress,
-        amount: Number(params.amount),
-        network: params.network
-      });
-      txID = result.txID;
-      rawData = result.rawData;
-    }
-    const signatures = await this.signHash(
-      txID,
-      wallet,
-      pinHash,
-      secureService
-    );
-    const txHash = await this.broadcast(rawData, signatures, params.network);
-    console.log("[TronApi] \u2705 Transaction complete:", txHash);
-    return txHash;
+  async getTronAddress(_publicKey, _network) {
+    const api = getTalkenApiClient8();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    const addresses = await api.wallet.getAddresses();
+    if (!addresses.tron) {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "TRON address not found in TalkenApiClient response"
+      );
+    }
+    return addresses.tron;
   }
 };
 
@@ -7085,7 +5345,6 @@ var AbcWaasApiClient = class {
     this.auth = new AuthApi(config);
     this.wallet = new WalletApi(config);
     this.transaction = new TransactionApi(config);
-    this.signing = new SigningApi(config);
     this.solana = new SolanaApi(config);
     this.bitcoin = new BitcoinApi(config);
     this.tron = new TronApi(config);
@@ -7503,19 +5762,74 @@ var AbcBitcoinProvider = class extends EventEmitter2 {
     }
   }
   /**
-   * Sign Bitcoin message (BIP-322)
-   * NOTE: Currently not supported - Bitcoin uses v2 API which doesn't have message signing endpoint
-   * Only transaction signing is supported via PSBT
+   * Sign Bitcoin message (Bitcoin Signed Message format)
+   * Uses secp256k1 sign/hash endpoint with double-SHA256 of prefixed message.
    *
-   * @param _message - Message to sign (string) - unused, always throws error
-   * @returns Signature in base64 format
+   * Format: SHA256(SHA256("\x18Bitcoin Signed Message:\n" + varint(len) + message))
+   *
+   * @param message - Message to sign (string)
+   * @returns Signature in hex format (compact: r + s + v)
    */
-  async signMessage(_message) {
-    console.log("[BitcoinProvider] \u26A0\uFE0F Bitcoin message signing requested");
-    throw new BitcoinProviderError(
-      BitcoinErrorCode.UNSUPPORTED_METHOD,
-      "Bitcoin message signing is not supported. Bitcoin uses v2 API which only supports transaction signing (PSBT). Use signTransaction() instead."
-    );
+  async signMessage(message) {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    console.log("[BitcoinProvider] \u{1F4DD} Signing Bitcoin message...");
+    const prefix = "Bitcoin Signed Message:\n";
+    const msgBytes = new TextEncoder().encode(message);
+    const varint = this.encodeVarint(msgBytes.length);
+    const prefixBytes = new TextEncoder().encode(prefix);
+    const preimage = new Uint8Array(prefixBytes.length + varint.length + msgBytes.length);
+    preimage.set(prefixBytes, 0);
+    preimage.set(varint, prefixBytes.length);
+    preimage.set(msgBytes, prefixBytes.length + varint.length);
+    const hash1 = await crypto.subtle.digest("SHA-256", preimage);
+    const hash2 = await crypto.subtle.digest("SHA-256", hash1);
+    const hashHex = Array.from(new Uint8Array(hash2)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const api = getTalkenApiClient12();
+    if (!api) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INTERNAL_ERROR,
+        "TalkenApiClient not initialized"
+      );
+    }
+    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || "";
+    const result = await api.bitcoin.signHash({
+      hash: hashHex,
+      pin: pinHash,
+      network: this.network.type
+    });
+    const signstr = result?.signstr || result?.data?.signstr || "";
+    if (!signstr) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INTERNAL_ERROR,
+        "Empty signature from sign/hash"
+      );
+    }
+    console.log("[BitcoinProvider] \u2705 Message signed successfully");
+    return signstr;
+  }
+  /** Encode integer as Bitcoin varint */
+  encodeVarint(n) {
+    if (n < 253)
+      return new Uint8Array([n]);
+    if (n <= 65535) {
+      const buf2 = new Uint8Array(3);
+      buf2[0] = 253;
+      buf2[1] = n & 255;
+      buf2[2] = n >> 8 & 255;
+      return buf2;
+    }
+    const buf = new Uint8Array(5);
+    buf[0] = 254;
+    buf[1] = n & 255;
+    buf[2] = n >> 8 & 255;
+    buf[3] = n >> 16 & 255;
+    buf[4] = n >> 24 & 255;
+    return buf;
   }
   /**
    * High-level transaction sending (like Solana pattern)
@@ -8159,6 +6473,14 @@ var AbcSolanaProvider = class extends EventEmitter3 {
           "PIN hash not found. Please login again."
         );
       }
+      console.log(`[AbcSolanaProvider] transfer START`, {
+        kind: params.mintAddress ? "spl" : "native",
+        toAddress: params.toAddress,
+        amount: params.amount,
+        mintAddress: params.mintAddress || null,
+        network: this.wallet.network,
+        hasPinHash: !!pinHash
+      });
       const api = this.talkenApi || getTalkenApiClient13();
       if (params.mintAddress) {
         const apiNetwork = this.wallet.network === "solana" ? "solana_mainnet" : this.wallet.network;
@@ -8177,18 +6499,31 @@ var AbcSolanaProvider = class extends EventEmitter3 {
           network: apiNetwork,
           pin: pinHash
         });
+        console.log(`[AbcSolanaProvider] SPL transfer result:`, result2);
         return { signature: result2.txHash };
       }
       const { LAMPORTS_PER_SOL } = await import("@solana/web3.js");
       const amountLamports = params.amount * LAMPORTS_PER_SOL;
+      console.log(`[AbcSolanaProvider] native transfer request:`, {
+        toAddress: params.toAddress,
+        amountLamports: String(amountLamports),
+        amountSOL: params.amount
+      });
       const result = await api.solana.transfer({
         kind: "native",
         toAddress: params.toAddress,
         amountLamports: String(amountLamports),
         pin: pinHash
       });
+      console.log(`[AbcSolanaProvider] native transfer result:`, result);
       return { signature: result.txHash };
     } catch (error) {
+      console.error(`[AbcSolanaProvider] transfer FAILED:`, {
+        message: error.message,
+        code: error.code,
+        status: error.status,
+        details: error.details || error.data
+      });
       if (error.code === 4001 || error.cancelled) {
         throw error;
       }
@@ -8674,13 +7009,6 @@ export {
   getSupportedNetworks,
   networks_exports,
   init_networks,
-  SolanaNetwork,
-  BitcoinNetwork,
-  TronNetwork,
-  getEvmNetwork,
-  getSolanaNetwork,
-  getBitcoinNetwork,
-  getTronNetwork,
   AbcStorageKey,
   AbcErrorCode,
   AbcError,
@@ -8738,19 +7066,24 @@ export {
   isValidEthereumAddress,
   isValidSolanaAddress,
   getExplorerUrl,
-  secure_default,
   AbcWaasClient,
   createAbcWaasClient,
   AbcEvmProvider,
   createAbcEvmProvider,
   createAbcProvider,
+  SolanaNetwork,
+  BitcoinNetwork,
+  TronNetwork,
+  getEvmNetwork,
+  getSolanaNetwork,
+  getBitcoinNetwork,
+  getTronNetwork,
   abcConnector,
   abcWallet,
   BaseApiClient,
   AuthApi,
   WalletApi,
   TransactionApi,
-  SigningApi,
   SolanaApi,
   WalletscanApi,
   GasApi,