@pioneer-platform/eth-network 8.13.16 → 8.14.3

package/.turbo/turbo-build.log

@@ -1,2 +1 @@
-
-$ tsc -p .
+$ tsc -p .

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @pioneer-platform/eth-network
 
+## 8.14.3
+
+### Patch Changes
+
+- fix: Add node racing to all eth-network \*ByNetwork functions
+
+## 8.14.2
+
+### Patch Changes
+
+- fix: Add node racing to all eth-network \*ByNetwork functions
+
+## 8.14.1
+
+### Patch Changes
+
+- cache work
+
+## 8.14.0
+
+### Minor Changes
+
+- Merge branch 'feature/ethereum-reports'
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/blockbook@8.12.0
+
 ## 8.13.16
 
 ### Patch Changes

package/lib/index.d.ts

@@ -18,6 +18,8 @@ export declare const addNode: (node: any) => number;
 export declare const addNodes: (nodeList: any) => void;
 /**
  * Get nonce for address
+ * @deprecated Use getNonceByNetwork instead - this method relies on environment variables
+ * and does not use the node racing/fallback system
  */
 export declare const getNonce: (address: string) => Promise<any>;
 /**
@@ -26,6 +28,8 @@ export declare const getNonce: (address: string) => Promise<any>;
 export declare const getNonceByNetwork: (networkId: string, address: string) => Promise<number>;
 /**
  * Get current gas price
+ * @deprecated Use getGasPriceByNetwork instead - this method relies on environment variables
+ * and does not use the node racing/fallback system
  */
 export declare const getGasPrice: () => Promise<any>;
 /**
@@ -38,10 +42,13 @@ export declare const getGasPriceByNetwork: (networkId: string) => Promise<import
 export declare const estimateFee: (asset: any, params: any) => Promise<any>;
 /**
  * Get ETH balance for address
+ * @deprecated Use getBalanceAddressByNetwork instead - this method relies on environment variables
+ * and does not use the node racing/fallback system with health tracking
  */
 export declare const getBalance: (address: string) => Promise<string>;
 /**
  * Get balances for multiple addresses
+ * @deprecated Use getBalanceAddressByNetwork in a loop instead - this method relies on environment variables
  */
 export declare const getBalances: (addresses: string[]) => Promise<string[]>;
 /**

package/lib/index.js

@@ -64,7 +64,8 @@ const NodeHealth = __importStar(require("./node-health"));
 const log = require('@pioneer-platform/loggerdog')();
 let wait = require('wait-promise');
 let sleep = wait.sleep;
-// Provider instances
+// Legacy provider instances - DEPRECATED, kept for backward compatibility only
+// All production methods should use *ByNetwork variants with node racing
 let ETHERSCAN;
 let PROVIDER;
 let PROVIDER_BASE;
@@ -112,14 +113,14 @@ const TIER_PRIORITY = {
 // - VALIDATE_NODES_ON_STARTUP: Set to 'false' to disable background validation (default: enabled)
 // - STARTUP_NODE_TIMEOUT: Timeout per node in ms (default: 3000)
 // - STARTUP_NODE_CONCURRENCY: Number of parallel validation workers (default: 20)
-// - STARTUP_VALIDATION_TIER: Comma-separated tiers to validate on startup (default: 'premium,reliable')
+// - STARTUP_VALIDATION_TIER: Comma-separated tiers to validate on startup (default: 'premium,reliable,public')
 // - STARTUP_NODE_SAMPLE: Number of random nodes to test per tier (default: 0 = all)
 //
 // Note: Validation runs in background and does NOT block server startup
 const STARTUP_VALIDATION_ENABLED = process.env.VALIDATE_NODES_ON_STARTUP !== 'false'; // Default true
 const STARTUP_VALIDATION_TIMEOUT = parseInt(process.env.STARTUP_NODE_TIMEOUT || '3000'); // 3s timeout
 const STARTUP_VALIDATION_CONCURRENCY = parseInt(process.env.STARTUP_NODE_CONCURRENCY || '20'); // 20 parallel
-const STARTUP_VALIDATION_TIERS = (process.env.STARTUP_VALIDATION_TIER || 'premium,reliable').split(',');
+const STARTUP_VALIDATION_TIERS = (process.env.STARTUP_VALIDATION_TIER || 'premium,reliable,public').split(',');
 const STARTUP_VALIDATION_SAMPLE_SIZE = parseInt(process.env.STARTUP_NODE_SAMPLE || '0'); // 0 = all nodes in tier
 /**
  * Check if a node is marked as dead
@@ -291,26 +292,22 @@ const init = async function (settings, redis) {
             log.error(tag, 'Background node validation failed:', err);
         });
     }
-    if (!settings) {
-        // Use default mainnet
-        PROVIDER = new ethers.providers.JsonRpcProvider(process.env['PARITY_ARCHIVE_NODE'] || 'https://eth.llamarpc.com');
-        PROVIDER_BASE = new ethers.providers.JsonRpcProvider(process.env['BASE_NODE'] || 'https://base.llamarpc.com');
+    // DEPRECATED: Legacy provider initialization for backward compatibility
+    // Modern code should use *ByNetwork methods which leverage the full node racing system
+    // These globals are only initialized for legacy methods (getNonce, getBalance, etc.)
+    // and are NOT used by production endpoints in evm.controller.ts
+    // Only initialize Etherscan for legacy compatibility
+    if (process.env['ETHERSCAN_API_KEY']) {
         ETHERSCAN = new providers_1.EtherscanProvider('mainnet', process.env['ETHERSCAN_API_KEY']);
-        NODE_URL = process.env['PARITY_ARCHIVE_NODE'] || 'https://eth.llamarpc.com';
-    }
-    else if (settings.testnet) {
-        if (!process.env['INFURA_TESTNET_ROPSTEN'])
-            throw Error("Missing INFURA_TESTNET_ROPSTEN");
-        if (!process.env['ETHERSCAN_API_KEY'])
-            throw Error("Missing ETHERSCAN_API_KEY");
-        PROVIDER = new ethers.providers.JsonRpcProvider(process.env['INFURA_TESTNET_ROPSTEN']);
-        NODE_URL = process.env['INFURA_TESTNET_ROPSTEN'];
-        ETHERSCAN = new providers_1.EtherscanProvider('ropsten', process.env['ETHERSCAN_API_KEY']);
-    }
-    else {
-        PROVIDER = new ethers.providers.JsonRpcProvider(process.env['PARITY_ARCHIVE_NODE'] || 'https://eth.llamarpc.com');
     }
+    // REMOVED: PROVIDER, PROVIDER_BASE, NODE_URL initialization
+    // These environment variables are no longer needed because:
+    // 1. All production methods use *ByNetwork variants
+    // 2. Node racing system provides superior reliability and performance
+    // 3. 1200+ validated nodes vs single environment variable endpoint
+    // 4. Automatic failover, health tracking, and tier-based routing
     log.info(tag, 'ETH network module initialized successfully');
+    log.info(tag, '✅ Using node racing system for all operations (no env dependencies)');
 };
 exports.init = init;
 /**
@@ -347,8 +344,12 @@ const addNodes = function (nodeList) {
 exports.addNodes = addNodes;
 /**
  * Get nonce for address
+ * @deprecated Use getNonceByNetwork instead - this method relies on environment variables
+ * and does not use the node racing/fallback system
  */
 const getNonce = async function (address) {
+    if (!PROVIDER)
+        throw Error('PROVIDER not initialized - use getNonceByNetwork instead');
     return await PROVIDER.getTransactionCount(address, 'pending');
 };
 exports.getNonce = getNonce;
@@ -357,23 +358,49 @@ exports.getNonce = getNonce;
  */
 const getNonceByNetwork = async function (networkId, address) {
     let tag = TAG + ' | getNonceByNetwork | ';
-    try {
-        let node = NODES.find((n) => n.networkId === networkId);
-        if (!node)
-            throw Error(`Node not found for networkId: ${networkId}`);
-        const provider = new ethers.providers.JsonRpcProvider(node.service);
-        return await withTimeout(provider.getTransactionCount(address, 'pending'), RPC_TIMEOUT_MS, `Nonce fetch timeout after ${RPC_TIMEOUT_MS}ms`);
+    // Get ALL nodes for this network
+    let nodes = NODES.filter((n) => n.networkId === networkId);
+    if (!nodes || nodes.length === 0) {
+        throw Error(`No nodes found for networkId: ${networkId}`);
     }
-    catch (e) {
-        log.error(tag, e);
-        throw e;
+    // Extract chain ID from networkId (e.g., "eip155:1" -> 1)
+    let chainId;
+    if (networkId.includes(':')) {
+        chainId = parseInt(networkId.split(':')[1]);
     }
+    // Try each node until one succeeds
+    let lastError = null;
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        try {
+            // Use StaticJsonRpcProvider to skip network auto-detection
+            const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
+            const nonce = await withTimeout(provider.getTransactionCount(address, 'pending'), RPC_TIMEOUT_MS, `Nonce fetch timeout after ${RPC_TIMEOUT_MS}ms for ${node.service.substring(0, 50)}`);
+            // Success! Log which node worked (only if not the first one)
+            if (i > 0) {
+                log.info(tag, `Successfully fetched nonce from node ${i + 1}/${nodes.length}: ${node.service.substring(0, 50)}`);
+            }
+            return nonce;
+        }
+        catch (e) {
+            lastError = e;
+            log.warn(tag, `Node ${i + 1}/${nodes.length} failed (${node.service.substring(0, 50)}): ${e.message}`);
+            // Continue to next node
+        }
+    }
+    // All nodes failed
+    log.error(tag, `All ${nodes.length} nodes failed for ${networkId}`);
+    throw lastError || Error(`Failed to get nonce from any node for ${networkId}`);
 };
 exports.getNonceByNetwork = getNonceByNetwork;
 /**
  * Get current gas price
+ * @deprecated Use getGasPriceByNetwork instead - this method relies on environment variables
+ * and does not use the node racing/fallback system
  */
 const getGasPrice = async function () {
+    if (!PROVIDER)
+        throw Error('PROVIDER not initialized - use getGasPriceByNetwork instead');
     return await PROVIDER.getGasPrice();
 };
 exports.getGasPrice = getGasPrice;
@@ -471,9 +498,13 @@ const estimateFee = async function (asset, params) {
 exports.estimateFee = estimateFee;
 /**
  * Get ETH balance for address
+ * @deprecated Use getBalanceAddressByNetwork instead - this method relies on environment variables
+ * and does not use the node racing/fallback system with health tracking
  */
 const getBalance = async function (address) {
     let tag = TAG + ' | getBalance | ';
+    if (!PROVIDER)
+        throw Error('PROVIDER not initialized - use getBalanceAddressByNetwork instead');
     try {
         const balance = await PROVIDER.getBalance(address);
         return ethers.utils.formatEther(balance);
@@ -486,9 +517,12 @@ const getBalance = async function (address) {
 exports.getBalance = getBalance;
 /**
  * Get balances for multiple addresses
+ * @deprecated Use getBalanceAddressByNetwork in a loop instead - this method relies on environment variables
  */
 const getBalances = async function (addresses) {
     let tag = TAG + ' | getBalances | ';
+    if (!PROVIDER)
+        throw Error('PROVIDER not initialized - use getBalanceAddressByNetwork instead');
     try {
         const promises = addresses.map(addr => PROVIDER.getBalance(addr));
         const balances = await Promise.all(promises);
@@ -671,29 +705,40 @@ const getBalanceAddressByNetwork = async function (networkId, address) {
             }
             catch (e) {
                 log.warn(tag, `❌ Node ${batchStartIndex + index + 1}/${nodes.length} failed: ${node.service.substring(0, 50)} - ${e.message}`);
-                // CRITICAL FIX: Don't mark nodes dead for validation errors
-                // Only mark dead for connectivity/timeout issues
+                // CRITICAL FIX: Don't mark nodes dead for validation or SSL errors
+                // Only mark dead for persistent connectivity/timeout issues
                 const isValidationError = e.message && (e.message.includes('invalid address') ||
                     e.message.includes('INVALID_ARGUMENT') ||
                     e.message.includes('bad address checksum'));
-                if (!isValidationError) {
+                const isSSLError = e.message && (e.message.includes('UNABLE_TO_GET_ISSUER_CERT') ||
+                    e.message.includes('certificate') ||
+                    e.message.includes('SSL') ||
+                    e.message.includes('TLS') ||
+                    e.code === 'UNABLE_TO_GET_ISSUER_CERT' ||
+                    e.code === 'CERT_HAS_EXPIRED' ||
+                    e.code === 'SELF_SIGNED_CERT_IN_CHAIN');
+                if (!isValidationError && !isSSLError) {
                     markNodeDead(node.service, node.tier);
                     await NodeHealth.recordFailure(node.service, node.networkId);
                 }
-                else {
+                else if (isValidationError) {
                     log.warn(tag, `Skipping node death marking - validation error (not node's fault)`);
                 }
+                else if (isSSLError) {
+                    log.warn(tag, `Skipping node death marking - SSL/TLS error (might be temporary certificate issue)`);
+                }
                 throw e;
             }
         });
-        // Race this batch - return first successful result
-        try {
-            const winner = await Promise.race(racePromises.map(p => p.catch(e => Promise.reject(e))));
-            return winner.result;
-        }
-        catch (e) {
-            log.warn(tag, `Batch ${Math.floor(batchStartIndex / RACE_BATCH_SIZE) + 1} failed, trying next batch...`);
+        // Use allSettled to let all nodes complete, return first success
+        const results = await Promise.allSettled(racePromises);
+        // Find first successful result
+        const successResult = results.find(r => r.status === 'fulfilled' && r.value.success);
+        if (successResult && successResult.status === 'fulfilled') {
+            return successResult.value.result;
         }
+        // All nodes in this batch failed, try next batch
+        log.warn(tag, `Batch ${Math.floor(batchStartIndex / RACE_BATCH_SIZE) + 1} failed (${results.filter(r => r.status === 'rejected').length}/${results.length} errors), trying next batch...`);
         batchStartIndex += RACE_BATCH_SIZE;
     }
     // All batches failed
@@ -749,21 +794,40 @@ const getBalanceTokenByNetwork = async function (networkId, address, tokenAddres
                 return { success: true, result, nodeUrl: node.service };
             }
             catch (e) {
-                // Mark node as dead and continue
+                // Check error type before marking node dead
                 log.warn(tag, `❌ Node ${batchStartIndex + index + 1}/${nodes.length} failed: ${node.service.substring(0, 50)} - ${e.message}`);
-                markNodeDead(node.service, node.tier);
+                // Don't mark nodes dead for validation or SSL errors
+                const isValidationError = e.message && (e.message.includes('invalid address') ||
+                    e.message.includes('INVALID_ARGUMENT') ||
+                    e.message.includes('bad address checksum'));
+                const isSSLError = e.message && (e.message.includes('UNABLE_TO_GET_ISSUER_CERT') ||
+                    e.message.includes('certificate') ||
+                    e.message.includes('SSL') ||
+                    e.message.includes('TLS') ||
+                    e.code === 'UNABLE_TO_GET_ISSUER_CERT' ||
+                    e.code === 'CERT_HAS_EXPIRED' ||
+                    e.code === 'SELF_SIGNED_CERT_IN_CHAIN');
+                if (!isValidationError && !isSSLError) {
+                    markNodeDead(node.service, node.tier);
+                }
+                else if (isValidationError) {
+                    log.warn(tag, `Skipping node death marking - validation error`);
+                }
+                else if (isSSLError) {
+                    log.warn(tag, `Skipping node death marking - SSL/TLS error (might be temporary)`);
+                }
                 throw e;
             }
         });
-        // Race this batch - return first successful result
-        try {
-            const winner = await Promise.race(racePromises.map(p => p.catch(e => Promise.reject(e))));
-            return winner.result;
-        }
-        catch (e) {
-            // All nodes in this batch failed, try next batch
-            log.warn(tag, `Batch ${Math.floor(batchStartIndex / RACE_BATCH_SIZE) + 1} failed, trying next batch...`);
+        // Use allSettled to let all nodes complete, return first success
+        const results = await Promise.allSettled(racePromises);
+        // Find first successful result
+        const successResult = results.find(r => r.status === 'fulfilled' && r.value.success);
+        if (successResult && successResult.status === 'fulfilled') {
+            return successResult.value.result;
         }
+        // All nodes in this batch failed, try next batch
+        log.warn(tag, `Batch ${Math.floor(batchStartIndex / RACE_BATCH_SIZE) + 1} failed (${results.filter(r => r.status === 'rejected').length}/${results.length} errors), trying next batch...`);
         batchStartIndex += RACE_BATCH_SIZE;
     }
     // All batches failed
@@ -793,27 +857,41 @@ exports.getBalanceTokensByNetwork = getBalanceTokensByNetwork;
  */
 const getTokenDecimalsByNetwork = async function (networkId, tokenAddress) {
     let tag = TAG + ' | getTokenDecimalsByNetwork | ';
-    try {
-        // Find the node for this network
-        let node = NODES.find((n) => n.networkId === networkId);
-        if (!node)
-            throw Error(`Node not found for networkId: ${networkId}`);
-        // Extract chain ID from networkId (e.g., "eip155:1" -> 1)
-        let chainId;
-        if (networkId.includes(':')) {
-            chainId = parseInt(networkId.split(':')[1]);
-        }
-        // Use StaticJsonRpcProvider to skip network auto-detection
-        const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
-        const contract = new ethers.Contract(tokenAddress, ERC20ABI, provider);
-        const decimals = await contract.decimals();
-        // Return as number for easy use
-        return Number(decimals);
+    // Get ALL nodes for this network
+    let nodes = NODES.filter((n) => n.networkId === networkId);
+    if (!nodes || nodes.length === 0) {
+        throw Error(`No nodes found for networkId: ${networkId}`);
     }
-    catch (e) {
-        log.error(tag, 'Failed to fetch decimals for', tokenAddress, 'on', networkId, ':', e);
-        throw e;
+    // Extract chain ID from networkId (e.g., "eip155:1" -> 1)
+    let chainId;
+    if (networkId.includes(':')) {
+        chainId = parseInt(networkId.split(':')[1]);
+    }
+    // Try each node until one succeeds
+    let lastError = null;
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        try {
+            // Use StaticJsonRpcProvider to skip network auto-detection
+            const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
+            const contract = new ethers.Contract(tokenAddress, ERC20ABI, provider);
+            const decimals = await withTimeout(contract.decimals(), RPC_TIMEOUT_MS, `Token decimals fetch timeout after ${RPC_TIMEOUT_MS}ms for ${node.service.substring(0, 50)}`);
+            // Success! Log which node worked (only if not the first one)
+            if (i > 0) {
+                log.info(tag, `Successfully fetched decimals from node ${i + 1}/${nodes.length}: ${node.service.substring(0, 50)}`);
+            }
+            // Return as number for easy use
+            return Number(decimals);
+        }
+        catch (e) {
+            lastError = e;
+            log.warn(tag, `Node ${i + 1}/${nodes.length} failed (${node.service.substring(0, 50)}): ${e.message}`);
+            // Continue to next node
+        }
     }
+    // All nodes failed
+    log.error(tag, `All ${nodes.length} nodes failed for ${networkId}`);
+    throw lastError || Error(`Failed to get token decimals from any node for ${networkId}`);
 };
 exports.getTokenDecimalsByNetwork = getTokenDecimalsByNetwork;
 /**
@@ -890,25 +968,46 @@ const getTokenMetadata = async function (networkId, contractAddress, userAddress
                 return { success: true, result: metadata, nodeUrl: node.service };
             }
             catch (e) {
+                // Check error type before marking node dead
                 log.warn(tag, `❌ Node ${batchStartIndex + index + 1}/${nodes.length} failed: ${node.service.substring(0, 50)} - ${e.message}`);
-                markNodeDead(node.service, node.tier);
+                // Don't mark nodes dead for validation or SSL errors
+                const isValidationError = e.message && (e.message.includes('invalid address') ||
+                    e.message.includes('INVALID_ARGUMENT') ||
+                    e.message.includes('bad address checksum'));
+                const isSSLError = e.message && (e.message.includes('UNABLE_TO_GET_ISSUER_CERT') ||
+                    e.message.includes('certificate') ||
+                    e.message.includes('SSL') ||
+                    e.message.includes('TLS') ||
+                    e.code === 'UNABLE_TO_GET_ISSUER_CERT' ||
+                    e.code === 'CERT_HAS_EXPIRED' ||
+                    e.code === 'SELF_SIGNED_CERT_IN_CHAIN');
+                if (!isValidationError && !isSSLError) {
+                    markNodeDead(node.service, node.tier);
+                }
+                else if (isValidationError) {
+                    log.warn(tag, `Skipping node death marking - validation error`);
+                }
+                else if (isSSLError) {
+                    log.warn(tag, `Skipping node death marking - SSL/TLS error (might be temporary)`);
+                }
                 throw e;
             }
         });
-        // Race this batch - return first successful result
-        try {
-            const winner = await Promise.race(racePromises.map(p => p.catch(e => Promise.reject(e))));
+        // Use allSettled to let all nodes complete, return first success
+        const results = await Promise.allSettled(racePromises);
+        // Find first successful result
+        const successResult = results.find(r => r.status === 'fulfilled' && r.value.success);
+        if (successResult && successResult.status === 'fulfilled') {
             log.info(tag, `Token metadata fetched successfully:`, {
-                name: winner.result.name,
-                symbol: winner.result.symbol,
-                decimals: winner.result.decimals,
-                balance: winner.result.balance
+                name: successResult.value.result.name,
+                symbol: successResult.value.result.symbol,
+                decimals: successResult.value.result.decimals,
+                balance: successResult.value.result.balance
             });
-            return winner.result;
-        }
-        catch (e) {
-            log.warn(tag, `Batch ${Math.floor(batchStartIndex / RACE_BATCH_SIZE) + 1} failed, trying next batch...`);
+            return successResult.value.result;
         }
+        // All nodes in this batch failed, try next batch
+        log.warn(tag, `Batch ${Math.floor(batchStartIndex / RACE_BATCH_SIZE) + 1} failed (${results.filter(r => r.status === 'rejected').length}/${results.length} errors), trying next batch...`);
         batchStartIndex += RACE_BATCH_SIZE;
     }
     // All batches failed
@@ -930,23 +1029,38 @@ exports.getTokenMetadataByNetwork = getTokenMetadataByNetwork;
  */
 const estimateGasByNetwork = async function (networkId, transaction) {
     let tag = TAG + ' | estimateGasByNetwork | ';
-    try {
-        let node = NODES.find((n) => n.networkId === networkId);
-        if (!node)
-            throw Error(`Node not found for networkId: ${networkId}`);
-        // Extract chain ID from networkId
-        let chainId;
-        if (networkId.includes(':')) {
-            chainId = parseInt(networkId.split(':')[1]);
-        }
-        const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
-        const gasEstimate = await provider.estimateGas(transaction);
-        return gasEstimate;
+    // Get ALL nodes for this network
+    let nodes = NODES.filter((n) => n.networkId === networkId);
+    if (!nodes || nodes.length === 0) {
+        throw Error(`No nodes found for networkId: ${networkId}`);
     }
-    catch (e) {
-        log.error(tag, e);
-        throw e;
+    // Extract chain ID from networkId
+    let chainId;
+    if (networkId.includes(':')) {
+        chainId = parseInt(networkId.split(':')[1]);
     }
+    // Try each node until one succeeds
+    let lastError = null;
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        try {
+            const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
+            const gasEstimate = await withTimeout(provider.estimateGas(transaction), RPC_TIMEOUT_MS, `Gas estimate timeout after ${RPC_TIMEOUT_MS}ms for ${node.service.substring(0, 50)}`);
+            // Success! Log which node worked (only if not the first one)
+            if (i > 0) {
+                log.info(tag, `Successfully estimated gas from node ${i + 1}/${nodes.length}: ${node.service.substring(0, 50)}`);
+            }
+            return gasEstimate;
+        }
+        catch (e) {
+            lastError = e;
+            log.warn(tag, `Node ${i + 1}/${nodes.length} failed (${node.service.substring(0, 50)}): ${e.message}`);
+            // Continue to next node
+        }
+    }
+    // All nodes failed
+    log.error(tag, `All ${nodes.length} nodes failed for ${networkId}`);
+    throw lastError || Error(`Failed to estimate gas from any node for ${networkId}`);
 };
 exports.estimateGasByNetwork = estimateGasByNetwork;
 /**
@@ -954,38 +1068,55 @@ exports.estimateGasByNetwork = estimateGasByNetwork;
  */
 const broadcastByNetwork = async function (networkId, signedTx) {
     let tag = TAG + ' | broadcastByNetwork | ';
-    try {
-        let node = NODES.find((n) => n.networkId === networkId);
-        if (!node)
-            throw Error(`Node not found for networkId: ${networkId}`);
-        // Extract chain ID from networkId
-        let chainId;
-        if (networkId.includes(':')) {
-            chainId = parseInt(networkId.split(':')[1]);
-        }
-        const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
-        const result = await provider.sendTransaction(signedTx);
-        // Return in expected format for pioneer-server
-        return {
-            success: true,
-            txid: result.hash,
-            transactionHash: result.hash,
-            from: result.from,
-            to: result.to,
-            nonce: result.nonce,
-            gasLimit: result.gasLimit?.toString(),
-            gasPrice: result.gasPrice?.toString(),
-            chainId: result.chainId
-        };
-    }
-    catch (e) {
-        log.error(tag, e);
-        // Return error format expected by server
+    // Get ALL nodes for this network
+    let nodes = NODES.filter((n) => n.networkId === networkId);
+    if (!nodes || nodes.length === 0) {
         return {
             success: false,
-            error: e.message || e.toString()
+            error: `No nodes found for networkId: ${networkId}`
         };
     }
+    // Extract chain ID from networkId
+    let chainId;
+    if (networkId.includes(':')) {
+        chainId = parseInt(networkId.split(':')[1]);
+    }
+    // Try each node until one succeeds
+    let lastError = null;
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        try {
+            const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
+            const result = await withTimeout(provider.sendTransaction(signedTx), RPC_TIMEOUT_MS, `Broadcast timeout after ${RPC_TIMEOUT_MS}ms for ${node.service.substring(0, 50)}`);
+            // Success! Log which node worked (only if not the first one)
+            if (i > 0) {
+                log.info(tag, `Successfully broadcasted from node ${i + 1}/${nodes.length}: ${node.service.substring(0, 50)}`);
+            }
+            // Return in expected format for pioneer-server
+            return {
+                success: true,
+                txid: result.hash,
+                transactionHash: result.hash,
+                from: result.from,
+                to: result.to,
+                nonce: result.nonce,
+                gasLimit: result.gasLimit?.toString(),
+                gasPrice: result.gasPrice?.toString(),
+                chainId: result.chainId
+            };
+        }
+        catch (e) {
+            lastError = e;
+            log.warn(tag, `Node ${i + 1}/${nodes.length} failed (${node.service.substring(0, 50)}): ${e.message}`);
+            // Continue to next node
+        }
+    }
+    // All nodes failed
+    log.error(tag, `All ${nodes.length} nodes failed for ${networkId}`);
+    return {
+        success: false,
+        error: lastError?.message || `Failed to broadcast from any node for ${networkId}`
+    };
 };
 exports.broadcastByNetwork = broadcastByNetwork;
 /**
@@ -993,25 +1124,40 @@ exports.broadcastByNetwork = broadcastByNetwork;
  */
 const getTransactionByNetwork = async function (networkId, txid) {
     let tag = TAG + ' | getTransactionByNetwork | ';
-    try {
-        let node = NODES.find((n) => n.networkId === networkId);
-        if (!node)
-            throw Error(`Node not found for networkId: ${networkId}`);
-        // Extract chain ID from networkId
-        let chainId;
-        if (networkId.includes(':')) {
-            chainId = parseInt(networkId.split(':')[1]);
-        }
-        const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
-        log.info(tag, `Fetching transaction ${txid} on ${networkId}`);
-        const tx = await provider.getTransaction(txid);
-        const receipt = await provider.getTransactionReceipt(txid);
-        return { tx, receipt };
+    // Get ALL nodes for this network
+    let nodes = NODES.filter((n) => n.networkId === networkId);
+    if (!nodes || nodes.length === 0) {
+        throw Error(`No nodes found for networkId: ${networkId}`);
     }
-    catch (e) {
-        log.error(tag, e);
-        throw e;
+    // Extract chain ID from networkId
+    let chainId;
+    if (networkId.includes(':')) {
+        chainId = parseInt(networkId.split(':')[1]);
     }
+    log.info(tag, `Fetching transaction ${txid} on ${networkId}`);
+    // Try each node until one succeeds
+    let lastError = null;
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        try {
+            const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
+            const tx = await withTimeout(provider.getTransaction(txid), RPC_TIMEOUT_MS, `Get transaction timeout after ${RPC_TIMEOUT_MS}ms for ${node.service.substring(0, 50)}`);
+            const receipt = await withTimeout(provider.getTransactionReceipt(txid), RPC_TIMEOUT_MS, `Get receipt timeout after ${RPC_TIMEOUT_MS}ms for ${node.service.substring(0, 50)}`);
+            // Success! Log which node worked (only if not the first one)
+            if (i > 0) {
+                log.info(tag, `Successfully fetched transaction from node ${i + 1}/${nodes.length}: ${node.service.substring(0, 50)}`);
+            }
+            return { tx, receipt };
+        }
+        catch (e) {
+            lastError = e;
+            log.warn(tag, `Node ${i + 1}/${nodes.length} failed (${node.service.substring(0, 50)}): ${e.message}`);
+            // Continue to next node
+        }
+    }
+    // All nodes failed
+    log.error(tag, `All ${nodes.length} nodes failed for ${networkId}`);
+    throw lastError || Error(`Failed to get transaction from any node for ${networkId}`);
 };
 exports.getTransactionByNetwork = getTransactionByNetwork;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/eth-network",
-  "version": "8.13.16",
+  "version": "8.14.3",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "scripts": {
@@ -18,7 +18,7 @@
     "@ethersproject/abstract-provider": "^5.8.0",
     "@ethersproject/bignumber": "^5.8.0",
     "@ethersproject/providers": "^5.8.0",
-    "@pioneer-platform/blockbook": "^8.11.6",
+    "@pioneer-platform/blockbook": "^8.12.0",
     "@pioneer-platform/loggerdog": "^8.11.0",
     "@pioneer-platform/nodes": "^8.11.10",
     "@pioneer-platform/pioneer-caip": "^9.10.0",