@zubari/sdk 0.1.5 → 0.1.6

package/dist/services/index.d.mts

@@ -1,5 +1,36 @@
-export { F as FeeEstimate, S as SwapService, d as TransactionHistoryItem, a as TransactionParams, b as TransactionResult, T as TransactionService, e as TransactionServiceConfig, c as createTransactionService, g as getTransactionService } from '../TransactionService-CxwB1kpN.mjs';
-import { N as NetworkType } from '../index-DhluuR9H.mjs';
+import { k as SwapQuote, b as TxResult, N as NetworkType } from '../index-DhluuR9H.mjs';
+
+/**
+ * SwapService - DEX integration via Velora
+ *
+ * Handles token swaps with slippage protection,
+ * quote fetching, and earnings conversion.
+ */
+declare class SwapService {
+    private readonly _chainId;
+    private readonly isTestnet;
+    constructor(chainId: number, isTestnet?: boolean);
+    /**
+     * Get a swap quote
+     */
+    getQuote(tokenIn: string, tokenOut: string, amountIn: bigint): Promise<SwapQuote>;
+    /**
+     * Execute a swap with slippage protection
+     */
+    executeSwap(quote: SwapQuote, slippageToleranceBps?: number): Promise<TxResult>;
+    /**
+     * Convert earnings to USDT, keeping some ETH for gas
+     */
+    convertEarningsToStable(ethBalance: bigint, reserveForGas?: bigint): Promise<TxResult>;
+    /**
+     * Check if a swap route exists
+     */
+    hasRoute(tokenIn: string, tokenOut: string): Promise<boolean>;
+    /**
+     * Get supported tokens for swapping
+     */
+    getSupportedTokens(): Promise<string[]>;
+}
 
 /**
  * WDK API Client
@@ -159,13 +190,18 @@ declare namespace BrowserAddressDerivation {
 }
 
 /**
- * WDK Service for SDK
+ * Zubari WDK Service - Unified Multi-Chain Wallet Service
  *
- * Native integration with Tether WDK for multi-chain address derivation.
- * Uses individual wallet modules for each chain to derive cryptographically
- * valid addresses from a BIP-39 seed phrase.
+ * This service provides a unified interface for multi-chain wallet operations
+ * that works in both browser and Node.js environments.
  *
- * Supported chains: Ethereum, Bitcoin, TON, TRON, Solana, Spark (Lightning)
+ * Strategy:
+ * - Browser: Uses WdkApiClient to call the backend API (which has Tether WDK)
+ * - Node.js: Uses WdkService natively (with Tether WDK modules)
+ *
+ * The Tether WDK (@tetherto/wdk-*) only works in Node.js environments due to
+ * native dependencies (Electrum client, gRPC, etc.). For browser environments,
+ * we route all operations through the backend API.
  *
  * @see https://docs.wallet.tether.io/
  */
@@ -183,101 +219,299 @@ interface MultiChainAddresses {
     solana: string | null;
     spark: string | null;
 }
-interface WdkServiceConfig {
+interface ChainBalance {
+    chain: SupportedChain;
+    address: string;
+    balance: string;
+    symbol: string;
+}
+interface FeeRates {
+    slow: string;
+    normal: string;
+    fast: string;
+}
+interface TransactionResult$1 {
+    success: boolean;
+    txHash?: string;
+    from?: string;
+    to?: string;
+    amount?: string;
+    chain?: string;
+    network?: string;
+    error?: string;
+}
+interface ZubariWdkServiceConfig {
+    /** Network to use (mainnet or testnet) */
     network: 'mainnet' | 'testnet';
-    rpcUrls?: {
-        ethereum?: string;
-        bitcoin?: string;
-        solana?: string;
-        ton?: string;
-        tron?: string;
-    };
+    /** API URL for the Zubari backend (required for browser environments) */
+    apiUrl?: string;
+    /** Force using API even in Node.js (useful for testing) */
+    forceApi?: boolean;
+    /** Request timeout in milliseconds */
+    timeout?: number;
 }
 /**
- * WDK Service for native multi-chain address derivation
- * Uses Tether WDK wallet modules directly without needing a backend API
+ * Check if we're running in a browser environment
  */
-declare class WdkService {
-    private seed;
+declare function isBrowser(): boolean;
+/**
+ * ZubariWdkService - Unified wallet service for browser and Node.js
+ *
+ * This service automatically routes operations to:
+ * - API backend (browser) - using WdkApiClient
+ * - Native WDK (Node.js) - using WdkService
+ * - Browser derivation (fallback) - using BrowserAddressDerivation
+ */
+declare class ZubariWdkService {
     private config;
-    private wallets;
-    constructor(config?: Partial<WdkServiceConfig>);
+    private apiClient;
+    private nativeWdkService;
+    private initialized;
+    private useNativeWdk;
+    constructor(config?: Partial<ZubariWdkServiceConfig>);
     /**
-     * Check if WDK modules are loaded
+     * Initialize the service and determine the best strategy
      */
-    static isLoaded(): boolean;
+    initialize(): Promise<void>;
     /**
-     * Ensure WDK modules are loaded
+     * Get the current execution mode
      */
-    private ensureLoaded;
+    getMode(): 'api' | 'native' | 'browser-fallback';
     /**
-     * Load WDK modules (call this before using sync methods)
+     * Check if running in browser
      */
-    loadModules(): Promise<void>;
+    isBrowserEnvironment(): boolean;
     /**
-     * Generate a random BIP-39 seed phrase (12 words)
+     * Generate a new BIP-39 seed phrase (12 words)
      */
-    generateSeedPhrase(): Promise<string>;
+    generateSeed(): Promise<string>;
     /**
      * Validate a BIP-39 seed phrase
      */
-    isValidSeed(seed: string): Promise<boolean>;
+    validateSeed(seed: string): Promise<boolean>;
     /**
-     * Validate seed phrase (sync version - basic check)
+     * Derive address for a specific chain
      */
-    isValidSeedSync(seed: string): boolean;
+    deriveAddress(seed: string, chain: SupportedChain): Promise<ChainAddress>;
     /**
-     * Initialize the service with a seed phrase
+     * Derive addresses for all supported chains
      */
-    initialize(seed: string): Promise<void>;
+    deriveAllAddresses(seed: string): Promise<MultiChainAddresses>;
+    /**
+     * Get balances for all chains
+     */
+    getAllBalances(seed: string): Promise<Record<string, ChainBalance | null>>;
+    /**
+     * Get fee rates for a chain
+     */
+    getFeeRates(seed: string, chain: SupportedChain): Promise<FeeRates>;
+    /**
+     * Estimate transaction fee
+     */
+    estimateFee(seed: string, chain: SupportedChain, to: string, amount: string): Promise<{
+        fee: string;
+        symbol: string;
+    }>;
+    /**
+     * Send a transaction
+     */
+    sendTransaction(seed: string, chain: SupportedChain, to: string, amount: string): Promise<TransactionResult$1>;
+    /**
+     * Get the network configuration
+     */
+    getNetwork(): 'mainnet' | 'testnet';
+    /**
+     * Get API URL
+     */
+    getApiUrl(): string;
+    private getDerivationPath;
+    private getChainSymbol;
+    /**
+     * Derive address using browser-compatible libraries
+     */
+    private deriveBrowserAddress;
+    /**
+     * Derive all addresses using browser-compatible libraries
+     */
+    private deriveAllBrowserAddresses;
+}
+/**
+ * Get or create the default ZubariWdkService instance
+ */
+declare function getZubariWdkService(config?: Partial<ZubariWdkServiceConfig>): ZubariWdkService;
+/**
+ * Create a new ZubariWdkService instance
+ */
+declare function createZubariWdkService(config?: Partial<ZubariWdkServiceConfig>): ZubariWdkService;
+
+/**
+ * Transaction Service for Zubari SDK
+ *
+ * Provides multi-chain transaction capabilities using Tether WDK.
+ * Supports Ethereum, Bitcoin, Solana, TON, TRON, and Spark (Lightning).
+ *
+ * @see https://docs.wallet.tether.io/
+ */
+
+/**
+ * Transaction parameters for sending
+ */
+interface TransactionParams {
+    /** Recipient address */
+    to: string;
+    /** Amount to send (in human-readable format, e.g., "0.1") */
+    amount: string;
+    /** Token address (optional, for ERC-20/SPL tokens) */
+    token?: string;
+    /** Transaction memo/message (for chains that support it) */
+    memo?: string;
+    /** Fee priority: 'slow' | 'medium' | 'fast' */
+    feePriority?: 'slow' | 'medium' | 'fast';
+    /** Custom gas limit (EVM chains) */
+    gasLimit?: string;
+    /** Custom gas price (EVM chains) */
+    gasPrice?: string;
+}
+/**
+ * Transaction result with detailed information
+ */
+interface TransactionResult {
+    /** Transaction hash */
+    hash: string;
+    /** Network/chain */
+    network: NetworkType;
+    /** Transaction status */
+    status: 'pending' | 'confirmed' | 'failed';
+    /** Block number (when confirmed) */
+    blockNumber?: number;
+    /** Gas used (EVM chains) */
+    gasUsed?: string;
+    /** Fee paid */
+    fee?: string;
+    /** Explorer URL */
+    explorerUrl?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Transaction history item
+ */
+interface TransactionHistoryItem {
+    hash: string;
+    network: NetworkType;
+    type: 'send' | 'receive' | 'swap' | 'contract';
+    from: string;
+    to: string;
+    amount: string;
+    token?: string;
+    fee?: string;
+    status: 'pending' | 'confirmed' | 'failed';
+    timestamp: number;
+    blockNumber?: number;
+}
+/**
+ * Fee estimate for a transaction
+ */
+interface FeeEstimate {
+    slow: {
+        fee: string;
+        estimatedTime: string;
+    };
+    medium: {
+        fee: string;
+        estimatedTime: string;
+    };
+    fast: {
+        fee: string;
+        estimatedTime: string;
+    };
+}
+/**
+ * Transaction Service configuration
+ */
+interface TransactionServiceConfig {
+    network: 'mainnet' | 'testnet';
+    rpcUrls?: Partial<Record<NetworkType, string>>;
+}
+/**
+ * Transaction Service
+ *
+ * Provides multi-chain transaction capabilities:
+ * - Send native tokens (ETH, BTC, SOL, TON, TRX)
+ * - Send ERC-20/SPL tokens
+ * - Fee estimation
+ * - Transaction history
+ */
+declare class TransactionService {
+    private seed;
+    private config;
+    private wallets;
+    constructor(config?: Partial<TransactionServiceConfig>);
+    /**
+     * Ensure WDK modules are loaded
+     */
+    private ensureLoaded;
     /**
      * Get RPC URL for a chain
      */
     private getRpcUrl;
+    /**
+     * Get explorer URL for a transaction
+     */
+    getExplorerUrl(chain: NetworkType, txHash: string): string;
+    /**
+     * Initialize the service with a seed phrase
+     */
+    initialize(seed: string): Promise<void>;
+    /**
+     * Check if service is initialized
+     */
+    isInitialized(): boolean;
     /**
      * Get or create wallet instance for a specific chain
      */
     private getWallet;
     /**
-     * Derive address for a specific chain
+     * Estimate transaction fee
      */
-    deriveAddress(chain: SupportedChain): Promise<ChainAddress>;
+    estimateFee(chain: NetworkType, params: TransactionParams): Promise<FeeEstimate>;
     /**
-     * Derive addresses for all supported chains
+     * Send a transaction
+     */
+    send(chain: NetworkType, params: TransactionParams): Promise<TransactionResult>;
+    /**
+     * Get transaction status
      */
-    deriveAllAddresses(): Promise<MultiChainAddresses>;
+    getTransactionStatus(chain: NetworkType, txHash: string): Promise<TransactionResult>;
     /**
-     * Derive addresses for specific chains only
+     * Get transaction history for an address
      */
-    deriveAddressesForChains(chains: SupportedChain[]): Promise<Partial<MultiChainAddresses>>;
+    getTransactionHistory(chain: NetworkType, limit?: number): Promise<TransactionHistoryItem[]>;
     /**
-     * Get fee rates for a specific chain
+     * Get balance for a specific chain
      */
-    getFeeRates(chain: SupportedChain): Promise<{
-        slow: string;
-        medium: string;
-        fast: string;
+    getBalance(chain: NetworkType): Promise<{
+        balance: string;
+        balanceUsd: number;
     }>;
     /**
      * Get the current network configuration
      */
     getNetwork(): 'mainnet' | 'testnet';
-    /**
-     * Check if service is initialized
-     */
-    isInitialized(): boolean;
     /**
      * Clean up and dispose of wallet instances
      */
     dispose(): void;
 }
 /**
- * Get or create the WDK service singleton
+ * Get or create the Transaction service singleton
  */
-declare function getWdkService(config?: Partial<WdkServiceConfig>): WdkService;
+declare function getTransactionService(config?: Partial<TransactionServiceConfig>): TransactionService;
 /**
- * Create a new WDK service instance (non-singleton)
+ * Create a new Transaction service instance (non-singleton)
  */
-declare function createWdkService(config?: Partial<WdkServiceConfig>): WdkService;
+declare function createTransactionService(config?: Partial<TransactionServiceConfig>): TransactionService;
 
-export { BrowserAddressDerivation, type ChainAddress$1 as BrowserChainAddress, type BrowserMultiChainAddresses, type ChainAddress, type DeriveAddressResponse, type DeriveAllAddressesResponse, type GenerateSeedResponse, type MultiChainAddresses, type SupportedChain, type ValidateSeedResponse, WdkApiClient, type WdkApiConfig, WdkService, type WdkServiceConfig, createWdkService, getWdkApiClient, getWdkService };
+export { BrowserAddressDerivation, type ChainAddress$1 as BrowserChainAddress, type BrowserMultiChainAddresses, type ChainAddress, type ChainBalance, type DeriveAddressResponse, type DeriveAllAddressesResponse, type FeeEstimate, type FeeRates, type GenerateSeedResponse, type MultiChainAddresses, type SupportedChain, SwapService, type TransactionHistoryItem, type TransactionParams, type TransactionResult, TransactionService, type TransactionServiceConfig, type ValidateSeedResponse, WdkApiClient, type WdkApiConfig, type TransactionResult$1 as WdkTransactionResult, ZubariWdkService, type ZubariWdkServiceConfig, createTransactionService, createZubariWdkService, getTransactionService, getWdkApiClient, getZubariWdkService, isBrowser };