@talken/talkenkit 2.4.16 → 2.4.18

package/dist/wallets/walletConnectors/abcWallet/api/TalkenApiClient.d.ts

@@ -0,0 +1,365 @@
+/**
+ * TalkenApiClient
+ *
+ * Unified client for communicating with the Talken API backend.
+ * Routes all requests through the talken-api backend, which handles:
+ *   - Secure Channel creation and management (server-side)
+ *   - ABC WaaS API proxying with server-side secrets
+ *   - Token management with enhanced security
+ *
+ * Auth endpoints use action-based routing: POST /wallet/auth { action: '...' }
+ * All other endpoints use standard REST-style routes.
+ *
+ * WaaS-direct operations (not proxied by talken-api):
+ *   - Solana signMessage, signTransaction, transferSpl — use abcApi.ts directly
+ */
+import type { ABCNFT, ABCToken, GasEstimateResponse, SuggestedGasFees, TalkenApiConfig, TalkenAuthResponse, TalkenBtcFeeResponse, TalkenBtcTxHashResponse, TalkenBtcUtxosResponse, TalkenBtcValidateAddressResponse, TalkenEmailCheckResponse, TalkenEvmSignPersonalRequest, TalkenEvmSignRequest, TalkenEvmSignTypedRequest, TalkenEvmSignatureResponse, TalkenGasEstimateRequest, TalkenOtpResponse, TalkenSnsLoginRequest, TalkenTxBtcRequest, TalkenTxEvmRequest, TalkenTxRawRequest, TalkenTxResponse, TalkenTxSvmRequest, TalkenTxTvmRequest, TalkenWalletscanNativesRequest, TalkenWalletscanNftsRequest, TalkenWalletscanTokenRequest } from '../types';
+declare class TalkenAuthModule {
+    private client;
+    constructor(client: TalkenApiClient);
+    /**
+     * Login with email and password
+     * POST /wallet/auth { action: 'login', method: 'password', email, password }
+     */
+    loginWithPassword(email: string, password: string): Promise<TalkenAuthResponse>;
+    /**
+     * Send OTP code to email
+     * POST /wallet/auth { action: 'otp.send', email }
+     */
+    sendOtp(email: string): Promise<TalkenOtpResponse>;
+    /**
+     * Verify OTP code
+     * POST /wallet/auth { action: 'otp.verify', email, otpCode }
+     */
+    verifyOtp(email: string, otpCode: string): Promise<TalkenOtpResponse>;
+    /**
+     * Check if email is already registered
+     * POST /wallet/auth { action: 'email.check', email }
+     * Returns code 606 if email exists
+     */
+    checkEmail(email: string): Promise<TalkenEmailCheckResponse>;
+    /**
+     * Register a new user (creates account + auto-login)
+     * POST /wallet/auth { action: 'register', email, otpCode, password, name? }
+     */
+    register(params: {
+        email: string;
+        otpCode: string;
+        password: string;
+        name?: string;
+    }): Promise<TalkenAuthResponse>;
+    /**
+     * Reset password for existing user
+     * POST /wallet/auth { action: 'password.reset', email, newPassword, emailCode }
+     */
+    resetPassword(email: string, newPassword: string, emailCode: string): Promise<TalkenOtpResponse>;
+    /**
+     * Login with social provider (Google, Apple, Kakao, etc.)
+     * POST /wallet/auth { action: 'login', method: 'sns', token, service, audience? }
+     */
+    loginWithSns(params: TalkenSnsLoginRequest): Promise<TalkenAuthResponse>;
+    /**
+     * Refresh access token
+     * POST /wallet/auth { action: 'token.refresh', refreshToken }
+     */
+    refresh(): Promise<TalkenAuthResponse>;
+    /**
+     * Logout (clear local session only — no server endpoint)
+     */
+    logout(): void;
+}
+declare class TalkenWalletModule {
+    private client;
+    constructor(client: TalkenApiClient);
+    /**
+     * Generate/recover MPC wallets (create = idempotent generate/recover)
+     * 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)
+     */
+    generate(pin: string, email?: string): Promise<any>;
+    /**
+     * Recover is the same as generate (create is idempotent)
+     */
+    recover(pin: string, email?: string): Promise<any>;
+    /**
+     * Get wallet info
+     * POST /wallet/mpc { action: 'info' }
+     */
+    getInfo(): Promise<any>;
+    /**
+     * Get addresses for all chains
+     * POST /wallet/address { chain: 'all' }
+     */
+    getAddresses(): Promise<any>;
+    /**
+     * Get addresses for a specific chain
+     * POST /wallet/address { chain, publicKey?, pin? }
+     */
+    getAddressForChain(chain: 'all' | 'btc' | 'sol' | 'trx', publicKey?: string, pin?: string): Promise<any>;
+}
+declare class TalkenEvmModule {
+    private client;
+    constructor(client: TalkenApiClient);
+    /**
+     * Sign EVM transaction (sign only, no broadcast)
+     * POST /wallet/sign/evm { network, to, from?, value?, data?, ... }
+     * Server handles SecureChannel internally
+     */
+    signTransaction(params: TalkenEvmSignRequest): Promise<TalkenEvmSignatureResponse>;
+    /**
+     * Sign EIP-712 typed data
+     * POST /wallet/sign/typed { network, typedData }
+     */
+    signTypedData(params: TalkenEvmSignTypedRequest): Promise<TalkenEvmSignatureResponse>;
+    /**
+     * Sign personal message (EIP-191)
+     * POST /wallet/sign/personal { network, message, address? }
+     */
+    signPersonal(params: TalkenEvmSignPersonalRequest): Promise<TalkenEvmSignatureResponse>;
+    /**
+     * Broadcast signed transaction
+     * POST /wallet/tx/raw { network, signedSerializeTx }
+     */
+    sendRawTransaction(params: TalkenTxRawRequest): Promise<TalkenTxResponse>;
+    /**
+     * Integrated EVM transfer (sign + broadcast)
+     * POST /wallet/tx/evm { chainKey, to, amountWei, pin, ... }
+     */
+    sendTransaction(params: TalkenTxEvmRequest): Promise<TalkenTxResponse>;
+    /**
+     * Get gas price
+     * GET /wallet/gas/price?network=
+     */
+    getGasPrice(network: string): Promise<any>;
+    /**
+     * Get suggested gas fees (EIP-1559)
+     * GET /wallet/gas/suggested?network=
+     */
+    getGasSuggested(network: string): Promise<SuggestedGasFees>;
+    /**
+     * Estimate gas
+     * POST /wallet/gas/estimate { network, from, to, value?, data? }
+     */
+    estimateGas(params: TalkenGasEstimateRequest): Promise<GasEstimateResponse>;
+    /**
+     * Get nonce for address
+     * GET /wallet/nonce?network=&address=
+     */
+    getNonce(network: string, address: string): Promise<any>;
+}
+declare class TalkenSolanaModule {
+    private client;
+    constructor(client: TalkenApiClient);
+    /**
+     * Transfer SOL or SPL token (integrated sign + broadcast)
+     * POST /wallet/tx/svm
+     * - kind='native': { toAddress, amountLamports, pin }
+     * - kind='spl':    { toAddress, mintAddress, amount, decimals, network, pin }
+     */
+    transfer(params: TalkenTxSvmRequest): Promise<TalkenTxResponse>;
+    /**
+     * 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
+     */
+    sign(params: {
+        message: string;
+        pin?: string;
+        keyId?: string;
+        encryptedShare?: string;
+        secretStore?: string;
+        network?: 'solana' | 'solana_devnet';
+    }): Promise<{
+        signature: string;
+        publicKey?: string;
+    }>;
+}
+declare class TalkenBitcoinModule {
+    private client;
+    constructor(client: TalkenApiClient);
+    /**
+     * BTC fee rate lookup
+     * GET /wallet/btc?mode=fee&network=&blocks=
+     */
+    getFeeRate(network: 'bitcoin' | 'bitcoin_testnet', blocks?: number): Promise<TalkenBtcFeeResponse>;
+    /**
+     * BTC tx status by hash
+     * GET /wallet/btc?mode=txHash&network=&txHash=
+     */
+    getTxByHash(txHash: string, network: 'bitcoin' | 'bitcoin_testnet'): Promise<TalkenBtcTxHashResponse>;
+    /**
+     * BTC UTXO list
+     * GET /wallet/btc?mode=utxos&network=&address=
+     */
+    getUtxos(network: 'bitcoin' | 'bitcoin_testnet', address?: string): Promise<TalkenBtcUtxosResponse>;
+    /**
+     * BTC address validation
+     * GET /wallet/btc?mode=validateAddress&network=&address=
+     */
+    validateAddress(address: string, network: 'bitcoin' | 'bitcoin_testnet'): Promise<TalkenBtcValidateAddressResponse>;
+    /**
+     * Send BTC (integrated sign + broadcast, action=transfer)
+     * POST /wallet/tx/btc
+     */
+    sendTransaction(params: TalkenTxBtcRequest): Promise<TalkenTxResponse>;
+    /**
+     * Execute BTC action endpoint (transfer|generate|signHash|finalize)
+     * POST /wallet/tx/btc
+     */
+    execute(params: TalkenTxBtcRequest): Promise<Record<string, unknown>>;
+    /**
+     * Sign raw hash via secp256k1 MPC (universal: EVM/BTC/TVM)
+     * POST /wallet/sign/hash { hash, pin, network? }
+     */
+    signHash(params: {
+        hash: string;
+        pin: string;
+        network?: string;
+    }): Promise<{
+        signstr: string;
+    }>;
+    /**
+     * Broadcast raw BTC transaction
+     * POST /wallet/tx/raw { network, signedSerializeTx }
+     */
+    broadcastRawTransaction(params: {
+        network: 'bitcoin' | 'bitcoin_testnet';
+        rawTransaction: string;
+    }): Promise<TalkenTxResponse>;
+}
+declare class TalkenTronModule {
+    private client;
+    constructor(client: TalkenApiClient);
+    /**
+     * Execute TVM(TRON) transfer/call (integrated sign + broadcast)
+     * POST /wallet/tx/tvm
+     * - kind=native: TRX transfer (amountSun)
+     * - kind=trc20: TRC-20 transfer (contractAddress + amount)
+     * - kind=contract: arbitrary contract call (contractAddress + data)
+     */
+    transferTrx(params: TalkenTxTvmRequest): Promise<TalkenTxResponse>;
+}
+declare class TalkenWalletscanModule {
+    private client;
+    constructor(client: TalkenApiClient);
+    /**
+     * Get token metadata by contract address
+     * GET /wallet/scan?type=tokens&chainKeys=...&contractAddress=...
+     */
+    getToken(params: TalkenWalletscanTokenRequest): Promise<ABCToken[]>;
+    /**
+     * Get native coin balances
+     * GET /wallet/scan?type=natives&chainKeys=...&walletAddress=...
+     */
+    getNativeTokens(params: TalkenWalletscanNativesRequest): Promise<ABCToken[]>;
+    /**
+     * Get NFT metadata
+     * GET /wallet/scan?type=nfts&chainKeys=...&walletAddress=...
+     */
+    getNfts(params: TalkenWalletscanNftsRequest): Promise<ABCNFT[]>;
+}
+/**
+ * TalkenApiClient - Unified client for talken-api backend
+ *
+ * Auth uses action-based routing (POST /wallet/auth).
+ * WaaS proxy endpoints for EVM sign, gas, nonce.
+ * Integrated TX endpoints for EVM, Solana, Bitcoin, TRON.
+ *
+ * @example
+ * ```typescript
+ * const client = createTalkenApiClient({
+ *   baseUrl: 'https://dev.walletapi.talken.io/api/v1',
+ * });
+ *
+ * // Auth
+ * await client.auth.loginWithPassword('user@example.com', 'password');
+ *
+ * // Wallet
+ * await client.wallet.generate('user@example.com', hashedPin);
+ *
+ * // EVM Sign (sign only)
+ * const sig = await client.evm.signTransaction({ network: 'ethereum', to: '0x...', value: '1000' });
+ *
+ * // EVM integrated transfer
+ * await client.evm.sendTransaction({ chainKey: 'ethereum', to: '0x...', amountWei: '1000', pin: 'hash' });
+ * ```
+ */
+export declare class TalkenApiClient {
+    private config;
+    private accessToken;
+    private refreshToken_;
+    private expiresAt;
+    private isRefreshing;
+    private refreshPromise;
+    readonly auth: TalkenAuthModule;
+    readonly wallet: TalkenWalletModule;
+    readonly evm: TalkenEvmModule;
+    readonly solana: TalkenSolanaModule;
+    readonly bitcoin: TalkenBitcoinModule;
+    readonly tron: TalkenTronModule;
+    readonly walletscan: TalkenWalletscanModule;
+    constructor(config?: Partial<TalkenApiConfig>);
+    private restoreSession;
+    /** @internal Called by auth module after successful login/register */
+    handleAuthResponse(response: TalkenAuthResponse): void;
+    /** @internal Clear all session data */
+    clearSession(): void;
+    /**
+     * Check if user is authenticated (has valid access token)
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Check if current access token is expired
+     */
+    isTokenExpired(): boolean;
+    /**
+     * Get current access token
+     */
+    getAccessToken(): string | null;
+    /**
+     * Get current refresh token
+     * @internal Used by auth module for token refresh
+     */
+    getRefreshToken(): string | null;
+    /**
+     * Get client configuration
+     */
+    getConfig(): TalkenApiConfig;
+    /**
+     * Set tokens externally (useful for SSR or state management integration)
+     */
+    setTokens(accessToken: string, refreshToken: string, expiresAt: number): void;
+    /** @internal Make a GET request */
+    get<T>(endpoint: string, options?: {
+        skipAuth?: boolean;
+    }): Promise<T>;
+    /** @internal Make a POST request */
+    post<T = any>(endpoint: string, body: unknown, options?: {
+        skipAuth?: boolean;
+    }): Promise<T>;
+    /**
+     * Core HTTP request handler with automatic token refresh
+     * @internal
+     */
+    private request;
+    /**
+     * Ensure token is refreshed (handles concurrent requests)
+     */
+    private ensureTokenRefreshed;
+    /**
+     * Force a token refresh
+     */
+    private forceTokenRefresh;
+}
+/**
+ * Create a TalkenApiClient instance
+ */
+export declare function createTalkenApiClient(config?: Partial<TalkenApiConfig>): TalkenApiClient;
+export {};

package/dist/wallets/walletConnectors/abcWallet/api/TalkenApiClient.js

@@ -0,0 +1,11 @@
+"use client";
+import {
+  TalkenApiClient,
+  createTalkenApiClient
+} from "../../chunk-BBD77PEX.js";
+import "../../chunk-D5EFTEOM.js";
+import "../../chunk-DHHVIM22.js";
+export {
+  TalkenApiClient,
+  createTalkenApiClient
+};

package/dist/wallets/walletConnectors/abcWallet/api/TalkenApiSingleton.d.ts

@@ -0,0 +1,18 @@
+/**
+ * TalkenApiClient Singleton
+ *
+ * Global singleton for TalkenApiClient access across the app.
+ * Must be set by abcConnector during initialization via setTalkenApiClient().
+ * Host app must provide talkenApiUrl option to abcWallet().
+ */
+import type { TalkenApiClient } from './TalkenApiClient';
+/**
+ * Set the global TalkenApiClient instance.
+ * Called once during abcConnector initialization.
+ */
+export declare function setTalkenApiClient(client: TalkenApiClient): void;
+/**
+ * Get the global TalkenApiClient instance.
+ * Returns undefined if not initialized — host app must provide talkenApiUrl to abcWallet().
+ */
+export declare function getTalkenApiClient(): TalkenApiClient | undefined;

package/dist/wallets/walletConnectors/abcWallet/api/TalkenApiSingleton.js

@@ -0,0 +1,14 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/api/TalkenApiSingleton.ts
+var _instance;
+function setTalkenApiClient(client) {
+  _instance = client;
+}
+function getTalkenApiClient() {
+  return _instance;
+}
+export {
+  getTalkenApiClient,
+  setTalkenApiClient
+};

package/dist/wallets/walletConnectors/abcWallet/api/TransactionApi.d.ts

@@ -9,20 +9,14 @@
  */
 import { BaseApiClient } from './BaseApiClient';
 export declare class TransactionApi extends BaseApiClient {
-    /**
-     * Send raw transaction
-     */
-    sendRawTransaction(chainId: number, signedTransaction: string): Promise<{
-        txHash: string;
-    }>;
     /**
      * Get transaction count (nonce)
      */
-    getTransactionCount(_address: string, _network: string, _block?: string): Promise<number>;
+    getTransactionCount(address: string, network: string, block?: string): Promise<number>;
     /**
      * Get suggested gas fees for EIP-1559
      */
-    getSuggestedGasFees(_network: string): Promise<{
+    getSuggestedGasFees(network: string): Promise<{
         low: {
             maxFeePerGas: string;
             maxPriorityFeePerGas: string;

package/dist/wallets/walletConnectors/abcWallet/api/TransactionApi.js

@@ -1,13 +1,11 @@
 "use client";
 import {
   TransactionApi
-} from "../../chunk-DJKN2MCI.js";
-import "../../chunk-MPFE6GP2.js";
-import "../../chunk-4PCVQBFZ.js";
-import "../../chunk-NDYGTKP5.js";
-import "../../chunk-5RSS3SRV.js";
-import "../../chunk-RQIUWXDF.js";
-import "../../chunk-VETRBBA2.js";
+} from "../../chunk-NBEDPUHX.js";
+import "../../chunk-7ZCM4DCC.js";
+import "../../chunk-6LH6ZME2.js";
+import "../../chunk-D5EFTEOM.js";
+import "../../chunk-DHHVIM22.js";
 export {
   TransactionApi
 };

package/dist/wallets/walletConnectors/abcWallet/api/TronApi.d.ts

@@ -0,0 +1,24 @@
+/**
+ * TRON API Client
+ *
+ * Handles TRON-specific operations:
+ * - TRON address derivation from EVM public key (secp256k1)
+ *
+ * Signing operations are handled by TalkenApiClient.tron module
+ * (server-side via talken-api /wallet/tx/tvm).
+ */
+import { BaseApiClient } from './BaseApiClient';
+/**
+ * TRON API Client
+ * Extends BaseApiClient for TRON-specific operations
+ */
+export declare class TronApi 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')
+     */
+    getTronAddress(_publicKey: string, _network: 'tron' | 'tron_nile'): Promise<string>;
+}

package/dist/wallets/walletConnectors/abcWallet/api/TronApi.js

@@ -0,0 +1,11 @@
+"use client";
+import {
+  TronApi
+} from "../../chunk-RS36ZX4P.js";
+import "../../chunk-7ZCM4DCC.js";
+import "../../chunk-6LH6ZME2.js";
+import "../../chunk-D5EFTEOM.js";
+import "../../chunk-DHHVIM22.js";
+export {
+  TronApi
+};

package/dist/wallets/walletConnectors/abcWallet/api/WalletApi.d.ts

@@ -12,16 +12,18 @@ import { BaseApiClient } from './BaseApiClient';
 export declare class WalletApi extends BaseApiClient {
     /**
      * Generate or recover EVM wallet
+     * Delegates to TalkenApiClient unified wallet API
      */
     generateOrRecoverWallet(params: AbcWalletParams): Promise<AbcWalletResponse>;
     /**
      * Get wallet info
+     * Uses TalkenApiClient unified wallet info endpoint
      */
-    getWalletInfo(uid: string): Promise<any>;
+    getWalletInfo(_uid: string): Promise<any>;
     /**
      * Generate or recover Solana wallet (Ed25519)
      */
-    generateSolanaWallet(pin: string, _isRecover?: boolean): Promise<AbcSolanaWallet>;
+    generateSolanaWallet(pin: string, isRecover?: boolean): Promise<AbcSolanaWallet>;
     /**
      * Get Solana address from Ed25519 public key
      */

package/dist/wallets/walletConnectors/abcWallet/api/WalletApi.js

@@ -1,13 +1,12 @@
 "use client";
 import {
   WalletApi
-} from "../../chunk-V33I7JGZ.js";
-import "../../chunk-MPFE6GP2.js";
-import "../../chunk-NDYGTKP5.js";
-import "../../chunk-A7FIBI6X.js";
-import "../../chunk-5RSS3SRV.js";
-import "../../chunk-RQIUWXDF.js";
-import "../../chunk-VETRBBA2.js";
+} from "../../chunk-QHCLOJYA.js";
+import "../../chunk-7ZCM4DCC.js";
+import "../../chunk-O4AU63LK.js";
+import "../../chunk-6LH6ZME2.js";
+import "../../chunk-D5EFTEOM.js";
+import "../../chunk-DHHVIM22.js";
 export {
   WalletApi
 };

package/dist/wallets/walletConnectors/abcWallet/api/WalletscanApi.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Walletscan API Client
+ *
+ * Handles token metadata fetching from ABC WaaS backend
+ * GET /wapi/v2/walletscan/token/{contractAddress}?networks=xxx
+ */
+import type { ABCNFT, ABCNFTsRequest, ABCNativeTokensRequest, ABCToken, ABCTokensRequest } from '../types';
+import { BaseApiClient } from './BaseApiClient';
+/**
+ * Walletscan API Client for fetching token metadata
+ *
+ * Routes through TalkenApiClient backend for all walletscan operations.
+ */
+export declare class WalletscanApi extends BaseApiClient {
+    /**
+     * Get token metadata via TalkenApiClient walletscan endpoint
+     *
+     * @param params - Contract address and networks
+     * @returns Token metadata or null if not found/failed
+     */
+    getContractToken(params: ABCTokensRequest): Promise<ABCToken | null>;
+    /**
+     * Get token metadata with timeout
+     *
+     * @param params - Contract address and networks
+     * @param timeoutMs - Timeout in milliseconds (default: 3000)
+     * @returns Token metadata or null if timeout/failed
+     */
+    getContractTokenWithTimeout(params: ABCTokensRequest, timeoutMs?: number): Promise<ABCToken | null>;
+    /**
+     * Get native coin info via TalkenApiClient walletscan endpoint
+     *
+     * @param params - Wallet address and networks
+     * @returns Array of native coins or empty array if failed
+     */
+    getNativeToken(params: ABCNativeTokensRequest): Promise<ABCToken[]>;
+    /**
+     * Get native coin info with timeout
+     *
+     * @param params - Wallet address and networks
+     * @param timeoutMs - Timeout in milliseconds (default: 3000)
+     * @returns First native coin or null if timeout/failed
+     */
+    getNativeTokenWithTimeout(params: ABCNativeTokensRequest, timeoutMs?: number): Promise<ABCToken | null>;
+    /**
+     * Get NFT metadata via TalkenApiClient walletscan endpoint
+     *
+     * @param params - Contract address, wallet address, and networks
+     * @returns Array of NFT metadata or empty array if failed
+     */
+    getNFT(params: ABCNFTsRequest): Promise<ABCNFT[]>;
+    /**
+     * Get NFT metadata with timeout
+     *
+     * @param params - Contract address, wallet address, and networks
+     * @param timeoutMs - Timeout in milliseconds (default: 3000)
+     * @returns First NFT or null if timeout/failed/empty
+     */
+    getNFTWithTimeout(params: ABCNFTsRequest, timeoutMs?: number): Promise<ABCNFT | null>;
+}

package/dist/wallets/walletConnectors/abcWallet/api/WalletscanApi.js

@@ -0,0 +1,11 @@
+"use client";
+import {
+  WalletscanApi
+} from "../../chunk-7MDXHYMB.js";
+import "../../chunk-7ZCM4DCC.js";
+import "../../chunk-6LH6ZME2.js";
+import "../../chunk-D5EFTEOM.js";
+import "../../chunk-DHHVIM22.js";
+export {
+  WalletscanApi
+};

package/dist/wallets/walletConnectors/abcWallet/api/index.d.ts

@@ -2,32 +2,53 @@
  * ABC WaaS API Client
  *
  * Modular API client structure for better maintainability
+ *
+ * Two client architectures are available:
+ *
+ * 1. **AbcWaasApiClient** (Legacy) - Direct ABC WaaS API calls from client-side
+ *    Uses BaseApiClient + individual API modules (AuthApi, WalletApi, etc.)
+ *    Handles secure channels, token refresh, and MPC signing client-side.
+ *
+ * 2. **TalkenApiClient** (New) - Backend-proxied API calls via talken-api
+ *    Routes all requests through the talken-api NestJS backend.
+ *    Server handles secure channels, ABC WaaS communication, and key management.
+ *    Frontend only manages JWT session tokens.
  */
 export { BaseApiClient } from './BaseApiClient';
 export { AuthApi } from './AuthApi';
 export { WalletApi } from './WalletApi';
 export { TransactionApi } from './TransactionApi';
-export { SigningApi } from './SigningApi';
 export { SolanaApi } from './SolanaApi';
 export { BitcoinApi } from './BitcoinApi';
+export { TronApi } from './TronApi';
+export { WalletscanApi } from './WalletscanApi';
+export { GasApi } from './GasApi';
+export { TalkenApiClient, createTalkenApiClient } from './TalkenApiClient';
 import type { AbcWalletConfig } from '../types';
 import { AuthApi } from './AuthApi';
 import { BitcoinApi } from './BitcoinApi';
-import { SigningApi } from './SigningApi';
+import { GasApi } from './GasApi';
 import { SolanaApi } from './SolanaApi';
 import { TransactionApi } from './TransactionApi';
+import { TronApi } from './TronApi';
 import { WalletApi } from './WalletApi';
+import { WalletscanApi } from './WalletscanApi';
 /**
  * Unified ABC WaaS API Client
  * Combines all API modules into a single client
+ *
+ * Modules that need TalkenApiClient access it via the singleton
+ * (getTalkenApiClient()) rather than constructor injection.
  */
 export declare class AbcWaasApiClient {
     auth: AuthApi;
     wallet: WalletApi;
     transaction: TransactionApi;
-    signing: SigningApi;
     solana: SolanaApi;
     bitcoin: BitcoinApi;
+    tron: TronApi;
+    walletscan: WalletscanApi;
+    gas: GasApi;
     constructor(config: AbcWalletConfig);
     /**
      * Check if user is authenticated