@smartledger/bsv 3.3.2 → 3.3.3

package/smartcontract-entry.js

@@ -1,133 +1 @@
-/**
- * SmartLedger BSV - SmartContract Interface
- * 
- * Standalone SmartContract interface with debug tools for browser use.
- * This module provides the complete SmartContract development framework
- * including covenant builders, script debuggers, and testing tools.
- * 
- * Usage:
- *   <script src="bsv.min.js"></script>
- *   <script src="bsv-smartcontract.min.js"></script>
- *   <script>
- *     // SmartContract interface available under bsv.SmartContract
- *     const script = bsv.Script.fromASM('OP_1 OP_2 OP_ADD');
- *     const result = bsv.SmartContract.examineStack(script);
- *     const metrics = bsv.SmartContract.getScriptMetrics(script);
- *   </script>
- */
-
-'use strict'
-
-// Check if BSV library is available
-if (typeof window !== 'undefined' && typeof window.bsv === 'undefined') {
-  throw new Error('SmartContract interface requires BSV library. Load bsv.min.js first.')
-}
-
-// Get BSV reference (works in both Node.js and browser)
-var bsv = (typeof window !== 'undefined') ? window.bsv : require('./index.js')
-
-if (!bsv) {
-  throw new Error('BSV library not found. Ensure bsv.min.js is loaded before bsv-smartcontract.min.js')
-}
-
-// Load SmartContract interface
-var SmartContract
-try {
-  SmartContract = require('./lib/smart_contract')
-} catch (e) {
-  throw new Error('SmartContract module not found: ' + e.message)
-}
-
-// Attach to BSV library
-bsv.SmartContract = SmartContract
-
-// Make available globally for browser usage
-if (typeof window !== 'undefined') {
-  window.bsvSmartContract = SmartContract
-  
-  // Also ensure it's on the global bsv object
-  if (window.bsv) {
-    window.bsv.SmartContract = SmartContract
-  }
-}
-
-// Add debug tools information
-if (SmartContract) {
-  SmartContract.version = bsv.version || '3.2.1'
-  SmartContract.standalone = true
-  SmartContract.debugToolsAvailable = {
-    examineStack: !!SmartContract.examineStack,
-    interpretScript: !!SmartContract.interpretScript,
-    getScriptMetrics: !!SmartContract.getScriptMetrics,
-    optimizeScript: !!SmartContract.optimizeScript
-  }
-  
-  // Convenience method to check if debug tools are working
-  SmartContract.testDebugTools = function() {
-    try {
-      if (!bsv.Script) {
-        return { success: false, error: 'BSV Script class not available' }
-      }
-      
-      const testScript = bsv.Script.fromASM('OP_1 OP_2 OP_ADD')
-      const results = {}
-      
-      if (SmartContract.examineStack) {
-        try {
-          results.examineStack = SmartContract.examineStack(testScript)
-          results.examineStackWorking = true
-        } catch (e) {
-          results.examineStackWorking = false
-          results.examineStackError = e.message
-        }
-      }
-      
-      if (SmartContract.interpretScript) {
-        try {
-          results.interpretScript = SmartContract.interpretScript(testScript)
-          results.interpretScriptWorking = true
-        } catch (e) {
-          results.interpretScriptWorking = false
-          results.interpretScriptError = e.message
-        }
-      }
-      
-      if (SmartContract.getScriptMetrics) {
-        try {
-          results.scriptMetrics = SmartContract.getScriptMetrics(testScript)
-          results.scriptMetricsWorking = true
-        } catch (e) {
-          results.scriptMetricsWorking = false
-          results.scriptMetricsError = e.message
-        }
-      }
-      
-      if (SmartContract.optimizeScript) {
-        try {
-          results.optimizeScript = SmartContract.optimizeScript(testScript)
-          results.optimizeScriptWorking = true
-        } catch (e) {
-          results.optimizeScriptWorking = false
-          results.optimizeScriptError = e.message
-        }
-      }
-      
-      return {
-        success: true,
-        testScript: 'OP_1 OP_2 OP_ADD',
-        results: results,
-        methodCount: Object.keys(SmartContract).length
-      }
-    } catch (e) {
-      return { success: false, error: e.message }
-    }
-  }
-}
-
-console.log('SmartContract interface loaded:', !!SmartContract)
-if (SmartContract) {
-  console.log('SmartContract methods available:', Object.keys(SmartContract).length)
-  console.log('Debug tools available:', SmartContract.debugToolsAvailable)
-}
-
-module.exports = SmartContract
+module.exports = require('./lib/smart_contract');

package/tests/test_builtin_verify.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+/**
+ * Test Transaction VerifySignature Method
+ * 
+ * Tests the transaction's built-in verifySignature method
+ */
+
+const bsv = require('./index.js');
+
+console.log('🔍 Test Transaction VerifySignature Method');
+console.log('==========================================\n');
+
+const privateKey = new bsv.PrivateKey('L1aW4aubDFB7yfras2S1mN3bqg9nwySY8nkoLmJebSLD5BWv3ENZ');
+const address = privateKey.toAddress().toString();
+
+// Create and sign transaction
+const mockUTXO = {
+  txid: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+  vout: 0,
+  address: address,
+  satoshis: 50000,
+  script: bsv.Script.buildPublicKeyHashOut(address).toHex()
+};
+
+const transaction = new bsv.Transaction()
+  .from(mockUTXO)
+  .to(address, 100)
+  .change(address)
+  .feePerKb(10)
+  .sign(privateKey);
+
+console.log('✅ Transaction created and signed');
+console.log(`Transaction ID: ${transaction.id}`);
+console.log(`Basic verify(): ${transaction.verify()}`);
+
+// Extract signature details
+const input = transaction.inputs[0];
+const signature = input.script.chunks[0]?.buf;
+const publicKey = input.script.chunks[1]?.buf;
+
+if (signature && publicKey) {
+  console.log('\n🧪 Transaction VerifySignature Method Test:');
+  console.log('==========================================');
+  
+  const sigWithoutHashtype = signature.slice(0, -1);
+  const pubkeyObj = new bsv.PublicKey(publicKey);
+  const subscript = input.output.script;
+  const satoshisBN = new bsv.crypto.BN(input.output.satoshis);
+  
+  try {
+    // Parse the signature first
+    const parsedSig = bsv.crypto.Signature.fromDER(sigWithoutHashtype);
+    parsedSig.nhashtype = signature[signature.length - 1]; // Set the hashtype
+    
+    console.log(`Parsed signature r: ${parsedSig.r.toString('hex')}`);
+    console.log(`Parsed signature s: ${parsedSig.s.toString('hex')}`);
+    console.log(`Signature hashtype: 0x${parsedSig.nhashtype.toString(16)}`);
+    
+    // Test transaction's built-in verifySignature method
+    const builtinVerify = transaction.verifySignature(parsedSig, pubkeyObj, 0, subscript, satoshisBN);
+    console.log(`transaction.verifySignature(): ${builtinVerify ? '✅ VALID' : '❌ INVALID'}`);
+    
+    // Test with default flags
+    const builtinVerifyWithFlags = transaction.verifySignature(parsedSig, pubkeyObj, 0, subscript, satoshisBN, 
+      bsv.Script.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID);
+    console.log(`transaction.verifySignature() with flags: ${builtinVerifyWithFlags ? '✅ VALID' : '❌ INVALID'}`);
+    
+    console.log('\n🔍 Manual Sighash.verify Test:');
+    console.log('==============================');
+    
+    // Test the Sighash.verify method directly
+    const sighashVerify = bsv.Transaction.Sighash.verify(transaction, parsedSig, pubkeyObj, 0, subscript, satoshisBN);
+    console.log(`Sighash.verify(): ${sighashVerify ? '✅ VALID' : '❌ INVALID'}`);
+    
+    const sighashVerifyWithFlags = bsv.Transaction.Sighash.verify(transaction, parsedSig, pubkeyObj, 0, subscript, satoshisBN,
+      bsv.Script.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID);
+    console.log(`Sighash.verify() with flags: ${sighashVerifyWithFlags ? '✅ VALID' : '❌ INVALID'}`);
+    
+    console.log('\n🔧 Compare Sighash Calculation:');
+    console.log('===============================');
+    
+    // Get the sighash that Sighash.verify would calculate
+    const officialSighash = bsv.Transaction.Sighash.sighash(
+      transaction, 
+      parsedSig.nhashtype, 
+      0, 
+      subscript, 
+      satoshisBN,
+      bsv.Script.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
+    );
+    
+    console.log(`Official Sighash.sighash(): ${officialSighash.toString('hex')}`);
+    
+    // Compare with our transaction.sighash method
+    const ourSighash = transaction.sighash(0, parsedSig.nhashtype, subscript, satoshisBN);
+    console.log(`Our transaction.sighash(): ${ourSighash.toString('hex')}`);
+    console.log(`Sighashes match: ${officialSighash.equals(ourSighash) ? '✅ YES' : '❌ NO'}`);
+    
+    // Test verification with the official sighash
+    console.log('\n🎯 Verification with Official Sighash:');
+    console.log('=====================================');
+    
+    const ecdsaWithOfficial = bsv.crypto.ECDSA.verify(officialSighash, parsedSig, pubkeyObj);
+    console.log(`ECDSA.verify(officialSighash): ${ecdsaWithOfficial ? '✅ VALID' : '❌ INVALID'}`);
+    
+    const smartVerifyWithOfficial = bsv.SmartVerify.smartVerify(officialSighash, parsedSig, pubkeyObj);
+    console.log(`SmartVerify(officialSighash): ${smartVerifyWithOfficial ? '✅ VALID' : '❌ INVALID'}`);
+    
+  } catch (error) {
+    console.log('❌ Test failed:', error.message);
+    console.log('Stack:', error.stack);
+  }
+  
+} else {
+  console.log('❌ Could not extract signature or public key');
+}

package/tests/test_debug_integration.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * Test Script for Debug Tools Integration
+ * =======================================
+ * Tests the newly integrated StackExaminer and ScriptInterpreter tools
+ * in the SmartContract interface
+ */
+
+const SmartContract = require('./lib/smart_contract/index.js');
+
+console.log("🧪 Testing SmartContract Debug Tools Integration");
+console.log("=================================================\n");
+
+// Test 1: Check if modules are loaded
+console.log("1. Module Loading Test:");
+console.log("   StackExaminer loaded:", !!SmartContract.StackExaminer);
+console.log("   ScriptInterpreter loaded:", !!SmartContract.ScriptInterpreter);
+console.log("   examineStack method:", typeof SmartContract.examineStack);
+console.log("   debugScriptExecution method:", typeof SmartContract.debugScriptExecution);
+console.log("   parseScript method:", typeof SmartContract.parseScript);
+
+// Test 2: Feature flags
+console.log("\n2. Feature Flags Test:");
+console.log("   STACK_EXAMINATION:", SmartContract.features.STACK_EXAMINATION);
+console.log("   SCRIPT_DEBUGGING:", SmartContract.features.SCRIPT_DEBUGGING);
+console.log("   STEP_BY_STEP_EXECUTION:", SmartContract.features.STEP_BY_STEP_EXECUTION);
+console.log("   INTERACTIVE_DEBUGGING:", SmartContract.features.INTERACTIVE_DEBUGGING);
+
+// Test 3: Simple script parsing
+console.log("\n3. Script Parsing Test:");
+try {
+  const parsedASM = SmartContract.parseScript("OP_DUP OP_HASH160");
+  console.log("   ✅ ASM parsing successful");
+  console.log("   Script length:", parsedASM.chunks.length);
+} catch (err) {
+  console.log("   ❌ ASM parsing failed:", err.message);
+}
+
+try {
+  const parsedHex = SmartContract.parseScript("76a914");
+  console.log("   ✅ HEX parsing successful");
+  console.log("   Script length:", parsedHex.chunks.length);
+} catch (err) {
+  console.log("   ❌ HEX parsing failed:", err.message);
+}
+
+// Test 4: Stack examination (non-interactive)
+console.log("\n4. Stack Examination Test:");
+try {
+  // Use simple valid scripts for testing
+  const result = SmartContract.examineStack("51", "51"); // OP_1, OP_1
+  console.log("   ✅ Stack examination completed, result:", result);
+} catch (err) {
+  console.log("   ⚠️ Stack examination had issues:", err.message);
+}
+
+console.log("\n=================================================");
+console.log("🎉 Debug Tools Integration Test Complete!");
+console.log("=================================================");
+
+// Count total methods in SmartContract
+const methodCount = Object.keys(SmartContract).filter(key => 
+  typeof SmartContract[key] === 'function'
+).length;
+
+console.log(`\n📊 SmartContract Interface Summary:`);
+console.log(`   Total Methods: ${methodCount}`);
+console.log(`   Total Modules: ${Object.keys(SmartContract).filter(key => 
+  typeof SmartContract[key] === 'object' && SmartContract[key].constructor.name !== 'Object'
+).length}`);
+console.log(`   Feature Flags: ${Object.keys(SmartContract.features).length}`);

package/tests/test_ecdsa_little.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+/**
+ * Test ECDSA.verify with 'little' endianness
+ * 
+ * Tests if adding 'little' parameter fixes ECDSA.verify too
+ */
+
+const bsv = require('./index.js');
+
+console.log('🔍 Test ECDSA.verify with little endianness');
+console.log('============================================\n');
+
+// Simple signature test
+const privateKey = new bsv.PrivateKey('L1aW4aubDFB7yfras2S1mN3bqg9nwySY8nkoLmJebSLD5BWv3ENZ');
+const publicKey = privateKey.publicKey;
+const message = Buffer.from('hello world', 'utf8');
+const hash = bsv.crypto.Hash.sha256(message);
+
+console.log('Creating signature...');
+const signature = bsv.crypto.ECDSA.sign(hash, privateKey);
+const derSig = signature.toDER();
+
+console.log('\n🧪 ECDSA.verify Test Matrix:');
+console.log('============================');
+
+// Test without 'little'
+const ecdsaWithoutLittle = bsv.crypto.ECDSA.verify(hash, signature, publicKey);
+console.log(`ECDSA.verify(hash, sig, pubkey): ${ecdsaWithoutLittle ? '✅ VALID' : '❌ INVALID'}`);
+
+// Test with 'little' 
+const ecdsaWithLittle = bsv.crypto.ECDSA.verify(hash, signature, publicKey, 'little');
+console.log(`ECDSA.verify(hash, sig, pubkey, 'little'): ${ecdsaWithLittle ? '✅ VALID' : '❌ INVALID'}`);
+
+// Test with DER buffer without 'little'
+const ecdsaDerWithoutLittle = bsv.crypto.ECDSA.verify(hash, derSig, publicKey);
+console.log(`ECDSA.verify(hash, derSig, pubkey): ${ecdsaDerWithoutLittle ? '✅ VALID' : '❌ INVALID'}`);
+
+// Test with DER buffer with 'little'
+const ecdsaDerWithLittle = bsv.crypto.ECDSA.verify(hash, derSig, publicKey, 'little');
+console.log(`ECDSA.verify(hash, derSig, pubkey, 'little'): ${ecdsaDerWithLittle ? '✅ VALID' : '❌ INVALID'}`);
+
+console.log('\n🔍 Compare with SmartVerify:');
+console.log('============================');
+
+// Test SmartVerify 
+const smartVerifyObj = bsv.SmartVerify.smartVerify(hash, signature, publicKey);
+console.log(`SmartVerify(hash, sig, pubkey): ${smartVerifyObj ? '✅ VALID' : '❌ INVALID'}`);
+
+const smartVerifyDer = bsv.SmartVerify.smartVerify(hash, derSig, publicKey);
+console.log(`SmartVerify(hash, derSig, pubkey): ${smartVerifyDer ? '✅ VALID' : '❌ INVALID'}`);
+
+console.log('\n🔧 Signature Details:');
+console.log('=====================');
+console.log(`Signature r: ${signature.r.toString('hex')}`);
+console.log(`Signature s: ${signature.s.toString('hex')}`);
+console.log(`Is canonical: ${signature.isCanonical()}`);
+
+// Check if this is a canonicalization issue
+const canonicalSig = signature.toCanonical();
+console.log(`Canonical r: ${canonicalSig.r.toString('hex')}`);
+console.log(`Canonical s: ${canonicalSig.s.toString('hex')}`);
+console.log(`Same as original: ${signature.r.eq(canonicalSig.r) && signature.s.eq(canonicalSig.s)}`);
+
+// Test with canonical signature
+const ecdsaCanonical = bsv.crypto.ECDSA.verify(hash, canonicalSig, publicKey, 'little');
+console.log(`ECDSA.verify(hash, canonicalSig, pubkey, 'little'): ${ecdsaCanonical ? '✅ VALID' : '❌ INVALID'}`);
+
+const smartVerifyCanonical = bsv.SmartVerify.smartVerify(hash, canonicalSig, publicKey);
+console.log(`SmartVerify(hash, canonicalSig, pubkey): ${smartVerifyCanonical ? '✅ VALID' : '❌ INVALID'}`);

package/tests/test_smartverify_der.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * Test SmartVerify DER Buffer Handling
+ * 
+ * Tests SmartVerify with different input types to isolate the DER parsing issue
+ */
+
+const bsv = require('./index.js');
+
+console.log('🔍 Test SmartVerify DER Buffer Handling');
+console.log('=======================================\n');
+
+// Simple signature test like minimal reproduction
+const privateKey = new bsv.PrivateKey('L1aW4aubDFB7yfras2S1mN3bqg9nwySY8nkoLmJebSLD5BWv3ENZ');
+const publicKey = privateKey.publicKey;
+const message = Buffer.from('hello world', 'utf8');
+const hash = bsv.crypto.Hash.sha256(message);
+
+console.log('Creating signature...');
+const signature = bsv.crypto.ECDSA.sign(hash, privateKey);
+const derSig = signature.toDER();
+
+console.log(`Original signature r: ${signature.r.toString('hex')}`);
+console.log(`Original signature s: ${signature.s.toString('hex')}`);
+console.log(`DER buffer: ${derSig.toString('hex')}`);
+console.log(`DER length: ${derSig.length}`);
+
+console.log('\n🧪 SmartVerify Test Matrix:');
+console.log('===========================');
+
+// Test 1: Signature object
+const smartVerifyObj = bsv.SmartVerify.smartVerify(hash, signature, publicKey);
+console.log(`SmartVerify(hash, sigObject, pubkey): ${smartVerifyObj ? '✅ VALID' : '❌ INVALID'}`);
+
+// Test 2: DER buffer
+const smartVerifyBuffer = bsv.SmartVerify.smartVerify(hash, derSig, publicKey);
+console.log(`SmartVerify(hash, derBuffer, pubkey): ${smartVerifyBuffer ? '✅ VALID' : '❌ INVALID'}`);
+
+// Test 3: Manually parsed DER
+try {
+  const parsedFromDER = bsv.crypto.Signature.fromDER(derSig);
+  console.log(`Parsed from DER r: ${parsedFromDER.r.toString('hex')}`);
+  console.log(`Parsed from DER s: ${parsedFromDER.s.toString('hex')}`);
+  
+  const smartVerifyParsed = bsv.SmartVerify.smartVerify(hash, parsedFromDER, publicKey);
+  console.log(`SmartVerify(hash, parsedSig, pubkey): ${smartVerifyParsed ? '✅ VALID' : '❌ INVALID'}`);
+  
+  console.log('\n🔍 Compare r,s values:');
+  console.log('======================');
+  console.log(`Original r: ${signature.r.toString('hex')}`);
+  console.log(`Parsed r  : ${parsedFromDER.r.toString('hex')}`);
+  console.log(`r matches : ${signature.r.eq(parsedFromDER.r) ? '✅ YES' : '❌ NO'}`);
+  
+  console.log(`Original s: ${signature.s.toString('hex')}`);
+  console.log(`Parsed s  : ${parsedFromDER.s.toString('hex')}`);  
+  console.log(`s matches : ${signature.s.eq(parsedFromDER.s) ? '✅ YES' : '❌ NO'}`);
+  
+} catch (error) {
+  console.log(`❌ DER parsing failed: ${error.message}`);
+}
+
+console.log('\n🔧 Debug SmartVerify DER Parsing:');
+console.log('==================================');
+
+// Let's manually step through what SmartVerify does with DER buffers
+try {
+  console.log('Step 1: Input validation...');
+  console.log(`  Hash is Buffer: ${Buffer.isBuffer(hash)}`);
+  console.log(`  Hash length: ${hash.length}`);
+  console.log(`  DER is Buffer: ${Buffer.isBuffer(derSig)}`);
+  
+  console.log('Step 2: DER parsing in SmartVerify...');
+  
+  // This replicates what SmartVerify does internally
+  const Signature = bsv.crypto.Signature;
+  const testParsed = Signature.fromDER(derSig);
+  console.log(`  Parsed successfully: ✅`);
+  console.log(`  Parsed r: ${testParsed.r.toString('hex')}`);
+  console.log(`  Parsed s: ${testParsed.s.toString('hex')}`);
+  
+  const BN = bsv.crypto.BN;
+  const r = BN.isBN(testParsed.r) ? testParsed.r : new BN(testParsed.r);
+  const s = BN.isBN(testParsed.s) ? testParsed.s : new BN(testParsed.s);
+  console.log(`  r as BN: ${r.toString('hex')}`);
+  console.log(`  s as BN: ${s.toString('hex')}`);
+  
+  // Check canonicalization  
+  const Point = bsv.crypto.Point;
+  const n = Point.getN();
+  const nh = n.shrn(1);
+  console.log(`  s > n/2: ${s.gt(nh)}`);
+  
+  const canonicalS = s.gt(nh) ? n.sub(s) : s;
+  console.log(`  canonical s: ${canonicalS.toString('hex')}`);
+  
+  // Test final ECDSA call
+  const canonicalSig = new Signature({
+    r: r,
+    s: canonicalS
+  });
+  
+  const ECDSA = bsv.crypto.ECDSA;
+  const finalResult = ECDSA.verify(hash, canonicalSig, publicKey, 'little');
+  console.log(`  Final ECDSA result: ${finalResult ? '✅ VALID' : '❌ INVALID'}`);
+  
+} catch (error) {
+  console.log(`❌ Debug failed: ${error.message}`);
+  console.log(`Stack: ${error.stack}`);
+}