@smartledger/bsv 6.2.2 → 7.0.1

package/lib/mnemonic/mnemonic.js

@@ -89,8 +89,38 @@ var Mnemonic = function (data, wordlist) {
   })
 }
 
-Mnemonic.fromRandom = function (wordlist = Mnemonic.Words.ENGLISH) {
-  return new Mnemonic(wordlist)
+/**
+ * Generate a random Mnemonic with the given wordlist and entropy.
+ *
+ * A number in either argument position is the entropy in bits (128, 160, 192,
+ * 224 or 256 — higher = more words); an array is the wordlist. So every form
+ * below works AND honours the requested strength:
+ *   fromRandom()              -> ENGLISH, 128-bit (12 words)
+ *   fromRandom(wordlist)      -> wordlist, 128-bit
+ *   fromRandom(wordlist, 256) -> wordlist, 256-bit (24 words)
+ *   fromRandom(256)           -> ENGLISH, 256-bit
+ *   fromRandom(256, wordlist) -> wordlist, 256-bit
+ *
+ * Prior to 7.0.1 the second argument was silently dropped, so the documented
+ * `fromRandom(wordlist, 256)` form returned a weaker 12-word (128-bit) phrase
+ * with no error — a security foot-gun this fix closes. Invalid entropy still
+ * throws (must be a multiple of 32 and >= 128).
+ *
+ * @param {Array<string>|number} [wordlist] - wordlist, or entropy bits
+ * @param {number|Array<string>} [ent] - entropy bits, or wordlist
+ * @returns {Mnemonic}
+ */
+Mnemonic.fromRandom = function (wordlist, ent) {
+  // A number in the first position is the entropy; normalise so `ent` holds it
+  // and `wordlist` holds the array (either argument order is accepted).
+  if (_.isNumber(wordlist)) {
+    var swapped = ent
+    ent = wordlist
+    wordlist = swapped
+  }
+  wordlist = wordlist || Mnemonic.Words.ENGLISH
+  ent = ent || 128
+  return new Mnemonic(ent, wordlist)
 }
 
 Mnemonic.fromString = function (mnemonic, wordlist = Mnemonic.Words.ENGLISH) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartledger/bsv",
-  "version": "6.2.2",
+  "version": "7.0.1",
   "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",

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/mnemonic/mnemonic.js

@@ -27,6 +27,38 @@ describe('Mnemonic', function () {
       Mnemonic.Words.SPANISH.includes(mnemonic3.toString().split(' ')[1]).should.equal(true)
       Mnemonic.Words.SPANISH.includes(mnemonic3.toString().split(' ')[2]).should.equal(true)
     })
+
+    // Regression: the second argument used to be silently dropped, so the
+    // documented fromRandom(wordlist, 256) form returned a WEAK 12-word phrase.
+    function wordCount (m) { return m.toString().split(' ').length }
+
+    it('defaults to a 12-word (128-bit) phrase', function () {
+      wordCount(Mnemonic.fromRandom()).should.equal(12)
+      wordCount(Mnemonic.fromRandom(Mnemonic.Words.ENGLISH)).should.equal(12)
+    })
+
+    it('honours entropy passed as the second argument (wordlist, ent)', function () {
+      // The previously-broken documented form: must now yield 24 words.
+      wordCount(Mnemonic.fromRandom(Mnemonic.Words.ENGLISH, 256)).should.equal(24)
+      wordCount(Mnemonic.fromRandom(Mnemonic.Words.ENGLISH, 192)).should.equal(18)
+      wordCount(Mnemonic.fromRandom(Mnemonic.Words.ENGLISH, 160)).should.equal(15)
+    })
+
+    it('honours entropy passed as the first argument (ent) or (ent, wordlist)', function () {
+      wordCount(Mnemonic.fromRandom(256)).should.equal(24)
+      var es = Mnemonic.fromRandom(256, Mnemonic.Words.SPANISH)
+      wordCount(es).should.equal(24)
+      Mnemonic.Words.SPANISH.includes(es.toString().split(' ')[0]).should.equal(true)
+    })
+
+    it('throws on invalid entropy instead of silently degrading', function () {
+      ;(function () { Mnemonic.fromRandom(Mnemonic.Words.ENGLISH, 200) }).should.throw(/ENT/)
+      ;(function () { Mnemonic.fromRandom(64) }).should.throw(/ENT/)
+    })
+
+    it('reports a meaningful arity (2), not 0', function () {
+      Mnemonic.fromRandom.length.should.equal(2)
+    })
   })
 
   describe('# Mnemonic', function () {

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/version.js

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