@smartledger/bsv 9.13.0 → 9.15.0

package/lib/spv/merkleproof.js

@@ -99,6 +99,50 @@ function targetLimit (powLimit) {
   return target
 }
 
+/**
+ * A floor given in DIFFICULTY as the work it means: difficulty x 4,295,032,833, exactly.
+ *
+ * `minWork` counts hashes, and difficulty is the unit people actually quote — a real BSV
+ * header is "difficulty 2.6e10", not "1.1e20 hashes". Reading one as the other sets a floor
+ * 4.3 billion times too low and fails OPEN, which is why the unit is in the name. The
+ * multiplication is done on integers so a fractional difficulty keeps its digits instead of
+ * drifting through a float.
+ */
+function workFromDifficulty (difficulty) {
+  var text = typeof difficulty === 'number' ? numberToDecimal(difficulty) : String(difficulty)
+  // `1e19` is how a floor this size is written, by hand and by JSON, so both a Number and a
+  // string may arrive in exponent form. Expanded by moving the point, never through a float.
+  if (/^[0-9]+(\.[0-9]+)?[eE][+]?[0-9]+$/.test(text)) text = expandExponent(text)
+  if (!/^[0-9]+(\.[0-9]+)?$/.test(text)) {
+    throw new Error('minDifficulty must be a non-negative decimal number, not ' +
+      JSON.stringify(difficulty))
+  }
+  var parts = text.split('.')
+  var frac = parts[1] || ''
+  var scaled = new BN(parts[0] + frac, 10).mul(workFromTarget(targetFromBits(POW_LIMIT_BITS)))
+  return frac.length ? scaled.div(new BN(10).pow(new BN(frac.length))) : scaled
+}
+
+/** `2.557e10` as `25570000000`, by moving the decimal point, with no float in the path. */
+function expandExponent (text) {
+  var halves = text.split(/[eE]/)
+  var exp = parseInt(halves[1].replace('+', ''), 10)
+  var digits = halves[0].split('.')
+  var intPart = digits[0]
+  var frac = digits[1] || ''
+  if (exp >= frac.length) return intPart + frac + new Array(exp - frac.length + 1).join('0')
+  return intPart + frac.slice(0, exp) + '.' + frac.slice(exp)
+}
+
+/** A Number as plain decimal digits, so 2.6e10 does not reach the parser as "2.6e+10". */
+function numberToDecimal (n) {
+  if (!Number.isFinite(n) || n < 0) {
+    throw new Error('minDifficulty must be a non-negative finite number, not ' + String(n))
+  }
+  if (!/e/i.test(String(n))) return String(n)
+  return n.toLocaleString('en-US', { useGrouping: false, maximumFractionDigits: 20 })
+}
+
 /**
  * `minWork` as a BN, refusing anything bn.js would read loosely. It parses `1e21` as
  * 23521, `'4.3e9'` as 4 and `'abc'` as 1122, so a floor set from a Number near the
@@ -216,8 +260,10 @@ function verifyMerkleProof (proof) {
  *   header:   a bsv.BlockHeader, an 80-byte Buffer, or 80-byte hex.
  *   powLimit: the easiest target a header may declare, as compact bits (number or hex
  *             string) or a BN target. Default 0x1d00ffff. Regtest needs 0x207fffff.
- *   minWork:  minimum work the header must represent (number, decimal string or BN);
- *             2^256 / (target + 1). Difficulty 1 is about 4.295e9.
+ *   minWork:  minimum work the header must represent, in HASHES (number, decimal string or
+ *             BN): 2^256 / (target + 1). Difficulty 1 is about 4.295e9.
+ *   minDifficulty: the same floor in DIFFICULTY, which is the unit difficulty is quoted in
+ *             (a real BSV header is about 2.6e10). Exactly one of the two, or neither.
  * With `requirePow: false` the work checks are not performed at all: `targetAllowed` and
  * `workSufficient` report true because nothing objected, and `powLimit`/`minWork` are not
  * even read.
@@ -240,8 +286,20 @@ function verifyTxInclusion (params) {
   // when the work checks are off.
   var targetAllowed = target !== null &&
     (!requirePow || target.cmp(targetLimit(params.powLimit)) <= 0)
-  var workSufficient = !requirePow || params.minWork === undefined || params.minWork === null ||
-    work.cmp(minWorkBN(params.minWork)) >= 0
+  var floor = null
+  if (requirePow) {
+    // One floor, named for its unit. Accepting both would leave the caller guessing which
+    // one bit, and the two are 4.3e9 apart.
+    if (params.minWork !== undefined && params.minWork !== null &&
+      params.minDifficulty !== undefined && params.minDifficulty !== null) {
+      throw new Error('pass minWork (hashes) or minDifficulty (difficulty), not both')
+    }
+    if (params.minWork !== undefined && params.minWork !== null) floor = minWorkBN(params.minWork)
+    else if (params.minDifficulty !== undefined && params.minDifficulty !== null) {
+      floor = workFromDifficulty(params.minDifficulty)
+    }
+  }
+  var workSufficient = floor === null || work.cmp(floor) >= 0
 
   return {
     valid: rootMatches && (!requirePow || (powValid && targetAllowed && workSufficient)),
@@ -262,6 +320,7 @@ module.exports = {
   targetFromBits: targetFromBits,
   targetLimit: targetLimit,
   workFromTarget: workFromTarget,
+  workFromDifficulty: workFromDifficulty,
   headerSnapshot: headerSnapshot,
   merkleRootFromBranch: merkleRootFromBranch,
   verifyMerkleProof: verifyMerkleProof,

package/package.json

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

package/tools/sv-vector-harness.js

@@ -184,6 +184,17 @@ function classifyFlags (flagStr) {
  * only the spending transaction carries the version under test.
  */
 function evaluate (row, flags) {
+  // DoTest's one flag adjustment, which the rows themselves do not state:
+  //
+  //   if(flags & SCRIPT_VERIFY_CLEANSTACK) flags |= SCRIPT_VERIFY_P2SH;
+  //
+  // Without it a row naming CLEANSTACK alone is verified under a flag set the node refuses
+  // outright, so it fails for the wrong reason and the row silently stops testing clean
+  // stacks at all.
+  if ((flags & Interpreter.SCRIPT_VERIFY_CLEANSTACK) !== 0) {
+    flags |= Interpreter.SCRIPT_VERIFY_P2SH
+  }
+
   const scriptSig = fromBitcoindString(row.scriptSig)
   const scriptPubKey = fromBitcoindString(row.scriptPubKey)
 

package/version.js

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