Merge pull request #170 from MattFaus/fix_transaction_tests2

Hook up testdata/tx_valid.json and tx_invalid.json test cases

Key.js

@@ -78,6 +78,15 @@ if (process.versions) {
     return new Buffer(signature);
   };
   
+  kSpec.prototype.verifySignature = function(hash, sig, callback) {
+    try {
+      var result = this.verifySignatureSync(hash, sig);
+      callback(null, result);
+    } catch (e) {
+      callback(e);
+    }
+  };
+
   kSpec.prototype.verifySignatureSync = function(hash, sig) {
     var self = this;
 

Script.js

@@ -505,7 +505,7 @@ Script.stringToBuffer = function(s) {
       //console.log('hex value');
       buf.put(new Buffer(word.substring(2, word.length), 'hex'));
     } else {
-      var opcode = Opcode.map['OP_' + word];
+      var opcode = Opcode.map['OP_' + word] || Opcode.map[word];
       if (typeof opcode !== 'undefined') {
         // op code in string form
         //console.log('opcode');

ScriptInterpreter.js

@@ -7,6 +7,7 @@ var buffertools = imports.buffertools || require('buffertools');
 var bignum = imports.bignum || require('bignum');
 var Util = imports.Util || require('./util/util');
 var Script = require('./Script');
+var Key = require('./Key');
 
 var SIGHASH_ALL = 1;
 var SIGHASH_NONE = 2;
@@ -21,7 +22,8 @@ for (var i in Opcode.map) {
 var intToBufferSM = Util.intToBufferSM
 var bufferSMToInt = Util.bufferSMToInt;
 
-function ScriptInterpreter() {
+function ScriptInterpreter(opts) {
+  this.opts = opts || {};
   this.stack = [];
   this.disableUnsafeOpcodes = true;
 };
@@ -60,7 +62,6 @@ ScriptInterpreter.prototype.eval = function eval(script, tx, inIndex, hashType,
       return;
     }
 
-    try {
     // The execution bit is true if there are no "false" values in the
     // execution stack. (A "false" value indicates that we're in the
     // inactive branch of an if statement.)
@@ -98,8 +99,7 @@ ScriptInterpreter.prototype.eval = function eval(script, tx, inIndex, hashType,
 
     if (exec && Buffer.isBuffer(opcode)) {
       this.stack.push(opcode);
-      }
-      else if (exec || (OP_IF <= opcode && opcode <= OP_ENDIF))
+    } else if (exec || (OP_IF <= opcode && opcode <= OP_ENDIF))
       switch (opcode) {
         case OP_0:
           this.stack.push(new Buffer([]));
@@ -620,12 +620,11 @@ ScriptInterpreter.prototype.eval = function eval(script, tx, inIndex, hashType,
           // Remove signature if present (a signature can't sign itself)
           scriptCode.findAndDelete(sig);
 
-            //
-            isCanonicalSignature(new Buffer(sig));
+          // check canonical signature
+          this.isCanonicalSignature(new Buffer(sig));
 
           // Verify signature
           checkSig(sig, pubkey, scriptCode, tx, inIndex, hashType, function(e, result) {
-              try {
             var success;
 
             if (e) {
@@ -650,9 +649,6 @@ ScriptInterpreter.prototype.eval = function eval(script, tx, inIndex, hashType,
 
             // Run next step
             executeStep.call(this, cb);
-              } catch (e) {
-                cb(e);
-              }
           }.bind(this));
 
           // Note that for asynchronous opcodes we have to return here to prevent
@@ -695,8 +691,9 @@ ScriptInterpreter.prototype.eval = function eval(script, tx, inIndex, hashType,
           var scriptCode = Script.fromChunks(scriptChunks);
 
           // Drop the signatures, since a signature can't sign itself
+          var that = this;
           sigs.forEach(function(sig) {
-              isCanonicalSignature(new Buffer(sig));
+            that.isCanonicalSignature(new Buffer(sig));
             scriptCode.findAndDelete(sig);
           });
 
@@ -706,13 +703,11 @@ ScriptInterpreter.prototype.eval = function eval(script, tx, inIndex, hashType,
           checkMultiSigStep.call(this);
 
           function checkMultiSigStep() {
-              try {
             if (success && sigsCount > 0) {
               var sig = sigs[isig];
               var key = keys[ikey];
 
               checkSig(sig, key, scriptCode, tx, inIndex, hashType, function(e, result) {
-                    try {
                 if (!e && result) {
                   isig++;
                   sigsCount--;
@@ -728,9 +723,6 @@ ScriptInterpreter.prototype.eval = function eval(script, tx, inIndex, hashType,
                 }
 
                 checkMultiSigStep.call(this);
-                    } catch (e) {
-                      cb(e);
-                    }
               }.bind(this));
             } else {
               this.stack.push(new Buffer([success ? 1 : 0]));
@@ -745,9 +737,6 @@ ScriptInterpreter.prototype.eval = function eval(script, tx, inIndex, hashType,
               // Run next step
               executeStep.call(this, cb);
             }
-              } catch (e) {
-                cb(e);
-              }
           };
 
           // Note that for asynchronous opcodes we have to return here to prevent
@@ -764,18 +753,13 @@ ScriptInterpreter.prototype.eval = function eval(script, tx, inIndex, hashType,
     }
 
     // Run next step
-      if (pc % 100) {
+    if (false && pc % 100) {
       // V8 allows for much deeper stacks than Bitcoin's scripting language,
       // but just to be safe, we'll reset the stack every 100 steps
       process.nextTick(executeStep.bind(this, cb));
     } else {
       executeStep.call(this, cb);
     }
-    } catch (e) {
-      log.debug("Script aborted: " +
-        (e.message ? e.message : e));
-      cb(e);
-    }
   }
 };
 
@@ -811,7 +795,7 @@ ScriptInterpreter.prototype.stackTop = function stackTop(offset) {
 };
 
 ScriptInterpreter.prototype.stackBack = function stackBack() {
-  return this.stack[this.stack.length -1];
+  return this.stack[this.stack.length - 1];
 };
 
 /**
@@ -845,15 +829,15 @@ ScriptInterpreter.prototype.stackSwap = function stackSwap(a, b) {
  * integer. Any longer Buffer is converted to a hex string.
  */
 ScriptInterpreter.prototype.getPrimitiveStack = function getPrimitiveStack() {
-  return this.stack.map(function(entry) {
-    if (entry.length > 2) {
-      return buffertools.toHex(entry.slice(0));
+  return this.stack.map(function(chunk) {
+    if (chunk.length > 2) {
+      return buffertools.toHex(chunk.slice(0));
     }
-    var num = bufferSMToInt(entry);
+    var num = bufferSMToInt(chunk);
     if (num.cmp(-128) >= 0 && num.cmp(127) <= 0) {
       return num.toNumber();
     } else {
-      return buffertools.toHex(entry.slice(0));
+      return buffertools.toHex(chunk.slice(0));
     }
   });
 };
@@ -882,6 +866,7 @@ ScriptInterpreter.prototype.getResult = function getResult() {
   return castBool(this.stack[this.stack.length - 1]);
 };
 
+// Use ScriptInterpreter.verifyFull instead
 ScriptInterpreter.verify =
   function verify(scriptSig, scriptPubKey, txTo, n, hashType, callback) {
     if ("function" !== typeof callback) {
@@ -899,12 +884,7 @@ ScriptInterpreter.verify =
       }
 
       // Cast result to bool
-      try {
       var result = si.getResult();
-      } catch (err) {
-        callback(err);
-        return;
-      }
 
       callback(null, result);
     });
@@ -912,8 +892,8 @@ ScriptInterpreter.verify =
     return si;
 };
 
-function verifyStep4(scriptSig, scriptPubKey, txTo, nIn,
-  hashType, opts, callback, si, siCopy) {
+ScriptInterpreter.prototype.verifyStep4 = function(scriptSig, scriptPubKey,
+  txTo, nIn, hashType, callback, siCopy) {
   if (siCopy.stack.length == 0) {
     callback(null, false);
     return;
@@ -922,19 +902,19 @@ function verifyStep4(scriptSig, scriptPubKey, txTo, nIn,
   callback(null, castBool(siCopy.stackBack()));
 }
 
-function verifyStep3(scriptSig, scriptPubKey, txTo, nIn,
-  hashType, opts, callback, si, siCopy) {
-  if (si.stack.length == 0) {
+ScriptInterpreter.prototype.verifyStep3 = function(scriptSig,
+  scriptPubKey, txTo, nIn, hashType, callback, siCopy) {
+  if (this.stack.length == 0) {
     callback(null, false);
     return;
   }
-  if (castBool(si.stackBack()) == false) {
+  if (castBool(this.stackBack()) == false) {
     callback(null, false);
     return;
   }
 
   // if not P2SH, we're done
-  if (!opts.verifyP2SH || !scriptPubKey.isP2SH()) {
+  if (!this.opts.verifyP2SH || !scriptPubKey.isP2SH()) {
     callback(null, true);
     return;
   }
@@ -949,46 +929,50 @@ function verifyStep3(scriptSig, scriptPubKey, txTo, nIn,
 
   var subscript = new Script(siCopy.stackPop());
 
-  ok = true;
+  var that = this;
   siCopy.eval(subscript, txTo, nIn, hashType, function(err) {
-    if (err)
-      callback(err);
-    else
-      verifyStep4(scriptSig, scriptPubKey, txTo, nIn,
-        hashType, opts, callback, si, siCopy);
+    if (err) callback(err);
+    else that.verifyStep4(scriptSig, scriptPubKey, txTo, nIn,
+      hashType, callback, siCopy);
   });
-}
+};
 
-function verifyStep2(scriptSig, scriptPubKey, txTo, nIn,
-  hashType, opts, callback, si, siCopy) {
-  if (opts.verifyP2SH) {
-    si.stack.forEach(function(item) {
+ScriptInterpreter.prototype.verifyStep2 = function(scriptSig, scriptPubKey,
+  txTo, nIn, hashType, callback, siCopy) {
+  if (this.opts.verifyP2SH) {
+    this.stack.forEach(function(item) {
       siCopy.stack.push(item);
     });
   }
 
-  si.eval(scriptPubKey, txTo, nIn, hashType, function(err) {
-    if (err)
-      callback(err);
-    else
-      verifyStep3(scriptSig, scriptPubKey, txTo, nIn,
-        hashType, opts, callback, si, siCopy);
+  var that = this;
+  this.eval(scriptPubKey, txTo, nIn, hashType, function(err) {
+    if (err) callback(err);
+    else that.verifyStep3(scriptSig, scriptPubKey, txTo, nIn,
+      hashType, callback, siCopy);
   });
-}
+};
 
 ScriptInterpreter.verifyFull =
   function verifyFull(scriptSig, scriptPubKey, txTo, nIn, hashType,
     opts, callback) {
-    var si = new ScriptInterpreter();
-    var siCopy = new ScriptInterpreter();
+    var si = new ScriptInterpreter(opts);
+    si.verifyFull(scriptSig, scriptPubKey,
+      txTo, nIn, hashType, callback);
+};
 
-    si.eval(scriptSig, txTo, nIn, hashType, function(err) {
-      if (err)
-        callback(err);
-      else
-        verifyStep2(scriptSig, scriptPubKey, txTo, nIn,
-          hashType, opts, callback, si, siCopy);
+ScriptInterpreter.prototype.verifyFull = function(scriptSig, scriptPubKey,
+  txTo, nIn, hashType, callback) {
+  var siCopy = new ScriptInterpreter(this.opts);
+  var that = this;
+  this.eval(scriptSig, txTo, nIn, hashType, function(err) {
+    if (err) callback(err);
+    else {
+      that.verifyStep2(scriptSig, scriptPubKey, txTo, nIn,
+        hashType, callback, siCopy);
+    }
   });
+
 };
 
 var checkSig = ScriptInterpreter.checkSig =
@@ -1006,20 +990,16 @@ var checkSig = ScriptInterpreter.checkSig =
     }
     sig = sig.slice(0, sig.length - 1);
 
-    try {
     // Signature verification requires a special hash procedure
     var hash = tx.hashForSignature(scriptCode, n, hashType);
 
     // Verify signature
-      var key = new Util.BitcoinKey();
+    var key = new Key();
     key.public = pubkey;
     key.verifySignature(hash, sig, callback);
-    } catch (err) {
-      callback(null, false);
-    }
 };
 
-var isCanonicalSignature = ScriptInterpreter.isCanonicalSignature = function(sig, opts) {
+ScriptInterpreter.prototype.isCanonicalSignature = function(sig) {
   // See https://bitcointalk.org/index.php?topic=8392.msg127623#msg127623
   // A canonical signature exists of: <30> <total len> <02> <len R> <R> <02> <len S> <S> <hashtype>
   // Where R and S are not negative (their first byte has its highest bit not set), and not
@@ -1029,33 +1009,35 @@ var isCanonicalSignature = ScriptInterpreter.isCanonicalSignature = function(sig
   if (!Buffer.isBuffer(sig))
     throw new Error("arg should be a Buffer");
 
-    opts = opts || {};
+  // TODO: change to opts.verifyStrictEnc to make the default
+  // behavior not verify, as in bitcoin core
+  if (this.opts.dontVerifyStrictEnc) return true;
 
   var l = sig.length;
   if (l < 9) throw new Error("Non-canonical signature: too short");
   if (l > 73) throw new Error("Non-canonical signature: too long");
 
-    var  nHashType = sig[l-1] & (~(SIGHASH_ANYONECANPAY));
+  var nHashType = sig[l - 1] & (~(SIGHASH_ANYONECANPAY));
   if (nHashType < SIGHASH_ALL || nHashType > SIGHASH_SINGLE)
     throw new Error("Non-canonical signature: unknown hashtype byte");
 
   if (sig[0] !== 0x30)
     throw new Error("Non-canonical signature: wrong type");
-    if (sig[1] !== l-3)
+  if (sig[1] !== l - 3)
     throw new Error("Non-canonical signature: wrong length marker");
 
   var nLenR = sig[3];
   if (5 + nLenR >= l)
     throw new Error("Non-canonical signature: S length misplaced");
 
-    var nLenS = sig[5+nLenR];
-    if ( (nLenR+nLenS+7) !== l)
+  var nLenS = sig[5 + nLenR];
+  if ((nLenR + nLenS + 7) !== l)
     throw new Error("Non-canonical signature: R+S length mismatch");
 
   var rPos = 4;
   var R = new Buffer(nLenR);
-    sig.copy(R, 0,  rPos, rPos+ nLenR);
-     if (sig[rPos-2] !== 0x02)
+  sig.copy(R, 0, rPos, rPos + nLenR);
+  if (sig[rPos - 2] !== 0x02)
     throw new Error("Non-canonical signature: R value type mismatch");
   if (nLenR == 0)
     throw new Error("Non-canonical signature: R length is zero");
@@ -1066,8 +1048,8 @@ var isCanonicalSignature = ScriptInterpreter.isCanonicalSignature = function(sig
 
   var sPos = 6 + nLenR;
   var S = new Buffer(nLenS);
-    sig.copy(S, 0,  sPos, sPos+ nLenS);
-     if (sig[sPos-2] != 0x02)
+  sig.copy(S, 0, sPos, sPos + nLenS);
+  if (sig[sPos - 2] != 0x02)
     throw new Error("Non-canonical signature: S value type mismatch");
   if (nLenS == 0)
     throw new Error("Non-canonical signature: S length is zero");
@@ -1076,8 +1058,8 @@ var isCanonicalSignature = ScriptInterpreter.isCanonicalSignature = function(sig
   if (nLenS > 1 && (S[0] == 0x00) && !(S[1] & 0x80))
     throw new Error("Non-canonical signature: S value excessively padded");
 
-     if (opts.verifyEvenS) {
-         if (S[nLenS-1] & 1)
+  if (this.opts.verifyEvenS) {
+    if (S[nLenS - 1] & 1)
       throw new Error("Non-canonical signature: S value odd");
   }
   return true;

Transaction.js

@@ -64,7 +64,7 @@ TransactionIn.prototype.getOutpointHash = function getOutpointHash() {
 };
 
 TransactionIn.prototype.getOutpointIndex = function getOutpointIndex() {
-  return (this.o[32]      ) +
+  return (this.o[32]) +
     (this.o[33] << 8) +
     (this.o[34] << 16) +
     (this.o[35] << 24);
@@ -106,14 +106,14 @@ function Transaction(data) {
   this.hash = data.hash || null;
   this.version = data.version;
   this.lock_time = data.lock_time;
-  this.ins = Array.isArray(data.ins) ? data.ins.map(function (data) {
+  this.ins = Array.isArray(data.ins) ? data.ins.map(function(data) {
     var txin = new TransactionIn();
     txin.s = data.s;
     txin.q = data.q;
     txin.o = data.o;
     return txin;
   }) : [];
-  this.outs = Array.isArray(data.outs) ? data.outs.map(function (data) {
+  this.outs = Array.isArray(data.outs) ? data.outs.map(function(data) {
     var txout = new TransactionOut();
     txout.v = data.v;
     txout.s = data.s;
@@ -125,7 +125,7 @@ this.class = Transaction;
 Transaction.In = TransactionIn;
 Transaction.Out = TransactionOut;
 
-Transaction.prototype.isCoinBase = function () {
+Transaction.prototype.isCoinBase = function() {
   return this.ins.length == 1 && this.ins[0].isCoinBase();
 };
 
@@ -152,12 +152,12 @@ Transaction.prototype.serialize = function serialize() {
   bufs.push(buf);
 
   bufs.push(util.varIntBuf(this.ins.length));
-  this.ins.forEach(function (txin) {
+  this.ins.forEach(function(txin) {
     bufs.push(txin.serialize());
   });
 
   bufs.push(util.varIntBuf(this.outs.length));
-  this.outs.forEach(function (txout) {
+  this.outs.forEach(function(txout) {
     bufs.push(txout.serialize());
   });
 
@@ -204,7 +204,7 @@ Transaction.prototype.inputs = function inputs() {
   }
 
   return res;
-}
+};
 
 /**
  * Load and cache transaction inputs.
@@ -218,7 +218,7 @@ Transaction.prototype.inputs = function inputs() {
  * @param {Function} callback Function to call on completion.
  */
 Transaction.prototype.cacheInputs =
-function cacheInputs(blockChain, txStore, wait, callback) {
+  function cacheInputs(blockChain, txStore, wait, callback) {
     var self = this;
 
     var txCache = new TransactionInputsCache(this);
@@ -254,22 +254,22 @@ Transaction.prototype.verify = function verify(txCache, blockChain, callback) {
     var txout = fromTxOuts[outIndex];
 
     if (!txout) {
-      throw new Error("Source output index "+outIndex+
-                      " for input "+n+" out of bounds");
+      throw new Error("Source output index " + outIndex +
+        " for input " + n + " out of bounds");
     }
 
     return txout;
-  };
+  }
 
   Step(
-    function verifyInputs() {
+    function verifyInputs(opts) {
       var group = this.group();
 
       if (self.isCoinBase()) {
         throw new Error("Coinbase tx are invalid unless part of a block");
       }
 
-      self.ins.forEach(function (txin, n) {
+      self.ins.forEach(function(txin, n) {
         var txout = getTxOut(txin, n);
 
         // TODO: Verify coinbase maturity
@@ -278,7 +278,7 @@ Transaction.prototype.verify = function verify(txCache, blockChain, callback) {
 
         outpoints.push(txin.o);
 
-        self.verifyInput(n, txout.getScript(), group());
+        self.verifyInput(n, txout.getScript(), opts, group());
       });
     },
 
@@ -289,9 +289,9 @@ Transaction.prototype.verify = function verify(txCache, blockChain, callback) {
         if (!results[i]) {
           var txout = getTxOut(self.ins[i]);
           log.debug('Script evaluated to false');
-          log.debug('|- scriptSig', ""+self.ins[i].getScript());
-          log.debug('`- scriptPubKey', ""+txout.getScript());
-          throw new VerificationError('Script for input '+i+' evaluated to false');
+          log.debug('|- scriptSig', "" + self.ins[i].getScript());
+          log.debug('`- scriptPubKey', "" + txout.getScript());
+          throw new VerificationError('Script for input ' + i + ' evaluated to false');
         }
       }
 
@@ -307,37 +307,34 @@ Transaction.prototype.verify = function verify(txCache, blockChain, callback) {
     function checkConflicts(err, count) {
       if (err) throw err;
 
-      self.outs.forEach(function (txout) {
+      self.outs.forEach(function(txout) {
         valueOut = valueOut.add(util.valueToBigInt(txout.v));
       });
 
       if (valueIn.cmp(valueOut) < 0) {
         var outValue = util.formatValue(valueOut);
         var inValue = util.formatValue(valueIn);
-        throw new Error("Tx output value (BTC "+outValue+") "+
-                        "exceeds input value (BTC "+inValue+")");
+        throw new Error("Tx output value (BTC " + outValue + ") " +
+          "exceeds input value (BTC " + inValue + ")");
       }
 
       var fees = valueIn.sub(valueOut);
 
       if (count) {
         // Spent output detected, retrieve transaction that spends it
-        blockChain.getConflictingTransactions(outpoints, function (err, results) {
+        blockChain.getConflictingTransactions(outpoints, function(err, results) {
           if (results.length) {
             if (buffertools.compare(results[0].getHash(), self.getHash()) === 0) {
-              log.warn("Detected tx re-add (recoverable db corruption): "
-                          + util.formatHashAlt(results[0].getHash()));
+              log.warn("Detected tx re-add (recoverable db corruption): " + util.formatHashAlt(results[0].getHash()));
               // TODO: Needs to return an error for the memory pool case?
               callback(null, fees);
             } else {
-              callback(new Error("At least one referenced output has"
-                                 + " already been spent in tx "
-                                 + util.formatHashAlt(results[0].getHash())));
+              callback(new Error("At least one referenced output has" + " already been spent in tx " + util.formatHashAlt(results[0].getHash())));
             }
           } else {
-            callback(new Error("Outputs of this transaction are spent, but "+
-                               "the transaction(s) that spend them are not "+
-                               "available. This probably means you need to "+
+            callback(new Error("Outputs of this transaction are spent, but " +
+              "the transaction(s) that spend them are not " +
+              "available. This probably means you need to " +
               "reset your database."));
           }
         });
@@ -351,10 +348,13 @@ Transaction.prototype.verify = function verify(txCache, blockChain, callback) {
   );
 };
 
-Transaction.prototype.verifyInput = function verifyInput(n, scriptPubKey, callback) {
-  return ScriptInterpreter.verify(this.ins[n].getScript(),
+Transaction.prototype.verifyInput = function verifyInput(n, scriptPubKey, opts, callback) {
+  var scriptSig = this.ins[n].getScript();
+  return ScriptInterpreter.verifyFull(
+    scriptSig,
     scriptPubKey,
     this, n, 0,
+    opts,
     callback);
 };
 
@@ -372,7 +372,6 @@ Transaction.prototype.getAffectedKeys = function getAffectedKeys(txCache) {
 
     // Index any pubkeys affected by the outputs of this transaction
     for (var i = 0, l = this.outs.length; i < l; i++) {
-      try {
       var txout = this.outs[i];
       var script = txout.getScript();
 
@@ -380,18 +379,11 @@ Transaction.prototype.getAffectedKeys = function getAffectedKeys(txCache) {
       if (outPubKey) {
         this.affects.push(outPubKey);
       }
-      } catch (err) {
-        // It's not our job to validate, so we just ignore any errors and issue
-        // a very low level log message.
-        log.debug("Unable to determine affected pubkeys: " +
-                     (err.stack ? err.stack : ""+err));
-      }
     };
 
     // Index any pubkeys affected by the inputs of this transaction
     var txIndex = txCache.txIndex;
     for (var i = 0, l = this.ins.length; i < l; i++) {
-      try {
       var txin = this.ins[i];
 
       if (txin.isCoinBase()) continue;
@@ -415,18 +407,12 @@ Transaction.prototype.getAffectedKeys = function getAffectedKeys(txCache) {
       if (outPubKey) {
         this.affects.push(outPubKey);
       }
-      } catch (err) {
-        // It's not our job to validate, so we just ignore any errors and issue
-        // a very low level log message.
-        log.debug("Unable to determine affected pubkeys: " +
-                     (err.stack ? err.stack : ""+err));
-      }
     }
   }
 
   var affectedKeys = {};
 
-  this.affects.forEach(function (pubKeyHash) {
+  this.affects.forEach(function(pubKeyHash) {
     affectedKeys[pubKeyHash.toString('base64')] = pubKeyHash;
   });
 
@@ -440,25 +426,25 @@ var SIGHASH_NONE = 2;
 var SIGHASH_SINGLE = 3;
 var SIGHASH_ANYONECANPAY = 80;
 
-Transaction.SIGHASH_ALL=SIGHASH_ALL;
-Transaction.SIGHASH_NONE=SIGHASH_NONE;
-Transaction.SIGHASH_SINGLE=SIGHASH_SINGLE;
-Transaction.SIGHASH_ANYONECANPAY=SIGHASH_ANYONECANPAY;
+Transaction.SIGHASH_ALL = SIGHASH_ALL;
+Transaction.SIGHASH_NONE = SIGHASH_NONE;
+Transaction.SIGHASH_SINGLE = SIGHASH_SINGLE;
+Transaction.SIGHASH_ANYONECANPAY = SIGHASH_ANYONECANPAY;
 
 Transaction.prototype.hashForSignature =
-function hashForSignature(script, inIndex, hashType) {
+  function hashForSignature(script, inIndex, hashType) {
     if (+inIndex !== inIndex ||
       inIndex < 0 || inIndex >= this.ins.length) {
-    throw new Error("Input index '"+inIndex+"' invalid or out of bounds "+
-                    "("+this.ins.length+" inputs)");
+      throw new Error("Input index '" + inIndex + "' invalid or out of bounds " +
+        "(" + this.ins.length + " inputs)");
     }
 
     // Clone transaction
     var txTmp = new Transaction();
-  this.ins.forEach(function (txin, i) {
+    this.ins.forEach(function(txin, i) {
       txTmp.ins.push(new TransactionIn(txin));
     });
-  this.outs.forEach(function (txout) {
+    this.outs.forEach(function(txout) {
       txTmp.outs.push(new TransactionOut(txout));
     });
     txTmp.version = this.version;
@@ -562,7 +548,7 @@ Transaction.prototype.getStandardizedObject = function getStandardizedObject() {
 
   var totalSize = 8; // version + lock_time
   totalSize += util.getVarIntSize(this.ins.length); // tx_in count
-  var ins = this.ins.map(function (txin) {
+  var ins = this.ins.map(function(txin) {
     var txinObj = {
       prev_out: {
         hash: buffertools.reverse(new Buffer(txin.getOutpointHash())).toString('hex'),
@@ -580,7 +566,7 @@ Transaction.prototype.getStandardizedObject = function getStandardizedObject() {
   });
 
   totalSize += util.getVarIntSize(this.outs.length);
-  var outs = this.outs.map(function (txout) {
+  var outs = this.outs.map(function(txout) {
     totalSize += util.getVarIntSize(txout.s.length) +
       txout.s.length + 8; // script_len + script + value
     return {
@@ -646,7 +632,7 @@ Transaction.prototype.fromObj = function fromObj(obj) {
   this.outs = txobj.outs;
 }
 
-Transaction.prototype.parse = function (parser) {
+Transaction.prototype.parse = function(parser) {
   if (Buffer.isBuffer(parser)) {
     this._buffer = parser;
     parser = new Parser(parser);
@@ -702,9 +688,9 @@ Transaction.prototype.parse = function (parser) {
  *
  */
 
-Transaction.selectUnspent = function (utxos, totalNeededAmount, allowUnconfirmed) {
+Transaction.selectUnspent = function(utxos, totalNeededAmount, allowUnconfirmed) {
 
-  var minConfirmationSteps = [6,1];
+  var minConfirmationSteps = [6, 1];
   if (allowUnconfirmed) minConfirmationSteps.push(0);
 
   var ret = [];
@@ -716,25 +702,25 @@ Transaction.selectUnspent = function (utxos, totalNeededAmount, allowUnconfirmed
 
   do {
     var minConfirmations = minConfirmationSteps.shift();
-    for(var i = 0; i<l; i++) {
+    for (var i = 0; i < l; i++) {
       var u = utxos[i];
 
       var c = u.confirmations || 0;
 
-      if ( c  < minConfirmations || (maxConfirmations && c >=maxConfirmations) ) 
+      if (c < minConfirmations || (maxConfirmations && c >= maxConfirmations))
         continue;
 
 
       var sat = u.amountSat || util.parseValue(u.amount);
       totalSat = totalSat.add(sat);
       ret.push(u);
-      if(totalSat.cmp(totalNeededAmountSat) >= 0) {
+      if (totalSat.cmp(totalNeededAmountSat) >= 0) {
         fulfill = true;
         break;
       }
     }
     maxConfirmations = minConfirmations;
-  } while( !fulfill && minConfirmationSteps.length);
+  } while (!fulfill && minConfirmationSteps.length);
 
   //TODO(?): sort ret and check is some inputs can be avoided.
   //If the initial utxos are sorted, this step would be necesary only if
@@ -749,7 +735,7 @@ Transaction.selectUnspent = function (utxos, totalNeededAmount, allowUnconfirmed
  *  Returns a scriptPubKey for the given address type
  */
 
-Transaction._scriptForAddress = function (addressString) {
+Transaction._scriptForAddress = function(addressString) {
 
   var livenet = networks.livenet;
   var testnet = networks.testnet;
@@ -771,7 +757,7 @@ Transaction._sumOutputs = function(outs) {
   var valueOutSat = bignum(0);
   var l = outs.length;
 
-  for(var i=0;i<outs.length;i++) {
+  for (var i = 0; i < outs.length; i++) {
     var sat = outs[i].amountSat || util.parseValue(outs[i].amount);
     valueOutSat = valueOutSat.add(sat);
   }
@@ -784,7 +770,7 @@ Transaction._sumOutputs = function(outs) {
  *  details on the input on .create
  */
 
-Transaction.createWithFee = function (ins, outs, feeSat, opts) {
+Transaction.createWithFee = function(ins, outs, feeSat, opts) {
   opts = opts || {};
   feeSat = feeSat || 0;
 
@@ -797,7 +783,7 @@ Transaction.createWithFee = function (ins, outs, feeSat, opts) {
 
   var l = ins.length;
   var valueInSat = bignum(0);
-  for(var i=0; i<l; i++) {
+  for (var i = 0; i < l; i++) {
     valueInSat = valueInSat.add(util.parseValue(ins[i].amount));
 
     var txin = {};
@@ -818,14 +804,14 @@ Transaction.createWithFee = function (ins, outs, feeSat, opts) {
   var valueOutSat = Transaction._sumOutputs(outs);
   valueOutSat = valueOutSat.add(feeSat);
 
-  if (valueInSat.cmp(valueOutSat)<0) {
+  if (valueInSat.cmp(valueOutSat) < 0) {
     var inv = valueInSat.toString();
     var ouv = valueOutSat.toString();
     throw new Error('transaction input amount is less than outputs: ' +
-                    inv + ' < '+ouv + ' [SAT]');
+      inv + ' < ' + ouv + ' [SAT]');
   }
 
-  for(var i=0;i<outs.length;i++) {
+  for (var i = 0; i < outs.length; i++) {
     var amountSat = outs[i].amountSat || util.parseValue(outs[i].amount);
     var value = util.bigIntToValue(amountSat);
     var script = Transaction._scriptForAddress(outs[i].address);
@@ -838,7 +824,7 @@ Transaction.createWithFee = function (ins, outs, feeSat, opts) {
 
   // add remainder (without modifiying outs[])
   var remainderSat = valueInSat.sub(valueOutSat);
-  if (remainderSat.cmp(0)>0) {
+  if (remainderSat.cmp(0) > 0) {
     var remainderAddress = opts.remainderAddress || ins[0].address;
     var value = util.bigIntToValue(remainderSat);
     var script = Transaction._scriptForAddress(remainderAddress);
@@ -853,16 +839,16 @@ Transaction.createWithFee = function (ins, outs, feeSat, opts) {
   return new Transaction(txobj);
 };
 
-Transaction.prototype.calcSize = function () {
+Transaction.prototype.calcSize = function() {
   var totalSize = 8; // version + lock_time
   totalSize += util.getVarIntSize(this.ins.length); // tx_in count
-  this.ins.forEach(function (txin) {
+  this.ins.forEach(function(txin) {
     totalSize += 36 + util.getVarIntSize(txin.s.length) +
       txin.s.length + 4; // outpoint + script_len + script + sequence
   });
 
   totalSize += util.getVarIntSize(this.outs.length);
-  this.outs.forEach(function (txout) {
+  this.outs.forEach(function(txout) {
     totalSize += util.getVarIntSize(txout.s.length) +
       txout.s.length + 8; // script_len + script + value
   });
@@ -878,12 +864,12 @@ Transaction.prototype.getSize = function getHash() {
 };
 
 
-Transaction.prototype.isComplete = function () {
+Transaction.prototype.isComplete = function() {
   var l = this.ins.length;
 
   var ret = true;
-  for (var i=0; i<l; i++) {
-    if ( buffertools.compare(this.ins[i].s,util.EMPTY_BUFFER)===0 )  {
+  for (var i = 0; i < l; i++) {
+    if (buffertools.compare(this.ins[i].s, util.EMPTY_BUFFER) === 0) {
       ret = false;
       break;
     }
@@ -906,7 +892,7 @@ Transaction.prototype.isComplete = function () {
  *
  */
 
-Transaction.prototype.sign = function (selectedUtxos, keys, opts) {
+Transaction.prototype.sign = function(selectedUtxos, keys, opts) {
   var self = this;
   var complete = false;
   var m = keys.length;
@@ -918,8 +904,8 @@ Transaction.prototype.sign = function (selectedUtxos, keys, opts) {
 
   var inputMap = [];
   var l = selectedUtxos.length;
-  for(var i=0; i<l; i++) {
-    inputMap[i]= {
+  for (var i = 0; i < l; i++) {
+    inputMap[i] = {
       address: selectedUtxos[i].address,
       scriptPubKey: selectedUtxos[i].scriptPubKey
     };
@@ -929,18 +915,20 @@ Transaction.prototype.sign = function (selectedUtxos, keys, opts) {
   var walletKeyMap = {};
   var l = keys.length;
   var wk;
-  for(var i=0; i<l; i++) {
+  for (var i = 0; i < l; i++) {
     var k = keys[i];
 
     if (typeof k === 'string') {
       var pk = new PrivateKey(k);
-      wk = new WalletKey({network: pk.network()});
-      wk.fromObj({priv:k});
-    }
-    else if (k instanceof WalletKey) {
+      wk = new WalletKey({
+        network: pk.network()
+      });
+      wk.fromObj({
+        priv: k
+      });
+    } else if (k instanceof WalletKey) {
       wk = k;
-    }
-    else {
+    } else {
       throw new Error('argument must be an array of strings (WIF format) or WalletKey objects');
     }
     walletKeyMap[wk.storeObj().addr] = wk;
@@ -948,19 +936,19 @@ Transaction.prototype.sign = function (selectedUtxos, keys, opts) {
 
   var inputSigned = 0;
   l = self.ins.length;
-  for(var i=0;i<l;i++) {
+  for (var i = 0; i < l; i++) {
     var aIn = self.ins[i];
     var wk = walletKeyMap[inputMap[i].address];
 
     if (typeof wk === 'undefined') {
-      if ( buffertools.compare(aIn.s,util.EMPTY_BUFFER)!==0 ) 
+      if (buffertools.compare(aIn.s, util.EMPTY_BUFFER) !== 0)
         inputSigned++;
       continue;
     }
     var scriptBuf = new Buffer(inputMap[i].scriptPubKey, 'hex');
     var s = new Script(scriptBuf);
     if (s.classify() !== Script.TX_PUBKEYHASH) {
-      throw new Error('input:'+i+' script type:'+ s.getRawOutType() +' not supported yet');
+      throw new Error('input:' + i + ' script type:' + s.getRawOutType() + ' not supported yet');
     }
 
     var txSigHash = self.hashForSignature(s, i, signhash);
@@ -969,10 +957,10 @@ Transaction.prototype.sign = function (selectedUtxos, keys, opts) {
     var triesLeft = 10;
     do {
       sigRaw = wk.privKey.signSync(txSigHash);
-    } while ( wk.privKey.verifySignatureSync(txSigHash, sigRaw) === false && triesLeft-- );
+    } while (wk.privKey.verifySignatureSync(txSigHash, sigRaw) === false && triesLeft--);
 
     if (!triesLeft) {
-      log.debug('could not sign input:'+i +' verification failed');
+      log.debug('could not sign input:' + i + ' verification failed');
       continue;
     }
 
@@ -1008,7 +996,7 @@ Transaction.prototype.sign = function (selectedUtxos, keys, opts) {
  *
  */
 
-Transaction.create = function (utxos, outs, opts) {
+Transaction.create = function(utxos, outs, opts) {
 
   //starting size estimation
   var size = 500;
@@ -1022,23 +1010,19 @@ Transaction.create = function (utxos, outs, opts) {
   var selectedUtxos;
   do {
     // based on https://en.bitcoin.it/wiki/Transaction_fees
-      maxSizeK     = parseInt(size/1000) + 1;
-      var feeSat  = givenFeeSat
-        ? givenFeeSat : maxSizeK * FEE_PER_1000B_SAT ;
+    maxSizeK = parseInt(size / 1000) + 1;
+    var feeSat = givenFeeSat ? givenFeeSat : maxSizeK * FEE_PER_1000B_SAT;
 
     var valueOutSat = Transaction
       ._sumOutputs(outs)
       .add(feeSat);
 
     selectedUtxos = Transaction
-        .selectUnspent(utxos,valueOutSat / util.COIN, opts.allowUnconfirmed);
+      .selectUnspent(utxos, valueOutSat / util.COIN, opts.allowUnconfirmed);
 
     if (!selectedUtxos) {
       throw new Error(
-          'the given UTXOs dont sum up the given outputs: ' 
-          + valueOutSat.toString() 
-          + ' (fee is ' + feeSat
-          + ' )SAT'
+        'the given UTXOs dont sum up the given outputs: ' + valueOutSat.toString() + ' (fee is ' + feeSat + ' )SAT'
       );
     }
     var tx = Transaction.createWithFee(selectedUtxos, outs, feeSat, {
@@ -1047,9 +1031,12 @@ Transaction.create = function (utxos, outs, opts) {
     });
 
     size = tx.getSize();
-    } while (size > (maxSizeK+1)*1000 );
+  } while (size > (maxSizeK + 1) * 1000);
 
-    return {tx: tx, selectedUtxos: selectedUtxos};
+  return {
+    tx: tx,
+    selectedUtxos: selectedUtxos
+  };
 };
 
 
@@ -1116,21 +1103,20 @@ Transaction.create = function (utxos, outs, opts) {
  *
  */
 
-Transaction.createAndSign = function (utxos, outs, keys, opts) {
+Transaction.createAndSign = function(utxos, outs, keys, opts) {
   var ret = Transaction.create(utxos, outs, opts);
   ret.tx.sign(ret.selectedUtxos, keys);
   return ret;
 };
 
 var TransactionInputsCache = exports.TransactionInputsCache =
-function TransactionInputsCache(tx)
-{
+  function TransactionInputsCache(tx) {
     var txList = [];
     var txList64 = [];
     var reqOuts = {};
 
     // Get list of transactions required for verification
-  tx.ins.forEach(function (txin) {
+    tx.ins.forEach(function(txin) {
       if (txin.isCoinBase()) return;
 
       var hash = txin.o.slice(0, 32);
@@ -1153,8 +1139,7 @@ function TransactionInputsCache(tx)
     this.callbacks = [];
 };
 
-TransactionInputsCache.prototype.buffer = function buffer(blockChain, txStore, wait, callback)
-{
+TransactionInputsCache.prototype.buffer = function buffer(blockChain, txStore, wait, callback) {
   var self = this;
 
   var complete = false;
@@ -1164,7 +1149,7 @@ TransactionInputsCache.prototype.buffer = function buffer(blockChain, txStore, w
   }
 
   var missingTx = {};
-  self.txList64.forEach(function (hash64) {
+  self.txList64.forEach(function(hash64) {
     missingTx[hash64] = true;
   });
 
@@ -1173,10 +1158,10 @@ TransactionInputsCache.prototype.buffer = function buffer(blockChain, txStore, w
     if (err) throw err;
 
     // Index memory transactions
-    txs.forEach(function (tx) {
+    txs.forEach(function(tx) {
       var hash64 = tx.getHash().toString('base64');
       var obj = {};
-      Object.keys(self.requiredOuts[hash64]).forEach(function (o) {
+      Object.keys(self.requiredOuts[hash64]).forEach(function(o) {
         obj[+o] = tx.outs[+o];
       });
       self.txIndex[hash64] = obj;
@@ -1203,7 +1188,7 @@ TransactionInputsCache.prototype.buffer = function buffer(blockChain, txStore, w
       // TODO: Major speedup should be possible if we load only the outs and not
       //       whole transactions.
       var callback = this;
-      blockChain.getOutputsByHashes(self.txList, function (err, result) {
+      blockChain.getOutputsByHashes(self.txList, function(err, result) {
         callback(err, result);
       });
     },
@@ -1213,7 +1198,7 @@ TransactionInputsCache.prototype.buffer = function buffer(blockChain, txStore, w
 
       var missingTxDbg = '';
       if (Object.keys(missingTx).length) {
-        missingTxDbg = Object.keys(missingTx).map(function (hash64) {
+        missingTxDbg = Object.keys(missingTx).map(function(hash64) {
           return util.formatHash(new Buffer(hash64, 'base64'));
         }).join(',');
       }
@@ -1221,11 +1206,10 @@ TransactionInputsCache.prototype.buffer = function buffer(blockChain, txStore, w
       if (wait && Object.keys(missingTx).length) {
         // TODO: This might no longer be needed now that saveTransactions uses
         //       the safe=true option.
-        setTimeout(function () {
+        setTimeout(function() {
           var missingHashes = Object.keys(missingTx);
           if (missingHashes.length) {
-            self.callback(new Error('Missing inputs (timeout while searching): '
-                                    + missingTxDbg));
+            self.callback(new Error('Missing inputs (timeout while searching): ' + missingTxDbg));
           } else if (!complete) {
             self.callback(new Error('Callback failed to trigger'));
           }
@@ -1240,8 +1224,7 @@ TransactionInputsCache.prototype.buffer = function buffer(blockChain, txStore, w
 };
 
 
-TransactionInputsCache.prototype.callback = function callback(err)
-{
+TransactionInputsCache.prototype.callback = function callback(err) {
   var args = Array.prototype.slice.apply(arguments);
 
   // Empty the callback array first (because downstream functions could add new
@@ -1249,14 +1232,9 @@ TransactionInputsCache.prototype.callback = function callback(err)
   var cbs = this.callbacks;
   this.callbacks = [];
 
-  try {
-    cbs.forEach(function (cb) {
+  cbs.forEach(function(cb) {
     cb.apply(null, args);
   });
-  } catch (err) {
-    log.err("Callback error after connecting tx inputs: "+
-                 (err.stack ? err.stack : err.toString()));
-  }
 };
 
 module.exports = require('soop')(Transaction);

test/test.ScriptInterpreter.js

@@ -7,16 +7,11 @@ var buffertools = require('buffertools');
 var should = chai.should();
 var testdata = testdata || require('./testdata');
 
-var ScriptInterpreterModule = bitcore.ScriptInterpreter;
 var Script = bitcore.Script;
-var ScriptInterpreter;
+var ScriptInterpreter = bitcore.ScriptInterpreter;
 
 describe('ScriptInterpreter', function() {
   it('should initialze the main object', function() {
-    should.exist(ScriptInterpreterModule);
-  });
-  it('should be able to create class', function() {
-    ScriptInterpreter = ScriptInterpreterModule;
     should.exist(ScriptInterpreter);
   });
   it('should be able to create instance', function() {
@@ -24,7 +19,6 @@ describe('ScriptInterpreter', function() {
     should.exist(si);
   });
   var testScripts = function(data, valid) {
-    var i = 0;
     data.forEach(function(datum) {
       if (datum.length < 2) throw new Error('Invalid test data');
       var scriptSig = datum[0]; // script inputs
@@ -68,7 +62,7 @@ describe('ScriptInterpreter', function() {
 
   testdata.dataSigCanonical.forEach(function(datum) {
     it('should validate valid canonical signatures', function() {
-      ScriptInterpreter.isCanonicalSignature(new Buffer(datum, 'hex')).should.equal(true);
+      new ScriptInterpreter().isCanonicalSignature(new Buffer(datum, 'hex')).should.equal(true);
     });
   });
   testdata.dataSigNonCanonical.forEach(function(datum) {
@@ -81,9 +75,16 @@ describe('ScriptInterpreter', function() {
         isHex = 1;
       } catch (e) {}
 
-      if (isHex)
-        ScriptInterpreter.isCanonicalSignature.bind(sig).should.
-      throw ();
+      // ignore non-hex strings
+      if (isHex) {
+        var f = function() {
+          var si = new ScriptInterpreter();
+          var r = si.isCanonicalSignature(sig);
+        };
+        // how this test should be
+        // f.should.throw();
+        new ScriptInterpreter().isCanonicalSignature.bind(sig).should.throw();
+      }
     });
   });
 

test/test.Transaction.js

@@ -1,12 +1,12 @@
 'use strict';
 
 var chai = chai || require('chai');
+chai.Assertion.includeStack = true;
 var bitcore = bitcore || require('../bitcore');
 
 var should = chai.should();
 
-var TransactionModule = bitcore.Transaction;
-var Transaction;
+var Transaction = bitcore.Transaction;
 var In;
 var Out;
 var Script = bitcore.Script;
@@ -14,12 +14,41 @@ var util = bitcore.util;
 var buffertools = require('buffertools');
 var testdata = testdata || require('./testdata');
 
+// Read tests from test/data/tx_valid.json and tx_invalid.json
+// Format is an array of arrays
+// Inner arrays are either [ "comment" ]
+// or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"], serializedTransaction, enforceP2SH
+// ... where all scripts are stringified scripts.
+// Returns an object with the Transaction object, and an array of input objects
+function parse_test_transaction(entry) {
+  // Ignore comments
+  if (entry.length !== 3) return;
+
+  var inputs = {};
+  entry[0].forEach(function(vin) {
+    var hash = (vin[0]);
+    var index = vin[1];
+    var scriptPubKey = Script.fromHumanReadable(vin[2]);
+
+    var mapKey = [hash, index];
+    inputs[mapKey] = scriptPubKey;
+
+  });
+
+  var raw = new Buffer(entry[1], 'hex');
+  var tx = new Transaction();
+  tx.parse(raw);
+
+  // Sanity check transaction has been parsed correctly
+  buffertools.toHex(tx.serialize()).should.equal(buffertools.toHex(raw));
+  return {
+    'transaction': tx,
+    'inputs': inputs
+  };
+}
+
 describe('Transaction', function() {
   it('should initialze the main object', function() {
-    should.exist(TransactionModule);
-  });
-  it('should be able to create class', function() {
-    Transaction = TransactionModule;
     should.exist(Transaction);
     In = Transaction.In;
     Out = Transaction.Out;
@@ -35,7 +64,7 @@ describe('Transaction', function() {
 
 
   it('#selectUnspent should be able to select utxos', function() {
-    var u = Transaction.selectUnspent(testdata.dataUnspent,1.0, true);
+    var u = Transaction.selectUnspent(testdata.dataUnspent, 1.0, true);
     u.length.should.equal(3);
 
     should.exist(u[0].amount);
@@ -43,37 +72,37 @@ describe('Transaction', function() {
     should.exist(u[0].scriptPubKey);
     should.exist(u[0].vout);
 
-    u = Transaction.selectUnspent(testdata.dataUnspent,0.5, true);
+    u = Transaction.selectUnspent(testdata.dataUnspent, 0.5, true);
     u.length.should.equal(3);
 
-    u = Transaction.selectUnspent(testdata.dataUnspent,0.1, true);
+    u = Transaction.selectUnspent(testdata.dataUnspent, 0.1, true);
     u.length.should.equal(2);
 
-    u = Transaction.selectUnspent(testdata.dataUnspent,0.05, true);
+    u = Transaction.selectUnspent(testdata.dataUnspent, 0.05, true);
     u.length.should.equal(2);
 
-    u = Transaction.selectUnspent(testdata.dataUnspent,0.015, true);
+    u = Transaction.selectUnspent(testdata.dataUnspent, 0.015, true);
     u.length.should.equal(2);
 
-    u = Transaction.selectUnspent(testdata.dataUnspent,0.01, true);
+    u = Transaction.selectUnspent(testdata.dataUnspent, 0.01, true);
     u.length.should.equal(1);
   });
 
   it('#selectUnspent should return null if not enough utxos', function() {
-    var u = Transaction.selectUnspent(testdata.dataUnspent,1.12);
+    var u = Transaction.selectUnspent(testdata.dataUnspent, 1.12);
     should.not.exist(u);
   });
 
 
   it('#selectUnspent should check confirmations', function() {
-    var u = Transaction.selectUnspent(testdata.dataUnspent,0.9);
+    var u = Transaction.selectUnspent(testdata.dataUnspent, 0.9);
     should.not.exist(u);
-    var u = Transaction.selectUnspent(testdata.dataUnspent,0.9,true);
+    u = Transaction.selectUnspent(testdata.dataUnspent, 0.9, true);
     u.length.should.equal(3);
 
-    var u = Transaction.selectUnspent(testdata.dataUnspent,0.11);
+    u = Transaction.selectUnspent(testdata.dataUnspent, 0.11);
     u.length.should.equal(2);
-    var u = Transaction.selectUnspent(testdata.dataUnspent,0.111);
+    u = Transaction.selectUnspent(testdata.dataUnspent, 0.111);
     should.not.exist(u);
   });
 
@@ -84,8 +113,11 @@ describe('Transaction', function() {
   };
 
   it('#create should be able to create instance', function() {
-    var utxos =testdata.dataUnspent;
-    var outs = [{address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:0.08}];
+    var utxos = testdata.dataUnspent;
+    var outs = [{
+      address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+      amount: 0.08
+    }];
 
     var ret = Transaction.create(utxos, outs, opts);
     should.exist(ret.tx);
@@ -106,24 +138,35 @@ describe('Transaction', function() {
   });
 
   it('#create should fail if not enough inputs ', function() {
-    var utxos =testdata.dataUnspent;
-    var outs = [{address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:80}];
+    var utxos = testdata.dataUnspent;
+    var outs = [{
+      address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+      amount: 80
+    }];
     Transaction
       .create
       .bind(utxos, outs, opts)
-      .should.throw();
+      .should.
+    throw ();
 
-    var outs2 = [{address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:0.5}];
-    should.exist( Transaction.create(utxos, outs2, opts));
+    var outs2 = [{
+      address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+      amount: 0.5
+    }];
+    should.exist(Transaction.create(utxos, outs2, opts));
 
     // do not allow unconfirmed
-    Transaction.create.bind(utxos, outs2).should.throw();
+    Transaction.create.bind(utxos, outs2).should.
+    throw ();
   });
 
 
   it('#create should create same output as bitcoind createrawtransaction ', function() {
-    var utxos =testdata.dataUnspent;
-    var outs = [{address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:0.08}];
+    var utxos = testdata.dataUnspent;
+    var outs = [{
+      address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+      amount: 0.08
+    }];
     var ret = Transaction.create(utxos, outs, opts);
     var tx = ret.tx;
 
@@ -133,10 +176,15 @@ describe('Transaction', function() {
   });
 
   it('#create should create same output as bitcoind createrawtransaction wo remainder', function() {
-    var utxos =testdata.dataUnspent;
+    var utxos = testdata.dataUnspent;
     // no remainder
-    var outs = [{address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:0.08}];
-    var ret = Transaction.create(utxos, outs, {fee:0.03} ); 
+    var outs = [{
+      address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+      amount: 0.08
+    }];
+    var ret = Transaction.create(utxos, outs, {
+      fee: 0.03
+    });
     var tx = ret.tx;
 
     // string output generated from: bitcoind createrawtransaction '[{"txid": "2ac165fa7a3a2b535d106a0041c7568d03b531e58aeccdd3199d7289ab12cfc1","vout":1},{"txid":"2ac165fa7a3a2b535d106a0041c7568d03b531e58aeccdd3199d7289ab12cfc2","vout":0}  ]' '{"mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE":0.08}'
@@ -145,15 +193,21 @@ describe('Transaction', function() {
   });
 
   it('#createAndSign should sign a tx', function() {
-    var utxos =testdata.dataUnspentSign.unspent;
-    var outs = [{address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:0.08}];
+    var utxos = testdata.dataUnspentSign.unspent;
+    var outs = [{
+      address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+      amount: 0.08
+    }];
     var ret = Transaction.createAndSign(utxos, outs, testdata.dataUnspentSign.keyStrings, opts);
     var tx = ret.tx;
     tx.isComplete().should.equal(true);
     tx.ins.length.should.equal(1);
     tx.outs.length.should.equal(2);
 
-    var outs2 = [{address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:16}];
+    var outs2 = [{
+      address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+      amount: 16
+    }];
     var ret2 = Transaction.createAndSign(utxos, outs2, testdata.dataUnspentSign.keyStrings, opts);
     var tx2 = ret2.tx;
     tx2.isComplete().should.equal(true);
@@ -163,8 +217,11 @@ describe('Transaction', function() {
 
   it('#createAndSign should sign an incomplete tx ', function() {
     var keys = ['cNpW8B7XPAzCdRR9RBWxZeveSNy3meXgHD8GuhcqUyDuy8ptCDzJ'];
-    var utxos =testdata.dataUnspentSign.unspent;
-    var outs = [{address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:0.08}];
+    var utxos = testdata.dataUnspentSign.unspent;
+    var outs = [{
+      address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+      amount: 0.08
+    }];
     var ret = Transaction.createAndSign(utxos, outs, keys, opts);
     var tx = ret.tx;
     tx.ins.length.should.equal(1);
@@ -172,8 +229,11 @@ describe('Transaction', function() {
   });
   it('#isComplete should return TX signature status', function() {
     var keys = ['cNpW8B7XPAzCdRR9RBWxZeveSNy3meXgHD8GuhcqUyDuy8ptCDzJ'];
-    var utxos =testdata.dataUnspentSign.unspent;
-    var outs = [{address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:0.08}];
+    var utxos = testdata.dataUnspentSign.unspent;
+    var outs = [{
+      address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+      amount: 0.08
+    }];
     var ret = Transaction.createAndSign(utxos, outs, keys, opts);
     var tx = ret.tx;
     tx.isComplete().should.equal(false);
@@ -182,31 +242,37 @@ describe('Transaction', function() {
   });
 
   it('#sign should sign a tx in multiple steps (case1)', function() {
-    var outs = [{address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:1.08}];
+    var outs = [{
+      address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+      amount: 1.08
+    }];
     var ret = Transaction.create(testdata.dataUnspentSign.unspent, outs, opts);
     var tx = ret.tx;
     var selectedUtxos = ret.selectedUtxos;
 
-    var k1 = testdata.dataUnspentSign.keyStrings.slice(0,1);
+    var k1 = testdata.dataUnspentSign.keyStrings.slice(0, 1);
 
     tx.isComplete().should.equal(false);
 
     tx.sign(selectedUtxos, k1).should.equal(false);
 
-    var k23 = testdata.dataUnspentSign.keyStrings.slice(1,3);
+    var k23 = testdata.dataUnspentSign.keyStrings.slice(1, 3);
     tx.sign(selectedUtxos, k23).should.equal(true);
     tx.isComplete().should.equal(true);
   });
 
   it('#sign should sign a tx in multiple steps (case2)', function() {
-    var outs = [{address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:16}];
+    var outs = [{
+      address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+      amount: 16
+    }];
     var ret = Transaction.create(testdata.dataUnspentSign.unspent, outs, opts);
     var tx = ret.tx;
     var selectedUtxos = ret.selectedUtxos;
 
-    var k1 = testdata.dataUnspentSign.keyStrings.slice(0,1);
-    var k2 = testdata.dataUnspentSign.keyStrings.slice(1,2);
-    var k3 = testdata.dataUnspentSign.keyStrings.slice(2,3);
+    var k1 = testdata.dataUnspentSign.keyStrings.slice(0, 1);
+    var k2 = testdata.dataUnspentSign.keyStrings.slice(1, 2);
+    var k3 = testdata.dataUnspentSign.keyStrings.slice(2, 3);
     tx.sign(selectedUtxos, k1).should.equal(false);
     tx.sign(selectedUtxos, k2).should.equal(false);
     tx.sign(selectedUtxos, k3).should.equal(true);
@@ -216,11 +282,14 @@ describe('Transaction', function() {
   it('#createAndSign: should generate dynamic fee and readjust (and not) the selected UTXOs', function() {
     //this cases exceeds the input by 1mbtc AFTEr calculating the dynamic fee,
     //so, it should trigger adding a new 10BTC utxo
-    var utxos =testdata.dataUnspentSign.unspent;
+    var utxos = testdata.dataUnspentSign.unspent;
     var outs = [];
-    var n =101;
-    for (var i=0; i<n; i++) {
-      outs.push({address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:0.01});
+    var n = 101;
+    for (var i = 0; i < n; i++) {
+      outs.push({
+        address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+        amount: 0.01
+      });
     }
 
     var ret = Transaction.createAndSign(utxos, outs, testdata.dataUnspentSign.keyStrings, opts);
@@ -238,15 +307,18 @@ describe('Transaction', function() {
 
 
     //this is the complementary case, it does not trigger a new utxo
-    var utxos =testdata.dataUnspentSign.unspent;
-    var outs = [];
-    var n =100;
-    for (var i=0; i<n; i++) {
-      outs.push({address:'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE', amount:0.01});
+    utxos = testdata.dataUnspentSign.unspent;
+    outs = [];
+    n = 100;
+    for (i = 0; i < n; i++) {
+      outs.push({
+        address: 'mrPnbY1yKDBsdgbHbS7kJ8GVm8F66hWHLE',
+        amount: 0.01
+      });
     }
 
-    var ret = Transaction.createAndSign(utxos, outs, testdata.dataUnspentSign.keyStrings, opts); 
-    var tx = ret.tx;
+    ret = Transaction.createAndSign(utxos, outs, testdata.dataUnspentSign.keyStrings, opts);
+    tx = ret.tx;
     tx.getSize().should.equal(3485);
 
     // ins = 1.0101 BTC (1 inputs: 1.0101);
@@ -260,39 +332,49 @@ describe('Transaction', function() {
   });
 
 
-  // Read tests from test/data/tx_valid.json
-  // Format is an array of arrays
-  // Inner arrays are either [ "comment" ]
-  // or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"], serializedTransaction, enforceP2SH
-  // ... where all scripts are stringified scripts.
-  testdata.dataTxValid.forEach(function(datum) {
-    if (datum.length === 3) {
-      it.skip('valid tx=' + datum[1], function(done) {
-        var inputs = datum[0];
-        var map = {};
-        inputs.forEach(function(vin) {
-          var hash = vin[0];
-          var index = vin[1];
-          var scriptPubKey = new Script(new Buffer(vin[2]));
-          map[[hash, index]] = scriptPubKey; //Script.fromStringContent(scriptPubKey);
-          console.log(scriptPubKey.getStringContent());
-          console.log('********************************');
-          done();
 
-        });
-        var raw = new Buffer(datum[1], 'hex');
-        var tx = new Transaction();
-        tx.parse(raw);
 
-        buffertools.toHex(tx.serialize()).should.equal(buffertools.toHex(raw));
+  /*
+   * Bitcoin core transaction tests
+   */
+  // Verify that known valid transactions are intepretted correctly
+  var coreTest = function(data, valid) {
+    data.forEach(function(datum) {
+      if (datum.length < 3) return;
+      var raw = datum[1];
+      var verifyP2SH = datum[2];
 
-        var i = 0;
-        var stx = tx.getStandardizedObject();
-        tx.ins.forEach(function(txin) {
-          var scriptPubKey = map[[stx. in [i].prev_out.hash, stx. in [i].prev_out.n]];
-          i += 1;
-        });
-      });
+      it.skip((valid ? '' : 'in') + 'valid tx=' + raw, function(done) {
+        var cb = function(err, results) {
+          should.not.exist(err);
+          should.exist(results);
+          results.should.equal(valid);
+          done();
+        };
+
+        var testTx = parse_test_transaction(datum);
+        buffertools.toHex(testTx.transaction.serialize()).should.equal(raw);
+        var inputs = testTx.transaction.inputs();
+        for (var i = 0; i < inputs.length; i++) {
+          var input = inputs[i];
+          buffertools.reverse(input[0]);
+          input[0] = buffertools.toHex(input[0]);
+          var mapKey = [input];
+          var scriptPubKey = testTx.inputs[mapKey];
+          if (!scriptPubKey) throw new Error('Bad test: '+datum);
+          testTx.transaction.verifyInput(
+            i,
+            scriptPubKey, {
+              verifyP2SH: verifyP2SH,
+              dontVerifyStrictEnc: true
+            },
+            cb);
         }
       });
+    });
+  };
+
+  coreTest(testdata.dataTxValid, true);
+  coreTest(testdata.dataTxInvalid, false);
+
 });

util/util.js

@@ -1,26 +1,23 @@
-
 var crypto = require('crypto');
 var bignum = require('bignum');
 var Binary = require('binary');
 var Put = require('bufferput');
 var buffertools = require('buffertools');
 var browser;
-if (!process.versions) {
-  // browser version
+var inBrowser = !process.versions;
+if (inBrowser) {
   browser = require('../browser/vendor-bundle.js');
 }
 
 
-var sha256 = exports.sha256 = function (data) {
+var sha256 = exports.sha256 = function(data) {
   return new Buffer(crypto.createHash('sha256').update(data).digest('binary'), 'binary');
 };
-var ripe160 = exports.ripe160 = function (data) {
+var ripe160 = exports.ripe160 = function(data) {
   if (!Buffer.isBuffer(data)) {
     throw new Error('arg should be a buffer');
   }
-
-  if (!process.versions) {
-
+  if (inBrowser) {
     var w = new browser.crypto31.lib.WordArray.init(Crypto.util.bytesToWords(data), data.length);
     var wordArray = browser.crypto31.RIPEMD160(w);
     var words = wordArray.words;
@@ -33,22 +30,22 @@ var ripe160 = exports.ripe160 = function (data) {
   return new Buffer(crypto.createHash('rmd160').update(data).digest('binary'), 'binary');
 };
 
-var sha1 = exports.sha1 = function (data) {
+var sha1 = exports.sha1 = function(data) {
   return new Buffer(crypto.createHash('sha1').update(data).digest('binary'), 'binary');
 };
 
-var twoSha256 = exports.twoSha256 = function (data) {
+var twoSha256 = exports.twoSha256 = function(data) {
   return sha256(sha256(data));
 };
 
-var sha256ripe160 = exports.sha256ripe160 = function (data) {
+var sha256ripe160 = exports.sha256ripe160 = function(data) {
   return ripe160(sha256(data));
 };
 
 /**
  * Format a block hash like the official client does.
  */
-var formatHash = exports.formatHash = function (hash) {
+var formatHash = exports.formatHash = function(hash) {
   var hashEnd = new Buffer(10);
   hash.copy(hashEnd, 0, 22, 32);
   return buffertools.reverse(hashEnd).toString('hex');
@@ -57,7 +54,7 @@ var formatHash = exports.formatHash = function (hash) {
 /**
  * Display the whole hash, as hex, in correct endian order.
  */
-var formatHashFull = exports.formatHashFull = function (hash) {
+var formatHashFull = exports.formatHashFull = function(hash) {
   var copy = new Buffer(hash.length);
   hash.copy(copy);
   var hex = buffertools.toHex(buffertools.reverse(copy));
@@ -69,13 +66,13 @@ var formatHashFull = exports.formatHashFull = function (hash) {
  *
  * Formats a block hash by removing leading zeros and truncating to 10 characters.
  */
-var formatHashAlt = exports.formatHashAlt = function (hash) {
+var formatHashAlt = exports.formatHashAlt = function(hash) {
   var hex = formatHashFull(hash);
   hex = hex.replace(/^0*/, '');
   return hex.substr(0, 10);
 };
 
-var formatBuffer = exports.formatBuffer = function (buffer, maxLen) {
+var formatBuffer = exports.formatBuffer = function(buffer, maxLen) {
   // Calculate amount of bytes to display
   if (maxLen === null) {
     maxLen = 10;
@@ -96,41 +93,47 @@ var formatBuffer = exports.formatBuffer = function (buffer, maxLen) {
   return output;
 };
 
-var valueToBigInt = exports.valueToBigInt = function (valueBuffer) {
+var valueToBigInt = exports.valueToBigInt = function(valueBuffer) {
   if (Buffer.isBuffer(valueBuffer)) {
-    return bignum.fromBuffer(valueBuffer, {endian: 'little', size: 8});
+    return bignum.fromBuffer(valueBuffer, {
+      endian: 'little',
+      size: 8
+    });
   } else {
     return valueBuffer;
   }
 };
 
-var bigIntToValue = exports.bigIntToValue = function (valueBigInt) {
+var bigIntToValue = exports.bigIntToValue = function(valueBigInt) {
   if (Buffer.isBuffer(valueBigInt)) {
     return valueBigInt;
   } else {
-    return valueBigInt.toBuffer({endian: 'little', size: 8});
+    return valueBigInt.toBuffer({
+      endian: 'little',
+      size: 8
+    });
   }
 };
 
 var fitsInNBits = function(integer, n) {
   // TODO: make this efficient!!!
-  return integer.toString(2).replace('-','').length < n;
+  return integer.toString(2).replace('-', '').length < n;
 };
 exports.bytesNeededToStore = bytesNeededToStore = function(integer) {
   if (integer === 0) return 0;
-  return Math.ceil(((integer).toString(2).replace('-','').length + 1)/ 8);
+  return Math.ceil(((integer).toString(2).replace('-', '').length + 1) / 8);
 };
 
 exports.negativeBuffer = negativeBuffer = function(b) {
   // implement two-complement negative
   var c = new Buffer(b.length);
   // negate each byte
-  for (var i=0; i<b.length; i++){
+  for (var i = 0; i < b.length; i++) {
     c[i] = ~b[i];
     if (c[i] < 0) c[i] += 256;
   }
   // add one
-  for (var i=b.length - 1; i>=0; i--){
+  for (var i = b.length - 1; i >= 0; i--) {
     c[i] += 1;
     if (c[i] >= 256) c[i] -= 256;
     if (c[i] !== 0) break;
@@ -149,9 +152,9 @@ exports.intToBuffer2C = function(integer) {
   var buf = new Put();
   var s = integer.toString(16);
   var neg = s[0] === '-';
-  s = s.replace('-','');
-  for (var i=0; i<size; i++) {
-    var si = s.substring(s.length - 2*(i+1), s.length - 2*(i));
+  s = s.replace('-', '');
+  for (var i = 0; i < size; i++) {
+    var si = s.substring(s.length - 2 * (i + 1), s.length - 2 * (i));
     if (si.lenght === 1) {
       si = '0' + si;
     }
@@ -234,49 +237,44 @@ exports.bufferSMToInt = function(v) {
 
 
 
-var formatValue = exports.formatValue = function (valueBuffer) {
+var formatValue = exports.formatValue = function(valueBuffer) {
   var value = valueToBigInt(valueBuffer).toString();
-  var integerPart = value.length > 8 ? value.substr(0, value.length-8) : '0';
-  var decimalPart = value.length > 8 ? value.substr(value.length-8) : value;
+  var integerPart = value.length > 8 ? value.substr(0, value.length - 8) : '0';
+  var decimalPart = value.length > 8 ? value.substr(value.length - 8) : value;
   while (decimalPart.length < 8) {
-    decimalPart = "0"+decimalPart;
+    decimalPart = "0" + decimalPart;
   }
   decimalPart = decimalPart.replace(/0*$/, '');
   while (decimalPart.length < 2) {
     decimalPart += "0";
   }
-  return integerPart+"."+decimalPart;
+  return integerPart + "." + decimalPart;
 };
 
 var reFullVal = /^\s*(\d+)\.(\d+)/;
 var reFracVal = /^\s*\.(\d+)/;
 var reWholeVal = /^\s*(\d+)/;
 
-function padFrac(frac)
-{
-  frac=frac.substr(0,8); //truncate to 8 decimal places
+function padFrac(frac) {
+  frac = frac.substr(0, 8); //truncate to 8 decimal places
   while (frac.length < 8)
     frac = frac + '0';
   return frac;
 }
 
-function parseFullValue(res)
-{
+function parseFullValue(res) {
   return bignum(res[1]).mul('100000000').add(padFrac(res[2]));
 }
 
-function parseFracValue(res)
-{
+function parseFracValue(res) {
   return bignum(padFrac(res[1]));
 }
 
-function parseWholeValue(res)
-{
+function parseWholeValue(res) {
   return bignum(res[1]).mul('100000000');
 }
 
-exports.parseValue = function parseValue(valueStr)
-{
+exports.parseValue = function parseValue(valueStr) {
   if (typeof valueStr !== 'string')
     valueStr = valueStr.toString();
 
@@ -296,11 +294,11 @@ exports.parseValue = function parseValue(valueStr)
 };
 
 // Utility that synchronizes function calls based on a key
-var createSynchrotron = exports.createSynchrotron = function (fn) {
+var createSynchrotron = exports.createSynchrotron = function(fn) {
   var table = {};
-  return function (key) {
+  return function(key) {
     var args = Array.prototype.slice.call(arguments);
-    var run = function () {
+    var run = function() {
       // Function fn() will call when it finishes
       args[0] = function next() {
         if (table[key]) {
@@ -333,21 +331,23 @@ var createSynchrotron = exports.createSynchrotron = function (fn) {
  *
  * @returns Buffer random nonce
  */
-var generateNonce = exports.generateNonce = function () {
-  var b32 = 0x100000000, ff = 0xff;
-  var b = new Buffer(8), i = 0;
+var generateNonce = exports.generateNonce = function() {
+  var b32 = 0x100000000,
+    ff = 0xff;
+  var b = new Buffer(8),
+    i = 0;
 
   // Generate eight random bytes
-  r = Math.random()*b32;
+  r = Math.random() * b32;
   b[i++] = r & ff;
-  b[i++] = (r=r>>>8) & ff;
-  b[i++] = (r=r>>>8) & ff;
-  b[i++] = (r=r>>>8) & ff;
-  r = Math.random()*b32;
+  b[i++] = (r = r >>> 8) & ff;
+  b[i++] = (r = r >>> 8) & ff;
+  b[i++] = (r = r >>> 8) & ff;
+  r = Math.random() * b32;
   b[i++] = r & ff;
-  b[i++] = (r=r>>>8) & ff;
-  b[i++] = (r=r>>>8) & ff;
-  b[i++] = (r=r>>>8) & ff;
+  b[i++] = (r = r >>> 8) & ff;
+  b[i++] = (r = r >>> 8) & ff;
+  b[i++] = (r = r >>> 8) & ff;
 
   return b;
 };
@@ -357,10 +357,10 @@ var generateNonce = exports.generateNonce = function () {
  *
  * This function calculates the difficulty target given the difficulty bits.
  */
-var decodeDiffBits = exports.decodeDiffBits = function (diffBits, asBigInt) {
+var decodeDiffBits = exports.decodeDiffBits = function(diffBits, asBigInt) {
   diffBits = +diffBits;
   var target = bignum(diffBits & 0xffffff);
-  target = target.shiftLeft(8*((diffBits >>> 24) - 3));
+  target = target.shiftLeft(8 * ((diffBits >>> 24) - 3));
 
   if (asBigInt) {
     return target;
@@ -370,7 +370,7 @@ var decodeDiffBits = exports.decodeDiffBits = function (diffBits, asBigInt) {
   var diffBuf = target.toBuffer();
   var targetBuf = new Buffer(32);
   buffertools.fill(targetBuf, 0);
-  diffBuf.copy(targetBuf, 32-diffBuf.length);
+  diffBuf.copy(targetBuf, 32 - diffBuf.length);
   return targetBuf;
 };
 
@@ -394,7 +394,7 @@ var encodeDiffBits = exports.encodeDiffBits = function encodeDiffBits(target) {
   var compact = size << 24;
   if (size >= 1) compact |= mpiBuf[4] << 16;
   if (size >= 2) compact |= mpiBuf[5] << 8;
-  if (size >= 3) compact |= mpiBuf[6]      ;
+  if (size >= 3) compact |= mpiBuf[6];
 
   return compact;
 };
@@ -405,16 +405,20 @@ var encodeDiffBits = exports.encodeDiffBits = function encodeDiffBits(target) {
  * This function calculates the maximum difficulty target divided by the given
  * difficulty target.
  */
-var calcDifficulty = exports.calcDifficulty = function (target) {
+var calcDifficulty = exports.calcDifficulty = function(target) {
   if (!Buffer.isBuffer(target)) {
     target = decodeDiffBits(target);
   }
-  var targetBigint = bignum.fromBuffer(target, {order: 'forward'});
-  var maxBigint = bignum.fromBuffer(MAX_TARGET, {order: 'forward'});
+  var targetBigint = bignum.fromBuffer(target, {
+    order: 'forward'
+  });
+  var maxBigint = bignum.fromBuffer(MAX_TARGET, {
+    order: 'forward'
+  });
   return maxBigint.div(targetBigint).toNumber();
 };
 
-var reverseBytes32 = exports.reverseBytes32 = function (data) {
+var reverseBytes32 = exports.reverseBytes32 = function(data) {
   if (data.length % 4) {
     throw new Error("Util.reverseBytes32(): Data length must be multiple of 4");
   }