@smartledger/bsv 7.5.8 → 7.6.1

package/test/regressions.js

@@ -0,0 +1,180 @@
+'use strict'
+
+/* global describe, it */
+
+// Regressions for three wrong calls that shipped through 7.5.8, each of which
+// no test exercised.
+//
+// Two were live: Transaction#fromObject threw on an input its own
+// checkArgument accepts, and OP_CHECKSEQUENCEVERIFY failed every script with a
+// misleading error. Those two tests fail on the unfixed code.
+//
+// The third — sFromPreimage's toBuffer call — is LATENT, and the tests say so
+// rather than pretending otherwise. See the note on that block.
+
+require('chai').should()
+var bsv = require('../')
+var BN = bsv.crypto.BN
+
+describe('regressions', function () {
+  describe('Transaction#fromObject with a Transaction', function () {
+    // `fromObject` read `transaction.toObject()` where it meant
+    // `arg.toObject()`, so the branch that exists specifically to accept a
+    // Transaction was the only branch that could not work. checkArgument
+    // admits the input; the next line threw TypeError on it.
+    it('accepts a Transaction, which its own checkArgument allows', function () {
+      var key = bsv.PrivateKey.fromRandom()
+      var source = new bsv.Transaction().to(key.toAddress(), 1000)
+
+      var copy = new bsv.Transaction().fromObject(source)
+
+      copy.outputs.length.should.equal(1)
+      copy.outputs[0].satoshis.should.equal(1000)
+      copy.toObject().should.deep.equal(source.toObject())
+    })
+
+    it('still accepts the plain object form', function () {
+      var key = bsv.PrivateKey.fromRandom()
+      var source = new bsv.Transaction().to(key.toAddress(), 1000)
+
+      var copy = new bsv.Transaction().fromObject(source.toObject())
+
+      copy.toObject().should.deep.equal(source.toObject())
+    })
+  })
+
+  describe('BN#toBuffer with the native signature', function () {
+    // lib/crypto/bn.js REPLACES toBuffer with an options-object form. Calling
+    // it with bn.js's native (endian, length) signature silently ignores the
+    // length: 'be' lands in `opts`, `opts.size` is undefined, and the result
+    // is the natural-length buffer.
+    it('pads to the requested size when given the options form', function () {
+      // Leading zero byte, so the natural encoding is shorter than 32.
+      var n = new BN('00ff' + '11'.repeat(30), 'hex')
+
+      n.toBuffer({ size: 32 }).length.should.equal(32)
+    })
+
+    it('does NOT honour a positional length, which is why the options form is required', function () {
+      var n = new BN('00ff' + '11'.repeat(30), 'hex')
+
+      // Documents the trap rather than endorsing it: this is the call shape
+      // that produced a 31-byte s inside the OP_PUSH_TX grind.
+      n.toBuffer('be', 32).length.should.equal(31)
+    })
+  })
+
+  describe('PushTx.sFromPreimage uses the right toBuffer signature', function () {
+    // sFromPreimage called `s.toBuffer('be', 32)` — bn.js's NATIVE signature,
+    // against a toBuffer that lib/crypto/bn.js has replaced with an
+    // options-object form. The length argument was therefore ignored.
+    //
+    // This is a latent defect, NOT a live one, and the distinction is worth
+    // stating precisely: the truncation is currently unreachable. `s` is
+    // (HASH256(preimage) + Gx) mod n, and the caller has already required the
+    // hash's leading byte to be 0x01..0x7f, so z is in [2**248, 2**255).
+    // Adding Gx (about 0.476 * 2**256) never wraps, and the low-S filter caps
+    // the result at n/2 — confining s to a narrow band whose leading byte is
+    // always 0x7a..0x7f. It can never be zero, so the natural encoding is
+    // always 32 bytes anyway.
+    //
+    // The fix is worth making because the correctness of the output currently
+    // depends on two upstream filters that have nothing to do with buffer
+    // length. Change the MINIMALDATA range or drop the low-S requirement and
+    // the truncation becomes reachable, silently, in a covenant.
+    it('always returns exactly 32 bytes', function () {
+      var PushTx = bsv.SmartContract.PushTx
+      var accepted = 0
+
+      for (var i = 0; i < 4000; i++) {
+        var preimage = bsv.crypto.Hash.sha256(Buffer.from('grind-' + i))
+        var sBE = PushTx.sFromPreimage(preimage)
+        if (sBE) {
+          accepted++
+          sBE.length.should.equal(32)
+        }
+      }
+
+      accepted.should.be.above(0)
+    })
+
+    it('keeps s inside the band that makes the length safe', function () {
+      // Pins the property the paragraph above relies on. If this ever fails,
+      // the toBuffer call shape matters again — and the fix is already in.
+      var PushTx = bsv.SmartContract.PushTx
+
+      for (var i = 0; i < 2000; i++) {
+        var preimage = bsv.crypto.Hash.sha256(Buffer.from('band-' + i))
+        var sBE = PushTx.sFromPreimage(preimage)
+        if (sBE) {
+          sBE[0].should.be.within(0x01, 0x7f)
+        }
+      }
+    })
+  })
+
+  describe('OP_CHECKSEQUENCEVERIFY', function () {
+    // checkSequence masked with `nSequence.and(nLockTimeMask)` where the mask
+    // is a plain number. bn.js `and` requires a BN, so it threw
+    // 'num.clone is not a function'; the interpreter's try/catch swallowed
+    // that and reported SCRIPT_ERR_UNKNOWN_ERROR, making every CSV script fail
+    // with a misleading error.
+    //
+    // Note this is only reachable with SCRIPT_VERIFY_CHECKSEQUENCEVERIFY set:
+    // post-Genesis BSV reverted CSV to OP_NOP3 and the flag is off by default.
+    it('evaluates instead of failing with SCRIPT_ERR_UNKNOWN_ERROR', function () {
+      var Interpreter = bsv.Script.Interpreter
+      var key = bsv.PrivateKey.fromRandom()
+      var address = key.toAddress()
+      var prev = new bsv.Transaction().to(address, 1000)
+      var spend = new bsv.Transaction().from({
+        txId: prev.hash,
+        outputIndex: 0,
+        script: bsv.Script.buildPublicKeyHashOut(address).toHex(),
+        satoshis: 1000
+      })
+      spend.version = 2
+      spend.inputs[0].sequenceNumber = 20
+
+      var interpreter = new Interpreter()
+      var verified = interpreter.verify(
+        bsv.Script.fromASM('OP_1'),
+        bsv.Script.fromASM('OP_10 OP_CHECKSEQUENCEVERIFY'),
+        spend, 0,
+        Interpreter.SCRIPT_VERIFY_CHECKSEQUENCEVERIFY,
+        new BN(1000)
+      )
+
+      interpreter.errstr.should.equal('')
+      verified.should.equal(true)
+    })
+
+    it('still rejects a sequence that does not satisfy the requirement', function () {
+      var Interpreter = bsv.Script.Interpreter
+      var key = bsv.PrivateKey.fromRandom()
+      var address = key.toAddress()
+      var prev = new bsv.Transaction().to(address, 1000)
+      var spend = new bsv.Transaction().from({
+        txId: prev.hash,
+        outputIndex: 0,
+        script: bsv.Script.buildPublicKeyHashOut(address).toHex(),
+        satoshis: 1000
+      })
+      spend.version = 2
+      // Below the required relative locktime of 10.
+      spend.inputs[0].sequenceNumber = 5
+
+      var interpreter = new Interpreter()
+      var verified = interpreter.verify(
+        bsv.Script.fromASM('OP_1'),
+        bsv.Script.fromASM('OP_10 OP_CHECKSEQUENCEVERIFY'),
+        spend, 0,
+        Interpreter.SCRIPT_VERIFY_CHECKSEQUENCEVERIFY,
+        new BN(1000)
+      )
+
+      verified.should.equal(false)
+      interpreter.errstr.should.equal('SCRIPT_ERR_UNSATISFIED_LOCKTIME')
+    })
+  })
+})

package/test/script/interpreter.js

@@ -15,6 +15,26 @@ var scriptTests = require('../data/bitcoind/script_tests')
 var txValid = require('../data/bitcoind/tx_valid')
 var txInvalid = require('../data/bitcoind/tx_invalid')
 
+/**
+ * Bitcoin Core names for the bytes BSV reassigned at Chronicle.
+ *
+ * The vendored script_tests.json is a faithful upstream copy and is never edited, so it
+ * still says NOP4..NOP8 — names this library no longer defines, because 0xb3-0xb7 now
+ * carry OP_SUBSTR/OP_LEFT/OP_RIGHT/OP_LSHIFTNUM/OP_RSHIFTNUM.
+ *
+ * Resolving them to Core's BYTES keeps each vector assembling the exact script Core
+ * meant, so the comparison stays honest: same bytes in, different BSV verdict out.
+ * Letting them fail to parse would turn a documented consensus divergence into an
+ * opaque harness error.
+ */
+var CORE_ONLY_OPCODES = {
+  OP_NOP4: 0xb3,
+  OP_NOP5: 0xb4,
+  OP_NOP6: 0xb5,
+  OP_NOP7: 0xb6,
+  OP_NOP8: 0xb7
+}
+
 // the script string format used in bitcoind data tests
 Script.fromBitcoindString = function (str) {
   var bw = new BufferWriter()
@@ -40,6 +60,8 @@ Script.fromBitcoindString = function (str) {
       opstr = 'OP_' + token
       opcodenum = Opcode[opstr]
       bw.writeUInt8(opcodenum)
+    } else if (typeof CORE_ONLY_OPCODES['OP_' + token] === 'number') {
+      bw.writeUInt8(CORE_ONLY_OPCODES['OP_' + token])
     } else if (typeof Opcode[token] === 'number') {
       opstr = token
       opcodenum = Opcode[opstr]
@@ -618,9 +640,15 @@ describe('Interpreter', function () {
   //    the surrounding `0 IF <op> ELSE 1 ENDIF` form fails under upstream only
   //    because disabled opcodes are rejected even in unexecuted branches; once
   //    enabled, the branch is simply skipped and the script is 'OK'.)
-  //  - 0xba is OP_NOP8 in this build's opcode table (the NOPs are shifted to
-  //    make room for the OP_SUBSTR/OP_LEFT/OP_RIGHT string ops at 0xb3-0xb5;
-  //    see lib/opcode.js), so `1 0xba` is a valid no-op, not 'BAD_OPCODE'.
+  //  - Chronicle reassigned 0xb3-0xb7 to OP_SUBSTR/OP_LEFT/OP_RIGHT/OP_LSHIFTNUM/
+  //    OP_RSHIFTNUM, so Core's NOP4..NOP8 no longer exist as no-ops. Vectors that
+  //    expect those bytes to do nothing now fail here: 0xb3-0xb5 consume stack as
+  //    string ops (INVALID_STACK_OPERATION), and 0xb6/0xb7 are rejected outright
+  //    (BAD_OPCODE) because the shift SEMANTICS are deliberately unimplemented —
+  //    the spec underdetermines them, and validating wrongly is worse than
+  //    refusing. This is a real consensus divergence from Core, not a quirk.
+  //    (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 = {
     "'a' 'b'|CAT|P2SH,STRICTENC": 'OK',
     "'a' 'b' 0|IF CAT ELSE 1 ENDIF|P2SH,STRICTENC": 'OK',
@@ -635,7 +663,18 @@ describe('Interpreter', function () {
     '2 2 0 IF MOD ELSE 1 ENDIF|NOP|P2SH,STRICTENC': 'OK',
     '2 DUP DIV|1 EQUAL|P2SH,STRICTENC': 'OK',
     '7 3 MOD|1 EQUAL|P2SH,STRICTENC': 'OK',
-    '1|0xba|P2SH,STRICTENC': 'OK'
+
+    // Chronicle byte reassignment (see the note above). Values are the BSV error,
+    // recorded for documentation; the harness only distinguishes 'OK' from not-'OK'.
+    '1|NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 NOP10 1 EQUAL|P2SH,STRICTENC': 'SCRIPT_ERR_INVALID_STACK_OPERATION',
+    "'NOP_1_to_10' NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 NOP10|'NOP_1_to_10' EQUAL|P2SH,STRICTENC": 'SCRIPT_ERR_INVALID_STACK_OPERATION',
+    'NOP|NOP4 1|P2SH,STRICTENC': 'SCRIPT_ERR_INVALID_STACK_OPERATION',
+    'NOP|NOP5 1|P2SH,STRICTENC': 'SCRIPT_ERR_INVALID_STACK_OPERATION',
+    'NOP|NOP6 1|P2SH,STRICTENC': 'SCRIPT_ERR_INVALID_STACK_OPERATION',
+    'NOP|NOP7 1|P2SH,STRICTENC': 'SCRIPT_ERR_BAD_OPCODE',
+    'NOP|NOP8 1|P2SH,STRICTENC': 'SCRIPT_ERR_BAD_OPCODE',
+    '0x47 0x3044022018a2a81a93add5cb5f5da76305718e4ea66045ec4888b28d84cb22fae7f4645b02201e6daa5ed5d2e4b2b2027cf7ffd43d8d9844dd49f74ef86899ec8e669dfd39aa01 NOP8 0x23 0x2103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640ac|HASH160 0x14 0x215640c2f72f0d16b4eced26762035a42ffed39a EQUAL|': 'SCRIPT_ERR_BAD_OPCODE',
+    '0x47 0x304402203e4516da7253cf068effec6b95c41221c0cf3a8e6ccb8cbf1725b562e9afde2c022054e1c258c2981cdfba5df1f46661fb6541c44f77ca0092f3600331abfffb125101 NOP8|0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 CHECKSIG|': 'SCRIPT_ERR_BAD_OPCODE'
   }
 
   describe('bitcoind script evaluation fixtures', function () {

package/test/script/script.js

@@ -701,10 +701,11 @@ describe('Script', function () {
 
   describe('#add and #prepend', function () {
     it('should add these ops', function () {
-      // 186 (0xba) is OP_NOP8 in this build's opcode table — the NOPs are
-      // shifted up by 3 to make room for the OP_SUBSTR/OP_LEFT/OP_RIGHT string
-      // ops at 0xb3-0xb5 (see lib/opcode.js) — so it disassembles by name.
-      Script().add(1).add(10).add(186).toString().should.equal('0x01 0x0a OP_NOP8')
+      // 185 (0xb9) is OP_NOP10, the highest byte Chronicle still assigns, so it
+      // disassembles by name. 186 is unassigned and renders as a raw byte — the
+      // NOP names are no longer slid upward past 185 (see lib/opcode.js).
+      Script().add(1).add(10).add(185).toString().should.equal('0x01 0x0a OP_NOP10')
+      Script().add(1).add(10).add(186).toString().should.equal('0x01 0x0a 0xba')
       Script().add(1000).toString().should.equal('0x03e8')
       Script().add('OP_CHECKMULTISIG').toString().should.equal('OP_CHECKMULTISIG')
       Script().add('OP_1').add('OP_2').toString().should.equal('OP_1 OP_2')

package/version.js

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