Cuckoo Network WebSocket Guide

WebSocket connections provide real-time, bidirectional communication with the Cuckoo Network blockchain, enabling your applications to receive instant updates for new blocks, transactions, and smart contract events without polling.

Why Use WebSockets?

Advantages over HTTP Polling

Real-time Updates: Instant notifications when events occur
Lower Latency: No polling delays
Reduced Bandwidth: Only receive data when it changes
Better Performance: Persistent connection reduces overhead
Event-Driven: React to blockchain events as they happen

Common Use Cases

Trading Applications: Real-time price feeds and order book updates
DeFi Dashboards: Live liquidity and yield changes
NFT Marketplaces: Instant sale and listing notifications
Wallet Applications: Balance updates and transaction confirmations
Analytics Platforms: Real-time blockchain metrics

Connection Setup

WebSocket Endpoints

text

wss://api.bex.co/cuckoo/mainnet/${accessKey}
wss://ethereum-sepolia.bex.co/<your-api-key>
wss://polygon-mainnet.bex.co/<your-api-key>
wss://arbitrum-mainnet.bex.co/<your-api-key>

Basic Connection

JavaScript (Browser/Node.js)

javascript

const ws = new WebSocket('wss://api.bex.co/cuckoo/mainnet/${accessKey}');
 
ws.onopen = function(event) {
  console.log('WebSocket connected');
};
 
ws.onmessage = function(event) {
  const data = JSON.parse(event.data);
  console.log('Received:', data);
};
 
ws.onerror = function(error) {
  console.error('WebSocket error:', error);
};
 
ws.onclose = function(event) {
  console.log('WebSocket closed:', event.code, event.reason);
};

Python

python

import asyncio
import websockets
import json
 
async def connect():
    uri = "wss://api.bex.co/cuckoo/mainnet/${accessKey}"
    
    async with websockets.connect(uri) as websocket:
        print("WebSocket connected")
        
        # Subscribe to new heads
        subscribe_msg = {
            "jsonrpc": "2.0",
            "method": "eth_subscribe",
            "params": ["newHeads"],
            "id": 1
        }
        await websocket.send(json.dumps(subscribe_msg))
        
        # Listen for messages
        async for message in websocket:
            data = json.loads(message)
            print(f"Received: {data}")
 
# Run the connection
asyncio.run(connect())

Go

package main
 
import (
    "encoding/json"
    "fmt"
    "log"
    "github.com/gorilla/websocket"
)
 
type SubscriptionRequest struct {
    JSONRPC string      `json:"jsonrpc"`
    Method  string      `json:"method"`
    Params  []string    `json:"params"`
    ID      int         `json:"id"`
}
 
func main() {
    url := "wss://api.bex.co/cuckoo/mainnet/${accessKey}"
    
    conn, _, err := websocket.DefaultDialer.Dial(url, nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer conn.Close()
    
    // Subscribe to new heads
    req := SubscriptionRequest{
        JSONRPC: "2.0",
        Method:  "eth_subscribe",
        Params:  []string{"newHeads"},
        ID:      1,
    }
    
    if err := conn.WriteJSON(req); err != nil {
        log.Fatal("write:", err)
    }
    
    // Read messages
    for {
        var msg map[string]interface{}
        if err := conn.ReadJSON(&msg); err != nil {
            log.Fatal("read:", err)
        }
        fmt.Printf("Received: %+v\n", msg)
    }
}

Subscription Types

1. New Block Headers (newHeads)

Subscribe to new block headers as they're mined.

javascript

const subscribeToNewHeads = () => {
  const subscription = {
    jsonrpc: '2.0',
    method: 'eth_subscribe',
    params: ['newHeads'],
    id: 1
  };
  
  ws.send(JSON.stringify(subscription));
};
 
// Handle new block headers
ws.onmessage = function(event) {
  const data = JSON.parse(event.data);
  
  if (data.method === 'eth_subscription' && data.params.subscription) {
    const blockHeader = data.params.result;
    console.log('New block:', {
      number: parseInt(blockHeader.number, 16),
      hash: blockHeader.hash,
      timestamp: parseInt(blockHeader.timestamp, 16),
      gasUsed: parseInt(blockHeader.gasUsed, 16),
      gasLimit: parseInt(blockHeader.gasLimit, 16)
    });
  }
};

2. Pending Transactions (newPendingTransactions)

Subscribe to new pending transactions in the mempool.

javascript

const subscribeToPendingTransactions = () => {
  const subscription = {
    jsonrpc: '2.0',
    method: 'eth_subscribe',
    params: ['newPendingTransactions'],
    id: 2
  };
  
  ws.send(JSON.stringify(subscription));
};
 
// Handle pending transactions
ws.onmessage = function(event) {
  const data = JSON.parse(event.data);
  
  if (data.method === 'eth_subscription' && data.params.subscription) {
    const txHash = data.params.result;
    console.log('New pending transaction:', txHash);
    
    // Optionally fetch full transaction details
    fetchTransactionDetails(txHash);
  }
};

3. Smart Contract Events (logs)

Subscribe to specific smart contract events using log filters.

javascript

const subscribeToContractEvents = (contractAddress, topics) => {
  const subscription = {
    jsonrpc: '2.0',
    method: 'eth_subscribe',
    params: [
      'logs',
      {
        address: contractAddress,
        topics: topics
      }
    ],
    id: 3
  };
  
  ws.send(JSON.stringify(subscription));
};
 
// Subscribe to ERC-20 Transfer events
const ERC20_TRANSFER_TOPIC = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
subscribeToContractEvents('0xA0b86a33E6c0e4A2a2a5FB1C6A6D6a30BF8b6B3a', [ERC20_TRANSFER_TOPIC]);
 
// Handle contract events
ws.onmessage = function(event) {
  const data = JSON.parse(event.data);
  
  if (data.method === 'eth_subscription' && data.params.subscription) {
    const log = data.params.result;
    console.log('Contract event:', {
      address: log.address,
      topics: log.topics,
      data: log.data,
      blockNumber: parseInt(log.blockNumber, 16),
      transactionHash: log.transactionHash
    });
  }
};

4. Synchronized Blocks (syncing)

Subscribe to synchronization status updates.

javascript

const subscribeToSyncing = () => {
  const subscription = {
    jsonrpc: '2.0',
    method: 'eth_subscribe',
    params: ['syncing'],
    id: 4
  };
  
  ws.send(JSON.stringify(subscription));
};
 
// Handle sync status
ws.onmessage = function(event) {
  const data = JSON.parse(event.data);
  
  if (data.method === 'eth_subscription' && data.params.subscription) {
    const syncStatus = data.params.result;
    if (syncStatus === false) {
      console.log('Node is fully synchronized');
    } else {
      console.log('Sync status:', {
        startingBlock: parseInt(syncStatus.startingBlock, 16),
        currentBlock: parseInt(syncStatus.currentBlock, 16),
        highestBlock: parseInt(syncStatus.highestBlock, 16)
      });
    }
  }
};

Advanced Usage Patterns

Managing Multiple Subscriptions

javascript

class Cuckoo NetworkWebSocketManager {
  constructor(endpoint) {
    this.endpoint = endpoint;
    this.ws = null;
    this.subscriptions = new Map();
    this.messageHandlers = new Map();
    this.reconnectAttempts = 0;
    this.maxReconnectAttempts = 5;
  }
  
  connect() {
    return new Promise((resolve, reject) => {
      this.ws = new WebSocket(this.endpoint);
      
      this.ws.onopen = () => {
        console.log('WebSocket connected');
        this.reconnectAttempts = 0;
        resolve();
      };
      
      this.ws.onmessage = (event) => {
        this.handleMessage(JSON.parse(event.data));
      };
      
      this.ws.onerror = (error) => {
        console.error('WebSocket error:', error);
        reject(error);
      };
      
      this.ws.onclose = (event) => {
        console.log('WebSocket closed:', event.code, event.reason);
        this.handleReconnection();
      };
    });
  }
  
  subscribe(type, params, handler) {
    const id = Date.now();
    const subscription = {
      jsonrpc: '2.0',
      method: 'eth_subscribe',
      params: [type, ...(params || [])],
      id: id
    };
    
    this.ws.send(JSON.stringify(subscription));
    this.messageHandlers.set(id, handler);
    
    return id;
  }
  
  unsubscribe(subscriptionId) {
    const unsubscribe = {
      jsonrpc: '2.0',
      method: 'eth_unsubscribe',
      params: [subscriptionId],
      id: Date.now()
    };
    
    this.ws.send(JSON.stringify(unsubscribe));
    this.subscriptions.delete(subscriptionId);
  }
  
  handleMessage(data) {
    if (data.method === 'eth_subscription') {
      // Handle subscription data
      const subscriptionId = data.params.subscription;
      const handler = this.subscriptions.get(subscriptionId);
      if (handler) {
        handler(data.params.result);
      }
    } else if (data.id && this.messageHandlers.has(data.id)) {
      // Handle subscription response
      const handler = this.messageHandlers.get(data.id);
      this.messageHandlers.delete(data.id);
      
      if (data.result) {
        this.subscriptions.set(data.result, handler);
      }
    }
  }
  
  handleReconnection() {
    if (this.reconnectAttempts < this.maxReconnectAttempts) {
      this.reconnectAttempts++;
      const delay = Math.pow(2, this.reconnectAttempts) * 1000;
      
      setTimeout(() => {
        console.log(`Reconnecting... Attempt ${this.reconnectAttempts}`);
        this.connect().then(() => {
          // Resubscribe to all previous subscriptions
          this.resubscribeAll();
        });
      }, delay);
    }
  }
  
  resubscribeAll() {
    // Implementation depends on your subscription tracking
    console.log('Resubscribing to all previous subscriptions');
  }
}
 
// Usage
const wsManager = new Cuckoo NetworkWebSocketManager('wss://api.bex.co/cuckoo/mainnet/${accessKey}');
 
wsManager.connect().then(() => {
  // Subscribe to new blocks
  wsManager.subscribe('newHeads', null, (blockHeader) => {
    console.log('New block:', blockHeader);
  });
  
  // Subscribe to USDC transfers
  wsManager.subscribe('logs', [{
    address: '0xA0b86a33E6c0e4A2a2a5FB1C6A6D6a30BF8b6B3a',
    topics: ['0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef']
  }], (log) => {
    console.log('USDC transfer:', log);
  });
});

Real-time Trading Dashboard

javascript

class TradingDashboard {
  constructor(wsEndpoint) {
    this.wsManager = new Cuckoo NetworkWebSocketManager(wsEndpoint);
    this.priceFeeds = new Map();
    this.orderBookUpdates = new Map();
  }
  
  async start() {
    await this.wsManager.connect();
    
    // Subscribe to DEX events
    this.subscribeToUniswapV3();
    this.subscribeToSushiSwap();
    this.subscribeToNewBlocks();
  }
  
  subscribeToUniswapV3() {
    // Uniswap V3 Swap events
    const SWAP_TOPIC = '0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67';
    
    this.wsManager.subscribe('logs', [{
      address: '0x1F98431c8aD98523631AE4a59f267346ea31F984', // Uniswap V3 Factory
      topics: [SWAP_TOPIC]
    }], (log) => {
      this.handleUniswapSwap(log);
    });
  }
  
  subscribeToSushiSwap() {
    // SushiSwap Swap events
    const SWAP_TOPIC = '0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822';
    
    this.wsManager.subscribe('logs', [{
      topics: [SWAP_TOPIC]
    }], (log) => {
      this.handleSushiSwap(log);
    });
  }
  
  subscribeToNewBlocks() {
    this.wsManager.subscribe('newHeads', null, (blockHeader) => {
      this.updateBlockInfo(blockHeader);
    });
  }
  
  handleUniswapSwap(log) {
    // Parse Uniswap V3 swap data
    const poolAddress = log.address;
    const data = this.parseSwapData(log.data);
    
    this.updatePriceFeed('uniswap', poolAddress, data);
  }
  
  handleSushiSwap(log) {
    // Parse SushiSwap swap data
    const poolAddress = log.address;
    const data = this.parseSwapData(log.data);
    
    this.updatePriceFeed('sushiswap', poolAddress, data);
  }
  
  updatePriceFeed(exchange, pool, swapData) {
    const key = `${exchange}:${pool}`;
    const currentFeed = this.priceFeeds.get(key) || { prices: [], volume: 0 };
    
    currentFeed.prices.push({
      price: swapData.price,
      timestamp: Date.now(),
      volume: swapData.amount
    });
    
    // Keep only last 100 prices
    if (currentFeed.prices.length > 100) {
      currentFeed.prices.shift();
    }
    
    currentFeed.volume += swapData.amount;
    this.priceFeeds.set(key, currentFeed);
    
    // Emit update to UI
    this.emitPriceUpdate(exchange, pool, currentFeed);
  }
  
  parseSwapData(data) {
    // Implementation depends on the specific DEX
    // This is a simplified example
    return {
      price: parseFloat(data.slice(0, 66)),
      amount: parseFloat(data.slice(66, 130))
    };
  }
  
  emitPriceUpdate(exchange, pool, feed) {
    // Send to frontend/dashboard
    console.log(`Price update for ${exchange}:${pool}`, feed);
  }
  
  updateBlockInfo(blockHeader) {
    const blockInfo = {
      number: parseInt(blockHeader.number, 16),
      timestamp: parseInt(blockHeader.timestamp, 16),
      gasUsed: parseInt(blockHeader.gasUsed, 16),
      gasLimit: parseInt(blockHeader.gasLimit, 16)
    };
    
    console.log('New block:', blockInfo);
  }
}
 
// Usage
const dashboard = new TradingDashboard('wss://api.bex.co/cuckoo/mainnet/${accessKey}');
dashboard.start();

NFT Marketplace Monitor

javascript

class NFTMarketplaceMonitor {
  constructor(wsEndpoint) {
    this.wsManager = new Cuckoo NetworkWebSocketManager(wsEndpoint);
    this.marketplaces = {
      opensea: '0x00000000006c3852cbEf3e08E8dF289169EdE581',
      looksrare: '0x59728544B08AB483533076417FbBB2fD0B17CE3a',
      x2y2: '0x74312363e45DCaBA76c59ec49a7Aa8A65a67EeD3'
    };
  }
  
  async start() {
    await this.wsManager.connect();
    
    Object.entries(this.marketplaces).forEach(([name, address]) => {
      this.subscribeToMarketplace(name, address);
    });
  }
  
  subscribeToMarketplace(name, address) {
    // Subscribe to all events from marketplace contract
    this.wsManager.subscribe('logs', [{
      address: address
    }], (log) => {
      this.handleMarketplaceEvent(name, log);
    });
  }
  
  handleMarketplaceEvent(marketplace, log) {
    const eventSignature = log.topics[0];
    
    switch (eventSignature) {
      case '0x9d9af8e38d66c62e2c12f0225249fd9d721c54b83f48d9352c97c6cacdcb6f31': // Sale
        this.handleSale(marketplace, log);
        break;
      case '0x3cbb63f144840e5b1b0a38a7c19211d2e89de4d7c5faf8b2d3c1776c302d1d33': // Listing
        this.handleListing(marketplace, log);
        break;
      default:
        console.log(`Unknown event from ${marketplace}:`, eventSignature);
    }
  }
  
  handleSale(marketplace, log) {
    // Parse sale data
    const saleData = this.parseSaleData(log);
    
    console.log(`<ion-icon name="rocket" style={{verticalAlign: "middle", fontSize: "1.2em", color: "#8b5cf6"}}></ion-icon> NFT Sale on ${marketplace}:`, {
      collection: saleData.collection,
      tokenId: saleData.tokenId,
      price: saleData.price,
      buyer: saleData.buyer,
      seller: saleData.seller,
      txHash: log.transactionHash
    });
    
    // Send notification to users
    this.sendSaleNotification(marketplace, saleData);
  }
  
  handleListing(marketplace, log) {
    // Parse listing data
    const listingData = this.parseListingData(log);
    
    console.log(`<ion-icon name="warning" style={{verticalAlign: "middle", fontSize: "1.2em", color: "#f59e0b"}}></ion-icon> New Listing on ${marketplace}:`, {
      collection: listingData.collection,
      tokenId: listingData.tokenId,
      price: listingData.price,
      seller: listingData.seller
    });
  }
  
  parseSaleData(log) {
    // Implementation depends on marketplace contract
    return {
      collection: log.topics[1],
      tokenId: parseInt(log.topics[2], 16),
      price: parseInt(log.data.slice(0, 66), 16),
      buyer: `0x${log.data.slice(66, 106)}`,
      seller: `0x${log.data.slice(106, 146)}`
    };
  }
  
  parseListingData(log) {
    // Implementation depends on marketplace contract
    return {
      collection: log.topics[1],
      tokenId: parseInt(log.topics[2], 16),
      price: parseInt(log.data.slice(0, 66), 16),
      seller: `0x${log.data.slice(66, 106)}`
    };
  }
  
  sendSaleNotification(marketplace, saleData) {
    // Send to Discord, Telegram, email, etc.
    console.log(`Sending notification for ${marketplace} sale`);
  }
}
 
// Usage
const nftMonitor = new NFTMarketplaceMonitor('wss://api.bex.co/cuckoo/mainnet/${accessKey}');
nftMonitor.start();

Error Handling & Reconnection

Robust Error Handling

javascript

class RobustWebSocketClient {
  constructor(endpoint, options = {}) {
    this.endpoint = endpoint;
    this.options = {
      reconnectInterval: 5000,
      maxReconnectAttempts: 10,
      heartbeatInterval: 30000,
      ...options
    };
    
    this.ws = null;
    this.reconnectAttempts = 0;
    this.heartbeatTimer = null;
    this.subscriptions = new Map();
    this.isConnected = false;
  }
  
  connect() {
    return new Promise((resolve, reject) => {
      try {
        this.ws = new WebSocket(this.endpoint);
        
        this.ws.onopen = () => {
          console.log('WebSocket connected');
          this.isConnected = true;
          this.reconnectAttempts = 0;
          this.startHeartbeat();
          this.resubscribeAll();
          resolve();
        };
        
        this.ws.onmessage = (event) => {
          try {
            const data = JSON.parse(event.data);
            this.handleMessage(data);
          } catch (error) {
            console.error('Error parsing message:', error);
          }
        };
        
        this.ws.onerror = (error) => {
          console.error('WebSocket error:', error);
          this.isConnected = false;
        };
        
        this.ws.onclose = (event) => {
          console.log('WebSocket closed:', event.code, event.reason);
          this.isConnected = false;
          this.stopHeartbeat();
          
          if (event.code !== 1000) { // Not a normal closure
            this.handleReconnection();
          }
        };
        
      } catch (error) {
        reject(error);
      }
    });
  }
  
  startHeartbeat() {
    this.heartbeatTimer = setInterval(() => {
      if (this.isConnected && this.ws.readyState === WebSocket.OPEN) {
        this.ping();
      }
    }, this.options.heartbeatInterval);
  }
  
  stopHeartbeat() {
    if (this.heartbeatTimer) {
      clearInterval(this.heartbeatTimer);
      this.heartbeatTimer = null;
    }
  }
  
  ping() {
    // Send a simple request to check connection
    const ping = {
      jsonrpc: '2.0',
      method: 'net_version',
      params: [],
      id: 'ping'
    };
    
    this.send(ping);
  }
  
  send(data) {
    if (this.isConnected && this.ws.readyState === WebSocket.OPEN) {
      this.ws.send(JSON.stringify(data));
      return true;
    } else {
      console.warn('WebSocket not connected, queueing message');
      return false;
    }
  }
  
  handleReconnection() {
    if (this.reconnectAttempts < this.options.maxReconnectAttempts) {
      this.reconnectAttempts++;
      const delay = Math.min(
        this.options.reconnectInterval * Math.pow(2, this.reconnectAttempts - 1),
        30000 // Max 30 seconds
      );
      
      console.log(`Reconnecting in ${delay}ms... Attempt ${this.reconnectAttempts}`);
      
      setTimeout(() => {
        this.connect().catch((error) => {
          console.error('Reconnection failed:', error);
        });
      }, delay);
    } else {
      console.error('Max reconnection attempts reached');
    }
  }
  
  resubscribeAll() {
    // Resubscribe to all active subscriptions
    this.subscriptions.forEach((handler, subscription) => {
      // Implementation depends on your subscription tracking
    });
  }
  
  disconnect() {
    this.stopHeartbeat();
    if (this.ws) {
      this.ws.close(1000, 'Client disconnecting');
    }
  }
}

Performance Optimization

Efficient Message Processing

javascript

class OptimizedWebSocketProcessor {
  constructor(endpoint) {
    this.ws = new RobustWebSocketClient(endpoint);
    this.messageQueue = [];
    this.processing = false;
    this.batchSize = 100;
    this.batchTimeout = 100; // ms
  }
  
  async start() {
    await this.ws.connect();
    this.ws.onMessage = (data) => {
      this.queueMessage(data);
    };
    
    this.startBatchProcessor();
  }
  
  queueMessage(message) {
    this.messageQueue.push({
      message,
      timestamp: Date.now()
    });
    
    // Process immediately if queue is full
    if (this.messageQueue.length >= this.batchSize) {
      this.processBatch();
    }
  }
  
  startBatchProcessor() {
    setInterval(() => {
      if (this.messageQueue.length > 0 && !this.processing) {
        this.processBatch();
      }
    }, this.batchTimeout);
  }
  
  async processBatch() {
    if (this.processing || this.messageQueue.length === 0) {
      return;
    }
    
    this.processing = true;
    const batch = this.messageQueue.splice(0, this.batchSize);
    
    try {
      await this.processBatchAsync(batch);
    } catch (error) {
      console.error('Error processing batch:', error);
    } finally {
      this.processing = false;
    }
  }
  
  async processBatchAsync(batch) {
    // Process messages in parallel where possible
    const promises = batch.map(item => this.processMessage(item.message));
    await Promise.allSettled(promises);
  }
  
  async processMessage(message) {
    // Your message processing logic
    if (message.method === 'eth_subscription') {
      const subscription = message.params.subscription;
      const result = message.params.result;
      
      // Handle based on subscription type
      this.handleSubscriptionMessage(subscription, result);
    }
  }
  
  handleSubscriptionMessage(subscription, result) {
    // Route to appropriate handler
    console.log(`Processing subscription ${subscription}:`, result);
  }
}

Testing WebSocket Connections

Unit Testing

javascript

// Mock WebSocket for testing
class MockWebSocket {
  constructor(url) {
    this.url = url;
    this.readyState = WebSocket.CONNECTING;
    this.messages = [];
    
    // Simulate connection
    setTimeout(() => {
      this.readyState = WebSocket.OPEN;
      if (this.onopen) this.onopen();
    }, 100);
  }
  
  send(data) {
    this.messages.push(JSON.parse(data));
  }
  
  close() {
    this.readyState = WebSocket.CLOSED;
    if (this.onclose) this.onclose({ code: 1000, reason: 'Normal closure' });
  }
  
  simulateMessage(data) {
    if (this.onmessage) {
      this.onmessage({ data: JSON.stringify(data) });
    }
  }
}
 
// Test example
describe('WebSocket Manager', () => {
  let wsManager;
  let mockWs;
  
  beforeEach(() => {
    global.WebSocket = MockWebSocket;
    wsManager = new Cuckoo NetworkWebSocketManager('wss://test.example.com');
  });
  
  test('should connect and subscribe', async () => {
    await wsManager.connect();
    
    const handler = jest.fn();
    wsManager.subscribe('newHeads', null, handler);
    
    // Simulate subscription confirmation
    mockWs.simulateMessage({
      id: 1,
      result: 'subscription-id-123'
    });
    
    // Simulate new block
    mockWs.simulateMessage({
      method: 'eth_subscription',
      params: {
        subscription: 'subscription-id-123',
        result: { number: '0x123', hash: '0xabc...' }
      }
    });
    
    expect(handler).toHaveBeenCalledWith({ number: '0x123', hash: '0xabc...' });
  });
});

Best Practices

1. Connection Management

Always implement reconnection logic
Use heartbeat/ping to detect connection issues
Handle network interruptions gracefully
Limit concurrent connections

2. Resource Management

Unsubscribe from unused subscriptions
Implement proper cleanup on disconnect
Monitor memory usage for long-running connections
Use connection pooling for multiple subscriptions

3. Error Handling

Implement exponential backoff for reconnections
Log errors for debugging
Handle malformed messages gracefully
Set connection timeouts

4. Performance

Batch process messages when possible
Use appropriate buffer sizes
Implement message filtering client-side
Monitor subscription overhead

5. Security

Validate all incoming data
Use secure WebSocket connections (wss://)
Implement rate limiting
Keep API keys secure

Next Steps

Learn about [Web3.js Integration]./cuckoo-network-web3-integration.md for JavaScript development
Explore [Ethers.js Integration]./cuckoo-network-ethers-integration.md for modern web development
Check out smart contract interaction patterns for advanced use cases
Follow [JSON-RPC API Reference]./cuckoo-network-json-rpc-api.md for low-level operations

Resources

Cost: 300 CUs / req

Why Use WebSockets?​

Advantages over HTTP Polling​

Common Use Cases​

Connection Setup​

WebSocket Endpoints​

Basic Connection​

JavaScript (Browser/Node.js)​

Python​

Go​

Subscription Types​

1. New Block Headers (newHeads)​

2. Pending Transactions (newPendingTransactions)​

3. Smart Contract Events (logs)​

4. Synchronized Blocks (syncing)​

Advanced Usage Patterns​

Managing Multiple Subscriptions​

Real-time Trading Dashboard​

NFT Marketplace Monitor​

Error Handling & Reconnection​

Robust Error Handling​

Performance Optimization​

Efficient Message Processing​

Testing WebSocket Connections​

Unit Testing​

Best Practices​

1. Connection Management​

2. Resource Management​

3. Error Handling​

4. Performance​

5. Security​

Next Steps​

Resources​

One API key for 30+ chains

Why Use WebSockets?

Advantages over HTTP Polling

Common Use Cases

Connection Setup

WebSocket Endpoints

Basic Connection

JavaScript (Browser/Node.js)

Python

Go

Subscription Types

1. New Block Headers (newHeads)

2. Pending Transactions (newPendingTransactions)

3. Smart Contract Events (logs)

4. Synchronized Blocks (syncing)

Advanced Usage Patterns

Managing Multiple Subscriptions

Real-time Trading Dashboard

NFT Marketplace Monitor

Error Handling & Reconnection

Robust Error Handling

Performance Optimization

Efficient Message Processing

Testing WebSocket Connections

Unit Testing

Best Practices

1. Connection Management

2. Resource Management

3. Error Handling

4. Performance

5. Security

Next Steps

Resources