smartledger-bsv 3.3.3 → 3.3.5

package/examples/working_smart_contracts.js

@@ -0,0 +1,348 @@
+/**
+ * Working Smart Contract Examples - Fixed Version
+ * ==============================================
+ * 
+ * This file contains working, tested smart contract examples that properly
+ * integrate with smartledger-bsv's preimage validation system.
+ */
+
+const bsv = require('../index.js')
+
+// Enable colored output if available
+let chalk
+try {
+  chalk = require('chalk')
+} catch (e) {
+  chalk = {
+    green: (text) => `✅ ${text}`,
+    red: (text) => `❌ ${text}`,
+    yellow: (text) => `⚠️ ${text}`,
+    blue: (text) => `ℹ️ ${text}`,
+    magenta: (text) => `🔮 ${text}`,
+    cyan: (text) => `🌊 ${text}`,
+    bold: (text) => `**${text}**`
+  }
+}
+
+console.log(chalk.bold.blue('\n🔧 Working Smart Contract Examples (Fixed)\n'))
+
+/**
+ * WorkingAmountContract - A properly functioning amount validation contract
+ */
+class WorkingAmountContract {
+  constructor(expectedAmount) {
+    this.expectedAmount = expectedAmount
+    this.privateKey = new bsv.PrivateKey()
+    
+    // Create the contract script using the quick covenant method
+    this.script = this._createWorkingScript()
+    this.address = bsv.SmartContract.utils.createCovenantAddress(this.script)
+    
+    console.log(chalk.green(`✅ WorkingAmountContract created`))
+    console.log(chalk.blue(`   Expected Amount: ${expectedAmount} satoshis`))
+    console.log(chalk.blue(`   Contract Address: ${this.address.toString()}`))
+  }
+  
+  _createWorkingScript() {
+    // Use the createQuickCovenant method which is known to work
+    const covenant = bsv.SmartContract.createQuickCovenant('value_lock', {
+      value: this.expectedAmount
+    })
+    
+    // Convert the ASM to a proper BSV Script
+    return bsv.Script.fromASM(covenant.asm)
+  }
+  
+  // Test validation with a real preimage
+  validatePayment(preimageHex) {
+    try {
+      console.log(chalk.yellow('🔍 Testing payment validation with working script...'))
+      
+      const result = bsv.SmartContract.testScript(
+        preimageHex,
+        this.script.toHex(),
+        { verbose: true }
+      )
+      
+      if (result.valid) {
+        console.log(chalk.green('✅ Payment validation PASSED'))
+      } else {
+        console.log(chalk.red('❌ Payment validation FAILED'))
+        console.log(chalk.red(`   Error: ${result.error || 'Unknown error'}`))
+      }
+      
+      return {
+        success: result.valid,
+        error: result.error,
+        details: result
+      }
+    } catch (error) {
+      console.log(chalk.red('❌ Validation error:', error.message))
+      return {
+        success: false,
+        error: error.message
+      }
+    }
+  }
+  
+  // Create a proper test preimage for this contract
+  createTestPreimage(inputAmount) {
+    try {
+      console.log(chalk.yellow('📝 Creating test preimage...'))
+      
+      // Create a mock transaction that would spend from this contract
+      const mockTx = new bsv.Transaction()
+      
+      // Add input from contract (mock)
+      mockTx.addInput({
+        prevTxId: 'a'.repeat(64),
+        outputIndex: 0,
+        script: this.script.toHex(),
+        sequenceNumber: 0xffffffff
+      })
+      
+      // Add output with the input amount
+      mockTx.addOutput({
+        script: bsv.Script.buildPublicKeyHashOut(new bsv.Address('1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2')).toHex(),
+        satoshis: inputAmount
+      })
+      
+      // Generate preimage
+      const preimage = bsv.Transaction.sighash.sighashPreimage(
+        mockTx,
+        bsv.crypto.Signature.SIGHASH_ALL | bsv.crypto.Signature.SIGHASH_FORKID,
+        0,
+        this.script,
+        new bsv.crypto.BN(inputAmount + 1000) // Contract input amount
+      )
+      
+      console.log(chalk.blue(`   Generated preimage: ${preimage.toString('hex').substring(0, 64)}...`))
+      return preimage.toString('hex')
+      
+    } catch (error) {
+      console.log(chalk.red('❌ Preimage generation error:', error.message))
+      return null
+    }
+  }
+  
+  // Complete test of the contract
+  runCompleteTest() {
+    console.log(chalk.cyan('\n🧪 Running Complete Contract Test'))
+    console.log(chalk.cyan('==================================='))
+    
+    // Test with correct amount
+    console.log(chalk.yellow('\n1. Testing with CORRECT amount'))
+    const correctPreimage = this.createTestPreimage(this.expectedAmount)
+    if (correctPreimage) {
+      const correctResult = this.validatePayment(correctPreimage)
+      console.log(chalk.blue(`   Result: ${correctResult.success ? 'PASS' : 'FAIL'}`))
+    }
+    
+    // Test with incorrect amount
+    console.log(chalk.yellow('\n2. Testing with INCORRECT amount'))
+    const incorrectPreimage = this.createTestPreimage(this.expectedAmount - 10000)
+    if (incorrectPreimage) {
+      const incorrectResult = this.validatePayment(incorrectPreimage)
+      console.log(chalk.blue(`   Result: ${incorrectResult.success ? 'UNEXPECTED PASS' : 'EXPECTED FAIL'}`))
+    }
+    
+    console.log(chalk.cyan('\n✅ Complete test finished'))
+  }
+  
+  getContractInfo() {
+    return {
+      expectedAmount: this.expectedAmount,
+      address: this.address.toString(),
+      script: {
+        hex: this.script.toHex(),
+        asm: this.script.toASM(),
+        size: this.script.toBuffer().length
+      }
+    }
+  }
+}
+
+/**
+ * SimpleFieldExtractionDemo - Shows how field extraction actually works
+ */
+class SimpleFieldExtractionDemo {
+  constructor() {
+    console.log(chalk.bold.magenta('\n🔬 Field Extraction Demo\n'))
+  }
+  
+  demonstrateFieldExtraction() {
+    console.log(chalk.cyan('Testing Field Extraction with Real Preimage'))
+    console.log(chalk.cyan('===========================================\n'))
+    
+    // Create a simple transaction to get a real preimage
+    try {
+      const tx = new bsv.Transaction()
+        .from({
+          txId: 'a'.repeat(64),
+          outputIndex: 0,
+          script: bsv.Script.buildPublicKeyHashOut(new bsv.Address('1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2')).toHex(),
+          satoshis: 100000
+        })
+        .to('1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2', 90000)
+      
+      const preimage = bsv.Transaction.sighash.sighashPreimage(
+        tx,
+        bsv.crypto.Signature.SIGHASH_ALL | bsv.crypto.Signature.SIGHASH_FORKID,
+        0,
+        bsv.Script.buildPublicKeyHashOut(new bsv.Address('1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2')),
+        new bsv.crypto.BN(100000)
+      )
+      
+      console.log(chalk.blue(`Generated preimage: ${preimage.toString('hex').substring(0, 64)}...`))
+      
+      // Test field extraction
+      const fields = ['value', 'nVersion', 'nLocktime', 'hashOutputs']
+      
+      fields.forEach(field => {
+        console.log(chalk.yellow(`\nTesting ${field} extraction:`))
+        
+        try {
+          const result = bsv.SmartContract.testFieldExtraction(
+            preimage.toString('hex'),
+            field
+          )
+          
+          if (result.success) {
+            console.log(chalk.green(`✅ ${field} extraction successful`))
+            if (result.fieldExtraction) {
+              console.log(chalk.blue(`   Value: ${result.fieldExtraction.value}`))
+              if (result.fieldExtraction.interpretation) {
+                console.log(chalk.blue(`   Interpreted: ${result.fieldExtraction.interpretation.description || result.fieldExtraction.interpretation.satoshis || 'N/A'}`))
+              }
+            }
+          } else {
+            console.log(chalk.red(`❌ ${field} extraction failed`))
+            console.log(chalk.red(`   Error: ${result.error || 'Unknown error'}`))
+          }
+        } catch (error) {
+          console.log(chalk.red(`❌ ${field} extraction error: ${error.message}`))
+        }
+      })
+      
+    } catch (error) {
+      console.log(chalk.red('❌ Demo error:', error.message))
+    }
+  }
+}
+
+/**
+ * CovenantBuilderTest - Test the covenant builder functionality
+ */
+class CovenantBuilderTest {
+  constructor() {
+    console.log(chalk.bold.magenta('\n🏗️ Covenant Builder Test\n'))
+  }
+  
+  testCovenantBuilder() {
+    console.log(chalk.cyan('Testing CovenantBuilder Functionality'))
+    console.log(chalk.cyan('===================================\n'))
+    
+    try {
+      // Test 1: Simple covenant using CovenantTemplates
+      console.log(chalk.yellow('1. Testing CovenantTemplates.valueLock'))
+      
+      const valueLockCovenant = bsv.SmartContract.CovenantTemplates.valueLock('50c3000000000000') // 50000 satoshis in little-endian hex
+      const builtCovenant = valueLockCovenant.build()
+      
+      console.log(chalk.blue(`   ASM: ${builtCovenant.cleanedASM}`))
+      console.log(chalk.blue(`   Hex: ${builtCovenant.hex}`))
+      console.log(chalk.blue(`   Size: ${builtCovenant.size} operations`))
+      
+      // Test 2: Custom covenant using CovenantBuilder
+      console.log(chalk.yellow('\n2. Testing Custom CovenantBuilder'))
+      
+      const customBuilder = new bsv.SmartContract.CovenantBuilder()
+      const customCovenant = customBuilder
+        .comment('Simple value validation')
+        .extractField('value')
+        .push(100000)
+        .greaterThanOrEqual()
+        .verify()
+        .build()
+      
+      console.log(chalk.blue(`   Custom ASM: ${customCovenant.cleanedASM}`))
+      console.log(chalk.blue(`   Custom Hex: ${customCovenant.hex}`))
+      
+      // Test 3: Quick covenant creation
+      console.log(chalk.yellow('\n3. Testing Quick Covenant Creation'))
+      
+      const quickCovenant = bsv.SmartContract.createQuickCovenant('value_lock', {
+        value: 75000
+      })
+      
+      console.log(chalk.blue(`   Quick ASM: ${quickCovenant.asm}`))
+      console.log(chalk.blue(`   Quick Hex: ${quickCovenant.hex}`))
+      
+      console.log(chalk.green('\n✅ All covenant builder tests completed'))
+      
+    } catch (error) {
+      console.log(chalk.red('❌ Covenant builder test error:', error.message))
+      console.error(error.stack)
+    }
+  }
+}
+
+/**
+ * Main execution function
+ */
+async function main() {
+  try {
+    console.log(chalk.bold.blue('Working Smart Contract Examples'))
+    console.log(chalk.blue('===============================\n'))
+    
+    // 1. Test field extraction first
+    const fieldDemo = new SimpleFieldExtractionDemo()
+    fieldDemo.demonstrateFieldExtraction()
+    
+    // 2. Test covenant builder
+    const builderTest = new CovenantBuilderTest()
+    builderTest.testCovenantBuilder()
+    
+    // 3. Test working contract
+    console.log(chalk.bold.magenta('\n💰 Working Amount Contract Test\n'))
+    
+    const workingContract = new WorkingAmountContract(100000) // 100k sats
+    workingContract.runCompleteTest()
+    
+    // 4. Show contract info
+    console.log(chalk.bold.yellow('\n📋 Contract Information'))
+    console.log(chalk.yellow('======================='))
+    
+    const info = workingContract.getContractInfo()
+    console.log(chalk.blue(`Expected Amount: ${info.expectedAmount} satoshis`))
+    console.log(chalk.blue(`Contract Address: ${info.address}`))
+    console.log(chalk.blue(`Script Size: ${info.script.size} bytes`))
+    console.log(chalk.blue(`Script ASM: ${info.script.asm}`))
+    
+    console.log(chalk.bold.green('\n🎉 All working examples completed successfully!'))
+    
+    // Usage instructions
+    console.log(chalk.bold.yellow('\n📚 Key Learnings:'))
+    console.log(chalk.yellow('1. Use bsv.SmartContract.createQuickCovenant() for simple contracts'))
+    console.log(chalk.yellow('2. Field extraction works with proper preimage format'))
+    console.log(chalk.yellow('3. CovenantBuilder.build() returns an object, not a Script'))
+    console.log(chalk.yellow('4. Convert covenant ASM to Script using bsv.Script.fromASM()'))
+    console.log(chalk.yellow('5. Test with real preimages for accurate validation'))
+    
+  } catch (error) {
+    console.error(chalk.bold.red('\nDemo Error:'), error.message)
+    console.error(chalk.red('Stack:'), error.stack)
+  }
+}
+
+// Export for use in other modules
+module.exports = {
+  WorkingAmountContract,
+  SimpleFieldExtractionDemo,
+  CovenantBuilderTest
+}
+
+// Run demo if executed directly
+if (require.main === module) {
+  main().catch(console.error)
+}

package/index.js

@@ -115,6 +115,13 @@ try {
   }
 }
 
+// Browser-compatible UTXO Manager (always available)
+try {
+  bsv.BrowserUTXOManager = require('./lib/browser-utxo-manager-es5')
+} catch (e) {
+  // BrowserUTXOManager not available
+}
+
 // Node.js specific tools (advanced development tools)
 if (typeof window === 'undefined' && typeof require === 'function') {
   try {

package/lib/browser-utxo-manager-es5.js

@@ -0,0 +1,316 @@
+'use strict'
+
+/**
+ * Browser-Compatible UTXO Manager (ES5 Compatible)
+ * Lightweight UTXO management for browser environments with configurable storage
+ */
+
+var STORAGE_TYPES = {
+  MEMORY: 'memory',
+  SESSION: 'session',
+  LOCAL: 'local'
+}
+
+function BrowserUTXOManager(options) {
+  options = options || {}
+  
+  this.options = {
+    storage: options.storage || STORAGE_TYPES.MEMORY,
+    storageKey: options.storageKey || 'smartledger-utxos',
+    autoSave: options.autoSave !== false,
+    maxUTXOs: options.maxUTXOs || 1000
+  }
+
+  // Validate storage type
+  var validTypes = [STORAGE_TYPES.MEMORY, STORAGE_TYPES.SESSION, STORAGE_TYPES.LOCAL]
+  if (validTypes.indexOf(this.options.storage) === -1) {
+    throw new Error('Invalid storage type: ' + this.options.storage)
+  }
+
+  this.utxos = new Map()
+  this.addressIndex = new Map()
+  this.spentUTXOs = new Map()
+  this.metadata = {
+    totalUTXOs: 0,
+    totalValue: 0,
+    createdAt: new Date().toISOString(),
+    lastModified: new Date().toISOString()
+  }
+
+  this.loadFromStorage()
+}
+
+BrowserUTXOManager.prototype.getStorage = function() {
+  if (this.options.storage === STORAGE_TYPES.SESSION) {
+    return typeof sessionStorage !== 'undefined' ? sessionStorage : null
+  } else if (this.options.storage === STORAGE_TYPES.LOCAL) {
+    return typeof localStorage !== 'undefined' ? localStorage : null
+  }
+  return null
+}
+
+BrowserUTXOManager.prototype.loadFromStorage = function() {
+  var storage = this.getStorage()
+  if (!storage) return
+
+  try {
+    var data = storage.getItem(this.options.storageKey)
+    if (!data) return
+
+    var parsed = JSON.parse(data)
+    if (!parsed.utxos) return
+
+    var self = this
+    parsed.utxos.forEach(function(utxoData) {
+      var key = utxoData.txid + ':' + utxoData.vout
+      self.utxos.set(key, utxoData)
+      
+      if (!self.addressIndex.has(utxoData.address)) {
+        self.addressIndex.set(utxoData.address, new Set())
+      }
+      self.addressIndex.get(utxoData.address).add(key)
+    })
+
+    if (parsed.metadata) {
+      this.metadata = parsed.metadata
+    }
+
+    console.log('✅ BrowserUTXOManager: Loaded ' + this.utxos.size + ' UTXOs from ' + this.options.storage + ' storage')
+  } catch (e) {
+    console.error('Failed to load UTXOs from storage:', e)
+  }
+}
+
+BrowserUTXOManager.prototype.saveToStorage = function() {
+  if (this.options.storage === STORAGE_TYPES.MEMORY) return
+
+  var storage = this.getStorage()
+  if (!storage) return
+
+  try {
+    var data = {
+      utxos: Array.from(this.utxos.values()),
+      metadata: this.metadata,
+      version: '1.0.0',
+      timestamp: new Date().toISOString()
+    }
+
+    storage.setItem(this.options.storageKey, JSON.stringify(data))
+    console.log('💾 BrowserUTXOManager: Saved ' + this.utxos.size + ' UTXOs to ' + this.options.storage + ' storage')
+  } catch (e) {
+    console.error('Failed to save UTXOs to storage:', e)
+  }
+}
+
+BrowserUTXOManager.prototype.addUTXO = function(utxo) {
+  if (!utxo || !utxo.txid || typeof utxo.vout !== 'number') {
+    throw new Error('Invalid UTXO: missing txid or vout')
+  }
+
+  var key = utxo.txid + ':' + utxo.vout
+
+  if (this.utxos.has(key)) {
+    console.log('⚠️ UTXO already exists: ' + key)
+    return false
+  }
+
+  // Add required fields
+  var utxoData = {
+    txid: utxo.txid,
+    vout: utxo.vout,
+    address: utxo.address || '',
+    satoshis: utxo.satoshis || 0,
+    script: utxo.script || '',
+    status: 'available',
+    addedAt: new Date().toISOString()
+  }
+
+  this.utxos.set(key, utxoData)
+
+  // Update address index
+  if (utxoData.address) {
+    if (!this.addressIndex.has(utxoData.address)) {
+      this.addressIndex.set(utxoData.address, new Set())
+    }
+    this.addressIndex.get(utxoData.address).add(key)
+  }
+
+  this.updateMetadata()
+  if (this.options.autoSave) {
+    this.saveToStorage()
+  }
+
+  return true
+}
+
+BrowserUTXOManager.prototype.getUTXOsForAddress = function(address) {
+  var utxoKeys = this.addressIndex.get(address)
+  if (!utxoKeys) return []
+
+  var results = []
+  var self = this
+  utxoKeys.forEach(function(key) {
+    var utxo = self.utxos.get(key)
+    if (utxo && utxo.status === 'available') {
+      results.push(utxo)
+    }
+  })
+
+  return results
+}
+
+BrowserUTXOManager.prototype.getBalance = function(address) {
+  var utxos = this.getUTXOsForAddress(address)
+  return utxos.reduce(function(sum, utxo) {
+    return sum + (utxo.satoshis || 0)
+  }, 0)
+}
+
+BrowserUTXOManager.prototype.spendUTXOs = function(inputs, spentInTx) {
+  spentInTx = spentInTx || 'browser-spend'
+  var spentUTXOs = []
+
+  for (var i = 0; i < inputs.length; i++) {
+    var input = inputs[i]
+    var key = input.txid + ':' + input.vout
+    var utxo = this.utxos.get(key)
+
+    if (utxo && utxo.status === 'available') {
+      utxo.status = 'spent'
+      utxo.spentAt = new Date().toISOString()
+      utxo.spentInTx = spentInTx
+
+      this.spentUTXOs.set(key, {
+        txid: utxo.txid,
+        vout: utxo.vout,
+        spentInTx: spentInTx,
+        spentAt: utxo.spentAt
+      })
+
+      spentUTXOs.push(utxo)
+    }
+  }
+
+  this.updateMetadata()
+  if (this.options.autoSave) {
+    this.saveToStorage()
+  }
+
+  return spentUTXOs
+}
+
+BrowserUTXOManager.prototype.getUTXO = function(txid, vout) {
+  var key = txid + ':' + vout
+  var utxo = this.utxos.get(key)
+  
+  return {
+    exists: !!utxo,
+    utxo: utxo,
+    status: utxo ? utxo.status : 'not-found'
+  }
+}
+
+BrowserUTXOManager.prototype.createMockUTXOs = function(address, count, satoshis) {
+  count = count || 5
+  satoshis = satoshis || 100000
+  var mockUTXOs = []
+
+  for (var i = 0; i < count; i++) {
+    // Generate random-like txid
+    var txid = ''
+    for (var j = 0; j < 64; j++) {
+      txid += Math.floor(Math.random() * 16).toString(16)
+    }
+
+    var mockUTXO = {
+      txid: txid,
+      vout: i,
+      address: address,
+      satoshis: satoshis + Math.floor(Math.random() * 10000),
+      script: '',
+      status: 'available'
+    }
+
+    this.addUTXO(mockUTXO)
+    mockUTXOs.push(mockUTXO)
+  }
+
+  return mockUTXOs
+}
+
+BrowserUTXOManager.prototype.getStats = function() {
+  var totalValue = 0
+  var availableCount = 0
+  var spentCount = 0
+
+  this.utxos.forEach(function(utxo) {
+    totalValue += utxo.satoshis || 0
+    if (utxo.status === 'available') {
+      availableCount++
+    } else if (utxo.status === 'spent') {
+      spentCount++
+    }
+  })
+
+  return {
+    totalUTXOs: this.utxos.size,
+    totalAvailable: availableCount,
+    totalSpent: spentCount,
+    totalValue: totalValue,
+    totalAddresses: this.addressIndex.size,
+    storageType: this.options.storage,
+    metadata: this.metadata
+  }
+}
+
+BrowserUTXOManager.prototype.updateMetadata = function() {
+  var stats = this.getStats()
+  this.metadata.totalUTXOs = stats.totalUTXOs
+  this.metadata.totalValue = stats.totalValue
+  this.metadata.lastModified = new Date().toISOString()
+}
+
+BrowserUTXOManager.prototype.exportData = function() {
+  return JSON.stringify({
+    utxos: Array.from(this.utxos.values()),
+    metadata: this.metadata,
+    version: '1.0.0',
+    exportedAt: new Date().toISOString()
+  })
+}
+
+BrowserUTXOManager.prototype.importData = function(jsonData, merge) {
+  merge = merge || false
+  
+  try {
+    var data = JSON.parse(jsonData)
+    
+    if (!merge) {
+      this.utxos.clear()
+      this.addressIndex.clear()
+      this.spentUTXOs.clear()
+    }
+
+    if (data.utxos && Array.isArray(data.utxos)) {
+      var self = this
+      data.utxos.forEach(function(utxo) {
+        self.addUTXO(utxo)
+      })
+    }
+
+    console.log('✅ BrowserUTXOManager: Imported ' + (data.utxos && data.utxos.length || 0) + ' UTXOs')
+    return true
+  } catch (e) {
+    console.error('Failed to import UTXO data:', e)
+    return false
+  }
+}
+
+// Export
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = BrowserUTXOManager
+  module.exports.STORAGE_TYPES = STORAGE_TYPES
+} else if (typeof window !== 'undefined') {
+  window.BrowserUTXOManager = BrowserUTXOManager
+  window.BrowserUTXOManager.STORAGE_TYPES = STORAGE_TYPES
+}