@smartledger/bsv 8.3.1 → 9.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@smartledger/bsv",
-  "version": "8.3.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.",
+  "version": "9.1.0",
+  "description": "Bitcoin SV library with an interpreter-verified script engine: OP_PUSH_TX covenants, BIP-143 preimage tooling, and consensus flags that match what miners actually enforce. Also ships DID:web / W3C VC-JWT credentials and the Legal Token Protocol.",
   "author": "SmartLedger Technology <hello@smartledger.technology> (https://smartledger.technology)",
   "homepage": "https://github.com/codenlighten/smartledger-bsv#readme",
   "bugs": {
@@ -98,10 +98,12 @@
     "test:browser": "echo 'Open tests/standalone-modules-test.html in browser for comprehensive testing'",
     "test:bundle": "echo 'Open tests/bundle-completeness-test.html in browser to verify bundle completeness'",
     "preimage:extract": "node examples/preimage/extract_preimage_bidirectional.js",
-    "prepublishOnly": "npm run build-all && npm run check:readme",
+    "prepublishOnly": "npm run build-all && npm run check:readme && npm run check:api",
     "sync-cdn": "node scripts/sync-cdn-urls.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"
+    "test:browser:ci": "node tests/browser-smoke-runner.js",
+    "api:snapshot": "node scripts/api-surface.js",
+    "check:api": "mocha test/api_surface.js --no-config"
   },
   "unpkg": "bsv.min.js",
   "jsdelivr": "bsv.min.js",
@@ -110,8 +112,6 @@
     "index.js",
     "index.mjs",
     "version.js",
-    "test/",
-    ".mocharc.json",
     "lib/",
     "utilities/*.js",
     "utilities/README.md",
@@ -142,88 +142,25 @@
     "LICENSE",
     "README.md",
     "SECURITY.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "STABILITY.md"
   ],
   "keywords": [
-    "bitcoin",
     "bitcoin-sv",
     "bsv",
-    "legal-token-protocol",
-    "ltp",
-    "legal-tokens",
-    "primitives-only",
-    "legal-compliance",
-    "property-rights",
-    "obligations",
-    "attestations",
-    "gdaf",
-    "global-digital-attestation",
-    "w3c-credentials",
-    "verifiable-credentials",
-    "decentralized-identity",
-    "shamir-secret-sharing",
-    "threshold-cryptography",
-    "cryptocurrency",
-    "blockchain",
-    "smart-contracts",
-    "defi",
+    "bitcoin-script",
+    "opcode",
     "covenant",
-    "covenants",
-    "script-debugger",
-    "debug-tools",
-    "modular-loading",
-    "standalone-modules",
-    "elliptic-curve-fix",
-    "smartledger",
-    "transaction",
-    "address",
-    "signature",
-    "wallet",
-    "hd-wallet",
-    "mnemonic",
-    "ecies",
-    "encryption",
-    "message-signing",
-    "pushtx",
-    "pels",
+    "op-push-tx",
     "bip143",
     "preimage",
-    "secret-splitting",
-    "did-resolution",
-    "selective-disclosure",
-    "blockchain-anchoring",
-    "attestation-framework",
-    "nchain",
-    "custom-scripts",
-    "multisig",
-    "timelock",
-    "conditional-scripts",
-    "utxo-management",
-    "ultra-low-fees",
-    "javascript-to-script",
-    "opcode-mapping",
-    "covenant-builder",
-    "script-simulation",
-    "bitcoin-script",
-    "asm-generation",
-    "advanced-features",
-    "script-development",
-    "blockchain-simulator",
-    "miner-simulator",
-    "testing-tools",
-    "development-framework",
-    "browser-compatible",
-    "nodejs-compatible",
-    "webpack-ready",
-    "cdn-ready",
-    "typescript-definitions",
-    "drop-in-replacement",
-    "performance-optimized",
-    "bip21",
-    "bip32",
-    "bip37",
-    "bip69",
-    "bip70"
+    "smart-contracts",
+    "script-interpreter",
+    "transaction",
+    "utxo",
+    "verifiable-credentials",
+    "did-web",
+    "legal-token-protocol"
   ],
   "repository": {
     "type": "git",
@@ -246,7 +183,7 @@
     "chai": "6.2.2",
     "create-hash": "^1.2.0",
     "create-hmac": "^1.1.7",
-    "esbuild": "^0.28.1",
+    "esbuild": "^0.28.2",
     "events": "^3.3.0",
     "jose": "^5.10.0",
     "mocha": "^11.8.0",

package/tools/gen-brc220-batch-vector.js

@@ -0,0 +1,205 @@
+'use strict'
+
+/**
+ * Generate the BRC-220 batch-mode golden vector.
+ *
+ *   node tools/gen-brc220-batch-vector.js > test/data/brc220-batch-vector.json
+ *
+ * WHY THIS FILE EXISTS
+ *
+ * BRC-220 §On-chain record specifies the batch tree as RFC 6962 and writes
+ * `leaf = SHA256(0x00 ‖ d)`, but never binds `d` to a value. Two readings are available —
+ * `d = proofHash` and `d = canonicalBytes` — both second-preimage resistant, producing
+ * DIFFERENT roots. Implementations that choose differently do not interoperate, and the
+ * failure is silent: the fold simply does not reach the root.
+ *
+ * Prose cannot reliably close that. One golden vector can. See
+ * docs/BRC220_BATCH_LEAF_AMENDMENT.md.
+ *
+ * WHAT THIS VECTOR IS, AND IS NOT
+ *
+ * It is a CONFORMANCE TARGET, generated by this implementation. It is NOT external
+ * validation, and nothing here should be read as proving our tree is the "correct" one.
+ * What makes it useful is that the tree underneath it IS externally anchored: the RFC 6962
+ * construction is checked against the published Certificate Transparency roots in
+ * test/notaryhash/merkle.js. Given a tree that provably matches RFC 6962, this vector
+ * fixes the one thing the spec leaves open — what goes in the leaf.
+ *
+ * EVERY VALUE IS DERIVED, NOT CHOSEN
+ *
+ * Keys and payloads come from labelled SHA-256 preimages, and timestamps are fixed
+ * constants, so the file regenerates byte-identically and a third party can reproduce
+ * every intermediate with any library. The vector records those intermediates —
+ * canonicalBytes, proofHash, leaf hash — precisely so a reader can check each step
+ * independently instead of trusting the final root.
+ *
+ * Do not regenerate this to make a failing test pass. A diff is either a real change in
+ * the encoding or a bug.
+ */
+
+var Hash = require('../lib/crypto/hash')
+var BN = require('../lib/crypto/bn')
+var PrivateKey = require('../lib/privatekey')
+var ECDSA = require('../lib/crypto/ecdsa')
+var Point = require('../lib/crypto/point')
+var Encoding = require('../lib/notaryhash/encoding')
+var Merkle = require('../lib/notaryhash/merkle')
+
+// Five proofs. Five rather than four on purpose: RFC 6962 splits at the largest power of
+// two BELOW n, so n=5 splits 4/1 where a midpoint split would give 2/3 and a different
+// root. It also makes the leaf count odd, exercising the rule that the last leaf is never
+// duplicated. Those are the two places an implementation of this tree goes wrong, so the
+// vector is worth more at n=5 than at any power of two.
+var LEAF_COUNT = 5
+
+// Fixed, so the file is reproducible. ISO-8601 Z, one day apart.
+var CREATED_AT = [
+  '2026-01-01T00:00:00.000Z',
+  '2026-01-02T00:00:00.000Z',
+  '2026-01-03T00:00:00.000Z',
+  '2026-01-04T00:00:00.000Z',
+  '2026-01-05T00:00:00.000Z'
+]
+
+var ALGORITHM = 'ECDSA-secp256k1'
+var HASH_ALGORITHM = 'SHA-256'
+
+// Labelled preimages, so anyone can recompute the inputs themselves.
+function derive (label, i) {
+  return Hash.sha256(Buffer.from('BRC-220/batch-vector/' + label + '/' + i, 'utf8'))
+}
+
+// Raw 64-byte r‖s, low-S, as `encoding: "raw"` requires. Not DER.
+function signRaw (payloadHash, privkey) {
+  // set() rather than assigning fields directly: it derives `pubkey` from `privkey`,
+  // which sign() requires. RFC 6979 makes this deterministic, so the vector reproduces.
+  //
+  // NO `endian` option. BRC-220 signs the 32-byte payloadHash directly, so the digest IS
+  // the scalar, big-endian. The first version of this file passed `endian: 'little'`,
+  // matching the verifier bug fixed in 8.3.1, and produced a "golden" vector whose five
+  // signatures no conformant implementation could verify — 0/5 under @noble/curves. A
+  // reference vector that is wrong is worse than no vector, because it is published as
+  // the thing to match.
+  //
+  // It survived review because the generator and the checker used the same signer, so
+  // both were wrong in the same direction. test/notaryhash/batch_vector.js now verifies
+  // every signature under @noble/curves as well, which is the assertion that fails if
+  // this line is ever changed back.
+  var ecdsa = ECDSA().set({ hashbuf: payloadHash, privkey: privkey })
+  ecdsa.sign()
+  var sig = ecdsa.sig
+
+  var halfOrder = Point.getN().div(new BN(2))
+  if (sig.s.gt(halfOrder)) {
+    throw new Error('signature is not low-S; the signer must produce low-S, not normalise')
+  }
+
+  var r = sig.r.toBuffer({ size: 32 })
+  var s = sig.s.toBuffer({ size: 32 })
+  return Buffer.concat([r, s])
+}
+
+function u32beHex (n) {
+  var b = Buffer.alloc(4)
+  b.writeUInt32BE(n, 0)
+  return b.toString('hex')
+}
+
+var proofs = []
+for (var i = 0; i < LEAF_COUNT; i++) {
+  // fromObject rather than new PrivateKey(bn): the bare-BN form leaves `compressed`
+  // unset, and public-key derivation then fails.
+  var privkey = PrivateKey.fromObject({
+    bn: BN.fromBuffer(derive('key', i)),
+    compressed: true,
+    network: 'livenet'
+  })
+  var payloadHash = derive('payload', i)
+  var publicKey = privkey.publicKey.toBuffer() // 33-byte compressed SEC1
+  var signature = signRaw(payloadHash, privkey)
+  var createdAtUnix = Encoding.toUnixSeconds(CREATED_AT[i])
+
+  var fields = {
+    algorithm: ALGORITHM,
+    hashAlgorithm: HASH_ALGORITHM,
+    payloadHash: payloadHash,
+    publicKey: publicKey,
+    signature: signature,
+    createdAtUnix: createdAtUnix
+  }
+
+  var canonicalBytes = Encoding.canonicalBytes(fields)
+  var proofHash = Encoding.proofHash(fields)
+
+  proofs.push({
+    leafIndex: i,
+    keyPreimage: 'BRC-220/batch-vector/key/' + i,
+    payloadPreimage: 'BRC-220/batch-vector/payload/' + i,
+    algorithm: ALGORITHM,
+    hashAlgorithm: HASH_ALGORITHM,
+    encoding: 'raw',
+    payloadHash: payloadHash.toString('hex'),
+    publicKey: publicKey.toString('hex'),
+    signature: signature.toString('hex'),
+    createdAt: CREATED_AT[i],
+    createdAtUnix: createdAtUnix,
+    canonicalBytes: canonicalBytes.toString('hex'),
+    proofHash: proofHash.toString('hex'),
+    // The value the spec leaves open, spelled out at both readings so the divergence is
+    // visible in the published artifact rather than only in prose.
+    leafHash: Merkle.hashLeaf(proofHash).toString('hex'),
+    leafHashUnderRejectedReading: Merkle.hashLeaf(canonicalBytes).toString('hex')
+  })
+}
+
+var leaves = proofs.map(function (p) { return Buffer.from(p.proofHash, 'hex') })
+var root = Merkle.root(leaves)
+
+proofs.forEach(function (p, idx) {
+  p.path = Merkle.path(leaves, idx).map(function (n) { return n.toString('hex') })
+})
+
+var vector = {
+  _comment: [
+    'BRC-220 batch-mode golden vector. Generated by tools/gen-brc220-batch-vector.js;',
+    'do not hand-edit. Every value is derived from the labelled preimages recorded on each',
+    'proof, so the file is reproducible from scratch in any language.',
+    '',
+    'THE POINT OF THIS FILE: BRC-220 writes the batch leaf as SHA256(0x00 || d) and never',
+    'says what d is. This vector fixes d = proofHash. The `rejectedReading` block records',
+    'what the same five proofs produce under d = canonicalBytes — equally sound',
+    'cryptographically, a different root, and therefore not interoperable. An',
+    'implementation matching `rejectedReading.root` has made the other choice, which is',
+    'exactly the confusion this vector exists to make visible.',
+    '',
+    'This is a conformance target produced by @smartledger/bsv, not external validation.',
+    'The tree beneath it is externally anchored: the RFC 6962 construction is verified',
+    'against the published Certificate Transparency roots in test/notaryhash/merkle.js.',
+    '',
+    'n = 5 deliberately: RFC 6962 splits at the largest power of two BELOW n, so this',
+    'splits 4/1 (a midpoint split would give 2/3 and a different root), and the odd count',
+    'exercises the rule that the last leaf is never duplicated.'
+  ].join(' ').replace(/\s+/g, ' ').trim(),
+  spec: 'BRC-220',
+  tree: 'RFC 6962',
+  leafDatum: 'proofHash',
+  leafRule: 'leaf = SHA-256(0x00 || proofHash); node = SHA-256(0x01 || left || right)',
+  leafCount: LEAF_COUNT,
+  root: root.toString('hex'),
+  onChainRecordTail: {
+    _comment: 'The batch record is "NOTARYHASH" | u8(1) | u8(2) | merkleRoot(32) | u32be(leafCount).',
+    merkleRoot: root.toString('hex'),
+    leafCountU32be: u32beHex(LEAF_COUNT)
+  },
+  rejectedReading: {
+    _comment: 'What d = canonicalBytes yields over the SAME five proofs. Recorded so the ' +
+      'divergence is checkable, not to endorse it.',
+    leafDatum: 'canonicalBytes',
+    root: Merkle.root(proofs.map(function (p) {
+      return Buffer.from(p.canonicalBytes, 'hex')
+    })).toString('hex')
+  },
+  proofs: proofs
+}
+
+process.stdout.write(JSON.stringify(vector, null, 2) + '\n')

package/version.js

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

package/.mocharc.json

@@ -1,5 +0,0 @@
-{
-  "recursive": true,
-  "timeout": 8000,
-  "spec": "test/**/*.js"
-}