@smartledger/bsv 3.1.1 → 3.2.0

package/examples/preimage/generate_sample_preimage.js

@@ -0,0 +1,208 @@
+#!/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

@@ -0,0 +1,152 @@
+#!/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

@@ -0,0 +1,117 @@
+#!/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

@@ -0,0 +1,53 @@
+#!/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

@@ -0,0 +1,95 @@
+#!/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.');