update bsv

patches/bsv/index.d.ts

@@ -344,7 +344,10 @@ declare module 'bsv' {
             readonly satoshis: number;
             readonly satoshisBN: crypto.BN;
             spentTxId: string | null;
-            constructor(data: object);
+            constructor(data: {
+                script: Script,
+                satoshis: number
+            });
 
             setScript(script: Script | string | Buffer): this;
             inspect(): string;
@@ -362,12 +365,14 @@ declare module 'bsv' {
             constructor(params: object);
             isValidSignature(tx: Transaction, sig: any): boolean;
             setScript(script: Script): this;
+            getSignatures(tx: Transaction, privateKey: PrivateKey, inputIndex: number, sigtype?: number): any;
+            getPreimage(tx: Transaction, inputIndex: number, sigtype?: number, isLowS?: boolean): any;
         }
 
 
         namespace Input {
             class PublicKeyHash extends Input {
-            
+
             }
         }
 
@@ -464,7 +469,7 @@ declare module 'bsv' {
         getLockTime(): Date | number;
         setLockTime(t: number): void;
 
-        verify(): string | boolean;
+        verify(): string | true;
         isCoinbase(): boolean;
 
         enableRBF(): this;
@@ -489,15 +494,30 @@ declare module 'bsv' {
             privateKey?: PrivateKey,
             sigtype?: number,
             isLowS?: boolean
-        }, unlockingScript: Script | ((tx: Transaction, outputInPrevTx: Transaction.Output, preimage: string, signature: string) => Script)): this;
+        }, unlockingScript: Script | ((tx: Transaction, outputInPrevTx: Transaction.Output) => Script)): this;
         setInputSequence(inputIndex: number, sequence: number): this;
         setOutput(outputIndex: number, output: Transaction.Output | ((tx: Transaction) => Transaction.Output)): this;
-        seal(): void;
+        seal(): this;
         isSealed(): boolean;
         getChangeAmount(): number;
         getEstimateFee(): number;
         checkFeeRate(feePerKb?: number): boolean;
         prevouts(): string;
+        getSignature(inputIndex: number, privateKey?: PrivateKey, sigtype?: number): string;
+        getPreimage(inputIndex: number, sigtype?: number, isLowS?: boolean): string;
+        addInputFromPrevTx(prevTx: Transaction, outputIndex?: number): this;
+        addDummyInput(script: Script, satoshis: number): this;
+        verifyInput(inputIndex: number, cb?: (execution: {
+            success: boolean,
+            error: string,
+            failedAt: any
+        }) => string): {
+            success: boolean,
+            error: string,
+            failedAt: any
+        };
+        getInputAmount(inputIndex: number): number;
+        getOutputAmount(outputIndex: number): number;
     }
 
     export class ECIES {

patches/bsv/lib/errors/spec.js

@@ -66,6 +66,9 @@ module.exports = [{
     }, {
       name: 'MissingPreviousOutput',
       message: 'No previous output information.'
+    }, {
+      name: 'MissingInput',
+      message: 'Invalid inputIndex.'
     }]
   }, {
     name: 'NeedMoreInfo',
@@ -88,6 +91,9 @@ module.exports = [{
   }, {
     name: 'DustOutputs',
     message: 'Dust amount detected in one output'
+  }, {
+    name: 'MissingOutput',
+    message: 'Output not found'
   }, {
     name: 'InvalidSatoshis',
     message: 'Output satoshis are invalid'

patches/bsv/lib/transaction/input/input.js

@@ -9,12 +9,32 @@ var JSUtil = require('../../util/js')
 var Script = require('../../script')
 var Sighash = require('../sighash')
 var Output = require('../output')
+var Signature = require('../../crypto/signature')
+var TransactionSignature = require('../signature')
+var Hash = require('../../crypto/hash')
+var Interpreter = require('../../script/interpreter')
+var Opcode = require('../../opcode')
 
 var MAXINT = 0xffffffff // Math.pow(2, 32) - 1;
 var DEFAULT_RBF_SEQNUMBER = MAXINT - 2
 var DEFAULT_SEQNUMBER = MAXINT
 var DEFAULT_LOCKTIME_SEQNUMBER = MAXINT - 1
 
+function getLowSPreimage (tx, sigtype, inputIndex, inputLockingScript, inputAmount) {
+  var i = 0
+  do {
+    var preimage = Sighash.sighashPreimage(tx, sigtype, inputIndex, inputLockingScript, inputAmount)
+
+    var sighash = Hash.sha256sha256(preimage)
+
+    if (_.isPositiveNumber(sighash.readUInt8()) && _.isPositiveNumber(sighash.readUInt8(31))) {
+      return preimage
+    }
+
+    tx.nLockTime++
+  } while (i < Number.MAX_SAFE_INTEGER)
+}
+
 function Input (params) {
   if (!(this instanceof Input)) {
     return new Input(params)
@@ -146,17 +166,38 @@ Input.prototype.setScript = function (script) {
  * @param {Transaction} transaction - the transaction to be signed
  * @param {PrivateKey} privateKey - the private key to use when signing
  * @param {number} inputIndex - the index of this input in the provided transaction
- * @param {number} sigType - defaults to Signature.SIGHASH_ALL
- * @param {Buffer} addressHash - if provided, don't calculate the hash of the
- *     public key associated with the private key provided
+ * @param {number} sigType - defaults to Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID
+ * @abstract
+ */
+Input.prototype.getSignatures = function (transaction, privateKey, inputIndex, sigtype) {
+  $.checkState(this.output instanceof Output)
+  sigtype = sigtype || (Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID)
+  return [new TransactionSignature({
+    publicKey: privateKey.publicKey,
+    prevTxId: this.prevTxId,
+    outputIndex: this.outputIndex,
+    inputIndex: inputIndex,
+    signature: Sighash.sign(transaction, privateKey, sigtype, inputIndex, this.output.script, this.output.satoshisBN),
+    sigtype: sigtype
+  })]
+}
+
+/**
+ * Retrieve preimage for the Input.
+ *
+ * @param {Transaction} transaction - the transaction to be signed
+ * @param {number} inputIndex - the index of this input in the provided transaction
+ * @param {number} sigType - defaults to Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID
+ * @param {boolean} isLowS - true if the sig hash is safe for low s.
  * @abstract
  */
-Input.prototype.getSignatures = function () {
-  // throw new errors.AbstractMethodInvoked(
-  //   'Trying to sign unsupported output type (only P2PKH and P2SH multisig inputs are supported)' +
-  //   ' for input: ' + JSON.stringify(this)
-  // )
-  return []
+Input.prototype.getPreimage = function (transaction, inputIndex, sigtype, isLowS) {
+  $.checkState(this.output instanceof Output)
+  sigtype = sigtype || (Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID)
+  isLowS = isLowS || false
+  return isLowS
+    ? getLowSPreimage(transaction, sigtype, inputIndex, this.output.script, this.output.satoshisBN)
+    : Sighash.sighashPreimage(transaction, sigtype, inputIndex, this.output.script, this.output.satoshisBN)
 }
 
 Input.prototype.isFullySigned = function () {
@@ -200,4 +241,35 @@ Input.prototype._estimateSize = function () {
   return this.toBufferWriter().toBuffer().length
 }
 
+Input.prototype.verify = function (transaction, inputIndex) {
+  $.checkState(this.output instanceof Output)
+  $.checkState(this.script instanceof Script)
+
+  var us = this.script
+  var ls = this.output.script
+  var inputSatoshis = this.output.satoshisBN
+
+  Interpreter.MAX_SCRIPT_ELEMENT_SIZE = Number.MAX_SAFE_INTEGER
+  Interpreter.MAXIMUM_ELEMENT_SIZE = Number.MAX_SAFE_INTEGER
+
+  const bsi = new Interpreter()
+
+  let failedAt = {}
+
+  bsi.stepListener = function (step) {
+    if (step.fExec || (Opcode.OP_IF <= step.opcode.toNumber() && step.opcode.toNumber() <= Opcode.OP_ENDIF)) {
+      if ((Opcode.OP_IF <= step.opcode.toNumber() && step.opcode.toNumber() <= Opcode.OP_ENDIF) || step.opcode.toNumber() === Opcode.OP_RETURN) /** Opreturn */ {
+        failedAt.opcode = step.opcode
+      } else {
+        failedAt = step
+      }
+    }
+  }
+
+  var success = bsi.verify(us, ls, transaction, inputIndex, Interpreter.DEFAULT_FLAGS, inputSatoshis)
+
+  failedAt.opcode = failedAt.opcode.toNumber()
+  return { success, error: bsi.errstr, failedAt: success ? {} : failedAt }
+}
+
 module.exports = Input