@smartledger/bsv 9.0.0 → 9.1.1

package/test/script/defaults.js

@@ -1,160 +0,0 @@
-'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)
-    })
-  })
-})
-
-// The script-number bound is era-derived, not a process-wide static.
-//
-// `mainnetFlags()` omitted every era flag except SCRIPT_ENABLE_CHRONICLE, so
-// `maxScriptNumLength()` fell back to the pre-Genesis 4 for a validator built from the
-// helper named after mainnet — while post-Genesis is 750,000 and post-Chronicle
-// 32,000,000. An earlier fix pinned MAXIMUM_ELEMENT_SIZE to stop useGenesisLimits()
-// raising it to 0x7fffffff and making Chronicle's shift-overflow check unreachable; that
-// treated the symptom rather than the missing flags.
-//
-// The node's vectors settle the pre-Genesis value at 4 and are silent above it: all 22
-// SCRIPTNUM_OVERFLOW rows carry P2SH,STRICTENC and no era flag, and raising the static
-// bound to 8 turns 15 of them into false accepts.
-describe('script-number bound follows the era', function () {
-  function boundFor (flags) {
-    var i = new Interpreter()
-    i.set({ flags: flags })
-    return i.maxScriptNumLength()
-  }
-
-  it('is 4 before Genesis, which the node vectors pin', function () {
-    boundFor(0).should.equal(4)
-  })
-
-  it('is the post-Genesis figure when only Genesis is asked for', function () {
-    boundFor(Interpreter.mainnetFlags({ afterChronicle: false }))
-      .should.equal(Interpreter.MAX_SCRIPT_NUM_LENGTH_AFTER_GENESIS)
-  })
-
-  it('is the post-Chronicle figure under mainnetFlags() and the default', function () {
-    boundFor(Interpreter.mainnetFlags())
-      .should.equal(Interpreter.MAX_SCRIPT_NUM_LENGTH_AFTER_CHRONICLE)
-    boundFor(Interpreter.currentConsensusFlags())
-      .should.equal(Interpreter.MAX_SCRIPT_NUM_LENGTH_AFTER_CHRONICLE)
-  })
-
-  // Genesis activated in 2020 and nothing still spendable predates it in a way that
-  // makes a mainnet helper want the older limits, so it is not opt-out-able here.
-  it('carries the Genesis era flags in mainnetFlags(), both variants', function () {
-    ;[Interpreter.mainnetFlags(), Interpreter.mainnetFlags({ afterChronicle: false })].forEach(function (f) {
-      (f & Interpreter.SCRIPT_GENESIS).should.equal(Interpreter.SCRIPT_GENESIS)
-      ;(f & Interpreter.SCRIPT_UTXO_AFTER_GENESIS).should.equal(Interpreter.SCRIPT_UTXO_AFTER_GENESIS)
-    })
-  })
-
-  it('drops only the Chronicle pair for a pre-activation UTXO', function () {
-    var pre = Interpreter.mainnetFlags({ afterChronicle: false })
-    ;(pre & Interpreter.SCRIPT_ENABLE_CHRONICLE).should.equal(0)
-    ;(pre & Interpreter.SCRIPT_UTXO_AFTER_CHRONICLE).should.equal(0)
-  })
-
-  // useMainnetConsensus() must no longer pin the static; the flags carry the bound.
-  //
-  // The limits are process-wide statics, so this saves and restores them. Without the
-  // restore the raised caps leak into every later test in the same mocha process — 24 of
-  // them, when this was first written, including the inherited pre-Genesis bitcoind
-  // vectors. The same trap #114 hit and documented.
-  it('is not overridden by useMainnetConsensus()', function () {
-    var saved = Interpreter.getLimits()
-    try {
-      var flags = Interpreter.useMainnetConsensus()
-      boundFor(flags).should.equal(Interpreter.MAX_SCRIPT_NUM_LENGTH_AFTER_CHRONICLE)
-    } finally {
-      Interpreter.setLimits(saved)
-    }
-  })
-})

package/test/script/genesis_limits.js

@@ -1,203 +0,0 @@
-'use strict'
-
-/* global describe, it, beforeEach, afterEach */
-var should = require('chai').should()
-var bsv = require('../..')
-var BN = bsv.crypto.BN
-var Interpreter = bsv.Script.Interpreter
-var Script = bsv.Script
-var Opcode = bsv.Opcode
-var Transaction = bsv.Transaction
-
-// Post-Genesis BSV removed the pre-Genesis script limits (520-byte element,
-// 4-byte script number, 201 opcodes). These are now configurable so modern
-// covenants (e.g. OP_PUSH_TX) can be evaluated. Defaults are unchanged.
-describe('Interpreter post-Genesis limits', function () {
-  var saved
-
-  beforeEach(function () {
-    saved = Interpreter.getLimits()
-  })
-  afterEach(function () {
-    Interpreter.setLimits(saved)
-  })
-
-  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)
-    // 500, not Core's 201: BSV raised the limit before Genesis removed it.
-    Interpreter.MAX_OPS_PER_SCRIPT.should.equal(500)
-  })
-
-  // MAXIMUM_ELEMENT_SIZE is no longer among them. It is CScriptNum's max_length, and
-  // since the limits became era-derived it is only the PRE-Genesis fallback — raising it
-  // could not enable post-Genesis arithmetic, only corrupt pre-Genesis validation.
-  it('useGenesisLimits() lifts the size caps but not the script-number bound', function () {
-    Interpreter.useGenesisLimits()
-    Interpreter.MAX_SCRIPT_ELEMENT_SIZE.should.equal(0x7fffffff)
-    Interpreter.MAX_OPS_PER_SCRIPT.should.equal(0x7fffffff)
-    Interpreter.MAXIMUM_ELEMENT_SIZE.should.equal(4)
-  })
-
-  // The reason it must not be raised, stated as a test: a 5-byte operand is an overflow
-  // before Genesis, and no process-wide call may turn that into an accept.
-  it('cannot be made to accept a pre-Genesis script-number overflow', function () {
-    var overflow = new Script()
-      .add(Buffer.from('1234567890', 'hex'))
-      .add(Buffer.from([2]))
-      .add(Opcode.OP_MUL)
-    var flags = Interpreter.SCRIPT_VERIFY_P2SH | Interpreter.SCRIPT_VERIFY_STRICTENC |
-      Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES | Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES
-    Interpreter.useGenesisLimits()
-    var interp = new Interpreter()
-    interp.verify(new Script(), overflow, new bsv.Transaction(), 0, flags, new BN(0))
-      .should.equal(false)
-    interp.errstr.should.equal('SCRIPT_ERR_SCRIPTNUM_OVERFLOW')
-  })
-
-  // <2^32> <2^32> OP_ADD <2^33> OP_NUMEQUAL  — operands exceed the 4-byte cap.
-  var bigAdd = new Script()
-    .add(Buffer.from('0000000001', 'hex')) // 2^32, little-endian, 5 bytes
-    .add(Buffer.from('0000000001', 'hex'))
-    .add(Opcode.OP_ADD)
-    .add(Buffer.from('0000000002', 'hex')) // 2^33
-    .add(Opcode.OP_NUMEQUAL)
-
-  function run (lock) {
-    var interp = new Interpreter()
-    var ok
-    try { ok = interp.verify(new Script(), lock, new Transaction(), 0, 0) } catch (e) { ok = false }
-    return ok
-  }
-
-  it('rejects >4-byte arithmetic under default limits', function () {
-    run(bigAdd).should.equal(false)
-  })
-
-  // Post-Genesis arithmetic is reached through the ERA, not through the static. Before
-  // the limits became era-derived, useGenesisLimits() was the only route; it no longer
-  // is, and using it for this would corrupt pre-Genesis validation elsewhere.
-  it('allows >4-byte arithmetic when the post-Genesis era is asked for', function () {
-    var interp = new Interpreter()
-    interp.verify(new Script(), bigAdd, new bsv.Transaction(), 0,
-      Interpreter.mainnetFlags(), new BN(0)).should.equal(true)
-  })
-
-  it('still rejects it under pre-Genesis rules, whatever the statics say', function () {
-    Interpreter.useGenesisLimits()
-    run(bigAdd).should.equal(false)
-  })
-
-  // 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 < 520; i++) manyOps.add(Opcode.OP_NOP)
-  manyOps.add(Opcode.OP_1)
-
-  it('rejects more opcodes than the pre-Genesis limit allows', function () {
-    run(manyOps).should.equal(false)
-  })
-
-  it('allows them after useGenesisLimits()', function () {
-    Interpreter.useGenesisLimits()
-    run(manyOps).should.equal(true)
-  })
-  // Total script size was a hard-coded 10,000 in evaluate(), so useGenesisLimits()
-  // could not lift it: any script over 10 KB failed SCRIPT_ERR_SCRIPT_SIZE regardless
-  // of what the caller asked for. That put every sizeable 1Sat Ordinals inscription
-  // out of reach of the interpreter entirely.
-  function scriptOfSize (bytes) {
-    // OP_DROP a single large push, then OP_1 — trivially true, but big.
-    return new Script()
-      .add(Buffer.alloc(bytes))
-      .add(Opcode.OP_DROP)
-      .add(Opcode.OP_1)
-  }
-
-  it('exposes the total script size cap as a constant, defaulting to pre-Genesis', function () {
-    Interpreter.MAX_SCRIPT_SIZE.should.equal(10000)
-  })
-
-  // 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()
-    // 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')
-  })
-
-  it('allows a >10 KB script after useGenesisLimits()', function () {
-    Interpreter.useGenesisLimits()
-    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 the size caps, and getLimits/setLimits round-trip', function () {
-    var before = Interpreter.getLimits()
-    before.maxScriptSize.should.equal(10000)
-    Interpreter.useGenesisLimits(64 * 1024)
-    var after = Interpreter.getLimits()
-    after.maxScriptElementSize.should.equal(64 * 1024)
-    after.maxOpsPerScript.should.equal(64 * 1024)
-    // Not raised — see the note on useGenesisLimits. setLimits() can still set it
-    // explicitly, which is what the round-trip below checks.
-    after.maximumElementSize.should.equal(4)
-    after.maxScriptSize.should.equal(64 * 1024)
-    Interpreter.setLimits(before)
-    Interpreter.getLimits().maxScriptSize.should.equal(10000)
-    Interpreter.MAX_SCRIPT_ELEMENT_SIZE.should.equal(520)
-  })
-})