@smartledger/bsv 7.8.1 → 7.10.0

package/lib/smartutxo.js

@@ -35,6 +35,13 @@ const debug = function () {
   if (enabled) console.log.apply(console, arguments)
 }
 
+// Library primitives, required directly rather than through the package root.
+// createMockUTXOs() previously did a lazy `require('../')` to dodge the
+// module-init cycle; with the cycle gone these can be plain top-level imports.
+const Script = require('./script')
+const Address = require('./address')
+const Random = require('./crypto/random')
+
 // Browser-compatible imports
 let fs, path, crypto, blockchainState
 
@@ -54,9 +61,9 @@ if (typeof window === 'undefined' && typeof require === 'function') {
  * Comprehensive UTXO Management System for BSV development
  */
 class SmartUTXOManager {
-  constructor(options = {}) {
+  constructor (options = {}) {
     this.options = options || {}
-    
+
     // Initialize blockchain state - this creates the file if needed
     this.loadState()
   }
@@ -64,7 +71,7 @@ class SmartUTXOManager {
   /**
    * Load blockchain state from file (initializes if needed)
    */
-  loadState() {
+  loadState () {
     try {
       const state = blockchainState.loadBlockchainState()
       return state
@@ -75,9 +82,9 @@ class SmartUTXOManager {
   }
 
   /**
-   * Save blockchain state to file  
+   * Save blockchain state to file
    */
-  saveState() {
+  saveState () {
     try {
       const state = blockchainState.loadBlockchainState()
       blockchainState.saveBlockchainState(state)
@@ -93,15 +100,15 @@ class SmartUTXOManager {
    * @param {string} address - Bitcoin address
    * @returns {Array} Array of UTXO objects
    */
-  getUTXOsForAddress(address) {
+  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) {
@@ -114,7 +121,7 @@ class SmartUTXOManager {
    * Add a new UTXO to the system
    * @param {Object} utxo - UTXO object {txid, vout, address, satoshis, script}
    */
-  addUTXO(utxo) {
+  addUTXO (utxo) {
     try {
       // Use the correct API: addUTXO(utxo, ownerAddress)
       blockchainState.addUTXO(utxo, utxo.address)
@@ -128,7 +135,7 @@ class SmartUTXOManager {
    * @param {Array} inputs - Array of input objects {txid, vout}
    * @param {string} spentInTx - Optional transaction ID where UTXO was spent
    */
-  spendUTXOs(inputs, spentInTx = 'manual-spend') {
+  spendUTXOs (inputs, spentInTx = 'manual-spend') {
     try {
       for (const input of inputs) {
         // Use the correct API: spendUTXO(txid, vout, spentInTx)
@@ -153,18 +160,17 @@ class SmartUTXOManager {
    * @param {number} satoshis - Satoshis per UTXO
    * @returns {Array} Array of created UTXOs
    */
-  createMockUTXOs(address, count = 5, satoshis = 100000) {
+  createMockUTXOs (address, count = 5, satoshis = 100000) {
     // Use bsv's own RNG so this works in both Node and browser builds
     // (the Node `crypto` import above is undefined in browser context).
-    const bsv = require('../')
-    const lockingScriptHex = bsv.Script.buildPublicKeyHashOut(
-      bsv.Address.fromString(address)
+    const lockingScriptHex = Script.buildPublicKeyHashOut(
+      Address.fromString(address)
     ).toHex()
 
     const mockUTXOs = []
     for (let i = 0; i < count; i++) {
       mockUTXOs.push({
-        txid: bsv.crypto.Random.getRandomBuffer(32).toString('hex'),
+        txid: Random.getRandomBuffer(32).toString('hex'),
         vout: i,
         address,
         satoshis,
@@ -179,15 +185,15 @@ class SmartUTXOManager {
    * @param {string} address - Bitcoin address
    * @returns {number} Total satoshis
    */
-  getBalance(address) {
+  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) {
@@ -200,7 +206,7 @@ class SmartUTXOManager {
    * Get blockchain statistics
    * @returns {Object} Stats object
    */
-  getStats() {
+  getStats () {
     try {
       const state = blockchainState.getBlockchainStats() // This returns the full state
       return {
@@ -219,7 +225,7 @@ class SmartUTXOManager {
   /**
    * Reset blockchain state
    */
-  reset() {
+  reset () {
     try {
       const statePath = path.join(__dirname, '../utilities/blockchain-state.json')
       if (fs.existsSync(statePath)) {
@@ -232,4 +238,4 @@ class SmartUTXOManager {
   }
 }
 
-module.exports = SmartUTXOManager
+module.exports = SmartUTXOManager

package/lib/spv/headerchain.js

@@ -15,14 +15,14 @@
  * (or anchor) must match; the headers around it are then real work extending a block
  * you trust. Full difficulty-retarget validation is intentionally out of scope here.
  */
-var bsv = require('../..')
+var BlockHeader = require('../block/blockheader')
 
 function rev (b) { return Buffer.from(b).reverse() }
 
 function toHeader (h) {
   if (h && typeof h.validProofOfWork === 'function') return h
-  if (Buffer.isBuffer(h)) return bsv.BlockHeader.fromBuffer(h)
-  if (typeof h === 'string') return bsv.BlockHeader.fromBuffer(Buffer.from(h, 'hex'))
+  if (Buffer.isBuffer(h)) return BlockHeader.fromBuffer(h)
+  if (typeof h === 'string') return BlockHeader.fromBuffer(Buffer.from(h, 'hex'))
   throw new Error('each header must be a BlockHeader, an 80-byte Buffer, or hex')
 }
 

package/lib/spv/merkleproof.js

@@ -15,8 +15,8 @@
  * lib/block/{block,merkleblock}.js. A node of '*' (or '' / null) means "duplicate the
  * working hash" — Bitcoin's odd-node rule, per the TSC Merkle Proof standard.
  */
-var bsv = require('../..')
-var Hash = bsv.crypto.Hash
+var BlockHeader = require('../block/blockheader')
+var Hash = require('../crypto/hash')
 
 var HEX32 = /^[0-9a-fA-F]{64}$/
 
@@ -81,7 +81,7 @@ function verifyMerkleProof (proof) {
 function verifyTxInclusion (params) {
   var header = params.header
   if (Buffer.isBuffer(header) || typeof header === 'string') {
-    header = bsv.BlockHeader.fromBuffer(Buffer.isBuffer(header) ? header : Buffer.from(header, 'hex'))
+    header = BlockHeader.fromBuffer(Buffer.isBuffer(header) ? header : Buffer.from(header, 'hex'))
   }
   if (!header || !header.merkleRoot) throw new Error('a valid block header is required')
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartledger/bsv",
-  "version": "7.8.1",
+  "version": "7.10.0",
   "description": "🚀 Complete Bitcoin SV development framework with legally-recognizable DID:web + W3C VC-JWT toolkit, Legal Token Protocol (LTP), Global Digital Attestation Framework (GDAF), StatusList2021 revocation, and 16 flexible loading options. Standards-based credentials with ES256/ES256K support, on-chain BSV anchoring, and comprehensive Bitcoin SV API. Perfect for legal tokens, verifiable credentials, DeFi, smart contracts, and secure Bitcoin applications.",
   "author": "SmartLedger Technology <hello@smartledger.technology> (https://smartledger.technology)",
   "homepage": "https://github.com/codenlighten/smartledger-bsv#readme",
@@ -31,6 +31,7 @@
     "./vcjwt": "./vcjwt-entry.js",
     "./lib/anchor": "./lib/anchor/index.js",
     "./lib/block": "./lib/block/index.js",
+    "./lib/covenant": "./lib/covenant/index.js",
     "./lib/didweb": "./lib/didweb/index.js",
     "./lib/ecies": "./lib/ecies/index.js",
     "./lib/errors": "./lib/errors/index.js",
@@ -58,6 +59,8 @@
   "scripts": {
     "lint": "standard",
     "check:load-order": "node scripts/check-address-load-order.js",
+    "conformance": "node conformance/verify.js",
+    "conformance:generate": "node conformance/generate.js",
     "lint:ratchet": "node scripts/lint-ratchet.js",
     "lint:ratchet:update": "node scripts/lint-ratchet.js --update",
     "test": "mocha",
@@ -227,7 +230,6 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
-    "aes-js": "^3.1.2",
     "bn.js": "=4.12.5",
     "bs58": "=4.0.1",
     "clone-deep": "^4.0.1",

package/test/script/chronicle.js

@@ -114,32 +114,75 @@ describe('Chronicle script surface', function () {
   })
 
   describe('OP_VERIF / OP_VERNOTIF', function () {
-    it('are BAD_OPCODE without the flag EVEN IN AN UNEXECUTED BRANCH', function () {
-      // A rule Bitcoin applies to no other opcode, which is why the flag check sits
-      // outside the fExec guard. If it moved inside, this script would pass.
-      var r = run(function (s) {
+    it('without the flag, errors only in an EXECUTED branch', function () {
+      // Core treats OP_VERIF as illegal everywhere, including unexecuted
+      // branches — a rule it applies to no other opcode. BSV dropped that at
+      // Genesis, and the node is explicit:
+      //
+      //   if(!utxo_after_chronicle) {
+      //     if(utxo_after_genesis && !fExec) break;
+      //     else return SCRIPT_ERR_BAD_OPCODE;
+      //   }
+      //
+      // Asserting BAD_OPCODE here made this library reject scripts the network
+      // accepts.
+      var unexecuted = run(function (s) {
         s.add(Opcode.OP_0).add(Opcode.OP_IF).add(Opcode.OP_VERIF).add(Opcode.OP_ENDIF).add(Opcode.OP_1)
       }, { flags: 0 })
-      r.verified.should.equal(false)
-      r.errstr.should.match(/BAD_OPCODE/)
+      unexecuted.verified.should.equal(true)
+
+      var executed = run(function (s) {
+        s.add(Opcode.OP_1).add(Opcode.OP_VERIF).add(Opcode.OP_ENDIF)
+      }, { flags: 0 })
+      executed.verified.should.equal(false)
+      executed.errstr.should.match(/BAD_OPCODE/)
     })
 
-    it('OP_VERIF takes the branch when the top of stack equals the tx version', function () {
+    // The comparison is BYTE-WISE against the four little-endian version
+    // bytes, not numeric:
+    //
+    //   if(vch.size() == 4) { to_le(checker.Version(), val.data());
+    //                         fValue = std::ranges::equal(val, vch); }
+    //
+    // So a 1-byte script number never matches, however equal it looks
+    // numerically, and the idiomatic form is `OP_VER OP_VERIF`.
+    var LE = function (v) {
+      var b = Buffer.alloc(4)
+      b.writeInt32LE(v, 0)
+      return b
+    }
+
+    it('OP_VERIF takes the branch on a 4-byte little-endian version match', function () {
       var taken = run(function (s) {
-        s.add(new BN(2).toScriptNumBuffer()).add(Opcode.OP_VERIF).add(Opcode.OP_1).add(Opcode.OP_ENDIF)
+        s.add(LE(2)).add(Opcode.OP_VERIF).add(Opcode.OP_1).add(Opcode.OP_ENDIF)
       }, { version: 2 })
       taken.verified.should.equal(true)
 
       var notTaken = run(function (s) {
-        s.add(new BN(9).toScriptNumBuffer()).add(Opcode.OP_VERIF).add(Opcode.OP_1).add(Opcode.OP_ENDIF).add(Opcode.OP_1)
+        s.add(LE(9)).add(Opcode.OP_VERIF).add(Opcode.OP_1).add(Opcode.OP_ENDIF).add(Opcode.OP_1)
       }, { version: 2 })
       notTaken.verified.should.equal(true)
       notTaken.stack.length.should.equal(1) // only the trailing OP_1
     })
 
+    it('a numerically-equal operand of the wrong LENGTH does not match', function () {
+      var r = run(function (s) {
+        s.add(new BN(2).toScriptNumBuffer()).add(Opcode.OP_VERIF).add(Opcode.OP_1).add(Opcode.OP_ENDIF).add(Opcode.OP_1)
+      }, { version: 2 })
+      r.verified.should.equal(true)
+      r.stack.length.should.equal(1) // branch NOT taken
+    })
+
+    it('OP_VER feeds OP_VERIF directly', function () {
+      var r = run(function (s) {
+        s.add(Opcode.OP_VER).add(Opcode.OP_VERIF).add(Opcode.OP_1).add(Opcode.OP_ENDIF)
+      }, { version: 2 })
+      r.verified.should.equal(true)
+    })
+
     it('OP_VERNOTIF is its negation', function () {
       var r = run(function (s) {
-        s.add(new BN(9).toScriptNumBuffer()).add(Opcode.OP_VERNOTIF).add(Opcode.OP_1).add(Opcode.OP_ENDIF)
+        s.add(LE(9)).add(Opcode.OP_VERNOTIF).add(Opcode.OP_1).add(Opcode.OP_ENDIF)
       }, { version: 2 })
       r.verified.should.equal(true)
     })

package/test/script/interpreter.js

@@ -649,6 +649,14 @@ describe('Interpreter', function () {
   //    (0xba is no longer a NOP either; it is unassigned, which now AGREES with
   //    Core, so its former override has been removed.)
   var BSV_DIVERGENCES = {
+    //  - OP_VERIF/OP_VERNOTIF are "illegal everywhere" in Core, including in an
+    //    unexecuted branch — a rule it applies to no other opcode. BSV dropped
+    //    that at Genesis: the node breaks when the branch is not executed and
+    //    the UTXO predates Chronicle. So these four verify here.
+    '0|IF VERIF ELSE 1 ENDIF|P2SH,STRICTENC': 'OK',
+    '0|IF ELSE 1 ELSE VERIF ENDIF|P2SH,STRICTENC': 'OK',
+    '0|IF VERNOTIF ELSE 1 ENDIF|P2SH,STRICTENC': 'OK',
+    '0|IF ELSE 1 ELSE VERNOTIF ENDIF|P2SH,STRICTENC': 'OK',
     "'a' 'b'|CAT|P2SH,STRICTENC": 'OK',
     "'a' 'b' 0|IF CAT ELSE 1 ENDIF|P2SH,STRICTENC": 'OK',
     "'abc' 1|SPLIT|P2SH,STRICTENC": 'OK',
@@ -661,15 +669,10 @@ describe('Interpreter', function () {
     '2 2 0 IF DIV ELSE 1 ENDIF|NOP|P2SH,STRICTENC': 'OK',
     '2 2 0 IF MOD ELSE 1 ENDIF|NOP|P2SH,STRICTENC': 'OK',
     '2 DUP DIV|1 EQUAL|P2SH,STRICTENC': 'OK',
-    '7 3 MOD|1 EQUAL|P2SH,STRICTENC': 'OK',
+    '7 3 MOD|1 EQUAL|P2SH,STRICTENC': 'OK'
 
     // Chronicle byte reassignment (see the note above). Values are the BSV error,
     // recorded for documentation; the harness only distinguishes 'OK' from not-'OK'.
-    '1|NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 NOP10 1 EQUAL|P2SH,STRICTENC': 'SCRIPT_ERR_INVALID_STACK_OPERATION',
-    "'NOP_1_to_10' NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 NOP10|'NOP_1_to_10' EQUAL|P2SH,STRICTENC": 'SCRIPT_ERR_INVALID_STACK_OPERATION',
-    'NOP|NOP4 1|P2SH,STRICTENC': 'SCRIPT_ERR_INVALID_STACK_OPERATION',
-    'NOP|NOP5 1|P2SH,STRICTENC': 'SCRIPT_ERR_INVALID_STACK_OPERATION',
-    'NOP|NOP6 1|P2SH,STRICTENC': 'SCRIPT_ERR_INVALID_STACK_OPERATION'
   }
 
   describe('bitcoind script evaluation fixtures', function () {

package/test/script/string_ops.js

@@ -7,10 +7,15 @@ var Interpreter = bsv.Script.Interpreter
 var Script = bsv.Script
 var Opcode = bsv.Opcode
 var Transaction = bsv.Transaction
+var CHRONICLE = Interpreter.SCRIPT_ENABLE_CHRONICLE
 
-// OP_SUBSTR / OP_LEFT / OP_RIGHT — re-enabled BSV (Chronicle) string opcodes,
-// original Satoshi semantics. Declared in the opcode map at 0xb3/0xb4/0xb5 but
-// previously unimplemented (BAD_OPCODE). These tests verify behavior end-to-end.
+// OP_SUBSTR / OP_LEFT / OP_RIGHT — Chronicle string opcodes at 0xb3/0xb4/0xb5.
+//
+// Every case here passes SCRIPT_ENABLE_CHRONICLE, because without it these
+// bytes are UPGRADABLE NOPS, exactly as they are on a pre-Chronicle node. An
+// earlier version of these tests ran them with flags=0 and passed, which is
+// what hid the fact that the interpreter was executing them unconditionally —
+// more permissively than the network.
 describe('String opcodes OP_SUBSTR / OP_LEFT / OP_RIGHT', function () {
   var DATA = Buffer.from('aabbccdd', 'hex')
 
@@ -20,14 +25,14 @@ describe('String opcodes OP_SUBSTR / OP_LEFT / OP_RIGHT', function () {
     buildOps(lock)
     lock.add(Buffer.from(expectedHex, 'hex')).add(Opcode.OP_EQUAL)
     var interp = new Interpreter()
-    return interp.verify(new Script(), lock, new Transaction(), 0, 0)
+    return interp.verify(new Script(), lock, new Transaction(), 0, CHRONICLE)
   }
   function errors (buildOps) {
     var lock = new Script().add(DATA)
     buildOps(lock)
     var interp = new Interpreter()
     var ok
-    try { ok = interp.verify(new Script(), lock, new Transaction(), 0, 0) } catch (e) { ok = false }
+    try { ok = interp.verify(new Script(), lock, new Transaction(), 0, CHRONICLE) } catch (e) { ok = false }
     return ok === false
   }
 
@@ -52,12 +57,23 @@ describe('String opcodes OP_SUBSTR / OP_LEFT / OP_RIGHT', function () {
     yields(function (s) { s.add(Opcode.OP_1).add(Opcode.OP_2).add(Opcode.OP_SUBSTR) }, 'bbcc').should.equal(true)
   })
 
-  it('OP_LEFT clamps n greater than the length', function () {
-    yields(function (s) { s.add(Opcode.OP_10).add(Opcode.OP_LEFT) }, 'aabbccdd').should.equal(true)
+  // The node ERRORS rather than clamping:
+  //   if(len < 0 || len > size) return SCRIPT_ERR_INVALID_NUMBER_RANGE;
+  // Clamping made scripts the node rejects succeed here.
+  it('OP_LEFT rejects n greater than the length', function () {
+    errors(function (s) { s.add(Opcode.OP_10).add(Opcode.OP_LEFT) }).should.equal(true)
   })
 
-  it('OP_RIGHT clamps n greater than the length', function () {
-    yields(function (s) { s.add(Opcode.OP_10).add(Opcode.OP_RIGHT) }, 'aabbccdd').should.equal(true)
+  it('OP_RIGHT rejects n greater than the length', function () {
+    errors(function (s) { s.add(Opcode.OP_10).add(Opcode.OP_RIGHT) }).should.equal(true)
+  })
+
+  it('is a no-op without SCRIPT_ENABLE_CHRONICLE, as a pre-Chronicle node is', function () {
+    const interp = new Interpreter()
+    const lock = new Script().add(DATA).add(Opcode.OP_2).add(Opcode.OP_LEFT)
+    interp.verify(new Script(), lock, new Transaction(), 0, 0).should.equal(true)
+    // Untouched: the opcode did nothing, so both operands survive.
+    interp.stack.length.should.equal(2)
   })
 
   it('rejects a negative size', function () {
@@ -67,6 +83,6 @@ describe('String opcodes OP_SUBSTR / OP_LEFT / OP_RIGHT', function () {
   it('rejects OP_LEFT with too few stack items', function () {
     var interp = new Interpreter()
     var lock = new Script().add(Opcode.OP_LEFT) // nothing to operate on
-    interp.verify(new Script(), lock, new Transaction(), 0, 0).should.equal(false)
+    interp.verify(new Script(), lock, new Transaction(), 0, CHRONICLE).should.equal(false)
   })
 })

package/version.js

@@ -1,3 +1,3 @@
 'use strict'
 // GENERATED by scripts/sync-version.js on `npm version` — do not edit.
-module.exports = '7.8.1'
+module.exports = '7.10.0'