@pioneer-platform/eth-network 8.13.13 → 8.13.15

package/lib/index.js

@@ -0,0 +1,1097 @@
+"use strict";
+/*
+   ETH Network tools - Cleaned up for pioneer-sdk
+
+   Essential features only:
+   - Token transfers (ETH + ERC20)
+   - Balance queries
+   - Fee estimation
+   - Memo encoding (THORChain/Maya)
+   - Multi-network support
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFees = exports.getBalanceAddress = exports.getTransactionsByNetwork = exports.getTransactionByNetwork = exports.broadcastByNetwork = exports.estimateGasByNetwork = exports.getTokenMetadataByNetwork = exports.getTokenMetadata = exports.getTokenDecimalsByNetwork = exports.getBalanceTokensByNetwork = exports.getBalanceTokenByNetwork = exports.getBalanceAddressByNetwork = exports.getMemoEncoded = exports.getTransferData = exports.broadcast = exports.getTransaction = exports.getSymbolFromContract = exports.getAllowance = exports.getBalanceToken = exports.getBalances = exports.getBalance = exports.estimateFee = exports.getGasPriceByNetwork = exports.getGasPrice = exports.getNonceByNetwork = exports.getNonce = exports.addNodes = exports.addNode = exports.getNodes = exports.init = void 0;
+const TAG = " | eth-network | ";
+const ethers = __importStar(require("ethers"));
+const BigNumber = require('bignumber.js');
+const axiosLib = require('axios');
+const Axios = axiosLib.default || axiosLib;
+const https = require('https');
+const axios = Axios.create({
+    httpsAgent: new https.Agent({
+        rejectUnauthorized: false
+    })
+});
+let blockbook = require("@pioneer-platform/blockbook");
+const providers_1 = require("@ethersproject/providers");
+const utils_1 = require("./utils");
+const xchain_util_1 = require("@xchainjs/xchain-util");
+const nodes_1 = require("@pioneer-platform/nodes");
+const NodeHealth = __importStar(require("./node-health"));
+const log = require('@pioneer-platform/loggerdog')();
+let wait = require('wait-promise');
+let sleep = wait.sleep;
+// Provider instances
+let ETHERSCAN;
+let PROVIDER;
+let PROVIDER_BASE;
+let NODE_URL;
+let BASE = 1000000000000000000;
+// Timeout configuration
+const RPC_TIMEOUT_MS = 10000; // 10 second timeout for RPC calls
+/**
+ * Wrap a promise with a timeout
+ * @param promise Promise to wrap
+ * @param timeoutMs Timeout in milliseconds
+ * @param errorMessage Error message if timeout occurs
+ */
+const withTimeout = (promise, timeoutMs, errorMessage) => {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs))
+    ]);
+};
+// ERC20 ABI (minimal for transfers and balances)
+const ERC20ABI = [
+    "function balanceOf(address owner) view returns (uint256)",
+    "function transfer(address to, uint256 amount) returns (bool)",
+    "function allowance(address owner, address spender) view returns (uint256)",
+    "function approve(address spender, uint256 amount) returns (bool)",
+    "function decimals() view returns (uint8)",
+    "function symbol() view returns (string)",
+    "function name() view returns (string)"
+];
+// Node registry
+let NODES = [];
+// Dead node tracker - nodes that failed recently (service URL -> timestamp)
+const DEAD_NODES = new Map();
+const DEAD_NODE_TTL_MS = 5 * 60 * 1000; // 5 minutes before retry
+const RACE_BATCH_SIZE = 3; // Try 3 premium/reliable nodes first (reduced from 6)
+// Node tier priority (lower = higher priority)
+const TIER_PRIORITY = {
+    premium: 1,
+    reliable: 2,
+    public: 3,
+    untrusted: 4,
+};
+// Startup validation configuration
+// Environment variables:
+// - 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_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_SAMPLE_SIZE = parseInt(process.env.STARTUP_NODE_SAMPLE || '0'); // 0 = all nodes in tier
+/**
+ * Check if a node is marked as dead
+ */
+const isNodeDead = (nodeUrl) => {
+    const deathTime = DEAD_NODES.get(nodeUrl);
+    if (!deathTime)
+        return false;
+    // Check if TTL expired
+    if (Date.now() - deathTime > DEAD_NODE_TTL_MS) {
+        DEAD_NODES.delete(nodeUrl);
+        return false;
+    }
+    return true;
+};
+/**
+ * Mark a node as dead
+ * Only logs at WARN level for premium/reliable nodes, DEBUG for others
+ */
+const markNodeDead = (nodeUrl, tier) => {
+    DEAD_NODES.set(nodeUrl, Date.now());
+    // Only log failures for premium/reliable nodes (reduces spam)
+    if (tier === 'premium' || tier === 'reliable') {
+        log.warn(TAG + ' | markNodeDead | ', `⚠️  ${tier} node failed: ${nodeUrl.substring(0, 50)}...`);
+    }
+    else {
+        log.debug(TAG + ' | markNodeDead | ', `Public/untrusted node failed: ${nodeUrl.substring(0, 50)}...`);
+    }
+};
+/**
+ * Quick health check for a single node
+ * @param node Node to test
+ * @param timeout Timeout in ms
+ * @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]);
+        }
+        // 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;
+    }
+    catch (e) {
+        return false;
+    }
+};
+/**
+ * Validate nodes on startup
+ * Tests nodes in parallel, respecting tier configuration
+ * Only validates premium/reliable nodes by default (configurable via STARTUP_VALIDATION_TIER)
+ */
+const validateNodesOnStartup = async () => {
+    const tag = TAG + ' | validateNodesOnStartup | ';
+    if (!STARTUP_VALIDATION_ENABLED) {
+        log.info(tag, 'Startup node validation disabled (VALIDATE_NODES_ON_STARTUP=false)');
+        return;
+    }
+    if (NODES.length === 0) {
+        log.warn(tag, 'No nodes to validate');
+        return;
+    }
+    // Filter nodes by tier
+    let nodesToTest = NODES.filter(node => {
+        const tier = node.tier || 'public';
+        return STARTUP_VALIDATION_TIERS.includes(tier);
+    });
+    log.info(tag, `Filtering ${NODES.length} total nodes to ${nodesToTest.length} nodes in tiers: ${STARTUP_VALIDATION_TIERS.join(', ')}`);
+    if (nodesToTest.length === 0) {
+        log.warn(tag, `No nodes found matching tiers: ${STARTUP_VALIDATION_TIERS.join(', ')}`);
+        return;
+    }
+    // Sample if configured
+    if (STARTUP_VALIDATION_SAMPLE_SIZE > 0 && STARTUP_VALIDATION_SAMPLE_SIZE < nodesToTest.length) {
+        nodesToTest = nodesToTest
+            .sort(() => Math.random() - 0.5)
+            .slice(0, STARTUP_VALIDATION_SAMPLE_SIZE);
+        log.info(tag, `Sampling ${STARTUP_VALIDATION_SAMPLE_SIZE} random nodes from filtered list`);
+    }
+    const startTime = Date.now();
+    let completed = 0;
+    let healthy = 0;
+    let dead = 0;
+    const tierStats = {};
+    // Process nodes in batches with concurrency limit
+    const queue = [...nodesToTest];
+    const workers = [];
+    for (let i = 0; i < STARTUP_VALIDATION_CONCURRENCY; i++) {
+        workers.push((async () => {
+            while (queue.length > 0) {
+                const node = queue.shift();
+                if (!node)
+                    break;
+                const tier = node.tier || 'public';
+                if (!tierStats[tier]) {
+                    tierStats[tier] = { healthy: 0, dead: 0 };
+                }
+                const isHealthy = await quickNodeHealthCheck(node, STARTUP_VALIDATION_TIMEOUT);
+                completed++;
+                if (!isHealthy) {
+                    markNodeDead(node.service, node.tier);
+                    dead++;
+                    tierStats[tier].dead++;
+                }
+                else {
+                    healthy++;
+                    tierStats[tier].healthy++;
+                }
+            }
+        })());
+    }
+    await Promise.all(workers);
+    const elapsed = Date.now() - startTime;
+    const healthyPercent = ((healthy / nodesToTest.length) * 100).toFixed(1);
+    // Log tier breakdown
+    const tierSummary = Object.entries(tierStats)
+        .map(([tier, stats]) => `${tier}: ${stats.healthy}/${stats.healthy + stats.dead}`)
+        .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`);
+    }
+    if (healthy === 0) {
+        log.error(tag, '❌ No healthy nodes found! Network operations may fail');
+    }
+};
+/**
+ * Initialize the ETH network module
+ */
+const init = async function (settings, redis) {
+    const tag = TAG + ' | init | ';
+    // NOTE: Blockbook is initialized globally by the server with all networks
+    // Do NOT call blockbook.init() here as it would overwrite the server's initialization
+    log.debug(tag, 'Blockbook should already be initialized by server for transaction history');
+    // Initialize node health tracking (with optional Redis)
+    await NodeHealth.initNodeHealth(redis);
+    // Load web3 nodes from @pioneer-platform/nodes
+    let web3nodes = (0, nodes_1.getWeb3Nodes)();
+    for (let i = 0; i < web3nodes.length; i++) {
+        let node = web3nodes[i];
+        if (!node.networkId)
+            throw Error('missing networkId');
+        if (!node.service)
+            throw Error('missing service');
+        // Cast to TieredNode (tier will be 'premium' | 'reliable' | 'public' | 'untrusted' or undefined)
+        NODES.push(node);
+    }
+    log.info(tag, `Loaded ${NODES.length} Web3 nodes (${NODES.filter(n => n.tier === 'premium').length} premium, ${NODES.filter(n => n.tier === 'reliable').length} reliable)`);
+    // Validate nodes in background to avoid blocking server startup
+    if (STARTUP_VALIDATION_ENABLED) {
+        log.info(tag, '🔄 Starting background node validation...');
+        validateNodesOnStartup().catch(err => {
+            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');
+        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');
+    }
+    log.info(tag, 'ETH network module initialized successfully');
+};
+exports.init = init;
+/**
+ * Get registered nodes
+ */
+const getNodes = function () {
+    return NODES;
+};
+exports.getNodes = getNodes;
+/**
+ * Add a single node
+ */
+const addNode = function (node) {
+    if (!node.networkId)
+        throw Error('missing networkId');
+    if (!node.service)
+        throw Error('missing service');
+    return NODES.push(node);
+};
+exports.addNode = addNode;
+/**
+ * Add multiple nodes
+ */
+const addNodes = function (nodeList) {
+    for (let i = 0; i < nodeList.length; i++) {
+        let node = nodeList[i];
+        if (!node.networkId)
+            throw Error('missing networkId');
+        if (!node.service)
+            throw Error('missing service');
+        NODES.push(node);
+    }
+};
+exports.addNodes = addNodes;
+/**
+ * Get nonce for address
+ */
+const getNonce = async function (address) {
+    return await PROVIDER.getTransactionCount(address, 'pending');
+};
+exports.getNonce = getNonce;
+/**
+ * Get transaction count by network
+ */
+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`);
+    }
+    catch (e) {
+        log.error(tag, e);
+        throw e;
+    }
+};
+exports.getNonceByNetwork = getNonceByNetwork;
+/**
+ * Get current gas price
+ */
+const getGasPrice = async function () {
+    return await PROVIDER.getGasPrice();
+};
+exports.getGasPrice = getGasPrice;
+/**
+ * Get gas price by network - with retry logic across multiple nodes
+ */
+const getGasPriceByNetwork = async function (networkId) {
+    let tag = TAG + ' | getGasPriceByNetwork | ';
+    // 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}`);
+    }
+    // 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 gasPrice = await withTimeout(provider.getGasPrice(), RPC_TIMEOUT_MS, `Gas price 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 gas price from node ${i + 1}/${nodes.length}: ${node.service.substring(0, 50)}`);
+            }
+            return gasPrice;
+        }
+        catch (e) {
+            lastError = e;
+            // Log the failure and try next node
+            log.warn(tag, `Node ${i + 1}/${nodes.length} failed (${node.service.substring(0, 50)}): ${e.message || e}`);
+            // Continue to next node
+        }
+    }
+    // All nodes failed
+    log.error(tag, `All ${nodes.length} nodes failed for ${networkId}`);
+    throw lastError || Error(`Failed to fetch gas price from all nodes for ${networkId}`);
+};
+exports.getGasPriceByNetwork = getGasPriceByNetwork;
+/**
+ * Estimate fee for transaction
+ */
+const estimateFee = async function (asset, params) {
+    if (!params)
+        throw Error("params required");
+    if (!params.asset && !asset)
+        throw Error("Asset or params.asset required");
+    let assetForEstimate = asset ? asset : params.asset;
+    const { average: averageGP, fast: fastGP, fastest: fastestGP } = (0, utils_1.getDefaultGasPrices)();
+    let assetAddress;
+    if (assetForEstimate && (0, xchain_util_1.assetToString)(assetForEstimate) !== (0, xchain_util_1.assetToString)(xchain_util_1.AssetETH)) {
+        assetAddress = (0, utils_1.getTokenAddress)(assetForEstimate);
+    }
+    let gasLimit;
+    if (assetAddress && assetAddress !== utils_1.ETHAddress) {
+        // ERC20 token transfer
+        if (!params.sender || !params.recipient)
+            throw Error("missing params! need sender and recipient on token tx!");
+        let contract = new ethers.Contract(assetAddress, ERC20ABI, PROVIDER);
+        gasLimit = params.data
+            ? await contract.estimateGas.transfer(params.recipient, params.data, { from: params.sender })
+            : await contract.estimateGas.transfer(params.recipient, 1, { from: params.sender });
+    }
+    else {
+        // ETH transfer
+        if (!params.sender || !params.recipient)
+            throw Error("missing params! need sender and recipient");
+        const gasEstimate = await PROVIDER.estimateGas({
+            from: params.sender,
+            to: params.recipient,
+            value: ethers.utils.parseEther('0.000001')
+        });
+        gasLimit = gasEstimate.add(0);
+    }
+    return {
+        gasPrices: {
+            average: averageGP,
+            fast: fastGP,
+            fastest: fastestGP
+        },
+        gasLimit,
+        fees: {
+            type: 'byte',
+            average: (0, utils_1.getFee)({ gasPrice: averageGP, gasLimit }),
+            fast: (0, utils_1.getFee)({ gasPrice: fastGP, gasLimit }),
+            fastest: (0, utils_1.getFee)({ gasPrice: fastestGP, gasLimit })
+        }
+    };
+};
+exports.estimateFee = estimateFee;
+/**
+ * Get ETH balance for address
+ */
+const getBalance = async function (address) {
+    let tag = TAG + ' | getBalance | ';
+    try {
+        const balance = await PROVIDER.getBalance(address);
+        return ethers.utils.formatEther(balance);
+    }
+    catch (e) {
+        log.error(tag, e);
+        throw e;
+    }
+};
+exports.getBalance = getBalance;
+/**
+ * Get balances for multiple addresses
+ */
+const getBalances = async function (addresses) {
+    let tag = TAG + ' | getBalances | ';
+    try {
+        const promises = addresses.map(addr => PROVIDER.getBalance(addr));
+        const balances = await Promise.all(promises);
+        return balances.map(b => ethers.utils.formatEther(b));
+    }
+    catch (e) {
+        log.error(tag, e);
+        throw e;
+    }
+};
+exports.getBalances = getBalances;
+/**
+ * Get ERC20 token balance
+ */
+const getBalanceToken = async function (address, tokenAddress) {
+    let tag = TAG + ' | getBalanceToken | ';
+    try {
+        const contract = new ethers.Contract(tokenAddress, ERC20ABI, PROVIDER);
+        const balance = await contract.balanceOf(address);
+        const decimals = await contract.decimals();
+        return ethers.utils.formatUnits(balance, decimals);
+    }
+    catch (e) {
+        log.error(tag, e);
+        throw e;
+    }
+};
+exports.getBalanceToken = getBalanceToken;
+/**
+ * Get ERC20 allowance
+ */
+const getAllowance = async function (tokenAddress, spender, sender) {
+    let tag = TAG + ' | getAllowance | ';
+    try {
+        const contract = new ethers.Contract(tokenAddress, ERC20ABI, PROVIDER);
+        const allowance = await contract.allowance(sender, spender);
+        return allowance.toString();
+    }
+    catch (e) {
+        log.error(tag, e);
+        throw e;
+    }
+};
+exports.getAllowance = getAllowance;
+/**
+ * Get symbol from contract address
+ */
+const getSymbolFromContract = async function (contractAddress) {
+    let tag = TAG + ' | getSymbolFromContract | ';
+    try {
+        const contract = new ethers.Contract(contractAddress, ERC20ABI, PROVIDER);
+        return await contract.symbol();
+    }
+    catch (e) {
+        log.error(tag, e);
+        throw e;
+    }
+};
+exports.getSymbolFromContract = getSymbolFromContract;
+/**
+ * Get transaction by hash
+ */
+const getTransaction = async function (txid) {
+    let tag = TAG + ' | getTransaction | ';
+    try {
+        const tx = await PROVIDER.getTransaction(txid);
+        const receipt = await PROVIDER.getTransactionReceipt(txid);
+        return { tx, receipt };
+    }
+    catch (e) {
+        log.error(tag, e);
+        throw e;
+    }
+};
+exports.getTransaction = getTransaction;
+/**
+ * Broadcast signed transaction
+ */
+const broadcast = async function (tx) {
+    let tag = TAG + ' | broadcast | ';
+    try {
+        const result = await PROVIDER.sendTransaction(tx);
+        return result;
+    }
+    catch (e) {
+        log.error(tag, e);
+        throw e;
+    }
+};
+exports.broadcast = broadcast;
+/**
+ * Get ERC20 transfer data (for building unsigned transactions)
+ */
+const getTransferData = function (toAddress, amount, contractAddress) {
+    const iface = new ethers.utils.Interface(ERC20ABI);
+    return iface.encodeFunctionData("transfer", [toAddress, amount]);
+};
+exports.getTransferData = getTransferData;
+/**
+ * Encode memo data for THORChain/Maya swaps
+ */
+const getMemoEncoded = async function (swap) {
+    let tag = TAG + ' | getMemoEncoded | ';
+    try {
+        const provider = new ethers.providers.JsonRpcProvider('https://eth.llamarpc.com');
+        const abiEncoder = new ethers.utils.AbiCoder();
+        const encoded = abiEncoder.encode(["address", "address", "uint256", "uint256", "string"], [
+            swap.vault || "0x0000000000000000000000000000000000000000",
+            swap.asset || "0x0000000000000000000000000000000000000000",
+            swap.amount || "0",
+            swap.amountOutMin || "0",
+            swap.memo || ""
+        ]);
+        return encoded;
+    }
+    catch (e) {
+        log.error(tag, "Error encoding memo:", e);
+        throw e;
+    }
+};
+exports.getMemoEncoded = getMemoEncoded;
+/**
+ * Get ETH balance by network - with parallel racing logic
+ */
+const getBalanceAddressByNetwork = async function (networkId, address) {
+    let tag = TAG + ' | getBalanceAddressByNetwork | ';
+    // CRITICAL FIX: Normalize/checksum address before using with ethers
+    let checksummedAddress;
+    try {
+        checksummedAddress = ethers.utils.getAddress(address);
+    }
+    catch (e) {
+        log.error(tag, `Invalid Ethereum address format: ${address} - ${e.message}`);
+        throw new Error(`Invalid Ethereum address: ${address}`);
+    }
+    // Get ALL nodes for this network, excluding dead ones
+    let allNodes = NODES.filter((n) => n.networkId === networkId);
+    if (!allNodes || allNodes.length === 0) {
+        throw Error(`No nodes found for networkId: ${networkId}`);
+    }
+    // Filter out dead nodes and sort by health score (tier + metrics)
+    const nodesWithHealth = await Promise.all(allNodes
+        .filter((n) => !isNodeDead(n.service))
+        .map(async (node) => {
+        const metrics = await NodeHealth.getNodeHealth(node.service, node.networkId);
+        const score = NodeHealth.getHealthScore(node, metrics);
+        return { node, score, metrics };
+    }));
+    let nodes = nodesWithHealth
+        .sort((a, b) => b.score - a.score) // Higher score first
+        .map((item) => item.node);
+    if (nodes.length === 0) {
+        log.error(tag, `All ${allNodes.length} nodes are marked dead for ${networkId} - failing fast`);
+        throw Error(`No healthy nodes available for ${networkId} (all ${allNodes.length} nodes are dead)`);
+    }
+    const topTier = nodes[0].tier || 'public';
+    log.info(tag, `Racing top ${Math.min(RACE_BATCH_SIZE, nodes.length)} nodes (${nodes.length} alive of ${allNodes.length} total, starting with ${topTier})`);
+    // Extract chain ID from networkId (e.g., "eip155:1" -> 1)
+    let chainId;
+    if (networkId.includes(':')) {
+        chainId = parseInt(networkId.split(':')[1]);
+    }
+    // Race nodes in batches (now sorted by tier, so best nodes first)
+    let batchStartIndex = 0;
+    while (batchStartIndex < nodes.length) {
+        const batch = nodes.slice(batchStartIndex, batchStartIndex + RACE_BATCH_SIZE);
+        // Create racing promises for this batch
+        const racePromises = batch.map(async (node, index) => {
+            const startTime = Date.now();
+            try {
+                const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
+                const balance = await withTimeout(provider.getBalance(checksummedAddress), // USE CHECKSUMMED ADDRESS
+                RPC_TIMEOUT_MS, `Balance fetch timeout after ${RPC_TIMEOUT_MS}ms`);
+                const result = ethers.utils.formatEther(balance);
+                // Record success with response time
+                const responseTime = Date.now() - startTime;
+                await NodeHealth.recordSuccess(node.service, node.networkId, responseTime);
+                log.info(tag, `✅ Node ${batchStartIndex + index + 1}/${nodes.length} succeeded: ${node.service.substring(0, 50)} (${responseTime}ms)`);
+                return { success: true, result, nodeUrl: node.service };
+            }
+            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
+                const isValidationError = e.message && (e.message.includes('invalid address') ||
+                    e.message.includes('INVALID_ARGUMENT') ||
+                    e.message.includes('bad address checksum'));
+                if (!isValidationError) {
+                    markNodeDead(node.service, node.tier);
+                    await NodeHealth.recordFailure(node.service, node.networkId);
+                }
+                else {
+                    log.warn(tag, `Skipping node death marking - validation error (not node's fault)`);
+                }
+                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...`);
+        }
+        batchStartIndex += RACE_BATCH_SIZE;
+    }
+    // All batches failed
+    const deadCount = DEAD_NODES.size;
+    log.error(tag, `All ${nodes.length} nodes failed for ${networkId} (${deadCount} marked dead)`);
+    throw Error(`Failed to fetch balance from all nodes for ${networkId}`);
+};
+exports.getBalanceAddressByNetwork = getBalanceAddressByNetwork;
+/**
+ * Get ERC20 token balance by network
+ */
+const getBalanceTokenByNetwork = async function (networkId, address, tokenAddress) {
+    let tag = TAG + ' | getBalanceTokenByNetwork | ';
+    // Get ALL nodes for this network, excluding dead ones
+    let allNodes = NODES.filter((n) => n.networkId === networkId);
+    if (!allNodes || allNodes.length === 0) {
+        throw Error(`No nodes found for networkId: ${networkId}`);
+    }
+    // Filter out dead nodes and sort by tier priority
+    let nodes = allNodes
+        .filter((n) => !isNodeDead(n.service))
+        .sort((a, b) => {
+        const tierA = a.tier || 'public';
+        const tierB = b.tier || 'public';
+        return TIER_PRIORITY[tierA] - TIER_PRIORITY[tierB];
+    });
+    if (nodes.length === 0) {
+        log.error(tag, `All ${allNodes.length} nodes are marked dead for ${networkId} token ${tokenAddress} - failing fast`);
+        throw Error(`No healthy nodes available for ${networkId} token ${tokenAddress} (all ${allNodes.length} nodes are dead)`);
+    }
+    const topTier = nodes[0].tier || 'public';
+    log.info(tag, `Racing top ${Math.min(RACE_BATCH_SIZE, nodes.length)} nodes (${nodes.length} alive of ${allNodes.length} total, starting with ${topTier})`);
+    // Extract chain ID from networkId (e.g., "eip155:1" -> 1)
+    let chainId;
+    if (networkId.includes(':')) {
+        chainId = parseInt(networkId.split(':')[1]);
+    }
+    // Race nodes in batches
+    let batchStartIndex = 0;
+    while (batchStartIndex < nodes.length) {
+        const batch = nodes.slice(batchStartIndex, batchStartIndex + RACE_BATCH_SIZE);
+        // Create racing promises for this batch
+        const racePromises = batch.map(async (node, index) => {
+            try {
+                const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
+                const contract = new ethers.Contract(tokenAddress, ERC20ABI, provider);
+                // Wrap both contract calls with timeout
+                const balance = await withTimeout(contract.balanceOf(address), RPC_TIMEOUT_MS, `Token balance fetch timeout after ${RPC_TIMEOUT_MS}ms`);
+                const decimals = await withTimeout(contract.decimals(), RPC_TIMEOUT_MS, `Token decimals fetch timeout after ${RPC_TIMEOUT_MS}ms`);
+                const result = ethers.utils.formatUnits(balance, decimals);
+                // Success!
+                log.info(tag, `✅ Node ${batchStartIndex + index + 1}/${nodes.length} succeeded: ${node.service.substring(0, 50)}`);
+                return { success: true, result, nodeUrl: node.service };
+            }
+            catch (e) {
+                // Mark node as dead and continue
+                log.warn(tag, `❌ Node ${batchStartIndex + index + 1}/${nodes.length} failed: ${node.service.substring(0, 50)} - ${e.message}`);
+                markNodeDead(node.service, node.tier);
+                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...`);
+        }
+        batchStartIndex += RACE_BATCH_SIZE;
+    }
+    // All batches failed
+    const deadCount = DEAD_NODES.size;
+    log.error(tag, `All ${nodes.length} nodes failed for token balance ${networkId} (${deadCount} marked dead)`);
+    throw Error(`Failed to fetch token balance from all nodes for ${networkId}`);
+};
+exports.getBalanceTokenByNetwork = getBalanceTokenByNetwork;
+/**
+ * Get all ERC20 token balances by network (returns empty array for now - requires token list)
+ */
+const getBalanceTokensByNetwork = async function (networkId, address) {
+    let tag = TAG + ' | getBalanceTokensByNetwork | ';
+    try {
+        log.warn(tag, 'Token discovery not yet implemented - return empty array');
+        // TODO: Implement token discovery via Alchemy/Covalent/etc
+        return [];
+    }
+    catch (e) {
+        log.error(tag, e);
+        throw e;
+    }
+};
+exports.getBalanceTokensByNetwork = getBalanceTokensByNetwork;
+/**
+ * Get ERC20 token decimals by network - CRITICAL for correct amount calculations
+ */
+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);
+    }
+    catch (e) {
+        log.error(tag, 'Failed to fetch decimals for', tokenAddress, 'on', networkId, ':', e);
+        throw e;
+    }
+};
+exports.getTokenDecimalsByNetwork = getTokenDecimalsByNetwork;
+/**
+ * Get comprehensive ERC20 token metadata from contract address
+ * Fetches name, symbol, decimals, and can check balance for a user address
+ */
+const getTokenMetadata = async function (networkId, contractAddress, userAddress) {
+    let tag = TAG + ' | getTokenMetadata | ';
+    // Get ALL nodes for this network
+    let allNodes = NODES.filter((n) => n.networkId === networkId);
+    if (!allNodes || allNodes.length === 0) {
+        throw Error(`No nodes found for networkId: ${networkId}`);
+    }
+    // Filter out dead nodes and sort by tier priority
+    let nodes = allNodes
+        .filter((n) => !isNodeDead(n.service))
+        .sort((a, b) => {
+        const tierA = a.tier || 'public';
+        const tierB = b.tier || 'public';
+        return TIER_PRIORITY[tierA] - TIER_PRIORITY[tierB];
+    });
+    if (nodes.length === 0) {
+        log.error(tag, `All ${allNodes.length} nodes are marked dead for ${networkId} contract ${contractAddress} - failing fast`);
+        throw Error(`No healthy nodes available for ${networkId} contract ${contractAddress} (all ${allNodes.length} nodes are dead)`);
+    }
+    const topTier = nodes[0].tier || 'public';
+    log.info(tag, `Racing top ${Math.min(RACE_BATCH_SIZE, nodes.length)} nodes for token metadata: ${contractAddress} (${nodes.length} alive of ${allNodes.length} total, starting with ${topTier})`);
+    // Extract chain ID from networkId (e.g., "eip155:1" -> 1)
+    let chainId;
+    if (networkId.includes(':')) {
+        chainId = parseInt(networkId.split(':')[1]);
+    }
+    // Race nodes in batches
+    let batchStartIndex = 0;
+    while (batchStartIndex < nodes.length) {
+        const batch = nodes.slice(batchStartIndex, batchStartIndex + RACE_BATCH_SIZE);
+        // Create racing promises for this batch
+        const racePromises = batch.map(async (node, index) => {
+            try {
+                // Use StaticJsonRpcProvider to skip network auto-detection
+                const provider = new ethers.providers.StaticJsonRpcProvider(node.service, chainId ? { chainId, name: node.networkId } : undefined);
+                // Create contract instance
+                const contract = new ethers.Contract(contractAddress, ERC20ABI, provider);
+                // Fetch token metadata (name, symbol, decimals in parallel)
+                const [name, symbol, decimals] = await Promise.all([
+                    withTimeout(contract.name(), RPC_TIMEOUT_MS, `Token name fetch timeout after ${RPC_TIMEOUT_MS}ms`),
+                    withTimeout(contract.symbol(), RPC_TIMEOUT_MS, `Token symbol fetch timeout after ${RPC_TIMEOUT_MS}ms`),
+                    withTimeout(contract.decimals(), RPC_TIMEOUT_MS, `Token decimals fetch timeout after ${RPC_TIMEOUT_MS}ms`)
+                ]);
+                // Build metadata object
+                const metadata = {
+                    name: name || 'Unknown Token',
+                    symbol: symbol || 'UNKNOWN',
+                    decimals: Number(decimals) || 18,
+                    contractAddress: contractAddress.toLowerCase(),
+                    networkId,
+                    chainId
+                };
+                // If user address provided, fetch balance
+                if (userAddress) {
+                    try {
+                        const balance = await withTimeout(contract.balanceOf(userAddress), RPC_TIMEOUT_MS, `Token balance fetch timeout after ${RPC_TIMEOUT_MS}ms`);
+                        const formattedBalance = ethers.utils.formatUnits(balance, metadata.decimals);
+                        metadata.balance = formattedBalance;
+                        metadata.balanceRaw = balance.toString();
+                    }
+                    catch (balanceError) {
+                        log.warn(tag, `Failed to fetch balance for ${userAddress}:`, balanceError);
+                        metadata.balance = '0';
+                        metadata.balanceRaw = '0';
+                    }
+                }
+                log.info(tag, `✅ Node ${batchStartIndex + index + 1}/${nodes.length} succeeded: ${node.service.substring(0, 50)}`);
+                return { success: true, result: metadata, nodeUrl: node.service };
+            }
+            catch (e) {
+                log.warn(tag, `❌ Node ${batchStartIndex + index + 1}/${nodes.length} failed: ${node.service.substring(0, 50)} - ${e.message}`);
+                markNodeDead(node.service, node.tier);
+                throw e;
+            }
+        });
+        // Race this batch - return first successful result
+        try {
+            const winner = await Promise.race(racePromises.map(p => p.catch(e => Promise.reject(e))));
+            log.info(tag, `Token metadata fetched successfully:`, {
+                name: winner.result.name,
+                symbol: winner.result.symbol,
+                decimals: winner.result.decimals,
+                balance: winner.result.balance
+            });
+            return winner.result;
+        }
+        catch (e) {
+            log.warn(tag, `Batch ${Math.floor(batchStartIndex / RACE_BATCH_SIZE) + 1} failed, trying next batch...`);
+        }
+        batchStartIndex += RACE_BATCH_SIZE;
+    }
+    // All batches failed
+    const deadCount = DEAD_NODES.size;
+    log.error(tag, `All ${nodes.length} nodes failed for token ${contractAddress} on ${networkId} (${deadCount} marked dead)`);
+    throw new Error(`Failed to fetch token metadata from all nodes for ${contractAddress} on ${networkId}`);
+};
+exports.getTokenMetadata = getTokenMetadata;
+/**
+ * Get token metadata by network with balance check
+ * Convenience wrapper for getTokenMetadata
+ */
+const getTokenMetadataByNetwork = async function (networkId, contractAddress, userAddress) {
+    return (0, exports.getTokenMetadata)(networkId, contractAddress, userAddress);
+};
+exports.getTokenMetadataByNetwork = getTokenMetadataByNetwork;
+/**
+ * Estimate gas by network
+ */
+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;
+    }
+    catch (e) {
+        log.error(tag, e);
+        throw e;
+    }
+};
+exports.estimateGasByNetwork = estimateGasByNetwork;
+/**
+ * Broadcast transaction by network
+ */
+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
+        return {
+            success: false,
+            error: e.message || e.toString()
+        };
+    }
+};
+exports.broadcastByNetwork = broadcastByNetwork;
+/**
+ * Get transaction by network and txid
+ */
+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 };
+    }
+    catch (e) {
+        log.error(tag, e);
+        throw e;
+    }
+};
+exports.getTransactionByNetwork = getTransactionByNetwork;
+/**
+ * Get transaction history by network
+ */
+const getTransactionsByNetwork = async function (networkId, address, options = {}) {
+    let tag = TAG + ' | getTransactionsByNetwork | ';
+    try {
+        log.info(tag, `Fetching transactions for ${address} on ${networkId}`);
+        // Normalize address to checksummed format
+        let checksummedAddress;
+        try {
+            checksummedAddress = ethers.utils.getAddress(address);
+        }
+        catch (e) {
+            log.error(tag, `Invalid Ethereum address format: ${address} - ${e.message}`);
+            throw new Error(`Invalid Ethereum address: ${address}`);
+        }
+        // Determine which coin symbol to use for Blockbook
+        // ETH mainnet uses "ETH", other networks would need mapping
+        let coinSymbol = 'ETH'; // Default to ETH mainnet
+        // Map network ID to Blockbook coin symbol
+        const networkToCoin = {
+            'eip155:1': 'ETH', // Ethereum Mainnet
+            'eip155:137': 'MATIC', // Polygon (if supported)
+            'eip155:56': 'BSC', // BSC (if supported)
+            // Add more as needed
+        };
+        if (networkToCoin[networkId]) {
+            coinSymbol = networkToCoin[networkId];
+        }
+        else {
+            log.warn(tag, `Unknown networkId ${networkId}, defaulting to ETH`);
+        }
+        // Fetch address info from Blockbook with transaction details
+        const page = options?.page || 1;
+        const pageSize = options?.pageSize || 1000; // Max transactions per page
+        log.info(tag, `Fetching from Blockbook: ${coinSymbol} address ${checksummedAddress} page ${page} pageSize ${pageSize}`);
+        // Use Blockbook to get address info with transactions
+        const addressInfo = await blockbook.getAddressInfo(coinSymbol, checksummedAddress, 'txs', { page, pageSize });
+        if (!addressInfo || !addressInfo.transactions) {
+            log.warn(tag, 'No transactions found for address');
+            return [];
+        }
+        // Parse and normalize transactions
+        const transactions = addressInfo.transactions.map((tx) => ({
+            hash: tx.txid,
+            from: tx.vin && tx.vin[0] && tx.vin[0].addresses && tx.vin[0].addresses[0] ? tx.vin[0].addresses[0] : '',
+            to: tx.vout && tx.vout[0] && tx.vout[0].addresses && tx.vout[0].addresses[0] ? tx.vout[0].addresses[0] : '',
+            value: tx.value || '0',
+            blockNumber: tx.blockHeight || 0,
+            timestamp: tx.blockTime ? new Date(tx.blockTime * 1000).toISOString() : '',
+            gasUsed: tx.ethereumSpecific?.gasUsed?.toString() || '0',
+            gasPrice: tx.ethereumSpecific?.gasPrice?.toString() || '0',
+            status: tx.ethereumSpecific?.status === 1 || tx.confirmations > 0 ? 'success' : 'failed',
+            confirmations: tx.confirmations || 0,
+            // Include raw tx for detailed analysis
+            _raw: tx
+        }));
+        // Apply date range filter if specified
+        if (options?.dateRange) {
+            const from = options.dateRange.from ? new Date(options.dateRange.from).getTime() : 0;
+            const to = options.dateRange.to ? new Date(options.dateRange.to).getTime() : Date.now();
+            return transactions.filter((tx) => {
+                const txTime = new Date(tx.timestamp).getTime();
+                return txTime >= from && txTime <= to;
+            });
+        }
+        log.info(tag, `Fetched ${transactions.length} transactions for ${checksummedAddress}`);
+        return transactions;
+    }
+    catch (e) {
+        log.error(tag, 'Error fetching transactions:', e.message);
+        log.error(tag, 'Full error:', e);
+        log.error(tag, 'Stack:', e.stack);
+        // Don't throw - return empty array to allow graceful degradation
+        return [];
+    }
+};
+exports.getTransactionsByNetwork = getTransactionsByNetwork;
+// Legacy compatibility exports
+exports.getBalanceAddress = exports.getBalance;
+exports.getFees = exports.estimateFee;