smartledger-bsv 3.0.1 → 3.0.2

package/index.js

@@ -97,5 +97,15 @@ bsv.SmartLedger = {
 bsv.SmartVerify = require('./lib/crypto/smartledger_verify')
 bsv.EllipticFixed = require('./lib/crypto/elliptic-fixed')
 
+// SmartLedger Development & Testing Tools (Node.js only)
+if (typeof window === 'undefined' && typeof require === 'function') {
+  try {
+    bsv.SmartUTXO = require('./lib/smartutxo')
+    bsv.SmartMiner = require('./lib/smartminer')
+  } catch (e) {
+    // Browser environment - these tools not available
+  }
+}
+
 // Internal usage, exposed for testing/advanced tweaking
 bsv.Transaction.sighash = require('./lib/transaction/sighash')

package/lib/crypto/ecdsa.js

@@ -23,7 +23,22 @@ ECDSA.prototype.set = function (obj) {
   this.endian = obj.endian || this.endian // the endianness of hashbuf
   this.privkey = obj.privkey || this.privkey
   this.pubkey = obj.pubkey || (this.privkey ? this.privkey.publicKey : this.pubkey)
-  this.sig = obj.sig || this.sig
+  
+  // === SmartLedger Signature Handling ===
+  // Auto-parse DER buffers to Signature objects for compatibility
+  if (obj.sig) {
+    if (Buffer.isBuffer(obj.sig)) {
+      // Parse DER buffer to Signature object
+      var Signature = require('./signature')
+      this.sig = Signature.fromDER(obj.sig)
+    } else {
+      // Already a Signature object
+      this.sig = obj.sig
+    }
+  } else {
+    this.sig = this.sig
+  }
+  
   this.k = obj.k || this.k
   this.verified = obj.verified || this.verified
   return this
@@ -159,53 +174,57 @@ ECDSA.prototype.sigError = function () {
 
   // === SmartLedger Security Patches ===
   // Apply security validation during cryptographic verification
-  try {
-    // Create a copy to avoid mutating original signature
-    var secureSig = {
-      r: this.sig.r,
-      s: this.sig.s
-    }
-
-    // Apply security patches to the copy
-    var n = Point.getN()
+  var r = this.sig.r
+  var s = this.sig.s
+  var n = Point.getN()
 
-    // Fix 1 & 2: Enhanced range validation (maintains original message for compatibility)
-    if (secureSig.r.isZero() || secureSig.s.isZero() ||
-        secureSig.r.gte(n) || secureSig.s.gte(n)) {
+  try {
+    // Fix 1 & 2: Enhanced range validation
+    if (r.isZero() || s.isZero() || r.gte(n) || s.gte(n)) {
       return 'r and s not in range'
     }
 
-    // Fix 3: Canonicalize s for verification (non-mutating)
+    // Fix 3: Handle canonicalization properly
+    // For verification, we need to try both the original s and canonical s
+    // This handles both pre-canonicalized signatures and non-canonical ones
     var nh = n.shrn(1) // n/2
-    if (secureSig.s.gt(nh)) {
-      secureSig.s = n.sub(secureSig.s)
+    var canonicalS = s.gt(nh) ? n.sub(s) : s
+
+    var e = BN.fromBuffer(this.hashbuf, this.endian ? {
+      endian: this.endian
+    } : undefined)
+
+    // Try verification with canonical s
+    var sinv = canonicalS.invm(n)
+    var u1 = sinv.mul(e).umod(n)
+    var u2 = sinv.mul(r).umod(n)
+
+    var p = Point.getG().mulAdd(u1, this.pubkey.point, u2)
+    if (p.isInfinity()) {
+      return 'p is infinity'
     }
 
-    // Use secure signature for verification
-    var r = secureSig.r
-    var canonicalS = secureSig.s
+    if (p.getX().umod(n).cmp(r) !== 0) {
+      // If canonical verification failed and s was already canonical, 
+      // try with the non-canonical version (for backwards compatibility)
+      if (s.lte(nh)) {
+        var nonCanonicalS = n.sub(s)
+        sinv = nonCanonicalS.invm(n)
+        u1 = sinv.mul(e).umod(n)
+        u2 = sinv.mul(r).umod(n)
+        
+        p = Point.getG().mulAdd(u1, this.pubkey.point, u2)
+        if (!p.isInfinity() && p.getX().umod(n).cmp(r) === 0) {
+          return false  // Verification succeeded with non-canonical s
+        }
+      }
+      return 'Invalid signature'
+    } else {
+      return false  // Verification succeeded with canonical s
+    }
   } catch (error) {
     return 'Signature security validation failed: ' + error.message
   }
-
-  var e = BN.fromBuffer(this.hashbuf, this.endian ? {
-    endian: this.endian
-  } : undefined)
-  // Use canonical s for verification
-  var sinv = canonicalS.invm(n)
-  var u1 = sinv.mul(e).umod(n)
-  var u2 = sinv.mul(r).umod(n)
-
-  var p = Point.getG().mulAdd(u1, this.pubkey.point, u2)
-  if (p.isInfinity()) {
-    return 'p is infinity'
-  }
-
-  if (p.getX().umod(n).cmp(r) !== 0) {
-    return 'Invalid signature'
-  } else {
-    return false
-  }
 }
 
 ECDSA.toLowS = function (s) {

package/lib/crypto/smartledger_verify.js

@@ -16,7 +16,7 @@ const nh = n.shrn(1) // n / 2
 /**
  * Hardened signature verification with canonicalization
  * @param {Buffer} msgHash - 32-byte message hash
- * @param {Signature} sig - Signature object with r,s components
+ * @param {Signature|Buffer} sig - Signature object with r,s components or DER buffer
  * @param {PublicKey} pubkey - Public key for verification
  * @returns {boolean} - true if signature is valid and canonical
  */
@@ -26,13 +26,28 @@ function smartVerify (msgHash, sig, pubkey) {
     throw new Error('Invalid message hash: must be 32-byte buffer')
   }
 
-  if (!sig || !sig.r || !sig.s) {
+  if (!sig) {
+    return false
+  }
+
+  // Parse DER buffer to Signature object if needed
+  let sigObj = sig
+  if (Buffer.isBuffer(sig)) {
+    try {
+      const Signature = require('./signature')
+      sigObj = Signature.fromDER(sig)
+    } catch (e) {
+      return false
+    }
+  }
+
+  if (!sigObj || !sigObj.r || !sigObj.s) {
     return false
   }
 
   // Ensure r and s are BN instances
-  const r = BN.isBN(sig.r) ? sig.r : new BN(sig.r)
-  const s = BN.isBN(sig.s) ? sig.s : new BN(sig.s)
+  const r = BN.isBN(sigObj.r) ? sigObj.r : new BN(sigObj.r)
+  const s = BN.isBN(sigObj.s) ? sigObj.s : new BN(sigObj.s)
 
   // Reject zero values
   if (r.isZero() || s.isZero()) {
@@ -50,27 +65,43 @@ function smartVerify (msgHash, sig, pubkey) {
     canonicalS = n.sub(s)
   }
 
-  // Create canonicalized signature object
-  const canonicalSig = {
+  // Create canonicalized signature object for ECDSA verify
+  const Signature = require('./signature')
+  const canonicalSig = new Signature({
     r: r,
     s: canonicalS
-  }
+  })
 
-  // Use BSV's original ECDSA verify with canonical signature
+  // Use BSV's ECDSA verify with canonical signature object
   return ECDSA.verify(msgHash, canonicalSig, pubkey)
 }
 
 /**
  * Check if signature is in canonical form (s <= n/2)
- * @param {Object} sig - Signature with r,s components
+ * @param {Object|Buffer} sig - Signature with r,s components or DER buffer
  * @returns {boolean} - true if signature is canonical
  */
 function isCanonical (sig) {
-  if (!sig || !sig.s) {
+  if (!sig) {
     return false
   }
 
-  const s = BN.isBN(sig.s) ? sig.s : new BN(sig.s)
+  // Parse DER buffer to Signature object if needed
+  let sigObj = sig
+  if (Buffer.isBuffer(sig)) {
+    try {
+      const Signature = require('./signature')
+      sigObj = Signature.fromDER(sig)
+    } catch (e) {
+      return false
+    }
+  }
+
+  if (!sigObj || !sigObj.s) {
+    return false
+  }
+
+  const s = BN.isBN(sigObj.s) ? sigObj.s : new BN(sigObj.s)
   return s.lte(nh)
 }
 

package/lib/script/interpreter.js

@@ -655,19 +655,21 @@ Interpreter.prototype.step = function () {
     switch (opcode) {
       case Opcode.OP_2MUL:
       case Opcode.OP_2DIV:
-
-        // Disabled opcodes.
+        // Permanently disabled opcodes.
         return true
 
       case Opcode.OP_INVERT:
       case Opcode.OP_MUL:
       case Opcode.OP_LSHIFT:
       case Opcode.OP_RSHIFT:
-        // Opcodes that have been reenabled.
+        // Magnetic opcodes - still require flag for backwards compatibility
         if ((self.flags & Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES) === 0) {
           return true
         }
         break
+        
+      // Monolith opcodes are now enabled by default in SmartLedger BSV
+      // These were activated in May 2018 and are part of standard BSV consensus
       case Opcode.OP_DIV:
       case Opcode.OP_MOD:
       case Opcode.OP_SPLIT:
@@ -677,11 +679,9 @@ Interpreter.prototype.step = function () {
       case Opcode.OP_XOR:
       case Opcode.OP_BIN2NUM:
       case Opcode.OP_NUM2BIN:
-        // Opcodes that have been reenabled.
-        if ((self.flags & Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES) === 0) {
-          return true
-        }
-        break
+        // These opcodes are now always enabled - no flag required
+        return false
+        
       default:
         break
     }

package/lib/smartminer.js

@@ -0,0 +1,169 @@
+'use strict'
+
+/**
+ * SmartLedger Miner Simulator
+ * Provides BSV blockchain mining simulation for testing and development
+ */
+
+/**
+ * Comprehensive BSV Miner Simulator for development and testing
+ */
+class SmartMiner {
+  constructor(bsv, options = {}) {
+    this.bsv = bsv
+    this.options = {
+      difficulty: options.difficulty || 1,
+      blockTime: options.blockTime || 10000, // 10 seconds for testing
+      validateScripts: options.validateScripts !== false, // default true
+      logLevel: options.logLevel || 'info',
+      ...options
+    }
+    
+    this.currentBlock = {
+      height: 0,
+      transactions: [],
+      timestamp: Date.now()
+    }
+    
+    this.mempool = []
+  }
+
+  /**
+   * Add a transaction to the mempool for mining
+   * @param {Transaction} transaction - BSV transaction object
+   * @returns {boolean} - true if accepted, false if rejected
+   */
+  acceptTransaction(transaction) {
+    try {
+      // Validate transaction if script validation is enabled
+      if (this.options.validateScripts) {
+        const isValid = this.validateTransactionSignatures(transaction)
+        if (!isValid) {
+          this.log('warn', '❌ Transaction rejected: Invalid signatures')
+          return false
+        }
+      }
+
+      // Add to mempool
+      this.mempool.push(transaction)
+      this.log('info', `✅ Transaction accepted into mempool: ${transaction.id || 'unknown'}`)
+      return true
+
+    } catch (error) {
+      this.log('error', `❌ Transaction rejected: ${error.message}`)
+      return false
+    }
+  }
+
+  /**
+   * Validate transaction signatures using BSV library
+   * @param {Transaction} transaction - BSV transaction
+   * @returns {boolean} - true if all signatures are valid
+   */
+  validateTransactionSignatures(transaction) {
+    try {
+      // Use BSV's built-in transaction verification
+      const result = transaction.verify()
+      this.log('debug', `📊 Transaction verification result: ${result}`)
+      return result === true
+    } catch (error) {
+      this.log('warn', `⚠️ Signature validation error: ${error.message}`)
+      return false
+    }
+  }
+
+  /**
+   * Mine a new block with transactions from mempool
+   * @param {number} maxTransactions - Maximum transactions per block
+   * @returns {Object} - Mined block object
+   */
+  mineBlock(maxTransactions = 10) {
+    const transactions = this.mempool.splice(0, maxTransactions)
+    
+    const block = {
+      height: this.currentBlock.height + 1,
+      timestamp: Date.now(),
+      transactions: transactions,
+      transactionCount: transactions.length,
+      previousBlockHash: this.currentBlock.hash || '0000000000000000000000000000000000000000000000000000000000000000'
+    }
+
+    // Simple block hash simulation
+    const blockData = JSON.stringify({
+      height: block.height,
+      timestamp: block.timestamp,
+      previousBlockHash: block.previousBlockHash,
+      transactions: transactions.map(tx => tx.id || tx.toString())
+    })
+    
+    block.hash = this.bsv.crypto.Hash.sha256(Buffer.from(blockData)).toString('hex')
+    
+    this.currentBlock = block
+    
+    this.log('info', `⛏️ Mined block ${block.height} with ${transactions.length} transactions`)
+    this.log('debug', `📦 Block hash: ${block.hash}`)
+    
+    return block
+  }
+
+  /**
+   * Get mempool status
+   * @returns {Object} - Mempool statistics
+   */
+  getMempoolStats() {
+    return {
+      transactionCount: this.mempool.length,
+      transactions: this.mempool.map(tx => ({
+        id: tx.id || 'unknown',
+        size: tx.toBuffer ? tx.toBuffer().length : 0,
+        inputs: tx.inputs ? tx.inputs.length : 0,
+        outputs: tx.outputs ? tx.outputs.length : 0
+      }))
+    }
+  }
+
+  /**
+   * Get current blockchain status
+   * @returns {Object} - Blockchain statistics
+   */
+  getBlockchainStats() {
+    return {
+      currentHeight: this.currentBlock.height,
+      currentBlockHash: this.currentBlock.hash,
+      currentBlockTimestamp: this.currentBlock.timestamp,
+      mempoolSize: this.mempool.length,
+      difficulty: this.options.difficulty,
+      blockTime: this.options.blockTime
+    }
+  }
+
+  /**
+   * Reset the miner state
+   */
+  reset() {
+    this.currentBlock = {
+      height: 0,
+      transactions: [],
+      timestamp: Date.now()
+    }
+    this.mempool = []
+    this.log('info', '🔄 Miner reset to genesis state')
+  }
+
+  /**
+   * Logging utility
+   * @param {string} level - Log level
+   * @param {string} message - Log message
+   */
+  log(level, message) {
+    const levels = { error: 0, warn: 1, info: 2, debug: 3 }
+    const currentLevel = levels[this.options.logLevel] || 2
+    
+    if (levels[level] <= currentLevel) {
+      const timestamp = new Date().toISOString()
+      console.log(`[${timestamp}] [${level.toUpperCase()}] ${message}`)
+    }
+  }
+}
+
+module.exports = SmartMiner

package/lib/smartutxo.js

@@ -0,0 +1,200 @@
+'use strict'
+
+/**
+ * SmartLedger UTXO Management System
+ * Provides blockchain state management and UTXO tracking for testing and development
+ */
+
+// Browser-compatible imports
+let fs, path, crypto, blockchainState
+
+// Only require Node.js modules in Node.js environment
+if (typeof window === 'undefined' && typeof require === 'function') {
+  try {
+    fs = require('fs')
+    path = require('path')
+    crypto = require('crypto')
+    blockchainState = require('../utilities/blockchain-state')
+  } catch (e) {
+    // Fallback for environments where these modules aren't available
+    console.warn('SmartUTXO: Running in browser mode - some features may be limited')
+  }
+}
+
+/**
+ * Comprehensive UTXO Management System for BSV development
+ */
+class SmartUTXOManager {
+  constructor(options = {}) {
+    this.options = options || {}
+    
+    // Initialize blockchain state - this creates the file if needed
+    this.loadState()
+  }
+
+  /**
+   * Load blockchain state from file (initializes if needed)
+   */
+  loadState() {
+    try {
+      const state = blockchainState.loadBlockchainState()
+      return state
+    } catch (error) {
+      console.log('⚠️ Could not load blockchain state:', error.message)
+      return null
+    }
+  }
+
+  /**
+   * Save blockchain state to file  
+   */
+  saveState() {
+    try {
+      const state = blockchainState.loadBlockchainState()
+      blockchainState.saveBlockchainState(state)
+      const utxoCount = Object.keys(state.globalUTXOSet || {}).length
+      console.log(`💾 Saved blockchain state with ${utxoCount} UTXOs`)
+    } catch (error) {
+      console.log('⚠️ Could not save blockchain state:', error.message)
+    }
+  }
+
+  /**
+   * Get all UTXOs for a given address
+   * @param {string} address - Bitcoin address
+   * @returns {Array} Array of UTXO objects
+   */
+  getUTXOsForAddress(address) {
+    try {
+      const state = blockchainState.loadBlockchainState()
+      
+      // Check if wallet exists
+      if (!state.wallets || !state.wallets[address]) {
+        return []
+      }
+      
+      // Return the wallet's UTXOs
+      return state.wallets[address].utxos || []
+    } catch (error) {
+      console.log('⚠️ Error getting UTXOs:', error.message)
+      return []
+    }
+  }
+
+  /**
+   * Add a new UTXO to the system
+   * @param {Object} utxo - UTXO object {txid, vout, address, satoshis, script}
+   */
+  addUTXO(utxo) {
+    try {
+      // Use the correct API: addUTXO(utxo, ownerAddress)
+      blockchainState.addUTXO(utxo, utxo.address)
+    } catch (error) {
+      console.log('⚠️ Error adding UTXO:', error.message)
+    }
+  }
+
+  /**
+   * Spend UTXOs (remove from available set)
+   * @param {Array} inputs - Array of input objects {txid, vout}
+   * @param {string} spentInTx - Optional transaction ID where UTXO was spent
+   */
+  spendUTXOs(inputs, spentInTx = 'manual-spend') {
+    try {
+      for (const input of inputs) {
+        // Use the correct API: spendUTXO(txid, vout, spentInTx)
+        blockchainState.spendUTXO(input.txid, input.vout, spentInTx)
+      }
+    } catch (error) {
+      console.log('⚠️ Error spending UTXOs:', error.message)
+    }
+  }
+
+  /**
+   * Create mock UTXOs for testing
+   * @param {string} address - Target address
+   * @param {number} count - Number of UTXOs to create
+   * @param {number} satoshis - Satoshis per UTXO
+   * @returns {Array} Array of created UTXOs
+   */
+  createMockUTXOs(address, count = 5, satoshis = 100000) {
+    const mockUTXOs = []
+    
+    for (let i = 0; i < count; i++) {
+      const txid = crypto.randomBytes(32).toString('hex')
+      const vout = i
+      const script = `76a914${crypto.randomBytes(20).toString('hex')}88ac` // Mock P2PKH script
+      
+      const utxo = {
+        txid,
+        vout,
+        address,
+        satoshis,
+        script
+      }
+      
+      mockUTXOs.push(utxo)
+    }
+    
+    return mockUTXOs
+  }
+
+  /**
+   * Get total balance for an address
+   * @param {string} address - Bitcoin address
+   * @returns {number} Total satoshis
+   */
+  getBalance(address) {
+    try {
+      const state = blockchainState.loadBlockchainState()
+      
+      // Check if wallet exists
+      if (!state.wallets || !state.wallets[address]) {
+        return 0
+      }
+      
+      // Return the wallet's total value
+      return state.wallets[address].totalValue || 0
+    } catch (error) {
+      console.log('⚠️ Error getting balance:', error.message)
+      return 0
+    }
+  }
+
+  /**
+   * Get blockchain statistics
+   * @returns {Object} Stats object
+   */
+  getStats() {
+    try {
+      const state = blockchainState.getBlockchainStats() // This returns the full state
+      return {
+        totalUTXOs: state.metadata.totalUTXOs,
+        totalValue: state.metadata.totalValue,
+        totalWallets: state.metadata.totalWallets,
+        blockHeight: state.metadata.blockHeight,
+        lastUpdated: state.metadata.lastUpdated
+      }
+    } catch (error) {
+      console.log('⚠️ Error getting stats:', error.message)
+      return { totalUTXOs: 0, totalValue: 0, totalWallets: 0, blockHeight: 0 }
+    }
+  }
+
+  /**
+   * Reset blockchain state
+   */
+  reset() {
+    try {
+      const statePath = path.join(__dirname, '../utilities/blockchain-state.json')
+      if (fs.existsSync(statePath)) {
+        fs.unlinkSync(statePath)
+        console.log('🔄 Blockchain state reset')
+      }
+    } catch (error) {
+      console.log('⚠️ Could not reset blockchain state:', error.message)
+    }
+  }
+}
+
+module.exports = SmartUTXOManager

package/lib/transaction/transaction.js

@@ -24,6 +24,10 @@ var Output = require('./output')
 var Script = require('../script')
 var PrivateKey = require('../privatekey')
 var BN = require('../crypto/bn')
+var Interpreter = require('../script/interpreter')
+
+// By default, we sign with sighash_forkid
+var DEFAULT_SIGN_FLAGS = Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
 
 /**
  * Represents a transaction, a set of inputs and outputs to change ownership of tokens
@@ -1205,4 +1209,39 @@ Transaction.prototype.isCoinbase = function () {
   return (this.inputs.length === 1 && this.inputs[0].isNull())
 }
 
+/**
+ * Calculate the signature hash for an input
+ * 
+ * @param {number} inputIndex - The index of the input to sign
+ * @param {number} sighashType - The signature hash type (optional, defaults to ALL|FORKID)
+ * @param {Script} subscript - The subscript to use (optional, derived from input)
+ * @param {BN} satoshisBN - The amount in satoshis for this input (optional, derived from input)
+ * @param {number} flags - Script verification flags (optional)
+ * @return {Buffer} The signature hash for this input
+ */
+Transaction.prototype.sighash = function (inputIndex, sighashType, subscript, satoshisBN, flags) {
+  sighashType = sighashType || (Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID)
+  
+  // Get the input we're signing for
+  var input = this.inputs[inputIndex]
+  if (!input) {
+    throw new Error('Input index ' + inputIndex + ' does not exist')
+  }
+  
+  // If subscript not provided, derive it from the input
+  if (!subscript && input.output) {
+    subscript = input.output.script
+  }
+  
+  // If satoshisBN not provided, derive it from the input
+  if (!satoshisBN && input.output) {
+    satoshisBN = new BN(input.output.satoshis)
+  }
+  
+  // Use default flags if not provided
+  flags = flags || DEFAULT_SIGN_FLAGS
+  
+  return Sighash.sighash(this, sighashType, inputIndex, subscript, satoshisBN, flags)
+}
+
 module.exports = Transaction