@talken/talkenkit 2.3.15 → 2.4.5

package/dist/wallets/walletConnectors/{chunk-QI2VB7LL.js → chunk-RHQXGWIW.js}

@@ -1,15 +1,16 @@
 "use client";
 import {
   BaseApiClient
-} from "./chunk-H2MX4NAL.js";
+} from "./chunk-J6VUIOSE.js";
 import {
   getSolanaNetwork
 } from "./chunk-A7FIBI6X.js";
 import {
   createAbcError
-} from "./chunk-UV5HHESJ.js";
+} from "./chunk-5RSS3SRV.js";
 
 // src/wallets/walletConnectors/abcWallet/api/SolanaApi.ts
+import { PublicKey } from "@solana/web3.js";
 var SolanaApi = class extends BaseApiClient {
   /**
    * Generate Solana wallet (Ed25519)
@@ -21,25 +22,34 @@ var SolanaApi = class extends BaseApiClient {
    */
   async generateSolanaWallet(pin, isRecover = false) {
     const endpoint = `/v3/wallet/${isRecover ? "recover" : "generate"}`;
+    const network = getSolanaNetwork();
     const response = await this.request(endpoint, {
       method: "POST",
       contentType: "json",
       body: {
         curve: "ed25519",
         password: pin,
-        network: "solana"
+        network
       }
     });
-    if (response.status !== "success" || !response.result) {
+    let result;
+    if (response.status === "success" && response.result) {
+      result = response.result;
+    } else if (response.encrypted_share && response.key_id) {
+      result = response;
+    } else {
       throw createAbcError(
         "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
         `Failed to ${isRecover ? "recover" : "generate"} Solana wallet`,
         response
       );
     }
-    const result = response.result;
-    const address = this.deriveAddressFromPublicKey(result.public_key);
-    const network = getSolanaNetwork();
+    let address;
+    try {
+      address = this.deriveAddressFromPublicKey(result.public_key);
+    } catch (error) {
+      address = result.public_key.startsWith("0x") ? result.public_key.slice(2) : result.public_key;
+    }
     return {
       uid: result.uid || "",
       sessionId: result.share_id,
@@ -47,9 +57,13 @@ var SolanaApi = class extends BaseApiClient {
       publicKey: result.public_key,
       address,
       keyId: result.key_id || result.share_id,
+      // API returns snake_case key_id
       encryptedShare: result.encrypted_share || "",
+      // API returns snake_case encrypted_share
       secretStore: result.secret_store || "",
+      // API returns snake_case secret_store
       network
+      // Use network from request (already has correct value)
     };
   }
   /**
@@ -63,32 +77,46 @@ var SolanaApi = class extends BaseApiClient {
   }
   /**
    * Derive Solana address from Ed25519 public key
-   * Converts hex public key to base58-encoded Solana address
-   *
    * @param publicKey - Ed25519 public key (hex)
    * @returns Solana address (base58)
    */
   deriveAddressFromPublicKey(publicKey) {
     const cleanKey = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
-    return cleanKey;
+    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
       }
     });
-    if (response.status !== "success" || !response.result?.signature) {
+    let signature;
+    if (response.status === "success" && response.result?.signature) {
+      signature = response.result.signature;
+    } else if (response.signature) {
+      signature = response.signature;
+    } else {
       throw createAbcError(
         "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
         "Failed to sign Solana transaction",
@@ -96,7 +124,7 @@ var SolanaApi = class extends BaseApiClient {
       );
     }
     return {
-      signature: response.result.signature
+      signature
     };
   }
   /**
@@ -104,18 +132,25 @@ var SolanaApi = class extends BaseApiClient {
    * 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
       }
     });
-    if (response.status !== "success" || !response.result?.signature) {
+    let signature;
+    if (response.status === "success" && response.result?.signature) {
+      signature = response.result.signature;
+    } else if (response.signature) {
+      signature = response.signature;
+    } else {
       throw createAbcError(
         "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
         "Failed to sign Solana message",
@@ -123,7 +158,36 @@ var SolanaApi = class extends BaseApiClient {
       );
     }
     return {
-      signature: response.result.signature
+      signature
+    };
+  }
+  /**
+   * Generate Solana transfer transaction via ABC WaaS API
+   * This ensures the transaction uses the same RPC and blockhash as the server
+   */
+  async generateTransferTransaction(params) {
+    const response = await this.request("/wapi/v2/solana/tx/generateTransferSOLTransaction", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        network: params.network,
+        amount: params.amount,
+        fromAddress: params.fromAddress,
+        toAddress: params.toAddress,
+        feePayerAddress: params.feePayerAddress
+      }
+    });
+    const responseData = response;
+    const serializedTx = responseData.data?.serialized_tx || response.status === "success" && response.result?.data?.serialized_tx;
+    if (!serializedTx) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to generate Solana transaction",
+        response
+      );
+    }
+    return {
+      serialized_tx: serializedTx
     };
   }
   /**
@@ -139,7 +203,9 @@ var SolanaApi = class extends BaseApiClient {
         signatures: params.signatures
       }
     });
-    if (response.status !== "success" || !response.result?.data) {
+    const responseData = response;
+    const txHash = responseData.data || response.status === "success" && response.result?.data;
+    if (!txHash || typeof txHash !== "string") {
       throw createAbcError(
         "NETWORK_ERROR" /* NETWORK_ERROR */,
         "Failed to send Solana transaction",
@@ -147,7 +213,7 @@ var SolanaApi = class extends BaseApiClient {
       );
     }
     return {
-      txHash: response.result.data
+      txHash
     };
   }
 };

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

@@ -0,0 +1,276 @@
+"use client";
+import {
+  createAbcEvmProvider
+} from "./chunk-2NVHWZUE.js";
+import {
+  createAbcWaasClient
+} from "./chunk-FWCS4HBL.js";
+import {
+  setGlobalDefaultBitcoinNetwork,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork
+} from "./chunk-A7FIBI6X.js";
+import {
+  clearAuthState,
+  clearEncryptedTokens,
+  clearStorage,
+  loadAuthState,
+  loadFromStorage,
+  saveAuthState
+} from "./chunk-5RSS3SRV.js";
+
+// src/wallets/walletConnectors/abcWallet/abcConnector.ts
+import { createConnector } from "wagmi";
+function abcConnector(options) {
+  const { config } = options;
+  if (config.defaultChainId) {
+    setGlobalDefaultChainId(config.defaultChainId);
+  }
+  if (config.defaultSolanaNetwork) {
+    setGlobalDefaultSolanaNetwork(config.defaultSolanaNetwork);
+  }
+  if (config.defaultBitcoinNetwork) {
+    setGlobalDefaultBitcoinNetwork(config.defaultBitcoinNetwork);
+  }
+  return createConnector((wagmiConfig) => {
+    const client = createAbcWaasClient(config);
+    const provider = createAbcEvmProvider(client);
+    let accountsChangedHandler;
+    let chainChangedHandler;
+    let disconnectHandler;
+    return {
+      id: "abc",
+      name: "ABC Wallet",
+      type: "abc",
+      /**
+       * Connect wallet
+       */
+      async connect() {
+        try {
+          const authState = loadAuthState();
+          if (!authState || !authState.isAuthenticated || !authState.wallet) {
+            throw new Error("ABC_LOGIN_REQUIRED");
+          }
+          provider.setWallet(authState.wallet);
+          if (authState.accessToken && authState.refreshToken && authState.expiresAt) {
+            client.setTokens(
+              authState.accessToken,
+              authState.refreshToken,
+              authState.expiresAt
+            );
+          }
+          const accounts = await provider.request({
+            method: "eth_requestAccounts"
+          });
+          const currentChainId = await provider.request({
+            method: "eth_chainId"
+          });
+          if (accountsChangedHandler) {
+            provider.removeListener("accountsChanged", accountsChangedHandler);
+          }
+          accountsChangedHandler = (accounts2) => {
+            wagmiConfig.emitter.emit("change", {
+              accounts: accounts2
+            });
+          };
+          provider.on("accountsChanged", accountsChangedHandler);
+          if (chainChangedHandler) {
+            provider.removeListener("chainChanged", chainChangedHandler);
+          }
+          chainChangedHandler = (chainId) => {
+            wagmiConfig.emitter.emit("change", {
+              chainId: Number(chainId)
+            });
+          };
+          provider.on("chainChanged", chainChangedHandler);
+          if (disconnectHandler) {
+            provider.removeListener("disconnect", disconnectHandler);
+          }
+          disconnectHandler = () => {
+            wagmiConfig.emitter.emit("disconnect");
+            this.onDisconnect();
+          };
+          provider.on("disconnect", disconnectHandler);
+          wagmiConfig.emitter.emit("connect", {
+            accounts,
+            chainId: Number(currentChainId)
+          });
+          return {
+            accounts,
+            chainId: Number(currentChainId)
+          };
+        } catch (error) {
+          console.error("\u274C ABC Connector connect() failed:", {
+            message: error.message,
+            code: error.code,
+            error
+          });
+          if (error.message === "ABC_LOGIN_REQUIRED") {
+            throw error;
+          }
+          throw error;
+        }
+      },
+      /**
+       * Disconnect wallet
+       */
+      async disconnect() {
+        if (accountsChangedHandler) {
+          provider.removeListener("accountsChanged", accountsChangedHandler);
+          accountsChangedHandler = void 0;
+        }
+        if (chainChangedHandler) {
+          provider.removeListener("chainChanged", chainChangedHandler);
+          chainChangedHandler = void 0;
+        }
+        if (disconnectHandler) {
+          provider.removeListener("disconnect", disconnectHandler);
+          disconnectHandler = void 0;
+        }
+        provider.clearWallet();
+        await client.logout();
+        let savedPinHash = null;
+        let savedEmail = null;
+        if (typeof window !== "undefined") {
+          savedPinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+          savedEmail = localStorage.getItem("talkenkit_abc_saved_email");
+        }
+        clearAuthState();
+        clearEncryptedTokens();
+        if (typeof window !== "undefined") {
+          localStorage.removeItem("talkenkit_abc_enc_salt");
+          localStorage.removeItem("talkenkit_abc_enc_tokens");
+          if (savedPinHash) {
+            localStorage.setItem("talkenkit_abc_pin_hash", savedPinHash);
+          }
+          if (savedEmail) {
+            localStorage.setItem("talkenkit_abc_saved_email", savedEmail);
+          }
+        }
+        console.log("\u2705 ABC Wallet disconnected (PIN preserved)");
+      },
+      /**
+       * Get accounts
+       */
+      async getAccounts() {
+        const accounts = await provider.request({
+          method: "eth_accounts"
+        });
+        return accounts.map((account) => account);
+      },
+      /**
+       * Get chain ID
+       */
+      async getChainId() {
+        const chainId = await provider.request({
+          method: "eth_chainId"
+        });
+        return Number(chainId);
+      },
+      /**
+       * Get provider
+       */
+      async getProvider() {
+        return provider;
+      },
+      /**
+       * Check if authorized (has valid session)
+       * Auto-refreshes access token if expired but refresh token is valid
+       */
+      async isAuthorized() {
+        try {
+          const authState = loadAuthState();
+          if (!authState || !authState.isAuthenticated) {
+            return false;
+          }
+          if (!authState.wallet) {
+            return false;
+          }
+          if (client.isAuthenticated()) {
+            return true;
+          }
+          const refreshToken = loadFromStorage(
+            "refresh_token" /* REFRESH_TOKEN */
+          );
+          if (!refreshToken) {
+            clearStorage();
+            return false;
+          }
+          try {
+            await client.refreshTokens(refreshToken);
+            const updatedState = loadAuthState();
+            return updatedState?.isAuthenticated ?? false;
+          } catch (error) {
+            console.error("[AbcConnector] Token refresh failed:", error);
+            clearStorage();
+            return false;
+          }
+        } catch (error) {
+          console.error(
+            "[AbcConnector] Unexpected error in isAuthorized:",
+            error
+          );
+          return false;
+        }
+      },
+      /**
+       * Switch chain
+       */
+      async switchChain({ chainId }) {
+        await provider.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId: `0x${chainId.toString(16)}` }]
+        });
+        const newChainId = await this.getChainId();
+        const authState = loadAuthState();
+        if (authState?.wallet) {
+          authState.wallet.chainId = newChainId;
+          saveAuthState(authState);
+        }
+        return wagmiConfig.chains.find((x) => x.id === chainId) ?? {
+          id: chainId,
+          name: `Chain ${chainId}`,
+          nativeCurrency: {
+            name: "Ether",
+            decimals: 18,
+            symbol: "ETH"
+          },
+          rpcUrls: {
+            default: { http: [""] }
+          }
+        };
+      },
+      /**
+       * Handle accounts changed
+       */
+      onAccountsChanged(accounts) {
+        if (accounts.length === 0) {
+          this.onDisconnect();
+        } else {
+          wagmiConfig.emitter.emit("change", {
+            accounts
+          });
+        }
+      },
+      /**
+       * Handle chain changed
+       */
+      onChainChanged(chain) {
+        const chainId = Number(chain);
+        wagmiConfig.emitter.emit("change", { chainId });
+      },
+      /**
+       * Handle disconnect
+       */
+      onDisconnect(_error) {
+        provider.clearWallet();
+        clearAuthState();
+        wagmiConfig.emitter.emit("disconnect");
+      }
+    };
+  });
+}
+
+export {
+  abcConnector
+};

package/dist/wallets/walletConnectors/{chunk-5UEBEMEE.js → chunk-RQIUWXDF.js}

@@ -29,11 +29,12 @@ var AbcErrorCode = /* @__PURE__ */ ((AbcErrorCode2) => {
   return AbcErrorCode2;
 })(AbcErrorCode || {});
 var AbcError = class extends Error {
-  constructor(code, message, details) {
+  constructor(code, message, details, statusCode) {
     super(message);
     this.name = "AbcError";
     this.code = code;
     this.details = details;
+    this.statusCode = statusCode;
   }
 };
 

package/dist/wallets/walletConnectors/{chunk-RLR4Y5WO.js → chunk-SCD35IRD.js}

@@ -106,6 +106,10 @@ var AbcBitcoinProvider = class extends EventEmitter {
       address: wallet.address,
       network: this.network.type
     });
+    console.log(
+      "[BitcoinProvider] \u2705 Wallet connected:",
+      `${wallet.address.substring(0, 6)}...${wallet.address.substring(wallet.address.length - 4)}`
+    );
   }
   /**
    * Clear wallet (disconnect)

package/dist/wallets/walletConnectors/{chunk-EGOIRXTV.js → chunk-SOCVQ5N3.js}

@@ -1,13 +1,13 @@
 "use client";
 import {
   BaseApiClient
-} from "./chunk-NX5MQHSQ.js";
+} from "./chunk-J6VUIOSE.js";
 import {
   getSolanaNetwork
 } from "./chunk-A7FIBI6X.js";
 import {
   createAbcError
-} from "./chunk-UV5HHESJ.js";
+} from "./chunk-5RSS3SRV.js";
 import {
   ABC_ENDPOINTS,
   DEFAULT_HEADERS