Merge pull request #265 from sCrypt-Inc/hash-cache

zhfnjust · web-flow · commit 732660076bce · 2024-04-26T16:25:59.000+08:00
add hash cache
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "scryptlib",
-  "version": "2.1.41",
+  "version": "2.1.42",
   "description": "Javascript SDK for integration of Bitcoin SV Smart Contracts written in sCrypt language.",
   "engines": {
     "node": ">=14.0.0"
@@ -76,4 +76,4 @@
     "yargs": "^17.6.2",
     "chalk": "2.4.2"
   }
-}
+}
diff --git a/patches/bsv/index.d.ts b/patches/bsv/index.d.ts
@@ -753,24 +753,16 @@ declare module 'bsv' {
         }
 
         class Point {
-            constructor(x: crypto.BN | string,
-                y: crypto.BN | string,
-                isRed: boolean);
-
             static fromX(odd: boolean, x: crypto.BN | string): Point;
             static getG(): any;
             static getN(): crypto.BN;
             getX(): crypto.BN;
             getY(): crypto.BN;
             validate(): this;
             mul(n: crypto.BN): Point;
-            add(n: crypto.Point): Point;
-            neg(): Point;
         }
 
         class Signature {
-            constructor(r: crypto.BN, s: crypto.BN);
-
             static fromDER(sig: Buffer): Signature;
             static fromTxFormat(buf: Buffer): Signature;
             static fromString(data: string): Signature;
@@ -873,15 +865,17 @@ declare module 'bsv' {
                 inputNumber: number,
                 subscript: Script,
                 satoshisBN: crypto.BN,
-                flags?: number
+                flags?: number,
+                hashCache?: HashCache
             ): Buffer;
             function sighash(
                 transaction: Transaction,
                 sighashType: number,
                 inputNumber: number,
                 subscript: Script,
                 satoshisBN: crypto.BN,
-                flags?: number
+                flags?: number,
+                hashCache?: HashCache
             ): Buffer;
             function sign(
                 transaction: Transaction,
@@ -890,7 +884,8 @@ declare module 'bsv' {
                 inputIndex: number,
                 subscript: Script,
                 satoshisBN: crypto.BN,
-                flags?: number
+                flags?: number,
+                hashCache?: HashCache
             ): crypto.Signature;
             function verify(
                 transaction: Transaction,
@@ -899,7 +894,8 @@ declare module 'bsv' {
                 inputIndex: number,
                 subscript: Script,
                 satoshisBN: crypto.BN,
-                flags?: number
+                flags?: number,
+                hashCache?: HashCache
             ): boolean;
         }
     }
@@ -1486,4 +1482,20 @@ declare module 'bsv' {
             flags: Array<number>;
         };
     }
-}
+
+    export class HashCache {
+        constructor(
+            prevoutsHashBuf?: Buffer,
+            sequenceHashBuf?: Buffer,
+            outputsHashBuf?: Buffer
+        )
+
+        static fromBuffer(buf: Buffer): HashCache
+        static fromJSON(json: object): HashCache
+        static fromHex(hex: string): HashCache
+        
+        toBuffer(): HashCache
+        toJSON(): HashCache
+        toHex(): HashCache
+    }
+}
diff --git a/patches/bsv/index.js b/patches/bsv/index.js
@@ -55,6 +55,7 @@ bsv.PublicKey = require('./lib/publickey')
 bsv.Script = require('./lib/script')
 bsv.Transaction = require('./lib/transaction')
 bsv.ECIES = require('./lib/ecies')
+bsv.HashCache = require('./lib/hash-cache')
 
 // dependencies, subject to change
 bsv.deps = {}
diff --git a/patches/bsv/lib/hash-cache.js b/patches/bsv/lib/hash-cache.js
@@ -0,0 +1,50 @@
+/**
+ * Hash Cache
+ * ==========
+ *
+ * For use in sighash.
+ */
+'use strict'
+
+class HashCache {
+  constructor (prevoutsHashBuf, sequenceHashBuf, outputsHashBuf) {
+    this.prevoutsHashBuf = prevoutsHashBuf
+    this.sequenceHashBuf = sequenceHashBuf
+    this.outputsHashBuf = outputsHashBuf
+  }
+
+  static fromBuffer (buf) {
+    return HashCache.fromJSON(JSON.parse(buf.toString()))
+  }
+
+  toBuffer () {
+    return Buffer.from(JSON.stringify(this.toJSON()))
+  }
+
+  static fromJSON (json) {
+    return new HashCache(
+      json.prevoutsHashBuf ? Buffer.from(json.prevoutsHashBuf, 'hex') : undefined,
+      json.sequenceHashBuf ? Buffer.from(json.sequenceHashBuf, 'hex') : undefined,
+      json.outputsHashBuf ? Buffer.from(json.outputsHashBuf, 'hex') : undefined
+    )
+  }
+
+  toJSON () {
+    return {
+      prevoutsHashBuf: this.prevoutsHashBuf ? this.prevoutsHashBuf.toString('hex') : undefined,
+      sequenceHashBuf: this.sequenceHashBuf ? this.sequenceHashBuf.toString('hex') : undefined,
+      outputsHashBuf: this.outputsHashBuf ? this.outputsHashBuf.toString('hex') : undefined
+    }
+  }
+
+  toHex () {
+    return this.toBuffer().toString('hex')
+  }
+
+  static fromHex (hex) {
+    const buf = Buffer.from(hex, 'hex')
+    return HashCache.fromBuffer(buf)
+  }
+}
+
+module.exports = HashCache
diff --git a/patches/bsv/lib/transaction/sighash.js b/patches/bsv/lib/transaction/sighash.js
@@ -13,14 +13,15 @@ var ECDSA = require('../crypto/ecdsa')
 var $ = require('../util/preconditions')
 var Interpreter = require('../script/interpreter')
 var _ = require('../util/_')
+var HashCache = require('../hash-cache')
 
 var SIGHASH_SINGLE_BUG = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex')
 var BITS_64_ON = 'ffffffffffffffff'
 
 // By default, we sign with sighash_forkid
 var DEFAULT_SIGN_FLAGS = Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
 
-var sighashPreimageForForkId = function (transaction, sighashType, inputNumber, subscript, satoshisBN) {
+var sighashPreimageForForkId = function (transaction, sighashType, inputNumber, subscript, satoshisBN, hashCache = new HashCache()) {
   var input = transaction.inputs[inputNumber]
   $.checkArgument(
     satoshisBN instanceof BN,
@@ -73,17 +74,17 @@ var sighashPreimageForForkId = function (transaction, sighashType, inputNumber,
   var hashOutputs = Buffer.alloc(32)
 
   if (!(sighashType & Signature.SIGHASH_ANYONECANPAY)) {
-    hashPrevouts = GetPrevoutHash(transaction)
+    hashPrevouts = hashCache.prevoutsHashBuf ? hashCache.prevoutsHashBuf : hashCache.prevoutsHashBuf = GetPrevoutHash(transaction)
   }
 
   if (!(sighashType & Signature.SIGHASH_ANYONECANPAY) &&
     (sighashType & 31) !== Signature.SIGHASH_SINGLE &&
     (sighashType & 31) !== Signature.SIGHASH_NONE) {
-    hashSequence = GetSequenceHash(transaction)
+    hashSequence = hashCache.sequenceHashBuf ? hashCache.sequenceHashBuf : hashCache.sequenceHashBuf = GetSequenceHash(transaction)
   }
 
   if ((sighashType & 31) !== Signature.SIGHASH_SINGLE && (sighashType & 31) !== Signature.SIGHASH_NONE) {
-    hashOutputs = GetOutputsHash(transaction)
+    hashOutputs = hashCache.outputsHashBuf ? hashCache.outputsHashBuf : hashCache.outputsHashBuf = GetOutputsHash(transaction)
   } else if ((sighashType & 31) === Signature.SIGHASH_SINGLE && inputNumber < transaction.outputs.length) {
     hashOutputs = GetOutputsHash(transaction, inputNumber)
   }
@@ -136,7 +137,7 @@ var sighashPreimageForForkId = function (transaction, sighashType, inputNumber,
  * @param {satoshisBN} input's amount (for  ForkId signatures)
  *
  */
-var sighashPreimage = function sighashPreimage (transaction, sighashType, inputNumber, subscript, satoshisBN, flags) {
+var sighashPreimage = function sighashPreimage (transaction, sighashType, inputNumber, subscript, satoshisBN, flags, hashCache = new HashCache()) {
   var Transaction = require('./transaction')
   var Input = require('./input')
 
@@ -227,8 +228,8 @@ var sighashPreimage = function sighashPreimage (transaction, sighashType, inputN
  * @param {satoshisBN} input's amount (for  ForkId signatures)
  *
  */
-var sighash = function sighash (transaction, sighashType, inputNumber, subscript, satoshisBN, flags) {
-  var preimage = sighashPreimage(transaction, sighashType, inputNumber, subscript, satoshisBN, flags)
+var sighash = function sighash (transaction, sighashType, inputNumber, subscript, satoshisBN, flags, hashCache = new HashCache()) {
+  var preimage = sighashPreimage(transaction, sighashType, inputNumber, subscript, satoshisBN, flags, hashCache)
   if (preimage.compare(SIGHASH_SINGLE_BUG) === 0) return preimage
   var ret = Hash.sha256sha256(preimage)
   ret = new BufferReader(ret).readReverse()
@@ -247,8 +248,8 @@ var sighash = function sighash (transaction, sighashType, inputNumber, subscript
  * @param {satoshisBN} input's amount
  * @return {Signature}
  */
-function sign (transaction, privateKey, sighashType, inputIndex, subscript, satoshisBN, flags) {
-  var hashbuf = sighash(transaction, sighashType, inputIndex, subscript, satoshisBN, flags)
+function sign (transaction, privateKey, sighashType, inputIndex, subscript, satoshisBN, flags, hashCache = new HashCache()) {
+  var hashbuf = sighash(transaction, sighashType, inputIndex, subscript, satoshisBN, flags, hashCache)
 
   var sig = ECDSA.sign(hashbuf, privateKey, 'little').set({
     nhashtype: sighashType
@@ -269,10 +270,10 @@ function sign (transaction, privateKey, sighashType, inputIndex, subscript, sato
  * @param {flags} verification flags
  * @return {boolean}
  */
-function verify (transaction, signature, publicKey, inputIndex, subscript, satoshisBN, flags) {
+function verify (transaction, signature, publicKey, inputIndex, subscript, satoshisBN, flags, hashCache = new HashCache()) {
   $.checkArgument(!_.isUndefined(transaction))
   $.checkArgument(!_.isUndefined(signature) && !_.isUndefined(signature.nhashtype))
-  var hashbuf = sighash(transaction, signature.nhashtype, inputIndex, subscript, satoshisBN, flags)
+  var hashbuf = sighash(transaction, signature.nhashtype, inputIndex, subscript, satoshisBN, flags, hashCache)
   return ECDSA.verify(hashbuf, signature, publicKey, 'little')
 }
 
diff --git a/src/utils.ts b/src/utils.ts
@@ -165,7 +165,16 @@ export function hexStringToBytes(hex: string): number[] {
 }
 
 
-export function signTx(tx: bsv.Transaction, privateKey: bsv.PrivateKey, lockingScript: Script, inputAmount: number, inputIndex = 0, sighashType = DEFAULT_SIGHASH_TYPE, flags = DEFAULT_FLAGS): string {
+export function signTx(
+  tx: bsv.Transaction,
+  privateKey: bsv.PrivateKey,
+  lockingScript: Script,
+  inputAmount: number,
+  inputIndex = 0,
+  sighashType = DEFAULT_SIGHASH_TYPE,
+  flags = DEFAULT_FLAGS,
+  hashCache?: bsv.HashCache
+): string {
 
   if (!tx) {
     throw new Error('param tx can not be empty');
@@ -189,7 +198,7 @@ export function signTx(tx: bsv.Transaction, privateKey: bsv.PrivateKey, lockingS
 
   return toHex(bsv.Transaction.Sighash.sign(
     tx, privateKey, sighashType, inputIndex,
-    lockingScript, new bsv.crypto.BN(inputAmount), flags
+    lockingScript, new bsv.crypto.BN(inputAmount), flags, hashCache
   ).toTxFormat());
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "scryptlib",`
`3`		`- "version": "2.1.41",`
	`3`	`+ "version": "2.1.42",`
`4`	`4`	`"description": "Javascript SDK for integration of Bitcoin SV Smart Contracts written in sCrypt language.",`
`5`	`5`	`"engines": {`
`6`	`6`	`"node": ">=14.0.0"`
`@@ -76,4 +76,4 @@`
`76`	`76`	`"yargs": "^17.6.2",`
`77`	`77`	`"chalk": "2.4.2"`
`78`	`78`	`}`
`79`		`-}`
	`79`	`+}`