smartledger-bsv 3.0.1 → 3.1.0

package/index.js

@@ -97,5 +97,16 @@ 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')
+    bsv.CustomScriptHelper = require('./lib/custom-script-helper')
+  } 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/custom-script-helper.js

@@ -0,0 +1,249 @@
+/**
+ * SmartLedger BSV Custom Script Helper
+ * Simplified API for custom script development
+ */
+
+const bsv = require('../index.js');
+
+class CustomScriptHelper {
+  
+  /**
+   * Create a signature for any custom script
+   * @param {Transaction} transaction - The transaction object
+   * @param {PrivateKey} privateKey - Private key to sign with
+   * @param {number} inputIndex - Input index (0 for first input)
+   * @param {Script} lockingScript - The locking script being spent
+   * @param {number} satoshis - Amount in satoshis
+   * @param {number} sighashType - Signature hash type
+   * @returns {Buffer} Complete signature with sighash type
+   */
+  static createSignature(transaction, privateKey, inputIndex, lockingScript, satoshis, sighashType = null) {
+    sighashType = sighashType || (bsv.crypto.Signature.SIGHASH_ALL | bsv.crypto.Signature.SIGHASH_FORKID);
+    
+    const signature = bsv.Transaction.sighash.sign(
+      transaction,
+      privateKey,
+      sighashType,
+      inputIndex,
+      lockingScript,
+      new bsv.crypto.BN(satoshis)
+    );
+    
+    return Buffer.concat([signature.toDER(), Buffer.from([sighashType])]);
+  }
+
+  /**
+   * Create a multi-signature locking script
+   * @param {number} m - Required signatures
+   * @param {PublicKey[]} publicKeys - Array of public keys
+   * @returns {Script} Multi-signature locking script
+   */
+  static createMultisigScript(m, publicKeys) {
+    let script = new bsv.Script().add(bsv.Opcode[`OP_${m}`]);
+    
+    for (const pubKey of publicKeys) {
+      script = script.add(pubKey.toBuffer());
+    }
+    
+    return script
+      .add(bsv.Opcode[`OP_${publicKeys.length}`])
+      .add(bsv.Opcode.OP_CHECKMULTISIG);
+  }
+
+  /**
+   * Create an unlocking script for multi-signature
+   * @param {Buffer[]} signatures - Array of signatures
+   * @returns {Script} Unlocking script for multisig
+   */
+  static createMultisigUnlocking(signatures) {
+    let script = new bsv.Script().add(bsv.Opcode.OP_0); // CHECKMULTISIG bug
+    
+    for (const sig of signatures) {
+      script = script.add(sig);
+    }
+    
+    return script;
+  }
+
+  /**
+   * Create a time-locked script (CHECKLOCKTIMEVERIFY)
+   * @param {number} lockTime - Block height or timestamp
+   * @param {Script} baseScript - Base script to execute after time lock
+   * @returns {Script} Time-locked script
+   */
+  static createTimelockScript(lockTime, baseScript) {
+    const lockTimeBuffer = Buffer.from(lockTime.toString(16).padStart(8, '0'), 'hex').reverse();
+    
+    return new bsv.Script()
+      .add(lockTimeBuffer)
+      .add(bsv.Opcode.OP_CHECKLOCKTIMEVERIFY)
+      .add(bsv.Opcode.OP_DROP)
+      .add(baseScript.toBuffer());
+  }
+
+  /**
+   * Create a conditional script (IF/ELSE/ENDIF)
+   * @param {Script} ifScript - Script to execute if condition is true
+   * @param {Script} elseScript - Script to execute if condition is false
+   * @returns {Script} Conditional script
+   */
+  static createConditionalScript(ifScript, elseScript = null) {
+    let script = new bsv.Script()
+      .add(bsv.Opcode.OP_IF)
+      .add(ifScript.toBuffer());
+    
+    if (elseScript) {
+      script = script
+        .add(bsv.Opcode.OP_ELSE)
+        .add(elseScript.toBuffer());
+    }
+    
+    return script.add(bsv.Opcode.OP_ENDIF);
+  }
+
+  /**
+   * Create P2PKH script for a public key
+   * @param {PublicKey} publicKey - Public key
+   * @returns {Script} P2PKH locking script
+   */
+  static createP2PKHScript(publicKey) {
+    return new bsv.Script()
+      .add(bsv.Opcode.OP_DUP)
+      .add(bsv.Opcode.OP_HASH160)
+      .add(publicKey.toAddress().hashBuffer)
+      .add(bsv.Opcode.OP_EQUALVERIFY)
+      .add(bsv.Opcode.OP_CHECKSIG);
+  }
+
+  /**
+   * Create P2PKH unlocking script
+   * @param {Buffer} signature - Signature
+   * @param {PublicKey} publicKey - Public key
+   * @returns {Script} P2PKH unlocking script
+   */
+  static createP2PKHUnlocking(signature, publicKey) {
+    return new bsv.Script()
+      .add(signature)
+      .add(publicKey.toBuffer());
+  }
+
+  /**
+   * Get transaction preimage for covenant scripts
+   * @param {Transaction} transaction - The transaction
+   * @param {number} inputIndex - Input index
+   * @param {Script} lockingScript - Locking script
+   * @param {number} satoshis - Amount in satoshis
+   * @param {number} sighashType - Signature hash type
+   * @returns {Buffer} Transaction preimage
+   */
+  static getPreimage(transaction, inputIndex, lockingScript, satoshis, sighashType = null) {
+    sighashType = sighashType || (bsv.crypto.Signature.SIGHASH_ALL | bsv.crypto.Signature.SIGHASH_FORKID);
+    
+    return bsv.Transaction.sighash.sighash(
+      transaction,
+      sighashType,
+      inputIndex,
+      lockingScript,
+      new bsv.crypto.BN(satoshis)
+    );
+  }
+
+  /**
+   * Create a simple data push script
+   * @param {Buffer|string} data - Data to push
+   * @returns {Script} Data push script
+   */
+  static createDataScript(data) {
+    if (typeof data === 'string') {
+      data = Buffer.from(data, 'utf8');
+    }
+    return new bsv.Script().add(data);
+  }
+
+  /**
+   * Create OP_RETURN data script
+   * @param {Buffer|string} data - Data for OP_RETURN
+   * @returns {Script} OP_RETURN script
+   */
+  static createOpReturnScript(data) {
+    if (typeof data === 'string') {
+      data = Buffer.from(data, 'utf8');
+    }
+    return new bsv.Script()
+      .add(bsv.Opcode.OP_FALSE)
+      .add(bsv.Opcode.OP_RETURN)
+      .add(data);
+  }
+
+  /**
+   * Validate a transaction with custom scripts
+   * @param {Transaction} transaction - Transaction to validate
+   * @returns {boolean} True if valid
+   */
+  static validateTransaction(transaction) {
+    try {
+      return transaction.verify();
+    } catch (error) {
+      console.error('Transaction validation error:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Validate a specific input script
+   * @param {Script} unlockingScript - Unlocking script
+   * @param {Script} lockingScript - Locking script
+   * @param {Transaction} transaction - Transaction
+   * @param {number} inputIndex - Input index
+   * @returns {boolean} True if script is valid
+   */
+  static validateScript(unlockingScript, lockingScript, transaction, inputIndex) {
+    try {
+      const interpreter = new bsv.Script.Interpreter();
+      return interpreter.verify(
+        unlockingScript,
+        lockingScript,
+        transaction,
+        inputIndex,
+        bsv.Script.Interpreter.SCRIPT_VERIFY_P2SH | 
+        bsv.Script.Interpreter.SCRIPT_VERIFY_STRICTENC |
+        bsv.Script.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
+        bsv.Script.Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES |
+        bsv.Script.Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES
+      );
+    } catch (error) {
+      console.error('Script validation error:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Create a transaction with ultra-low fees
+   * @param {Object[]} utxos - Array of UTXOs
+   * @param {Object[]} outputs - Array of outputs
+   * @param {number} feePerKb - Fee per KB (default: 10 sats = 0.01 sats/byte)
+   * @returns {Transaction} Transaction with ultra-low fees
+   */
+  static createLowFeeTransaction(utxos, outputs, feePerKb = 10) {
+    let tx = new bsv.Transaction().feePerKb(feePerKb);
+    
+    // Add inputs
+    for (const utxo of utxos) {
+      tx = tx.from(utxo);
+    }
+    
+    // Add outputs
+    for (const output of outputs) {
+      tx = tx.to(output.address, output.satoshis);
+    }
+    
+    return tx;
+  }
+}
+
+// Common signature hash types
+CustomScriptHelper.SIGHASH_ALL = bsv.crypto.Signature.SIGHASH_ALL | bsv.crypto.Signature.SIGHASH_FORKID;
+CustomScriptHelper.SIGHASH_NONE = bsv.crypto.Signature.SIGHASH_NONE | bsv.crypto.Signature.SIGHASH_FORKID;
+CustomScriptHelper.SIGHASH_SINGLE = bsv.crypto.Signature.SIGHASH_SINGLE | bsv.crypto.Signature.SIGHASH_FORKID;
+
+module.exports = CustomScriptHelper;

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