@clawdvault/sdk 0.1.1 → 0.1.3

package/README.md

@@ -1,5 +1,8 @@
 # @clawdvault/sdk
 
+[![npm version](https://img.shields.io/npm/v/@clawdvault/sdk.svg)](https://www.npmjs.com/package/@clawdvault/sdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 TypeScript SDK for [ClawdVault](https://clawdvault.com) - a pump.fun-style token launchpad on Solana.
 
 ## Features
@@ -36,6 +39,12 @@ const quote = await client.getQuote({
   type: 'buy',
   amount: 0.1
 });
+
+// Get SOL/USD price
+const { price } = await client.getSolPrice();
+
+// Get top holders
+const { holders } = await client.getHolders('TOKEN_MINT_ADDRESS');
 ```
 
 ### Write Operations (Wallet Required)
@@ -43,9 +52,12 @@ const quote = await client.getQuote({
 ```typescript
 import { createClient, KeypairSigner } from '@clawdvault/sdk';
 
-// Load wallet from file or private key
+// Load wallet from file
 const signer = KeypairSigner.fromFile('/path/to/wallet.json');
-// or: const signer = new KeypairSigner(process.env.SOLANA_PRIVATE_KEY);
+// Or from environment variable
+const signer = KeypairSigner.fromEnv('SOLANA_PRIVATE_KEY');
+// Or from base58 string
+const signer = new KeypairSigner('base58_private_key');
 
 const client = createClient({ signer });
 
@@ -55,26 +67,161 @@ const result = await client.createToken({
   symbol: 'MYTOK',
   description: 'A cool token',
   image: 'https://example.com/image.png',
-  initialBuy: 0.1  // Optional initial buy in SOL
+  initialBuy: 0.1,  // Optional initial buy in SOL
+  twitter: 'https://twitter.com/mytoken',
+  website: 'https://mytoken.io'
 });
 
+console.log('Token created:', result.mint);
+
 // Buy tokens with 0.1 SOL
 const buyResult = await client.buy('TOKEN_MINT_ADDRESS', 0.1);
+console.log('Bought tokens, tx:', buyResult.signature);
 
 // Sell tokens
 const sellResult = await client.sell('TOKEN_MINT_ADDRESS', 1000000); // 1M tokens
 
 // Sell percentage of holdings
 const sellPercentResult = await client.sellPercent('TOKEN_MINT_ADDRESS', 50);
+
+// Check your balance
+const { balance } = await client.getMyBalance('TOKEN_MINT_ADDRESS');
+```
+
+### Smart Trading (Auto-Routes for Graduated Tokens)
+
+```typescript
+// smartBuy automatically uses Jupiter for graduated tokens
+const result = await client.smartBuy('TOKEN_MINT_ADDRESS', 0.5);
+
+// Check if token uses Jupiter
+const { graduated } = await client.getJupiterStatus('TOKEN_MINT_ADDRESS');
+if (graduated) {
+  console.log('Token graduated - using Jupiter DEX');
+}
+```
+
+## Real-Time Streaming
+
+Subscribe to live data feeds using Server-Sent Events (SSE):
+
+```typescript
+import { createStreaming } from '@clawdvault/sdk';
+
+const streaming = createStreaming('https://clawdvault.com/api');
+
+// Quick subscription helpers
+const { unsubscribe, connection } = streaming.onTrades('TOKEN_MINT', (trade) => {
+  console.log(`${trade.type.toUpperCase()}: ${trade.sol_amount} SOL`);
+});
+
+// Later: cleanup
+unsubscribe();
+connection.disconnect();
+```
+
+### Streaming Trades
+
+```typescript
+const conn = streaming.streamTrades('TOKEN_MINT');
+
+conn.onConnect(() => console.log('Connected!'));
+conn.onDisconnect(() => console.log('Disconnected'));
+conn.onError((err) => console.error(err));
+
+conn.on('trade', (trade) => {
+  console.log('New trade:', trade.type, trade.sol_amount, 'SOL');
+});
+
+conn.connect();
+
+// Cleanup
+conn.disconnect();
+```
+
+### Streaming Token Price Updates
+
+```typescript
+const conn = streaming.streamToken('TOKEN_MINT');
+
+conn.on('connected', (data) => {
+  console.log(`${data.name} (${data.symbol})`);
+  console.log(`Price: ${data.price_sol} SOL`);
+  console.log(`Market Cap: ${data.market_cap_sol} SOL`);
+});
+
+conn.on('update', (update) => {
+  console.log(`New price: ${update.price_sol} SOL`);
+});
+
+conn.on('trade', (trade) => {
+  console.log(`Price changed from ${trade.type}: ${trade.price_sol}`);
+});
+
+conn.connect();
+```
+
+### Streaming Chat Messages
+
+```typescript
+const conn = streaming.streamChat('TOKEN_MINT');
+
+conn.on('message', (msg) => {
+  const sender = msg.username || msg.wallet.slice(0, 8);
+  console.log(`${sender}: ${msg.message}`);
+});
+
+conn.on('reaction_added', (reaction) => {
+  console.log(`${reaction.emoji} added to message`);
+});
+
+conn.connect();
+```
+
+### Streaming Options
+
+```typescript
+const streaming = createStreaming('https://clawdvault.com/api', {
+  autoReconnect: true,       // Auto-reconnect on disconnect (default: true)
+  reconnectDelay: 3000,      // Initial delay before reconnect (default: 3000ms)
+  maxReconnectAttempts: 10,  // Max attempts before giving up (default: 10)
+});
+```
+
+### Disconnect All Streams
+
+```typescript
+// Disconnect everything
+streaming.disconnectAll();
+
+// Or disconnect specific stream
+streaming.disconnect('trades', 'TOKEN_MINT');
 ```
 
 ## Configuration
 
 ```typescript
 const client = createClient({
-  baseUrl: 'https://clawdvault.com/api',  // Optional: custom API endpoint
-  signer: mySigner,  // Optional: add later with setSigner()
+  // Optional: custom API endpoint
+  baseUrl: 'https://clawdvault.com/api',
+  
+  // Optional: wallet signer (can also use setSigner() later)
+  signer: mySigner,
+  
+  // Optional: session token for authenticated endpoints
+  sessionToken: 'your-session-token',
+  
+  // Optional: global error handler
+  onError: (error) => {
+    console.error('API Error:', error.message);
+  }
 });
+
+// Add signer later
+client.setSigner(newSigner);
+
+// Get connected wallet address
+const address = client.getWalletAddress(); // returns string | null
 ```
 
 ## Browser Usage with Phantom Wallet
@@ -82,6 +229,7 @@ const client = createClient({
 ```typescript
 import { createClient, PhantomSigner } from '@clawdvault/sdk';
 
+// Connect to Phantom (will prompt user)
 const phantomSigner = await PhantomSigner.fromWindow();
 const client = createClient({ signer: phantomSigner });
 
@@ -91,7 +239,234 @@ const result = await client.buy('TOKEN_MINT_ADDRESS', 0.1);
 
 ## API Reference
 
-See the [ClawdVault API Documentation](https://clawdvault.com/docs) for full endpoint details.
+### Token Operations
+
+```typescript
+// List tokens with filters
+const { tokens } = await client.listTokens({
+  sort: 'market_cap',  // 'created_at' | 'market_cap' | 'volume' | 'price'
+  limit: 20,
+  page: 1,
+  graduated: false  // filter by graduation status
+});
+
+// Get single token
+const { token, trades } = await client.getToken('MINT_ADDRESS');
+
+// Get Metaplex metadata
+const metadata = await client.getMetadata('MINT_ADDRESS');
+
+// Create new token
+const result = await client.createToken({
+  name: 'Token Name',
+  symbol: 'SYMBOL',
+  description: 'Description',
+  image: 'https://...',  // or upload first with uploadImage()
+  initialBuy: 0.1,       // optional
+  twitter: 'https://twitter.com/...',
+  telegram: 'https://t.me/...',
+  website: 'https://...'
+});
+```
+
+### Trading Operations
+
+```typescript
+// Get quote (no wallet required)
+const quote = await client.getQuote({
+  mint: 'MINT_ADDRESS',
+  type: 'buy',  // or 'sell'
+  amount: 0.1
+});
+console.log('Expected tokens:', quote.expectedAmount);
+console.log('Price impact:', quote.priceImpact);
+
+// Buy on bonding curve
+const buyResult = await client.buy('MINT', 0.1, 0.01);  // 1% slippage
+
+// Sell on bonding curve  
+const sellResult = await client.sell('MINT', 1000000, 0.01);
+
+// Sell percentage
+const result = await client.sellPercent('MINT', 50, 0.01);  // sell 50%
+
+// Smart trading (auto-routes to Jupiter for graduated tokens)
+const smartBuy = await client.smartBuy('MINT', 0.5, 0.01);
+const smartSell = await client.smartSell('MINT', 1000000, 0.01);
+
+// Jupiter-specific (for graduated tokens)
+const jupBuy = await client.buyJupiter('MINT', 0.5, 50);   // 50 bps = 0.5%
+const jupSell = await client.sellJupiter('MINT', 1000000, 50);
+```
+
+### Price & Market Data
+
+```typescript
+// Trade history
+const { trades } = await client.getTrades({
+  mint: 'MINT_ADDRESS',
+  limit: 50
+});
+
+// OHLCV candles
+const { candles } = await client.getCandles({
+  mint: 'MINT_ADDRESS',
+  interval: '1m',  // '1m' | '5m' | '15m' | '1h' | '4h' | '1d'
+  limit: 100
+});
+
+// On-chain stats
+const stats = await client.getStats('MINT_ADDRESS');
+
+// Top holders
+const { holders } = await client.getHolders('MINT_ADDRESS');
+
+// Token balance
+const { balance } = await client.getBalance('WALLET_ADDRESS', 'MINT_ADDRESS');
+const { balance: myBalance } = await client.getMyBalance('MINT_ADDRESS');
+
+// SOL/USD price
+const { price } = await client.getSolPrice();
+
+// Graduation status
+const status = await client.getGraduationStatus('MINT_ADDRESS');
+const jupStatus = await client.getJupiterStatus('MINT_ADDRESS');
+```
+
+### Chat & Social
+
+```typescript
+// Get chat messages
+const { messages } = await client.getChat({
+  mint: 'MINT_ADDRESS',
+  limit: 50
+});
+
+// Send message (requires auth)
+await client.sendChat({
+  mint: 'MINT_ADDRESS',
+  content: 'Hello world!'
+});
+
+// Reactions
+await client.addReaction('MESSAGE_ID', '🚀');
+await client.removeReaction('MESSAGE_ID', '🚀');
+```
+
+### User & Auth
+
+```typescript
+// Get profile
+const profile = await client.getProfile('WALLET_ADDRESS');
+
+// Update profile
+await client.updateProfile({
+  username: 'newname',
+  bio: 'New bio'
+});
+
+// Session management
+const { token } = await client.createSession();
+client.setSessionToken(token);
+const { valid } = await client.validateSession();
+```
+
+### File Upload
+
+```typescript
+// Upload from file path (Node.js)
+const { url } = await client.uploadImageFromPath('./logo.png');
+
+// Upload from Buffer/File
+const { url } = await client.uploadImage(buffer, 'logo.png');
+
+// Use in token creation
+await client.createToken({
+  name: 'My Token',
+  symbol: 'MTK',
+  image: url  // use uploaded URL
+});
+```
+
+## Error Handling
+
+```typescript
+import { createClient, KeypairSigner } from '@clawdvault/sdk';
+
+const client = createClient({
+  signer: KeypairSigner.fromEnv(),
+  onError: (error) => {
+    // Global error handler
+    console.error('API Error:', error.message);
+  }
+});
+
+// Try/catch for specific handling
+try {
+  const result = await client.buy('MINT_ADDRESS', 0.1);
+} catch (error) {
+  // error.status - HTTP status code (404, 400, 500, etc.)
+  // error.response - parsed response body
+  // error.message - error message
+  
+  if (error.status === 404) {
+    console.log('Token not found');
+  } else if (error.status === 400) {
+    console.log('Bad request:', error.response?.error);
+  } else if (error.message.includes('Signer required')) {
+    console.log('Wallet not connected');
+  } else if (error.message.includes('No tokens to sell')) {
+    console.log('Zero balance');
+  } else {
+    console.log('Unexpected error:', error.message);
+  }
+}
+```
+
+## TypeScript Types
+
+All types are exported for use in your application:
+
+```typescript
+import type {
+  Token,
+  Trade,
+  QuoteResponse,
+  TokenListParams,
+  ExecuteTradeResponse,
+  // ... many more
+} from '@clawdvault/sdk';
+```
+
+## Constants
+
+```typescript
+import { PROGRAM_ID, DEFAULT_BASE_URL } from '@clawdvault/sdk';
+
+console.log(PROGRAM_ID);       // 'GUyF2TVe32Cid4iGVt2F6wPYDhLSVmTUZBj2974outYM'
+console.log(DEFAULT_BASE_URL); // 'https://clawdvault.com/api'
+```
+
+## Troubleshooting
+
+### "Signer required" error
+Write operations (buy, sell, createToken) need a wallet signer:
+```typescript
+const signer = KeypairSigner.fromFile('~/.config/solana/id.json');
+const client = createClient({ signer });
+```
+
+### "Phantom wallet not found"
+- Install the Phantom browser extension
+- Page must be served over HTTPS (or localhost)
+
+### Transaction failures
+- Increase slippage: `client.buy(mint, sol, 0.05)` (5%)
+- Check SOL balance for fees
+- Token price may have moved
+
+### "No tokens to sell"
+Call `getMyBalance()` to verify you have tokens before selling.
 
 ## License
 

package/dist/index.d.mts

@@ -600,6 +600,161 @@ declare class ClawdVaultClient {
  */
 declare function createClient(config?: ClawdVaultConfig): ClawdVaultClient;
 
+/**
+ * ClawdVault Streaming Client
+ * Real-time data feeds via Server-Sent Events
+ */
+interface StreamTrade {
+    id: string;
+    type: 'buy' | 'sell';
+    sol_amount: number;
+    token_amount: number;
+    price_sol: number;
+    trader: string;
+    signature?: string;
+    created_at: string;
+}
+interface StreamTokenUpdate {
+    price_sol: number;
+    market_cap_sol: number;
+    virtual_sol_reserves: number;
+    virtual_token_reserves: number;
+    real_sol_reserves: number;
+    graduated: boolean;
+    timestamp: number;
+}
+interface StreamTokenConnected extends StreamTokenUpdate {
+    mint: string;
+    name: string;
+    symbol: string;
+}
+interface StreamChatMessage {
+    id: string;
+    wallet: string;
+    username?: string;
+    message: string;
+    reply_to?: string;
+    created_at: string;
+}
+interface StreamReaction {
+    message_id: string;
+    emoji: string;
+    wallet: string;
+}
+interface StreamingOptions {
+    /** Auto-reconnect on connection loss (default: true) */
+    autoReconnect?: boolean;
+    /** Reconnect delay in ms (default: 3000) */
+    reconnectDelay?: number;
+    /** Max reconnect attempts (default: 10) */
+    maxReconnectAttempts?: number;
+}
+type EventCallback<T> = (data: T) => void;
+type ErrorCallback = (error: Error) => void;
+type ConnectionCallback = () => void;
+declare class StreamConnection {
+    private eventSource;
+    private url;
+    private options;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private listeners;
+    private onConnectCallbacks;
+    private onDisconnectCallbacks;
+    private onErrorCallbacks;
+    private isConnected;
+    private isManuallyDisconnected;
+    constructor(url: string, options?: StreamingOptions);
+    /**
+     * Connect to the stream
+     */
+    connect(): void;
+    private handleEvent;
+    private scheduleReconnect;
+    /**
+     * Disconnect from the stream
+     */
+    disconnect(): void;
+    /**
+     * Subscribe to an event type
+     */
+    on<T>(eventType: string, callback: EventCallback<T>): () => void;
+    /**
+     * One-time event listener
+     */
+    once<T>(eventType: string, callback: EventCallback<T>): void;
+    /**
+     * Register connection callback
+     */
+    onConnect(callback: ConnectionCallback): () => void;
+    /**
+     * Register disconnection callback
+     */
+    onDisconnect(callback: ConnectionCallback): () => void;
+    /**
+     * Register error callback
+     */
+    onError(callback: ErrorCallback): () => void;
+    /**
+     * Check if connected
+     */
+    get connected(): boolean;
+}
+/**
+ * Streaming client for ClawdVault
+ */
+declare class ClawdVaultStreaming {
+    private baseUrl;
+    private connections;
+    private options;
+    constructor(baseUrl?: string, options?: StreamingOptions);
+    /**
+     * Stream trades for a token
+     */
+    streamTrades(mint: string): StreamConnection;
+    /**
+     * Stream token updates (price, market cap)
+     */
+    streamToken(mint: string): StreamConnection;
+    /**
+     * Stream chat messages
+     */
+    streamChat(mint: string): StreamConnection;
+    /**
+     * Convenience: Subscribe to trades with callback
+     */
+    onTrades(mint: string, callback: EventCallback<StreamTrade>): {
+        unsubscribe: () => void;
+        connection: StreamConnection;
+    };
+    /**
+     * Convenience: Subscribe to token price updates
+     */
+    onPrice(mint: string, callback: EventCallback<StreamTokenUpdate>): {
+        unsubscribe: () => void;
+        connection: StreamConnection;
+    };
+    /**
+     * Convenience: Subscribe to chat messages
+     */
+    onChat(mint: string, callback: EventCallback<StreamChatMessage>): {
+        unsubscribe: () => void;
+        connection: StreamConnection;
+    };
+    /**
+     * Disconnect all streams
+     */
+    disconnectAll(): void;
+    /**
+     * Disconnect a specific stream
+     */
+    disconnect(type: 'trades' | 'token' | 'chat', mint: string): void;
+}
+/**
+ * Create streaming client
+ */
+declare function createStreaming(baseUrl?: string, options?: StreamingOptions): ClawdVaultStreaming;
+
 /**
  * ClawdVault SDK
  * TypeScript client for ClawdVault token launchpad on Solana
@@ -610,4 +765,4 @@ declare function createClient(config?: ClawdVaultConfig): ClawdVaultClient;
 declare const PROGRAM_ID = "GUyF2TVe32Cid4iGVt2F6wPYDhLSVmTUZBj2974outYM";
 declare const DEFAULT_BASE_URL = "https://clawdvault.com/api";
 
-export { type BalanceResponse, type CandleData, type CandlesParams, type CandlesResponse, type ChatMessage, type ChatMessagesResponse, type ChatParams, ClawdVaultClient, type ClawdVaultConfig, DEFAULT_BASE_URL, type ExecuteCreateRequest, type ExecuteCreateResponse, type ExecuteTradeRequest, type ExecuteTradeResponse, type GraduationStatusResponse, type HolderInfo, type HoldersResponse, type JupiterExecuteRequest, type JupiterQuoteResponse, type JupiterStatusResponse, type JupiterSwapRequest, KeypairSigner, type NetworkStatusResponse, PROGRAM_ID, PhantomSigner, type PhantomWallet, type PrepareCreateRequest, type PrepareCreateResponse, type PrepareTradeRequest, type PrepareTradeResponse, type QuoteParams, type QuoteResponse, type SendChatRequest, type SessionResponse, type SessionValidateResponse, type SolPriceResponse, type StatsResponse, type Token, type TokenDetailResponse, type TokenListParams, type TokenListResponse, type Trade, type TradeHistoryResponse, type TradesParams, type UpdateProfileRequest, type UploadResponse, type UserProfile, type WalletSigner, createAuthSignature, createClient, signAndSerialize, verifySignature };
+export { type BalanceResponse, type CandleData, type CandlesParams, type CandlesResponse, type ChatMessage, type ChatMessagesResponse, type ChatParams, ClawdVaultClient, type ClawdVaultConfig, ClawdVaultStreaming, DEFAULT_BASE_URL, type ExecuteCreateRequest, type ExecuteCreateResponse, type ExecuteTradeRequest, type ExecuteTradeResponse, type GraduationStatusResponse, type HolderInfo, type HoldersResponse, type JupiterExecuteRequest, type JupiterQuoteResponse, type JupiterStatusResponse, type JupiterSwapRequest, KeypairSigner, type NetworkStatusResponse, PROGRAM_ID, PhantomSigner, type PhantomWallet, type PrepareCreateRequest, type PrepareCreateResponse, type PrepareTradeRequest, type PrepareTradeResponse, type QuoteParams, type QuoteResponse, type SendChatRequest, type SessionResponse, type SessionValidateResponse, type SolPriceResponse, type StatsResponse, type StreamChatMessage, StreamConnection, type StreamReaction, type StreamTokenConnected, type StreamTokenUpdate, type StreamTrade, type StreamingOptions, type Token, type TokenDetailResponse, type TokenListParams, type TokenListResponse, type Trade, type TradeHistoryResponse, type TradesParams, type UpdateProfileRequest, type UploadResponse, type UserProfile, type WalletSigner, createAuthSignature, createClient, createStreaming, signAndSerialize, verifySignature };

package/dist/index.d.ts

@@ -600,6 +600,161 @@ declare class ClawdVaultClient {
  */
 declare function createClient(config?: ClawdVaultConfig): ClawdVaultClient;
 
+/**
+ * ClawdVault Streaming Client
+ * Real-time data feeds via Server-Sent Events
+ */
+interface StreamTrade {
+    id: string;
+    type: 'buy' | 'sell';
+    sol_amount: number;
+    token_amount: number;
+    price_sol: number;
+    trader: string;
+    signature?: string;
+    created_at: string;
+}
+interface StreamTokenUpdate {
+    price_sol: number;
+    market_cap_sol: number;
+    virtual_sol_reserves: number;
+    virtual_token_reserves: number;
+    real_sol_reserves: number;
+    graduated: boolean;
+    timestamp: number;
+}
+interface StreamTokenConnected extends StreamTokenUpdate {
+    mint: string;
+    name: string;
+    symbol: string;
+}
+interface StreamChatMessage {
+    id: string;
+    wallet: string;
+    username?: string;
+    message: string;
+    reply_to?: string;
+    created_at: string;
+}
+interface StreamReaction {
+    message_id: string;
+    emoji: string;
+    wallet: string;
+}
+interface StreamingOptions {
+    /** Auto-reconnect on connection loss (default: true) */
+    autoReconnect?: boolean;
+    /** Reconnect delay in ms (default: 3000) */
+    reconnectDelay?: number;
+    /** Max reconnect attempts (default: 10) */
+    maxReconnectAttempts?: number;
+}
+type EventCallback<T> = (data: T) => void;
+type ErrorCallback = (error: Error) => void;
+type ConnectionCallback = () => void;
+declare class StreamConnection {
+    private eventSource;
+    private url;
+    private options;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private listeners;
+    private onConnectCallbacks;
+    private onDisconnectCallbacks;
+    private onErrorCallbacks;
+    private isConnected;
+    private isManuallyDisconnected;
+    constructor(url: string, options?: StreamingOptions);
+    /**
+     * Connect to the stream
+     */
+    connect(): void;
+    private handleEvent;
+    private scheduleReconnect;
+    /**
+     * Disconnect from the stream
+     */
+    disconnect(): void;
+    /**
+     * Subscribe to an event type
+     */
+    on<T>(eventType: string, callback: EventCallback<T>): () => void;
+    /**
+     * One-time event listener
+     */
+    once<T>(eventType: string, callback: EventCallback<T>): void;
+    /**
+     * Register connection callback
+     */
+    onConnect(callback: ConnectionCallback): () => void;
+    /**
+     * Register disconnection callback
+     */
+    onDisconnect(callback: ConnectionCallback): () => void;
+    /**
+     * Register error callback
+     */
+    onError(callback: ErrorCallback): () => void;
+    /**
+     * Check if connected
+     */
+    get connected(): boolean;
+}
+/**
+ * Streaming client for ClawdVault
+ */
+declare class ClawdVaultStreaming {
+    private baseUrl;
+    private connections;
+    private options;
+    constructor(baseUrl?: string, options?: StreamingOptions);
+    /**
+     * Stream trades for a token
+     */
+    streamTrades(mint: string): StreamConnection;
+    /**
+     * Stream token updates (price, market cap)
+     */
+    streamToken(mint: string): StreamConnection;
+    /**
+     * Stream chat messages
+     */
+    streamChat(mint: string): StreamConnection;
+    /**
+     * Convenience: Subscribe to trades with callback
+     */
+    onTrades(mint: string, callback: EventCallback<StreamTrade>): {
+        unsubscribe: () => void;
+        connection: StreamConnection;
+    };
+    /**
+     * Convenience: Subscribe to token price updates
+     */
+    onPrice(mint: string, callback: EventCallback<StreamTokenUpdate>): {
+        unsubscribe: () => void;
+        connection: StreamConnection;
+    };
+    /**
+     * Convenience: Subscribe to chat messages
+     */
+    onChat(mint: string, callback: EventCallback<StreamChatMessage>): {
+        unsubscribe: () => void;
+        connection: StreamConnection;
+    };
+    /**
+     * Disconnect all streams
+     */
+    disconnectAll(): void;
+    /**
+     * Disconnect a specific stream
+     */
+    disconnect(type: 'trades' | 'token' | 'chat', mint: string): void;
+}
+/**
+ * Create streaming client
+ */
+declare function createStreaming(baseUrl?: string, options?: StreamingOptions): ClawdVaultStreaming;
+
 /**
  * ClawdVault SDK
  * TypeScript client for ClawdVault token launchpad on Solana
@@ -610,4 +765,4 @@ declare function createClient(config?: ClawdVaultConfig): ClawdVaultClient;
 declare const PROGRAM_ID = "GUyF2TVe32Cid4iGVt2F6wPYDhLSVmTUZBj2974outYM";
 declare const DEFAULT_BASE_URL = "https://clawdvault.com/api";
 
-export { type BalanceResponse, type CandleData, type CandlesParams, type CandlesResponse, type ChatMessage, type ChatMessagesResponse, type ChatParams, ClawdVaultClient, type ClawdVaultConfig, DEFAULT_BASE_URL, type ExecuteCreateRequest, type ExecuteCreateResponse, type ExecuteTradeRequest, type ExecuteTradeResponse, type GraduationStatusResponse, type HolderInfo, type HoldersResponse, type JupiterExecuteRequest, type JupiterQuoteResponse, type JupiterStatusResponse, type JupiterSwapRequest, KeypairSigner, type NetworkStatusResponse, PROGRAM_ID, PhantomSigner, type PhantomWallet, type PrepareCreateRequest, type PrepareCreateResponse, type PrepareTradeRequest, type PrepareTradeResponse, type QuoteParams, type QuoteResponse, type SendChatRequest, type SessionResponse, type SessionValidateResponse, type SolPriceResponse, type StatsResponse, type Token, type TokenDetailResponse, type TokenListParams, type TokenListResponse, type Trade, type TradeHistoryResponse, type TradesParams, type UpdateProfileRequest, type UploadResponse, type UserProfile, type WalletSigner, createAuthSignature, createClient, signAndSerialize, verifySignature };
+export { type BalanceResponse, type CandleData, type CandlesParams, type CandlesResponse, type ChatMessage, type ChatMessagesResponse, type ChatParams, ClawdVaultClient, type ClawdVaultConfig, ClawdVaultStreaming, DEFAULT_BASE_URL, type ExecuteCreateRequest, type ExecuteCreateResponse, type ExecuteTradeRequest, type ExecuteTradeResponse, type GraduationStatusResponse, type HolderInfo, type HoldersResponse, type JupiterExecuteRequest, type JupiterQuoteResponse, type JupiterStatusResponse, type JupiterSwapRequest, KeypairSigner, type NetworkStatusResponse, PROGRAM_ID, PhantomSigner, type PhantomWallet, type PrepareCreateRequest, type PrepareCreateResponse, type PrepareTradeRequest, type PrepareTradeResponse, type QuoteParams, type QuoteResponse, type SendChatRequest, type SessionResponse, type SessionValidateResponse, type SolPriceResponse, type StatsResponse, type StreamChatMessage, StreamConnection, type StreamReaction, type StreamTokenConnected, type StreamTokenUpdate, type StreamTrade, type StreamingOptions, type Token, type TokenDetailResponse, type TokenListParams, type TokenListResponse, type Trade, type TradeHistoryResponse, type TradesParams, type UpdateProfileRequest, type UploadResponse, type UserProfile, type WalletSigner, createAuthSignature, createClient, createStreaming, signAndSerialize, verifySignature };

package/dist/index.js

@@ -31,14 +31,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ClawdVaultClient: () => ClawdVaultClient,
+  ClawdVaultStreaming: () => ClawdVaultStreaming,
   DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
   Keypair: () => import_web32.Keypair,
   KeypairSigner: () => KeypairSigner,
   PROGRAM_ID: () => PROGRAM_ID,
   PhantomSigner: () => PhantomSigner,
   PublicKey: () => import_web32.PublicKey,
+  StreamConnection: () => StreamConnection,
   createAuthSignature: () => createAuthSignature,
   createClient: () => createClient,
+  createStreaming: () => createStreaming,
   signAndSerialize: () => signAndSerialize,
   verifySignature: () => verifySignature
 });
@@ -611,6 +614,268 @@ function createClient(config) {
   return new ClawdVaultClient(config);
 }
 
+// src/streaming.ts
+var getEventSource = () => {
+  if (typeof EventSource !== "undefined") {
+    return EventSource;
+  }
+  return require("eventsource");
+};
+var StreamConnection = class {
+  constructor(url, options = {}) {
+    this.eventSource = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimeout = null;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.onConnectCallbacks = /* @__PURE__ */ new Set();
+    this.onDisconnectCallbacks = /* @__PURE__ */ new Set();
+    this.onErrorCallbacks = /* @__PURE__ */ new Set();
+    this.isConnected = false;
+    this.isManuallyDisconnected = false;
+    this.url = url;
+    this.options = {
+      autoReconnect: options.autoReconnect ?? true,
+      reconnectDelay: options.reconnectDelay ?? 3e3,
+      maxReconnectAttempts: options.maxReconnectAttempts ?? 10
+    };
+  }
+  /**
+   * Connect to the stream
+   */
+  connect() {
+    if (this.eventSource) {
+      return;
+    }
+    this.isManuallyDisconnected = false;
+    const EventSourceImpl = getEventSource();
+    this.eventSource = new EventSourceImpl(this.url);
+    this.eventSource.onopen = () => {
+      this.isConnected = true;
+      this.reconnectAttempts = 0;
+      this.onConnectCallbacks.forEach((cb) => cb());
+    };
+    this.eventSource.onerror = (event) => {
+      const wasConnected = this.isConnected;
+      this.isConnected = false;
+      if (wasConnected) {
+        this.onDisconnectCallbacks.forEach((cb) => cb());
+      }
+      this.onErrorCallbacks.forEach((cb) => cb(new Error("Stream connection error")));
+      if (this.options.autoReconnect && !this.isManuallyDisconnected) {
+        this.scheduleReconnect();
+      }
+    };
+    this.eventSource.onmessage = (event) => {
+      this.handleEvent("message", event.data);
+    };
+    for (const eventType of this.listeners.keys()) {
+      this.eventSource.addEventListener(eventType, (event) => {
+        this.handleEvent(eventType, event.data);
+      });
+    }
+  }
+  handleEvent(eventType, data) {
+    const callbacks = this.listeners.get(eventType);
+    if (!callbacks) return;
+    try {
+      const parsed = JSON.parse(data);
+      callbacks.forEach((cb) => cb(parsed));
+    } catch {
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+    }
+    if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+      this.onErrorCallbacks.forEach(
+        (cb) => cb(new Error(`Max reconnect attempts (${this.options.maxReconnectAttempts}) reached`))
+      );
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = this.options.reconnectDelay * Math.pow(1.5, this.reconnectAttempts - 1);
+    this.reconnectTimeout = setTimeout(() => {
+      this.eventSource?.close();
+      this.eventSource = null;
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Disconnect from the stream
+   */
+  disconnect() {
+    this.isManuallyDisconnected = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+    if (this.isConnected) {
+      this.isConnected = false;
+      this.onDisconnectCallbacks.forEach((cb) => cb());
+    }
+  }
+  /**
+   * Subscribe to an event type
+   */
+  on(eventType, callback) {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, /* @__PURE__ */ new Set());
+      if (this.eventSource) {
+        this.eventSource.addEventListener(eventType, (event) => {
+          this.handleEvent(eventType, event.data);
+        });
+      }
+    }
+    this.listeners.get(eventType).add(callback);
+    return () => {
+      const callbacks = this.listeners.get(eventType);
+      if (callbacks) {
+        callbacks.delete(callback);
+      }
+    };
+  }
+  /**
+   * One-time event listener
+   */
+  once(eventType, callback) {
+    const unsubscribe = this.on(eventType, (data) => {
+      unsubscribe();
+      callback(data);
+    });
+  }
+  /**
+   * Register connection callback
+   */
+  onConnect(callback) {
+    this.onConnectCallbacks.add(callback);
+    return () => this.onConnectCallbacks.delete(callback);
+  }
+  /**
+   * Register disconnection callback
+   */
+  onDisconnect(callback) {
+    this.onDisconnectCallbacks.add(callback);
+    return () => this.onDisconnectCallbacks.delete(callback);
+  }
+  /**
+   * Register error callback
+   */
+  onError(callback) {
+    this.onErrorCallbacks.add(callback);
+    return () => this.onErrorCallbacks.delete(callback);
+  }
+  /**
+   * Check if connected
+   */
+  get connected() {
+    return this.isConnected;
+  }
+};
+var ClawdVaultStreaming = class {
+  constructor(baseUrl = "https://clawdvault.com/api", options = {}) {
+    this.connections = /* @__PURE__ */ new Map();
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.options = options;
+  }
+  /**
+   * Stream trades for a token
+   */
+  streamTrades(mint) {
+    const key = `trades:${mint}`;
+    if (!this.connections.has(key)) {
+      const conn = new StreamConnection(
+        `${this.baseUrl}/stream/trades?mint=${mint}`,
+        this.options
+      );
+      this.connections.set(key, conn);
+    }
+    return this.connections.get(key);
+  }
+  /**
+   * Stream token updates (price, market cap)
+   */
+  streamToken(mint) {
+    const key = `token:${mint}`;
+    if (!this.connections.has(key)) {
+      const conn = new StreamConnection(
+        `${this.baseUrl}/stream/token?mint=${mint}`,
+        this.options
+      );
+      this.connections.set(key, conn);
+    }
+    return this.connections.get(key);
+  }
+  /**
+   * Stream chat messages
+   */
+  streamChat(mint) {
+    const key = `chat:${mint}`;
+    if (!this.connections.has(key)) {
+      const conn = new StreamConnection(
+        `${this.baseUrl}/stream/chat?mint=${mint}`,
+        this.options
+      );
+      this.connections.set(key, conn);
+    }
+    return this.connections.get(key);
+  }
+  /**
+   * Convenience: Subscribe to trades with callback
+   */
+  onTrades(mint, callback) {
+    const conn = this.streamTrades(mint);
+    const unsubscribe = conn.on("trade", callback);
+    conn.connect();
+    return { unsubscribe, connection: conn };
+  }
+  /**
+   * Convenience: Subscribe to token price updates
+   */
+  onPrice(mint, callback) {
+    const conn = this.streamToken(mint);
+    const unsubscribe = conn.on("update", callback);
+    conn.connect();
+    return { unsubscribe, connection: conn };
+  }
+  /**
+   * Convenience: Subscribe to chat messages
+   */
+  onChat(mint, callback) {
+    const conn = this.streamChat(mint);
+    const unsubscribe = conn.on("message", callback);
+    conn.connect();
+    return { unsubscribe, connection: conn };
+  }
+  /**
+   * Disconnect all streams
+   */
+  disconnectAll() {
+    for (const conn of this.connections.values()) {
+      conn.disconnect();
+    }
+    this.connections.clear();
+  }
+  /**
+   * Disconnect a specific stream
+   */
+  disconnect(type, mint) {
+    const key = `${type}:${mint}`;
+    const conn = this.connections.get(key);
+    if (conn) {
+      conn.disconnect();
+      this.connections.delete(key);
+    }
+  }
+};
+function createStreaming(baseUrl, options) {
+  return new ClawdVaultStreaming(baseUrl, options);
+}
+
 // src/index.ts
 var import_web32 = require("@solana/web3.js");
 var PROGRAM_ID = "GUyF2TVe32Cid4iGVt2F6wPYDhLSVmTUZBj2974outYM";
@@ -618,14 +883,17 @@ var DEFAULT_BASE_URL = "https://clawdvault.com/api";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ClawdVaultClient,
+  ClawdVaultStreaming,
   DEFAULT_BASE_URL,
   Keypair,
   KeypairSigner,
   PROGRAM_ID,
   PhantomSigner,
   PublicKey,
+  StreamConnection,
   createAuthSignature,
   createClient,
+  createStreaming,
   signAndSerialize,
   verifySignature
 });

package/dist/index.mjs

@@ -577,20 +577,285 @@ function createClient(config) {
   return new ClawdVaultClient(config);
 }
 
+// src/streaming.ts
+var getEventSource = () => {
+  if (typeof EventSource !== "undefined") {
+    return EventSource;
+  }
+  return __require("eventsource");
+};
+var StreamConnection = class {
+  constructor(url, options = {}) {
+    this.eventSource = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimeout = null;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.onConnectCallbacks = /* @__PURE__ */ new Set();
+    this.onDisconnectCallbacks = /* @__PURE__ */ new Set();
+    this.onErrorCallbacks = /* @__PURE__ */ new Set();
+    this.isConnected = false;
+    this.isManuallyDisconnected = false;
+    this.url = url;
+    this.options = {
+      autoReconnect: options.autoReconnect ?? true,
+      reconnectDelay: options.reconnectDelay ?? 3e3,
+      maxReconnectAttempts: options.maxReconnectAttempts ?? 10
+    };
+  }
+  /**
+   * Connect to the stream
+   */
+  connect() {
+    if (this.eventSource) {
+      return;
+    }
+    this.isManuallyDisconnected = false;
+    const EventSourceImpl = getEventSource();
+    this.eventSource = new EventSourceImpl(this.url);
+    this.eventSource.onopen = () => {
+      this.isConnected = true;
+      this.reconnectAttempts = 0;
+      this.onConnectCallbacks.forEach((cb) => cb());
+    };
+    this.eventSource.onerror = (event) => {
+      const wasConnected = this.isConnected;
+      this.isConnected = false;
+      if (wasConnected) {
+        this.onDisconnectCallbacks.forEach((cb) => cb());
+      }
+      this.onErrorCallbacks.forEach((cb) => cb(new Error("Stream connection error")));
+      if (this.options.autoReconnect && !this.isManuallyDisconnected) {
+        this.scheduleReconnect();
+      }
+    };
+    this.eventSource.onmessage = (event) => {
+      this.handleEvent("message", event.data);
+    };
+    for (const eventType of this.listeners.keys()) {
+      this.eventSource.addEventListener(eventType, (event) => {
+        this.handleEvent(eventType, event.data);
+      });
+    }
+  }
+  handleEvent(eventType, data) {
+    const callbacks = this.listeners.get(eventType);
+    if (!callbacks) return;
+    try {
+      const parsed = JSON.parse(data);
+      callbacks.forEach((cb) => cb(parsed));
+    } catch {
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+    }
+    if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+      this.onErrorCallbacks.forEach(
+        (cb) => cb(new Error(`Max reconnect attempts (${this.options.maxReconnectAttempts}) reached`))
+      );
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = this.options.reconnectDelay * Math.pow(1.5, this.reconnectAttempts - 1);
+    this.reconnectTimeout = setTimeout(() => {
+      this.eventSource?.close();
+      this.eventSource = null;
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Disconnect from the stream
+   */
+  disconnect() {
+    this.isManuallyDisconnected = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+    if (this.isConnected) {
+      this.isConnected = false;
+      this.onDisconnectCallbacks.forEach((cb) => cb());
+    }
+  }
+  /**
+   * Subscribe to an event type
+   */
+  on(eventType, callback) {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, /* @__PURE__ */ new Set());
+      if (this.eventSource) {
+        this.eventSource.addEventListener(eventType, (event) => {
+          this.handleEvent(eventType, event.data);
+        });
+      }
+    }
+    this.listeners.get(eventType).add(callback);
+    return () => {
+      const callbacks = this.listeners.get(eventType);
+      if (callbacks) {
+        callbacks.delete(callback);
+      }
+    };
+  }
+  /**
+   * One-time event listener
+   */
+  once(eventType, callback) {
+    const unsubscribe = this.on(eventType, (data) => {
+      unsubscribe();
+      callback(data);
+    });
+  }
+  /**
+   * Register connection callback
+   */
+  onConnect(callback) {
+    this.onConnectCallbacks.add(callback);
+    return () => this.onConnectCallbacks.delete(callback);
+  }
+  /**
+   * Register disconnection callback
+   */
+  onDisconnect(callback) {
+    this.onDisconnectCallbacks.add(callback);
+    return () => this.onDisconnectCallbacks.delete(callback);
+  }
+  /**
+   * Register error callback
+   */
+  onError(callback) {
+    this.onErrorCallbacks.add(callback);
+    return () => this.onErrorCallbacks.delete(callback);
+  }
+  /**
+   * Check if connected
+   */
+  get connected() {
+    return this.isConnected;
+  }
+};
+var ClawdVaultStreaming = class {
+  constructor(baseUrl = "https://clawdvault.com/api", options = {}) {
+    this.connections = /* @__PURE__ */ new Map();
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.options = options;
+  }
+  /**
+   * Stream trades for a token
+   */
+  streamTrades(mint) {
+    const key = `trades:${mint}`;
+    if (!this.connections.has(key)) {
+      const conn = new StreamConnection(
+        `${this.baseUrl}/stream/trades?mint=${mint}`,
+        this.options
+      );
+      this.connections.set(key, conn);
+    }
+    return this.connections.get(key);
+  }
+  /**
+   * Stream token updates (price, market cap)
+   */
+  streamToken(mint) {
+    const key = `token:${mint}`;
+    if (!this.connections.has(key)) {
+      const conn = new StreamConnection(
+        `${this.baseUrl}/stream/token?mint=${mint}`,
+        this.options
+      );
+      this.connections.set(key, conn);
+    }
+    return this.connections.get(key);
+  }
+  /**
+   * Stream chat messages
+   */
+  streamChat(mint) {
+    const key = `chat:${mint}`;
+    if (!this.connections.has(key)) {
+      const conn = new StreamConnection(
+        `${this.baseUrl}/stream/chat?mint=${mint}`,
+        this.options
+      );
+      this.connections.set(key, conn);
+    }
+    return this.connections.get(key);
+  }
+  /**
+   * Convenience: Subscribe to trades with callback
+   */
+  onTrades(mint, callback) {
+    const conn = this.streamTrades(mint);
+    const unsubscribe = conn.on("trade", callback);
+    conn.connect();
+    return { unsubscribe, connection: conn };
+  }
+  /**
+   * Convenience: Subscribe to token price updates
+   */
+  onPrice(mint, callback) {
+    const conn = this.streamToken(mint);
+    const unsubscribe = conn.on("update", callback);
+    conn.connect();
+    return { unsubscribe, connection: conn };
+  }
+  /**
+   * Convenience: Subscribe to chat messages
+   */
+  onChat(mint, callback) {
+    const conn = this.streamChat(mint);
+    const unsubscribe = conn.on("message", callback);
+    conn.connect();
+    return { unsubscribe, connection: conn };
+  }
+  /**
+   * Disconnect all streams
+   */
+  disconnectAll() {
+    for (const conn of this.connections.values()) {
+      conn.disconnect();
+    }
+    this.connections.clear();
+  }
+  /**
+   * Disconnect a specific stream
+   */
+  disconnect(type, mint) {
+    const key = `${type}:${mint}`;
+    const conn = this.connections.get(key);
+    if (conn) {
+      conn.disconnect();
+      this.connections.delete(key);
+    }
+  }
+};
+function createStreaming(baseUrl, options) {
+  return new ClawdVaultStreaming(baseUrl, options);
+}
+
 // src/index.ts
 import { PublicKey as PublicKey2, Keypair as Keypair2 } from "@solana/web3.js";
 var PROGRAM_ID = "GUyF2TVe32Cid4iGVt2F6wPYDhLSVmTUZBj2974outYM";
 var DEFAULT_BASE_URL = "https://clawdvault.com/api";
 export {
   ClawdVaultClient,
+  ClawdVaultStreaming,
   DEFAULT_BASE_URL,
   Keypair2 as Keypair,
   KeypairSigner,
   PROGRAM_ID,
   PhantomSigner,
   PublicKey2 as PublicKey,
+  StreamConnection,
   createAuthSignature,
   createClient,
+  createStreaming,
   signAndSerialize,
   verifySignature
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawdvault/sdk",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "TypeScript SDK for ClawdVault - Solana token launchpad",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -25,7 +25,8 @@
     "@solana/web3.js": "^1.91.0",
     "@solana/spl-token": "^0.4.0",
     "bs58": "^5.0.0",
-    "tweetnacl": "^1.0.3"
+    "tweetnacl": "^1.0.3",
+    "eventsource": "^2.0.2"
   },
   "devDependencies": {
     "tsup": "^8.0.1",