@pioneer-platform/eth-network 8.14.0 → 8.14.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pioneer-platform/eth-network
 
+## 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

package/lib/index.js

@@ -358,23 +358,39 @@ 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}`);
-        // 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);
-        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;
 /**
@@ -689,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
@@ -767,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
@@ -811,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;
 /**
@@ -908,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
@@ -948,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;
 /**
@@ -972,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;
 /**
@@ -1011,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.14.0",
+  "version": "8.14.2",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "scripts": {