@talken/talkenkit 2.3.11 → 2.3.13

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

@@ -0,0 +1,157 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-KJHOGJ3A.js";
+import {
+  createAbcError
+} from "./chunk-UV5HHESJ.js";
+import {
+  getSolanaNetwork
+} from "./chunk-VZCI2K6Y.js";
+
+// src/wallets/walletConnectors/abcWallet/api/SolanaApi.ts
+var SolanaApi = class extends BaseApiClient {
+  /**
+   * Generate Solana wallet (Ed25519)
+   * Uses V3 API with Ed25519 curve
+   *
+   * @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 endpoint = `/v3/wallet/${isRecover ? "recover" : "generate"}`;
+    const response = await this.request(endpoint, {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        password: pin,
+        network: "solana"
+      }
+    });
+    if (response.status !== "success" || !response.result) {
+      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();
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || "",
+      secretStore: result.secret_store || "",
+      network
+    };
+  }
+  /**
+   * Recover Solana wallet (alias for generateSolanaWallet with isRecover=true)
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @returns Recovered Solana wallet information
+   */
+  async recoverSolanaWallet(pin) {
+    return this.generateSolanaWallet(pin, true);
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Sign Solana transaction with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
+   */
+  async signSolanaTransaction(params) {
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
+      }
+    });
+    if (response.status !== "success" || !response.result?.signature) {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana transaction",
+        response
+      );
+    }
+    return {
+      signature: response.result.signature
+    };
+  }
+  /**
+   * Sign Solana message with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
+   */
+  async signSolanaMessage(params) {
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
+      }
+    });
+    if (response.status !== "success" || !response.result?.signature) {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana message",
+        response
+      );
+    }
+    return {
+      signature: response.result.signature
+    };
+  }
+  /**
+   * Send Solana transaction
+   */
+  async sendSolanaTransaction(params) {
+    const response = await this.request("/wapi/v2/solana/tx/sendTransaction", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        network: params.network,
+        serializedTX: params.serializedTX,
+        signatures: params.signatures
+      }
+    });
+    if (response.status !== "success" || !response.result?.data) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to send Solana transaction",
+        response
+      );
+    }
+    return {
+      txHash: response.result.data
+    };
+  }
+};
+
+export {
+  SolanaApi
+};

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

@@ -0,0 +1,285 @@
+"use client";
+import {
+  createAbcEvmProvider
+} from "./chunk-XYPR4BAF.js";
+import {
+  createAbcWaasClient
+} from "./chunk-DA7TFV7F.js";
+import {
+  clearAuthState,
+  clearEncryptedTokens,
+  clearStorage,
+  loadAuthState,
+  loadFromStorage,
+  saveAuthState
+} from "./chunk-W2VDZD74.js";
+
+// src/wallets/walletConnectors/abcWallet/abcConnector.ts
+import { createConnector } from "wagmi";
+function abcConnector(options) {
+  const { config } = options;
+  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();
+          console.log("\u{1F527} ABC Connector connect() called:", {
+            hasAuthState: !!authState,
+            isAuthenticated: authState?.isAuthenticated,
+            hasWallet: !!authState?.wallet,
+            walletAddress: authState?.wallet?.address
+          });
+          if (!authState || !authState.isAuthenticated || !authState.wallet) {
+            throw new Error("ABC_LOGIN_REQUIRED");
+          }
+          provider.setWallet(authState.wallet);
+          console.log("\u2705 Provider wallet set:", {
+            address: authState.wallet.address,
+            hasPIN: !!authState.pin
+          });
+          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);
+          console.log("\u2705 ABC Connector connected successfully:", {
+            accounts: accounts.length,
+            chainId: Number(currentChainId)
+          });
+          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 {
+          console.log("[AbcConnector] \u{1F50D} isAuthorized() called");
+          const authState = loadAuthState();
+          console.log("[AbcConnector] Auth state check:", {
+            hasAuthState: !!authState,
+            isAuthenticated: authState?.isAuthenticated,
+            hasWallet: !!authState?.wallet,
+            hasAccessToken: !!authState?.accessToken,
+            hasRefreshToken: !!authState?.refreshToken
+          });
+          if (!authState || !authState.isAuthenticated) {
+            console.log("[AbcConnector] \u274C Not authenticated");
+            return false;
+          }
+          if (!authState.wallet) {
+            console.log("[AbcConnector] \u274C No wallet data - cannot reconnect");
+            return false;
+          }
+          if (client.isAuthenticated()) {
+            console.log("[AbcConnector] \u2705 Token valid - authorized");
+            return true;
+          }
+          console.log("[AbcConnector] \u26A0\uFE0F Token expired - attempting refresh...");
+          const refreshToken = loadFromStorage(
+            "refresh_token" /* REFRESH_TOKEN */
+          );
+          if (!refreshToken) {
+            console.log("[AbcConnector] \u274C No refresh token - clearing storage");
+            clearStorage();
+            return false;
+          }
+          try {
+            await client.refreshTokens(refreshToken);
+            console.log("[AbcConnector] \u2705 Token refreshed successfully");
+            const updatedState = loadAuthState();
+            const authorized = updatedState?.isAuthenticated ?? false;
+            console.log("[AbcConnector] Final authorization status:", authorized);
+            return authorized;
+          } catch (error) {
+            console.error("[AbcConnector] \u274C Token refresh failed:", error);
+            clearStorage();
+            return false;
+          }
+        } catch (error) {
+          console.error(
+            "[AbcConnector] \u274C 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-YC73LM6F.js

@@ -0,0 +1,63 @@
+"use client";
+import {
+  TransactionApi
+} from "./chunk-HDYBRMYW.js";
+import {
+  WalletApi
+} from "./chunk-WZAIQD3G.js";
+import {
+  AuthApi
+} from "./chunk-RLBGBBIO.js";
+import {
+  BitcoinApi
+} from "./chunk-IA4EQFSS.js";
+import {
+  SigningApi
+} from "./chunk-TUUNSVKZ.js";
+import {
+  SolanaApi
+} from "./chunk-KN4I4DKC.js";
+
+// src/wallets/walletConnectors/abcWallet/api/index.ts
+var AbcWaasApiClient = class {
+  constructor(config) {
+    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);
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return this.auth.isAuthenticated();
+  }
+  /**
+   * Check if access token is expired
+   */
+  isTokenExpired() {
+    return this.auth.isTokenExpired();
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.auth.getAccessToken();
+  }
+  /**
+   * Logout (clear tokens)
+   */
+  async logout() {
+    await this.auth.logout();
+  }
+};
+function createAbcWaasApiClient(config) {
+  return new AbcWaasApiClient(config);
+}
+
+export {
+  AbcWaasApiClient,
+  createAbcWaasApiClient
+};

package/dist/wallets/walletConnectors/{chunk-RLBGBBIO.js → chunk-YEHCPL4R.js}

@@ -1,10 +1,10 @@
 "use client";
 import {
   BaseApiClient
-} from "./chunk-WAO3KL5U.js";
+} from "./chunk-NX5MQHSQ.js";
 import {
   createAbcError
-} from "./chunk-W2VDZD74.js";
+} from "./chunk-UV5HHESJ.js";
 import {
   ABC_AUDIENCE,
   ABC_ENDPOINTS

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

@@ -0,0 +1,39 @@
+"use client";
+import {
+  createAbcSolanaConnector
+} from "./chunk-U2CUEL35.js";
+import {
+  createAbcSolanaProvider
+} from "./chunk-FROV5VDF.js";
+import {
+  createAbcWaasClient
+} from "./chunk-F5HCFRTK.js";
+
+// src/wallets/walletConnectors/abcWallet/abcSolanaWallet.ts
+var abcSolanaWallet = (options) => ({
+  id: "abc-solana",
+  name: "ABC Solana Wallet",
+  iconUrl: async () => (await import("./abcWallet-AYWSIGAG.js")).default,
+  iconBackground: "#fff",
+  // Embedded wallet - no download URLs needed
+  installed: void 0,
+  createConnector: () => {
+    console.log("[abcSolanaWallet] Creating Solana connector with options:", {
+      hasConfig: !!options.config,
+      waasUrl: options.config.waasUrl,
+      environment: options.config.environment
+    });
+    const client = createAbcWaasClient(options.config);
+    const provider = createAbcSolanaProvider(client);
+    const connector = createAbcSolanaConnector({
+      client,
+      provider
+    });
+    console.log("[abcSolanaWallet] Solana connector created successfully");
+    return connector;
+  }
+});
+
+export {
+  abcSolanaWallet
+};