@dignetwork/chia-block-listener 0.1.11 → 0.1.12

package/README.md

@@ -6,11 +6,15 @@ A high-performance Chia blockchain listener for Node.js, built with Rust and NAP
 
 - **Real-time Block Monitoring**: Listen for new blocks as they're produced on the Chia network
 - **Peer Management**: Connect to multiple Chia full nodes simultaneously
+- **Automatic Failover**: Intelligent peer failover with automatic retry across multiple peers
+- **Enhanced Error Handling**: Automatic disconnection of peers that refuse blocks or have protocol errors
 - **Efficient Parsing**: Fast extraction of coin spends, additions, and removals from blocks
 - **Event-Driven Architecture**: TypeScript-friendly event system with full type safety
 - **Transaction Analysis**: Parse CLVM puzzles and solutions from coin spends
-- **Historical Block Access**: Retrieve blocks by height or ranges
+- **Historical Block Access**: Retrieve blocks by height or ranges with automatic load balancing
 - **Connection Pool**: ChiaPeerPool provides automatic load balancing and rate limiting for historical queries
+- **Peak Height Tracking**: Monitor blockchain sync progress across all connected peers
+- **DNS Peer Discovery**: Automatic peer discovery using Chia network DNS introducers
 - **Cross-platform Support**: Works on Windows, macOS, and Linux (x64 and ARM64)
 - **TypeScript Support**: Complete TypeScript definitions with IntelliSense
 
@@ -65,6 +69,30 @@ process.on('SIGINT', () => {
 })
 ```
 
+## Recent Enhancements 🚀
+
+This library includes several powerful enhancements for production use:
+
+### Automatic Failover System
+- **Intelligent Retry Logic**: Automatically tries up to 3 different peers when block requests fail
+- **Smart Peer Selection**: Chooses the best available peer for each request based on response times
+- **Transparent Operation**: Failover happens automatically without user intervention
+
+### Enhanced Error Handling
+- **Protocol Error Detection**: Automatically detects and disconnects peers that refuse blocks or send invalid data
+- **Connection Health Monitoring**: Tracks peer connection health and removes problematic peers
+- **Error Classification**: Distinguishes between temporary issues and permanent peer problems
+
+### Performance Optimizations
+- **Aggressive Rate Limiting**: 50ms rate limiting per peer for maximum throughput
+- **Persistent Connections**: Reuses WebSocket connections for optimal performance
+- **Parallel Processing**: Efficient handling of multiple concurrent block requests
+
+### Developer Experience
+- **camelCase API**: All JavaScript methods use proper camelCase naming conventions
+- **Comprehensive Events**: Detailed event system for monitoring peer lifecycle and errors
+- **TypeScript Support**: Full type safety with complete TypeScript definitions
+
 ## API Reference
 
 ### ChiaBlockListener Class
@@ -130,7 +158,7 @@ Retrieves a range of blocks from a connected peer.
 
 ### ChiaPeerPool Class
 
-The `ChiaPeerPool` provides a managed pool of peer connections for retrieving historical blocks with automatic load balancing and rate limiting.
+The `ChiaPeerPool` provides a managed pool of peer connections for retrieving historical blocks with automatic load balancing and intelligent failover across multiple peers. When a peer fails to provide a block or experiences protocol errors, the pool automatically tries alternative peers and removes problematic peers from the pool.
 
 #### Constructor
 
@@ -320,7 +348,7 @@ interface CoinSpend {
 
 ## ChiaPeerPool Usage
 
-The `ChiaPeerPool` is designed for efficiently retrieving historical blocks with automatic load balancing across multiple peers.
+The `ChiaPeerPool` is designed for efficiently retrieving historical blocks with automatic load balancing and intelligent failover across multiple peers. When a peer fails to provide a block or experiences protocol errors, the pool automatically tries alternative peers and removes problematic peers from the pool.
 
 ### Basic Usage
 
@@ -375,7 +403,7 @@ main().catch(console.error)
 
 #### Rate Limiting
 
-The pool automatically enforces a 500ms rate limit per peer to prevent overwhelming any single node:
+The pool automatically enforces a 50ms rate limit per peer for maximum performance while preventing node overload:
 
 ```javascript
 // Rapid requests are automatically queued and distributed
@@ -385,10 +413,48 @@ for (let i = 5000000; i < 5000100; i++) {
 }
 
 // All requests will be processed efficiently across all peers
+// with automatic load balancing and rate limiting
 const blocks = await Promise.all(promises)
 console.log(`Retrieved ${blocks.length} blocks`)
 ```
 
+#### Automatic Failover and Error Handling
+
+The pool provides robust error handling with automatic failover:
+
+```javascript
+// The pool automatically handles various error scenarios:
+
+// 1. Connection failures - automatically tries other peers
+try {
+  const block = await pool.getBlockByHeight(5000000)
+  console.log(`Retrieved block ${block.height}`)
+} catch (error) {
+  // If all peers fail, you'll get an error after all retry attempts
+  console.error('All peers failed:', error.message)
+}
+
+// 2. Protocol errors - peers that refuse blocks are automatically disconnected
+pool.on('peerDisconnected', (event) => {
+  console.log(`Peer ${event.peerId} disconnected: ${event.reason}`)
+  // Reasons include: "Block request rejected", "Protocol error", "Connection timeout"
+})
+
+// 3. Automatic peer cleanup - problematic peers are removed from the pool
+console.log('Active peers before:', await pool.getConnectedPeers())
+await pool.getBlockByHeight(5000000) // May trigger peer removal
+console.log('Active peers after:', await pool.getConnectedPeers())
+
+// 4. Multiple retry attempts - tries up to 3 different peers per request
+// This happens automatically and transparently
+const block = await pool.getBlockByHeight(5000000) // Will try multiple peers if needed
+```
+
+**Error Types Handled Automatically:**
+- **Connection Errors**: Timeouts, network failures, WebSocket errors
+- **Protocol Errors**: Block rejections, parsing failures, handshake failures
+- **Peer Misbehavior**: Unexpected responses, invalid data formats
+
 #### Dynamic Peer Management
 
 ```javascript
@@ -510,14 +576,14 @@ listener.on('blockReceived', (block: BlockReceivedEvent) => {
   console.log(`Block ${block.height} from peer ${block.peerId}`)
   
   // Process coin additions
-  block.coin_additions.forEach((coin: CoinRecord) => {
+  block.coinAdditions.forEach((coin: CoinRecord) => {
     console.log(`New coin: ${coin.amount} mojos`)
   })
   
   // Process coin spends
-  block.coin_spends.forEach((spend: CoinSpend) => {
+  block.coinSpends.forEach((spend: CoinSpend) => {
     console.log(`Spend: ${spend.coin.amount} mojos`)
-    console.log(`Puzzle: ${spend.puzzle_reveal}`)
+    console.log(`Puzzle: ${spend.puzzleReveal}`)
     console.log(`Solution: ${spend.solution}`)
   })
 })
@@ -541,7 +607,7 @@ const testnetPeer = listener.addPeer('testnet-node.chia.net', 58444, 'testnet')
 async function getHistoricalBlocks() {
   try {
     const block = listener.getBlockByHeight(mainnetPeer, 1000000)
-    console.log(`Block 1000000 hash: ${block.header_hash}`)
+    console.log(`Block 1000000 hash: ${block.headerHash}`)
     
     const blocks = listener.getBlocksRange(mainnetPeer, 1000000, 1000010)
     console.log(`Retrieved ${blocks.length} blocks`)
@@ -587,8 +653,8 @@ async function fetchHistoricalData() {
 listener.on('blockReceived', (block) => {
   const targetPuzzleHash = '0x1234...' // Your puzzle hash
   
-  block.coin_spends.forEach((spend) => {
-    if (spend.coin.puzzle_hash === targetPuzzleHash) {
+  block.coinSpends.forEach((spend) => {
+    if (spend.coin.puzzleHash === targetPuzzleHash) {
       console.log('Found spend for our puzzle!')
       console.log('Amount:', spend.coin.amount)
       console.log('Solution:', spend.solution)

package/examples/basic-connection-test.js

@@ -0,0 +1,55 @@
+const { ChiaPeerPool } = require('../index.js');
+
+// Enable debug logging to see what's happening
+process.env.RUST_LOG = 'chia_block_listener=debug';
+
+async function basicConnectionTest() {
+  const pool = new ChiaPeerPool();
+  
+  try {
+    console.log('🔍 Basic Connection Test');
+    console.log('=======================\n');
+    
+    // Test with a single known-good peer
+    console.log('Testing connection to a reliable peer...');
+    
+    try {
+      console.log('1. Attempting to add peer...');
+      const peerId = await pool.addPeer('185.69.164.168', 8444, 'mainnet');
+      console.log(`✅ Peer added successfully: ${peerId}`);
+      
+      console.log('2. Waiting for connection to stabilize...');
+      await new Promise(resolve => setTimeout(resolve, 3000));
+      
+      const connectedPeers = await pool.getConnectedPeers();
+      console.log(`✅ Connected peers: ${connectedPeers.length}`);
+      
+      if (connectedPeers.length > 0) {
+        console.log('3. Attempting block request...');
+        
+        try {
+          const block = await pool.getBlockByHeight(3200000);
+          console.log(`✅ Block request successful! Height: ${block.height}`);
+        } catch (blockError) {
+          console.log(`❌ Block request failed: ${blockError.message}`);
+          console.log('This suggests connection establishment worked but block fetching failed');
+        }
+      } else {
+        console.log('❌ No connected peers - connection establishment failed');
+      }
+      
+    } catch (peerError) {
+      console.log(`❌ Failed to add peer: ${peerError.message}`);
+      console.log('This suggests the initial connection setup is failing');
+    }
+    
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+  } finally {
+    console.log('\n🛑 Shutting down...');
+    await pool.shutdown();
+    console.log('✅ Test complete');
+  }
+}
+
+basicConnectionTest().catch(console.error); 

package/examples/block-refusal-test.js

@@ -0,0 +1,251 @@
+const { ChiaPeerPool } = require('../index.js');
+const dns = require('dns').promises;
+
+// DNS introducers for peer discovery
+const MAINNET_DNS_INTRODUCERS = [
+    "dns-introducer.chia.net",
+    "chia.ctrlaltdel.ch", 
+    "seeder.dexie.space",
+    "chia.hoffmang.com"
+];
+
+const MAINNET_DEFAULT_PORT = 8444;
+
+// Shuffle array for randomness
+function shuffleArray(array) {
+    const shuffled = [...array];
+    for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    return shuffled;
+}
+
+// Discover actual peer IPs using DNS introducers
+async function discoverPeers(networkId = 'mainnet') {
+    console.log(`🔍 Discovering peers for ${networkId} using DNS introducers...`);
+    
+    let allAddresses = [];
+    
+    // Resolve all introducers to IP addresses
+    for (const introducer of MAINNET_DNS_INTRODUCERS) {
+        try {
+            console.log(`   Resolving ${introducer}...`);
+            const addresses = await dns.lookup(introducer, { all: true });
+            for (const addr of addresses) {
+                allAddresses.push({ 
+                    host: addr.address, 
+                    port: MAINNET_DEFAULT_PORT,
+                    family: addr.family,
+                    source: introducer
+                });
+            }
+            console.log(`   Found ${addresses.length} peers from ${introducer}`);
+        } catch (error) {
+            console.log(`   Failed to resolve ${introducer}: ${error.message}`);
+        }
+    }
+
+    if (allAddresses.length === 0) {
+        throw new Error('Failed to resolve any peer addresses from introducers');
+    }
+
+    // Remove duplicates and shuffle
+    const uniqueAddresses = [];
+    const seen = new Set();
+    for (const addr of allAddresses) {
+        const key = `${addr.host}:${addr.port}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            uniqueAddresses.push(addr);
+        }
+    }
+    
+    return shuffleArray(uniqueAddresses);
+}
+
+// Format address for display (IPv6 needs brackets in URLs)
+function formatAddress(host, port, family) {
+    if (family === 6) {
+        return `[${host}]:${port}`;
+    }
+    return `${host}:${port}`;
+}
+
+async function testBlockRefusalHandling() {
+    console.log('🚫 Testing Block Refusal and Automatic Peer Disconnection');
+    console.log('='.repeat(60));
+    
+    const pool = new ChiaPeerPool();
+    
+    let disconnectedPeers = [];
+    let connectedPeers = [];
+    
+    // Set up event handlers to monitor peer lifecycle
+    pool.on('peerConnected', (event) => {
+        connectedPeers.push(`${event.host}:${event.port}`);
+        console.log(`✅ Peer connected: ${event.host}:${event.port}`);
+    });
+    
+    pool.on('peerDisconnected', (event) => {
+        const peerAddr = `${event.host}:${event.port}`;
+        disconnectedPeers.push(peerAddr);
+        console.log(`❌ Peer disconnected: ${peerAddr} - ${event.reason || 'Unknown reason'}`);
+    });
+    
+    try {
+        console.log('\n1️⃣ Discovering and connecting to peers...');
+        
+        // Discover actual peer IPs
+        const discoveredPeers = await discoverPeers('mainnet');
+        
+        // Try to connect to several peers
+        const peersToTry = discoveredPeers.slice(0, 8);
+        let successfulConnections = 0;
+        
+        for (const peer of peersToTry) {
+            const displayAddress = formatAddress(peer.host, peer.port, peer.family);
+            try {
+                await pool.addPeer(peer.host, peer.port, 'mainnet');
+                successfulConnections++;
+                console.log(`   ✅ Connected: ${displayAddress}`);
+                
+                // Stop once we have enough peers for testing
+                if (successfulConnections >= 4) {
+                    break;
+                }
+            } catch (error) {
+                console.log(`   ❌ Failed: ${displayAddress} - ${error.message}`);
+            }
+        }
+        
+        console.log(`\n📊 Connected to ${successfulConnections} peers`);
+        
+        if (successfulConnections === 0) {
+            console.log('❌ No peers connected. Cannot test block refusal handling.');
+            return;
+        }
+        
+        // Wait for connections to stabilize
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
+        console.log('\n2️⃣ Testing block requests to identify problematic peers...');
+        
+        // Test with a series of block heights to see if any peers refuse
+        const testHeights = [4920000, 4920001, 4920002, 4920003, 4920004];
+        let requestCount = 0;
+        let successCount = 0;
+        let errorPatterns = new Map();
+        
+        for (const height of testHeights) {
+            console.log(`\nTesting block ${height}...`);
+            const startTime = Date.now();
+            requestCount++;
+            
+            try {
+                const block = await pool.getBlockByHeight(height);
+                const duration = Date.now() - startTime;
+                successCount++;
+                console.log(`   ✅ Success: Got block in ${duration}ms (${block.transactions?.length || 0} transactions)`);
+            } catch (error) {
+                const duration = Date.now() - startTime;
+                console.log(`   ❌ Failed after ${duration}ms: ${error.message}`);
+                
+                // Track error patterns
+                const errorType = error.message.includes('rejected') ? 'Block Rejected' :
+                                 error.message.includes('Protocol') ? 'Protocol Error' :
+                                 error.message.includes('timeout') ? 'Timeout' :
+                                 error.message.includes('Connection') ? 'Connection Error' :
+                                 'Other';
+                
+                errorPatterns.set(errorType, (errorPatterns.get(errorType) || 0) + 1);
+            }
+            
+            // Check current peer status
+            const currentPeers = await pool.getConnectedPeers();
+            console.log(`   🔗 Active peers: ${currentPeers.length}`);
+        }
+        
+        console.log('\n3️⃣ Testing parallel requests to stress test error handling...');
+        
+        const parallelPromises = [];
+        const parallelHeights = [4920005, 4920006, 4920007, 4920008, 4920009];
+        
+        for (const height of parallelHeights) {
+            parallelPromises.push(
+                pool.getBlockByHeight(height)
+                    .then(block => ({
+                        height,
+                        success: true,
+                        transactions: block.transactions?.length || 0
+                    }))
+                    .catch(error => ({
+                        height,
+                        success: false,
+                        error: error.message
+                    }))
+            );
+        }
+        
+        console.log('   Launching 5 parallel requests...');
+        const parallelResults = await Promise.all(parallelPromises);
+        
+        let parallelSuccessCount = 0;
+        parallelResults.forEach(result => {
+            if (result.success) {
+                parallelSuccessCount++;
+                console.log(`   ✅ Block ${result.height}: ${result.transactions} transactions`);
+            } else {
+                console.log(`   ❌ Block ${result.height}: ${result.error}`);
+            }
+        });
+        
+        // Final status check
+        const finalPeers = await pool.getConnectedPeers();
+        
+        console.log('\n4️⃣ Test Results Summary');
+        console.log('='.repeat(40));
+        console.log(`📊 Sequential requests: ${successCount}/${requestCount} successful`);
+        console.log(`📊 Parallel requests: ${parallelSuccessCount}/${parallelResults.length} successful`);
+        console.log(`🔗 Initial peers: ${connectedPeers.length}`);
+        console.log(`🔗 Final peers: ${finalPeers.length}`);
+        console.log(`❌ Disconnected peers: ${disconnectedPeers.length}`);
+        
+        if (errorPatterns.size > 0) {
+            console.log('\n📈 Error Pattern Analysis:');
+            for (const [errorType, count] of errorPatterns.entries()) {
+                console.log(`   ${errorType}: ${count} occurrences`);
+            }
+        }
+        
+        if (disconnectedPeers.length > 0) {
+            console.log('\n🚫 Disconnected Peers:');
+            disconnectedPeers.forEach((peer, index) => {
+                console.log(`   ${index + 1}. ${peer}`);
+            });
+        }
+        
+        console.log('\n✅ Key Features Demonstrated:');
+        console.log('• ✅ Automatic peer discovery using DNS introducers');
+        console.log('• ✅ Detection of peers that refuse to provide blocks');
+        console.log('• ✅ Automatic disconnection of problematic peers');
+        console.log('• ✅ Failover to working peers when others fail');
+        console.log('• ✅ Protocol error handling (block rejections, parsing errors)');
+        console.log('• ✅ Connection error handling (timeouts, network issues)');
+        
+    } catch (error) {
+        console.error('❌ Test error:', error);
+    } finally {
+        console.log('\n🔄 Shutting down...');
+        await pool.shutdown();
+        console.log('✅ Test completed.');
+    }
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+    console.log('\n\n⚠️  Received interrupt signal, shutting down gracefully...');
+    process.exit(0);
+});
+
+testBlockRefusalHandling().catch(console.error); 

package/examples/failover-demo.js

@@ -0,0 +1,225 @@
+const { ChiaPeerPool } = require('../index.js');
+const dns = require('dns').promises;
+
+// DNS introducers for peer discovery
+const MAINNET_DNS_INTRODUCERS = [
+    "dns-introducer.chia.net",
+    "chia.ctrlaltdel.ch", 
+    "seeder.dexie.space",
+    "chia.hoffmang.com"
+];
+
+const MAINNET_DEFAULT_PORT = 8444;
+
+// Shuffle array for randomness
+function shuffleArray(array) {
+    const shuffled = [...array];
+    for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    return shuffled;
+}
+
+// Discover actual peer IPs using DNS introducers
+async function discoverPeers(networkId = 'mainnet') {
+    const introducers = MAINNET_DNS_INTRODUCERS;
+    const defaultPort = MAINNET_DEFAULT_PORT;
+
+    console.log(`🔍 Discovering peers for ${networkId} using DNS introducers...`);
+    
+    let allAddresses = [];
+    
+    // Resolve all introducers to IP addresses
+    for (const introducer of introducers) {
+        try {
+            console.log(`   Resolving ${introducer}...`);
+            const addresses = await dns.lookup(introducer, { all: true });
+            for (const addr of addresses) {
+                // Store the address with family information for proper handling
+                allAddresses.push({ 
+                    host: addr.address, 
+                    port: defaultPort,
+                    family: addr.family, // 4 for IPv4, 6 for IPv6
+                    source: introducer
+                });
+            }
+            console.log(`   Found ${addresses.length} peers from ${introducer}`);
+        } catch (error) {
+            console.log(`   Failed to resolve ${introducer}: ${error.message}`);
+        }
+    }
+
+    if (allAddresses.length === 0) {
+        throw new Error('Failed to resolve any peer addresses from introducers');
+    }
+
+    // Shuffle for randomness and remove duplicates
+    const uniqueAddresses = [];
+    const seen = new Set();
+    for (const addr of allAddresses) {
+        const key = `${addr.host}:${addr.port}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            uniqueAddresses.push(addr);
+        }
+    }
+    
+    const shuffledAddresses = shuffleArray(uniqueAddresses);
+    console.log(`   Total unique peers discovered: ${shuffledAddresses.length}`);
+    
+    return shuffledAddresses;
+}
+
+// Format address for display (IPv6 needs brackets in URLs)
+function formatAddress(host, port, family) {
+    if (family === 6) {
+        return `[${host}]:${port}`;
+    }
+    return `${host}:${port}`;
+}
+
+async function demonstrateFailover() {
+    console.log('🔄 Demonstrating Automatic Failover Functionality');
+    console.log('='.repeat(50));
+    
+    const pool = new ChiaPeerPool();
+    
+    // Set up event handlers to monitor peer lifecycle
+    pool.on('peerConnected', (event) => {
+        console.log(`✅ Peer connected: ${event.host}:${event.port}`);
+    });
+    
+    pool.on('peerDisconnected', (event) => {
+        console.log(`❌ Peer disconnected: ${event.host}:${event.port} - ${event.reason}`);
+    });
+    
+    try {
+        console.log('\n1️⃣ Discovering peers using DNS introducers...');
+        
+        // Discover actual peer IPs
+        const discoveredPeers = await discoverPeers('mainnet');
+        
+        // Take first 6 peers: some may work, some may fail
+        const peersToTry = discoveredPeers.slice(0, 6);
+        
+        console.log(`\n2️⃣ Adding discovered peers to pool...`);
+        let connectedCount = 0;
+        
+        for (const peer of peersToTry) {
+            const displayAddress = formatAddress(peer.host, peer.port, peer.family);
+            try {
+                await pool.addPeer(peer.host, peer.port, 'mainnet');
+                connectedCount++;
+                console.log(`   ✅ Successfully added: ${displayAddress} (from ${peer.source})`);
+            } catch (error) {
+                console.log(`   ❌ Failed to add: ${displayAddress} - ${error.message}`);
+            }
+        }
+        
+        console.log(`\n📊 Result: ${connectedCount}/${peersToTry.length} peers connected`);
+        
+        if (connectedCount === 0) {
+            console.log('❌ No peers connected. Cannot demonstrate failover.');
+            return;
+        }
+        
+        // Wait for connections to stabilize
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
+        console.log('\n3️⃣ Testing automatic failover...');
+        console.log('The system will try multiple peers if one fails.\n');
+        
+        // Test with a known good block height
+        const testHeight = 4920000;
+        const attempts = 3;
+        
+        for (let i = 1; i <= attempts; i++) {
+            console.log(`Attempt ${i}: Requesting block ${testHeight + i - 1}...`);
+            const startTime = Date.now();
+            
+            try {
+                const block = await pool.getBlockByHeight(testHeight + i - 1);
+                const duration = Date.now() - startTime;
+                
+                console.log(`   ✅ Success! Got block in ${duration}ms`);
+                console.log(`   📊 Block info: ${block.transactions?.length || 0} transactions`);
+                
+                // Check which peer provided the block
+                const currentPeers = await pool.getConnectedPeers();
+                console.log(`   🔗 Available peers: ${currentPeers.length}`);
+                
+            } catch (error) {
+                const duration = Date.now() - startTime;
+                console.log(`   ❌ Failed after ${duration}ms: ${error.message}`);
+                
+                // Show remaining peers after failure
+                const remainingPeers = await pool.getConnectedPeers();
+                console.log(`   🔗 Remaining peers: ${remainingPeers.length}`);
+            }
+            
+            console.log('');
+        }
+        
+        console.log('4️⃣ Testing rapid parallel requests (stress test)...');
+        
+        const parallelRequests = [];
+        const baseHeight = 4920000;
+        
+        for (let i = 0; i < 5; i++) {
+            const height = baseHeight + i;
+            parallelRequests.push(
+                pool.getBlockByHeight(height)
+                    .then(block => ({
+                        height,
+                        success: true,
+                        transactions: block.transactions?.length || 0,
+                        duration: 'N/A' // Duration tracking would require more complex logic
+                    }))
+                    .catch(error => ({
+                        height,
+                        success: false,
+                        error: error.message
+                    }))
+            );
+        }
+        
+        console.log('   Launching 5 parallel requests...');
+        const results = await Promise.all(parallelRequests);
+        
+        let successCount = 0;
+        results.forEach(result => {
+            if (result.success) {
+                successCount++;
+                console.log(`   ✅ Block ${result.height}: ${result.transactions} transactions`);
+            } else {
+                console.log(`   ❌ Block ${result.height}: ${result.error}`);
+            }
+        });
+        
+        console.log(`\n📊 Parallel test results: ${successCount}/${results.length} successful`);
+        
+        console.log('\n✅ Failover demonstration completed!');
+        console.log('\nKey points demonstrated:');
+        console.log('• ✅ DNS introducers used to discover actual peer IPs');
+        console.log('• ✅ Failed peers are automatically rejected during connection');
+        console.log('• ✅ Block requests succeed even with some failed peers');
+        console.log('• ✅ System handles parallel requests efficiently');
+        console.log('• ✅ Automatic failover works transparently to the user');
+        
+    } catch (error) {
+        console.error('❌ Test error:', error);
+    } finally {
+        console.log('\n🔄 Shutting down...');
+        await pool.shutdown();
+        console.log('✅ Shutdown complete.');
+    }
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+    console.log('\n\n⚠️  Received interrupt signal, shutting down gracefully...');
+    process.exit(0);
+});
+
+demonstrateFailover().catch(console.error);