@zubari/sdk 0.2.4 → 0.2.5

package/dist/TransactionService-8xSEGoWA.d.mts

@@ -0,0 +1,579 @@
+import { o as SwapQuote, c as TxResult, a as NetworkType } from './index-Cx389p_j.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
+ *
+ * Client for calling the backend WDK endpoints to derive addresses
+ * using Tether WDK (which runs server-side in Node.js).
+ */
+
+interface WdkApiConfig {
+    baseUrl: string;
+    timeout?: number;
+}
+interface DeriveAddressResponse {
+    success: boolean;
+    address?: string;
+    chain?: string;
+    path?: string;
+    network?: string;
+    error?: string;
+}
+interface DeriveAllAddressesResponse {
+    success: boolean;
+    addresses?: {
+        ethereum: string | null;
+        bitcoin: string | null;
+        ton: string | null;
+        tron: string | null;
+        solana: string | null;
+        spark: string | null;
+    };
+    network?: string;
+    error?: string;
+}
+interface ValidateSeedResponse {
+    success: boolean;
+    isValid?: boolean;
+    wordCount?: number;
+    error?: string;
+}
+interface GenerateSeedResponse {
+    success: boolean;
+    seed?: string;
+    wordCount?: number;
+    error?: string;
+}
+interface TransactionHistoryItem$1 {
+    hash: string;
+    from: string;
+    to: string;
+    value: string;
+    timestamp: number;
+    status: 'confirmed' | 'pending' | 'failed';
+    blockNumber?: number;
+}
+interface TransactionHistoryResponse {
+    success: boolean;
+    address?: string;
+    transactions?: TransactionHistoryItem$1[];
+    chain?: string;
+    network?: string;
+    error?: string;
+}
+interface SendTransactionResponse {
+    success: boolean;
+    txHash?: string;
+    from?: string;
+    to?: string;
+    amount?: string;
+    chain?: string;
+    network?: string;
+    error?: string;
+}
+interface TransactionStatusResponse {
+    success: boolean;
+    hash?: string;
+    status?: 'confirmed' | 'pending' | 'failed';
+    blockNumber?: number;
+    confirmations?: number;
+    timestamp?: number;
+    from?: string;
+    to?: string;
+    value?: string;
+    fee?: string;
+    chain?: string;
+    network?: string;
+    error?: string;
+}
+/**
+ * WDK API Client for server-side Tether WDK integration
+ */
+declare class WdkApiClient {
+    private config;
+    constructor(config: WdkApiConfig);
+    /**
+     * Generate a new BIP-39 seed phrase using Tether WDK
+     */
+    generateSeed(): Promise<GenerateSeedResponse>;
+    /**
+     * Validate a BIP-39 seed phrase
+     */
+    validateSeed(seed: string): Promise<ValidateSeedResponse>;
+    /**
+     * Derive address for a specific chain using Tether WDK
+     */
+    deriveAddress(seed: string, chain: NetworkType, network?: 'mainnet' | 'testnet'): Promise<DeriveAddressResponse>;
+    /**
+     * Derive addresses for all chains using Tether WDK
+     */
+    deriveAllAddresses(seed: string, network?: 'mainnet' | 'testnet'): Promise<DeriveAllAddressesResponse>;
+    /**
+     * Send a transaction on a specific chain using Tether WDK
+     */
+    sendTransaction(seed: string, chain: NetworkType, to: string, amount: string, network?: 'mainnet' | 'testnet'): Promise<SendTransactionResponse>;
+    /**
+     * Get transaction history for an address on a specific chain
+     * Fetches from blockchain explorers (Etherscan, mempool.space, etc.)
+     */
+    getTransactionHistory(seed: string, chain: NetworkType, network?: 'mainnet' | 'testnet', limit?: number): Promise<TransactionHistoryResponse>;
+    /**
+     * Get transaction status by hash
+     * Fetches from blockchain explorers to check confirmation status
+     */
+    getTransactionStatus(txHash: string, chain: NetworkType, network?: 'mainnet' | 'testnet'): Promise<TransactionStatusResponse>;
+}
+/**
+ * Get or create the WDK API client instance
+ */
+declare function getWdkApiClient(baseUrl?: string): WdkApiClient;
+
+/**
+ * Browser-Compatible Address Derivation
+ *
+ * This module provides multi-chain address derivation that works in browser environments.
+ * It uses the @scure libraries which are pure JS and don't require Node.js polyfills.
+ *
+ * Supported chains:
+ * - Ethereum: ethers.js (BIP-44)
+ * - Bitcoin: @scure/bip32 + @scure/base (BIP-84 native SegWit)
+ * - Solana: ed25519-hd-key + tweetnacl (SLIP-0010)
+ * - TON: ed25519 derivation with TON address format
+ * - TRON: secp256k1 + base58check
+ * - Spark: Bitcoin-based with custom derivation
+ */
+
+interface ChainAddress$1 {
+    chain: NetworkType;
+    address: string;
+    path: string;
+}
+interface BrowserMultiChainAddresses {
+    ethereum: string | null;
+    bitcoin: string | null;
+    ton: string | null;
+    tron: string | null;
+    solana: string | null;
+    spark: string | null;
+}
+/**
+ * Derive Ethereum address from seed phrase
+ */
+declare function deriveEthereumAddress(seed: string): string;
+/**
+ * Derive Bitcoin address from seed phrase (BIP-84 native SegWit)
+ * Uses @scure libraries for browser compatibility
+ */
+declare function deriveBitcoinAddress(seed: string, network?: 'mainnet' | 'testnet'): string;
+/**
+ * Derive Solana address from seed phrase using SLIP-0010 (ed25519)
+ */
+declare function deriveSolanaAddress(seed: string): Promise<string>;
+/**
+ * Derive TON address from seed phrase
+ * Uses proper BIP-44 derivation path m/44'/607'/0'/0'/0'
+ */
+declare function deriveTonAddress(seed: string): Promise<string>;
+/**
+ * Derive TRON address from seed phrase
+ * TRON uses secp256k1 like Ethereum but with base58check encoding
+ * Uses @scure/base for browser compatibility
+ */
+declare function deriveTronAddress(seed: string): string;
+/**
+ * Derive Spark address from seed phrase
+ * Spark uses its own derivation path and bech32 format
+ * Uses @scure libraries for browser compatibility
+ */
+declare function deriveSparkAddress(seed: string, network?: 'mainnet' | 'testnet'): string;
+/**
+ * Derive addresses for all supported chains
+ */
+declare function deriveAllAddresses(seed: string, network?: 'mainnet' | 'testnet'): Promise<BrowserMultiChainAddresses>;
+/**
+ * Validate a BIP-39 seed phrase using @scure/bip39
+ */
+declare function isValidSeed(seed: string): boolean;
+/**
+ * Generate a random BIP-39 seed phrase using @scure/bip39
+ */
+declare function generateSeedPhrase(): string;
+
+type BrowserAddressDerivation_BrowserMultiChainAddresses = BrowserMultiChainAddresses;
+declare const BrowserAddressDerivation_deriveAllAddresses: typeof deriveAllAddresses;
+declare const BrowserAddressDerivation_deriveBitcoinAddress: typeof deriveBitcoinAddress;
+declare const BrowserAddressDerivation_deriveEthereumAddress: typeof deriveEthereumAddress;
+declare const BrowserAddressDerivation_deriveSolanaAddress: typeof deriveSolanaAddress;
+declare const BrowserAddressDerivation_deriveSparkAddress: typeof deriveSparkAddress;
+declare const BrowserAddressDerivation_deriveTonAddress: typeof deriveTonAddress;
+declare const BrowserAddressDerivation_deriveTronAddress: typeof deriveTronAddress;
+declare const BrowserAddressDerivation_generateSeedPhrase: typeof generateSeedPhrase;
+declare const BrowserAddressDerivation_isValidSeed: typeof isValidSeed;
+declare namespace BrowserAddressDerivation {
+  export { type BrowserAddressDerivation_BrowserMultiChainAddresses as BrowserMultiChainAddresses, type ChainAddress$1 as ChainAddress, BrowserAddressDerivation_deriveAllAddresses as deriveAllAddresses, BrowserAddressDerivation_deriveBitcoinAddress as deriveBitcoinAddress, BrowserAddressDerivation_deriveEthereumAddress as deriveEthereumAddress, BrowserAddressDerivation_deriveSolanaAddress as deriveSolanaAddress, BrowserAddressDerivation_deriveSparkAddress as deriveSparkAddress, BrowserAddressDerivation_deriveTonAddress as deriveTonAddress, BrowserAddressDerivation_deriveTronAddress as deriveTronAddress, BrowserAddressDerivation_generateSeedPhrase as generateSeedPhrase, BrowserAddressDerivation_isValidSeed as isValidSeed };
+}
+
+/**
+ * Zubari WDK Service - Unified Multi-Chain Wallet Service
+ *
+ * This service provides a unified interface for multi-chain wallet operations
+ * that works in both browser and Node.js environments.
+ *
+ * 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/
+ */
+type SupportedChain = 'ethereum' | 'bitcoin' | 'ton' | 'tron' | 'solana' | 'spark';
+interface ChainAddress {
+    chain: SupportedChain;
+    address: string;
+    path: string;
+}
+interface MultiChainAddresses {
+    ethereum: string | null;
+    bitcoin: string | null;
+    ton: string | null;
+    tron: string | null;
+    solana: string | null;
+    spark: string | null;
+}
+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';
+    /** 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;
+}
+/**
+ * Check if we're running in a browser environment
+ */
+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 apiClient;
+    private nativeWdkService;
+    private initialized;
+    private useNativeWdk;
+    constructor(config?: Partial<ZubariWdkServiceConfig>);
+    /**
+     * Initialize the service and determine the best strategy
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get the current execution mode
+     */
+    getMode(): 'api' | 'native' | 'browser-fallback';
+    /**
+     * Check if running in browser
+     */
+    isBrowserEnvironment(): boolean;
+    /**
+     * Generate a new BIP-39 seed phrase (12 words)
+     */
+    generateSeed(): Promise<string>;
+    /**
+     * Validate a BIP-39 seed phrase
+     */
+    validateSeed(seed: string): Promise<boolean>;
+    /**
+     * Derive address for a specific chain using WDK API
+     *
+     * For Ethereum, falls back to local derivation if API fails.
+     * For other chains, WDK API is required - no placeholder fallback.
+     */
+    deriveAddress(seed: string, chain: SupportedChain): Promise<ChainAddress>;
+    /**
+     * Derive addresses for all supported chains using WDK API
+     *
+     * Uses the backend WDK API for real cryptographically valid addresses.
+     * No placeholder fallback - WDK API is required for multi-chain addresses.
+     */
+    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;
+    /**
+     * Estimate transaction fee
+     */
+    estimateFee(chain: NetworkType, params: TransactionParams): Promise<FeeEstimate>;
+    /**
+     * Send a transaction
+     */
+    send(chain: NetworkType, params: TransactionParams): Promise<TransactionResult>;
+    /**
+     * Get transaction status
+     */
+    getTransactionStatus(chain: NetworkType, txHash: string): Promise<TransactionResult>;
+    /**
+     * Get transaction history for an address
+     */
+    getTransactionHistory(chain: NetworkType, limit?: number): Promise<TransactionHistoryItem[]>;
+    /**
+     * Get balance for a specific chain
+     */
+    getBalance(chain: NetworkType): Promise<{
+        balance: string;
+        balanceUsd: number;
+    }>;
+    /**
+     * Get the current network configuration
+     */
+    getNetwork(): 'mainnet' | 'testnet';
+    /**
+     * Clean up and dispose of wallet instances
+     */
+    dispose(): void;
+}
+/**
+ * Get or create the Transaction service singleton
+ */
+declare function getTransactionService(config?: Partial<TransactionServiceConfig>): TransactionService;
+/**
+ * Create a new Transaction service instance (non-singleton)
+ */
+declare function createTransactionService(config?: Partial<TransactionServiceConfig>): TransactionService;
+
+export { BrowserAddressDerivation as B, type ChainAddress$1 as C, type DeriveAddressResponse as D, type FeeRates as F, type GenerateSeedResponse as G, type MultiChainAddresses as M, SwapService as S, type TransactionHistoryItem$1 as T, type ValidateSeedResponse as V, WdkApiClient as W, ZubariWdkService as Z, type BrowserMultiChainAddresses as a, type WdkApiConfig as b, type DeriveAllAddressesResponse as c, type TransactionHistoryResponse as d, type SendTransactionResponse as e, type TransactionStatusResponse as f, getWdkApiClient as g, getZubariWdkService as h, createZubariWdkService as i, isBrowser as j, type SupportedChain as k, type ChainAddress as l, type ChainBalance as m, type TransactionResult$1 as n, type ZubariWdkServiceConfig as o, TransactionService as p, getTransactionService as q, createTransactionService as r, type TransactionParams as s, type TransactionResult as t, type TransactionHistoryItem as u, type FeeEstimate as v, type TransactionServiceConfig as w };