@smartledger/bsv 8.3.0 → 9.0.0

package/test/ordinals/ordlock.js

@@ -24,16 +24,6 @@ var PRICE = 100000
 
 describe('Ordinals OrdLock marketplace', function () {
   this.timeout(20000)
-  var I = bsv.Script.Interpreter
-  var saved
-
-  before(function () {
-    saved = I.getLimits()
-    SC.enableGenesis()
-  })
-  after(function () {
-    I.setLimits(saved)
-  })
 
   var seller = PrivateKey.fromRandom()
   var buyer = PrivateKey.fromRandom()
@@ -168,15 +158,6 @@ describe('Ordinals OrdLock marketplace', function () {
 
 describe('Ordinals OrdLock — multi-output payments (royalties + marketplace fee)', function () {
   this.timeout(20000)
-  var I = bsv.Script.Interpreter
-  var saved
-  before(function () {
-    saved = I.getLimits()
-    SC.enableGenesis()
-  })
-  after(function () {
-    I.setLimits(saved)
-  })
 
   var seller = PrivateKey.fromRandom()
   var royalty = PrivateKey.fromRandom()
@@ -283,15 +264,6 @@ describe('Ordinals OrdLock — parseOrdLock (self-describing listings)', functio
 
 describe('Ordinals OrdLock — buildPurchaseTx (end-to-end)', function () {
   this.timeout(20000)
-  var I = bsv.Script.Interpreter
-  var saved
-  before(function () {
-    saved = I.getLimits()
-    SC.enableGenesis()
-  })
-  after(function () {
-    I.setLimits(saved)
-  })
 
   var seller = PrivateKey.fromRandom()
   var royalty = PrivateKey.fromRandom()
@@ -377,15 +349,6 @@ describe('Ordinals OrdLock — buildPurchaseTx (end-to-end)', function () {
 
 describe('Ordinals OrdLock — full lifecycle (list -> buy / cancel)', function () {
   this.timeout(20000)
-  var I = bsv.Script.Interpreter
-  var saved
-  before(function () {
-    saved = I.getLimits()
-    SC.enableGenesis()
-  })
-  after(function () {
-    I.setLimits(saved)
-  })
 
   var owner = PrivateKey.fromRandom() // current ordinal owner / seller
   var royalty = PrivateKey.fromRandom()
@@ -475,15 +438,6 @@ describe('Ordinals OrdLock — full lifecycle (list -> buy / cancel)', function
 
 describe('Ordinals OrdLock — code-review regressions', function () {
   this.timeout(20000)
-  var I = bsv.Script.Interpreter
-  var saved
-  before(function () {
-    saved = I.getLimits()
-    SC.enableGenesis()
-  })
-  after(function () {
-    I.setLimits(saved)
-  })
 
   var owner = PrivateKey.fromRandom()
   var fundKey = PrivateKey.fromRandom()

package/test/smart_contract/covenants.js

@@ -20,16 +20,6 @@ var SATS = 100000
 
 describe('SmartContract covenants (v4.2.0)', function () {
   this.timeout(20000)
-  var I = bsv.Script.Interpreter
-  var saved
-
-  before(function () {
-    saved = I.getLimits()
-    SC.enableGenesis() // OP_PUSH_TX covenants need post-Genesis limits
-  })
-  after(function () {
-    I.setLimits(saved)
-  })
 
   var alice = PrivateKey.fromRandom()
   var bob = PrivateKey.fromRandom()
@@ -59,40 +49,12 @@ describe('SmartContract covenants (v4.2.0)', function () {
       verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(true)
     })
 
-    it('CLTV accepts a matured spend and rejects an immature one', function () {
-      var lt = 800000
-      var c = Locks.timeLockCLTV(alice, lt)
-      var spend = spendOf(c.lock, SATS, [p2pkhOutput(alice, SATS - 500)])
-      spend.nLockTime = lt; spend.inputs[0].sequenceNumber = 0xfffffffe
-      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.nLockTime = lt - 1; spend.inputs[0].sequenceNumber = 0xfffffffe
-      spend.inputs[0].setScript(c.unlock(spend, SATS))
-      verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(false)
-    })
-
     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)
     })
-
-    it('HTLC supports claim and rejects an early refund', function () {
-      var secret = Buffer.from('lightning-preimage-32bytes------')
-      var timeout = 750000
-      var c = Locks.htlc({ secret: secret, receiver: bob, sender: alice, timeout: timeout })
-      var spend = spendOf(c.lock, SATS, [p2pkhOutput(bob, SATS - 500)])
-      spend.inputs[0].setScript(c.unlockClaim(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.nLockTime = timeout - 1; spend.inputs[0].sequenceNumber = 0xfffffffe
-      spend.inputs[0].setScript(c.unlockRefund(spend, SATS))
-      verify(spend.inputs[0].script, c.lock, { tx: spend, satoshis: SATS }).ok.should.equal(false)
-    })
   })
 
   describe('OP_PUSH_TX', function () {

package/test/smart_contract/dsl_debugger.js

@@ -14,15 +14,6 @@ var SATS = 100000
 
 describe('SmartContract covenant DSL + debugger (v4.5.0)', function () {
   this.timeout(20000)
-  var I = bsv.Script.Interpreter
-  var saved
-  before(function () {
-    saved = I.getLimits()
-    SC.enableGenesis()
-  })
-  after(function () {
-    I.setLimits(saved)
-  })
 
   var alice = PrivateKey.fromRandom()
   var attacker = PrivateKey.fromRandom()

package/test/smart_contract/ordinal_transfer.js

@@ -23,19 +23,9 @@ var verify = help.verify
 
 describe('Ordinal-safe transfer (1-sat, SIGHASH_ALL)', function () {
   this.timeout(20000)
-  var I = bsv.Script.Interpreter
-  var saved
   var alice = PrivateKey.fromRandom()
   var bob = PrivateKey.fromRandom()
 
-  before(function () {
-    saved = I.getLimits()
-    SC.enableGenesis()
-  })
-  after(function () {
-    I.setLimits(saved)
-  })
-
   it('transferOrdinal recreates the 1-sat token among funding outputs and verifies', function () {
     var lock = Token.ordinalLock(Token.ownerId(alice))
     var bobHash = Token.ownerId(bob)

package/test/smart_contract/sighash_marketplace.js

@@ -27,18 +27,8 @@ var SATS = 100000
 
 describe('Configurable SIGHASH — SINGLE|ANYONECANPAY marketplace covenant', function () {
   this.timeout(20000)
-  var I = bsv.Script.Interpreter
-  var saved
   var flag = P.SIGHASH_SINGLE_ANYONECANPAY_FORKID // 0xc3
 
-  before(function () {
-    saved = I.getLimits()
-    SC.enableGenesis()
-  })
-  after(function () {
-    I.setLimits(saved)
-  })
-
   // Lock: authenticate the pushed preimage under `flag`, assert the flag, succeed.
   function makeLock () {
     var lock = new Script()

package/test/smart_contract/token_generalized.js

@@ -20,16 +20,6 @@ var FEE = 500
 
 describe('SmartContract generalized token (pluggable auth + multi-output)', function () {
   this.timeout(20000)
-  var I = bsv.Script.Interpreter
-  var saved
-
-  before(function () {
-    saved = I.getLimits()
-    SC.enableGenesis()
-  })
-  after(function () {
-    I.setLimits(saved)
-  })
 
   function spendOf (lock, sats, outputs) {
     return fundAndSpend(lock, sats, { outputs: outputs }).spend

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.0'
+module.exports = '9.0.0'