@smartledger/bsv 6.2.1 → 7.0.0

package/lib/smart_contract/preimage.js

@@ -40,6 +40,15 @@ function Preimage(preimage, options) {
   }
 }
 
+// Structural minimum of a BIP-143 preimage, so a too-short buffer fails with an
+// HONEST error instead of tripping decodeCompactSize into a misleading
+// "8-byte CompactSize" throw. LEFT fixed (nVersion 4 + hashPrevouts 32 +
+// hashSequence 32 + outpoint 36 = 104) + smallest scriptLen varint (1) + RIGHT
+// fixed (amount 8 + nSequence 4 + hashOutputs 32 + nLocktime 4 + sighash 4 = 52).
+Preimage.LEFT_FIXED_LENGTH = 4 + 32 + 32 + 36 // 104
+Preimage.RIGHT_FIXED_LENGTH = 8 + 4 + 32 + 4 + 4 // 52
+Preimage.MIN_PREIMAGE_LENGTH = Preimage.LEFT_FIXED_LENGTH + 1 + Preimage.RIGHT_FIXED_LENGTH // 157
+
 /**
  * Extract all preimage fields using bidirectional strategy
  * @param {string} extractionStrategy - 'LEFT', 'RIGHT', or 'DYNAMIC'
@@ -141,13 +150,27 @@ Preimage.prototype.extractFields = function(fieldNames) {
  * @returns {Object} Validation result
  */
 Preimage.prototype.validate = function() {
+  var errors = []
+  var warnings = []
+
+  // Length first: a buffer too short to hold the fixed fields can't be
+  // field-extracted, so report it without tripping extraction. (For a
+  // non-deferred Preimage construction already threw the same error.)
+  if (this.preimage.length < Preimage.MIN_PREIMAGE_LENGTH) {
+    errors.push('Preimage too short: ' + this.preimage.length +
+      ' bytes (BIP-143 preimage requires at least ' + Preimage.MIN_PREIMAGE_LENGTH + ')')
+    return {
+      valid: false,
+      errors: errors,
+      warnings: warnings,
+      sighashInfo: this.sighashInfo
+    }
+  }
+
   if (!this.fields) {
     this._extractFields()
   }
 
-  var errors = []
-  var warnings = []
-
   // Check required fields
   var requiredFields = [
     'version', 'hashPrevouts', 'hashSequence', 'outpoint',
@@ -165,11 +188,6 @@ Preimage.prototype.validate = function() {
     warnings.push('Zero hashes detected - check SIGHASH flags: ' + this.sighashInfo.zeroFields.join(', '))
   }
 
-  // Validate preimage length
-  if (this.preimage.length < 104) { // Minimum BIP-143 preimage size
-    errors.push('Preimage too short: ' + this.preimage.length + ' bytes (minimum 104)')
-  }
-
   return {
     valid: errors.length === 0,
     errors: errors,
@@ -222,6 +240,13 @@ Preimage.prototype._extractFields = function() {
     warnings: []
   }
 
+  // Fail closed with an honest error before any slice/varint work runs on a
+  // buffer too small to hold the fixed BIP-143 fields.
+  if (this.preimage.length < Preimage.MIN_PREIMAGE_LENGTH) {
+    throw new Error('Preimage too short: ' + this.preimage.length +
+      ' bytes (BIP-143 preimage requires at least ' + Preimage.MIN_PREIMAGE_LENGTH + ')')
+  }
+
   try {
     if (this.strategy === 'LEFT' || this.strategy === 'DYNAMIC') {
       this._extractFromLeft()
@@ -735,6 +760,10 @@ Preimage.prototype._getExtractionStrategy = function(fieldName) {
  * @returns {Object} Decoded value and next offset
  */
 Preimage.decodeCompactSize = function(buffer, offset) {
+  if (offset >= buffer.length) {
+    throw new Error('CompactSize read past end of preimage buffer (offset ' +
+      offset + ', length ' + buffer.length + ')')
+  }
   var firstByte = buffer[offset]
 
   if (firstByte < 0xfd) {
@@ -742,24 +771,22 @@ Preimage.decodeCompactSize = function(buffer, offset) {
     return { value: firstByte, nextOffset: offset + 1, bytes: 1 }
   } else if (firstByte === 0xfd) {
     // 2 byte encoding (253-65535)
+    if (offset + 3 > buffer.length) {
+      throw new Error('Truncated 2-byte CompactSize in preimage at offset ' + offset)
+    }
     var value = buffer.readUInt16LE(offset + 1)
     return { value: value, nextOffset: offset + 3, bytes: 3 }
   } else if (firstByte === 0xfe) {
     // 4 byte encoding (65536-4294967295) - rare for script lengths
-    var value = buffer.readUInt32LE(offset + 1)
-    return { value: value, nextOffset: offset + 5, bytes: 5 }
-  } else {
-    // 8 byte encoding - extremely rare, try to handle gracefully
-    console.warn('Encountered 8-byte CompactSize - this is very unusual for script lengths')
-    // For our purposes, assume it's a reasonable script length and try to parse it
-    // This is a fallback for malformed or test data
-    try {
-      // Read as 4-byte for now since 8-byte values would be enormous for scripts
-      var value = buffer.readUInt32LE(offset + 1)
-      return { value: value, nextOffset: offset + 9, bytes: 9 } // Skip full 8 bytes + marker
-    } catch (e) {
-      throw new Error('Invalid 8-byte CompactSize encoding in preimage')
+    if (offset + 5 > buffer.length) {
+      throw new Error('Truncated 4-byte CompactSize in preimage at offset ' + offset)
     }
+    var value4 = buffer.readUInt32LE(offset + 1)
+    return { value: value4, nextOffset: offset + 5, bytes: 5 }
+  } else {
+    // 0xff marks an 8-byte length (>4 GB) - impossible for a real script length,
+    // so this is malformed/misaligned data rather than a value to salvage.
+    throw new Error('Invalid CompactSize: 8-byte length prefix (0xff) is not a valid script length')
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartledger/bsv",
-  "version": "6.2.1",
+  "version": "7.0.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",
@@ -9,6 +9,19 @@
   },
   "main": "index.js",
   "types": "bsv.d.ts",
+  "exports": {
+    ".": {
+      "types": "./bsv.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json",
+    "./version": "./version.js",
+    "./lib/*.js": "./lib/*.js",
+    "./lib/*": "./lib/*.js",
+    "./*": "./*"
+  },
   "engines": {
     "node": ">=20.19.0"
   },
@@ -51,7 +64,7 @@
     "preimage:extract": "node examples/preimage/extract_preimage_bidirectional.js",
     "prepublishOnly": "npm run build-all",
     "sync-cdn": "node scripts/sync-cdn-urls.js",
-    "version": "node scripts/sync-cdn-urls.js && node scripts/sync-version.js && git add README.md docs version.js",
+    "version": "node scripts/sync-cdn-urls.js && node scripts/sync-version.js && node scripts/gen-esm-wrapper.js && git add README.md docs version.js index.mjs",
     "test:browser:ci": "node tests/browser-smoke-runner.js"
   },
   "unpkg": "bsv.min.js",
@@ -59,6 +72,7 @@
   "cdn": "bsv.min.js",
   "files": [
     "index.js",
+    "index.mjs",
     "version.js",
     "test/",
     ".mocharc.json",
@@ -196,12 +210,12 @@
   },
   "devDependencies": {
     "assert": "^2.1.0",
-    "brfs": "2.0.1",
     "browserify-zlib": "^0.2.0",
     "buffer": "^6.0.3",
     "chai": "4.2.0",
     "crypto-browserify": "^3.12.1",
     "esbuild": "^0.28.1",
+    "events": "^3.3.0",
     "jose": "^5.10.0",
     "mocha": "^11.7.6",
     "nyc": "^18.0.0",
@@ -210,12 +224,9 @@
     "sinon": "7.2.3",
     "standard": "12.0.1",
     "stream-browserify": "^3.0.0",
-    "terser-webpack-plugin": "^5.6.1",
     "typescript": "^5.9.3",
     "util": "^0.12.5",
-    "vm-browserify": "^1.1.2",
-    "webpack": "^5.107.2",
-    "webpack-cli": "^5.1.4"
+    "vm-browserify": "^1.1.2"
   },
   "license": "MIT",
   "standard": {

package/test/build/esm_wrapper.js

@@ -0,0 +1,66 @@
+'use strict'
+
+/* global describe, it */
+
+// Guards index.mjs — the real ESM entry behind the package's `import` condition.
+// Asserts (a) it hasn't drifted from the CJS surface, (b) native ESM default AND
+// named imports actually work, and (c) deprecated getters (SmartUTXO) are NOT
+// forced as named exports (they'd fire their warning on every import).
+//
+// ESM behaviour is exercised in a child process (via an --input-type=module
+// script string) rather than a dynamic import() in this file, so the source
+// stays parseable by the pinned standard@12 linter.
+
+require('chai').should()
+var fs = require('fs')
+var path = require('path')
+var execFileSync = require('child_process').execFileSync
+var spawnSync = require('child_process').spawnSync
+var gen = require('../../scripts/gen-esm-wrapper')
+
+var ROOT = path.resolve(__dirname, '../..')
+var MJS = path.join(ROOT, 'index.mjs')
+
+function runEsm (body) {
+  return execFileSync(process.execPath, ['--input-type=module', '-e', body],
+    { cwd: ROOT, stdio: 'pipe' })
+}
+
+describe('ESM wrapper (index.mjs)', function () {
+  it('is in sync with the CJS surface (no drift)', function () {
+    var onDisk = fs.readFileSync(MJS, 'utf8')
+    onDisk.should.equal(gen.generate())
+  })
+
+  it('exports every non-accessor top-level member as a named binding', function () {
+    var bsv = require('../..')
+    var names = gen.exportableNames(bsv)
+    names.length.should.be.above(100)
+    // SmartUTXO is an accessor (deprecated getter) and must be excluded.
+    names.should.not.include('SmartUTXO')
+    Object.getOwnPropertyDescriptor(bsv, 'SmartUTXO').get.should.be.a('function')
+  })
+
+  it('resolves real ESM default + named imports natively', function () {
+    runEsm(
+      'import bsv, { PrivateKey, crypto } from ' + JSON.stringify('./index.mjs') + ';' +
+      'process.exit((bsv && typeof PrivateKey === "function" && ' +
+      'PrivateKey === bsv.PrivateKey && typeof crypto.ECDSA === "function") ? 0 : 3)')
+  })
+
+  it('does not emit the SmartUTXO deprecation warning at import (getter excluded)', function () {
+    // Re-exporting the getter would trip its console.warn at import time; stderr
+    // must be empty for a bare `import './index.mjs'`.
+    var res = spawnSync(process.execPath,
+      ['--input-type=module', '-e', 'import ' + JSON.stringify('./index.mjs') + ';'],
+      { cwd: ROOT, encoding: 'utf8' })
+    res.status.should.equal(0)
+    res.stderr.should.equal('')
+  })
+
+  it('keeps deprecated getters reachable via the default export only', function () {
+    runEsm(
+      'import bsv from ' + JSON.stringify('./index.mjs') + ';' +
+      'process.exit(("SmartUTXO" in bsv) ? 0 : 3)')
+  })
+})

package/test/build/exports_resolution.js

@@ -0,0 +1,58 @@
+'use strict'
+
+/* global describe, it */
+
+// Guards the 7.0 package.json `exports` map. Adding `exports` switches Node to
+// strict subpath resolution, so this asserts the surface consumers actually use
+// still resolves (via package self-reference, which Node enables once `exports`
+// exists): the main entry, package.json, ./version, the shipped bundles, and
+// lib/* deep imports in BOTH extension styles. Also smoke-tests the ESM `import`
+// condition in a child process so the dual-ready "." entry can't silently rot.
+
+require('chai').should()
+var path = require('path')
+var execFileSync = require('child_process').execFileSync
+
+var N = '@smartledger/bsv'
+var ROOT = path.resolve(__dirname, '../..')
+
+describe('7.0 exports map resolution', function () {
+  it('resolves the main entry via self-reference', function () {
+    var bsv = require(N)
+    bsv.should.be.an('object')
+    bsv.PrivateKey.should.be.a('function')
+    bsv.crypto.ECDSA.should.be.a('function')
+  })
+
+  it('exposes package.json and ./version, and they agree', function () {
+    var pkg = require(N + '/package.json')
+    var version = require(N + '/version')
+    pkg.name.should.equal(N)
+    version.should.equal(pkg.version)
+  })
+
+  it('resolves lib/* deep imports with and without the .js extension', function () {
+    var withExt = require(N + '/lib/crypto/ecdsa.js')
+    var noExt = require(N + '/lib/crypto/ecdsa')
+    withExt.should.be.a('function')
+    noExt.should.equal(withExt) // same module, one cache entry
+  })
+
+  it('serves the full browser bundle over a subpath (loaded in isolation)', function () {
+    // The bundle is a self-contained bsv; loading it in-process collides with the
+    // main require above ("multiple bsv instances"), so resolve+load it in a child.
+    var script = 'var m=require(' + JSON.stringify(N + '/bsv.min.js') + ');' +
+      'process.exit(m && m.PrivateKey ? 0 : 3)'
+    execFileSync(process.execPath, ['-e', script], { cwd: ROOT, stdio: 'pipe' })
+  })
+
+  it('routes the ESM `import` condition to index.mjs with default AND named exports', function () {
+    // Proves the dual-ESM entry end-to-end through the package specifier: the
+    // `import` condition resolves to index.mjs, which exposes real named bindings.
+    var script =
+      'import bsv, { PrivateKey, Transaction, crypto } from ' + JSON.stringify(N) + ';' +
+      'process.exit((bsv && bsv.PrivateKey && PrivateKey === bsv.PrivateKey && ' +
+      'typeof Transaction === "function" && typeof crypto.ECDSA === "function") ? 0 : 3)'
+    execFileSync(process.execPath, ['--input-type=module', '-e', script], { cwd: ROOT, stdio: 'pipe' })
+  })
+})

package/test/crypto/ecdsa.js

@@ -176,7 +176,7 @@ describe('ECDSA', function () {
     it('should create a valid signature', function () {
       ecdsa.randomK()
       ecdsa.sign()
-      ecdsa.verify().verified.should.equal(true)
+      ecdsa.verify().should.equal(true)
     })
 
     it('should should throw an error if hashbuf is not 32 bytes', function () {
@@ -253,11 +253,36 @@ describe('ECDSA', function () {
       it('should verify a signature that was just signed', function () {
         ecdsa.sig = Signature.fromString('3046022100e9915e6236695f093a4128ac2a956c' +
           '40ed971531de2f4f41ba05fac7e2bd019c02210094e6a4a769cc7f2a8ab3db696c7cd8d56bcdbfff860a8c81de4bc6a798b90827')
-        ecdsa.verify().verified.should.equal(true)
+        ecdsa.verify().should.equal(true)
+      })
+      // 7.0: verify() returns a strict boolean, not the (always-truthy) instance.
+      // A forged signature must be REJECTED by `if (ecdsa.verify())`, which was the
+      // whole point of removing the trap.
+      it('returns a strict boolean, not the instance (7.0 trap closed)', function () {
+        ecdsa.signRandomK()
+        var result = ecdsa.verify()
+        result.should.be.a('boolean')
+        result.should.equal(true)
+        // Forge the signature: the return value itself must be falsy.
+        var forged = new ECDSA()
+        forged.hashbuf = ecdsa.hashbuf
+        forged.pubkey = ecdsa.pubkey
+        forged.sig = new Signature(ecdsa.sig.r.add(new BN(1)), ecdsa.sig.s)
+        forged.verify().should.equal(false)
+        ;(!!forged.verify()).should.equal(false) // `if (forged.verify())` does NOT enter
+      })
+      it('verifyBool() remains a strict-boolean alias', function () {
+        ecdsa.signRandomK()
+        ecdsa.verifyBool().should.equal(true)
+        var forged = new ECDSA()
+        forged.hashbuf = ecdsa.hashbuf
+        forged.pubkey = ecdsa.pubkey
+        forged.sig = new Signature(ecdsa.sig.r.add(new BN(1)), ecdsa.sig.s)
+        forged.verifyBool().should.equal(false)
       })
       it('should verify this known good signature', function () {
         ecdsa.signRandomK()
-        ecdsa.verify().verified.should.equal(true)
+        ecdsa.verify().should.equal(true)
       })
       it('should verify a valid signature, and unverify an invalid signature', function () {
         var sig = ECDSA.sign(ecdsa.hashbuf, ecdsa.privkey)
@@ -295,7 +320,7 @@ describe('ECDSA', function () {
           ecdsa2.k.toString().should.equal(ecdsa.k.toString())
           ecdsa2.sig.toString().should.equal(ecdsa.sig.toString())
           ecdsa2.sig.i.should.equal(ecdsa.sig.i)
-          ecdsa.verify().verified.should.equal(true)
+          ecdsa.verify().should.equal(true)
         })
       })
 

package/test/security/fail_closed_contracts.js

@@ -49,15 +49,19 @@ describe('security: fail-closed verification contracts', function () {
       inst(wrongPub).verifyBool().should.equal(false)
     })
 
-    // Locks the documented trap: instance .verify() returns the INSTANCE (truthy), so it
-    // must never be read as a boolean. If this ever changes (e.g. a deliberate 7.0 that
-    // makes verify() return a bool), this test forces the change to be intentional.
-    it('instance .verify() returns the instance with the result on .verified (documented trap)', function () {
-      var e = new ECDSA(); e.hashbuf = hash; e.sig = goodSig; e.pubkey = wrongPub
-      var r = e.verify()
-      ;(typeof r).should.equal('object') // NOT a boolean — the trap
-      isStrictBool(r.verified).should.equal(true)
-      r.verified.should.equal(false) // forged → verified is false, even though `r` is truthy
+    // 7.0: the trap is CLOSED. Instance .verify() now returns a STRICT boolean, so
+    // `if (ecdsa.verify())` correctly rejects a forgery. (Pre-7.0 it returned the
+    // truthy instance with the real result on .verified; that idiom is gone.)
+    it('instance .verify() returns a strict boolean and fails closed on a forgery', function () {
+      var good = new ECDSA(); good.hashbuf = hash; good.sig = goodSig; good.pubkey = rightPub
+      isStrictBool(good.verify()).should.equal(true)
+      good.verify().should.equal(true)
+
+      var forged = new ECDSA(); forged.hashbuf = hash; forged.sig = goodSig; forged.pubkey = wrongPub
+      isStrictBool(forged.verify()).should.equal(true)
+      forged.verify().should.equal(false) // forged → false, and `if (forged.verify())` does NOT enter
+      // The result is still mirrored on .verified as a side effect.
+      forged.verified.should.equal(false)
     })
   })
 

package/test/smart_contract/preimage.js

@@ -0,0 +1,98 @@
+'use strict'
+
+/* global describe, it */
+
+// Coverage for SmartContract.Preimage (previously untested public class).
+// Focus: a too-short buffer must fail with an HONEST error (it used to trip
+// decodeCompactSize into a misleading "8-byte CompactSize" throw plus console
+// spam), while real BIP-143 preimages round-trip their fields.
+
+require('chai').should()
+var bsv = require('../..')
+var Preimage = bsv.SmartContract.Preimage
+
+describe('SmartContract.Preimage', function () {
+  describe('length guard (honest failure)', function () {
+    it('exposes the derived BIP-143 structural minimum (157)', function () {
+      Preimage.LEFT_FIXED_LENGTH.should.equal(104)
+      Preimage.RIGHT_FIXED_LENGTH.should.equal(52)
+      Preimage.MIN_PREIMAGE_LENGTH.should.equal(157)
+    })
+
+    it('throws a clear "too short" error at construction, not a CompactSize error', function () {
+      ;[0, 50, 103, 156].forEach(function (n) {
+        (function () { return new Preimage(Buffer.alloc(n)) })
+          .should.throw(/Preimage too short/)
+      })
+    })
+
+    it('does NOT mention CompactSize when the real problem is length', function () {
+      var threw
+      try { threw = new Preimage(Buffer.alloc(50)) } catch (e) { threw = e.message }
+      threw.should.match(/Preimage too short/)
+      threw.should.not.match(/CompactSize/)
+    })
+
+    it('validate() reports the length gracefully for a deferred preimage (no throw)', function () {
+      var p = new Preimage(Buffer.alloc(50), { deferExtraction: true })
+      var res = p.validate()
+      res.valid.should.equal(false)
+      res.errors.join(' ').should.match(/Preimage too short: 50 bytes/)
+    })
+
+    it('accepts a buffer exactly at the minimum length', function () {
+      // 157 bytes: 104 left + 1-byte scriptLen varint (0x00 => empty script) + 52 right.
+      var buf = Buffer.alloc(Preimage.MIN_PREIMAGE_LENGTH)
+      ;(function () { return new Preimage(buf) }).should.not.throw()
+    })
+  })
+
+  describe('decodeCompactSize (honest failure)', function () {
+    it('throws when reading past the end of the buffer', function () {
+      (function () { Preimage.decodeCompactSize(Buffer.alloc(4), 4) })
+        .should.throw(/past end of preimage buffer/)
+    })
+
+    it('rejects the 8-byte (0xff) length prefix as invalid for a script length', function () {
+      var buf = Buffer.concat([Buffer.from([0xff]), Buffer.alloc(8)])
+      ;(function () { Preimage.decodeCompactSize(buf, 0) })
+        .should.throw(/8-byte length prefix/)
+    })
+
+    it('rejects a truncated 2-byte CompactSize', function () {
+      (function () { Preimage.decodeCompactSize(Buffer.from([0xfd, 0x01]), 0) })
+        .should.throw(/Truncated 2-byte CompactSize/)
+    })
+
+    it('decodes a plain 1-byte length', function () {
+      var r = Preimage.decodeCompactSize(Buffer.from([0x19]), 0)
+      r.value.should.equal(0x19)
+      r.bytes.should.equal(1)
+      r.nextOffset.should.equal(1)
+    })
+  })
+
+  describe('real preimage round-trip', function () {
+    it('constructs, extracts fields, and validates a genuine preimage', function () {
+      var ex = Preimage.createExample(0x41) // SIGHASH_ALL | FORKID
+      ex.preimage.length.should.be.above(Preimage.MIN_PREIMAGE_LENGTH)
+
+      // Fixed-width fields come back at their BIP-143 sizes.
+      ex.getField('version').length.should.equal(4)
+      ex.getField('hashPrevouts').length.should.equal(32)
+      ex.getField('hashOutputs').length.should.equal(32)
+      ex.getField('sighash').length.should.equal(4)
+
+      var v = ex.validate()
+      v.valid.should.equal(true)
+      v.errors.length.should.equal(0)
+    })
+
+    it('reports SIGHASH flag info for the extracted sighash', function () {
+      var ex = Preimage.createExample(0x41)
+      var info = ex.getSighashInfo()
+      info.flagName.should.match(/ALL/)
+      info.flagName.should.match(/FORKID/)
+    })
+  })
+})

package/version.js

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