Transaction parsing

lib/full_node.js

@@ -0,0 +1,14 @@
+//      
+var bcoin = require('bcoin');
+var TrustIsRisk = require('./trust_is_risk');
+
+class FullNode extends bcoin.fullnode {
+
+
+  constructor(options         ) {
+    super(options);
+    this.trust = new TrustIsRisk(this);
+  }
+}
+
+module.exports = FullNode;

lib/index.js

@@ -1,12 +1,5 @@
 //      
-var bcoin = require('bcoin');
-
-class fullnode extends bcoin.fullnode {
-  constructor(options         ) {
-    super(options);
-  }
-}
-
 module.exports = {
-  fullnode
+  FullNode: require('./full_node'),
+  TrustIsRisk: require('./trust_is_risk')
 }

lib/trust_is_risk.js

@@ -0,0 +1,202 @@
+//      
+var bcoin = require('bcoin');
+var assert = require('assert');
+var Address = bcoin.primitives.Address;
+
+                      // base58 bitcoin address
+
+
+
+
+
+
+
+
+
+
+class TrustIsRisk {
+
+
+
+
+
+
+
+
+
+
+
+
+  constructor(node                 ) {
+    this.node = node;
+    this.directTrust = {};
+    this.TXToTrust = {};
+
+    this.node.on('tx', this.addTX.bind(this));
+  }
+
+  getDirectTrust(from         , to         )          {
+    if (!this.directTrust.hasOwnProperty(from)) return 0;
+    if (!this.directTrust[from].hasOwnProperty(to)) return 0;
+    return this.directTrust[from][to];
+  }
+
+  // Attempts to parse a bitcoin transaction as a trust change and adds it to the trust network
+  // if successful.
+  // Returns true if the transaction is a TIR transaction and was successfully added to the
+  // network, false otherwise.
+  // Throws an error if the transaction was processed earlier.
+  addTX(tx           )           {
+    var txHash = tx.hash().toString('hex');
+    if (this.TXToTrust.hasOwnProperty(txHash)) {
+      throw new Error('Duplicate TX: Transaction with hash ' + txHash + ' has been seen again.');
+    }
+
+    var trustChanges = this.getTrustChanges(tx);
+    if (trustChanges.length === 0) return false;
+    else {
+      trustChanges.map(this.applyTrustChange.bind(this));
+      return true;
+    }
+  }
+
+  // Returns a list of trust changes that a transaction causes, which will be one of the following:
+  //   * An empty list (for non-TIR transactions).
+  //   * A list containing a single trust increase (for trust-increasing transactions).
+  //   * A list containing one or more trust decreases (for trust-decreasing transactions).
+  getTrustChanges(tx           )                 {
+    var trustIncrease = this.parseTXAsTrustIncrease(tx);
+    if (trustIncrease !== null) {
+      return [trustIncrease];
+    } else {
+      return this.getTrustDecreases(tx);
+    }
+  }
+
+  applyTrustChange(trustChange              ) {
+    if (!this.directTrust.hasOwnProperty(trustChange.from)) this.directTrust[trustChange.from] = {};
+    if (!this.directTrust[trustChange.from].hasOwnProperty(trustChange.to)) {
+      this.directTrust[trustChange.from][trustChange.to] = 0
+    }
+
+    this.directTrust[trustChange.from][trustChange.to] += trustChange.amount;
+
+    if (this.directTrust[trustChange.from][trustChange.to] > 0) {
+      this.TXToTrust[trustChange.txHash] = {
+        from: trustChange.from,
+        to: trustChange.to,
+        amount: this.directTrust[trustChange.from][trustChange.to],
+        txHash: trustChange.txHash,
+        outputIndex: trustChange.outputIndex
+      };
+    }
+  }
+
+  parseTXAsTrustIncrease(tx           )                        {
+    if (tx.inputs.length !== 1) return null;
+    if (tx.inputs[0].getType() !== 'pubkeyhash') return null; // TODO: This is unreliable
+    if (this.TXToTrust[tx.inputs[0].prevout.hash.toString('hex')]) return null;
+    var sender = tx.inputs[0].getAddress().toBase58();
+
+    if (tx.outputs.length === 0 || tx.outputs.length > 2) return null;
+
+    var trustOutputs = this.searchForDirectTrustOutputs(tx, sender);
+    if (trustOutputs.length !== 1) return null;
+
+    var changeOutputCount = tx.outputs.filter((o) => this.isChangeOutput(o, sender)).length
+    if (changeOutputCount + 1 !== tx.outputs.length) return null;
+
+    return trustOutputs[0];
+  }
+
+  getTrustDecreases(tx           )                 {
+    var inputTrusts = this.getInputTrusts(tx.inputs);
+    return inputTrusts.map(this.getTrustDecrease.bind(this, tx));
+  }
+
+  getInputTrusts(inputs                )                 {
+    return inputs.map((input) => {
+      var trust = this.TXToTrust[input.prevout.hash.toString('hex')]
+      if (trust && trust.outputIndex === input.prevout.index) return trust;
+      else return null;
+    }).filter(Boolean);
+  }
+
+  getTrustDecrease(tx           , prevTrust              )               {
+    var txHash = tx.hash().toString('hex');
+    var nullifyTrust = {
+      from: prevTrust.from,
+      to: prevTrust.to,
+      amount: -prevTrust.amount,
+      txHash,
+      outputIndex: null
+    };
+
+    if (tx.inputs.length !== 1) return nullifyTrust;
+
+    var trustOutputs = this.searchForDirectTrustOutputs(tx, prevTrust.from, prevTrust.to);
+    if (trustOutputs.length != 1) return nullifyTrust;
+    var nextTrust = trustOutputs[0];
+
+    assert(nextTrust.from === prevTrust.from);
+    assert(nextTrust.to === prevTrust.to);
+
+    var trustAmountChange = nextTrust.amount - prevTrust.amount;
+    assert(trustAmountChange <= 0);
+    return {
+      from: nextTrust.from,
+      to: nextTrust.to,
+      amount: trustAmountChange,
+      txHash,
+      outputIndex: nextTrust.outputIndex
+    }
+  }
+
+  // Looks for direct trust outputs that originate from a sender in an array of bitcoin outputs.
+  // If the recipient parameter is set, it will limit the results only to the outputs being sent to
+  // the recipient.
+  searchForDirectTrustOutputs(tx           , sender         , recipient          )                 {
+    var directTrusts = tx.outputs.map((output, outputIndex) =>
+      this.parseOutputAsDirectTrust(tx, outputIndex, sender)
+    ).filter(Boolean);
+
+    if (recipient) {
+      directTrusts.filter((trust) => trust.to === recipient);
+    }
+
+    return directTrusts;
+  }
+
+  isChangeOutput(output               , sender         )           {
+    return (output.getType() === 'pubkeyhash')
+            && (output.getAddress().toBase58() === sender);
+  }
+
+  parseOutputAsDirectTrust(tx           , outputIndex         , sender         )
+                             {
+    var txHash = tx.hash().toString('hex');
+    var output = tx.outputs[outputIndex];
+    if (output.getType() !== 'multisig') return null;
+
+    var addressA = Address.fromHash(bcoin.crypto.hash160(output.script.get(1))).toBase58()
+    var addressB = Address.fromHash(bcoin.crypto.hash160(output.script.get(2))).toBase58();
+
+    if (addressA === addressB) return null;
+
+    var recipient;
+    if (addressA === sender) recipient = addressB;
+    else if (addressB === sender) recipient = addressA;
+    else return null; 
+
+    return {
+      from: sender,
+      to: recipient,
+      amount: Number(output.value),
+      txHash,
+      outputIndex
+    };
+  }
+
+}
+
+module.exports = TrustIsRisk;

package.json

@@ -5,7 +5,7 @@
   "main": "lib/index.js",
   "scripts": {
     "build": "flow-remove-types -d lib/ src/",
-    "test": "npm run build && mocha",
+    "test": "npm run build && mocha -t 5000",
     "prepublish": "npm run build",
     "typecheck": "flow check"
   },
@@ -27,7 +27,10 @@
   "devDependencies": {
     "flow-bin": "^0.45.0",
     "flow-remove-types": "^1.2.0",
-    "should": "^11.2.1"
+    "mocha": "^3.4.2",
+    "should": "^11.2.1",
+    "should-sinon": "0.0.5",
+    "sinon": "^2.2.0"
   },
   "dependencies": {
     "bcoin": "^1.0.0-beta.12"

src/full_node.js

@@ -0,0 +1,14 @@
+// @flow
+var bcoin = require('bcoin');
+var TrustIsRisk = require('./trust_is_risk');
+
+class FullNode extends bcoin.fullnode {
+  trust : TrustIsRisk
+
+  constructor(options : Object) {
+    super(options);
+    this.trust = new TrustIsRisk(this);
+  }
+}
+
+module.exports = FullNode;

src/index.js

@@ -1,12 +1,5 @@
 // @flow
-var bcoin = require('bcoin');
-
-class fullnode extends bcoin.fullnode {
-  constructor(options : Object) {
-    super(options);
-  }
-}
-
 module.exports = {
-  fullnode
+  FullNode: require('./full_node'),
+  TrustIsRisk: require('./trust_is_risk')
 }