@smartledger/bsv 7.13.0 → 8.0.0

package/test/script/chronicle.js

@@ -1,6 +1,6 @@
 'use strict'
 
-/* global describe, it */
+/* global describe, it, beforeEach, afterEach */
 
 // The BSV Chronicle script surface: OP_2MUL/OP_2DIV restored, OP_VER/OP_VERIF/
 // OP_VERNOTIF given meaning, and SIGHASH_CHRONICLE selecting the Original
@@ -35,7 +35,12 @@ function run (build, opts) {
   return {
     verified: verified,
     errstr: interp.errstr || '',
-    stack: (interp.stack || []).map(function (b) { return BN.fromScriptNumBuffer(b).toString() }),
+    // Read with the era's width, not BN's four-byte default: post-Genesis
+    // results are routinely wider than that, and a default-width read throws
+    // on them rather than reporting the value.
+    stack: (interp.stack || []).map(function (b) {
+      return BN.fromScriptNumBuffer(b, false, Math.max(b.length, 4)).toString()
+    }),
     // The raw bytes as well: several Chronicle behaviours are about WIDTH, not
     // value, and a script-number reading collapses that distinction.
     raw: (interp.stack || []).map(function (b) { return Buffer.from(b) })
@@ -60,12 +65,25 @@ describe('Chronicle script surface', function () {
     // — and Interpreter.DEFAULT_FLAGS does not exist, so it evaluated `undefined & n`,
     // which is 0 for every n. A tautology, written by me, in the same change that added
     // the flag. What it MEANT to assert is that verify() enables nothing on its own.
-    it('is not enabled unless the caller asks: verify() defaults to no flags', function () {
-      // Deliberately NOT via run(): that helper defaults to CHRONICLE, so it would
+    // The intent inverted in 8.0.0. It used to assert that verify() enables nothing on
+    // its own, which was true and was the bug: a BSV library whose default described
+    // Bitcoin in 2015 accepted scripts the network rejects. The default is now current
+    // mainnet, so the assertion is that Chronicle IS on without being asked for.
+    it('is enabled by default, because mainnet has it', function () {
+      // Deliberately NOT via run(): that helper passes CHRONICLE explicitly, so it would
       // measure the helper rather than the library. Omit the argument entirely.
       var script = new Script().add(Opcode.OP_VER)
       var interp = new Interpreter()
-      var verified = interp.verify(new Script(), script, new bsv.Transaction(), 0)
+      interp.verify(new Script(), script, new bsv.Transaction(), 0)
+      // OP_VER is meaningful under Chronicle; BAD_OPCODE would mean it was not enabled.
+      ;(interp.errstr || '').should.not.match(/BAD_OPCODE/)
+      ;(Interpreter.currentConsensusFlags() & CHRONICLE).should.equal(CHRONICLE)
+    })
+
+    it('can still be turned off for a pre-activation UTXO', function () {
+      var script = new Script().add(Opcode.OP_VER)
+      var interp = new Interpreter()
+      var verified = interp.verify(new Script(), script, new bsv.Transaction(), 0, 0)
       verified.should.equal(false)
       interp.errstr.should.match(/BAD_OPCODE/)
     })
@@ -151,7 +169,7 @@ describe('Chronicle script surface', function () {
   })
 
   describe('OP_VERIF / OP_VERNOTIF', function () {
-    it('without the flag, errors only in an EXECUTED branch', function () {
+    it('after Genesis, 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:
@@ -161,13 +179,22 @@ describe('Chronicle script surface', function () {
       //     else return SCRIPT_ERR_BAD_OPCODE;
       //   }
       //
-      // Asserting BAD_OPCODE here made this library reject scripts the network
-      // accepts.
+      // Note the condition includes utxo_after_genesis, so the era has to be
+      // stated. Run without it, this is a pre-Genesis output, and then Core's
+      // rule is also BSV's: illegal everywhere, which the node's own corpus
+      // confirms for exactly these scripts.
       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 })
+      }, { flags: Interpreter.SCRIPT_UTXO_AFTER_GENESIS })
       unexecuted.verified.should.equal(true)
 
+      // Pre-Genesis the same script is invalid, unexecuted branch or not.
+      var preGenesis = 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 })
+      preGenesis.verified.should.equal(false)
+      preGenesis.errstr.should.match(/BAD_OPCODE/)
+
       var executed = run(function (s) {
         s.add(Opcode.OP_1).add(Opcode.OP_VERIF).add(Opcode.OP_ENDIF)
       }, { flags: 0 })
@@ -328,11 +355,25 @@ describe('Chronicle script surface', function () {
     it('left shift overflows rather than growing without bound', function () {
       // CScriptNum bounds this BEFORE shifting (current_size + shift_bytes >
       // max_length), so a huge count cannot allocate a huge number first.
-      var r = shift(5, 1000, Opcode.OP_LSHIFTNUM)
+      //
+      // The count has to exceed the real bound to test that. Chronicle's
+      // max_length is 32,000,000 bytes, so 1000 bits — 125 bytes — is a
+      // perfectly valid post-Chronicle number and overflows only against the
+      // pre-Genesis four. This used to pass because the bound was four
+      // whatever the era.
+      var r = shift(5, 8 * Interpreter.MAX_SCRIPT_NUM_LENGTH_AFTER_CHRONICLE,
+        Opcode.OP_LSHIFTNUM)
       r.verified.should.equal(false)
       r.errstr.should.match(/OVERFLOW/)
     })
 
+    it('leaves a shift inside the bound alone', function () {
+      // The counterpart: 1000 bits is valid post-Chronicle, and was not before.
+      var r = shift(5, 1000, Opcode.OP_LSHIFTNUM)
+      r.verified.should.equal(true)
+      r.raw[0].length.should.equal(126)
+    })
+
     it('fails on a short stack', function () {
       var r = run(function (s) { s.add(new BN(1).toScriptNumBuffer()).add(Opcode.OP_LSHIFTNUM) })
       r.verified.should.equal(false)
@@ -370,29 +411,133 @@ describe('Chronicle script surface', function () {
     it('OVERRIDES FORKID — otherwise the bit could never select OTDA in practice', function () {
       // FORKID is set on essentially every BSV signature written since 2018, so a
       // CHRONICLE bit that only applied when FORKID was absent would mean nothing.
+      //
+      // Stated against the algorithm rather than against the flag: the node
+      // routes on the bit alone, so with the bit set, enabling forkid makes no
+      // difference and the result is the original digest either way.
       var f = fixture()
       var type = Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID | Signature.SIGHASH_CHRONICLE
-      var chronicle = bsv.Transaction.sighash.sighash(
-        f.tx, type, 0, f.sub, f.amt,
-        Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID | CHRONICLE
+      var withForkId = bsv.Transaction.sighash.sighash(
+        f.tx, type, 0, f.sub, f.amt, Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
       )
+      var forcedOtda = bsv.Transaction.sighash.sighash(f.tx, type, 0, f.sub, f.amt, 0)
+      withForkId.toString('hex').should.equal(forcedOtda.toString('hex'))
+
+      // And it does override: without the bit the same transaction takes BIP-143.
+      var withoutBit = Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID
       var bip143 = bsv.Transaction.sighash.sighash(
-        f.tx, type, 0, f.sub, f.amt, Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
+        f.tx, withoutBit, 0, f.sub, f.amt, Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
       )
-      chronicle.toString('hex').should.not.equal(bip143.toString('hex'))
+      bip143.toString('hex').should.not.equal(withForkId.toString('hex'))
     })
 
-    it('is IGNORED without the flag, so existing BIP-143 signatures are unaffected', function () {
+    it('cannot be used outside Chronicle, so old BIP-143 signatures are unaffected', function () {
       // Before the upgrade the 0x20 bit means nothing, so signatures already exist
-      // whose type byte happens to set it. Honouring it unconditionally would
-      // reinterpret those as OTDA — a silent validity change on historic data.
-      var f = fixture()
-      var withBit = Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID | Signature.SIGHASH_CHRONICLE
-      var viaForkId = bsv.Transaction.sighash.sighash(
-        f.tx, withBit, 0, f.sub, f.amt, Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
-      )
-      var forcedOtda = bsv.Transaction.sighash.sighash(f.tx, withBit, 0, f.sub, f.amt, 0)
-      viaForkId.toString('hex').should.not.equal(forcedOtda.toString('hex'))
+      // whose type byte happens to set it. Reinterpreting those as OTDA would be
+      // a silent validity change on historic data.
+      //
+      // The node prevents that in CheckSignatureEncoding rather than in the
+      // digest function: a signature carrying the bit outside Chronicle is
+      // REJECTED, not reinterpreted, so it never reaches a digest at all. That
+      // is what lets SignatureHash() route on the bit alone, and gating the
+      // digest instead made 260 of the node's 1000 vectors disagree.
+      var priv = new bsv.PrivateKey()
+      var hashbuf = bsv.crypto.Hash.sha256(Buffer.from('chronicle bit'))
+      var type = Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID | Signature.SIGHASH_CHRONICLE
+      var sig = bsv.crypto.ECDSA.sign(hashbuf, priv)
+      sig.nhashtype = type
+
+      var interp = new Interpreter()
+      interp.set({ flags: Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID | Interpreter.SCRIPT_VERIFY_STRICTENC })
+      interp.checkSignatureEncoding(sig.toTxFormat()).should.equal(false)
+      interp.errstr.should.equal('SCRIPT_ERR_ILLEGAL_CHRONICLE')
+
+      // With Chronicle in force it is allowed.
+      var ok = new Interpreter()
+      ok.set({
+        flags: Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
+          Interpreter.SCRIPT_VERIFY_STRICTENC | Interpreter.SCRIPT_CHRONICLE
+      })
+      ok.checkSignatureEncoding(sig.toTxFormat()).should.equal(true)
+    })
+  })
+
+  describe('mainnet consensus helpers', function () {
+    var BN2 = bsv.crypto.BN
+
+    // useMainnetConsensus() mutates process-wide statics, so the limits are saved
+    // and restored around every case here. Without this the raised caps leak into
+    // every later test in the run — 27 of them, when it was first written.
+    var savedLimits
+    beforeEach(function () { savedLimits = Interpreter.getLimits() })
+    afterEach(function () { Interpreter.setLimits(savedLimits) })
+
+    // Genesis reverted CLTV/CSV to OP_NOP2/OP_NOP3, and the node ignores their flags
+    // once the UTXO is post-Genesis:
+    //   if (!(flags & SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY) || utxo_after_genesis)
+    // Including them made mainnetFlags() reject scripts mainnet accepts.
+    it('mainnetFlags omits CLTV and CSV', function () {
+      var f = Interpreter.mainnetFlags()
+      ;(f & Interpreter.SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY).should.equal(0)
+      ;(f & Interpreter.SCRIPT_VERIFY_CHECKSEQUENCEVERIFY).should.equal(0)
+    })
+
+    it('mainnetFlags accepts a CLTV script, as mainnet does', function () {
+      var lock = new Script()
+        .add(new BN2(500000000).toScriptNumBuffer())
+        .add(Opcode.OP_CHECKLOCKTIMEVERIFY)
+        .add(Opcode.OP_DROP)
+        .add(Opcode.OP_1)
+      var tx = new bsv.Transaction()
+      tx.version = 2
+      var interp = new Interpreter()
+      interp.verify(new Script(), lock, tx, 0, Interpreter.mainnetFlags(), new BN2(0))
+        .should.equal(true)
+      interp.errstr.should.equal('')
+    })
+
+    it('mainnetFlags accepts a CSV script, as mainnet does', function () {
+      var lock = new Script()
+        .add(new BN2(1000).toScriptNumBuffer())
+        .add(Opcode.OP_CHECKSEQUENCEVERIFY)
+        .add(Opcode.OP_DROP)
+        .add(Opcode.OP_1)
+      var tx = new bsv.Transaction()
+      tx.version = 2
+      var interp = new Interpreter()
+      interp.verify(new Script(), lock, tx, 0, Interpreter.mainnetFlags(), new BN2(0))
+        .should.equal(true)
+    })
+
+    // The flags still exist for pre-Genesis emulation — that capability is retained,
+    // it is simply not what mainnet does.
+    it('the CLTV flag still enforces when a caller asks for it', function () {
+      var lock = new Script()
+        .add(new BN2(500000000).toScriptNumBuffer())
+        .add(Opcode.OP_CHECKLOCKTIMEVERIFY)
+        .add(Opcode.OP_DROP)
+        .add(Opcode.OP_1)
+      var tx = new bsv.Transaction()
+      tx.version = 2
+      var interp = new Interpreter()
+      interp.verify(new Script(), lock, tx, 0,
+        Interpreter.SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, new BN2(0)).should.equal(false)
+      interp.errstr.should.match(/UNSATISFIED_LOCKTIME/)
+    })
+
+    // Flags and limits are separate mechanisms; mainnetFlags() cannot set the statics.
+    // A script over the pre-Genesis 10,000-byte cap is valid on mainnet.
+    it('useMainnetConsensus lifts the limits that mainnetFlags cannot', function () {
+      var big = new Script()
+      for (var i = 0; i < 400; i++) big.add(Buffer.alloc(30, 1)).add(Opcode.OP_DROP)
+      big.add(Opcode.OP_1)
+      big.toBuffer().length.should.be.above(10000)
+
+      var flags = Interpreter.useMainnetConsensus()
+      var interp = new Interpreter()
+      interp.verify(new Script(), big, new bsv.Transaction(), 0, flags, new BN2(0))
+        .should.equal(true)
+      Interpreter.MAX_SCRIPT_SIZE.should.be.above(10000)
     })
   })
 })

package/test/script/defaults.js

@@ -0,0 +1,93 @@
+'use strict'
+
+/* global describe, it */
+
+// `verify()` describes BSV mainnet as it is today when the caller says nothing.
+//
+// Until 8.0.0 it defaulted to `0` — no rules at all. That is the wrong direction to be
+// wrong in: a validator looser than consensus accepts scripts the network rejects, and
+// nothing that tests this library against itself can see it. The node vectors found 21
+// such cases the first time they were run.
+//
+// The set is not assembled by judgement. It mirrors what tools/sv-vector-harness.js
+// applies, including the MONOLITH/MAGNETIC pair — BSV restored those opcodes in 2018 and
+// the node does not gate them, so omitting them here would make the default STRICTER
+// than consensus.
+
+require('chai').should()
+var bsv = require('../..')
+var Script = bsv.Script
+var Interpreter = Script.Interpreter
+var Opcode = bsv.Opcode
+var BN = bsv.crypto.BN
+
+describe('verify() consensus defaults', function () {
+  var FLAGS = Interpreter.currentConsensusFlags()
+
+  it('includes both era pairs, for the spend and the output being spent', function () {
+    ;[
+      'SCRIPT_GENESIS', 'SCRIPT_UTXO_AFTER_GENESIS',
+      'SCRIPT_ENABLE_CHRONICLE', 'SCRIPT_UTXO_AFTER_CHRONICLE'
+    ].forEach(function (name) {
+      (FLAGS & Interpreter[name]).should.equal(Interpreter[name], name + ' missing from the default')
+    })
+  })
+
+  // Omitting these would make the library stricter than the node, which is the error
+  // #112 fixed in mainnetFlags(). The harness sets the same pair for every vector.
+  it('enables the opcode groups the node does not gate', function () {
+    (FLAGS & Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES)
+      .should.equal(Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES)
+    ;(FLAGS & Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES)
+      .should.equal(Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES)
+  })
+
+  it('does not enable the pre-Genesis timelock flags', function () {
+    // Genesis reverted CLTV/CSV to upgradable NOPs; carrying their flags made
+    // mainnetFlags() report timelocked outputs unspendable. See #112.
+    ;(FLAGS & Interpreter.SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY).should.equal(0)
+    ;(FLAGS & Interpreter.SCRIPT_VERIFY_CHECKSEQUENCEVERIFY).should.equal(0)
+  })
+
+  describe('applied by verify()', function () {
+    function evaluate (build, args) {
+      var script = new Script()
+      build(script)
+      var interp = new Interpreter()
+      var verified = interp.verify.apply(interp, [new Script(), script].concat(args || []))
+      return { verified: verified, errstr: interp.errstr || '' }
+    }
+
+    // OP_VER is a Chronicle opcode. Reaching it without BAD_OPCODE proves the default
+    // enabled Chronicle rather than merely exposing a constant.
+    it('evaluates a Chronicle opcode with no flags argument', function () {
+      var r = evaluate(function (s) { s.add(Opcode.OP_VER) }, [new bsv.Transaction(), 0])
+      r.errstr.should.not.match(/BAD_OPCODE/)
+    })
+
+    it('still lets the caller select older rules explicitly', function () {
+      var r = evaluate(function (s) { s.add(Opcode.OP_VER) }, [new bsv.Transaction(), 0, 0])
+      r.verified.should.equal(false)
+      r.errstr.should.match(/BAD_OPCODE/)
+    })
+
+    // FORKID changes the sighash algorithm and cannot be applied without the input
+    // amount — verify() rejects that combination outright. Rather than forcing every
+    // caller to supply satoshis for scripts containing no signature check, the flag is
+    // dropped when there is nothing for it to act on. A FORKID-signed input without the
+    // amount then fails to verify, which is a false negative, never a false positive.
+    it('drops FORKID when no input amount is supplied, instead of throwing', function () {
+      ;(function () {
+        evaluate(function (s) { s.add(Opcode.OP_1) }, [new bsv.Transaction(), 0])
+      }).should.not.throw()
+    })
+
+    it('keeps FORKID when the input amount is supplied', function () {
+      var interp = new Interpreter()
+      var script = new Script().add(Opcode.OP_1)
+      interp.verify(new Script(), script, new bsv.Transaction(), 0, undefined, new BN(1000))
+      ;(interp.flags & Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID)
+        .should.equal(Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID)
+    })
+  })
+})

package/test/script/genesis_limits.js

@@ -24,7 +24,8 @@ describe('Interpreter post-Genesis limits', function () {
   it('keeps pre-Genesis defaults out of the box', function () {
     Interpreter.MAX_SCRIPT_ELEMENT_SIZE.should.equal(520)
     Interpreter.MAXIMUM_ELEMENT_SIZE.should.equal(4)
-    Interpreter.MAX_OPS_PER_SCRIPT.should.equal(201)
+    // 500, not Core's 201: BSV raised the limit before Genesis removed it.
+    Interpreter.MAX_OPS_PER_SCRIPT.should.equal(500)
   })
 
   it('useGenesisLimits() lifts all three caps', function () {
@@ -59,15 +60,17 @@ describe('Interpreter post-Genesis limits', function () {
   })
 
   // 220 OP_NOPs then OP_1 — more non-push opcodes than the 201 cap allows.
+  // Over BSV's pre-Genesis limit of 500. It used to be 220, which is over
+  // Core's 201 but comfortably inside what BSV allowed.
   var manyOps = new Script()
-  for (var i = 0; i < 220; i++) manyOps.add(Opcode.OP_NOP)
+  for (var i = 0; i < 520; i++) manyOps.add(Opcode.OP_NOP)
   manyOps.add(Opcode.OP_1)
 
-  it('rejects >201 opcodes under default limits', function () {
+  it('rejects more opcodes than the pre-Genesis limit allows', function () {
     run(manyOps).should.equal(false)
   })
 
-  it('allows >201 opcodes after useGenesisLimits()', function () {
+  it('allows them after useGenesisLimits()', function () {
     Interpreter.useGenesisLimits()
     run(manyOps).should.equal(true)
   })
@@ -87,11 +90,23 @@ describe('Interpreter post-Genesis limits', function () {
     Interpreter.MAX_SCRIPT_SIZE.should.equal(10000)
   })
 
-  it('rejects a >10 KB script under default limits', function () {
+  // Intent inverted in 8.0.0. verify() now defaults to current mainnet, where Genesis
+  // removed the size cap, so a 20 KB script is accepted unless the caller asks for the
+  // pre-Genesis era. The cap is still enforced — it just has to be selected, which is
+  // what the following test asserts.
+  it('accepts a >10 KB script under the default (post-Genesis) rules', function () {
+    Interpreter.useGenesisLimits()
+    Interpreter.MAX_SCRIPT_SIZE = 10000 // the static cap is irrelevant post-Genesis
+    var interp = new Interpreter()
+    interp.verify(new Script(), scriptOfSize(20 * 1024)).should.equal(true)
+  })
+
+  it('rejects a >10 KB script when the pre-Genesis era is asked for', function () {
     Interpreter.useGenesisLimits() // lift element/ops caps so SIZE is what is under test
     Interpreter.MAX_SCRIPT_SIZE = 10000 // ...but keep the pre-Genesis size cap
     var interp = new Interpreter()
-    interp.verify(new Script(), scriptOfSize(20 * 1024)).should.equal(false)
+    // Flags omitted would mean post-Genesis; 0 selects the older rules explicitly.
+    interp.verify(new Script(), scriptOfSize(20 * 1024), new bsv.Transaction(), 0, 0).should.equal(false)
     interp.errstr.should.equal('SCRIPT_ERR_SCRIPT_SIZE')
   })
 
@@ -100,6 +115,47 @@ describe('Interpreter post-Genesis limits', function () {
     run(scriptOfSize(20 * 1024)).should.equal(true)
   })
 
+  // Genesis lifted the 520-byte element cap, and OP_CAT is where an
+  // implementation is most likely to keep enforcing it: it is the one opcode
+  // that can grow an element past the limit from two legal halves. This read
+  // the static constant rather than the era-derived size, so it stayed capped
+  // at 520 after Genesis and rejected concatenations the network accepts.
+  //
+  // No vector in the SV corpus covers it, so the corpus passes completely
+  // either way. It is held here instead.
+  describe('OP_CAT and the element size cap', function () {
+    var MONOLITH = Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES
+
+    // Two 300-byte pushes: each is legal pre-Genesis, their concatenation is
+    // not. Nothing but the cap distinguishes the two cases below.
+    var cat = new Script()
+      .add(Buffer.alloc(300, 1))
+      .add(Buffer.alloc(300, 1))
+      .add(Opcode.OP_CAT)
+
+    function runWith (flags) {
+      var interp = new Interpreter()
+      var ok
+      try {
+        ok = interp.verify(new Script(), cat, new Transaction(), 0, flags)
+      } catch (e) {
+        ok = false
+      }
+      return { ok: ok, errstr: interp.errstr }
+    }
+
+    it('rejects a 600-byte concatenation before Genesis', function () {
+      var got = runWith(MONOLITH)
+      got.ok.should.equal(false)
+      got.errstr.should.equal('SCRIPT_ERR_PUSH_SIZE')
+    })
+
+    it('allows it after Genesis', function () {
+      var got = runWith(MONOLITH | Interpreter.SCRIPT_UTXO_AFTER_GENESIS)
+      got.ok.should.equal(true, 'rejected with ' + got.errstr)
+    })
+  })
+
   it('useGenesisLimits raises all four caps, and getLimits/setLimits round-trip', function () {
     var before = Interpreter.getLimits()
     before.maxScriptSize.should.equal(10000)

package/test/script/interpreter.js

@@ -649,14 +649,22 @@ 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',
+    //  - The four OP_VERIF/OP_VERNOTIF rows that used to be listed here are
+    //    gone. They were overridden to 'OK' on the reasoning that BSV dropped
+    //    Core's "illegal everywhere" rule at Genesis, which is half the rule.
+    //    The node reads
+    //
+    //      if(!utxo_after_chronicle) {
+    //        if(utxo_after_genesis && !fExec) break;
+    //        else return SCRIPT_ERR_BAD_OPCODE;
+    //      }
+    //
+    //    so an unexecuted one is harmless only when the UTXO is post-Genesis.
+    //    These rows carry P2SH,STRICTENC and no Genesis flag, so they are
+    //    pre-Genesis and BAD_OPCODE is right — and the node's own corpus says
+    //    so, in test/data/bitcoin-sv, with the same comment. The override was
+    //    a reasonable inference while this library could not express an era
+    //    and everything was implicitly post-Genesis. It can now.
     "'a' 'b'|CAT|P2SH,STRICTENC": 'OK',
     "'a' 'b' 0|IF CAT ELSE 1 ENDIF|P2SH,STRICTENC": 'OK',
     "'abc' 1|SPLIT|P2SH,STRICTENC": 'OK',
@@ -689,6 +697,14 @@ describe('Interpreter', function () {
           extraData = vector.shift()
         }
 
+        // Bitcoin Core's 201-operation limit. BSV raised it to 500 before
+        // Genesis removed it altogether, so these five rows describe a rule
+        // the network has not applied since 2020. The node's own corpus in
+        // test/data/bitcoin-sv contains no OP_COUNT row at all.
+        if (vector[3] === 'OP_COUNT') {
+          return
+        }
+
         var fullScriptString = `${vector[0]} ${vector[1]}`
         var divergeKey = `${vector[0]}|${vector[1]}|${vector[2]}`
         var expectedError = Object.prototype.hasOwnProperty.call(BSV_DIVERGENCES, divergeKey)

package/test/transaction/sighash.js

@@ -32,7 +32,10 @@ describe('sighash', function () {
     var scriptbuf = buffer.Buffer.from(vector[1], 'hex')
     var subscript = Script(scriptbuf)
     var nin = vector[2]
-    var nhashtype = vector[3]
+    // This vector happens to set the Chronicle bit as well. Only BIP-143 needs
+    // the input's amount, so the bit has to be cleared for its omission to be
+    // an error at all.
+    var nhashtype = vector[3] & ~Signature.SIGHASH_CHRONICLE
     var sighashbuf = buffer.Buffer.from(vector[4], 'hex')
     var tx = new Transaction(txbuf)
 
@@ -46,11 +49,28 @@ describe('sighash', function () {
   })
 
   var zeroBN = BN.Zero
+  // These vectors were recorded before Chronicle, when bit 0x20 of the sighash
+  // type carried no meaning and BIP-143 was selected on the forkid bit alone.
+  // Chronicle gave 0x20 to SIGHASH_CHRONICLE, which selects the original digest
+  // even when forkid is present, so for a row setting both bits the recorded
+  // digest is no longer the answer. Those 251 rows are skipped rather than
+  // restated: editing a copied corpus costs it the outside-check value it was
+  // imported for, and the behaviour they used to pin is covered properly by
+  // test/consensus/sv-sighash-vectors.js, whose vectors come from the Chronicle
+  // node itself and carry both digests for every row.
+  function usesChronicleDigest (nhashtype) {
+    var t = nhashtype >>> 0
+    return (t & Signature.SIGHASH_FORKID) !== 0 && (t & Signature.SIGHASH_CHRONICLE) !== 0
+  }
+
   vectorsSighash.forEach(function (vector, i) {
     if (i === 0 || !vector[4]) {
       // First element is just a row describing the next ones
       return
     }
+    if (usesChronicleDigest(vector[3])) {
+      return
+    }
     it('test vector from bitcoind #' + i + ' (' + vector[4].substring(0, 16) + ')', function () {
       var txbuf = buffer.Buffer.from(vector[0], 'hex')
       var scriptbuf = buffer.Buffer.from(vector[1], 'hex')

package/version.js

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