@talken/talkenkit 2.3.14 → 2.4.4

package/dist/wallets/walletConnectors/abcWallet/networkConfig.js

@@ -5,7 +5,6 @@ import {
   DEFAULT_NETWORK_CONFIG,
   SolanaNetwork,
   getBitcoinNetwork,
-  getEnvironment,
   getEvmNetwork,
   getNetworkDisplayName,
   getNetworkForChain,
@@ -13,15 +12,17 @@ import {
   isBitcoinNetwork,
   isEvmNetwork,
   isMainnet,
-  isSolanaNetwork
-} from "../chunk-ZX6LABEF.js";
+  isSolanaNetwork,
+  setGlobalDefaultBitcoinNetwork,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork
+} from "../chunk-A7FIBI6X.js";
 export {
   BitcoinNetwork,
   ChainType,
   DEFAULT_NETWORK_CONFIG,
   SolanaNetwork,
   getBitcoinNetwork,
-  getEnvironment,
   getEvmNetwork,
   getNetworkDisplayName,
   getNetworkForChain,
@@ -29,5 +30,8 @@ export {
   isBitcoinNetwork,
   isEvmNetwork,
   isMainnet,
-  isSolanaNetwork
+  isSolanaNetwork,
+  setGlobalDefaultBitcoinNetwork,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork
 };

package/dist/wallets/walletConnectors/abcWallet/secure.js

@@ -1,7 +1,7 @@
 "use client";
 import {
   secure_default
-} from "../chunk-G2LI5MVX.js";
+} from "../chunk-NDYGTKP5.js";
 import "../chunk-VETRBBA2.js";
 export {
   secure_default as default

package/dist/wallets/walletConnectors/abcWallet/sessionUtils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Session management utilities for ABC WaaS providers
+ */
+/**
+ * Custom error for session expiry
+ */
+export declare class SessionExpiredError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Dispatch session expired event to trigger Connect Modal
+ */
+export declare function dispatchSessionExpired(): void;
+/**
+ * Check if response is 401 Unauthorized and throw SessionExpiredError
+ * @param response - Fetch API response
+ * @throws SessionExpiredError if status is 401
+ */
+export declare function handleUnauthorizedResponse(response: Response): void;
+/**
+ * Wrapper for fetch that automatically handles 401 errors
+ * @param url - Request URL
+ * @param options - Fetch options
+ * @returns Response
+ * @throws SessionExpiredError if response is 401
+ */
+export declare function fetchWithSessionCheck(url: string, options?: RequestInit): Promise<Response>;
+/**
+ * Interface for PIN request callback
+ */
+export type PinRequestCallback = () => Promise<string>;
+/**
+ * Refresh access token using refresh token
+ * @param pinCallback - Callback to request PIN from user
+ * @returns New access token
+ * @throws SessionExpiredError if refresh token is missing or refresh fails
+ */
+export declare function refreshAccessToken(pinCallback?: PinRequestCallback): Promise<string>;

package/dist/wallets/walletConnectors/abcWallet/sessionUtils.js

@@ -0,0 +1,15 @@
+"use client";
+import {
+  SessionExpiredError,
+  dispatchSessionExpired,
+  fetchWithSessionCheck,
+  handleUnauthorizedResponse,
+  refreshAccessToken
+} from "../chunk-AO24PU7X.js";
+export {
+  SessionExpiredError,
+  dispatchSessionExpired,
+  fetchWithSessionCheck,
+  handleUnauthorizedResponse,
+  refreshAccessToken
+};

package/dist/wallets/walletConnectors/abcWallet/types.d.ts

@@ -29,6 +29,12 @@ export interface AbcWalletConfig {
     plain: string;
     /** Environment mode */
     environment: 'development' | 'production';
+    /** Default Chain ID for EVM network (optional, overrides environment-based detection) */
+    defaultChainId?: number;
+    /** Default Solana network (optional) */
+    defaultSolanaNetwork?: SolanaNetwork;
+    /** Default Bitcoin network (optional) */
+    defaultBitcoinNetwork?: BitcoinNetwork;
     /** Project identifier */
     projectId?: string;
 }
@@ -224,6 +230,22 @@ export interface AbcSignSolanaTransactionParams {
     message: string;
     /** PIN code */
     pin: string;
+    /** Network - 'solana' for mainnet, 'solana_devnet' for devnet */
+    network: 'solana' | 'solana_devnet';
+}
+/**
+ * Solana transaction signing parameters (v3 API)
+ * Used by SolanaApi
+ */
+export interface AbcSignSolanaTransactionParamsV3 {
+    /** Key identifier */
+    keyId: string;
+    /** Encrypted share */
+    encryptedShare: string;
+    /** Secret store for encryption */
+    secretStore?: string;
+    /** Serialized transaction (base64) */
+    message: string;
 }
 /**
  * Solana message signing parameters
@@ -245,6 +267,22 @@ export interface AbcSignSolanaMessageParams {
     message: string;
     /** PIN code */
     pin: string;
+    /** Network - 'solana' for mainnet, 'solana_devnet' for devnet */
+    network: 'solana' | 'solana_devnet';
+}
+/**
+ * Solana message signing parameters (v3 API)
+ * Used by SolanaApi
+ */
+export interface AbcSignSolanaMessageParamsV3 {
+    /** Key identifier */
+    keyId: string;
+    /** Encrypted share */
+    encryptedShare: string;
+    /** Secret store for encryption */
+    secretStore?: string;
+    /** Message to sign (base64) */
+    message: string;
 }
 /**
  * Solana transaction broadcast parameters
@@ -506,7 +544,8 @@ export declare enum AbcErrorCode {
 export declare class AbcError extends Error {
     code: AbcErrorCode;
     details?: any;
-    constructor(code: AbcErrorCode, message: string, details?: any);
+    statusCode?: number;
+    constructor(code: AbcErrorCode, message: string, details?: any, statusCode?: number);
 }
 /**
  * Chain configuration

package/dist/wallets/walletConnectors/abcWallet/types.js

@@ -3,7 +3,7 @@ import {
   AbcError,
   AbcErrorCode,
   AbcStorageKey
-} from "../chunk-5UEBEMEE.js";
+} from "../chunk-RQIUWXDF.js";
 export {
   AbcError,
   AbcErrorCode,

package/dist/wallets/walletConnectors/abcWallet/utils.d.ts

@@ -66,7 +66,7 @@ export declare function formatAddress(address: string, startLength?: number, end
 /**
  * Create AbcError from API response
  */
-export declare function createAbcError(code: AbcErrorCode, message: string, details?: any): AbcError;
+export declare function createAbcError(code: AbcErrorCode, message: string, details?: any, statusCode?: number): AbcError;
 /**
  * Sleep for specified milliseconds
  */

package/dist/wallets/walletConnectors/abcWallet/utils.js

@@ -35,9 +35,9 @@ import {
   throttle,
   validateEmail,
   validatePin
-} from "../chunk-UV5HHESJ.js";
-import "../chunk-5UEBEMEE.js";
+} from "../chunk-TYUEB4VT.js";
 import "../chunk-VETRBBA2.js";
+import "../chunk-RQIUWXDF.js";
 export {
   calculateExpiryTimestamp,
   clearAuthState,

package/dist/wallets/walletConnectors/abcWallet/walletGeneration.js

@@ -3,8 +3,8 @@ import {
   generateMpcWallets,
   recoverMpcWallets,
   validateMpcWallets
-} from "../chunk-WTYSUOKN.js";
-import "../chunk-5UEBEMEE.js";
+} from "../chunk-UZXTNCDO.js";
+import "../chunk-RQIUWXDF.js";
 export {
   generateMpcWallets,
   recoverMpcWallets,

package/dist/wallets/walletConnectors/{chunk-VZCI2K6Y.js → chunk-2GNL2GNB.js}

@@ -34,27 +34,49 @@ var DEFAULT_NETWORK_CONFIG = {
     testnet: "bitcoin_testnet" /* Testnet */
   }
 };
-function getEnvironment() {
-  if (typeof process === "undefined") {
-    return "development";
-  }
-  const env = process.env.NEXT_PUBLIC_ENVIRONMENT;
-  return env === "production" ? "production" : "development";
+var globalDefaultChainId;
+var globalDefaultSolanaNetwork;
+var globalDefaultBitcoinNetwork;
+function setGlobalDefaultChainId(chainId) {
+  globalDefaultChainId = chainId;
+}
+function setGlobalDefaultSolanaNetwork(network) {
+  globalDefaultSolanaNetwork = network;
+}
+function setGlobalDefaultBitcoinNetwork(network) {
+  globalDefaultBitcoinNetwork = network;
 }
 function getEvmNetwork(customChainId) {
   if (customChainId !== void 0) {
     return customChainId;
   }
-  const environment = getEnvironment();
-  return environment === "production" ? DEFAULT_NETWORK_CONFIG.evm.mainnet : DEFAULT_NETWORK_CONFIG.evm.testnet;
+  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() {
-  const environment = getEnvironment();
-  return environment === "production" ? DEFAULT_NETWORK_CONFIG.solana.mainnet : DEFAULT_NETWORK_CONFIG.solana.devnet;
+  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() {
-  const environment = getEnvironment();
-  return environment === "production" ? DEFAULT_NETWORK_CONFIG.bitcoin.mainnet : DEFAULT_NETWORK_CONFIG.bitcoin.testnet;
+  if (globalDefaultBitcoinNetwork !== void 0) {
+    console.log("[networkConfig] \u{1F50D} Using global default Bitcoin network:", globalDefaultBitcoinNetwork);
+    return globalDefaultBitcoinNetwork;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  const network = isProduction ? DEFAULT_NETWORK_CONFIG.bitcoin.mainnet : DEFAULT_NETWORK_CONFIG.bitcoin.testnet;
+  console.log("[networkConfig] \u{1F50D} Bitcoin network determined:", {
+    NEXT_PUBLIC_ENVIRONMENT: process.env.NEXT_PUBLIC_ENVIRONMENT,
+    isProduction,
+    network
+  });
+  return network;
 }
 function getNetworkForChain(chainType) {
   switch (chainType) {
@@ -79,7 +101,13 @@ function isMainnet(chainType, network) {
 function getNetworkDisplayName(chainType, network) {
   switch (chainType) {
     case "solana" /* Solana */:
-      return network === "solana" /* Mainnet */ ? "Solana Mainnet" : "Solana Devnet";
+      if (network === "solana" /* Mainnet */)
+        return "Solana Mainnet";
+      if (network === "solana_devnet" /* Devnet */)
+        return "Solana Devnet";
+      if (network === "solana_testnet" /* Testnet */)
+        return "Solana Testnet";
+      return `Solana ${network}`;
     case "bitcoin" /* Bitcoin */:
       return network === "bitcoin" /* Mainnet */ ? "Bitcoin Mainnet" : "Bitcoin Testnet";
     case "evm" /* EVM */: {
@@ -111,7 +139,9 @@ export {
   SolanaNetwork,
   BitcoinNetwork,
   DEFAULT_NETWORK_CONFIG,
-  getEnvironment,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork,
+  setGlobalDefaultBitcoinNetwork,
   getEvmNetwork,
   getSolanaNetwork,
   getBitcoinNetwork,

package/dist/wallets/walletConnectors/{chunk-5DDAV4BZ.js → chunk-2NAY6X3G.js}

@@ -2,7 +2,7 @@
 import {
   loadAuthState,
   saveAuthState
-} from "./chunk-UV5HHESJ.js";
+} from "./chunk-5RSS3SRV.js";
 
 // src/wallets/walletConnectors/abcWallet/abcBitcoinConnector.ts
 var AbcBitcoinConnector = class {

package/dist/wallets/walletConnectors/{chunk-ZIYAL44B.js → chunk-2NVHWZUE.js}

@@ -2,7 +2,7 @@
 import {
   hexToNumber,
   numberToHex
-} from "./chunk-UV5HHESJ.js";
+} from "./chunk-5RSS3SRV.js";
 
 // src/wallets/walletConnectors/abcWallet/abcProvider.ts
 var EventEmitter = class {

package/dist/wallets/walletConnectors/chunk-36J4NGMW.js

@@ -0,0 +1,276 @@
+"use client";
+import {
+  createAbcWaasClient
+} from "./chunk-ZUIY2TRJ.js";
+import {
+  setGlobalDefaultBitcoinNetwork,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork
+} from "./chunk-A7FIBI6X.js";
+import {
+  createAbcEvmProvider
+} from "./chunk-CZVBS7QE.js";
+import {
+  clearAuthState,
+  clearEncryptedTokens,
+  clearStorage,
+  loadAuthState,
+  loadFromStorage,
+  saveAuthState
+} from "./chunk-TYUEB4VT.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-4QPXFUDC.js → chunk-3CTIR723.js}

@@ -1,7 +1,7 @@
 "use client";
 import {
   abcConnector
-} from "./chunk-QHHR2DQK.js";
+} from "./chunk-IQJWD4IN.js";
 import {
   ABC_WALLET_METADATA
 } from "./chunk-VETRBBA2.js";
@@ -20,6 +20,9 @@ var abcWallet = (specificOptions) => ({ projectId }) => {
     plain: specificOptions?.plain || "",
     // Deprecated - not used (secure.ts uses random generation)
     environment: specificOptions?.environment || "development",
+    defaultChainId: specificOptions?.defaultChainId,
+    defaultSolanaNetwork: specificOptions?.defaultSolanaNetwork,
+    defaultBitcoinNetwork: specificOptions?.defaultBitcoinNetwork,
     projectId
   };
   return {

package/dist/wallets/walletConnectors/{chunk-25LLSYLN.js → chunk-3WLUH24A.js}

@@ -1,22 +1,22 @@
 "use client";
-import {
-  SolanaApi
-} from "./chunk-A7KV643A.js";
-import {
-  TransactionApi
-} from "./chunk-FGBDWBWQ.js";
 import {
   AuthApi
-} from "./chunk-MZOFZ2NQ.js";
+} from "./chunk-ZQLQELFC.js";
 import {
   BitcoinApi
-} from "./chunk-BNSBK5PQ.js";
+} from "./chunk-M7KXDTM6.js";
 import {
   SigningApi
-} from "./chunk-KZG5KU7A.js";
+} from "./chunk-HTD7IRKM.js";
+import {
+  TransactionApi
+} from "./chunk-HFC4AK72.js";
 import {
   WalletApi
-} from "./chunk-DPL5VRGJ.js";
+} from "./chunk-MKAXMNZM.js";
+import {
+  SolanaApi
+} from "./chunk-RCI7QYCZ.js";
 
 // src/wallets/walletConnectors/abcWallet/api/index.ts
 var AbcWaasApiClient = class {

package/dist/wallets/walletConnectors/{chunk-MZOFZ2NQ.js → chunk-53LPTQ6J.js}

@@ -1,10 +1,10 @@
 "use client";
 import {
   BaseApiClient
-} from "./chunk-KJHOGJ3A.js";
+} from "./chunk-J6VUIOSE.js";
 import {
   createAbcError
-} from "./chunk-UV5HHESJ.js";
+} from "./chunk-5RSS3SRV.js";
 import {
   ABC_AUDIENCE,
   ABC_ENDPOINTS