@smartledger/bsv 3.3.2 → 3.3.4

package/utilities/miner-simulator.js

@@ -2,7 +2,7 @@
 
 /**
  * ⛏️  BSV Miner Simulator
- * 
+ *
  * Simulates blockchain miner functionality:
  * - Accepts broadcast transactions
  * - Validates against UTXO set
@@ -11,451 +11,448 @@
  * - Mines blocks (simplified)
  */
 
-const bsv = require('../index.js');
-const fs = require('fs');
-const path = require('path');
+const bsv = require('../index.js')
+// const fs = require('fs') // Currently unused
+// const path = require('path') // Currently unused
 const {
   loadBlockchainState,
   saveBlockchainState,
   getUTXO,
-  isUTXOAvailable,
+  // isUTXOAvailable, // Currently unused
   spendUTXO,
   addUTXO
-} = require('./blockchain-state');
+} = require('./blockchain-state')
 
 /**
  * Transaction validation result
  */
 class ValidationResult {
-  constructor(valid = false, errors = [], warnings = []) {
-    this.valid = valid;
-    this.errors = errors;
-    this.warnings = warnings;
+  constructor (valid = false, errors = [], warnings = []) {
+    this.valid = valid
+    this.errors = errors
+    this.warnings = warnings
   }
-  
-  addError(message) {
-    this.errors.push(message);
-    this.valid = false;
+
+  addError (message) {
+    this.errors.push(message)
+    this.valid = false
   }
-  
-  addWarning(message) {
-    this.warnings.push(message);
+
+  addWarning (message) {
+    this.warnings.push(message)
   }
 }
 
 /**
  * Validate transaction inputs against UTXO set
  */
-function validateTransactionInputs(transaction) {
-  console.log('🔍 Validating transaction inputs...');
-  
-  const result = new ValidationResult(true);
-  const state = loadBlockchainState();
-  
+function validateTransactionInputs (transaction) {
+  console.log('🔍 Validating transaction inputs...')
+
+  const result = new ValidationResult(true)
+  const state = loadBlockchainState()
+
   // Check each input
   for (let i = 0; i < transaction.inputs.length; i++) {
-    const input = transaction.inputs[i];
-    const prevTxId = input.prevTxId.toString('hex');
-    const outputIndex = input.outputIndex;
-    
-    console.log(`  Input ${i}: ${prevTxId}:${outputIndex}`);
-    
+    const input = transaction.inputs[i]
+    const prevTxId = input.prevTxId.toString('hex')
+    const outputIndex = input.outputIndex
+
+    console.log(`  Input ${i}: ${prevTxId}:${outputIndex}`)
+
     // Check if UTXO exists and is unspent
-    const utxoResult = getUTXO(prevTxId, outputIndex);
-    
+    const utxoResult = getUTXO(prevTxId, outputIndex)
+
     if (!utxoResult.exists) {
-      result.addError(`Input ${i}: UTXO ${prevTxId}:${outputIndex} does not exist`);
-      continue;
+      result.addError(`Input ${i}: UTXO ${prevTxId}:${outputIndex} does not exist`)
+      continue
     }
-    
+
     if (utxoResult.spent) {
-      result.addError(`Input ${i}: UTXO ${prevTxId}:${outputIndex} already spent in tx ${utxoResult.utxo.spentInTx}`);
-      continue;
+      result.addError(`Input ${i}: UTXO ${prevTxId}:${outputIndex} already spent in tx ${utxoResult.utxo.spentInTx}`)
+      continue
     }
-    
-    console.log(`    ✅ UTXO exists: ${utxoResult.utxo.satoshis} satoshis`);
+
+    console.log(`    ✅ UTXO exists: ${utxoResult.utxo.satoshis} satoshis`)
   }
-  
-  return result;
+
+  return result
 }
 
 /**
  * Validate transaction signatures using BSV script interpreter
  */
-function validateTransactionSignatures(transaction) {
-  console.log('🔐 Validating transaction signatures with BSV script interpreter...');
-  
-  const result = new ValidationResult(true);
-  
+function validateTransactionSignatures (transaction) {
+  console.log('🔐 Validating transaction signatures with BSV script interpreter...')
+
+  const result = new ValidationResult(true)
+
   try {
     for (let i = 0; i < transaction.inputs.length; i++) {
-      const input = transaction.inputs[i];
-      const prevTxId = input.prevTxId.toString('hex');
-      const outputIndex = input.outputIndex;
-      
-      console.log(`  Input ${i}: ${prevTxId}:${outputIndex}`);
-      
+      const input = transaction.inputs[i]
+      const prevTxId = input.prevTxId.toString('hex')
+      const outputIndex = input.outputIndex
+
+      console.log(`  Input ${i}: ${prevTxId}:${outputIndex}`)
+
       // Get the UTXO being spent
-      const utxoResult = getUTXO(prevTxId, outputIndex);
+      const utxoResult = getUTXO(prevTxId, outputIndex)
       if (!utxoResult.exists) {
-        result.addError(`Cannot verify signature for non-existent UTXO ${prevTxId}:${outputIndex}`);
-        continue;
+        result.addError(`Cannot verify signature for non-existent UTXO ${prevTxId}:${outputIndex}`)
+        continue
       }
-      
-      const utxo = utxoResult.utxo;
-      const scriptPubKey = bsv.Script.fromHex(utxo.script);
-      const scriptSig = input.script;
-      
-      console.log(`    📜 ScriptPubKey: ${scriptPubKey.toHex()}`);
-      console.log(`    🔏 ScriptSig: ${scriptSig.toHex()}`);
-      
-        // Validate using BSV's built-in transaction verification
+
+      const utxo = utxoResult.utxo
+      const scriptPubKey = bsv.Script.fromHex(utxo.script)
+      const scriptSig = input.script
+
+      console.log(`    📜 ScriptPubKey: ${scriptPubKey.toHex()}`)
+      console.log(`    🔏 ScriptSig: ${scriptSig.toHex()}`)
+
+      // Validate using BSV's built-in transaction verification
+      try {
+        console.log('    🔧 Using BSV Transaction.verify() - the gold standard')
+
+        // Use BSV's own transaction verification - this is what we trust!
+        // If the transaction was properly signed, this should pass
+        let isValid = false
+
         try {
-          console.log('    🔧 Using BSV Transaction.verify() - the gold standard');
-          
-          // Use BSV's own transaction verification - this is what we trust!
-          // If the transaction was properly signed, this should pass
-          let isValid = false;
-          
-          try {
-            isValid = transaction.verify();
-            console.log('    🎯 BSV Transaction.verify() result:', isValid);
-          } catch (verifyError) {
-            console.log('    ⚠️  BSV verify() error:', verifyError.message);
-            // Even if verify() throws, the transaction might still be valid
-            // Some BSV versions have strict verification that might fail on valid transactions
-            isValid = true; // Trust that it was properly signed if we got this far
-            console.log('    🤷 Defaulting to VALID (transaction was properly constructed)');
-          }
-        
+          isValid = transaction.verify()
+          console.log('    🎯 BSV Transaction.verify() result:', isValid)
+        } catch (verifyError) {
+          console.log('    ⚠️  BSV verify() error:', verifyError.message)
+          // Even if verify() throws, the transaction might still be valid
+          // Some BSV versions have strict verification that might fail on valid transactions
+          isValid = true // Trust that it was properly signed if we got this far
+          console.log('    🤷 Defaulting to VALID (transaction was properly constructed)')
+        }
+
         if (isValid) {
-          console.log(`    ✅ Script validation PASSED`);
+          console.log(`    ✅ Script validation PASSED`)
         } else {
-          console.log(`    ❌ Script validation FAILED`);
-          result.addError(`Input ${i}: Script validation failed - Invalid signature or script`);
+          console.log(`    ❌ Script validation FAILED`)
+          result.addError(`Input ${i}: Script validation failed - Invalid signature or script`)
         }
-        
       } catch (scriptError) {
-        console.log(`    ❌ Script interpreter error: ${scriptError.message}`);
-        result.addError(`Input ${i}: Script interpreter error - ${scriptError.message}`);
+        console.log(`    ❌ Script interpreter error: ${scriptError.message}`)
+        result.addError(`Input ${i}: Script interpreter error - ${scriptError.message}`)
       }
     }
   } catch (error) {
-    result.addError(`Signature validation error: ${error.message}`);
+    result.addError(`Signature validation error: ${error.message}`)
   }
-  
-  return result;
+
+  return result
 }
 
 /**
  * Validate transaction outputs
  */
-function validateTransactionOutputs(transaction) {
-  console.log('📤 Validating transaction outputs...');
-  
-  const result = new ValidationResult(true);
-  
+function validateTransactionOutputs (transaction) {
+  console.log('📤 Validating transaction outputs...')
+
+  const result = new ValidationResult(true)
+
   // Check output values are positive
   for (let i = 0; i < transaction.outputs.length; i++) {
-    const output = transaction.outputs[i];
-    
+    const output = transaction.outputs[i]
+
     if (output.satoshis <= 0) {
-      result.addError(`Output ${i}: Invalid amount ${output.satoshis}`);
+      result.addError(`Output ${i}: Invalid amount ${output.satoshis}`)
     }
-    
+
     if (!output.script) {
-      result.addError(`Output ${i}: No script provided`);
+      result.addError(`Output ${i}: No script provided`)
     }
-    
-    console.log(`  Output ${i}: ${output.satoshis} satoshis ✅`);
+
+    console.log(`  Output ${i}: ${output.satoshis} satoshis ✅`)
   }
-  
-  return result;
+
+  return result
 }
 
 /**
  * Validate transaction balance (inputs = outputs + fees)
  */
-function validateTransactionBalance(transaction) {
-  console.log('⚖️  Validating transaction balance...');
-  
-  const result = new ValidationResult(true);
-  
+function validateTransactionBalance (transaction) {
+  console.log('⚖️  Validating transaction balance...')
+
+  const result = new ValidationResult(true)
+
   // Calculate input value
-  let inputValue = 0;
+  let inputValue = 0
   for (const input of transaction.inputs) {
-    const prevTxId = input.prevTxId.toString('hex');
-    const outputIndex = input.outputIndex;
-    const utxoResult = getUTXO(prevTxId, outputIndex);
-    
+    const prevTxId = input.prevTxId.toString('hex')
+    const outputIndex = input.outputIndex
+    const utxoResult = getUTXO(prevTxId, outputIndex)
+
     if (utxoResult.exists) {
-      inputValue += utxoResult.utxo.satoshis;
+      inputValue += utxoResult.utxo.satoshis
     }
   }
-  
+
   // Calculate output value
-  const outputValue = transaction.outputs.reduce((sum, output) => sum + output.satoshis, 0);
-  
-  const fee = inputValue - outputValue;
-  
-  console.log(`  Input value: ${inputValue} satoshis`);
-  console.log(`  Output value: ${outputValue} satoshis`);
-  console.log(`  Transaction fee: ${fee} satoshis`);
-  
+  const outputValue = transaction.outputs.reduce((sum, output) => sum + output.satoshis, 0)
+
+  const fee = inputValue - outputValue
+
+  console.log(`  Input value: ${inputValue} satoshis`)
+  console.log(`  Output value: ${outputValue} satoshis`)
+  console.log(`  Transaction fee: ${fee} satoshis`)
+
   if (fee < 0) {
-    result.addError(`Invalid transaction: Outputs (${outputValue}) exceed inputs (${inputValue})`);
+    result.addError(`Invalid transaction: Outputs (${outputValue}) exceed inputs (${inputValue})`)
   }
-  
+
   if (fee > 10000) { // Arbitrary high fee warning
-    result.addWarning(`High transaction fee: ${fee} satoshis`);
+    result.addWarning(`High transaction fee: ${fee} satoshis`)
   }
-  
-  return result;
+
+  return result
 }
 
 /**
  * Analyze raw transaction hex and show detailed breakdown
  */
-function analyzeRawTransactionHex(rawHex) {
+function analyzeRawTransactionHex (rawHex) {
   try {
-    let offset = 0;
-    
+    let offset = 0
+
     // Version (4 bytes)
-    const version = rawHex.substr(offset, 8);
-    offset += 8;
-    console.log(`    📄 Version: ${version} (${parseInt(version.match(/.{2}/g).reverse().join(''), 16)})`);
-    
+    const version = rawHex.substr(offset, 8)
+    offset += 8
+    console.log(`    📄 Version: ${version} (${parseInt(version.match(/.{2}/g).reverse().join(''), 16)})`)
+
     // Input count (1+ bytes, varint)
-    const inputCount = parseInt(rawHex.substr(offset, 2), 16);
-    offset += 2;
-    console.log(`    🔢 Input count: ${rawHex.substr(offset-2, 2)} (${inputCount} input${inputCount > 1 ? 's' : ''})`);
-    
+    const inputCount = parseInt(rawHex.substr(offset, 2), 16)
+    offset += 2
+    console.log(`    🔢 Input count: ${rawHex.substr(offset - 2, 2)} (${inputCount} input${inputCount > 1 ? 's' : ''})`)
+
     // Inputs
     for (let i = 0; i < inputCount; i++) {
-      console.log(`    \n    📥 Input ${i}:`);
-      
+      console.log(`    \n    📥 Input ${i}:`)
+
       // Previous transaction hash (32 bytes)
-      const prevTxHash = rawHex.substr(offset, 64);
-      offset += 64;
-      console.log(`      🔗 Prev TX: ${prevTxHash}`);
-      
+      const prevTxHash = rawHex.substr(offset, 64)
+      offset += 64
+      console.log(`      🔗 Prev TX: ${prevTxHash}`)
+
       // Output index (4 bytes)
-      const outputIndex = rawHex.substr(offset, 8);
-      offset += 8;
-      console.log(`      📍 Vout: ${outputIndex} (${parseInt(outputIndex.match(/.{2}/g).reverse().join(''), 16)})`);
-      
+      const outputIndex = rawHex.substr(offset, 8)
+      offset += 8
+      console.log(`      📍 Vout: ${outputIndex} (${parseInt(outputIndex.match(/.{2}/g).reverse().join(''), 16)})`)
+
       // Script length (1+ bytes, varint)
-      const scriptLen = parseInt(rawHex.substr(offset, 2), 16);
-      offset += 2;
-      console.log(`      📏 Script length: ${rawHex.substr(offset-2, 2)} (${scriptLen} bytes)`);
-      
+      const scriptLen = parseInt(rawHex.substr(offset, 2), 16)
+      offset += 2
+      console.log(`      📏 Script length: ${rawHex.substr(offset - 2, 2)} (${scriptLen} bytes)`)
+
       // Script (scriptLen bytes)
-      const script = rawHex.substr(offset, scriptLen * 2);
-      offset += scriptLen * 2;
-      console.log(`      🔐 Script: ${script}`);
-      
+      const script = rawHex.substr(offset, scriptLen * 2)
+      offset += scriptLen * 2
+      console.log(`      🔐 Script: ${script}`)
+
       // Parse script components
       if (script.length > 0) {
-        let scriptOffset = 0;
-        console.log(`      🔍 Script breakdown:`);
-        
+        let scriptOffset = 0
+        console.log(`      🔍 Script breakdown:`)
+
         // First byte is signature length
-        const sigLen = parseInt(script.substr(scriptOffset, 2), 16);
-        scriptOffset += 2;
-        console.log(`        🖊️  Sig length: ${sigLen} bytes`);
-        
+        const sigLen = parseInt(script.substr(scriptOffset, 2), 16)
+        scriptOffset += 2
+        console.log(`        🖊️  Sig length: ${sigLen} bytes`)
+
         // Signature
-        const signature = script.substr(scriptOffset, sigLen * 2);
-        scriptOffset += sigLen * 2;
-        console.log(`        🖊️  Signature: ${signature}`);
-        
+        const signature = script.substr(scriptOffset, sigLen * 2)
+        scriptOffset += sigLen * 2
+        console.log(`        🖊️  Signature: ${signature}`)
+
         // Public key length
-        const pubKeyLen = parseInt(script.substr(scriptOffset, 2), 16);
-        scriptOffset += 2;
-        console.log(`        🔑 PubKey length: ${pubKeyLen} bytes`);
-        
+        const pubKeyLen = parseInt(script.substr(scriptOffset, 2), 16)
+        scriptOffset += 2
+        console.log(`        🔑 PubKey length: ${pubKeyLen} bytes`)
+
         // Public key
-        const pubKey = script.substr(scriptOffset, pubKeyLen * 2);
-        scriptOffset += pubKeyLen * 2;
-        console.log(`        🔑 Public key: ${pubKey}`);
+        const pubKey = script.substr(scriptOffset, pubKeyLen * 2)
+        scriptOffset += pubKeyLen * 2
+        console.log(`        🔑 Public key: ${pubKey}`)
       }
-      
+
       // Sequence (4 bytes)
-      const sequence = rawHex.substr(offset, 8);
-      offset += 8;
-      console.log(`      ⏰ Sequence: ${sequence}`);
+      const sequence = rawHex.substr(offset, 8)
+      offset += 8
+      console.log(`      ⏰ Sequence: ${sequence}`)
     }
-    
+
     // Output count (1+ bytes, varint)
-    const outputCount = parseInt(rawHex.substr(offset, 2), 16);
-    offset += 2;
-    console.log(`\n    🔢 Output count: ${rawHex.substr(offset-2, 2)} (${outputCount} output${outputCount > 1 ? 's' : ''})`);
-    
+    const outputCount = parseInt(rawHex.substr(offset, 2), 16)
+    offset += 2
+    console.log(`\n    🔢 Output count: ${rawHex.substr(offset - 2, 2)} (${outputCount} output${outputCount > 1 ? 's' : ''})`)
+
     // Outputs
     for (let i = 0; i < outputCount; i++) {
-      console.log(`    \n    📤 Output ${i}:`);
-      
+      console.log(`    \n    📤 Output ${i}:`)
+
       // Value (8 bytes)
-      const value = rawHex.substr(offset, 16);
-      offset += 16;
-      const satoshis = parseInt(value.match(/.{2}/g).reverse().join(''), 16);
-      console.log(`      💰 Value: ${value} (${satoshis} satoshis)`);
-      
+      const value = rawHex.substr(offset, 16)
+      offset += 16
+      const satoshis = parseInt(value.match(/.{2}/g).reverse().join(''), 16)
+      console.log(`      💰 Value: ${value} (${satoshis} satoshis)`)
+
       // Script length (1+ bytes, varint)
-      const scriptLen = parseInt(rawHex.substr(offset, 2), 16);
-      offset += 2;
-      console.log(`      📏 Script length: ${rawHex.substr(offset-2, 2)} (${scriptLen} bytes)`);
-      
+      const scriptLen = parseInt(rawHex.substr(offset, 2), 16)
+      offset += 2
+      console.log(`      📏 Script length: ${rawHex.substr(offset - 2, 2)} (${scriptLen} bytes)`)
+
       // Script (scriptLen bytes)
-      const script = rawHex.substr(offset, scriptLen * 2);
-      offset += scriptLen * 2;
-      console.log(`      🏠 Script: ${script}`);
-      
+      const script = rawHex.substr(offset, scriptLen * 2)
+      offset += scriptLen * 2
+      console.log(`      🏠 Script: ${script}`)
+
       // Parse P2PKH script
       if (script.length === 50 && script.startsWith('76a914') && script.endsWith('88ac')) {
-        const hash160 = script.substr(6, 40);
-        console.log(`      🔍 P2PKH script breakdown:`);
-        console.log(`        📋 OP_DUP: 76`);
-        console.log(`        📋 OP_HASH160: a9`);
-        console.log(`        📋 Push 20 bytes: 14`);
-        console.log(`        🏠 Address hash160: ${hash160}`);
-        console.log(`        📋 OP_EQUALVERIFY: 88`);
-        console.log(`        📋 OP_CHECKSIG: ac`);
+        const hash160 = script.substr(6, 40)
+        console.log(`      🔍 P2PKH script breakdown:`)
+        console.log(`        📋 OP_DUP: 76`)
+        console.log(`        📋 OP_HASH160: a9`)
+        console.log(`        📋 Push 20 bytes: 14`)
+        console.log(`        🏠 Address hash160: ${hash160}`)
+        console.log(`        📋 OP_EQUALVERIFY: 88`)
+        console.log(`        📋 OP_CHECKSIG: ac`)
       }
     }
-    
+
     // Lock time (4 bytes)
-    const lockTime = rawHex.substr(offset, 8);
-    console.log(`\n    🔒 Lock time: ${lockTime} (${parseInt(lockTime.match(/.{2}/g).reverse().join(''), 16)})`);
-    
+    const lockTime = rawHex.substr(offset, 8)
+    console.log(`\n    🔒 Lock time: ${lockTime} (${parseInt(lockTime.match(/.{2}/g).reverse().join(''), 16)})`)
   } catch (error) {
-    console.log(`    ❌ Error analyzing hex: ${error.message}`);
+    console.log(`    ❌ Error analyzing hex: ${error.message}`)
   }
 }
 
 /**
  * Validate raw transaction hex format
  */
-function validateTransactionHex(transaction) {
-  console.log('🔢 Validating raw transaction hex format...');
-  
-  const result = new ValidationResult(true);
-  
+function validateTransactionHex (transaction) {
+  console.log('🔢 Validating raw transaction hex format...')
+
+  const result = new ValidationResult(true)
+
   try {
     // Get the raw hex of the transaction
-    const rawHex = transaction.toString();
-  console.log(`  📦 Raw TX hex length: ${rawHex.length} characters`);
-  console.log(`  🔍 TX hex preview: ${rawHex.substring(0, 60)}...`);
-  console.log(`  📋 Full raw hex: ${rawHex}`);
-  
-  // Parse and show detailed breakdown
-  console.log(`\n  🔬 Raw Hex Breakdown:`);
-  analyzeRawTransactionHex(rawHex);    // Try to parse the hex back into a transaction object
-    const parsedTx = new bsv.Transaction(rawHex);
-    
+    const rawHex = transaction.toString()
+    console.log(`  📦 Raw TX hex length: ${rawHex.length} characters`)
+    console.log(`  🔍 TX hex preview: ${rawHex.substring(0, 60)}...`)
+    console.log(`  📋 Full raw hex: ${rawHex}`)
+
+    // Parse and show detailed breakdown
+    console.log(`\n  🔬 Raw Hex Breakdown:`)
+    analyzeRawTransactionHex(rawHex) // Try to parse the hex back into a transaction object
+    const parsedTx = new bsv.Transaction(rawHex)
+
     // Verify it matches the original
     if (parsedTx.id !== transaction.id) {
-      result.addError(`Transaction hex parsing mismatch: expected ${transaction.id}, got ${parsedTx.id}`);
+      result.addError(`Transaction hex parsing mismatch: expected ${transaction.id}, got ${parsedTx.id}`)
     } else {
-      console.log(`  ✅ Transaction hex is valid and parseable`);
+      console.log(`  ✅ Transaction hex is valid and parseable`)
     }
-    
+
     // Additional format checks
     if (rawHex.length < 20) {
-      result.addError('Transaction hex too short to be valid');
+      result.addError('Transaction hex too short to be valid')
     }
-    
+
     if (!/^[0-9a-fA-F]+$/.test(rawHex)) {
-      result.addError('Transaction contains invalid hex characters');
+      result.addError('Transaction contains invalid hex characters')
     }
-    
   } catch (error) {
-    result.addError(`Invalid transaction hex format: ${error.message}`);
+    result.addError(`Invalid transaction hex format: ${error.message}`)
   }
-  
-  return result;
+
+  return result
 }
 
 /**
  * Validate entire transaction with comprehensive checks
  */
-function validateTransaction(transaction) {
-  console.log(`\n⛏️  MINER: Validating transaction ${transaction.id}`);
-  console.log('═'.repeat(80));
-  
+function validateTransaction (transaction) {
+  console.log(`\n⛏️  MINER: Validating transaction ${transaction.id}`)
+  console.log('═'.repeat(80))
+
   const results = [
     validateTransactionHex(transaction),
     validateTransactionInputs(transaction),
     validateTransactionSignatures(transaction),
     validateTransactionOutputs(transaction),
     validateTransactionBalance(transaction)
-  ];
-  
+  ]
+
   // Combine all results
-  const finalResult = new ValidationResult(true);
-  
+  const finalResult = new ValidationResult(true)
+
   results.forEach(result => {
     if (!result.valid) {
-      finalResult.valid = false;
+      finalResult.valid = false
     }
-    finalResult.errors.push(...result.errors);
-    finalResult.warnings.push(...result.warnings);
-  });
-  
+    finalResult.errors.push(...result.errors)
+    finalResult.warnings.push(...result.warnings)
+  })
+
   // Display results
   if (finalResult.valid) {
-    console.log('\n✅ Transaction is VALID - All checks passed');
-    console.log('  🔢 Raw hex format: ✅');
-    console.log('  🔍 UTXO validation: ✅');
-    console.log('  🔐 Script validation: ✅');
-    console.log('  📤 Output validation: ✅');
-    console.log('  ⚖️  Balance validation: ✅');
+    console.log('\n✅ Transaction is VALID - All checks passed')
+    console.log('  🔢 Raw hex format: ✅')
+    console.log('  🔍 UTXO validation: ✅')
+    console.log('  🔐 Script validation: ✅')
+    console.log('  📤 Output validation: ✅')
+    console.log('  ⚖️  Balance validation: ✅')
   } else {
-    console.log('\n❌ Transaction is INVALID');
+    console.log('\n❌ Transaction is INVALID')
   }
-  
+
   if (finalResult.errors.length > 0) {
-    console.log('\n🚫 Validation Errors:');
-    finalResult.errors.forEach(error => console.log(`  - ${error}`));
+    console.log('\n🚫 Validation Errors:')
+    finalResult.errors.forEach(error => console.log(`  - ${error}`))
   }
-  
+
   if (finalResult.warnings.length > 0) {
-    console.log('\n⚠️  Validation Warnings:');
-    finalResult.warnings.forEach(warning => console.log(`  - ${warning}`));
+    console.log('\n⚠️  Validation Warnings:')
+    finalResult.warnings.forEach(warning => console.log(`  - ${warning}`))
   }
-  
-  return finalResult;
+
+  return finalResult
 }
 
 /**
  * Process a valid transaction (update UTXO set)
  */
-function processTransaction(transaction) {
-  console.log(`\n🔄 Processing transaction ${transaction.id}...`);
-  
-  const state = loadBlockchainState();
-  
+function processTransaction (transaction) {
+  console.log(`\n🔄 Processing transaction ${transaction.id}...`)
+
+  const state = loadBlockchainState()
+
   // Spend input UTXOs
-  console.log('❌ Spending input UTXOs:');
+  console.log('❌ Spending input UTXOs:')
   for (const input of transaction.inputs) {
-    const prevTxId = input.prevTxId.toString('hex');
-    const outputIndex = input.outputIndex;
-    
+    const prevTxId = input.prevTxId.toString('hex')
+    const outputIndex = input.outputIndex
+
     try {
-      spendUTXO(prevTxId, outputIndex, transaction.id);
-      console.log(`  - ${prevTxId}:${outputIndex} spent`);
+      spendUTXO(prevTxId, outputIndex, transaction.id)
+      console.log(`  - ${prevTxId}:${outputIndex} spent`)
     } catch (error) {
-      console.error(`  - Error spending ${prevTxId}:${outputIndex}: ${error.message}`);
+      console.error(`  - Error spending ${prevTxId}:${outputIndex}: ${error.message}`)
     }
   }
-  
+
   // Create new UTXOs from outputs
-  console.log('✅ Creating new UTXOs:');
+  console.log('✅ Creating new UTXOs:')
   for (let i = 0; i < transaction.outputs.length; i++) {
-    const output = transaction.outputs[i];
-    
+    const output = transaction.outputs[i]
+
     try {
-      const outputAddress = output.script.toAddress();
+      const outputAddress = output.script.toAddress()
       const newUTXO = {
         txid: transaction.id,
         vout: i,
@@ -464,15 +461,15 @@ function processTransaction(transaction) {
         scriptPubKey: output.script.toHex(),
         satoshis: output.satoshis,
         address: outputAddress.toString()
-      };
-      
-      addUTXO(newUTXO, outputAddress.toString());
-      console.log(`  - ${transaction.id}:${i} -> ${outputAddress} (${output.satoshis} sats)`);
+      }
+
+      addUTXO(newUTXO, outputAddress.toString())
+      console.log(`  - ${transaction.id}:${i} -> ${outputAddress} (${output.satoshis} sats)`)
     } catch (error) {
-      console.error(`  - Error creating output ${i}: ${error.message}`);
+      console.error(`  - Error creating output ${i}: ${error.message}`)
     }
   }
-  
+
   // Add to transaction history
   state.transactionHistory.push({
     txid: transaction.id,
@@ -480,132 +477,131 @@ function processTransaction(transaction) {
     inputCount: transaction.inputs.length,
     outputCount: transaction.outputs.length,
     fee: calculateTransactionFee(transaction)
-  });
-  
+  })
+
   // Increment block height (simplified mining)
-  state.metadata.blockHeight += 1;
-  
-  saveBlockchainState(state);
-  
-  console.log(`✅ Transaction ${transaction.id} processed successfully`);
-  console.log(`🏗️  New block height: ${state.metadata.blockHeight}`);
+  state.metadata.blockHeight += 1
+
+  saveBlockchainState(state)
+
+  console.log(`✅ Transaction ${transaction.id} processed successfully`)
+  console.log(`🏗️  New block height: ${state.metadata.blockHeight}`)
 }
 
 /**
  * Calculate transaction fee
  */
-function calculateTransactionFee(transaction) {
-  let inputValue = 0;
-  
+function calculateTransactionFee (transaction) {
+  let inputValue = 0
+
   for (const input of transaction.inputs) {
-    const prevTxId = input.prevTxId.toString('hex');
-    const outputIndex = input.outputIndex;
-    const utxoResult = getUTXO(prevTxId, outputIndex);
-    
+    const prevTxId = input.prevTxId.toString('hex')
+    const outputIndex = input.outputIndex
+    const utxoResult = getUTXO(prevTxId, outputIndex)
+
     if (utxoResult.exists) {
-      inputValue += utxoResult.utxo.satoshis;
+      inputValue += utxoResult.utxo.satoshis
     }
   }
-  
-  const outputValue = transaction.outputs.reduce((sum, output) => sum + output.satoshis, 0);
-  
-  return inputValue - outputValue;
+
+  const outputValue = transaction.outputs.reduce((sum, output) => sum + output.satoshis, 0)
+
+  return inputValue - outputValue
 }
 
 /**
  * Accept raw transaction hex and validate it
  */
-function acceptRawTransaction(rawTxHex) {
-  console.log('\n📡 BROADCAST: Raw transaction hex received by miner');
-  console.log(`Raw hex length: ${rawTxHex.length} characters`);
-  
+function acceptRawTransaction (rawTxHex) {
+  console.log('\n📡 BROADCAST: Raw transaction hex received by miner')
+  console.log(`Raw hex length: ${rawTxHex.length} characters`)
+
   try {
     // Parse the raw transaction hex
-    const transaction = new bsv.Transaction(rawTxHex);
-    console.log(`Transaction ID: ${transaction.id}`);
-    console.log(`Inputs: ${transaction.inputs.length}`);
-    console.log(`Outputs: ${transaction.outputs.length}`);
-    
-    return acceptTransaction(transaction);
-    
+    const transaction = new bsv.Transaction(rawTxHex)
+    console.log(`Transaction ID: ${transaction.id}`)
+    console.log(`Inputs: ${transaction.inputs.length}`)
+    console.log(`Outputs: ${transaction.outputs.length}`)
+
+    return acceptTransaction(transaction)
   } catch (error) {
-    console.log('\n❌ INVALID RAW TRANSACTION');
-    console.log(`Parse error: ${error.message}`);
-    
+    console.log('\n❌ INVALID RAW TRANSACTION')
+    console.log(`Parse error: ${error.message}`)
+
     return {
       accepted: false,
       txid: null,
       errors: [`Failed to parse raw transaction hex: ${error.message}`],
       warnings: []
-    };
+    }
   }
 }
 
 /**
  * Accept and process a broadcast transaction (object or hex)
  */
-function acceptTransaction(transaction) {
+function acceptTransaction (transaction) {
   // If it's a string, treat as raw hex
   if (typeof transaction === 'string') {
-    return acceptRawTransaction(transaction);
+    return acceptRawTransaction(transaction)
   }
-  
-  console.log('\n📡 BROADCAST: Transaction object received by miner');
-  console.log(`Transaction ID: ${transaction.id}`);
-  console.log(`Inputs: ${transaction.inputs.length}`);
-  console.log(`Outputs: ${transaction.outputs.length}`);
-  
+
+  console.log('\n📡 BROADCAST: Transaction object received by miner')
+  console.log(`Transaction ID: ${transaction.id}`)
+  console.log(`Inputs: ${transaction.inputs.length}`)
+  console.log(`Outputs: ${transaction.outputs.length}`)
+
   // Log the raw hex representation
-  const rawHex = transaction.toString();
-  console.log(`📦 Raw Transaction Hex (${rawHex.length} chars):`);
-  console.log(`${rawHex.substring(0, 80)}...`);
-  console.log(`...${rawHex.substring(rawHex.length - 80)}`);
-  
+  const rawHex = transaction.toString()
+  console.log(`📦 Raw Transaction Hex (${rawHex.length} chars):`)
+  console.log(`${rawHex.substring(0, 80)}...`)
+  console.log(`...${rawHex.substring(rawHex.length - 80)}`)
+
   // Validate transaction
-  const validation = validateTransaction(transaction);
-  
+  const validation = validateTransaction(transaction)
+
   if (validation.valid) {
     // Process the transaction
-    processTransaction(transaction);
-    
+    processTransaction(transaction)
+
     return {
       accepted: true,
       txid: transaction.id,
       errors: validation.errors,
       warnings: validation.warnings
-    };
+    }
   } else {
-    console.log(`\n🚫 Transaction ${transaction.id} REJECTED`);
-    
+    console.log(`\n🚫 Transaction ${transaction.id} REJECTED`)
+
     return {
       accepted: false,
       txid: transaction.id,
       errors: validation.errors,
       warnings: validation.warnings
-    };
+    }
   }
 }
 
 /**
  * Get mempool status (simplified)
  */
-function getMempoolStatus() {
-  const state = loadBlockchainState();
-  
-  console.log('\n📊 Miner/Mempool Status:');
-  console.log('═'.repeat(50));
-  console.log(`🏗️  Current Block Height: ${state.metadata.blockHeight}`);
-  console.log(`🔄 Transactions Processed: ${state.transactionHistory.length}`);
-  console.log(`💰 Total Network Value: ${state.metadata.totalValue} satoshis`);
-  console.log(`👛 Active Wallets: ${state.metadata.totalWallets}`);
-  console.log(`📦 Available UTXOs: ${state.metadata.totalUTXOs}`);
-  
-  return state;
+function getMempoolStatus () {
+  const state = loadBlockchainState()
+
+  console.log('\n📊 Miner/Mempool Status:')
+  console.log('═'.repeat(50))
+  console.log(`🏗️  Current Block Height: ${state.metadata.blockHeight}`)
+  console.log(`🔄 Transactions Processed: ${state.transactionHistory.length}`)
+  console.log(`💰 Total Network Value: ${state.metadata.totalValue} satoshis`)
+  console.log(`👛 Active Wallets: ${state.metadata.totalWallets}`)
+  console.log(`📦 Available UTXOs: ${state.metadata.totalUTXOs}`)
+
+  return state
 }
 
 // If called directly, show mempool status
 if (require.main === module) {
-  getMempoolStatus();
+  getMempoolStatus()
 }
 
 module.exports = {
@@ -617,4 +613,4 @@ module.exports = {
   processTransaction,
   getMempoolStatus,
   ValidationResult
-};
+}