@smartledger/bsv 9.10.0 → 9.11.0

package/lib/script/script.js

@@ -1,8 +1,9 @@
 'use strict'
 
+var assert = require('assert')
+
 var Address = require('../address')
 var BufferReader = require('../encoding/bufferreader')
-var BufferWriter = require('../encoding/bufferwriter')
 var Hash = require('../crypto/hash')
 var Opcode = require('../opcode')
 var PublicKey = require('../publickey')
@@ -107,29 +108,59 @@ Script.fromBuffer = function (buffer) {
 }
 
 Script.prototype.toBuffer = function () {
-  var bw = new BufferWriter()
+  // Sized first and written into one allocation. A locking script can have
+  // hundreds of thousands of chunks, and this runs for every signature check
+  // over it; a writer that allocates per chunk made that the dominant cost.
+  // Writes go through Buffer's checked writers, so a malformed chunk throws
+  // exactly where the per-chunk writer threw.
+  var chunks = this.chunks
+  var size = 0
+  var i, chunk, opcodenum
+  for (i = 0; i < chunks.length; i++) {
+    chunk = chunks[i]
+    opcodenum = chunk.opcodenum
+    size += 1
+    if (chunk.buf) {
+      if (opcodenum < Opcode.OP_PUSHDATA1) {
+        size += bufLength(chunk.buf)
+      } else if (opcodenum === Opcode.OP_PUSHDATA1) {
+        size += 1 + bufLength(chunk.buf)
+      } else if (opcodenum === Opcode.OP_PUSHDATA2) {
+        size += 2 + bufLength(chunk.buf)
+      } else if (opcodenum === Opcode.OP_PUSHDATA4) {
+        size += 4 + bufLength(chunk.buf)
+      }
+    }
+  }
 
-  for (var i = 0; i < this.chunks.length; i++) {
-    var chunk = this.chunks[i]
-    var opcodenum = chunk.opcodenum
-    bw.writeUInt8(chunk.opcodenum)
+  var out = Buffer.alloc(size)
+  var o = 0
+  for (i = 0; i < chunks.length; i++) {
+    chunk = chunks[i]
+    opcodenum = chunk.opcodenum
+    o = out.writeUInt8(chunk.opcodenum, o)
     if (chunk.buf) {
       if (opcodenum < Opcode.OP_PUSHDATA1) {
-        bw.write(chunk.buf)
+        o += chunk.buf.copy(out, o)
       } else if (opcodenum === Opcode.OP_PUSHDATA1) {
-        bw.writeUInt8(chunk.len)
-        bw.write(chunk.buf)
+        o = out.writeUInt8(chunk.len, o)
+        o += chunk.buf.copy(out, o)
       } else if (opcodenum === Opcode.OP_PUSHDATA2) {
-        bw.writeUInt16LE(chunk.len)
-        bw.write(chunk.buf)
+        o = out.writeUInt16LE(chunk.len, o)
+        o += chunk.buf.copy(out, o)
       } else if (opcodenum === Opcode.OP_PUSHDATA4) {
-        bw.writeUInt32LE(chunk.len)
-        bw.write(chunk.buf)
+        o = out.writeUInt32LE(chunk.len, o)
+        o += chunk.buf.copy(out, o)
       }
     }
   }
+  return out
+}
 
-  return bw.concat()
+// A chunk's data must be a Buffer; BufferWriter#write asserted as much.
+function bufLength (buf) {
+  if (!Buffer.isBuffer(buf)) throw new assert.AssertionError({ message: 'chunk data must be a Buffer', actual: buf, expected: 'Buffer', operator: 'isBuffer' })
+  return buf.length
 }
 
 Script.fromASM = function (str) {
@@ -1081,20 +1112,40 @@ Script.prototype.toAddress = function (network) {
  */
 Script.prototype.findAndDelete = function (script) {
   var buf = script.toBuffer()
-  var hex = buf.toString('hex')
+  // A chunk serializes to bytes starting with its opcode, so only chunks whose
+  // opcode is the first byte of `buf` can match. Every other chunk is still
+  // serialized when its encoding would throw, so malformed input fails as it
+  // always did.
+  var first = buf.length ? buf[0] : -1
   for (var i = 0; i < this.chunks.length; i++) {
-    var script2 = Script({
-      chunks: [this.chunks[i]]
-    })
-    var buf2 = script2.toBuffer()
-    var hex2 = buf2.toString('hex')
-    if (hex === hex2) {
+    var chunk = this.chunks[i]
+    if (chunk.opcodenum !== first && serializesCleanly(chunk)) continue
+    var buf2 = Script({
+      chunks: [chunk]
+    }).toBuffer()
+    if (buf.equals(buf2)) {
+      // Look at the chunk that slid into this position too: CScript::FindAndDelete
+      // removes consecutive occurrences.
       this.chunks.splice(i, 1)
+      i--
     }
   }
   return this
 }
 
+function serializesCleanly (chunk) {
+  var op = chunk.opcodenum
+  if (typeof op !== 'number' || !Number.isInteger(op) || op < 0 || op > 255) return false
+  if (!chunk.buf) return true
+  if (op > Opcode.OP_PUSHDATA4) return true
+  if (!Buffer.isBuffer(chunk.buf)) return false
+  var len = chunk.len
+  if (op === Opcode.OP_PUSHDATA1) return Number.isInteger(len) && len >= 0 && len <= 0xff
+  if (op === Opcode.OP_PUSHDATA2) return Number.isInteger(len) && len >= 0 && len <= 0xffff
+  if (op === Opcode.OP_PUSHDATA4) return Number.isInteger(len) && len >= 0 && len <= 0xffffffff
+  return true
+}
+
 /**
  * Comes from bitcoind's script interpreter CheckMinimalPush function
  * @returns {boolean} if the chunk {i} is the smallest way to push that particular data.

package/lib/transaction/sighash.js

@@ -102,8 +102,9 @@ var sighashPreimageForForkId = function (transaction, sighashType, inputNumber,
   writer.writeUInt32LE(input.outputIndex)
 
   // scriptCode of the input (serialized as scripts inside CTxOuts)
-  writer.writeVarintNum(subscript.toBuffer().length)
-  writer.write(subscript.toBuffer())
+  var scriptCode = subscript.toBuffer()
+  writer.writeVarintNum(scriptCode.length)
+  writer.write(scriptCode)
 
   // value of the output spent by this input (8-byte little endian)
   writer.writeUInt64LEBN(satoshisBN)
@@ -148,8 +149,13 @@ var sighashPreimage = function sighashPreimage (transaction, sighashType, inputN
   // Copy transaction
   var txcopy = Transaction.shallowCopy(transaction)
 
-  // Copy script
-  subscript = new Script(subscript)
+  // The BIP-143 path below only reads the script. The original algorithm
+  // modifies it, so it takes its own copy there; copying a large script up
+  // front cost more than the whole digest. Anything that is not a Script yet
+  // is converted, as the copy did.
+  if (!(subscript instanceof Script)) {
+    subscript = new Script(subscript)
+  }
 
   if (flags & Interpreter.SCRIPT_ENABLE_REPLAY_PROTECTION) {
     // Legacy chain's value for fork id must be of the form 0xffxxxx.
@@ -192,7 +198,8 @@ var sighashPreimage = function sighashPreimage (transaction, sighashType, inputN
     return sighashPreimageForForkId(txcopy, sighashType, inputNumber, subscript, satoshisBN)
   }
 
-  // For no ForkId sighash, separators need to be removed.
+  // For no ForkId sighash, separators need to be removed — from a copy.
+  subscript = new Script(subscript)
   subscript.removeCodeseparators()
 
   var i

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartledger/bsv",
-  "version": "9.10.0",
+  "version": "9.11.0",
   "description": "Bitcoin SV library with an interpreter-verified script engine: OP_PUSH_TX covenants, BIP-143 preimage tooling, and consensus flags that match what miners actually enforce. Also ships DID:web / W3C VC-JWT credentials and the Legal Token Protocol.",
   "author": "SmartLedger Technology <hello@smartledger.technology> (https://smartledger.technology)",
   "homepage": "https://github.com/codenlighten/smartledger-bsv#readme",

package/version.js

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