@talken/talkenkit 2.4.16 → 2.4.18

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

@@ -0,0 +1,204 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-7ZCM4DCC.js";
+import {
+  createAbcError
+} from "./chunk-6LH6ZME2.js";
+
+// src/wallets/walletConnectors/abcWallet/api/AuthApi.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var AuthApi = class extends BaseApiClient {
+  /**
+   * Login with email and password
+   */
+  async loginWithEmail(email, password) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.loginWithPassword(email, password);
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return {
+        uid: res.uid,
+        email: res.email,
+        accessToken: res.accessToken,
+        refreshToken: res.refreshToken,
+        expiresIn: res.expiresIn
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Login with email and OTP
+   * NOTE: OTP login removed from server — use password login instead.
+   * This method kept for backward compatibility, delegates to loginWithEmail.
+   */
+  async loginWithOtp(email, otpCode) {
+    return this.loginWithEmail(email, otpCode);
+  }
+  /**
+   * Login with social provider (Google, Apple, Kakao)
+   * Routes through TalkenApiClient → POST /wallet/auth { action: 'login', method: 'sns' }
+   */
+  async loginWithSocial(provider, token, _email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.loginWithSns({
+        token,
+        service: provider
+      });
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return {
+        uid: res.uid,
+        email: res.email,
+        accessToken: res.accessToken,
+        refreshToken: res.refreshToken,
+        expiresIn: res.expiresIn
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Request OTP code for email
+   */
+  async requestOtpCode(email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.sendOtp(email);
+      return { sent: true, expiresIn: 300 };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Verify OTP code
+   */
+  async verifyOtpCode(email, code) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.verifyOtp(email, code);
+      return true;
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Check if email already exists
+   */
+  async emailCheck(_email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.checkEmail(_email);
+      return {
+        status: "success",
+        message: { code: res.code || 0, text: res.message || "" }
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Send OTP code to email for signup
+   */
+  async sendOtpCode(_email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.sendOtp(_email);
+      return { status: "success", data: { sent: true } };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Verify OTP code for signup
+   */
+  async verifyOtpCodeSignup(email, code) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.verifyOtp(email, code);
+      return {
+        status: "success",
+        data: { verified: true }
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Register new user with password
+   */
+  async registerUser(params) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.register({
+        email: params.username,
+        password: params.password,
+        otpCode: params.emailCode,
+        name: params.name
+      });
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return { status: "success", data: res };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Register new SNS user (email-based registration with OTP, no password)
+   */
+  async registerSnsUser(params) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.register({
+        email: params.username,
+        password: "",
+        otpCode: params.sixCode,
+        name: params.name
+      });
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return { status: "success", data: res };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Reset/Set password for existing user
+   */
+  async resetPassword(params) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.resetPassword(
+        params.username,
+        params.password,
+        params.emailCode
+      );
+      return { status: "success", data: res };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+};
+
+export {
+  AuthApi
+};

package/dist/wallets/walletConnectors/{chunk-A7FIBI6X.js → chunk-O4AU63LK.js}

@@ -5,6 +5,7 @@ var ChainType = /* @__PURE__ */ ((ChainType2) => {
   ChainType2["EVM"] = "evm";
   ChainType2["Solana"] = "solana";
   ChainType2["Bitcoin"] = "bitcoin";
+  ChainType2["Tron"] = "tron";
   return ChainType2;
 })(ChainType || {});
 var SolanaNetwork = /* @__PURE__ */ ((SolanaNetwork2) => {
@@ -18,6 +19,11 @@ var BitcoinNetwork = /* @__PURE__ */ ((BitcoinNetwork2) => {
   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,
@@ -32,11 +38,16 @@ var DEFAULT_NETWORK_CONFIG = {
   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;
 }
@@ -46,6 +57,9 @@ function setGlobalDefaultSolanaNetwork(network) {
 function setGlobalDefaultBitcoinNetwork(network) {
   globalDefaultBitcoinNetwork = network;
 }
+function setGlobalDefaultTronNetwork(network) {
+  globalDefaultTronNetwork = network;
+}
 function getEvmNetwork(customChainId) {
   if (customChainId !== void 0) {
     return customChainId;
@@ -71,12 +85,21 @@ function getBitcoinNetwork() {
   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;
+}
 function getNetworkForChain(chainType) {
   switch (chainType) {
     case "solana" /* Solana */:
       return getSolanaNetwork();
     case "bitcoin" /* Bitcoin */:
       return getBitcoinNetwork();
+    case "tron" /* Tron */:
+      return getTronNetwork();
     case "evm" /* EVM */:
       return getEvmNetwork();
   }
@@ -87,6 +110,8 @@ function isMainnet(chainType, network) {
       return network === DEFAULT_NETWORK_CONFIG.solana.mainnet;
     case "bitcoin" /* Bitcoin */:
       return network === DEFAULT_NETWORK_CONFIG.bitcoin.mainnet;
+    case "tron" /* Tron */:
+      return network === DEFAULT_NETWORK_CONFIG.tron.mainnet;
     case "evm" /* EVM */:
       return network !== DEFAULT_NETWORK_CONFIG.evm.testnet;
   }
@@ -103,6 +128,8 @@ function getNetworkDisplayName(chainType, network) {
       return `Solana ${network}`;
     case "bitcoin" /* Bitcoin */:
       return network === "bitcoin" /* Mainnet */ ? "Bitcoin Mainnet" : "Bitcoin Testnet";
+    case "tron" /* Tron */:
+      return network === "tron" /* Mainnet */ ? "TRON Mainnet" : "TRON Nile Testnet";
     case "evm" /* EVM */: {
       const evmNetwork = network;
       if (evmNetwork === 1)
@@ -123,6 +150,9 @@ function isSolanaNetwork(value) {
 function isBitcoinNetwork(value) {
   return value === "bitcoin" /* Mainnet */ || value === "bitcoin_testnet" /* Testnet */;
 }
+function isTronNetwork(value) {
+  return value === "tron" /* Mainnet */ || value === "tron_nile" /* Nile */;
+}
 function isEvmNetwork(value) {
   return typeof value === "number" && value > 0;
 }
@@ -131,17 +161,21 @@ export {
   ChainType,
   SolanaNetwork,
   BitcoinNetwork,
+  TronNetwork,
   DEFAULT_NETWORK_CONFIG,
   setGlobalDefaultChainId,
   setGlobalDefaultSolanaNetwork,
   setGlobalDefaultBitcoinNetwork,
+  setGlobalDefaultTronNetwork,
   getEvmNetwork,
   getSolanaNetwork,
   getBitcoinNetwork,
+  getTronNetwork,
   getNetworkForChain,
   isMainnet,
   getNetworkDisplayName,
   isSolanaNetwork,
   isBitcoinNetwork,
+  isTronNetwork,
   isEvmNetwork
 };

package/dist/wallets/walletConnectors/{chunk-XJ4SP35I.js → chunk-OA57GKKV.js}

@@ -1,6 +1,7 @@
 "use client";
 
 // src/wallets/walletConnectors/abcWallet/abcBitcoinProvider.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
 var EventEmitter = class {
   constructor() {
     this.events = /* @__PURE__ */ new Map();
@@ -123,27 +124,11 @@ var AbcBitcoinProvider = class extends EventEmitter {
     console.log("[BitcoinProvider] \u{1F50C} Wallet disconnected");
   }
   /**
-   * Set PIN request callback for transaction signing
+   * Set TalkenApiClient for backend-proxied transaction flow
+   * When set, sendTransaction will use a single API call instead of multi-step WaaS
    */
-  setRequestPinCallback(callback) {
-    this.requestPinCallback = callback;
-  }
-  /**
-   * Request PIN from user
-   * First tries global callback, then falls back to manual callback
-   */
-  async requestPin() {
-    const globalRequestPin = window.__TALKENKIT_REQUEST_PIN__;
-    if (globalRequestPin && typeof globalRequestPin === "function") {
-      return globalRequestPin("transaction");
-    }
-    if (!this.requestPinCallback) {
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.INTERNAL_ERROR,
-        "PIN request callback not configured. Make sure RainbowKitProvider is rendered."
-      );
-    }
-    return this.requestPinCallback();
+  setTalkenApi(talkenApi) {
+    this.talkenApi = talkenApi;
   }
   /**
    * Set network
@@ -227,6 +212,19 @@ var AbcBitcoinProvider = class extends EventEmitter {
       return false;
     return Date.now() < expiry;
   }
+  normalizeUtxos(rawUtxos) {
+    return rawUtxos.map((u) => ({
+      txid: String(u?.txid ?? u?.tx_hash ?? ""),
+      vout: Number(u?.vout ?? u?.output_index ?? 0),
+      value: Number(u?.value ?? u?.satoshis ?? 0),
+      scriptPubKey: String(
+        u?.scriptPubKey ?? u?.script_pub_key ?? u?.script ?? ""
+      ),
+      confirmations: Number(u?.confirmations ?? 0)
+    })).filter(
+      (u) => Boolean(u.txid) && Number.isFinite(u.vout) && Number.isFinite(u.value) && Number.isFinite(u.confirmations)
+    );
+  }
   /**
    * Get UTXOs for address (with caching)
    */
@@ -249,10 +247,9 @@ var AbcBitcoinProvider = class extends EventEmitter {
     }
     try {
       console.log("[BitcoinProvider] \u{1F50D} Fetching UTXOs from network...");
-      const utxos = await this.client.bitcoin.getUtxos(
-        address,
-        this.network.type
-      );
+      const api = this.talkenApi || getTalkenApiClient();
+      const result = await api.bitcoin.getUtxos(this.network.type, address);
+      const utxos = this.normalizeUtxos(result.utxos || []);
       this.utxoCache.set(address, utxos);
       this.cacheExpiry.set(address, Date.now() + this.CACHE_TTL);
       console.log(`[BitcoinProvider] \u2705 Fetched ${utxos.length} UTXOs`);
@@ -287,10 +284,15 @@ var AbcBitcoinProvider = class extends EventEmitter {
    */
   async estimateFee(targetBlocks = 6) {
     try {
-      const feeRate = await this.client.bitcoin.estimateFee(
+      const api = this.talkenApi || getTalkenApiClient();
+      const result = await api.bitcoin.getFeeRate(
         this.network.type,
         targetBlocks
       );
+      const feeRate = Number(result.feeRate);
+      if (!Number.isFinite(feeRate) || feeRate <= 0) {
+        throw new Error("Invalid fee rate");
+      }
       console.log(`[BitcoinProvider] \u26FD Fee rate: ${feeRate} sat/byte`);
       return feeRate;
     } catch (_error) {
@@ -299,19 +301,74 @@ var AbcBitcoinProvider = class extends EventEmitter {
     }
   }
   /**
-   * 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 = getTalkenApiClient();
+    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)
@@ -331,63 +388,30 @@ var AbcBitcoinProvider = class extends EventEmitter {
     }
     try {
       console.log("[BitcoinProvider] \u{1F4B8} Starting high-level transaction...");
-      const authStateKey = "talkenkit_abc_auth_state";
-      const authState = typeof window !== "undefined" ? localStorage.getItem(authStateKey) : null;
-      if (!authState) {
-        throw new BitcoinProviderError(
-          BitcoinErrorCode.UNAUTHORIZED,
-          "Not authenticated - auth state not found"
-        );
-      }
-      const parsed = JSON.parse(authState);
-      const evmWallet = parsed.wallet;
-      if (!evmWallet?.uid || !evmWallet?.sid || !evmWallet?.pvencstr || !evmWallet?.wid) {
+      const pinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+      if (!pinHash) {
         throw new BitcoinProviderError(
-          BitcoinErrorCode.UNAUTHORIZED,
-          "EVM wallet data not found (required for Bitcoin signing)"
+          BitcoinErrorCode.INTERNAL_ERROR,
+          "PIN hash not found. Please login again."
         );
       }
-      console.log(
-        "[BitcoinProvider] \u{1F510} Requesting PIN for Bitcoin transaction..."
-      );
-      const pin = await this.requestPin();
-      const encoder = new TextEncoder();
-      const data = encoder.encode(pin);
-      const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-      const hashArray = Array.from(new Uint8Array(hashBuffer));
-      const pinHash = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
       const satoshis = Math.floor(params.amount * 1e8);
-      const SecureService = (await import("./abcWallet/secure.js")).default;
-      const secureService = new SecureService(this.client.bitcoin.getBaseURL());
-      const walletData = {
-        address: evmWallet.address,
-        keyId: evmWallet.keyId,
-        encryptedShare: evmWallet.encryptedShare,
-        uid: evmWallet.uid,
-        sid: evmWallet.sid,
-        wid: evmWallet.wid,
-        pvencstr: evmWallet.pvencstr,
-        encryptDevicePassword: evmWallet.encryptDevicePassword,
-        pubkey: evmWallet.pubkey
-      };
-      const txHash = await this.client.bitcoin.sendTransaction(
-        {
-          amount: satoshis.toString(),
-          to: params.toAddress,
-          pubkey: this.wallet.publicKey,
-          network: this.network.type
-        },
-        walletData,
-        pinHash,
-        secureService
+      const api = this.talkenApi || getTalkenApiClient();
+      const result = await api.bitcoin.sendTransaction({
+        toAddress: params.toAddress,
+        amountSats: satoshis.toString(),
+        pin: pinHash
+      });
+      console.log(
+        "[BitcoinProvider] \u2705 BTC transaction complete via TalkenApiClient:",
+        result.txHash
       );
-      console.log("[BitcoinProvider] \u2705 Transaction complete:", txHash);
       this.emit("transactionBroadcasted", {
-        txHash,
-        explorerUrl: `${this.network.explorer}/tx/${txHash}`
+        txHash: result.txHash,
+        explorerUrl: `${this.network.explorer}/tx/${result.txHash}`
       });
       this.clearUtxoCache();
-      return txHash;
+      return result.txHash;
     } catch (error) {
       if (error.message?.includes("cancelled") || error.message?.includes("rejected")) {
         console.log("[BitcoinProvider] \u2139\uFE0F User cancelled transaction");
@@ -429,10 +453,15 @@ var AbcBitcoinProvider = class extends EventEmitter {
     }
     try {
       console.log("[BitcoinProvider] \u{1F4E1} Broadcasting transaction...");
-      const result = await this.client.bitcoin.sendBitcoinTransaction({
+      if (psbt) {
+        console.log(
+          "[BitcoinProvider] \u2139\uFE0F PSBT argument provided; raw tx broadcast uses rawTransaction only via talken-api"
+        );
+      }
+      const api = this.talkenApi || getTalkenApiClient();
+      const result = await api.bitcoin.broadcastRawTransaction({
         network: this.network.type,
-        rawTransaction,
-        ...psbt && { psbt }
+        rawTransaction
       });
       console.log(
         "[BitcoinProvider] \u2705 Transaction broadcasted:",

package/dist/wallets/walletConnectors/{chunk-2NHQTZGS.js → chunk-OTES5NGR.js}

@@ -1,15 +1,15 @@
 "use client";
 import {
   createAbcEvmProvider
-} from "./chunk-Z2IWGNDA.js";
-import {
-  createAbcWaasClient
-} from "./chunk-HIRSPIIU.js";
+} from "./chunk-F5C6OZYF.js";
 import {
   setGlobalDefaultBitcoinNetwork,
   setGlobalDefaultChainId,
   setGlobalDefaultSolanaNetwork
-} from "./chunk-A7FIBI6X.js";
+} from "./chunk-O4AU63LK.js";
+import {
+  createAbcWaasClient
+} from "./chunk-PGOYWXV2.js";
 import {
   clearAuthState,
   clearEncryptedTokens,
@@ -17,9 +17,10 @@ import {
   loadAuthState,
   loadFromStorage,
   saveAuthState
-} from "./chunk-TYUEB4VT.js";
+} from "./chunk-6LH6ZME2.js";
 
 // src/wallets/walletConnectors/abcWallet/abcConnector.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
 import { createConnector } from "wagmi";
 function abcConnector(options) {
   const { config } = options;
@@ -147,7 +148,6 @@ function abcConnector(options) {
             localStorage.setItem("talkenkit_abc_saved_email", savedEmail);
           }
         }
-        console.log("\u2705 ABC Wallet disconnected (PIN preserved)");
       },
       /**
        * Get accounts
@@ -197,7 +197,17 @@ function abcConnector(options) {
             return false;
           }
           try {
-            await client.refreshTokens(refreshToken);
+            const api = getTalkenApiClient();
+            if (!api) {
+              clearStorage();
+              return false;
+            }
+            const res = await api.auth.refresh();
+            client.setTokens(
+              res.accessToken,
+              res.refreshToken,
+              Date.now() + res.expiresIn * 1e3
+            );
             const updatedState = loadAuthState();
             return updatedState?.isAuthenticated ?? false;
           } catch (error) {