@smartledger/bsv 8.0.1 → 8.2.0

package/test/script/genesis_limits.js

@@ -3,6 +3,7 @@
 /* global describe, it, beforeEach, afterEach */
 var should = require('chai').should()
 var bsv = require('../..')
+var BN = bsv.crypto.BN
 var Interpreter = bsv.Script.Interpreter
 var Script = bsv.Script
 var Opcode = bsv.Opcode
@@ -28,11 +29,30 @@ describe('Interpreter post-Genesis limits', function () {
     Interpreter.MAX_OPS_PER_SCRIPT.should.equal(500)
   })
 
-  it('useGenesisLimits() lifts all three caps', function () {
+  // MAXIMUM_ELEMENT_SIZE is no longer among them. It is CScriptNum's max_length, and
+  // since the limits became era-derived it is only the PRE-Genesis fallback — raising it
+  // could not enable post-Genesis arithmetic, only corrupt pre-Genesis validation.
+  it('useGenesisLimits() lifts the size caps but not the script-number bound', function () {
     Interpreter.useGenesisLimits()
     Interpreter.MAX_SCRIPT_ELEMENT_SIZE.should.equal(0x7fffffff)
-    Interpreter.MAXIMUM_ELEMENT_SIZE.should.equal(0x7fffffff)
     Interpreter.MAX_OPS_PER_SCRIPT.should.equal(0x7fffffff)
+    Interpreter.MAXIMUM_ELEMENT_SIZE.should.equal(4)
+  })
+
+  // The reason it must not be raised, stated as a test: a 5-byte operand is an overflow
+  // before Genesis, and no process-wide call may turn that into an accept.
+  it('cannot be made to accept a pre-Genesis script-number overflow', function () {
+    var overflow = new Script()
+      .add(Buffer.from('1234567890', 'hex'))
+      .add(Buffer.from([2]))
+      .add(Opcode.OP_MUL)
+    var flags = Interpreter.SCRIPT_VERIFY_P2SH | Interpreter.SCRIPT_VERIFY_STRICTENC |
+      Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES | Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES
+    Interpreter.useGenesisLimits()
+    var interp = new Interpreter()
+    interp.verify(new Script(), overflow, new bsv.Transaction(), 0, flags, new BN(0))
+      .should.equal(false)
+    interp.errstr.should.equal('SCRIPT_ERR_SCRIPTNUM_OVERFLOW')
   })
 
   // <2^32> <2^32> OP_ADD <2^33> OP_NUMEQUAL  — operands exceed the 4-byte cap.
@@ -54,9 +74,18 @@ describe('Interpreter post-Genesis limits', function () {
     run(bigAdd).should.equal(false)
   })
 
-  it('allows >4-byte arithmetic after useGenesisLimits()', function () {
+  // Post-Genesis arithmetic is reached through the ERA, not through the static. Before
+  // the limits became era-derived, useGenesisLimits() was the only route; it no longer
+  // is, and using it for this would corrupt pre-Genesis validation elsewhere.
+  it('allows >4-byte arithmetic when the post-Genesis era is asked for', function () {
+    var interp = new Interpreter()
+    interp.verify(new Script(), bigAdd, new bsv.Transaction(), 0,
+      Interpreter.mainnetFlags(), new BN(0)).should.equal(true)
+  })
+
+  it('still rejects it under pre-Genesis rules, whatever the statics say', function () {
     Interpreter.useGenesisLimits()
-    run(bigAdd).should.equal(true)
+    run(bigAdd).should.equal(false)
   })
 
   // 220 OP_NOPs then OP_1 — more non-push opcodes than the 201 cap allows.
@@ -156,14 +185,16 @@ describe('Interpreter post-Genesis limits', function () {
     })
   })
 
-  it('useGenesisLimits raises all four caps, and getLimits/setLimits round-trip', function () {
+  it('useGenesisLimits raises the size caps, and getLimits/setLimits round-trip', function () {
     var before = Interpreter.getLimits()
     before.maxScriptSize.should.equal(10000)
     Interpreter.useGenesisLimits(64 * 1024)
     var after = Interpreter.getLimits()
     after.maxScriptElementSize.should.equal(64 * 1024)
-    after.maximumElementSize.should.equal(64 * 1024)
     after.maxOpsPerScript.should.equal(64 * 1024)
+    // Not raised — see the note on useGenesisLimits. setLimits() can still set it
+    // explicitly, which is what the round-trip below checks.
+    after.maximumElementSize.should.equal(4)
     after.maxScriptSize.should.equal(64 * 1024)
     Interpreter.setLimits(before)
     Interpreter.getLimits().maxScriptSize.should.equal(10000)

package/tools/minimal_reproduction.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * SmartLedger-BSV v3.0.2 - Signature Verification Test
+ * 
+ * This script demonstrates the WORKING signature verification
+ * in SmartLedger-BSV v3.0.2 after successful fixes.
+ */
+
+const bsv = require('./index.js');
+
+console.log('🔬 SmartLedger-BSV v3.0.2 - Signature Verification Test');
+console.log('======================================================\n');
+
+// Generate a random private key using the BSV library
+const privateKey = new bsv.PrivateKey(); // This generates a random private key
+const publicKey = privateKey.publicKey;
+const message = Buffer.from('hello world', 'utf8');
+const hash = bsv.crypto.Hash.sha256(message);
+
+console.log('Test Data:');
+console.log('- Private Key:', privateKey.toString());
+console.log('- Public Key:', publicKey.toString()); 
+console.log('- Message:', message.toString());
+console.log('- Hash:', hash.toString('hex'));
+console.log('');
+
+// Test standard signature flow
+console.log('Testing Standard Signature Flow:');
+console.log('================================');
+
+try {
+  // Create signature
+  const signature = bsv.crypto.ECDSA.sign(hash, privateKey);
+  console.log('✅ Signature created successfully');
+  console.log('- Is canonical:', signature.isCanonical ? signature.isCanonical() : 'method unavailable');
+  
+  // Test DER format
+  const derSig = signature.toDER();
+  console.log('✅ DER conversion successful, length:', derSig.length);
+  
+  // Test canonical DER
+  const canonicalSig = signature.toCanonical();
+  const canonicalDer = canonicalSig.toDER();
+  console.log('✅ Canonical DER conversion successful, length:', canonicalDer.length);
+  console.log('- Is canonical:', canonicalSig.isCanonical ? canonicalSig.isCanonical() : 'method unavailable');
+  
+  // CRITICAL TEST: Verify the signature we just created
+  console.log('\nVerification Tests:');
+  console.log('==================');
+  
+  // Test 1: Standard ECDSA verify
+  const verified1 = bsv.crypto.ECDSA.verify(hash, derSig, publicKey);
+  console.log(`${verified1 ? '✅' : '❌'} ECDSA.verify(hash, derSig, publicKey):`, verified1);
+  
+  // Test 2: Canonical ECDSA verify  
+  const verified2 = bsv.crypto.ECDSA.verify(hash, canonicalDer, publicKey);
+  console.log(`${verified2 ? '✅' : '❌'} ECDSA.verify(hash, canonicalDer, publicKey):`, verified2);
+  
+  // Test 3: SmartVerify if available
+  if (bsv.SmartVerify) {
+    console.log('\nSmartVerify Tests:');
+    console.log('=================');
+    
+    if (bsv.SmartVerify.smartVerify) {
+      const smartVerified1 = bsv.SmartVerify.smartVerify(hash, derSig, publicKey);
+      console.log(`${smartVerified1 ? '✅' : '❌'} SmartVerify.smartVerify(hash, derSig, publicKey):`, smartVerified1);
+      
+      const smartVerified2 = bsv.SmartVerify.smartVerify(hash, canonicalDer, publicKey);
+      console.log(`${smartVerified2 ? '✅' : '❌'} SmartVerify.smartVerify(hash, canonicalDer, publicKey):`, smartVerified2);
+    }
+    
+    if (bsv.SmartVerify.isCanonical) {
+      const canonical1 = bsv.SmartVerify.isCanonical(derSig);
+      console.log(`${canonical1 ? '✅' : '❌'} SmartVerify.isCanonical(derSig):`, canonical1);
+      
+      const canonical2 = bsv.SmartVerify.isCanonical(canonicalDer);
+      console.log(`${canonical2 ? '✅' : '❌'} SmartVerify.isCanonical(canonicalDer):`, canonical2);
+    }
+  }
+  
+  // Dynamic success summary based on actual results
+  const allWorking = verified1 && verified2;
+  
+  if (allWorking) {
+    console.log('\n🎉 SUCCESS SUMMARY:');
+    console.log('=================='); 
+    console.log('1. ✅ Signatures created successfully');
+    console.log('2. ✅ Canonical validation working');
+    console.log('3. ✅ ALL verification methods return TRUE');
+    console.log('4. ✅ Transaction validation ENABLED');
+    console.log('');
+    console.log('🚀 SmartLedger-BSV v3.0.2 signature verification is WORKING!');
+    console.log('🔧 All signature verification issues have been RESOLVED!');
+  } else {
+    console.log('\n🚨 ISSUE SUMMARY:');
+    console.log('================='); 
+    console.log('1. Signatures are created successfully');
+    console.log('2. .isCanonical() reports true on signature objects');
+    console.log('3. Some verification methods still failing');
+    console.log('4. This may block transaction validation');
+    console.log('');
+    console.log('Status: Partial fix - some issues remain');
+  }
+
+} catch (error) {
+  console.log('❌ Test failed with error:', error.message);
+  console.log('Stack:', error.stack);
+}
+
+// Library version info
+console.log('\n📚 Environment Info:');
+console.log('====================');
+console.log('SmartLedger version:', bsv.SmartLedger?.version || 'not available');
+console.log('Base version:', bsv.SmartLedger?.baseVersion || 'not available'); 
+console.log('Hardened by:', bsv.SmartLedger?.hardenedBy || 'not available');
+if (bsv.SmartLedger?.securityFeatures) {
+  console.log('Security features:', bsv.SmartLedger.securityFeatures);
+}

package/tools/opcode_map.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+
+/**
+ * BSV Opcode Mapping and Interpreter Configuration Tool
+ * 
+ * Maps all opcodes with their enabled/disabled status and required flags
+ * Provides helper functions for script execution with proper flags
+ * 
+ * Usage: node opcode_map.js
+ */
+
+const bsv = require('./index.js');
+const { Opcode, Script } = bsv;
+const Interpreter = bsv.Script.Interpreter;
+
+// Create reverse opcode mapping
+const opcodeMap = {};
+for (let key in Opcode.map) {
+  const code = Opcode.map[key];
+  opcodeMap[code] = key;
+}
+
+// Define opcode categories and their enablement requirements
+const OPCODE_CATEGORIES = {
+  // Always enabled opcodes
+  CORE: {
+    description: 'Core opcodes - always enabled',
+    flag: null,
+    opcodes: [
+      'OP_0', 'OP_1NEGATE', 'OP_1', 'OP_2', 'OP_3', 'OP_4', 'OP_5', 'OP_6', 'OP_7', 'OP_8', 'OP_9', 'OP_10',
+      'OP_11', 'OP_12', 'OP_13', 'OP_14', 'OP_15', 'OP_16', 'OP_NOP', 'OP_IF', 'OP_NOTIF', 'OP_ELSE', 'OP_ENDIF',
+      'OP_VERIFY', 'OP_RETURN', 'OP_TOALTSTACK', 'OP_FROMALTSTACK', 'OP_2DROP', 'OP_2DUP', 'OP_3DUP', 'OP_2OVER',
+      'OP_2ROT', 'OP_2SWAP', 'OP_IFDUP', 'OP_DEPTH', 'OP_DROP', 'OP_DUP', 'OP_NIP', 'OP_OVER', 'OP_PICK', 'OP_ROLL',
+      'OP_ROT', 'OP_SWAP', 'OP_TUCK', 'OP_SIZE', 'OP_EQUAL', 'OP_EQUALVERIFY', 'OP_1ADD', 'OP_1SUB', 'OP_NEGATE',
+      'OP_ABS', 'OP_NOT', 'OP_0NOTEQUAL', 'OP_ADD', 'OP_SUB', 'OP_BOOLAND', 'OP_BOOLOR', 'OP_NUMEQUAL',
+      'OP_NUMEQUALVERIFY', 'OP_NUMNOTEQUAL', 'OP_LESSTHAN', 'OP_GREATERTHAN', 'OP_LESSTHANOREQUAL',
+      'OP_GREATERTHANOREQUAL', 'OP_MIN', 'OP_MAX', 'OP_WITHIN', 'OP_RIPEMD160', 'OP_SHA1', 'OP_SHA256',
+      'OP_HASH160', 'OP_HASH256', 'OP_CODESEPARATOR', 'OP_CHECKSIG', 'OP_CHECKSIGVERIFY', 'OP_CHECKMULTISIG',
+      'OP_CHECKMULTISIGVERIFY', 'OP_NOP1', 'OP_PUSHDATA1', 'OP_PUSHDATA2', 'OP_PUSHDATA4'
+    ]
+  },
+  
+  // Monolith opcodes (May 2018 upgrade)
+  MONOLITH: {
+    description: 'Monolith opcodes - require SCRIPT_ENABLE_MONOLITH_OPCODES',
+    flag: 'SCRIPT_ENABLE_MONOLITH_OPCODES',
+    flagValue: (1 << 18),
+    opcodes: [
+      'OP_CAT', 'OP_SPLIT', 'OP_NUM2BIN', 'OP_BIN2NUM', 'OP_AND', 'OP_OR', 'OP_XOR', 'OP_DIV', 'OP_MOD'
+    ]
+  },
+  
+  // Magnetic opcodes (future upgrade)
+  MAGNETIC: {
+    description: 'Magnetic opcodes - require SCRIPT_ENABLE_MAGNETIC_OPCODES',
+    flag: 'SCRIPT_ENABLE_MAGNETIC_OPCODES',
+    flagValue: (1 << 19),
+    opcodes: [
+      'OP_INVERT', 'OP_MUL', 'OP_LSHIFT', 'OP_RSHIFT'
+    ]
+  },
+  
+  // Always disabled opcodes
+  DISABLED: {
+    description: 'Permanently disabled opcodes',
+    flag: null,
+    opcodes: [
+      'OP_RESERVED', 'OP_VER', 'OP_VERIF', 'OP_VERNOTIF', 'OP_RESERVED1', 'OP_RESERVED2', 'OP_2MUL', 'OP_2DIV'
+    ]
+  },
+  
+  // NOP opcodes
+  NOPS: {
+    description: 'NOP opcodes - may be discouraged with SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS',
+    flag: 'SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS',
+    flagValue: (1 << 7),
+    opcodes: [
+      'OP_NOP2', 'OP_NOP3', 'OP_NOP4', 'OP_NOP5', 'OP_NOP6', 'OP_NOP7', 'OP_NOP8', 'OP_NOP9', 'OP_NOP10'
+    ]
+  }
+};
+
+/**
+ * Get opcode information including enablement status
+ */
+function getOpcodeInfo(opcodeValue) {
+  const opcodeName = opcodeMap[opcodeValue];
+  if (!opcodeName) {
+    return {
+      value: opcodeValue,
+      name: `UNKNOWN_${opcodeValue}`,
+      enabled: false,
+      category: 'UNKNOWN',
+      requiresFlag: null
+    };
+  }
+  
+  // Find which category this opcode belongs to
+  for (const [category, info] of Object.entries(OPCODE_CATEGORIES)) {
+    if (info.opcodes.includes(opcodeName)) {
+      return {
+        value: opcodeValue,
+        hex: `0x${opcodeValue.toString(16).padStart(2, '0')}`,
+        name: opcodeName,
+        enabled: category !== 'DISABLED',
+        category: category,
+        requiresFlag: info.flag,
+        flagValue: info.flagValue,
+        description: info.description
+      };
+    }
+  }
+  
+  // Default to core if not found in any category
+  return {
+    value: opcodeValue,
+    hex: `0x${opcodeValue.toString(16).padStart(2, '0')}`,
+    name: opcodeName,
+    enabled: true,
+    category: 'CORE',
+    requiresFlag: null,
+    description: 'Core opcode - always enabled'
+  };
+}
+
+/**
+ * Get recommended interpreter flags for different use cases
+ */
+function getInterpreterFlags() {
+  return {
+    // Minimal flags for basic scripts
+    BASIC: Interpreter.SCRIPT_VERIFY_P2SH,
+    
+    // Standard flags for most scripts
+    STANDARD: Interpreter.SCRIPT_VERIFY_P2SH | 
+              Interpreter.SCRIPT_VERIFY_STRICTENC |
+              Interpreter.SCRIPT_VERIFY_MINIMALDATA,
+    
+    // Modern BSV with monolith opcodes (recommended for new scripts)
+    MODERN: Interpreter.SCRIPT_VERIFY_P2SH | 
+            Interpreter.SCRIPT_VERIFY_STRICTENC |
+            Interpreter.SCRIPT_VERIFY_MINIMALDATA |
+            Interpreter.SCRIPT_VERIFY_SIGPUSHONLY |
+            Interpreter.SCRIPT_VERIFY_CLEANSTACK |
+            Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
+            Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES,
+    
+    // Full BSV with all opcodes enabled
+    FULL: Interpreter.SCRIPT_VERIFY_P2SH | 
+          Interpreter.SCRIPT_VERIFY_STRICTENC |
+          Interpreter.SCRIPT_VERIFY_MINIMALDATA |
+          Interpreter.SCRIPT_VERIFY_SIGPUSHONLY |
+          Interpreter.SCRIPT_VERIFY_CLEANSTACK |
+          Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
+          Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES |
+          Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES,
+    
+    // Genesis rules (most permissive)
+    GENESIS: Interpreter.SCRIPT_VERIFY_P2SH |
+             Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
+             Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES |
+             Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES
+  };
+}
+
+/**
+ * Analyze a script and determine required flags
+ */
+function analyzeScriptRequirements(script) {
+  let requiredFlags = Interpreter.SCRIPT_VERIFY_P2SH; // Base requirement
+  const usedOpcodes = [];
+  const issues = [];
+  
+  // Parse script
+  let chunks;
+  if (typeof script === 'string') {
+    // ASM format
+    chunks = script.split(' ').map(token => {
+      if (token.startsWith('OP_')) {
+        const opcodeValue = Object.keys(opcodeMap).find(key => opcodeMap[key] === token);
+        return { opcodenum: parseInt(opcodeValue) };
+      }
+      return { buf: Buffer.from(token, 'hex') };
+    });
+  } else if (script instanceof Script) {
+    chunks = script.chunks;
+  } else {
+    throw new Error('Invalid script format');
+  }
+  
+  // Analyze each chunk
+  chunks.forEach((chunk, index) => {
+    if (chunk.opcodenum !== undefined) {
+      const info = getOpcodeInfo(chunk.opcodenum);
+      usedOpcodes.push(info);
+      
+      if (!info.enabled) {
+        issues.push(`Opcode ${info.name} at position ${index} is permanently disabled`);
+      } else if (info.requiresFlag) {
+        if (info.flag === 'SCRIPT_ENABLE_MONOLITH_OPCODES') {
+          requiredFlags |= Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES;
+        } else if (info.flag === 'SCRIPT_ENABLE_MAGNETIC_OPCODES') {
+          requiredFlags |= Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES;
+        }
+      }
+    }
+  });
+  
+  // Add FORKID if using any signature opcodes
+  const hasSignatureOpcodes = usedOpcodes.some(op => 
+    op.name === 'OP_CHECKSIG' || op.name === 'OP_CHECKSIGVERIFY' || 
+    op.name === 'OP_CHECKMULTISIG' || op.name === 'OP_CHECKMULTISIGVERIFY'
+  );
+  
+  if (hasSignatureOpcodes) {
+    requiredFlags |= Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID;
+  }
+  
+  return {
+    requiredFlags,
+    usedOpcodes,
+    issues,
+    recommendations: {
+      basic: requiredFlags,
+      safe: requiredFlags | Interpreter.SCRIPT_VERIFY_STRICTENC | Interpreter.SCRIPT_VERIFY_MINIMALDATA,
+      strict: requiredFlags | Interpreter.SCRIPT_VERIFY_STRICTENC | Interpreter.SCRIPT_VERIFY_MINIMALDATA | 
+              Interpreter.SCRIPT_VERIFY_SIGPUSHONLY | Interpreter.SCRIPT_VERIFY_CLEANSTACK
+    }
+  };
+}
+
+/**
+ * Print opcode analysis
+ */
+function printOpcodeAnalysis() {
+  console.log('🔧 BSV Opcode Mapping and Interpreter Configuration');
+  console.log('═'.repeat(80));
+  
+  // Show interpreter flags
+  console.log('\n⚙️  Available Interpreter Flags:');
+  const flagNames = Object.keys(Interpreter).filter(key => key.startsWith('SCRIPT_'));
+  flagNames.forEach(flagName => {
+    const value = Interpreter[flagName];
+    console.log(`  ${flagName.padEnd(40)}: 0x${value.toString(16).padStart(8, '0').toUpperCase()}`);
+  });
+  
+  // Show recommended flag combinations
+  console.log('\n🎯 Recommended Flag Combinations:');
+  const flags = getInterpreterFlags();
+  Object.entries(flags).forEach(([name, value]) => {
+    console.log(`  ${name.padEnd(10)}: 0x${value.toString(16).padStart(8, '0').toUpperCase()}`);
+  });
+  
+  // Show opcode categories
+  console.log('\n📋 Opcode Categories:');
+  Object.entries(OPCODE_CATEGORIES).forEach(([category, info]) => {
+    console.log(`\n  ${category} - ${info.description}`);
+    if (info.flag) {
+      console.log(`    Required flag: ${info.flag} (0x${info.flagValue.toString(16).toUpperCase()})`);
+    }
+    console.log(`    Opcodes: ${info.opcodes.length}`);
+    
+    // Show first few opcodes
+    const sample = info.opcodes.slice(0, 5);
+    console.log(`    Sample: ${sample.join(', ')}${info.opcodes.length > 5 ? '...' : ''}`);
+  });
+  
+  // Show total counts
+  const totalOpcodes = Object.keys(opcodeMap).length;
+  const enabledOpcodes = Object.keys(opcodeMap).filter(code => {
+    const info = getOpcodeInfo(parseInt(code));
+    return info.enabled;
+  }).length;
+  
+  console.log(`\n📊 Summary:`);
+  console.log(`  Total opcodes defined: ${totalOpcodes}`);
+  console.log(`  Enabled opcodes: ${enabledOpcodes}`);
+  console.log(`  Disabled opcodes: ${totalOpcodes - enabledOpcodes}`);
+}
+
+/**
+ * Create a properly configured interpreter
+ */
+function createInterpreter(flagLevel = 'MODERN') {
+  const flags = getInterpreterFlags();
+  return {
+    interpreter: new Interpreter(),
+    flags: flags[flagLevel.toUpperCase()] || flags.MODERN,
+    
+    verify: function(scriptSig, scriptPubkey, tx, nin, satoshisBN) {
+      return this.interpreter.verify(
+        scriptSig, 
+        scriptPubkey, 
+        tx, 
+        nin, 
+        this.flags, 
+        satoshisBN
+      );
+    }
+  };
+}
+
+// CLI execution
+if (require.main === module) {
+  printOpcodeAnalysis();
+  
+  // Test with sample nLockTime script
+  console.log('\n🧪 Testing nLockTime Script Requirements:');
+  const sampleScript = 'OP_OVER OP_HASH256 a7a9bc2c7389fecf7d5279e0909bcaac1b0f7d0ee81713adfb7e97fad95322ad OP_EQUALVERIFY OP_OVER 6a OP_SPLIT OP_NIP 04 OP_SPLIT OP_NIP OP_BIN2NUM e803 OP_NUMEQUALVERIFY 03433a1466b09a27e0067efa9c58ec12ae5e26071a413cfe918b49656c75d7fb2d OP_CHECKSIGVERIFY';
+  
+  try {
+    const analysis = analyzeScriptRequirements(sampleScript);
+    console.log(`  Required flags: 0x${analysis.requiredFlags.toString(16).toUpperCase()}`);
+    console.log(`  Used opcodes: ${analysis.usedOpcodes.length}`);
+    
+    if (analysis.issues.length > 0) {
+      console.log(`  Issues:`);
+      analysis.issues.forEach(issue => console.log(`    ⚠️  ${issue}`));
+    } else {
+      console.log(`  ✅ No issues found`);
+    }
+    
+    console.log(`  Recommendations:`);
+    console.log(`    Basic:  0x${analysis.recommendations.basic.toString(16).toUpperCase()}`);
+    console.log(`    Safe:   0x${analysis.recommendations.safe.toString(16).toUpperCase()}`);
+    console.log(`    Strict: 0x${analysis.recommendations.strict.toString(16).toUpperCase()}`);
+    
+  } catch (error) {
+    console.log(`  ❌ Error analyzing script: ${error.message}`);
+  }
+}
+
+// Export functions and data
+module.exports = {
+  opcodeMap,
+  OPCODE_CATEGORIES,
+  getOpcodeInfo,
+  getInterpreterFlags,
+  analyzeScriptRequirements,
+  createInterpreter,
+  printOpcodeAnalysis
+};

package/tools/server.js

@@ -0,0 +1,97 @@
+const http = require('http')
+const fs = require('fs')
+const path = require('path')
+
+const port = 8080
+
+// MIME types for different file extensions
+const mimeTypes = {
+  '.html': 'text/html',
+  '.js': 'application/javascript',
+  '.css': 'text/css',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpg',
+  '.gif': 'image/gif',
+  '.ico': 'image/x-icon',
+  '.svg': 'image/svg+xml',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2'
+}
+
+const server = http.createServer((req, res) => {
+  console.log(`Request for ${req.url}`)
+
+  // Parse URL and remove query string
+  let filePath = req.url.split('?')[0]
+
+  // Default to index.html if no specific file requested
+  if (filePath === '/') {
+    filePath = '/test.html'
+  }
+
+  // Build full file path
+  const fullPath = path.join(__dirname, filePath)
+
+  // Get file extension
+  const extname = path.extname(fullPath)
+  const contentType = mimeTypes[extname] || 'application/octet-stream'
+
+  // Check if file exists
+  fs.readFile(fullPath, (err, content) => {
+    if (err) {
+      if (err.code === 'ENOENT') {
+        // File not found
+        res.writeHead(404, { 'Content-Type': 'text/html' })
+        res.end(`
+          <html>
+            <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
+              <h1>404 - File Not Found</h1>
+              <p>The requested file <strong>${req.url}</strong> was not found.</p>
+              <p><a href="/test.html">Go to BSV Security Test</a></p>
+            </body>
+          </html>
+        `)
+      } else {
+        // Server error
+        res.writeHead(500)
+        res.end(`Server Error: ${err.code}`)
+      }
+    } else {
+      // Success - serve the file
+      res.writeHead(200, {
+        'Content-Type': contentType,
+        'Cache-Control': 'no-cache' // Prevent caching for development
+      })
+      res.end(content)
+    }
+  })
+})
+
+server.listen(port, () => {
+  console.log(`
+🚀 SmartLedger BSV Test Server Started!
+
+📍 Server running at: http://localhost:${port}
+🧪 Test page: http://localhost:${port}/test.html
+📁 Serving files from: ${__dirname}
+
+📊 Available files:
+- test.html (Main test page)
+- bsv.min.js (${Math.round(fs.statSync('bsv.min.js').size / 1024)} KB)
+- bsv-message.min.js (${Math.round(fs.statSync('bsv-message.min.js').size / 1024)} KB)
+- bsv-ecies.min.js (${Math.round(fs.statSync('bsv-ecies.min.js').size / 1024)} KB)
+- bsv-mnemonic.min.js (${Math.round(fs.statSync('bsv-mnemonic.min.js').size / 1024)} KB)
+
+Press Ctrl+C to stop the server
+  `)
+})
+
+// Handle server shutdown gracefully
+process.on('SIGINT', () => {
+  console.log('\n👋 Shutting down server...')
+  server.close(() => {
+    console.log('✅ Server stopped')
+    process.exit(0)
+  })
+})