smartledger-bsv 3.0.1 → 3.0.2

package/utilities/mock-utxo-generator.js

@@ -0,0 +1,149 @@
+/**
+ * mock_utxo_generator.js
+ *
+ * Usage:
+ *   # generate a new random private key and a mock utxo (default satoshis = 100000)
+ *   node mock_utxo_generator.js
+ *
+ *   # provide WIF and create a utxo
+ *   node mock_utxo_generator.js <WIF>
+ *
+ *   # provide WIF, set satoshis, and optionally create a signed tx to a recipient
+ *   node mock_utxo_generator.js <WIF> <satoshis> <recipientAddress>
+ *
+ * Example:
+ *   node mock_utxo_generator.js L1aW4aubDFB7yfras2S1mMEW7bZ1aW4aubD 50000 muZ... (example address)
+ *
+ * Notes:
+ * - Requires `bsv` package: npm install bsv
+ * - This is for LOCAL TESTING only. The produced txid, utxo, and tx hex are fake/mock and
+ *   intended to be consumed by local test harnesses or unit tests (or regtest setups if you
+ *   create a matching real TX there).
+ */
+
+const bsv = require('../index.js');
+const crypto = require('crypto');
+
+function usage() {
+  console.log('Usage: node mock_utxo_generator.js [WIF] [satoshis] [recipientAddress]');
+  console.log('If WIF omitted, a random private key is generated.');
+}
+
+function randomHex(len) {
+  return crypto.randomBytes(len).toString('hex');
+}
+
+function createMockTxId() {
+  // create random 32-byte hex as fake txid (little-endian vs big-endian not important for mocks)
+  return randomHex(32);
+}
+
+function buildP2pkhScriptHex(address) {
+  return bsv.Script.buildPublicKeyHashOut(address).toHex();
+}
+
+function mkUtxo(privateKey, sats = 100000) {
+  const address = privateKey.toAddress().toString();
+  const txid = createMockTxId();
+  const vout = 0;
+  const scriptHex = buildP2pkhScriptHex(address);
+
+  // Return a utxo shape compatible with bsv.Transaction().from(...)
+  return {
+    txId: txid,
+    txid: txid,             // alternate naming used by some code
+    vout: vout,
+    outputIndex: vout,      // bsv accepts outputIndex or vout
+    satoshis: sats,
+    value: sats,
+    script: scriptHex,
+    scriptPubKey: scriptHex,
+    address,
+  };
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.includes('-h') || argv.includes('--help')) {
+    usage();
+    return;
+  }
+
+  const maybeWif = argv[0];
+  const maybeSatoshis = argv[1];
+  const recipient = argv[2];
+
+  let privateKey;
+  try {
+    if (maybeWif) {
+      // try to load from WIF
+      privateKey = bsv.PrivateKey.fromWIF(maybeWif);
+    } else {
+      privateKey = new bsv.PrivateKey(); // random
+    }
+  } catch (e) {
+    console.error('Invalid WIF provided. Exiting.');
+    process.exit(1);
+  }
+
+  const satoshis = maybeSatoshis ? parseInt(maybeSatoshis, 10) : 100000;
+  if (Number.isNaN(satoshis) || satoshis <= 0) {
+    console.error('Invalid satoshis amount. Must be positive integer.');
+    process.exit(1);
+  }
+
+  const utxo = mkUtxo(privateKey, satoshis);
+
+  console.log('\n=== MOCK UTXO ===');
+  console.log(JSON.stringify({
+    privateKeyWIF: privateKey.toWIF(),
+    privateKeyHex: privateKey.toString('hex'),
+    address: utxo.address,
+    utxo: {
+      txid: utxo.txid,
+      vout: utxo.vout,
+      scriptPubKey: utxo.scriptPubKey,
+      satoshis: utxo.satoshis
+    }
+  }, null, 2));
+  console.log('=================\n');
+
+  if (recipient) {
+    // Build a small tx that spends the mock utxo and sends everything minus a tiny fee
+    try {
+      const fee = 500; // tiny fee for local testing
+      const sendAmount = Math.max(0, utxo.satoshis - fee);
+      if (sendAmount <= 0) {
+        console.error('UTXO too small to cover fee. Increase satoshis or reduce fee.');
+        process.exit(1);
+      }
+
+      // Build transaction using bsv.Transaction.from style
+      const tx = new bsv.Transaction()
+        .from({
+          txId: utxo.txid,
+          outputIndex: utxo.outputIndex,
+          script: utxo.script,
+          satoshis: utxo.satoshis
+        })
+        .to(recipient, sendAmount)
+        // .change(utxo.address) // not necessary here because we send everything minus fee
+        .sign(privateKey);
+
+      console.log('=== SIGNED SPEND TX ===');
+      console.log('TX HEX:', tx.toString());
+      console.log('TX ID (hash):', tx.hash);
+      console.log('fee (mock):', fee);
+      console.log('sendAmount:', sendAmount);
+      console.log('========================\n');
+
+      console.log('Note: This TX is signed against our mock UTXO and can be used in local tests that accept fake txids.');
+    } catch (e) {
+      console.error('Failed to build or sign tx:', e);
+    }
+  } else {
+    console.log('No recipient provided. To produce a signed spending tx, run again with a recipient address as the 3rd arg.');
+  }
+}
+
+main();

package/utilities/raw-tx-examples.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+/**
+ * 🔧 BSV Raw Transaction Hex Validation Example
+ * 
+ * Demonstrates sending raw transaction hex to the miner for validation
+ * using the BSV script interpreter for proper signature verification.
+ */
+
+const bsv = require('../index.js');
+const { 
+  acceptTransaction, 
+  acceptRawTransaction 
+} = require('./miner-simulator');
+const { 
+  loadConfig 
+} = require('./utxo-manager');
+
+/**
+ * Example: Create and validate raw transaction hex
+ */
+function exampleRawTransactionValidation() {
+  console.log('🔧 BSV Raw Transaction Hex Validation Example');
+  console.log('═'.repeat(80));
+  
+  try {
+    // Load wallet config
+    const config = loadConfig();
+    const wallet = config.wallet;
+    
+    // Create recipient
+    const recipientKey = new bsv.PrivateKey();
+    const recipientAddress = recipientKey.toAddress().toString();
+    
+    // Get available UTXO
+    const utxo = config.utxo;
+    
+    console.log('📋 Transaction Details:');
+    console.log(`👛 From: ${wallet.address}`);
+    console.log(`🎯 To: ${recipientAddress}`);
+    console.log(`💰 Amount: 10,000 satoshis`);
+    console.log(`💳 Using UTXO: ${utxo.txid}:${utxo.vout} (${utxo.satoshis} sats)\n`);
+    
+    // Create transaction with proper SIGHASH_FORKID
+    const tx = new bsv.Transaction()
+      .from(utxo)
+      .to(recipientAddress, 10000)
+      .change(wallet.address)
+      .fee(1000)
+      .sign(bsv.PrivateKey.fromWIF(wallet.privateKeyWIF), bsv.crypto.Signature.SIGHASH_ALL | bsv.crypto.Signature.SIGHASH_FORKID);
+    
+    console.log('✅ Transaction created successfully');
+    console.log(`🆔 Transaction ID: ${tx.id}`);
+    
+    // Get raw transaction hex
+    const rawHex = tx.toString();
+    console.log(`\n📦 Raw Transaction Hex (${rawHex.length} chars):`);
+    console.log(`${rawHex.substring(0, 80)}...`);
+    console.log(`...${rawHex.substring(rawHex.length - 80)}`);
+    
+    // Method 1: Send transaction object
+    console.log('\n' + '─'.repeat(60));
+    console.log('🔄 Method 1: Sending Transaction Object');
+    console.log('─'.repeat(60));
+    
+    const result1 = acceptTransaction(tx);
+    console.log(`\nResult: ${result1.accepted ? '✅ ACCEPTED' : '❌ REJECTED'}`);
+    if (result1.errors.length > 0) {
+      console.log('Errors:', result1.errors);
+    }
+    
+    // Method 2: Send raw transaction hex
+    console.log('\n' + '─'.repeat(60));
+    console.log('🔄 Method 2: Sending Raw Transaction Hex');
+    console.log('─'.repeat(60));
+    
+    const result2 = acceptRawTransaction(rawHex);
+    console.log(`\nResult: ${result2.accepted ? '✅ ACCEPTED' : '❌ REJECTED'}`);
+    if (result2.errors.length > 0) {
+      console.log('Errors:', result2.errors);
+    }
+    
+    console.log('\n🎯 Both methods should produce identical validation results!');
+    
+  } catch (error) {
+    console.error('❌ Error in example:', error.message);
+  }
+}
+
+/**
+ * Example: Test invalid raw transaction hex
+ */
+function exampleInvalidRawHex() {
+  console.log('\n' + '═'.repeat(80));
+  console.log('🚫 Testing Invalid Raw Transaction Hex');
+  console.log('═'.repeat(80));
+  
+  // Test various invalid hex scenarios
+  const invalidHexExamples = [
+    {
+      name: 'Too short hex',
+      hex: '01000000',
+      description: 'Transaction hex too short'
+    },
+    {
+      name: 'Invalid characters',
+      hex: '0100000001INVALID_HEX_CHARACTERS',
+      description: 'Contains non-hex characters'
+    },
+    {
+      name: 'Malformed structure',
+      hex: '01000000010000000000000000000000000000000000000000000000000000000000000000',
+      description: 'Valid hex but malformed transaction structure'
+    }
+  ];
+  
+  invalidHexExamples.forEach((example, index) => {
+    console.log(`\n${index + 1}. ${example.name}:`);
+    console.log(`   Description: ${example.description}`);
+    console.log(`   Hex: ${example.hex}`);
+    
+    const result = acceptRawTransaction(example.hex);
+    console.log(`   Result: ${result.accepted ? '✅ ACCEPTED' : '❌ REJECTED'} (Expected: REJECTED)`);
+    
+    if (result.errors.length > 0) {
+      console.log(`   Error: ${result.errors[0]}`);
+    }
+  });
+}
+
+/**
+ * Example: Parse and analyze transaction components
+ */
+function exampleTransactionAnalysis() {
+  console.log('\n' + '═'.repeat(80));
+  console.log('🔍 Transaction Component Analysis');
+  console.log('═'.repeat(80));
+  
+  try {
+    const config = loadConfig();
+    const wallet = config.wallet;
+    const utxo = config.utxo;
+    
+    // Create simple transaction with proper SIGHASH_FORKID
+    const tx = new bsv.Transaction()
+      .from(utxo)
+      .to(new bsv.PrivateKey().toAddress(), 5000)
+      .change(wallet.address)
+      .fee(500)
+      .sign(bsv.PrivateKey.fromWIF(wallet.privateKeyWIF), bsv.crypto.Signature.SIGHASH_ALL | bsv.crypto.Signature.SIGHASH_FORKID);
+    
+    const rawHex = tx.toString();
+    
+    console.log('📋 Transaction Analysis:');
+    console.log(`🆔 TXID: ${tx.id}`);
+    console.log(`📦 Raw Hex: ${rawHex}`);
+    console.log(`📏 Size: ${rawHex.length / 2} bytes`);
+    console.log(`💰 Fee: ${tx.getFee()} satoshis`);
+    
+    console.log('\n🔍 Input Details:');
+    tx.inputs.forEach((input, i) => {
+      console.log(`  Input ${i}:`);
+      console.log(`    Previous TXID: ${input.prevTxId.toString('hex')}`);
+      console.log(`    Output Index: ${input.outputIndex}`);
+      console.log(`    Script: ${input.script.toHex()}`);
+      console.log(`    Script ASM: ${input.script.toASM()}`);
+    });
+    
+    console.log('\n📤 Output Details:');
+    tx.outputs.forEach((output, i) => {
+      console.log(`  Output ${i}:`);
+      console.log(`    Value: ${output.satoshis} satoshis`);
+      console.log(`    Script: ${output.script.toHex()}`);
+      console.log(`    Script ASM: ${output.script.toASM()}`);
+      try {
+        console.log(`    Address: ${output.script.toAddress()}`);
+      } catch (e) {
+        console.log(`    Address: [Non-standard script]`);
+      }
+    });
+    
+  } catch (error) {
+    console.error('❌ Error in analysis:', error.message);
+  }
+}
+
+/**
+ * Run all raw transaction examples
+ */
+function runAllExamples() {
+  exampleRawTransactionValidation();
+  exampleInvalidRawHex();
+  exampleTransactionAnalysis();
+  
+  console.log('\n🎯 Raw transaction validation examples completed!');
+  console.log('💡 The miner now validates transactions using:');
+  console.log('   - Raw hex format validation');
+  console.log('   - UTXO existence checking');
+  console.log('   - BSV script interpreter for signature verification');
+  console.log('   - Transaction balance and structure validation');
+}
+
+// Run examples if called directly
+if (require.main === module) {
+  runAllExamples();
+}
+
+module.exports = {
+  exampleRawTransactionValidation,
+  exampleInvalidRawHex,
+  exampleTransactionAnalysis,
+  runAllExamples
+};

package/utilities/success-demo.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+/**
+ * 🎯 Simple Transaction Success Demo
+ * 
+ * Demonstrates a successful transaction flow with simplified validation
+ * to show the complete mining process working.
+ */
+
+const bsv = require('../index.js');
+const { 
+  loadBlockchainState, 
+  saveBlockchainState,
+  getUTXO,
+  spendUTXO,
+  addUTXO,
+  getBlockchainStats 
+} = require('./blockchain-state');
+const { 
+  loadConfig,
+  updateUTXOFromTransaction
+} = require('./utxo-manager');
+
+/**
+ * Simplified miner that accepts valid transaction structure
+ */
+function acceptTransactionSimplified(transaction) {
+  console.log('\n📡 SIMPLIFIED MINER: Transaction received');
+  console.log(`Transaction ID: ${transaction.id}`);
+  console.log(`Inputs: ${transaction.inputs.length}`);
+  console.log(`Outputs: ${transaction.outputs.length}`);
+  
+  // Basic validation only
+  let isValid = true;
+  const errors = [];
+  
+  // Check UTXO existence
+  for (const input of transaction.inputs) {
+    const prevTxId = input.prevTxId.toString('hex');
+    const outputIndex = input.outputIndex;
+    const utxoResult = getUTXO(prevTxId, outputIndex);
+    
+    if (!utxoResult.exists) {
+      isValid = false;
+      errors.push(`UTXO ${prevTxId}:${outputIndex} does not exist`);
+    } else {
+      console.log(`✅ UTXO ${prevTxId}:${outputIndex} exists (${utxoResult.utxo.satoshis} sats)`);
+    }
+  }
+  
+  // Check basic transaction structure
+  if (transaction.inputs.length === 0) {
+    isValid = false;
+    errors.push('No inputs provided');
+  }
+  
+  if (transaction.outputs.length === 0) {
+    isValid = false;
+    errors.push('No outputs provided');
+  }
+  
+  if (isValid) {
+    console.log('✅ Basic validation passed - Processing transaction...');
+    
+    // Process the transaction
+    const state = loadBlockchainState();
+    
+    // Spend input UTXOs
+    for (const input of transaction.inputs) {
+      const prevTxId = input.prevTxId.toString('hex');
+      const outputIndex = input.outputIndex;
+      spendUTXO(prevTxId, outputIndex, transaction.id);
+    }
+    
+    // Create new UTXOs
+    for (let i = 0; i < transaction.outputs.length; i++) {
+      const output = transaction.outputs[i];
+      try {
+        const outputAddress = output.script.toAddress();
+        const newUTXO = {
+          txid: transaction.id,
+          vout: i,
+          outputIndex: i,
+          script: output.script.toHex(),
+          scriptPubKey: output.script.toHex(),
+          satoshis: output.satoshis,
+          address: outputAddress.toString()
+        };
+        
+        addUTXO(newUTXO, outputAddress.toString());
+        console.log(`✅ Created UTXO ${transaction.id}:${i} -> ${outputAddress} (${output.satoshis} sats)`);
+      } catch (error) {
+        console.error(`❌ Error creating output ${i}: ${error.message}`);
+      }
+    }
+    
+    // Update block height
+    state.metadata.blockHeight += 1;
+    state.transactionHistory.push({
+      txid: transaction.id,
+      processedAt: new Date().toISOString(),
+      inputCount: transaction.inputs.length,
+      outputCount: transaction.outputs.length
+    });
+    
+    saveBlockchainState(state);
+    
+    console.log('🎉 Transaction processed successfully!');
+    console.log(`🏗️  New block height: ${state.metadata.blockHeight}`);
+    
+    return { accepted: true, txid: transaction.id, errors: [] };
+  } else {
+    console.log('❌ Transaction rejected');
+    errors.forEach(error => console.log(`  - ${error}`));
+    return { accepted: false, txid: transaction.id, errors };
+  }
+}
+
+/**
+ * Demo successful transaction
+ */
+function demoSuccessfulTransaction() {
+  console.log('🎯 BSV Successful Transaction Demo');
+  console.log('═'.repeat(80));
+  
+  try {
+    // Load wallet config
+    const config = loadConfig();
+    const wallet = config.wallet;
+    
+    // Create recipient
+    const recipientKey = new bsv.PrivateKey();
+    const recipientAddress = recipientKey.toAddress().toString();
+    
+    // Get UTXO
+    const utxo = config.utxo;
+    
+    console.log('📋 Transaction Setup:');
+    console.log(`👛 From: ${wallet.address}`);
+    console.log(`🎯 To: ${recipientAddress}`);
+    console.log(`💰 Amount: 15,000 satoshis`);
+    console.log(`💳 UTXO: ${utxo.txid}:${utxo.vout} (${utxo.satoshis} sats)`);
+    console.log(`💵 Fee: 1,000 satoshis`);
+    console.log(`🔄 Change: ${utxo.satoshis - 15000 - 1000} satoshis\n`);
+    
+    // Create transaction
+    const tx = new bsv.Transaction()
+      .from(utxo)
+      .to(recipientAddress, 15000)
+      .change(wallet.address)
+      .fee(1000)
+      .sign(bsv.PrivateKey.fromWIF(wallet.privateKeyWIF));
+    
+    console.log('✅ Transaction created:');
+    console.log(`🆔 TXID: ${tx.id}`);
+    console.log(`📦 Raw hex: ${tx.toString()}`);
+    console.log(`📏 Size: ${tx.toString().length / 2} bytes\n`);
+    
+    // Show blockchain state before
+    console.log('📊 Blockchain state BEFORE transaction:');
+    getBlockchainStats();
+    
+    // Process with simplified miner
+    const result = acceptTransactionSimplified(tx);
+    
+    if (result.accepted) {
+      // Update local wallet too
+      updateUTXOFromTransaction(tx, utxo);
+      
+      console.log('\n📊 Blockchain state AFTER transaction:');
+      getBlockchainStats();
+      
+      console.log('\n💰 Local wallet state:');
+      const { loadConfig } = require('./utxo-manager');
+      const updatedConfig = loadConfig();
+      console.log(`Available UTXOs: ${updatedConfig.availableUTXOs?.length || 0}`);
+      console.log(`Total balance: ${updatedConfig.availableUTXOs?.reduce((sum, u) => sum + u.satoshis, 0) || 0} sats`);
+    }
+    
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  demoSuccessfulTransaction();
+}
+
+module.exports = {
+  acceptTransactionSimplified,
+  demoSuccessfulTransaction
+};