separate TxProposal to a different class. new tests

js/models/core/TxProposal.js

@@ -0,0 +1,226 @@
+'use strict';
+
+var bitcore = require('bitcore');
+var util = bitcore.util;
+var Transaction = bitcore.Transaction;
+var BuilderMockV0 = require('./BuilderMockV0');;
+var TransactionBuilder = bitcore.TransactionBuilder;
+var Script = bitcore.Script;
+var Key = bitcore.Key;
+var buffertools = bitcore.buffertools;
+var preconditions = require('preconditions').instance();
+
+
+function TxProposal(opts) {
+  preconditions.checkArgument(opts);
+  preconditions.checkArgument(opts.inputChainPaths);
+  preconditions.checkArgument(opts.creator);
+  preconditions.checkArgument(opts.createdTs);
+  preconditions.checkArgument(opts.builder);
+
+
+  this.creator = opts.creator;
+  this.createdTs = opts.createdTs;
+  this.builder = opts.builder;
+  this.inputChainPaths = opts.inputChainPaths;
+
+  this._inputSignedBy = [];
+  this.seenBy = opts.seenBy || {};
+  this.signedBy = opts.signedBy || {};
+  this.rejectedBy = opts.rejectedBy || {};
+  this.sentTs = opts.sentTs || null;
+  this.sentTxid = opts.sentTxid || null;
+  this.comment = opts.comment || null;
+  this.readonly = opts.readonly || null;
+  this._updateSignedBy();
+}
+
+TxProposal.prototype.getId = function() {
+  return this.builder.build().getNormalizedHash().toString('hex');
+};
+
+TxProposal.prototype.toObj = function() {
+  var o = JSON.parse(JSON.stringify(this));
+  delete o['builder'];
+  o.builderObj = this.builder.toObj();
+  return o;
+};
+
+
+TxProposal.prototype.setSent = function(sentTxid) {
+  this.sentTxid = sentTxid;
+  this.sentTs = Date.now();
+};
+
+TxProposal.fromObj = function(o, forceOpts) {
+  preconditions.checkArgument(o.builderObj);
+  delete o['builder'];
+
+  try {
+    // force opts is requested.
+    for (var k in forceOpts) {
+      o.builderObj.opts[k] = forceOpts[k];
+    }
+    o.builder = TransactionBuilder.fromObj(o.builderObj);
+  } catch (e) {
+    if (!o.version) {
+      o.builder = new BuilderMockV0(o.builderObj);
+      o.readonly = 1;
+    };
+  }
+  var t = new TxProposal(o);
+  t._throwIfInvalid();
+  t._updateSignedBy();
+  return t;
+};
+
+
+
+TxProposal.prototype._formatKeys = function(allowedPubKeys) {
+  var keys = [];
+  for (var i in allowedPubKeys) {
+    if (!Buffer.isBuffer(allowedPubKeys[i]))
+      throw new Error('allowedPubKeys must be buffers');
+
+    var k = new Key();
+    k.public = allowedPubKeys[i];
+    keys.push[k];
+  };
+};
+
+TxProposal.prototype._verifySignatures = function(inKeys, scriptSig, txSigHash) {
+  preconditions.checkArgument(Buffer.isBuffer(txSigHash));
+
+  if (scriptSig.chunks[0] !== 0)
+    throw new Error('Invalid scriptSig');
+
+  var keys = this._formatKeys(inKeys);
+  var ret = [];
+  for (var i = 1; typeof ret === 'undefined' && i <= scriptSig.countSignatures(); i++) {
+    var chunk = scriptSig.chunks[i];
+    var sigRaw = new Buffer(chunk.slice(0, chunk.length - 1));
+    for (var j in keys) {
+      var k = keys[j];
+      if (k.verifySignatureSync(txSigHash, sigRaw)) {
+        ret.push(j);
+      }
+    }
+  }
+  return ret;
+};
+
+TxProposal.prototype._keysFromRedeemScript = function(s) {
+  var redeemScript =  new Script(s.chunks[s.chunks.length-1]);
+  if (!redeemScript)
+    throw new Error('Bad scriptSig');
+  var pubkeys = redeemScript.capture();
+  if (!pubkeys || !pubkeys.length)
+    throw new Error('Bad scriptSig');
+
+  return pubkeys;
+};
+
+TxProposal.prototype._updateSignedBy = function() {
+  this._inputSignedBy = [];
+
+  var tx = this.builder.build();
+  for (var i in tx.ins) {
+    var scriptSig = new Script(tx.ins[i].s);
+
+    var keys = this._keysFromRedeemScript(scriptSig);
+    var txSigHash = tx.hashForSignature(this.builder.inputMap[i].scriptPubKey, i, Transaction.SIGHASH_ALL);
+    var copayerIndex = this._verifySignatures(keys, scriptSig, txSigHash);
+    if (typeof copayerIndex === 'undefined')
+      throw new Error('Invalid signature');
+    this._inputSignedBy[i] = this._inputSignedBy[i] || {};
+    this._inputSignedBy[i][copayerIndex] = true;
+  };
+};
+
+TxProposal.prototype.isValid = function() {
+
+  if (this.builder.signhash && this.builder.signhash !== Transaction.SIGHASH_ALL) {
+    return false;
+  }
+
+  var tx = this.builder.build();
+  if (!tx.ins.length)
+    return false;
+
+  for (var i = 0; i < tx.ins.length; i++) {
+    var hashType = tx.getHashType(i);
+    if (hashType && hashType !== Transaction.SIGHASH_ALL) {
+      return false;
+    }
+  }
+
+  console.log('[TxProposal.js.145]'); //TODO
+
+  //Should be signed
+  var scriptSigs = this.builder.vanilla.scriptSigs;
+  if (!scriptSigs)
+    return false;
+
+
+  console.log('[TxProposal.js.153]'); //TODO
+  return true;
+};
+
+
+TxProposal.prototype._throwIfInvalid = function(allowedPubKeys) {
+  if (!this.isValid(allowedPubKeys))
+    throw new Error('Invalid tx proposal');
+};
+
+
+TxProposal.prototype.merge = function(incoming, allowedPubKeys) {
+  var ret = {};
+  ret.events = [];
+  incoming._throwIfInvalid(allowedPubKeys);
+
+  /* TODO */
+
+  /*
+     events.push({
+type: 'seen',
+cId: k,
+txId: ntxid
+});
+events.push({
+type: 'signed',
+cId: k,
+txId: ntxid
+});
+events.push({
+type: 'rejected',
+cId: k,
+txId: ntxid
+});
+ret.events = this.mergeMetadata(incoming);
+*/
+  ret.hasChanged = this.mergeBuilder(incoming);
+  return ret;
+};
+
+TxProposal.prototype.mergeBuilder = function(incoming) {
+  var b0 = this.builder;
+  var b1 = incoming.builder;
+
+  var before = JSON.stringify(b0.toObj());
+  b0.merge(b1);
+  var after = JSON.stringify(b0.toObj());
+  return after !== before;
+};
+
+
+//This should be on bitcore / Transaction
+TxProposal.prototype.countSignatures = function() {
+  var tx = this.builder.build();
+
+  var ret = 0;
+  for (var i in tx.ins) {
+    ret += tx.countInputSignatures(i);
+  }
+  return ret;
+};
+module.exports = TxProposal;