@pioneer-platform/eth-network 8.16.0 → 8.19.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @pioneer-platform/eth-network
 
+## 8.19.0
+
+### Minor Changes
+
+- chore: chore: chore: chore: feat(pioneer): implement end-to-end Solana transaction signing
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/blockbook@8.16.0
+  - @pioneer-platform/pioneer-caip@9.15.0
+  - @pioneer-platform/nodes@8.15.0
+
+## 8.18.0
+
+### Minor Changes
+
+- chore: chore: chore: feat(pioneer): implement end-to-end Solana transaction signing
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/blockbook@8.15.0
+  - @pioneer-platform/pioneer-caip@9.14.0
+  - @pioneer-platform/nodes@8.14.0
+
+## 8.17.0
+
+### Minor Changes
+
+- chore: chore: feat(pioneer): implement end-to-end Solana transaction signing
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/blockbook@8.14.0
+  - @pioneer-platform/pioneer-caip@9.13.0
+  - @pioneer-platform/nodes@8.13.0
+
 ## 8.16.0
 
 ### Minor Changes

package/lib/index.d.ts

@@ -162,8 +162,19 @@ export declare const broadcastByNetwork: (networkId: string, signedTx: string) =
  * Get transaction by network and txid
  */
 export declare const getTransactionByNetwork: (networkId: string, txid: string) => Promise<{
+    error: boolean;
+    errorType: string;
+    message: string;
+    networkId: string;
+    tx?: undefined;
+    receipt?: undefined;
+} | {
     tx: ethers.ethers.providers.TransactionResponse;
     receipt: ethers.ethers.providers.TransactionReceipt;
+    error?: undefined;
+    errorType?: undefined;
+    message?: undefined;
+    networkId?: undefined;
 }>;
 /**
  * Get transaction history by network

package/lib/index.js

@@ -76,7 +76,7 @@ let BASE = 1000000000000000000;
 // - ETH_RPC_TIMEOUT: Timeout for RPC calls in ms (default: 30000)
 // - ETH_DEAD_NODE_TTL: Time before retrying dead nodes in ms (default: 300000 = 5 min)
 // - ETH_RACE_BATCH_SIZE: Number of nodes to try in parallel (default: 3)
-const RPC_TIMEOUT_MS = parseInt(process.env.ETH_RPC_TIMEOUT || '30000'); // 30 second timeout for RPC calls (increased from 10s)
+const RPC_TIMEOUT_MS = parseInt(process.env.ETH_RPC_TIMEOUT || '5000'); // 5 second timeout for RPC calls (reduced from 30s for faster fallback)
 /**
  * Wrap a promise with a timeout
  * @param promise Promise to wrap
@@ -101,10 +101,12 @@ const ERC20ABI = [
 ];
 // Node registry
 let NODES = [];
-// Dead node tracker - nodes that failed recently (service URL -> timestamp)
+// Dead node tracker - nodes that failed recently (service URL -> { timestamp, ttl })
 const DEAD_NODES = new Map();
 const DEAD_NODE_TTL_MS = parseInt(process.env.ETH_DEAD_NODE_TTL || '300000'); // 5 minutes before retry
-const RACE_BATCH_SIZE = parseInt(process.env.ETH_RACE_BATCH_SIZE || '5'); // Try 5 premium/reliable nodes first (increased from 3)
+const RACE_BATCH_SIZE = parseInt(process.env.ETH_RACE_BATCH_SIZE || '1'); // Try 1 node at a time (SEQUENTIAL, not parallel racing)
+// NOTE: Changed from 5 to 1 to reduce API request load by 80%
+// Fast timeout (500ms) ensures quick fallback if node is slow/down
 // Node tier priority (lower = higher priority)
 const TIER_PRIORITY = {
     premium: 1,
@@ -121,72 +123,113 @@ const TIER_PRIORITY = {
 // - 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_ENABLED = process.env.VALIDATE_NODES_ON_STARTUP === 'true'; // Default FALSE (changed to reduce startup API load)
+const STARTUP_VALIDATION_TIMEOUT = parseInt(process.env.STARTUP_NODE_TIMEOUT || '10000'); // 10s timeout (increased from 3s to avoid false positives)
+const STARTUP_VALIDATION_CONCURRENCY = parseInt(process.env.STARTUP_NODE_CONCURRENCY || '5'); // 5 parallel (reduced from 20 to avoid rate limiting)
 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
+const STARTUP_DEAD_NODE_TTL_MS = parseInt(process.env.STARTUP_DEAD_NODE_TTL || '60000'); // 1min TTL for startup failures (vs 5min for runtime)
 /**
  * Check if a node is marked as dead
  */
 const isNodeDead = (nodeUrl) => {
-    const deathTime = DEAD_NODES.get(nodeUrl);
-    if (!deathTime)
+    const entry = DEAD_NODES.get(nodeUrl);
+    if (!entry)
         return false;
-    // Check if TTL expired
-    if (Date.now() - deathTime > DEAD_NODE_TTL_MS) {
+    // Check if TTL expired (using node-specific TTL)
+    if (Date.now() - entry.timestamp > entry.ttl) {
         DEAD_NODES.delete(nodeUrl);
         return false;
     }
     return true;
 };
 /**
- * Mark a node as dead
+ * Mark a node as dead with optional custom TTL
  * Only logs at WARN level for premium/reliable nodes, DEBUG for others
+ * @param nodeUrl Node service URL
+ * @param tier Node tier (for logging)
+ * @param customTTL Optional custom TTL in ms (defaults to DEAD_NODE_TTL_MS)
  */
-const markNodeDead = (nodeUrl, tier) => {
-    DEAD_NODES.set(nodeUrl, Date.now());
+const markNodeDead = (nodeUrl, tier, customTTL) => {
+    // Use custom TTL if provided, otherwise use default
+    const ttl = customTTL || DEAD_NODE_TTL_MS;
+    DEAD_NODES.set(nodeUrl, { timestamp: Date.now(), ttl });
     // Only log failures for premium/reliable nodes (reduces spam)
+    const ttlMinutes = Math.round(ttl / 1000 / 60);
     if (tier === 'premium' || tier === 'reliable') {
-        log.warn(TAG + ' | markNodeDead | ', `⚠️  ${tier} node failed: ${nodeUrl.substring(0, 50)}...`);
+        log.warn(TAG + ' | markNodeDead | ', `⚠️  ${tier} node failed: ${nodeUrl.substring(0, 50)}... (dead for ${ttlMinutes}min)`);
     }
     else {
-        log.debug(TAG + ' | markNodeDead | ', `Public/untrusted node failed: ${nodeUrl.substring(0, 50)}...`);
+        log.debug(TAG + ' | markNodeDead | ', `Public/untrusted node failed: ${nodeUrl.substring(0, 50)}... (dead for ${ttlMinutes}min)`);
     }
 };
 /**
- * Quick health check for a single node
+ * Quick health check for a single node with retry logic and smart error filtering
  * @param node Node to test
  * @param timeout Timeout in ms
+ * @param maxRetries Maximum number of retry attempts (default: 2)
  * @returns true if healthy, false otherwise
  */
-const quickNodeHealthCheck = async (node, timeout = STARTUP_VALIDATION_TIMEOUT) => {
-    try {
-        // Extract chain ID from networkId (e.g., "eip155:1" -> 1)
-        let chainId;
-        if (node.networkId.includes(':')) {
-            chainId = parseInt(node.networkId.split(':')[1]);
+const quickNodeHealthCheck = async (node, timeout = STARTUP_VALIDATION_TIMEOUT, maxRetries = 2) => {
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            // Exponential backoff between retries (0ms, 500ms, 1000ms)
+            if (attempt > 0) {
+                await new Promise(resolve => setTimeout(resolve, attempt * 500));
+            }
+            // Extract chain ID from networkId (e.g., "eip155:1" -> 1)
+            let chainId;
+            if (node.networkId.includes(':')) {
+                chainId = parseInt(node.networkId.split(':')[1]);
+            }
+            // Create provider with timeout
+            const provider = new ethers.providers.JsonRpcProvider({
+                url: node.service,
+                timeout,
+            });
+            // Race between chainId check and timeout
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), timeout));
+            const network = await Promise.race([
+                provider.getNetwork(),
+                timeoutPromise,
+            ]);
+            // Verify chain ID matches if expected
+            if (chainId && network.chainId !== chainId) {
+                return false;
+            }
+            return true; // Success!
         }
-        // Create provider with timeout
-        const provider = new ethers.providers.JsonRpcProvider({
-            url: node.service,
-            timeout,
-        });
-        // Race between chainId check and timeout
-        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), timeout));
-        const network = await Promise.race([
-            provider.getNetwork(),
-            timeoutPromise,
-        ]);
-        // Verify chain ID matches if expected
-        if (chainId && network.chainId !== chainId) {
-            return false;
+        catch (e) {
+            lastError = e;
+            // Check if this is a temporary/ignorable error
+            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.message.includes('CERT_HAS_EXPIRED') ||
+                e.message.includes('SELF_SIGNED_CERT_IN_CHAIN') ||
+                e.code === 'UNABLE_TO_GET_ISSUER_CERT' ||
+                e.code === 'CERT_HAS_EXPIRED' ||
+                e.code === 'SELF_SIGNED_CERT_IN_CHAIN');
+            const isRateLimit = e.message && (e.message.includes('rate limit') ||
+                e.message.includes('too many requests') ||
+                e.message.includes('429'));
+            const isDNSError = e.message && (e.message.includes('ENOTFOUND') ||
+                e.message.includes('ECONNREFUSED') ||
+                e.message.includes('getaddrinfo'));
+            // Don't retry for permanent failures
+            if (!isSSLError && !isRateLimit && !isDNSError && e.message && e.message.includes('invalid')) {
+                return false; // Permanent failure (wrong chain, etc)
+            }
+            // For temporary errors, continue to next retry attempt
+            if (attempt < maxRetries) {
+                continue;
+            }
         }
-        return true;
-    }
-    catch (e) {
-        return false;
     }
+    // All retries exhausted
+    return false;
 };
 /**
  * Validate nodes on startup
@@ -241,7 +284,8 @@ const validateNodesOnStartup = async () => {
                 const isHealthy = await quickNodeHealthCheck(node, STARTUP_VALIDATION_TIMEOUT);
                 completed++;
                 if (!isHealthy) {
-                    markNodeDead(node.service, node.tier);
+                    // Use shorter TTL for startup failures (1min vs 5min for runtime)
+                    markNodeDead(node.service, node.tier, STARTUP_DEAD_NODE_TTL_MS);
                     dead++;
                     tierStats[tier].dead++;
                 }
@@ -261,7 +305,7 @@ const validateNodesOnStartup = async () => {
         .join(', ');
     log.info(tag, `✅ Validation complete: ${healthy}/${nodesToTest.length} healthy (${healthyPercent}%) in ${elapsed}ms | ${tierSummary}`);
     if (dead > 0) {
-        log.info(tag, `Marked ${dead} nodes as dead - will skip for ${DEAD_NODE_TTL_MS / 1000 / 60}min`);
+        log.info(tag, `Marked ${dead} nodes as dead - will skip for ${STARTUP_DEAD_NODE_TTL_MS / 1000 / 60}min (startup TTL)`);
     }
     if (healthy === 0) {
         log.error(tag, '❌ No healthy nodes found! Network operations may fail');
@@ -1288,7 +1332,14 @@ const getTransactionByNetwork = async function (networkId, txid) {
     // 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}`);
+        log.warn(tag, `No nodes found for networkId: ${networkId} - network may be offline or not supported`);
+        // Return error object instead of throwing - allows caller to handle gracefully
+        return {
+            error: true,
+            errorType: 'NO_NODES_FOUND',
+            message: `No nodes found for networkId: ${networkId}`,
+            networkId
+        };
     }
     // Extract chain ID from networkId
     let chainId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/eth-network",
-  "version": "8.16.0",
+  "version": "8.19.0",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "scripts": {
@@ -18,10 +18,10 @@
     "@ethersproject/abstract-provider": "^5.8.0",
     "@ethersproject/bignumber": "^5.8.0",
     "@ethersproject/providers": "^5.8.0",
-    "@pioneer-platform/blockbook": "^8.13.0",
+    "@pioneer-platform/blockbook": "^8.16.0",
     "@pioneer-platform/loggerdog": "^8.11.0",
-    "@pioneer-platform/nodes": "^8.12.0",
-    "@pioneer-platform/pioneer-caip": "^9.12.0",
+    "@pioneer-platform/nodes": "^8.15.0",
+    "@pioneer-platform/pioneer-caip": "^9.15.0",
     "@xchainjs/xchain-client": "0.9.0",
     "@xchainjs/xchain-util": "0.2.6",
     "axios": "^1.6.0",