@smartledger/bsv 9.0.0 → 9.1.0

package/test/script/string_ops.js

@@ -1,88 +0,0 @@
-'use strict'
-
-/* global describe, it */
-require('chai').should()
-var bsv = require('../..')
-var Interpreter = bsv.Script.Interpreter
-var Script = bsv.Script
-var Opcode = bsv.Opcode
-var Transaction = bsv.Transaction
-var CHRONICLE = Interpreter.SCRIPT_ENABLE_CHRONICLE
-
-// OP_SUBSTR / OP_LEFT / OP_RIGHT — Chronicle string opcodes at 0xb3/0xb4/0xb5.
-//
-// Every case here passes SCRIPT_ENABLE_CHRONICLE, because without it these
-// bytes are UPGRADABLE NOPS, exactly as they are on a pre-Chronicle node. An
-// earlier version of these tests ran them with flags=0 and passed, which is
-// what hid the fact that the interpreter was executing them unconditionally —
-// more permissively than the network.
-describe('String opcodes OP_SUBSTR / OP_LEFT / OP_RIGHT', function () {
-  var DATA = Buffer.from('aabbccdd', 'hex')
-
-  // Build `<DATA> <ops...>` and assert the top of stack equals `expected`.
-  function yields (buildOps, expectedHex) {
-    var lock = new Script().add(DATA)
-    buildOps(lock)
-    lock.add(Buffer.from(expectedHex, 'hex')).add(Opcode.OP_EQUAL)
-    var interp = new Interpreter()
-    return interp.verify(new Script(), lock, new Transaction(), 0, CHRONICLE)
-  }
-  function errors (buildOps) {
-    var lock = new Script().add(DATA)
-    buildOps(lock)
-    var interp = new Interpreter()
-    var ok
-    try { ok = interp.verify(new Script(), lock, new Transaction(), 0, CHRONICLE) } catch (e) { ok = false }
-    return ok === false
-  }
-
-  it('OP_LEFT keeps the first n bytes', function () {
-    yields(function (s) { s.add(Opcode.OP_2).add(Opcode.OP_LEFT) }, 'aabb').should.equal(true)
-  })
-
-  it('OP_RIGHT keeps the last n bytes', function () {
-    yields(function (s) { s.add(Opcode.OP_2).add(Opcode.OP_RIGHT) }, 'ccdd').should.equal(true)
-  })
-
-  it('OP_RIGHT 0 yields the empty string (not the whole string)', function () {
-    yields(function (s) { s.add(Opcode.OP_0).add(Opcode.OP_RIGHT) }, '').should.equal(true)
-  })
-
-  it('OP_LEFT 0 yields the empty string', function () {
-    yields(function (s) { s.add(Opcode.OP_0).add(Opcode.OP_LEFT) }, '').should.equal(true)
-  })
-
-  it('OP_SUBSTR extracts in[begin : begin+size]', function () {
-    // begin=1 size=2 -> bbcc.  Stack order is (in begin size -- out).
-    yields(function (s) { s.add(Opcode.OP_1).add(Opcode.OP_2).add(Opcode.OP_SUBSTR) }, 'bbcc').should.equal(true)
-  })
-
-  // The node ERRORS rather than clamping:
-  //   if(len < 0 || len > size) return SCRIPT_ERR_INVALID_NUMBER_RANGE;
-  // Clamping made scripts the node rejects succeed here.
-  it('OP_LEFT rejects n greater than the length', function () {
-    errors(function (s) { s.add(Opcode.OP_10).add(Opcode.OP_LEFT) }).should.equal(true)
-  })
-
-  it('OP_RIGHT rejects n greater than the length', function () {
-    errors(function (s) { s.add(Opcode.OP_10).add(Opcode.OP_RIGHT) }).should.equal(true)
-  })
-
-  it('is a no-op without SCRIPT_ENABLE_CHRONICLE, as a pre-Chronicle node is', function () {
-    const interp = new Interpreter()
-    const lock = new Script().add(DATA).add(Opcode.OP_2).add(Opcode.OP_LEFT)
-    interp.verify(new Script(), lock, new Transaction(), 0, 0).should.equal(true)
-    // Untouched: the opcode did nothing, so both operands survive.
-    interp.stack.length.should.equal(2)
-  })
-
-  it('rejects a negative size', function () {
-    errors(function (s) { s.add(Opcode.OP_1NEGATE).add(Opcode.OP_LEFT) }).should.equal(true)
-  })
-
-  it('rejects OP_LEFT with too few stack items', function () {
-    var interp = new Interpreter()
-    var lock = new Script().add(Opcode.OP_LEFT) // nothing to operate on
-    interp.verify(new Script(), lock, new Transaction(), 0, CHRONICLE).should.equal(false)
-  })
-})

package/test/security/fail_closed_contracts.js

@@ -1,104 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// FAIL-CLOSED CONTRACTS — a mechanical guard for the operating principle that every
-// security-critical verification "returns a bool or throws, never a chainable object"
-// and that a forged/invalid input is REJECTED (never accepted).
-//
-// This exists because the v6.0.0 security-hardening pass fixed four CRITICAL fail-open
-// forgery bugs, all of the same shape: code read a truthy return value (an ECDSA
-// *instance*, a stub `{verified:true}`) as if it meant "valid". These tests assert the
-// negative — a bad input must not verify — and pin the return-type contract so a
-// regression to fail-open trips a red test instead of shipping.
-
-require('chai').should()
-var assert = require('assert')
-var bsv = require('../..')
-
-var Hash = bsv.crypto.Hash
-var ECDSA = bsv.crypto.ECDSA
-
-function isStrictBool (v) { return v === true || v === false }
-
-describe('security: fail-closed verification contracts', function () {
-  // A signature over `hash` by `signer`, and a different key it was NOT signed by.
-  var signer = bsv.PrivateKey.fromRandom()
-  var hash = Hash.sha256(Buffer.from('the message'))
-  var goodSig = ECDSA.sign(hash, signer)
-  var rightPub = signer.toPublicKey()
-  var wrongPub = bsv.PrivateKey.fromRandom().toPublicKey()
-
-  describe('ECDSA signature verification', function () {
-    it('static ECDSA.verify returns a STRICT boolean (never a truthy object)', function () {
-      isStrictBool(ECDSA.verify(hash, goodSig, rightPub)).should.equal(true)
-      isStrictBool(ECDSA.verify(hash, goodSig, wrongPub)).should.equal(true)
-    })
-
-    it('static ECDSA.verify accepts a valid signature and REJECTS a forged one', function () {
-      ECDSA.verify(hash, goodSig, rightPub).should.equal(true)
-      ECDSA.verify(hash, goodSig, wrongPub).should.equal(false) // forged: wrong key
-    })
-
-    it('instance verifyBool() is the safe boolean path and fails closed on a forgery', function () {
-      function inst (pub) {
-        var e = new ECDSA(); e.hashbuf = hash; e.sig = goodSig; e.pubkey = pub; return e
-      }
-      isStrictBool(inst(rightPub).verifyBool()).should.equal(true)
-      inst(rightPub).verifyBool().should.equal(true)
-      inst(wrongPub).verifyBool().should.equal(false)
-    })
-
-    // 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)
-    })
-  })
-
-  describe('SmartVerify (hardened secp256k1 verify)', function () {
-    it('returns a STRICT boolean and rejects a forged signature', function () {
-      var ok = bsv.SmartVerify.smartVerify(hash, goodSig.toBuffer(), rightPub)
-      var bad = bsv.SmartVerify.smartVerify(hash, goodSig.toBuffer(), wrongPub)
-      isStrictBool(ok).should.equal(true)
-      isStrictBool(bad).should.equal(true)
-      ok.should.equal(true)
-      bad.should.equal(false)
-    })
-  })
-
-  describe('SPV inclusion / header-chain verification', function () {
-    it('verifyHeaderChain fails closed on empty / malformed input (throws, not truthy)', function () {
-      assert.throws(function () { bsv.SPV.verifyHeaderChain([], {}) })
-    })
-
-    it('verifyMerkleProof rejects a bad proof without ever returning a truthy non-boolean', function () {
-      var fakeRoot = Buffer.alloc(32, 1)
-      var fakeTxid = Buffer.alloc(32, 2)
-      var res
-      try {
-        res = bsv.SPV.verifyMerkleProof(fakeTxid, { index: 0, nodes: ['00'.repeat(32)] }, fakeRoot)
-      } catch (e) { res = false } // throwing is an acceptable fail-closed outcome
-      // Whatever the shape, it must not be a truthy value that reads as "included".
-      var included = (res === true) || (res && res.valid === true) || (res && res.verified === true)
-      included.should.equal(false)
-    })
-  })
-
-  describe('SmartContract script verification', function () {
-    it('verifyScript reports a boolean ok and fails an unsatisfiable lock', function () {
-      var r = bsv.SmartContract.verifyScript(new bsv.Script(), new bsv.Script().add(bsv.Opcode.OP_FALSE))
-      isStrictBool(r.ok).should.equal(true)
-      r.ok.should.equal(false)
-    })
-  })
-})

package/test/security/threat_model_coverage.js

@@ -1,31 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// Keeps docs/THREAT_MODEL.md honest: every `test/…js` the threat model cites as the
-// enforcer of a security property must actually exist. If a security test is renamed
-// or deleted, the threat model can no longer silently point at a ghost — this gate goes
-// red. (Same "docs are tested claims" principle as the type-drift gate.)
-
-require('chai').should()
-var fs = require('fs')
-var path = require('path')
-
-var ROOT = path.resolve(__dirname, '../..')
-var MODEL = path.join(ROOT, 'docs/THREAT_MODEL.md')
-
-describe('security: threat model references real tests', function () {
-  var text = fs.readFileSync(MODEL, 'utf8')
-  // Every referenced test path, e.g. `test/security/fail_closed_contracts.js`.
-  var refs = (text.match(/test\/[A-Za-z0-9_./-]+\.js/g) || [])
-  var unique = refs.filter(function (r, i) { return refs.indexOf(r) === i })
-
-  it('cites a meaningful number of enforcing tests', function () {
-    unique.length.should.be.above(6)
-  })
-
-  it('every cited test file exists', function () {
-    var missing = unique.filter(function (rel) { return !fs.existsSync(path.join(ROOT, rel)) })
-    missing.should.deep.equal([], 'THREAT_MODEL.md cites test files that do not exist:\n  ' + missing.join('\n  '))
-  })
-})

package/test/smart_contract/covenants.js

@@ -1,207 +0,0 @@
-'use strict'
-
-/* global describe, it, before, after */
-require('chai').should()
-var bsv = require('../..')
-var SC = bsv.SmartContract
-var PrivateKey = bsv.PrivateKey
-var Script = bsv.Script
-var Transaction = bsv.Transaction
-
-var Locks = SC.Locks
-var PushTx = SC.PushTx
-var Token = SC.Token
-var help = SC.CovenantHelpers
-var fundAndSpend = help.fundAndSpend
-var p2pkhOutput = help.p2pkhOutput
-var verify = help.verify
-
-var SATS = 100000
-
-describe('SmartContract covenants (v4.2.0)', function () {
-  this.timeout(20000)
-
-  var alice = PrivateKey.fromRandom()
-  var bob = PrivateKey.fromRandom()
-  var carol = PrivateKey.fromRandom()
-
-  function spendOf (lock, sats, outputs) {
-    return fundAndSpend(lock, sats, { outputs: outputs }).spend
-  }
-
-  describe('Locks', function () {
-    it('hash-lock accepts the right secret and rejects a wrong one', function () {
-      var secret = Buffer.from('correct horse battery staple')
-      var c = Locks.hashLock(secret)
-      var spend = spendOf(c.lock, SATS, [p2pkhOutput(alice, SATS - 500)])
-      spend.inputs[0].setScript(c.unlock(spend, SATS))
-      verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(true)
-
-      spend = spendOf(c.lock, SATS, [p2pkhOutput(alice, SATS - 500)])
-      spend.inputs[0].setScript(c.unlock(spend, SATS, Buffer.from('wrong')))
-      verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(false)
-    })
-
-    it('P2PKH verifies a valid signature', function () {
-      var c = Locks.p2pkh(alice)
-      var spend = spendOf(c.lock, SATS, [p2pkhOutput(bob, SATS - 500)])
-      spend.inputs[0].setScript(c.unlock(spend, SATS))
-      verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(true)
-    })
-
-    it('2-of-3 multisig verifies with two valid signatures', function () {
-      var c = Locks.multisig(2, [alice, bob, carol])
-      var spend = spendOf(c.lock, SATS, [p2pkhOutput(bob, SATS - 500)])
-      spend.inputs[0].setScript(c.unlock(spend, SATS, [alice, bob]))
-      verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(true)
-    })
-  })
-
-  describe('OP_PUSH_TX', function () {
-    it('accepts an authentic preimage and rejects a tampered one', function () {
-      var lock = PushTx.authenticator()
-      var spend = spendOf(lock, SATS, [p2pkhOutput(alice, SATS - 500)])
-      var g = PushTx.grind(spend, 0, lock, SATS)
-      spend.inputs[0].setScript(new Script().add(g.preimage))
-      verify(spend.inputs[0].script, lock, { tx: spend, satoshis: SATS }).ok.should.equal(true)
-
-      var bad = Buffer.from(g.preimage); bad[bad.length - 5] ^= 0xff
-      spend.inputs[0].setScript(new Script().add(bad))
-      verify(spend.inputs[0].script, lock, { tx: spend, satoshis: SATS }).ok.should.equal(false)
-    })
-
-    it('value covenant forces coins to the required outputs', function () {
-      var beneficiary = PrivateKey.fromRandom()
-      var attacker = PrivateKey.fromRandom()
-      var required = [p2pkhOutput(beneficiary, SATS - 500)]
-      var lock = PushTx.valueCovenant(PushTx.hashOutputs(required))
-
-      var spend = spendOf(lock, SATS, required)
-      spend.inputs[0].setScript(new Script().add(PushTx.grind(spend, 0, lock, SATS).preimage))
-      verify(spend.inputs[0].script, lock, { tx: spend, satoshis: SATS }).ok.should.equal(true)
-
-      spend = spendOf(lock, SATS, [p2pkhOutput(attacker, SATS - 500)])
-      spend.inputs[0].setScript(new Script().add(PushTx.grind(spend, 0, lock, SATS).preimage))
-      verify(spend.inputs[0].script, lock, { tx: spend, satoshis: SATS }).ok.should.equal(false)
-    })
-
-    it('grind yields a CANONICAL low-S signature, enforced under SCRIPT_VERIFY_LOW_S', function () {
-      var BN = bsv.crypto.BN
-      var Hash = bsv.crypto.Hash
-      var halfN = BN.fromBuffer(Buffer.from('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 'hex'))
-      var I = bsv.Script.Interpreter
-      // The hardened verify flags enforce low-S.
-      ;(help.flags() & I.SCRIPT_VERIFY_LOW_S).should.not.equal(0)
-
-      var lock = PushTx.authenticator()
-      var spend = spendOf(lock, SATS, [p2pkhOutput(alice, SATS - 500)])
-      var preimage = PushTx.grind(spend, 0, lock, SATS).preimage
-      // The in-script signature s = (HASH256(preimage)+Gx) mod n is provably low-S.
-      var s = BN.fromBuffer(Hash.sha256sha256(preimage)).add(BN.fromBuffer(PushTx.Gx)).mod(PushTx.N)
-      s.gt(halfN).should.equal(false)
-      // And it verifies with LOW_S enforced (a high-S signature would be rejected here).
-      spend.inputs[0].setScript(new Script().add(preimage))
-      verify(spend.inputs[0].script, lock, { tx: spend, satoshis: SATS }).ok.should.equal(true)
-    })
-  })
-
-  describe('PELS (perpetual covenant)', function () {
-    var FEE = 500
-    it('recreates the same script and chains a second hop', function () {
-      var lock = SC.perpetualCovenant(FEE)
-      var spend = spendOf(lock, SATS, [new Transaction.Output({ script: lock, satoshis: SATS - FEE })])
-      spend.inputs[0].setScript(new Script().add(PushTx.grind(spend, 0, lock, SATS).preimage))
-      verify(spend.inputs[0].script, lock, { tx: spend, satoshis: SATS }).ok.should.equal(true)
-
-      var inSats = SATS - FEE
-      spend = spendOf(lock, inSats, [new Transaction.Output({ script: lock, satoshis: inSats - FEE })])
-      spend.inputs[0].setScript(new Script().add(PushTx.grind(spend, 0, lock, inSats).preimage))
-      verify(spend.inputs[0].script, lock, { tx: spend, satoshis: inSats }).ok.should.equal(true)
-    })
-
-    it('rejects escaping to a P2PKH', function () {
-      var lock = SC.perpetualCovenant(FEE)
-      var spend = spendOf(lock, SATS, [p2pkhOutput(PrivateKey.fromRandom(), SATS - FEE)])
-      spend.inputs[0].setScript(new Script().add(PushTx.grind(spend, 0, lock, SATS).preimage))
-      verify(spend.inputs[0].script, lock, { tx: spend, satoshis: SATS }).ok.should.equal(false)
-    })
-  })
-
-  describe('Token (stateful NFT)', function () {
-    var FEE = 500
-
-    // Owners are keys, not secrets: ownerId = HASH160(pubkey); transfers are ECDSA-signed.
-    function transfer (currentLock, inSats, ownerKey, nextHash, outputOverride) {
-      var nextLock = Token.ownershipToken(FEE, nextHash)
-      var out = outputOverride || new Transaction.Output({ script: nextLock, satoshis: inSats - FEE })
-      var spend = spendOf(currentLock, inSats, [out])
-      spend.inputs[0].setScript(Token.unlockTransfer(ownerKey, nextHash, spend, inSats, currentLock))
-      return { spend: spend, nextLock: nextLock }
-    }
-
-    it('transfers ownership across a chain and rejects a non-owner', function () {
-      var aliceToken = Token.ownershipToken(FEE, Token.ownerId(alice))
-      var bobHash = Token.ownerId(bob)
-      var carolHash = Token.ownerId(carol)
-
-      var r = transfer(aliceToken, SATS, alice, bobHash)
-      verify(r.spend.inputs[0].script, aliceToken, { tx: r.spend, satoshis: SATS }).ok.should.equal(true)
-
-      var inSats = SATS - FEE
-      var r2 = transfer(r.nextLock, inSats, bob, carolHash)
-      verify(r2.spend.inputs[0].script, r.nextLock, { tx: r2.spend, satoshis: inSats }).ok.should.equal(true)
-
-      var bad = transfer(aliceToken, SATS, carol, bobHash) // carol does not own alice's token
-      verify(bad.spend.inputs[0].script, aliceToken, { tx: bad.spend, satoshis: SATS }).ok.should.equal(false)
-    })
-
-    it('rejects breaking the token out to a P2PKH', function () {
-      var aliceToken = Token.ownershipToken(FEE, Token.ownerId(alice))
-      var r = transfer(aliceToken, SATS, alice, Token.ownerId(bob),
-        p2pkhOutput(PrivateKey.fromRandom(), SATS - FEE))
-      verify(r.spend.inputs[0].script, aliceToken, { tx: r.spend, satoshis: SATS }).ok.should.equal(false)
-    })
-
-    it('defeats front-running: a third party cannot redirect a signed transfer', function () {
-      var aliceToken = Token.ownershipToken(FEE, Token.ownerId(alice))
-      var bobHash = Token.ownerId(bob)
-      var mallory = PrivateKey.fromRandom()
-      var malloryHash = Token.ownerId(mallory)
-
-      // Alice signs a valid transfer to Bob.
-      var r = transfer(aliceToken, SATS, alice, bobHash)
-      verify(r.spend.inputs[0].script, aliceToken, { tx: r.spend, satoshis: SATS }).ok.should.equal(true)
-
-      // A mempool watcher lifts Alice's signature + pubkey (chunks 1 and 2 of her
-      // unlock script) and tries to redirect the token to Mallory by recreating
-      // the token output owned by Mallory and reusing Alice's signature.
-      var chunks = r.spend.inputs[0].script.chunks
-      var stolenSig = chunks[1].buf
-      var stolenPub = chunks[2].buf
-
-      var malloryLock = Token.ownershipToken(FEE, malloryHash)
-      var evil = spendOf(aliceToken, SATS, [new Transaction.Output({ script: malloryLock, satoshis: SATS - FEE })])
-      var g = PushTx.grind(evil, 0, aliceToken, SATS) // a valid OP_PUSH_TX preimage for the evil tx
-      evil.inputs[0].setScript(new Script()
-        .add(Buffer.from(malloryHash))
-        .add(stolenSig) // Alice signed the Bob-output spend, not this one
-        .add(stolenPub)
-        .add(Buffer.from(g.preimage)))
-
-      // OP_CHECKSIG recomputes the sighash over the Mallory output => Alice's sig fails.
-      verify(evil.inputs[0].script, aliceToken, { tx: evil, satoshis: SATS }).ok.should.equal(false)
-    })
-
-    it('grinds the input sequence so a token can coexist with a pinned nLockTime', function () {
-      var aliceToken = Token.ownershipToken(FEE, Token.ownerId(alice))
-      var bobHash = Token.ownerId(bob)
-      var nextLock = Token.ownershipToken(FEE, bobHash)
-      var spend = spendOf(aliceToken, SATS, [new Transaction.Output({ script: nextLock, satoshis: SATS - FEE })])
-      spend.nLockTime = 500000 // caller pins nLockTime; grind must not clobber it
-      spend.inputs[0].setScript(
-        Token.unlockTransfer(alice, bobHash, spend, SATS, aliceToken, { grind: { field: 'sequence' } }))
-      spend.nLockTime.should.equal(500000)
-      verify(spend.inputs[0].script, aliceToken, { tx: spend, satoshis: SATS }).ok.should.equal(true)
-    })
-  })
-})

package/test/smart_contract/dsl_debugger.js

@@ -1,92 +0,0 @@
-'use strict'
-
-/* global describe, it, before, after */
-require('chai').should()
-var bsv = require('../..')
-var SC = bsv.SmartContract
-var Script = bsv.Script
-var PrivateKey = bsv.PrivateKey
-var Opcode = bsv.Opcode
-var H = SC.CovenantHelpers
-var verify = H.verify
-
-var SATS = 100000
-
-describe('SmartContract covenant DSL + debugger (v4.5.0)', function () {
-  this.timeout(20000)
-
-  var alice = PrivateKey.fromRandom()
-  var attacker = PrivateKey.fromRandom()
-  function spendWith (lock, outputs) {
-    return H.fundAndSpend(lock, SATS, { outputs: outputs }).spend
-  }
-
-  describe('policy() DSL', function () {
-    it('payTo: compiles a covenant that pins the output and rejects redirects', function () {
-      var c = SC.policy().payTo(alice.toAddress(), SATS - 500).compile()
-      var spend = spendWith(c.lock, c.outputs)
-      spend.inputs[0].setScript(c.unlock(spend, SATS))
-      verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(true)
-
-      spend = spendWith(c.lock, [H.p2pkhOutput(attacker, SATS - 500)])
-      spend.inputs[0].setScript(c.unlock(spend, SATS))
-      verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(false)
-    })
-
-    it('multi-output: pins the exact ordered set and rejects a tweaked amount', function () {
-      var c = SC.policy().payTo(alice.toAddress(), 60000).payTo(attacker.toAddress(), 39500).compile()
-      var spend = spendWith(c.lock, c.outputs)
-      spend.inputs[0].setScript(c.unlock(spend, SATS))
-      verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(true)
-
-      var bad = spendWith(c.lock, [H.p2pkhOutput(alice, 60001), H.p2pkhOutput(attacker, 39499)])
-      bad.inputs[0].setScript(c.unlock(bad, SATS))
-      verify(bad.inputs[0].script, c.lock, { tx: bad, satoshis: SATS }).ok.should.equal(false)
-    })
-
-    it('payTo AND lockUntil compose; rejects an early locktime', function () {
-      var height = 800000
-      var c = SC.policy().payTo(alice.toAddress(), SATS - 500).lockUntil(height).compile()
-      var spend = spendWith(c.lock, c.outputs)
-      spend.inputs[0].setScript(c.unlock(spend, SATS))
-      verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(true)
-
-      spend = spendWith(c.lock, c.outputs)
-      spend.nLockTime = height - 1
-      spend.inputs[0].sequenceNumber = 0xfffffffe
-      spend.inputs[0].setScript(new Script().add(SC.PushTx.grind(spend, 0, c.lock, SATS).preimage))
-      verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(false)
-    })
-
-    it('exposes .perpetual()/.token() shortcuts', function () {
-      SC.policy.perpetual(500).toBuffer().length.should.be.above(252)
-      var h = bsv.crypto.Hash.sha256ripemd160(bsv.PrivateKey.fromRandom().toPublicKey().toBuffer())
-      SC.policy.token(500, h).toBuffer().length.should.be.above(252)
-    })
-
-    it('throws on an empty policy', function () {
-      (function () { SC.policy().compile() }).should.throw(/empty policy/)
-    })
-  })
-
-  describe('trace() debugger', function () {
-    it('traces a hash-lock and agrees with the interpreter (true and false)', function () {
-      var secret = Buffer.from('hello')
-      var lock = new Script().add(Opcode.OP_SHA256).add(bsv.crypto.Hash.sha256(secret)).add(Opcode.OP_EQUAL)
-      var r = SC.trace(new Script().add(secret), lock, { satoshis: 1000 })
-      r.ok.should.equal(true)
-      r.steps[r.steps.length - 1].stack.join().should.equal('01')
-      SC.trace(new Script().add(Buffer.from('nope')), lock, { satoshis: 1000 }).ok.should.equal(false)
-    })
-
-    it('traces an OP_PUSH_TX covenant ending in OP_CHECKSIG -> 01', function () {
-      var lock = SC.PushTx.authenticator()
-      var spend = H.fundAndSpend(lock, SATS, { outputs: [H.p2pkhOutput(alice, SATS - 500)] }).spend
-      spend.inputs[0].setScript(new Script().add(SC.PushTx.grind(spend, 0, lock, SATS).preimage))
-      var r = SC.trace(spend.inputs[0].script, lock, { tx: spend, satoshis: SATS })
-      r.ok.should.equal(true)
-      r.steps[r.steps.length - 1].op.should.equal('OP_CHECKSIG')
-      SC.Debugger.format(r).should.contain('VALID')
-    })
-  })
-})

package/test/smart_contract/extract_field.js

@@ -1,61 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// Regression for the inverted OP_SPLIT/OP_DROP idiom in CovenantBuilder.extractField.
-// After OP_SPLIT the RIGHT part is on top, so keeping it needs OP_NIP; the code used
-// OP_DROP (which keeps the LEFT), so RIGHT-strategy fields (value, nSequence,
-// hashOutputs, nLocktime, sighashType) extracted the WRONG bytes — a covenant that
-// either fails to constrain the spend or is unspendable. These tests drive the real
-// builder through the interpreter and assert the extracted bytes are correct.
-
-require('chai').should()
-var bsv = require('../..')
-var Interpreter = bsv.Script.Interpreter
-var Script = bsv.Script
-var Opcode = bsv.Opcode
-var Transaction = bsv.Transaction
-var CovenantBuilder = require('../../lib/smart_contract/covenant_builder').CovenantBuilder
-
-// Synthetic preimage: 120 bytes of filler + a 52-byte BIP-143 right zone whose
-// fields are individually recognizable.
-var FILLER = Buffer.alloc(120, 0x11)
-var VALUE = Buffer.alloc(8, 0xaa)
-var NSEQ = Buffer.alloc(4, 0xbb)
-var HASHOUT = Buffer.alloc(32, 0xcc)
-var NLOCK = Buffer.alloc(4, 0xdd)
-var SIGHASH = Buffer.alloc(4, 0xee)
-var PREIMAGE = Buffer.concat([FILLER, VALUE, NSEQ, HASHOUT, NLOCK, SIGHASH])
-
-// Run `<PREIMAGE> <extractField(name) ops> <expected> OP_EQUAL` through the
-// interpreter (fromASM avoids the separately-tracked _asmToHex issue).
-function extractYields (fieldName, expected) {
-  var b = new CovenantBuilder()
-  b.extractField(fieldName)
-  var extractScript = Script.fromASM(b.operations.join(' '))
-  var lock = new Script().add(PREIMAGE)
-  extractScript.chunks.forEach(function (c) { lock.chunks.push(c) })
-  lock.add(expected).add(Opcode.OP_EQUAL)
-  var interp = new Interpreter()
-  return interp.verify(new Script(), lock, new Transaction(), 0,
-    Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES | Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES)
-}
-
-describe('CovenantBuilder.extractField (OP_SPLIT/OP_NIP regression)', function () {
-  it('extracts RIGHT field "value" (offsetFromEnd 52, len 8)', function () {
-    extractYields('value', VALUE).should.equal(true)
-  })
-  it('extracts RIGHT field "hashOutputs" (offsetFromEnd 40, len 32)', function () {
-    extractYields('hashOutputs', HASHOUT).should.equal(true)
-  })
-  it('extracts RIGHT field "nSequence" (offsetFromEnd 44, len 4)', function () {
-    extractYields('nSequence', NSEQ).should.equal(true)
-  })
-  it('extracts RIGHT field "sighashType" (offsetFromEnd 4, len 4)', function () {
-    extractYields('sighashType', SIGHASH).should.equal(true)
-  })
-  it('extracts LEFT field "hashPrevouts" (offset 4, len 32)', function () {
-    // First 4 bytes are filler(nVersion); bytes 4..36 are filler too here.
-    extractYields('hashPrevouts', PREIMAGE.slice(4, 36)).should.equal(true)
-  })
-})

package/test/smart_contract/nonenforcing_guard.js

@@ -1,44 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// Phase 1 consolidation guard: the two NON-ENFORCING covenant builders
-// (SmartContract.Covenant and SmartContract.Builder) reduce to plain P2PK and
-// bind nothing about the spend. They must fail loud rather than silently hand back
-// a fake covenant — callers are redirected to the enforcing OP_PUSH_TX API
-// (policy() / PushTx / Token). Explicit { allowNonEnforcing: true } opts in.
-
-require('chai').should()
-var bsv = require('../..')
-var SC = bsv.SmartContract
-var PrivateKey = bsv.PrivateKey
-
-describe('Non-enforcing covenant builders fail loud (Phase 1)', function () {
-  var key = PrivateKey.fromRandom()
-
-  it('SmartContract.Covenant.createFromP2PKH throws by default', function () {
-    ;(function () {
-      new SC.Covenant(key).createFromP2PKH({ satoshis: 1000, script: '00' })
-    }).should.throw(/NON-ENFORCING|allowNonEnforcing/)
-  })
-
-  it('SmartContract.Builder.buildLockingScript throws by default but works with allowNonEnforcing', function () {
-    ;(function () {
-      new SC.Builder(key).buildLockingScript({})
-    }).should.throw(/NON-ENFORCING|allowNonEnforcing/)
-
-    var script = new SC.Builder(key, { allowNonEnforcing: true }).buildLockingScript({})
-    script.toBuffer().length.should.be.greaterThan(0)
-  })
-
-  it('SmartContract.Builder.createCovenant throws by default', function () {
-    ;(function () {
-      new SC.Builder(key).createCovenant({ satoshis: 1000, script: '00' })
-    }).should.throw(/NON-ENFORCING|allowNonEnforcing/)
-  })
-
-  it('the enforcing path (ordinalLock / valueCovenant) still produces scripts', function () {
-    SC.ordinalLock(bsv.SmartContract.Token.ownerId(key)).toBuffer().length.should.be.greaterThan(0)
-    SC.valueCovenant(Buffer.alloc(32)).toBuffer().length.should.be.greaterThan(0)
-  })
-})