smartledger-bsv 3.4.0 → 3.4.4

package/examples/preimage/generate_sample_preimage.js

@@ -1,208 +0,0 @@
-#!/usr/bin/env node
-/**
- * generate_sample_preimage.js
- * Advanced BIP-143 preimage generator with multiple realistic scenarios
- * 
- * Generates various types of preimages for testing bidirectional extraction:
- * - Standard P2PKH transactions
- * - Multi-signature scenarios  
- * - Custom script patterns
- * - Different value ranges
- */
-
-function createSamplePreimage(type = 'standard') {
-  const { Buffer } = require("buffer");
-  
-  // Base fields (same for all types)
-  const baseFields = {
-    nVersion: Buffer.from([0x01, 0x00, 0x00, 0x00]), // Version 1
-    hashPrevouts: Buffer.alloc(32, 0xab), // Mock hash
-    hashSequence: Buffer.alloc(32, 0xcd), // Mock hash  
-    outpoint_txid: Buffer.alloc(32, 0x12), // Mock TXID
-    outpoint_vout: Buffer.from([0x00, 0x00, 0x00, 0x00]), // Output 0
-    nSequence: Buffer.from([0xff, 0xff, 0xff, 0xff]), // Max sequence
-    hashOutputs: Buffer.alloc(32, 0xef), // Mock hash
-    nLocktime: Buffer.from([0x00, 0x00, 0x00, 0x00]), // No locktime
-    sighashType: Buffer.from([0x41, 0x00, 0x00, 0x00]) // SIGHASH_ALL | FORKID
-  };
-  
-  let scriptVariant;
-  
-  switch (type) {
-    case 'standard':
-      // Standard P2PKH (25 bytes)
-      scriptVariant = {
-        scriptLen: Buffer.from([0x19]), // 25 bytes
-        scriptCode: Buffer.from([
-          0x76, 0xa9, 0x14,  // OP_DUP OP_HASH160 OP_PUSHDATA(20)
-          ...Buffer.alloc(20, 0x88),  // 20-byte pubkey hash
-          0x88, 0xac  // OP_EQUALVERIFY OP_CHECKSIG
-        ]),
-        value: Buffer.from([0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00]) // 100000000 satoshis (1 BSV)
-      };
-      break;
-      
-    case 'multisig':
-      // 2-of-3 multisig (71 bytes)
-      scriptVariant = {
-        scriptLen: Buffer.from([0x47]), // 71 bytes
-        scriptCode: Buffer.concat([
-          Buffer.from([0x52]),  // OP_2 (required signatures)
-          Buffer.from([0x21]), Buffer.alloc(33, 0xaa),  // First pubkey (33 bytes)
-          Buffer.from([0x21]), Buffer.alloc(33, 0xbb),  // Second pubkey (33 bytes)  
-          Buffer.from([0x21]), Buffer.alloc(33, 0xcc),  // Third pubkey (33 bytes)
-          Buffer.from([0x53]),  // OP_3 (total pubkeys)
-          Buffer.from([0xae])   // OP_CHECKMULTISIG
-        ]),
-        value: Buffer.from([0x00, 0x40, 0x42, 0x0f, 0x00, 0x00, 0x00, 0x00]) // 2.56 BSV
-      };
-      break;
-      
-    case 'custom':
-      // Custom script with OP_RETURN data (34 bytes)
-      scriptVariant = {
-        scriptLen: Buffer.from([0x22]), // 34 bytes
-        scriptCode: Buffer.concat([
-          Buffer.from([0x6a]),  // OP_RETURN
-          Buffer.from([0x20]),  // Push 32 bytes
-          Buffer.from('Hello Bitcoin SV - Custom Script Test', 'utf8').slice(0, 32)
-        ]),
-        value: Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) // 0 satoshis (OP_RETURN output)
-      };
-      break;
-      
-    case 'large':
-      // Large script (300 bytes) to test CompactSize 3-byte varint (0xFD)
-      const scriptSize = 300;
-      scriptVariant = {
-        scriptLen: Buffer.from([0xfd, scriptSize & 0xff, (scriptSize >> 8) & 0xff]), // 3-byte varint: 0xFD + 2-byte LE
-        scriptCode: Buffer.concat([
-          Buffer.from([0x76, 0xa9, 0x14]), // OP_DUP OP_HASH160 OP_PUSHDATA(20)
-          Buffer.alloc(20, 0x99), // 20-byte pubkey hash
-          Buffer.from([0x88, 0xac]), // OP_EQUALVERIFY OP_CHECKSIG  
-          Buffer.alloc(275, 0x6a) // Padding with OP_RETURN opcodes to reach 300 bytes
-        ]),
-        value: Buffer.from([0x00, 0x10, 0xa5, 0xd4, 0xe8, 0x00, 0x00, 0x00]) // 10 BSV
-      };
-      break;
-      
-    case 'huge':
-      // Huge script (70000 bytes) to test CompactSize 5-byte varint (0xFE) 
-      const hugeSize = 70000;
-      scriptVariant = {
-        scriptLen: Buffer.from([
-          0xfe, 
-          hugeSize & 0xff, 
-          (hugeSize >> 8) & 0xff, 
-          (hugeSize >> 16) & 0xff, 
-          (hugeSize >> 24) & 0xff
-        ]), // 5-byte varint: 0xFE + 4-byte LE
-        scriptCode: Buffer.concat([
-          Buffer.from([0x6a]), // OP_RETURN
-          Buffer.from([0x4c, 0xff, 0xff]), // OP_PUSHDATA2 + 65535 bytes
-          Buffer.alloc(65535, 0xaa), // Large data block
-          Buffer.alloc(hugeSize - 65539, 0xbb) // Remaining padding
-        ]),
-        value: Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) // 0 satoshis (data output)
-      };
-      break;
-      
-    default:
-      throw new Error(`Unknown preimage type: ${type}`);
-  }
-  
-  const fields = { ...baseFields, ...scriptVariant };
-  
-  // Concatenate all fields
-  const preimage = Buffer.concat([
-    fields.nVersion,
-    fields.hashPrevouts,
-    fields.hashSequence,
-    fields.outpoint_txid,
-    fields.outpoint_vout,
-    fields.scriptLen,
-    fields.scriptCode,
-    fields.value,
-    fields.nSequence,
-    fields.hashOutputs,
-    fields.nLocktime,
-    fields.sighashType
-  ]);
-  
-  return preimage.toString('hex');
-}
-
-// CLI Interface
-if (require.main === module) {
-  const type = process.argv[2] || 'standard';
-  
-  if (type === '--help' || type === '-h') {
-    console.log("🎯 Advanced BIP-143 Preimage Generator");
-    console.log("=====================================");
-    console.log("Usage: node generate_sample_preimage.js [type]");
-    console.log("");
-    console.log("Available types:");
-    console.log("  standard   - Standard P2PKH script (25 bytes, 1-byte varint) - DEFAULT");
-    console.log("  multisig   - 2-of-3 multisig script (71 bytes, 1-byte varint)");
-    console.log("  custom     - Custom OP_RETURN script (34 bytes, 1-byte varint)");
-    console.log("  large      - Large script (300 bytes, 3-byte varint 0xFD)");
-    console.log("  huge       - Huge script (70000 bytes, 5-byte varint 0xFE)");
-    console.log("");
-    console.log("Examples:");
-    console.log("  node generate_sample_preimage.js");
-    console.log("  node generate_sample_preimage.js multisig");
-    console.log("  node generate_sample_preimage.js large    # Test 3-byte varint");
-    console.log("  node generate_sample_preimage.js huge     # Test 5-byte varint");
-    process.exit(0);
-  }
-  
-  try {
-    console.log("🎯 Advanced BIP-143 Preimage Generator");
-    console.log("=====================================");
-    console.log(`📋 Type: ${type}`);
-    
-    const sampleHex = createSamplePreimage(type);
-    const scriptLen = parseInt(sampleHex.substring(208, 210), 16); // Extract scriptLen byte
-    
-    console.log(`📊 Generated: ${sampleHex.length / 2} bytes total`);
-    console.log(`📏 Structure: LEFT(105) + scriptCode(${scriptLen}) + RIGHT(52) bytes`);
-    console.log(`📦 Preimage: ${sampleHex}`);
-    
-    console.log("\n🧪 Test Commands:");
-    console.log(`   node extract_preimage_bidirectional.js ${sampleHex} scriptCode`);
-    console.log(`   node extract_preimage_bidirectional.js ${sampleHex} value`);
-    console.log(`   npm run preimage:extract ${sampleHex} nVersion`);
-    
-    console.log("\n🔍 Field Analysis:");
-    console.log(`   LEFT extraction:    nVersion, hashPrevouts, hashSequence, outpoint_*, scriptLen`);
-    console.log(`   DYNAMIC extraction: scriptCode (${scriptLen} bytes)`);
-    console.log(`   RIGHT extraction:   value, nSequence, hashOutputs, nLocktime, sighashType`);
-    
-  } catch (error) {
-    console.error("❌ Error:", error.message);
-    console.log("💡 Use --help to see available types");
-    process.exit(1);
-  }
-}
-
-// Export functions for programmatic use
-function generateAllTypes() {
-  return {
-    standard: createSamplePreimage('standard'),
-    multisig: createSamplePreimage('multisig'), 
-    custom: createSamplePreimage('custom'),
-    large: createSamplePreimage('large')
-  };
-}
-
-module.exports = { 
-  createSamplePreimage,
-  generateAllTypes,
-  
-  // Convenience functions
-  getStandardPreimage: () => createSamplePreimage('standard'),
-  getMultisigPreimage: () => createSamplePreimage('multisig'),
-  getCustomPreimage: () => createSamplePreimage('custom'),
-  getLargePreimage: () => createSamplePreimage('large'),
-  getHugePreimage: () => createSamplePreimage('huge')
-};

package/examples/preimage/generate_sighash_examples.js

@@ -1,152 +0,0 @@
-#!/usr/bin/env node
-/**
- * generate_sighash_examples.js  
- * Generate preimages demonstrating SIGHASH flag behavior that causes "zero hashes"
- * This explains the "extra zeros" that confuse developers in multi-input scenarios
- */
-
-const { Buffer } = require("buffer");
-
-function createSighashPreimage(sighashType = 'ALL_FORKID') {
-  // SIGHASH type mappings
-  const sighashTypes = {
-    'ALL': 0x01,
-    'ALL_FORKID': 0x41,
-    'NONE_FORKID': 0x42, 
-    'SINGLE_FORKID': 0x43,
-    'ALL_ANYONECANPAY_FORKID': 0xc1,
-    'NONE_ANYONECANPAY_FORKID': 0xc2,
-    'SINGLE_ANYONECANPAY_FORKID': 0xc3
-  };
-  
-  const sigType = sighashTypes[sighashType];
-  if (!sigType) {
-    throw new Error(`Unknown sighash type: ${sighashType}`);
-  }
-  
-  // Base preimage components
-  const nVersion = Buffer.from([0x01, 0x00, 0x00, 0x00]);
-  const outpoint_txid = Buffer.alloc(32, 0xaa);
-  const outpoint_vout = Buffer.from([0x00, 0x00, 0x00, 0x00]);
-  const scriptCode = Buffer.from([
-    0x76, 0xa9, 0x14,  // OP_DUP OP_HASH160 OP_PUSHDATA(20)
-    ...Buffer.alloc(20, 0x88),  // 20-byte pubkey hash
-    0x88, 0xac  // OP_EQUALVERIFY OP_CHECKSIG
-  ]);
-  const scriptLen = Buffer.from([scriptCode.length]);
-  const value = Buffer.from([0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00]);
-  const nSequence = Buffer.from([0xff, 0xff, 0xff, 0xff]);
-  const nLocktime = Buffer.from([0x00, 0x00, 0x00, 0x00]);
-  const sighashTypeBuffer = Buffer.from([sigType, 0x00, 0x00, 0x00]);
-  
-  // Apply SIGHASH rules for hash fields
-  let hashPrevouts, hashSequence, hashOutputs;
-  
-  if (sigType & 0x80) { // ANYONECANPAY flag
-    hashPrevouts = Buffer.alloc(32, 0x00); // Zero hash
-    hashSequence = Buffer.alloc(32, 0x00); // Zero hash
-  } else {
-    hashPrevouts = Buffer.alloc(32, 0xab); // Normal hash
-    hashSequence = Buffer.alloc(32, 0xcd); // Normal hash
-  }
-  
-  if ((sigType & 0x1f) === 0x02) { // SIGHASH_NONE
-    hashOutputs = Buffer.alloc(32, 0x00); // Zero hash
-  } else if ((sigType & 0x1f) === 0x03) { // SIGHASH_SINGLE  
-    hashOutputs = Buffer.alloc(32, 0x00); // Zero hash (simplified)
-  } else {
-    hashOutputs = Buffer.alloc(32, 0xef); // Normal hash
-  }
-  
-  // Construct preimage
-  const preimage = Buffer.concat([
-    nVersion,
-    hashPrevouts,
-    hashSequence,
-    outpoint_txid,
-    outpoint_vout,
-    scriptLen,
-    scriptCode,
-    value,
-    nSequence,
-    hashOutputs,
-    nLocktime,
-    sighashTypeBuffer
-  ]);
-  
-  return {
-    hex: preimage.toString('hex'),
-    analysis: {
-      sighashType: sighashType,
-      sighashValue: `0x${sigType.toString(16).padStart(2, '0')}`,
-      hashPrevouts: hashPrevouts.equals(Buffer.alloc(32, 0x00)) ? 'ZERO (ANYONECANPAY)' : 'NORMAL',
-      hashSequence: hashSequence.equals(Buffer.alloc(32, 0x00)) ? 'ZERO (ANYONECANPAY)' : 'NORMAL',  
-      hashOutputs: hashOutputs.equals(Buffer.alloc(32, 0x00)) ? 'ZERO (NONE/SINGLE)' : 'NORMAL'
-    }
-  };
-}
-
-// CLI Interface
-if (require.main === module) {
-  const sighashType = process.argv[2] || 'ALL_FORKID';
-  
-  if (sighashType === '--help' || sighashType === '-h') {
-    console.log("🔏 SIGHASH Flag Preimage Generator");
-    console.log("=================================");
-    console.log("Demonstrates how SIGHASH flags create 'zero hashes' in BIP-143 preimages");
-    console.log("");
-    console.log("Usage: node generate_sighash_examples.js [sighash_type]");
-    console.log("");
-    console.log("Available SIGHASH types:");
-    console.log("  ALL_FORKID                - Standard: all inputs/outputs (0x41) - DEFAULT");
-    console.log("  NONE_FORKID               - Zero hashOutputs (0x42)");
-    console.log("  SINGLE_FORKID             - Zero hashOutputs for single mode (0x43)");
-    console.log("  ALL_ANYONECANPAY_FORKID   - Zero hashPrevouts + hashSequence (0xC1)");
-    console.log("  NONE_ANYONECANPAY_FORKID  - Zero all hash fields (0xC2)");
-    console.log("");
-    console.log("Examples:");
-    console.log("  node generate_sighash_examples.js ALL_FORKID");
-    console.log("  node generate_sighash_examples.js ALL_ANYONECANPAY_FORKID");
-    console.log("  node generate_sighash_examples.js NONE_FORKID");
-    process.exit(0);
-  }
-  
-  try {
-    console.log("🔏 SIGHASH Flag Preimage Analysis");
-    console.log("=================================");
-    console.log(`📋 SIGHASH Type: ${sighashType}`);
-    
-    const result = createSighashPreimage(sighashType);
-    
-    console.log(`📊 Generated: ${result.hex.length / 2} bytes`);
-    console.log(`🔍 SIGHASH Value: ${result.analysis.sighashValue}`);
-    console.log("");
-    console.log("🧬 Hash Field Analysis:");
-    console.log(`   hashPrevouts: ${result.analysis.hashPrevouts}`);
-    console.log(`   hashSequence: ${result.analysis.hashSequence}`);  
-    console.log(`   hashOutputs:  ${result.analysis.hashOutputs}`);
-    console.log("");
-    
-    if (result.analysis.hashPrevouts === 'ZERO' || 
-        result.analysis.hashSequence === 'ZERO' || 
-        result.analysis.hashOutputs === 'ZERO') {
-      console.log("⚠️  ZERO HASH DETECTED!");
-      console.log("   This explains 'extra zeros' developers see in multi-input preimages.");
-      console.log("   These are NOT bugs - they're required by BIP-143 SIGHASH rules.");
-    }
-    
-    console.log(`📦 Preimage: ${result.hex}`);
-    console.log("");
-    console.log("🧪 Test Commands:");
-    console.log(`   node extract_preimage_bidirectional.js ${result.hex} hashPrevouts`);
-    console.log(`   node extract_preimage_bidirectional.js ${result.hex} hashOutputs`);
-    console.log(`   node extract_preimage_bidirectional.js ${result.hex} sighashType`);
-    
-  } catch (error) {
-    console.error("❌ Error:", error.message);
-    console.log("💡 Use --help to see available SIGHASH types");
-    process.exit(1);
-  }
-}
-
-module.exports = { createSighashPreimage };

package/examples/preimage/parse_preimage.js

@@ -1,117 +0,0 @@
-#!/usr/bin/env node
-/**
- * parse_preimage.js
- *
- * Extracts all parts of a Bitcoin (BSV/BTC-style) preimage from a raw hex string.
- * Works for preimages that follow the standard structure:
- *
- *  1. nVersion (4 bytes)
- *  2. hashPrevouts (32 bytes)
- *  3. hashSequence (32 bytes)
- *  4. outpoint (32 bytes + 4 bytes)
- *  5. scriptCode (variable length)
- *  6. value (8 bytes)
- *  7. nSequence (4 bytes)
- *  8. hashOutputs (32 bytes)
- *  9. nLocktime (4 bytes)
- * 10. sighashType (4 bytes)
- */
-
-const Buffer = require('buffer').Buffer;
-// =============================
-// Helper Functions
-// =============================
-function readLE(buffer, offset, length) {
-  return buffer.slice(offset, offset + length).reverse().toString('hex');
-}
-
-function readBE(buffer, offset, length) {
-  return buffer.slice(offset, offset + length).toString('hex');
-}
-
-function readUInt32LE(buffer, offset) {
-  return buffer.readUInt32LE(offset);
-}
-
-function readUInt64LE(buffer, offset) {
-  // Node.js Buffer has no readUInt64LE natively
-  const lo = buffer.readUInt32LE(offset);
-  const hi = buffer.readUInt32LE(offset + 4);
-  return hi * 0x100000000 + lo;
-}
-
-// =============================
-// Main Parse Function
-// =============================
-function parsePreimage(hex) {
-  const buf = Buffer.from(hex, 'hex');
-  let offset = 0;
-  const result = {};
-
-  result.nVersion = buf.readUInt32LE(offset);
-  offset += 4;
-
-  result.hashPrevouts = readBE(buf, offset, 32);
-  offset += 32;
-
-  result.hashSequence = readBE(buf, offset, 32);
-  offset += 32;
-
-  result.outpoint = {
-    txid: readBE(buf, offset, 32),
-    vout: buf.readUInt32LE(offset + 32),
-  };
-  offset += 36;
-
-  // NOTE: scriptCode is variable length; next byte(s) determine its length
-  const scriptLen = buf[offset];
-  offset += 1;
-  result.scriptCode = readBE(buf, offset, scriptLen);
-  offset += scriptLen;
-
-  result.value = readUInt64LE(buf, offset);
-  offset += 8;
-
-  result.nSequence = buf.readUInt32LE(offset);
-  offset += 4;
-
-  result.hashOutputs = readBE(buf, offset, 32);
-  offset += 32;
-
-  result.nLocktime = buf.readUInt32LE(offset);
-  offset += 4;
-
-  result.sighashType = buf.readUInt32LE(offset);
-  offset += 4;
-
-  return result;
-}
-
-// =============================
-// Example Usage
-// =============================
-
-if (process.argv.length < 3) {
-  console.log("Usage: node parse_preimage.js <raw_preimage_hex>");
-  process.exit(1);
-}
-
-// CLI usage
-if (require.main === module) {
-  const hex = process.argv[2];
-  const parsed = parsePreimage(hex);
-
-  console.log("🔍 Parsed Transaction Preimage:\n");
-  for (const [key, value] of Object.entries(parsed)) {
-    console.log(`${key}:`, value);
-  }
-}
-
-// Module exports for programmatic use
-module.exports = {
-  parsePreimage,
-  readLE,
-  readBE,
-  readUInt32LE,
-  readUInt64LE
-};

package/examples/preimage/test_preimage_extractor.js

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-/**
- * test_preimage_extractor.js
- * Test the bidirectional preimage extractor with sample data
- */
-
-const { execSync } = require('child_process');
-const path = require('path');
-
-// Sample BIP-143 preimage (properly structured) 
-const samplePreimage = '01000000' + // nVersion (4 bytes)
-  'aa'.repeat(32) + // hashPrevouts (32 bytes)
-  'bb'.repeat(32) + // hashSequence (32 bytes) 
-  'cc'.repeat(32) + // outpoint_txid (32 bytes)
-  '00000000' + // outpoint_vout (4 bytes)
-  '19' + // scriptLen (1 byte = 25 decimal)
-  '76a914' + 'dd'.repeat(20) + '88ac' + // scriptCode (25 bytes - standard P2PKH)
-  '0010a5d4e8000000' + // value (8 bytes = 1000000000000 satoshis)
-  'ffffffff' + // nSequence (4 bytes)
-  'ee'.repeat(32) + // hashOutputs (32 bytes)
-  '00000000' + // nLocktime (4 bytes)
-  '41000000'; // sighashType (4 bytes = SIGHASH_ALL | FORKID)
-
-const extractorPath = path.join(__dirname, 'extract_preimage_bidirectional.js');
-
-console.log('🧪 Testing Bidirectional Preimage Extractor');
-console.log('=' .repeat(60));
-console.log(`📊 Sample preimage: ${samplePreimage.length/2} bytes`);
-
-// Test different field types
-const testFields = [
-  'nVersion',    // LEFT field
-  'scriptCode',  // DYNAMIC field
-  'value',       // RIGHT field
-  'sighashType'  // RIGHT field
-];
-
-testFields.forEach(field => {
-  console.log(`\n🔍 Testing extraction of "${field}":`);
-  try {
-    const result = execSync(
-      `node "${extractorPath}" "${samplePreimage}" "${field}"`,
-      { encoding: 'utf8', cwd: path.dirname(extractorPath) }
-    );
-    console.log('✅ SUCCESS');
-  } catch (error) {
-    console.log('❌ ERROR:', error.message.split('\n')[0]);
-  }
-});
-
-console.log('\n' + '='.repeat(60));
-console.log('🎯 All tests completed! The extractor is working correctly.');
-console.log('💡 Try manual tests with: npm run preimage:extract <hex> <field>');

package/examples/preimage/test_varint_extraction.js

@@ -1,95 +0,0 @@
-#!/usr/bin/env node
-/**
- * test_varint_extraction.js
- * Test CompactSize varint extraction with various sizes
- */
-
-const { execSync } = require('child_process');
-const path = require('path');
-
-// Create test preimages with different varint sizes
-const createTestPreimage = (scriptSize) => {
-  let scriptLen;
-  
-  if (scriptSize < 253) {
-    // 1-byte encoding
-    scriptLen = Buffer.from([scriptSize]);
-  } else if (scriptSize <= 65535) {
-    // 3-byte encoding: 0xFD + 2-byte little-endian
-    scriptLen = Buffer.from([0xfd, scriptSize & 0xff, (scriptSize >> 8) & 0xff]);
-  } else {
-    // 5-byte encoding: 0xFE + 4-byte little-endian
-    scriptLen = Buffer.from([
-      0xfe, 
-      scriptSize & 0xff, 
-      (scriptSize >> 8) & 0xff, 
-      (scriptSize >> 16) & 0xff, 
-      (scriptSize >> 24) & 0xff
-    ]);
-  }
-  
-  // Fixed components
-  const leftFixed = Buffer.concat([
-    Buffer.from([0x01, 0x00, 0x00, 0x00]), // nVersion
-    Buffer.alloc(32, 0xaa), // hashPrevouts
-    Buffer.alloc(32, 0xbb), // hashSequence
-    Buffer.alloc(32, 0xcc), // outpoint_txid
-    Buffer.from([0x00, 0x00, 0x00, 0x00]) // outpoint_vout
-  ]);
-  
-  const scriptCode = Buffer.alloc(scriptSize, 0x6a); // Fill with OP_RETURN
-  
-  const rightFixed = Buffer.concat([
-    Buffer.from([0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00]), // value
-    Buffer.from([0xff, 0xff, 0xff, 0xff]), // nSequence
-    Buffer.alloc(32, 0xee), // hashOutputs
-    Buffer.from([0x00, 0x00, 0x00, 0x00]), // nLocktime
-    Buffer.from([0x41, 0x00, 0x00, 0x00]) // sighashType
-  ]);
-  
-  const preimage = Buffer.concat([leftFixed, scriptLen, scriptCode, rightFixed]);
-  return preimage.toString('hex');
-};
-
-const testCases = [
-  { name: "1-byte varint", size: 25 },
-  { name: "1-byte varint (max)", size: 252 },
-  { name: "3-byte varint (min)", size: 253 },
-  { name: "3-byte varint", size: 300 },
-  { name: "3-byte varint (large)", size: 1000 },
-  { name: "3-byte varint (max)", size: 65535 }
-];
-
-console.log('🧪 CompactSize Varint Extraction Test Suite');
-console.log('=' .repeat(60));
-
-testCases.forEach(test => {
-  console.log(`\n🔍 Testing ${test.name} (${test.size} bytes):`);
-  
-  const preimageHex = createTestPreimage(test.size);
-  const totalSize = preimageHex.length / 2;
-  
-  console.log(`   📏 Total preimage: ${totalSize} bytes`);
-  
-  try {
-    const extractorPath = path.join(__dirname, 'extract_preimage_bidirectional.js');
-    const result = execSync(
-      `node "${extractorPath}" "${preimageHex}" "scriptLen"`,
-      { encoding: 'utf8', cwd: __dirname }
-    );
-    
-    // Extract the decoded value from output
-    const match = result.match(/Decoded value: (\d+)/);
-    if (match && parseInt(match[1]) === test.size) {
-      console.log(`   ✅ SUCCESS: Correctly decoded ${test.size} bytes`);
-    } else {
-      console.log(`   ❌ FAILED: Expected ${test.size}, got ${match ? match[1] : 'unknown'}`);
-    }
-  } catch (error) {
-    console.log(`   ❌ ERROR: ${error.message.split('\n')[0]}`);
-  }
-});
-
-console.log('\n' + '='.repeat(60));
-console.log('🎯 Varint extraction test completed!');
-console.log('💡 This validates BIP-143 CompactSize compliance for multi-input transactions.');