From 2b22b49f8340f44650523effaa71dc9ada7d86ee Mon Sep 17 00:00:00 2001
From: wltsmrz <wltsmrz@gmail.com>
Date: Wed, 13 Aug 2014 12:26:00 -0700
Subject: [PATCH] Track unfunded orders in the orderbook. #132

---
 src/js/ripple/amount.js    |  389 +++++++------
 src/js/ripple/meta.js      |  185 ++++--
 src/js/ripple/orderbook.js | 1134 +++++++++++++++++++++++++++++-------
 test/orderbook-test.js     | 1057 +++++++++++++++++++++++++++++++++
 4 files changed, 2309 insertions(+), 456 deletions(-)
 create mode 100644 test/orderbook-test.js

diff --git a/src/js/ripple/amount.js b/src/js/ripple/amount.js
index ad1551d8..987c2dc5 100644
--- a/src/js/ripple/amount.js
+++ b/src/js/ripple/amount.js
@@ -160,157 +160,64 @@ Amount.prototype.add = function(v) {
   return result;
 };
 
-/**
- * Turn this amount into its inverse.
- *
- * @private
- */
-Amount.prototype._invert = function() {
-  this._value = consts.bi_1e32.divide(this._value);
-  this._offset = -32 - this._offset;
-  this.canonicalize();
-
-  return this;
+// Result in terms of this currency and issuer.
+Amount.prototype.subtract = function(v) {
+  // Correctness over speed, less code has less bugs, reuse add code.
+  return this.add(Amount.from_json(v).negate());
 };
 
-/**
- * Return the inverse of this amount.
- *
- * @return {Amount} New Amount object with same currency and issuer, but the
- *   inverse of the value.
- */
-Amount.prototype.invert = function() {
-  return this.copy()._invert();
-};
-
-Amount.prototype.canonicalize = function() {
-  if (!(this._value instanceof BigInteger)) {
-    // NaN.
-    // nothing
-  } else if (this._is_native) {
-    // Native.
-    if (this._value.equals(BigInteger.ZERO)) {
-      this._offset      = 0;
-      this._is_negative = false;
-    } else {
-      // Normalize _offset to 0.
-
-      while (this._offset < 0) {
-        this._value  = this._value.divide(consts.bi_10);
-        this._offset += 1;
-      }
-
-      while (this._offset > 0) {
-        this._value  = this._value.multiply(consts.bi_10);
-        this._offset -= 1;
-      }
-    }
-
-    // XXX Make sure not bigger than supported. Throw if so.
-  } else if (this.is_zero()) {
-    this._offset      = -100;
-    this._is_negative = false;
-  } else {
-    // Normalize mantissa to valid range.
-
-    while (this._value.compareTo(consts.bi_man_min_value) < 0) {
-      this._value  = this._value.multiply(consts.bi_10);
-      this._offset -= 1;
-    }
-
-    while (this._value.compareTo(consts.bi_man_max_value) > 0) {
-      this._value  = this._value.divide(consts.bi_10);
-      this._offset += 1;
-    }
-  }
-
-  return this;
-};
-
-Amount.prototype.clone = function(negate) {
-  return this.copyTo(new Amount(), negate);
-};
-
-Amount.prototype.compareTo = function(v) {
+// Result in terms of this' currency and issuer.
+// XXX Diverges from cpp.
+Amount.prototype.multiply = function(v) {
   var result;
 
-  if (!this.is_comparable(v)) {
-    result  = Amount.NaN();
-  } else if (this._is_negative !== v._is_negative) {
-    // Different sign.
-    result  = this._is_negative ? -1 : 1;
-  } else if (this._value.equals(BigInteger.ZERO)) {
-    // Same sign: positive.
-    result  = v._value.equals(BigInteger.ZERO) ? 0 : -1;
-  } else if (v._value.equals(BigInteger.ZERO)) {
-    // Same sign: positive.
-    result  = 1;
-  } else if (!this._is_native && this._offset > v._offset) {
-    result  = this._is_negative ? -1 : 1;
-  } else if (!this._is_native && this._offset < v._offset) {
-    result  = this._is_negative ? 1 : -1;
+  v = Amount.from_json(v);
+
+  if (this.is_zero()) {
+    result = this;
+  } else if (v.is_zero()) {
+    result = this.clone();
+    result._value = BigInteger.ZERO;
   } else {
-    result  = this._value.compareTo(v._value);
-    if (result > 0) {
-      result  = this._is_negative ? -1 : 1;
-    } else if (result < 0) {
-      result  = this._is_negative ? 1 : -1;
+    var v1 = this._value;
+    var o1 = this._offset;
+    var v2 = v._value;
+    var o2 = v._offset;
+
+    if (this.is_native()) {
+      while (v1.compareTo(consts.bi_man_min_value) < 0) {
+        v1 = v1.multiply(consts.bi_10);
+        o1 -= 1;
+      }
     }
+
+    if (v.is_native()) {
+      while (v2.compareTo(consts.bi_man_min_value) < 0) {
+        v2 = v2.multiply(consts.bi_10);
+        o2 -= 1;
+      }
+    }
+
+    result              = new Amount();
+    result._offset      = o1 + o2 + 14;
+    result._value       = v1.multiply(v2).divide(consts.bi_1e14).add(consts.bi_7);
+    result._is_native   = this._is_native;
+    result._is_negative = this._is_negative !== v._is_negative;
+    result._currency    = this._currency;
+    result._issuer      = this._issuer;
+
+    result.canonicalize();
   }
 
   return result;
 };
 
-// Make d a copy of this. Returns d.
-// Modification of objects internally refered to is not allowed.
-Amount.prototype.copyTo = function(d, negate) {
-  if (typeof this._value === 'object') {
-    this._value.copyTo(d._value);
-  } else {
-    d._value   = this._value;
-  }
-
-  d._offset = this._offset;
-  d._is_native = this._is_native;
-  d._is_negative  = negate
-    ? !this._is_negative    // Negating.
-    : this._is_negative;    // Just copying.
-
-  d._currency     = this._currency;
-  d._issuer       = this._issuer;
-
-  // Prevent negative zero
-  if (d.is_zero()) {
-    d._is_negative = false;
-  }
-
-  return d;
-};
-
-Amount.prototype.currency = function() {
-  return this._currency;
-};
-
-Amount.prototype.equals = function(d, ignore_issuer) {
-  if (typeof d === 'string') {
-    return this.equals(Amount.from_json(d));
-  }
-
-  var result = true;
-
-  result = !((!this.is_valid() || !d.is_valid())
-             || (this._is_native !== d._is_native)
-             || (!this._value.equals(d._value) || this._offset !== d._offset)
-             || (this._is_negative !== d._is_negative)
-             || (!this._is_native && (!this._currency.equals(d._currency) || !ignore_issuer && !this._issuer.equals(d._issuer))));
-
-  return result;
-};
-
 // Result in terms of this' currency and issuer.
 Amount.prototype.divide = function(d) {
   var result;
 
+  d = Amount.from_json(d);
+
   if (d.is_zero()) {
     throw new Error('divide by zero');
   }
@@ -359,8 +266,6 @@ Amount.prototype.divide = function(d) {
 };
 
 /**
- * Calculate a ratio between two amounts.
- *
  * This function calculates a ratio - such as a price - between two Amount
  * objects.
  *
@@ -382,14 +287,15 @@ Amount.prototype.divide = function(d) {
 Amount.prototype.ratio_human = function(denominator, opts) {
   opts = extend({ }, opts);
 
+  var numerator = this;
+
   if (typeof denominator === 'number' && parseInt(denominator, 10) === denominator) {
     // Special handling of integer arguments
-    denominator = Amount.from_json('' + denominator + '.0');
+    denominator = Amount.from_json(String(denominator) + '.0');
   } else {
     denominator = Amount.from_json(denominator);
   }
 
-  var numerator = this;
   denominator = Amount.from_json(denominator);
 
   // If either operand is NaN, the result is NaN.
@@ -397,6 +303,10 @@ Amount.prototype.ratio_human = function(denominator, opts) {
     return Amount.NaN();
   }
 
+  if (denominator.is_zero()) {
+    return Amount.NaN();
+  }
+
   // Apply interest/demurrage
   //
   // We only need to apply it to the second factor, because the currency unit of
@@ -482,6 +392,155 @@ Amount.prototype.product_human = function(factor, opts) {
   return product;
 };
 
+/**
+ * Turn this amount into its inverse.
+ *
+ * @private
+ */
+Amount.prototype._invert = function() {
+  this._value = consts.bi_1e32.divide(this._value);
+  this._offset = -32 - this._offset;
+  this.canonicalize();
+
+  return this;
+};
+
+/**
+ * Return the inverse of this amount.
+ *
+ * @return {Amount} New Amount object with same currency and issuer, but the
+ *   inverse of the value.
+ */
+Amount.prototype.invert = function() {
+  return this.copy()._invert();
+};
+
+Amount.prototype.canonicalize = function() {
+  if (!(this._value instanceof BigInteger)) {
+    // NaN.
+    // nothing
+  } else if (this._is_native) {
+    // Native.
+    if (this._value.equals(BigInteger.ZERO)) {
+      this._offset      = 0;
+      this._is_negative = false;
+    } else {
+      // Normalize _offset to 0.
+
+      while (this._offset < 0) {
+        this._value  = this._value.divide(consts.bi_10);
+        this._offset += 1;
+      }
+
+      while (this._offset > 0) {
+        this._value  = this._value.multiply(consts.bi_10);
+        this._offset -= 1;
+      }
+    }
+
+    // XXX Make sure not bigger than supported. Throw if so.
+  } else if (this.is_zero()) {
+    this._offset      = -100;
+    this._is_negative = false;
+  } else {
+    // Normalize mantissa to valid range.
+
+    while (this._value.compareTo(consts.bi_man_min_value) < 0) {
+      this._value  = this._value.multiply(consts.bi_10);
+      this._offset -= 1;
+    }
+
+    while (this._value.compareTo(consts.bi_man_max_value) > 0) {
+      this._value  = this._value.divide(consts.bi_10);
+      this._offset += 1;
+    }
+  }
+
+  return this;
+};
+
+Amount.prototype.clone = function(negate) {
+  return this.copyTo(new Amount(), negate);
+};
+
+Amount.prototype.compareTo = function(v) {
+  var result;
+
+  v = Amount.from_json(v);
+
+  if (!this.is_comparable(v)) {
+    result  = Amount.NaN();
+  } else if (this._is_negative !== v._is_negative) {
+    // Different sign.
+    result  = this._is_negative ? -1 : 1;
+  } else if (this._value.equals(BigInteger.ZERO)) {
+    // Same sign: positive.
+    result  = v._value.equals(BigInteger.ZERO) ? 0 : -1;
+  } else if (v._value.equals(BigInteger.ZERO)) {
+    // Same sign: positive.
+    result  = 1;
+  } else if (!this._is_native && this._offset > v._offset) {
+    result  = this._is_negative ? -1 : 1;
+  } else if (!this._is_native && this._offset < v._offset) {
+    result  = this._is_negative ? 1 : -1;
+  } else {
+    result  = this._value.compareTo(v._value);
+    if (result > 0) {
+      result  = this._is_negative ? -1 : 1;
+    } else if (result < 0) {
+      result  = this._is_negative ? 1 : -1;
+    }
+  }
+
+  return result;
+};
+
+// Make d a copy of this. Returns d.
+// Modification of objects internally refered to is not allowed.
+Amount.prototype.copyTo = function(d, negate) {
+  if (typeof this._value === 'object') {
+    this._value.copyTo(d._value);
+  } else {
+    d._value   = this._value;
+  }
+
+  d._offset = this._offset;
+  d._is_native = this._is_native;
+  d._is_negative  = negate
+    ? !this._is_negative    // Negating.
+    : this._is_negative;    // Just copying.
+
+  d._currency     = this._currency;
+  d._issuer       = this._issuer;
+
+  // Prevent negative zero
+  if (d.is_zero()) {
+    d._is_negative = false;
+  }
+
+  return d;
+};
+
+Amount.prototype.currency = function() {
+  return this._currency;
+};
+
+Amount.prototype.equals = function(d, ignore_issuer) {
+  if (typeof d === 'string') {
+    return this.equals(Amount.from_json(d));
+  }
+
+  var result = true;
+
+  result = !((!this.is_valid() || !d.is_valid())
+             || (this._is_native !== d._is_native)
+             || (!this._value.equals(d._value) || this._offset !== d._offset)
+             || (this._is_negative !== d._is_negative)
+             || (!this._is_native && (!this._currency.equals(d._currency) || !ignore_issuer && !this._issuer.equals(d._issuer))));
+
+  return result;
+};
+
 // True if Amounts are valid and both native or non-native.
 Amount.prototype.is_comparable = function(v) {
   return this._value instanceof BigInteger
@@ -520,50 +579,6 @@ Amount.prototype.issuer = function() {
   return this._issuer;
 };
 
-// Result in terms of this' currency and issuer.
-// XXX Diverges from cpp.
-Amount.prototype.multiply = function(v) {
-  var result;
-
-  if (this.is_zero()) {
-    result = this;
-  } else if (v.is_zero()) {
-    result = this.clone();
-    result._value = BigInteger.ZERO;
-  } else {
-    var v1 = this._value;
-    var o1 = this._offset;
-    var v2 = v._value;
-    var o2 = v._offset;
-
-    if (this.is_native()) {
-      while (v1.compareTo(consts.bi_man_min_value) < 0) {
-        v1 = v1.multiply(consts.bi_10);
-        o1 -= 1;
-      }
-    }
-
-    if (v.is_native()) {
-      while (v2.compareTo(consts.bi_man_min_value) < 0) {
-        v2 = v2.multiply(consts.bi_10);
-        o2 -= 1;
-      }
-    }
-
-    result              = new Amount();
-    result._offset      = o1 + o2 + 14;
-    result._value       = v1.multiply(v2).divide(consts.bi_1e14).add(consts.bi_7);
-    result._is_native   = this._is_native;
-    result._is_negative = this._is_negative !== v._is_negative;
-    result._currency    = this._currency;
-    result._issuer      = this._issuer;
-
-    result.canonicalize();
-  }
-
-  return result;
-};
-
 // Return a new value.
 Amount.prototype.negate = function() {
   return this.clone('NEGATE');
@@ -953,12 +968,6 @@ Amount.prototype.set_issuer = function(issuer) {
   return this;
 };
 
-// Result in terms of this' currency and issuer.
-Amount.prototype.subtract = function(v) {
-  // Correctness over speed, less code has less bugs, reuse add code.
-  return this.add(Amount.from_json(v).negate());
-};
-
 Amount.prototype.to_number = function(allow_nan) {
   var s = this.to_text(allow_nan);
   return typeof s === 'string' ? Number(s) : s;
diff --git a/src/js/ripple/meta.js b/src/js/ripple/meta.js
index bbdb475c..6bca5575 100644
--- a/src/js/ripple/meta.js
+++ b/src/js/ripple/meta.js
@@ -5,47 +5,51 @@ var Amount  = require('./amount').Amount;
 
 /**
  * Meta data processing facility
+ *
+ * @constructor
+ * @param {Object} transaction metadata
  */
 
-function Meta(raw_data) {
+function Meta(data) {
   var self = this;
 
   this.nodes = [ ];
 
-  raw_data.AffectedNodes.forEach(function(an) {
-    var result = { };
+  if (typeof data !== 'object') {
+    throw new TypeError('Missing metadata');
+  }
 
-    if ((result.diffType = self.diffType(an))) {
-      an = an[result.diffType];
+  if (!Array.isArray(data.AffectedNodes)) {
+    throw new TypeError('Metadata missing AffectedNodes');
+  }
 
-      result.entryType   = an.LedgerEntryType;
-      result.ledgerIndex = an.LedgerIndex;
-      result.fields      = extend({}, an.PreviousFields, an.NewFields, an.FinalFields);
-      result.fieldsPrev  = an.PreviousFields || {};
-      result.fieldsNew   = an.NewFields || {};
-      result.fieldsFinal = an.FinalFields || {};
-
-      // getAffectedBooks will set this
-      // result.bookKey   = undefined;
-
-      self.nodes.push(result);
-    }
-  });
+  data.AffectedNodes.forEach(this.addNode, this);
 };
 
-Meta.node_types = [
+Meta.nodeTypes = [
   'CreatedNode',
   'ModifiedNode',
   'DeletedNode'
 ];
 
-Meta.prototype.diffType = function(an) {
-  var result = false;
+Meta.amountFieldsAffectingIssuer = [
+  'LowLimit',
+  'HighLimit',
+  'TakerPays',
+  'TakerGets'
+];
 
-  for (var i=0; i<Meta.node_types.length; i++) {
-    var x = Meta.node_types[i];
-    if (an.hasOwnProperty(x)) {
-      result = x;
+/**
+ * @api private
+ */
+
+Meta.prototype.getNodeType = function(node) {
+  var result = null;
+
+  for (var i=0; i<Meta.nodeTypes.length; i++) {
+    var type = Meta.nodeTypes[i];
+    if (node.hasOwnProperty(type)) {
+      result = type;
       break;
     }
   }
@@ -53,6 +57,63 @@ Meta.prototype.diffType = function(an) {
   return result;
 };
 
+/**
+ * Add node to metadata
+ *
+ * @param {Object} node
+ * @api private
+ */
+
+Meta.prototype.addNode = function(node) {
+  this._affectedAccounts = void(0);
+  this._affectedBooks = void(0);
+
+  var result = { };
+
+  if ((result.nodeType = this.getNodeType(node))) {
+    node = node[result.nodeType];
+
+    result.diffType    = result.nodeType;
+    result.entryType   = node.LedgerEntryType;
+    result.ledgerIndex = node.LedgerIndex;
+    result.fields      = extend({ }, node.PreviousFields, node.NewFields, node.FinalFields);
+    result.fieldsPrev  = node.PreviousFields || { };
+    result.fieldsNew   = node.NewFields || { };
+    result.fieldsFinal = node.FinalFields || { };
+
+    // getAffectedBooks will set this
+    // result.bookKey   = undefined;
+
+    this.nodes.push(result);
+  }
+};
+
+/**
+ * Get affected nodes array
+ *
+ * @param {Object} filter options
+ * @return {Array} nodes
+ */
+
+Meta.prototype.getNodes = function(options) {
+  if (typeof options === 'object') {
+    return this.nodes.filter(function(node) {
+      if (options.nodeType && options.nodeType !== node.nodeType) {
+        return false;
+      }
+      if (options.entryType && options.entryType !== node.entryType) {
+        return false;
+      }
+      if (options.bookKey && options.bookKey !== node.bookKey) {
+        return false;
+      }
+      return true;
+    });
+  } else {
+    return this.nodes;
+  }
+};
+
 /**
  * Execute a function on each affected node.
  *
@@ -61,7 +122,7 @@ Meta.prototype.diffType = function(an) {
  *
  *   {
  *     // Type of diff, e.g. CreatedNode, ModifiedNode
- *     diffType: 'CreatedNode'
+ *     nodeType: 'CreatedNode'
  *
  *     // Type of node affected, e.g. RippleState, AccountRoot
  *     entryType: 'RippleState',
@@ -72,7 +133,7 @@ Meta.prototype.diffType = function(an) {
  *     // Contains all fields with later versions taking precedence
  *     //
  *     // This is a shorthand for doing things like checking which account
- *     // this affected without having to check the diffType.
+ *     // this affected without having to check the nodeType.
  *     fields: {...},
  *
  *     // Old fields (before the change)
@@ -88,43 +149,39 @@ Meta.prototype.diffType = function(an) {
  * The second parameter to the callback is the index of the node in the metadata
  * (first entry is index 0).
  */
-Meta.prototype.each = function(fn) {
-  for (var i = 0, l = this.nodes.length; i < l; i++) {
-    fn(this.nodes[i], i);
-  }
-};
 
-([
+[
  'forEach',
  'map',
  'filter',
  'every',
+ 'some',
  'reduce'
-]).forEach(function(fn) {
+].forEach(function(fn) {
   Meta.prototype[fn] = function() {
     return Array.prototype[fn].apply(this.nodes, arguments);
   };
 });
 
-var amountFieldsAffectingIssuer = [
-  'LowLimit',
-  'HighLimit',
-  'TakerPays',
-  'TakerGets'
-];
+Meta.prototype.each = Meta.prototype.forEach;
+
+Meta.prototype.getAffectedAccounts = function(from) {
+  if (this._affectedAccounts) {
+    return this._affectedAccounts;
+  }
 
-Meta.prototype.getAffectedAccounts = function() {
   var accounts = [ ];
 
   // This code should match the behavior of the C++ method:
   // TransactionMetaSet::getAffectedAccounts
-  this.nodes.forEach(function(an) {
-    var fields = (an.diffType === 'CreatedNode') ? an.fieldsNew : an.fieldsFinal;
-    for (var i in fields) {
-      var field = fields[i];
+  for (var i=0; i<this.nodes.length; i++) {
+    var node = this.nodes[i];
+    var fields = (node.nodeType === 'CreatedNode') ? node.fieldsNew : node.fieldsFinal;
+    for (var fieldName in fields) {
+      var field = fields[fieldName];
       if (typeof field === 'string' && UInt160.is_valid(field)) {
         accounts.push(field);
-      } else if (amountFieldsAffectingIssuer.indexOf(i) !== -1) {
+      } else if (~Meta.amountFieldsAffectingIssuer.indexOf(fieldName)) {
         var amount = Amount.from_json(field);
         var issuer = amount.issuer();
         if (issuer.is_valid() && !issuer.is_zero()) {
@@ -132,43 +189,53 @@ Meta.prototype.getAffectedAccounts = function() {
         }
       }
     }
-  });
+  }
 
-  return utils.arrayUnique(accounts);
+  this._affectedAccounts = utils.arrayUnique(accounts);
+
+  return  this._affectedAccounts;
 };
 
 Meta.prototype.getAffectedBooks = function() {
+  if (this._affectedBooks) {
+    return this._affectedBooks;
+  }
+
   var books = [ ];
 
-  this.nodes.forEach(function(an) {
-    if (an.entryType !== 'Offer') {
-      return;
+  for (var i=0; i<this.nodes.length; i++) {
+    var node = this.nodes[i];
+
+    if (node.entryType !== 'Offer') {
+      continue;
     }
 
-    var gets = Amount.from_json(an.fields.TakerGets);
-    var pays = Amount.from_json(an.fields.TakerPays);
-
+    var gets = Amount.from_json(node.fields.TakerGets);
+    var pays = Amount.from_json(node.fields.TakerPays);
     var getsKey = gets.currency().to_json();
+    var paysKey = pays.currency().to_json();
+
     if (getsKey !== 'XRP') {
       getsKey += '/' + gets.issuer().to_json();
     }
 
-    var paysKey = pays.currency().to_json();
     if (paysKey !== 'XRP') {
       paysKey += '/' + pays.issuer().to_json();
     }
 
-    var key = [ getsKey, paysKey ].join(':');
+    var key = getsKey + ':' + paysKey;
 
     // Hell of a lot of work, so we are going to cache this. We can use this
     // later to good effect in OrderBook.notify to make sure we only process
     // pertinent offers.
-    an.bookKey = key;
+    node.bookKey = key;
 
     books.push(key);
-  });
+  }
 
-  return utils.arrayUnique(books);
+  this._affectedBooks = utils.arrayUnique(books);
+
+  return this._affectedBooks;
 };
 
 exports.Meta = Meta;
diff --git a/src/js/ripple/orderbook.js b/src/js/ripple/orderbook.js
index 99d30cee..6641ae9e 100644
--- a/src/js/ripple/orderbook.js
+++ b/src/js/ripple/orderbook.js
@@ -4,72 +4,105 @@
 // asks) Which one depends on the ordering of the parameters.
 //
 // Events:
-//  - transaction   A transaction that affects the order book.
-
-// var network = require("./network.js");
+//  - model
+//  - trade
+//  - transaction
 
 var util         = require('util');
-var EventEmitter = require('events').EventEmitter;
 var extend       = require('extend');
+var assert       = require('assert');
+var async        = require('async');
+var EventEmitter = require('events').EventEmitter;
 var Amount       = require('./amount').Amount;
 var UInt160      = require('./uint160').UInt160;
 var Currency     = require('./currency').Currency;
+var log          = require('./log').internal.sub('orderbook');
 
-function OrderBook(remote, currency_gets, issuer_gets, currency_pays, issuer_pays, key) {
+/**
+ * @constructor OrderBook
+ * @param {Remote} remote
+ * @param {String} ask currency
+ * @param {String} ask issuer
+ * @param {String} bid currency
+ * @param {String} bid issuer
+ * @param {String} orderbook key
+ */
+
+function OrderBook(remote, getsC, getsI, paysC, paysI, key) {
   EventEmitter.call(this);
 
   var self = this;
 
-  this._remote        = remote;
-  this._currency_gets = Currency.from_json(currency_gets);
-  this._issuer_gets   = issuer_gets;
-  this._currency_pays = Currency.from_json(currency_pays);
-  this._issuer_pays   = issuer_pays;
-  this._subs          = 0;
-  this._key           = key;
-
-  // We consider ourselves synchronized if we have a current copy of the offers,
-  // we are online and subscribed to updates.
-  this._sync = false;
-
-  // Offers
+  this._remote = remote;
+  this._currencyGets = Currency.from_json(getsC);
+  this._issuerGets = getsI;
+  this._currencyPays = Currency.from_json(paysC);
+  this._issuerPays = paysI;
+  this._key = key;
+  this._subscribed = false;
+  this._shouldSubscribe = true;
+  this._listeners = 0;
   this._offers = [ ];
+  this._ownerFunds = { };
+  this._offerCounts = { };
 
-  function listenerAdded(type, listener) {
-    if (~OrderBook.subscribe_events.indexOf(type)) {
-      self._subs += 1;
-      if (self._subs === 1 && self._remote._connected) {
-        self._subscribe();
+  // We consider ourselves synchronized if we have a current
+  // copy of the offers, we are online and subscribed to updates.
+  this._synchronized = false;
+
+  function listenersModified(action, event) {
+    // Automatically subscribe and unsubscribe to orderbook
+    // on the basis of existing event listeners
+    if (~OrderBook.EVENTS.indexOf(event)) {
+      switch (action) {
+        case 'add':
+          if (++self._listeners === 1) {
+            self.subscribe();
+          }
+          break;
+        case 'remove':
+          if (--self._listeners === 0) {
+            self.unsubscribe();
+          }
+          break;
       }
     }
   };
 
-  this.on('newListener', listenerAdded);
-
-  function listenerRemoved(type, listener) {
-    if (~OrderBook.subscribe_events.indexOf(type)) {
-      self._subs -= 1;
-      if (!self._subs && self._remote._connected) {
-        self._sync = false;
-        self._remote.request_unsubscribe()
-        .books([self.to_json()])
-        .request();
-      }
-    }
-  };
-
-  this.on('removeListener', listenerRemoved);
-
-  // ST: This *should* call _prepareSubscribe.
-  this._remote.on('prepare_subscribe', function(request) {
-    self._subscribe(request);
+  this.on('newListener', function(event) {
+    listenersModified('add', event);
   });
 
-  function remoteDisconnected() {
-    self._sync = false;
+  this.on('removeListener', function(event) {
+    listenersModified('remove', event);
+  });
+
+  this.on('unsubscribe', function() {
+    self._ownerFunds = { };
+    self._remote.removeListener('transaction', updateFundedAmounts);
+    self._remote.removeListener('transaction', updateTransferRate);
+  });
+
+  this._remote.on('prepare_subscribe', function() {
+    self.subscribe();
+  });
+
+  this._remote.on('disconnect', function() {
+    self._ownerFunds = { };
+    self._synchronized = false;
+  });
+
+  function updateFundedAmounts(message) {
+    self.updateFundedAmounts(message);
   };
 
-  this._remote.on('disconnect', remoteDisconnected);
+  this._remote.on('transaction', updateFundedAmounts);
+
+  function updateTransferRate(message) {
+    self.updateTransferRate(message);
+  };
+
+  this._remote.on('transaction', updateTransferRate);
 
   return this;
 };
@@ -77,198 +110,629 @@ function OrderBook(remote, currency_gets, issuer_gets, currency_pays, issuer_pay
 util.inherits(OrderBook, EventEmitter);
 
 /**
- * List of events that require a remote subscription to the orderbook.
- */
-OrderBook.subscribe_events = ['transaction', 'model', 'trade'];
-
-/**
- * Subscribes to orderbook.
- *
- * @private
- */
-OrderBook.prototype._subscribe = function (request) {
-  var self = this;
-
-  if (self.is_valid() && self._subs) {
-    var request = this._remote.request_subscribe();
-    request.addBook(self.to_json(), true);
-
-    request.once('success', function(res) {
-      self._sync   = true;
-      self._offers = res.offers;
-      self.emit('model', self._offers);
-    });
-
-    request.once('error', function(err) {
-      // XXX What now?
-    });
-
-    request.request();
-  }
-};
-
-/**
- * Adds this orderbook to a subscription request.
-
-// ST: Currently this is not working because the server cannot give snapshots
-//     for more than one order book in the same subscribe message.
-
-OrderBook.prototype._prepareSubscribe = function (request) {
-  var self = this;
-  if (self.is_valid() && self._subs) {
-    request.addBook(self.to_json(), true);
-    request.once('success', function(res) {
-      self._sync   = true;
-      self._offers = res.offers;
-      self.emit('model', self._offers);
-    });
-    request.once('error', function(err) {
-      // XXX What now?
-    });
-  }
-};
+ * Events emitted from OrderBook
  */
 
-OrderBook.prototype.to_json = function () {
-  var json = {
-    taker_gets: {
-      currency: this._currency_gets.to_hex()
-    },
-    taker_pays: {
-      currency: this._currency_pays.to_hex()
-    }
-  };
+OrderBook.EVENTS = [ 'transaction', 'model', 'trade', 'offer' ];
 
-  if (!this._currency_gets.is_native()) {
-    json.taker_gets.issuer = this._issuer_gets;
-  }
-
-  if (!this._currency_pays.is_native()) {
-    json.taker_pays.issuer = this._issuer_pays;
-  }
-
-  return json;
-};
+OrderBook.DEFAULT_TRANSFER_RATE = 1000000000;
 
 /**
  * Whether the OrderBook is valid.
  *
  * Note: This only checks whether the parameters (currencies and issuer) are
  *       syntactically valid. It does not check anything against the ledger.
+ *
+ * @return {Boolean} is valid
  */
-OrderBook.prototype.is_valid = function () {
+
+OrderBook.prototype.isValid =
+OrderBook.prototype.is_valid = function() {
   // XXX Should check for same currency (non-native) && same issuer
   return (
-    this._currency_pays && this._currency_pays.is_valid() &&
-    (this._currency_pays.is_native() || UInt160.is_valid(this._issuer_pays)) &&
-
-    this._currency_gets && this._currency_gets.is_valid() &&
-    (this._currency_gets.is_native() || UInt160.is_valid(this._issuer_gets)) &&
-
-    !(this._currency_pays.is_native() && this._currency_gets.is_native())
+    this._currencyPays && this._currencyPays.is_valid() &&
+    (this._currencyPays.is_native() || UInt160.is_valid(this._issuerPays)) &&
+    this._currencyGets && this._currencyGets.is_valid() &&
+    (this._currencyGets.is_native() || UInt160.is_valid(this._issuerGets)) &&
+    !(this._currencyPays.is_native() && this._currencyGets.is_native())
   );
 };
 
-OrderBook.prototype.trade = function(type) {
-  var tradeStr = '0'
-  + ((Currency.from_json(this['_currency_' + type]).is_native()) ? '' : '/'
-     + this['_currency_' + type ] + '/'
-     + this['_issuer_' + type]);
-  return Amount.from_json(tradeStr);
+/**
+ * Initialize orderbook. Get orderbook offers and subscribe to transactions
+ */
+
+OrderBook.prototype.subscribe = function() {
+  var self = this;
+
+  if (!this._shouldSubscribe) {
+    return;
+  }
+
+  if (this._remote.trace) {
+    log.info('subscribing', this._key);
+  }
+
+  this.requestTransferRate();
+
+  this.requestOffers().once('success', function() {
+    self.subscribeTransactions();
+  });
 };
 
 /**
- * Notify object of a relevant transaction.
- *
- * This is only meant to be called by the Remote class. You should never have to
- * call this yourself.
+ * Unhook event listeners and prevent ripple-lib from further work on this
+ * orderbook. There is no more orderbook stream, so "unsubscribe" is nominal
  */
-OrderBook.prototype.notify = function (message) {
-  var self       = this;
-  var changed    = false;
-  var trade_gets = this.trade('gets');
-  var trade_pays = this.trade('pays');
 
-  function handleTransaction(an) {
-    if (an.entryType !== 'Offer' || an.bookKey !== self._key) {
-      return;
+OrderBook.prototype.unsubscribe = function() {
+  var self = this;
+
+  if (this._remote.trace) {
+    log.info('unsubscribing', this._key);
+  }
+
+  this._subscribed = false;
+  this._shouldSubscribe = false;
+
+  OrderBook.EVENTS.forEach(function(event) {
+    this.removeAllListeners(event);
+  }, this);
+
+  this.emit('unsubscribe');
+};
+
+/**
+ * Check that the funds for offer owner have been cached
+ *
+ * @param {String} account address
+ */
+
+OrderBook.prototype.hasCachedFunds = function(account) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  return this._ownerFunds[account] !== void(0);
+};
+
+/**
+ * Add cached offer owner funds
+ *
+ * @param {String} account address
+ * @param {String} funded amount
+ */
+
+OrderBook.prototype.addCachedFunds = function(account, fundedAmount) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  assert(!isNaN(fundedAmount), 'Funded amount is invalid');
+  this._ownerFunds[account] = fundedAmount;
+};
+
+/**
+ * Get cached offer owner funds
+ *
+ * @param {String} account address
+ */
+
+OrderBook.prototype.getCachedFunds = function(account) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  return this._ownerFunds[account];
+};
+
+/**
+ * Remove cached offer owner funds
+ *
+ * @param {String} account address
+ */
+
+OrderBook.prototype.removeCachedFunds = function(account) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  this._ownerFunds[account] = void(0);
+};
+
+/**
+ * Get offer count for offer owner
+ */
+
+OrderBook.prototype.getOfferCount = function(account) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  return this._offerCounts[account] || 0;
+};
+
+/**
+ * Increment offer count for offer owner
+ */
+
+OrderBook.prototype.incrementOfferCount = function(account) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  var result = (this._offerCounts[account] || 0) + 1;
+  this._offerCounts[account] = result;
+  return result;
+};
+
+/**
+ * Decrement offer count for offer owner
+ */
+
+OrderBook.prototype.decrementOfferCount = function(account) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  var result = (this._offerCounts[account] || 1) - 1;
+  this._offerCounts[account] = result;
+  return result;
+};
+
+/**
+ * Compute funded amount for a balance/transferRate
+ *
+ * @param {String} balance
+ * @param [String] transferRate
+ * @return {Amount} funded amount
+ */
+
+OrderBook.prototype.applyTransferRate = function(balance, transferRate) {
+  assert(!isNaN(balance), 'Balance is invalid');
+
+  if (this._currencyGets.is_native()) {
+    return balance;
+  }
+
+  if (transferRate === void(0)) {
+    transferRate = this._issuerTransferRate;
+  }
+
+  assert(!isNaN(transferRate), 'Transfer rate is invalid');
+
+  if (transferRate === OrderBook.DEFAULT_TRANSFER_RATE) {
+    return balance;
+  }
+
+  var adjustedBalance = Amount.from_json(balance
+   + '/' + this._currencyGets.to_json()
+   + '/' + this._issuerGets
+  )
+  .divide(transferRate)
+  .multiply(Amount.from_json(OrderBook.DEFAULT_TRANSFER_RATE))
+  .to_json()
+  .value;
+
+  return adjustedBalance;
+};
+
+/**
+ * Request transfer rate for this orderbook's issuer
+ *
+ * @param [Function] calback
+ */
+
+OrderBook.prototype.requestTransferRate = function(callback) {
+  var self = this;
+
+  var issuer = this._issuerGets;
+
+  this.once('transfer_rate', function(rate) {
+    if (typeof callback === 'function') {
+      callback(null, rate);
+    }
+  });
+
+  if (this._currencyGets.is_native()) {
+    // Transfer rate is default
+    return this.emit('transfer_rate', OrderBook.DEFAULT_TRANSFER_RATE);
+  }
+
+  if (this._issuerTransferRate) {
+    // Transfer rate has been cached
+    return this.emit('transfer_rate', this._issuerTransferRate);
+  }
+
+  this._remote.requestAccountInfo(issuer, function(err, info) {
+    if (err) {
+      // XXX What now?
+      return callback(err);
     }
 
-    var i, l, offer;
+    var transferRate = info.account_data.TransferRate
+    || OrderBook.DEFAULT_TRANSFER_RATE;
 
-    switch(an.diffType) {
-      case 'DeletedNode':
-      case 'ModifiedNode':
-        var deletedNode = an.diffType === 'DeletedNode';
+    self._issuerTransferRate = transferRate;
+    self.emit('transfer_rate', transferRate);
+  });
+};
 
-        for (i=0, l=self._offers.length; i<l; i++) {
-          offer = self._offers[i];
+/**
+ * Set funded amount on offer. All offers have taker_gets_funded property,
+ * which reflects the amount this account can afford to offer. All offers have
+ * is_fully_funded property, indicating whether these funds are sufficient for
+ * the offer placed.
+ *
+ * @param {Object} offer
+ * @param {String} funds
+ * @return offer
+ */
 
-          if (offer.index === an.ledgerIndex) {
-            if (deletedNode) {
-              self._offers.splice(i, 1);
-            } else {
-              // TODO: This assumes no fields are deleted, which is probably a
-              // safe assumption, but should be checked.
-              extend(offer, an.fieldsFinal);
-            }
+OrderBook.prototype.setFundedAmount = function(offer, fundedAmount) {
+  assert.strictEqual(typeof offer, 'object', 'Offer is invalid');
+  assert(!isNaN(fundedAmount), 'Funds is invalid');
 
-            changed = true;
-            break;
-          }
-        }
+  var iouSuffix = '/USD/rrrrrrrrrrrrrrrrrrrrBZbvji';
 
-        // We don't want to count a OfferCancel as a trade
-        if (message.transaction.TransactionType === 'OfferCancel') {
-          return;
-        }
+  var takerGetsValue = (typeof offer.TakerGets === 'object')
+  ? offer.TakerGets.value
+  : offer.TakerGets;
 
-        trade_gets = trade_gets.add(an.fieldsPrev.TakerGets);
-        trade_pays = trade_pays.add(an.fieldsPrev.TakerPays);
+  var takerGets = Amount.from_json(takerGetsValue + iouSuffix);
 
-        if (!deletedNode) {
-          trade_gets = trade_gets.subtract(an.fieldsFinal.TakerGets);
-          trade_pays = trade_pays.subtract(an.fieldsFinal.TakerPays);
-        }
-        break;
+  offer.is_fully_funded = Amount.from_json(
+    fundedAmount + iouSuffix
+  ).compareTo(takerGets) >= 0;
 
-      case 'CreatedNode':
-        // XXX Should use Amount#from_quality
-        var price = Amount.from_json(an.fields.TakerPays).ratio_human(an.fields.TakerGets, {reference_date: new Date()});
+  if (offer.is_fully_funded) {
+    offer.taker_gets_funded = takerGetsValue;
+  } else {
+    offer.taker_gets_funded = fundedAmount;
+  }
 
-        for (i = 0, l = self._offers.length; i < l; i++) {
-          offer = self._offers[i];
-          var priceItem = Amount.from_json(offer.TakerPays).ratio_human(offer.TakerGets, {reference_date: new Date()});
+  return offer;
+};
 
-          if (price.compareTo(priceItem) <= 0) {
-            var obj   = an.fields;
-            obj.index = an.ledgerIndex;
-            self._offers.splice(i, 0, an.fields);
-            changed = true;
-            break;
-          }
-        }
-        break;
-    }
+/**
+ * Determine what an account is funded to offer for orderbook's
+ * currency/issuer
+ *
+ * @param {String} account
+ * @param {Function} callback
+ */
+
+OrderBook.prototype.requestFundedAmount = function(account, callback) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  assert.strictEqual(typeof callback, 'function', 'Callback is invalid');
+
+  var self = this;
+
+  if (self._remote.trace) {
+    log.info('requesting funds', account);
+  }
+
+  function requestNativeBalance(callback) {
+    self._remote.requestAccountInfo(account, function(err, info) {
+      if (err) {
+        callback(err);
+      } else {
+        callback(null, String(info.account_data.Balance));
+      }
+    });
   };
 
-  message.mmeta.each(handleTransaction);
+  function requestLineBalance(callback) {
+    var request = self._remote.requestAccountLines(
+      account, // account
+      void(0), // account index
+      'VALIDATED', // ledger
+      self._issuerGets //peer
+    );
 
-  // Only trigger the event if the account object is actually
-  // subscribed - this prevents some weird phantom events from
-  // occurring.
-  if (this._subs) {
-    this.emit('transaction', message);
-    if (changed) {
-      this.emit('model', this._offers);
+    request.request(function(err, res) {
+      if (err) {
+        return callback(err);
+      }
+
+      var currency = self._currencyGets.to_json();
+      var balance = '0';
+
+      for (var i=0, line; (line=res.lines[i]); i++) {
+        if (line.currency === currency) {
+          balance = line.balance;
+          break;
+        }
+      }
+
+      callback(null, balance);
+    });
+  };
+
+  function computeFundedAmount(err, results) {
+    if (err) {
+      if (self._remote.trace) {
+        log.info('failed to request funds', err);
+      }
+      //XXX What now?
+      return callback(err);
     }
-    if (!trade_gets.is_zero()) {
-      this.emit('trade', trade_pays, trade_gets);
+
+    if (self._remote.trace) {
+      log.info('requested funds', account, results);
+    }
+
+    var balance;
+    var fundedAmount;
+
+    if (self._currencyGets.is_native()) {
+      balance = results[0];
+      fundedAmount = balance;
+    } else {
+      balance = results[1];
+      fundedAmount = self.applyTransferRate(balance, results[0]);
+    }
+
+    callback(null, fundedAmount);
+  };
+
+  var steps = [ ];
+
+  if (this._currencyGets.is_native()) {
+    steps.push(requestNativeBalance);
+  } else {
+    steps.push(this.requestTransferRate.bind(this));
+    steps.push(requestLineBalance);
+  }
+
+  async.parallel(steps, computeFundedAmount);
+};
+
+/**
+ * Get changed balance of an affected node
+ *
+ * @param {Object} RippleState or AccountRoot node
+ * @return {Object} { account, balance }
+ */
+
+OrderBook.prototype.getBalanceChange = function(node) {
+  var result = {
+    account: void(0),
+    balance: void(0)
+  };
+
+  switch (node.entryType) {
+    case 'AccountRoot':
+      result.account = node.fields.Account;
+      result.balance = node.fieldsFinal.Balance;
+      break;
+
+    case 'RippleState':
+      if (node.fields.HighLimit.issuer === this._issuerGets) {
+        result.account = node.fields.LowLimit.issuer;
+        result.balance = node.fieldsFinal.Balance.value;
+      } else if (node.fields.LowLimit.issuer === this._issuerGets) {
+        // Negate balance
+        result.account = node.fields.HighLimit.issuer;
+        result.balance = Amount.from_json(
+          node.fieldsFinal.Balance
+        ).negate().to_json().value;
+      }
+      break;
+  }
+
+  result.isValid = !isNaN(result.balance)
+                && UInt160.is_valid(result.account);
+
+  return result;
+};
+
+/**
+ * Check that affected node represents a balance change
+ *
+ * @param {Object} RippleState or AccountRoot node
+ * @return {Boolean}
+ */
+
+OrderBook.prototype.isBalanceChange = function(node) {
+  // Check balance change
+  if (!(node.fields && node.fields.Balance
+  && node.fieldsPrev && node.fieldsFinal
+  && node.fieldsPrev.Balance && node.fieldsFinal.Balance)) {
+    return false;
+  }
+
+  // Check currency
+  if (this._currencyGets.is_native()) {
+    return !isNaN(node.fields.Balance);
+  }
+
+  if (node.fields.Balance.currency !== this._currencyGets.to_json()) {
+    return false;
+  }
+
+  // Check issuer
+  if (!(node.fields.HighLimit.issuer === this._issuerGets
+     || node.fields.LowLimit.issuer === this._issuerGets)) {
+     return false;
+   }
+
+   return true;
+};
+
+/**
+ * Update funded amounts for offers in the orderbook as new transactions are
+ * streamed from server
+ *
+ * @param {Object} transaction
+ */
+
+OrderBook.prototype.updateFundedAmounts = function(message) {
+  var self = this;
+
+  var affectedAccounts = message.mmeta.getAffectedAccounts();
+
+  var isOwnerAffected = affectedAccounts.some(function(account) {
+    return self.hasCachedFunds(account);
+  });
+
+  if (!isOwnerAffected) {
+    return;
+  }
+
+  if (!this._currencyGets.is_native() && !this._issuerTransferRate) {
+    // Defer until transfer rate is requested
+    if (self._remote.trace) {
+      log.info('waiting for transfer rate');
+    }
+
+    this.once('transfer_rate', function() {
+      self.updateFundedAmounts(message);
+    });
+    return;
+  }
+
+  var nodes = message.mmeta.getNodes({
+    nodeType: 'ModifiedNode',
+    entryType: this._currencyGets.is_native() ? 'AccountRoot' : 'RippleState'
+  });
+
+  for (var i=0; i<nodes.length; i++) {
+    var node = nodes[i];
+
+    if (!this.isBalanceChange(node)) {
+      continue;
+    }
+
+    var result = this.getBalanceChange(node);
+
+    if (result.isValid) {
+      var account = result.account;
+      var balance = result.balance;
+
+      if (this.hasCachedFunds(account)) {
+        var fundedAmount = this.applyTransferRate(balance);
+        this.updateOfferFunds(account, fundedAmount);
+      }
     }
   }
 };
 
-OrderBook.prototype.notifyTx = OrderBook.prototype.notify;
+/**
+ * Update issuer's TransferRate as it changes
+ *
+ * @param {Object} transaction
+ */
+
+OrderBook.prototype.updateTransferRate = function(message) {
+  var self = this;
+
+  var affectedAccounts = message.mmeta.getAffectedAccounts();
+
+  var isIssuerAffected = affectedAccounts.some(function(account) {
+    return account === self._issuerGets;
+  });
+
+  if (!isIssuerAffected) {
+    return;
+  }
+
+  // XXX Update transfer rate
+  //
+  //  var nodes = message.mmeta.getNodes({
+  //    nodeType: 'ModifiedNode',
+  //    entryType: 'AccountRoot'
+  //  });
+};
+
+/**
+ * Request orderbook entries from server
+ */
+
+OrderBook.prototype.requestOffers = function() {
+  var self = this;
+
+  if (!this._shouldSubscribe) {
+    return;
+  }
+
+  if (this._remote.trace) {
+    log.info('requesting offers', this._key);
+  }
+
+  function handleOffers(res) {
+    if (!Array.isArray(res.offers)) {
+      // XXX What now?
+      return;
+    }
+
+    if (!self._currencyGets.is_native() && !self._issuerTransferRate) {
+      // Defer until transfer rate is requested
+      if (self._remote.trace) {
+        log.info('waiting for transfer rate');
+      }
+
+      self.once('transfer_rate', function() {
+        handleOffers(res);
+      });
+      return;
+    }
+
+    if (self._remote.trace) {
+      log.info('requested offers', self._key, 'offers: ' + res.offers.length);
+    }
+
+    self._offers = res.offers.map(function addOffer(offer) {
+      var fundedAmount;
+
+      if (self.hasCachedFunds(offer.Account)) {
+        fundedAmount = self.getCachedFunds(offer.Account);
+      } else if (offer.hasOwnProperty('owner_funds')) {
+        fundedAmount = self.applyTransferRate(offer.owner_funds);
+        self.addCachedFunds(offer.Account, fundedAmount);
+      }
+
+      self.setFundedAmount(offer, fundedAmount);
+      self.incrementOfferCount(offer.Account);
+
+      return offer;
+    });
+
+    self._synchronized = true;
+
+    self.emit('model', self._offers);
+  };
+
+  function handleError(err) {
+    // XXX What now?
+    if (self._remote.trace) {
+      log.info('failed to request offers', self._key, err);
+    }
+  };
+
+  var request = this._remote.requestBookOffers(this.toJSON());
+  request.once('success', handleOffers);
+  request.once('error', handleError);
+  request.request();
+
+  return request;
+};
+
+/**
+ * Subscribe to transactions stream
+ */
+
+OrderBook.prototype.subscribeTransactions = function() {
+  var self = this;
+
+  if (!this._shouldSubscribe) {
+    return;
+  }
+
+  if (this._remote.trace) {
+    log.info('subscribing to transactions');
+  }
+
+  function handleSubscribed() {
+    self._subscribed = true;
+    if (self._remote.trace) {
+      log.info('subscribed to transactions');
+    }
+  };
+
+  function handleError(err) {
+    if (self._remote.trace) {
+      log.info('failed to subscribe to transactions', self._key, err);
+    }
+  };
+
+  var request = this._remote.requestSubscribe();
+  request.addStream('transactions');
+  request.once('success', handleSubscribed);
+  request.once('error', handleError);
+  request.request();
+
+  return request;
+};
 
 /**
  * Get offers model asynchronously.
@@ -276,32 +740,288 @@ OrderBook.prototype.notifyTx = OrderBook.prototype.notify;
  * This function takes a callback and calls it with an array containing the
  * current set of offers in this order book.
  *
- * If the data is available immediately, the callback may be called synchronously.
+ * If the data is available immediately, the callback may be called
+ * synchronously.
+ *
+ * @param {Function} callback
  */
-OrderBook.prototype.offers = function (callback) {
+
+OrderBook.prototype.offers =
+OrderBook.prototype.getOffers = function(callback) {
+  assert.strictEqual(typeof callback, 'function', 'Callback missing');
+
   var self = this;
 
-  if (typeof callback === 'function') {
-    if (this._sync) {
-      callback(this._offers);
-    } else {
-      this.once('model', callback);
-    }
+  if (this._synchronized) {
+    callback(null, this._offers);
+  } else {
+    this.once('model', function(m) {
+      callback(null, m);
+    });
   }
 
   return this;
 };
 
 /**
- * Return latest known offers.
+ * Return latest known offers
  *
  * Usually, this will just be an empty array if the order book hasn't been
  * loaded yet. But this accessor may be convenient in some circumstances.
+ *
+ * @return {Array} offers
  */
-OrderBook.prototype.offersSync = function () {
+
+OrderBook.prototype.offersSync =
+OrderBook.prototype.getOffersSync = function() {
   return this._offers;
 };
 
+/**
+ * Insert an offer into the orderbook
+ *
+ * @param {Object} node
+ */
+
+OrderBook.prototype.insertOffer = function(node, fundedAmount) {
+  if (this._remote.trace) {
+    log.info('inserting offer', this._key, node.fields);
+  }
+
+  var nodeFields = node.fields;
+
+  nodeFields.index = node.ledgerIndex;
+
+  if (!isNaN(fundedAmount)) {
+    this.setFundedAmount(nodeFields, fundedAmount);
+    this.addCachedFunds(nodeFields.Account, fundedAmount);
+  }
+
+  var DATE_REF = {
+    reference_date: new Date()
+  };
+
+  // XXX Should use Amount#from_quality
+  var price = Amount.from_json(
+    nodeFields.TakerPays
+  ).ratio_human(node.fields.TakerGets, DATE_REF);
+
+  for (var i=0, l=this._offers.length; i<l; i++) {
+    var offer = this._offers[i];
+
+    var priceItem = Amount.from_json(
+      offer.TakerPays
+    ).ratio_human(offer.TakerGets, DATE_REF);
+
+    if (price.compareTo(priceItem) <= 0) {
+      this._offers.splice(i, 0, nodeFields);
+      break;
+    } else if (i === (l - 1)) {
+      this._offers.push(nodeFields);
+    }
+  }
+
+  this.emit('offer_added', nodeFields);
+};
+
+/**
+ * Modify an existing offer in the orderbook
+ *
+ * @param {Object} node
+ * @param {Boolean} isDeletedNode
+ */
+
+OrderBook.prototype.modifyOffer = function(node, isDeletedNode) {
+  if (this._remote.trace) {
+    if (isDeletedNode) {
+      log.info('deleting offer', this._key, node.fields);
+    } else {
+      log.info('modifying offer', this._key, node.fields);
+    }
+  }
+
+  for (var i=0; i<this._offers.length; i++) {
+    var offer = this._offers[i];
+    if (offer.index === node.ledgerIndex) {
+      if (isDeletedNode) {
+        // Multiple offers same account?
+        this._offers.splice(i, 1);
+        this.emit('offer_removed', offer);
+      } else {
+        // TODO: This assumes no fields are deleted, which is
+        // probably a safe assumption, but should be checked.
+        var previousOffer = extend({}, offer);
+        extend(offer, node.fieldsFinal);
+        this.emit('offer_changed', previousOffer, offer);
+      }
+      break;
+    }
+  }
+};
+
+/**
+ * Update funded status on offers whose account's balance has changed
+ *
+ * Update cached account funds
+ *
+ * @param {String} account address
+ * @param {String|Object} offer funds
+ */
+
+OrderBook.prototype.updateOfferFunds = function(account, fundedAmount) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  assert(!isNaN(fundedAmount), 'Funded amount is invalid');
+
+  if (this._remote.trace) {
+    log.info('updating offer funds', this._key, account, fundedAmount);
+  }
+
+  // Update cached account funds
+  this.addCachedFunds(account, fundedAmount);
+
+  for (var i=0; i<this._offers.length; i++) {
+    var offer = this._offers[i];
+
+    if (offer.Account === account) {
+      // Update funds for account's offer
+      var previousOffer = extend({}, offer);
+      var previousAmount = offer.taker_gets_funded;
+
+      this.setFundedAmount(offer, fundedAmount);
+
+      this.emit('offer_changed', previousOffer, offer);
+      this.emit('offer_funds_changed', offer, previousAmount, fundedAmount);
+    }
+  }
+};
+
+/**
+ * Notify orderbook of a relevant transaction
+ *
+ * @param {Object} transaction
+ * @api private
+ */
+
+OrderBook.prototype.notify = function(message) {
+  var self = this;
+
+  // Unsubscribed from OrderBook
+  if (!this._subscribed) {
+    return;
+  }
+
+  var affectedNodes = message.mmeta.getNodes({
+    entryType: 'Offer',
+    bookKey: this._key
+  });
+
+  if (affectedNodes.length < 1) {
+    return;
+  }
+
+  if (this._remote.trace) {
+    log.info('notifying', this._key, message.transaction.hash);
+  }
+
+  var tradeGets = Amount.from_json(
+    '0' + ((Currency.from_json(this._currencyGets).is_native())
+           ? ''
+           : ('/' + this._currencyGets + '/' + this._issuerGets))
+  );
+
+  var tradePays = Amount.from_json(
+    '0' + ((Currency.from_json(this._currencyPays).is_native())
+           ? ''
+           : ('/' + this._currencyPays + '/' + this._issuerPays))
+  );
+
+  function handleNode(node, callback) {
+    var isDeletedNode = node.nodeType === 'DeletedNode';
+    var isOfferCancel = message.transaction.TransactionType === 'OfferCancel';
+
+    switch (node.nodeType) {
+      case 'DeletedNode':
+      case 'ModifiedNode':
+         self.modifyOffer(node, isDeletedNode);
+
+        // We don't want to count an OfferCancel as a trade
+        if (!isOfferCancel) {
+          tradeGets = tradeGets.add(node.fieldsPrev.TakerGets);
+          tradePays = tradePays.add(node.fieldsPrev.TakerPays);
+
+          if (isDeletedNode) {
+            if (self.decrementOfferCount(node.fields.Account) < 1) {
+              self.removeCachedFunds(node.fields.Account);
+            }
+          } else {
+            tradeGets = tradeGets.subtract(node.fieldsFinal.TakerGets);
+            tradePays = tradePays.subtract(node.fieldsFinal.TakerPays);
+          }
+        }
+        callback();
+        break;
+
+      case 'CreatedNode':
+        self.incrementOfferCount(node.fields.Account);
+
+        var fundedAmount = message.transaction.owner_funds;
+
+        if (!isNaN(fundedAmount)) {
+          self.insertOffer(node, fundedAmount);
+          return callback();
+        }
+
+        // Get the offer account's balance from server
+        self.requestFundedAmount(
+          node.fields.Account, function(err, fundedAmount) {
+          if (err) {
+            // XXX Now what?
+          } else {
+            self.insertOffer(node, fundedAmount);
+          }
+          callback();
+        });
+        break;
+    }
+  };
+
+  async.eachSeries(affectedNodes, handleNode, function() {
+    self.emit('transaction', message);
+    self.emit('model', self._offers);
+    if (!tradeGets.is_zero()) {
+      self.emit('trade', tradePays, tradeGets);
+    }
+  });
+};
+
+/**
+ * Get request-representation of orderbook
+ *
+ * @return {Object} json
+ */
+
+OrderBook.prototype.toJSON =
+OrderBook.prototype.to_json = function() {
+  var json = {
+    taker_gets: {
+      currency: this._currencyGets.to_hex()
+    },
+    taker_pays: {
+      currency: this._currencyPays.to_hex()
+    }
+  };
+
+  if (!this._currencyGets.is_native()) {
+    json.taker_gets.issuer = this._issuerGets;
+  }
+
+  if (!this._currencyPays.is_native()) {
+    json.taker_pays.issuer = this._issuerPays;
+  }
+
+  return json;
+};
+
 exports.OrderBook = OrderBook;
 
 // vim:sw=2:sts=2:ts=8:et
diff --git a/test/orderbook-test.js b/test/orderbook-test.js
new file mode 100644
index 00000000..f7e37b07
--- /dev/null
+++ b/test/orderbook-test.js
@@ -0,0 +1,1057 @@
+var assert = require('assert');
+var utils = require('./testutils');
+var Remote  = utils.load_module('remote').Remote;
+var Currency = utils.load_module('currency').Currency;
+var Amount = utils.load_module('amount').Amount;
+var Meta = utils.load_module('meta').Meta;
+
+describe('OrderBook', function() {
+  it('toJSON', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+    assert.deepEqual(book.toJSON(), {
+      taker_gets: {
+        currency: Currency.from_json('XRP').to_hex()
+      },
+      taker_pays: {
+        currency: Currency.from_json('BTC').to_hex(),
+        issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji'
+      }
+    });
+  });
+
+  it('Check orderbook validity', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+    assert(book.isValid());
+  });
+
+  it('Automatic subscription (based on listeners)', function(done) {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+    book.subscribe = function() {
+      done();
+    };
+    book.on('model', function(){});
+  });
+
+  it('Subscribe', function(done) {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+
+    var requestedTransferRate = false;
+    var requestedOffers = false;
+
+    book.subscribeTransactions = function() {
+      assert(requestedTransferRate);
+      assert(requestedOffers);
+      done();
+    };
+
+    book.requestTransferRate = function(callback) {
+      requestedTransferRate = true;
+    };
+
+    book.requestOffers = function() {
+      requestedOffers = true;
+      var em = new process.EventEmitter();
+      setImmediate(function() {
+        em.emit('success', { offers: [ ] });
+      });
+      return em;
+    };
+
+    book.subscribe();
+  });
+
+  it('Unsubscribe', function(done) {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+
+    book.once('unsubscribe', function() {
+      done();
+    });
+
+    book.on('model', function(){});
+
+    book.unsubscribe();
+
+    assert(!book._subscribed);
+    assert(!book._shouldConnect);
+    assert.deepEqual(book.listeners(), []);
+  });
+
+  it('Automatic unsubscription (based on listeners)', function(done) {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+    book.unsubscribe = function() {
+      done();
+    };
+    book.on('model', function(){});
+    book.removeAllListeners('model');
+  });
+
+  it('Add cached owner funds', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+    book.addCachedFunds('rrrrrrrrrrrrrrrrrrrrBZbvji', '1');
+    assert.strictEqual(book.getCachedFunds('rrrrrrrrrrrrrrrrrrrrBZbvji'), '1');
+  });
+
+  it('Add cached owner funds - invalid account', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+    assert.throws(function() {
+      book.addCachedFunds('0rrrrrrrrrrrrrrrrrrrrBZbvji', '1');
+    });
+  });
+
+  it('Has cached owner funds', function() {
+    var book =  new Remote().createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+    book.addCachedFunds('rrrrrrrrrrrrrrrrrrrrBZbvji', '1');
+    assert(book.hasCachedFunds('rrrrrrrrrrrrrrrrrrrrBZbvji'));
+  });
+
+  it('Has cached owner funds - invalid account', function() {
+    var book =  new Remote().createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+    assert.throws(function() {
+      book.addCachedFunds('0rrrrrrrrrrrrrrrrrrrrBZbvji', '1');
+    });
+  });
+
+  it('Remove cached owner funds', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+    book.addCachedFunds('rrrrrrrrrrrrrrrrrrrrBZbvji', '1');
+    assert(book.hasCachedFunds('rrrrrrrrrrrrrrrrrrrrBZbvji'));
+    book.removeCachedFunds('rrrrrrrrrrrrrrrrrrrrBZbvji');
+    assert(!book.hasCachedFunds('rrrrrrrrrrrrrrrrrrrrBZbvji'));
+  });
+
+  it('Remove cached owner funds', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+    book.addCachedFunds('rrrrrrrrrrrrrrrrrrrrBZbvji', '1');
+    assert(book.hasCachedFunds('rrrrrrrrrrrrrrrrrrrrBZbvji'));
+    assert.throws(function() {
+      book.removeCachedFunds('0rrrrrrrrrrrrrrrrrrrrBZbvji');
+    });
+  });
+
+  it('Increment offer count', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+    assert.strictEqual(book.incrementOfferCount('rrrrrrrrrrrrrrrrrrrrBZbvji'), 1);
+    assert.strictEqual(book.getOfferCount('rrrrrrrrrrrrrrrrrrrrBZbvji'), 1);
+  });
+
+  it('Increment offer count - invalid address', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+    assert.throws(function() {
+      book.incrementOfferCount('zrrrrrrrrrrrrrrrrrrrBZbvji');
+    });
+  });
+
+  it('Decrement offer count', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+    book.incrementOfferCount('rrrrrrrrrrrrrrrrrrrrBZbvji');
+    assert.strictEqual(book.decrementOfferCount('rrrrrrrrrrrrrrrrrrrrBZbvji'), 0);
+    assert.strictEqual(book.getOfferCount('rrrrrrrrrrrrrrrrrrrrBZbvji'), 0);
+  });
+
+  it('Decrement offer count - invalid address', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+    assert.throws(function() {
+      book.decrementOfferCount('zrrrrrrrrrrrrrrrrrrrBZbvji');
+    });
+  });
+
+  it('Apply transfer rate', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+    assert.strictEqual(book.applyTransferRate('1', 1002000000), '0.9980039920159681');
+  });
+
+  it('Apply transfer rate - cached transfer rate', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+    book._issuerTransferRate = 1002000000;
+    assert.strictEqual(book.applyTransferRate('1'), '0.9980039920159681');
+  });
+
+  it('Apply transfer rate - invalid balance', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+    assert.throws(function() {
+      book.applyTransferRate('asdf');
+    });
+  });
+
+  it('Apply transfer rate - invalid transfer rate', function() {
+    var book = new Remote().createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+    assert.throws(function() {
+      book.applyTransferRate('1', 'asdf');
+    });
+  });
+
+  it('Request transfer rate', function() {
+    var remote = new Remote();
+    var book = remote.createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+
+    remote.request = function(request) {
+      assert.deepEqual(request.message, {
+        command: 'account_info',
+        id: void(0),
+        ident: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+        account: 'rrrrrrrrrrrrrrrrrrrrBZbvji'
+      });
+      request.emit('success', {
+        account_data: {
+          TransferRate: 1002000000
+        }
+      });
+    };
+
+    book.requestTransferRate(function(err, rate) {
+      assert.ifError(err);
+      assert.strictEqual(rate, 1002000000);
+    });
+  });
+
+  it('Request transfer rate - cached transfer rate', function() {
+    var remote = new Remote();
+    var book = remote.createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+
+    book._issuerTransferRate = 1002000000;
+
+    remote.request = function(request) {
+      assert(false);
+    };
+
+    book.requestTransferRate(function(err, rate) {
+      assert.ifError(err);
+      assert.strictEqual(rate, 1002000000);
+    });
+  });
+
+  it('Request transfer rate - native currency', function() {
+    var remote = new Remote();
+    var book = remote.createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+
+    remote.request = function(request) {
+      assert(false);
+    };
+
+    book.requestTransferRate(function(err, rate) {
+      assert.ifError(err);
+      assert.strictEqual(rate, 1000000000);
+    });
+  });
+
+  it('Set funded amount - funded', function() {
+    var remote = new Remote();
+    var book = remote.createOrderBook({
+      currency_pays: 'XRP',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_gets: 'BTC'
+    });
+
+    var offer = {
+      TakerGets: {
+        value: '100',
+        currency: 'BTC',
+        issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji'
+      }
+    };
+
+    book.setFundedAmount(offer, '100.1234');
+
+    assert.deepEqual(offer, {
+      TakerGets: offer.TakerGets,
+      taker_gets_funded: '100',
+      is_fully_funded: true
+    });
+  });
+
+  it('Set funded amount - unfunded', function() {
+    var remote = new Remote();
+    var book = remote.createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+
+    var offer = {
+      TakerGets: {
+        value: '100',
+        currency: 'BTC',
+        issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji'
+      }
+    };
+
+    book.setFundedAmount(offer, '99');
+
+    assert.deepEqual(offer, {
+      TakerGets: offer.TakerGets,
+      taker_gets_funded: '99',
+      is_fully_funded: false
+    });
+  });
+
+  it('Set funded amount - native currency - funded', function() {
+    var remote = new Remote();
+    var book = remote.createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+
+    var offer = {
+      TakerGets: '100'
+    };
+
+    book.setFundedAmount(offer, '100');
+
+    assert.deepEqual(offer, {
+      TakerGets: '100',
+      taker_gets_funded: '100',
+      is_fully_funded: true
+    });
+  });
+
+  it('Set funded amount - native currency - unfunded', function() {
+    var remote = new Remote();
+    var book = remote.createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+
+    var offer = {
+      TakerGets: '100'
+    };
+
+    book.setFundedAmount(offer, '99');
+
+    assert.deepEqual(offer, {
+      TakerGets: '100',
+      taker_gets_funded: '99',
+      is_fully_funded: false
+    });
+  });
+
+  it('Check is balance change', function() {
+    var remote = new Remote();
+
+    var book = remote.createOrderBook({
+      currency_gets: 'USD',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+
+    var meta = new Meta({
+      AffectedNodes: [{
+        ModifiedNode: {
+          FinalFields: {
+            Balance: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '-1'
+            },
+            Flags: 131072,
+            HighLimit: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '100'
+            },
+            HighNode: '0000000000000000',
+            LowLimit: {
+              currency: 'USD',
+              issuer: 'r3PDtZSa5LiYp1Ysn1vMuMzB59RzV3W9QH',
+              value: '0'
+            },
+            LowNode: '0000000000000000'
+          },
+          LedgerEntryType: 'RippleState',
+          LedgerIndex: 'EA4BF03B4700123CDFFB6EB09DC1D6E28D5CEB7F680FB00FC24BC1C3BB2DB959',
+          PreviousFields: {
+            Balance: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '0'
+            }
+          },
+          PreviousTxnID: '53354D84BAE8FDFC3F4DA879D984D24B929E7FEB9100D2AD9EFCD2E126BCCDC8',
+          PreviousTxnLgrSeq: 343570
+        }
+      }]
+    });
+
+    assert(book.isBalanceChange(meta.getNodes()[0]));
+  });
+
+  it('Check is balance change - not balance change', function() {
+    var remote = new Remote();
+
+    var book = remote.createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+
+    var meta = new Meta({
+      AffectedNodes: [{
+        ModifiedNode: {
+          FinalFields: {
+            Balance: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '-1'
+            },
+            Flags: 131072,
+            HighLimit: {
+              currency: 'USD',
+              issuer: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+              value: '100'
+            },
+            HighNode: '0000000000000000',
+            LowLimit: {
+              currency: 'USD',
+              issuer: 'r3PDtZSa5LiYp1Ysn1vMuMzB59RzV3W9QH',
+              value: '0'
+            },
+            LowNode: '0000000000000000'
+          },
+          LedgerEntryType: 'RippleState',
+          LedgerIndex: 'EA4BF03B4700123CDFFB6EB09DC1D6E28D5CEB7F680FB00FC24BC1C3BB2DB959',
+          PreviousTxnID: '53354D84BAE8FDFC3F4DA879D984D24B929E7FEB9100D2AD9EFCD2E126BCCDC8',
+          PreviousTxnLgrSeq: 343570
+        }
+      }]
+    });
+
+    assert(!book.isBalanceChange(meta.getNodes()[0]));
+  });
+
+  it('Check is balance change - different currency', function() {
+    var remote = new Remote();
+
+    var book = remote.createOrderBook({
+      currency_gets: 'BTC',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+
+    var meta = new Meta({
+      AffectedNodes: [{
+        ModifiedNode: {
+          FinalFields: {
+            Balance: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '-1'
+            },
+            Flags: 131072,
+            HighLimit: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '100'
+            },
+            HighNode: '0000000000000000',
+            LowLimit: {
+              currency: 'USD',
+              issuer: 'r3PDtZSa5LiYp1Ysn1vMuMzB59RzV3W9QH',
+              value: '0'
+            },
+            LowNode: '0000000000000000'
+          },
+          LedgerEntryType: 'RippleState',
+          LedgerIndex: 'EA4BF03B4700123CDFFB6EB09DC1D6E28D5CEB7F680FB00FC24BC1C3BB2DB959',
+          PreviousFields: {
+            Balance: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '0'
+            }
+          },
+          PreviousTxnID: '53354D84BAE8FDFC3F4DA879D984D24B929E7FEB9100D2AD9EFCD2E126BCCDC8',
+          PreviousTxnLgrSeq: 343570
+        }
+      }]
+    });
+
+    assert(!book.isBalanceChange(meta.getNodes()[0]));
+  });
+
+  it('Check is balance change - different issuer', function() {
+    var remote = new Remote();
+
+    var book = remote.createOrderBook({
+      currency_gets: 'USD',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+
+    var meta = new Meta({
+      AffectedNodes: [{
+        ModifiedNode: {
+          FinalFields: {
+            Balance: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '-1'
+            },
+            Flags: 131072,
+            HighLimit: {
+              currency: 'USD',
+              issuer: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+              value: '100'
+            },
+            HighNode: '0000000000000000',
+            LowLimit: {
+              currency: 'USD',
+              issuer: 'r3PDtZSa5LiYp1Ysn1vMuMzB59RzV3W9QH',
+              value: '0'
+            },
+            LowNode: '0000000000000000'
+          },
+          LedgerEntryType: 'RippleState',
+          LedgerIndex: 'EA4BF03B4700123CDFFB6EB09DC1D6E28D5CEB7F680FB00FC24BC1C3BB2DB959',
+          PreviousFields: {
+            Balance: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '0'
+            }
+          },
+          PreviousTxnID: '53354D84BAE8FDFC3F4DA879D984D24B929E7FEB9100D2AD9EFCD2E126BCCDC8',
+          PreviousTxnLgrSeq: 343570
+        }
+      }]
+    });
+
+    assert(!book.isBalanceChange(meta.getNodes()[0]));
+  });
+
+  it('Check is balance change - native currency', function() {
+    var remote = new Remote();
+
+    var book = remote.createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+
+    var meta = new Meta({
+      AffectedNodes: [{
+        ModifiedNode: {
+          FinalFields: {
+            Account: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+            Balance: '9999999990',
+            Flags: 0,
+            OwnerCount: 1,
+            Sequence: 2
+          },
+          LedgerEntryType: 'AccountRoot',
+          LedgerIndex: '4F83A2CF7E70F77F79A307E6A472BFC2585B806A70833CCD1C26105BAE0D6E05',
+          PreviousFields: {
+            Balance: '10000000000',
+            OwnerCount: 0,
+            Sequence: 1
+          },
+          PreviousTxnID: 'B24159F8552C355D35E43623F0E5AD965ADBF034D482421529E2703904E1EC09',
+          PreviousTxnLgrSeq: 16154
+        }
+      }]
+    });
+
+    assert(book.isBalanceChange(meta.getNodes()[0]));
+  });
+
+  it('Check is balance change - native currency - not balance change', function() {
+    var remote = new Remote();
+
+    var book = remote.createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'BTC'
+    });
+
+    var meta = new Meta({
+      AffectedNodes: [{
+        ModifiedNode: {
+          FinalFields: {
+            Account: 'r3kmLJN5D28dHuH8vZNUZpMC43pEHpaocV',
+            Balance: '78991384535796',
+            Flags: 0,
+            OwnerCount: 3,
+            Sequence: 188
+          },
+          LedgerEntryType: 'AccountRoot',
+          LedgerIndex: 'B33FDD5CF3445E1A7F2BE9B06336BEBD73A5E3EE885D3EF93F7E3E2992E46F1A',
+          PreviousTxnID: 'E9E1988A0F061679E5D14DE77DB0163CE0BBDC00F29E396FFD1DA0366E7D8904',
+          PreviousTxnLgrSeq: 195455
+        }
+      }]
+    });
+
+    assert(!book.isBalanceChange(meta.getNodes()[0]));
+  });
+
+  it('Get balance change', function() {
+    var remote = new Remote();
+
+    var book = remote.createOrderBook({
+      currency_gets: 'USD',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+
+    var meta = new Meta({
+      AffectedNodes: [{
+        ModifiedNode: {
+          FinalFields: {
+            Balance: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '10'
+            },
+            Flags: 131072,
+            HighLimit: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '100'
+            },
+            HighNode: '0000000000000000',
+            LowLimit: {
+              currency: 'USD',
+              issuer: 'r3PDtZSa5LiYp1Ysn1vMuMzB59RzV3W9QH',
+              value: '0'
+            },
+            LowNode: '0000000000000000'
+          },
+          LedgerEntryType: 'RippleState',
+          LedgerIndex: 'EA4BF03B4700123CDFFB6EB09DC1D6E28D5CEB7F680FB00FC24BC1C3BB2DB959',
+          PreviousFields: {
+            Balance: {
+              currency: 'USD',
+              issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+              value: '0'
+            }
+          },
+          PreviousTxnID: '53354D84BAE8FDFC3F4DA879D984D24B929E7FEB9100D2AD9EFCD2E126BCCDC8',
+          PreviousTxnLgrSeq: 343570
+        }
+      }]
+    });
+
+    assert.deepEqual(book.getBalanceChange(meta.getNodes()[0]), {
+      account: 'r3PDtZSa5LiYp1Ysn1vMuMzB59RzV3W9QH',
+      balance: '10',
+      isValid: true
+    });
+  });
+
+  it('Get balance change - native currency', function() {
+    var remote = new Remote();
+
+    var book = remote.createOrderBook({
+      currency_gets: 'USD',
+      issuer_gets: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+      currency_pays: 'XRP'
+    });
+
+    var meta = new Meta({
+      AffectedNodes: [{
+        ModifiedNode: {
+          FinalFields: {
+            Account: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+            Balance: '9999999990',
+            Flags: 0,
+            OwnerCount: 1,
+            Sequence: 2
+          },
+          LedgerEntryType: 'AccountRoot',
+          LedgerIndex: '4F83A2CF7E70F77F79A307E6A472BFC2585B806A70833CCD1C26105BAE0D6E05',
+          PreviousFields: {
+            Balance: '10000000000',
+            OwnerCount: 0,
+            Sequence: 1
+          },
+          PreviousTxnID: 'B24159F8552C355D35E43623F0E5AD965ADBF034D482421529E2703904E1EC09',
+          PreviousTxnLgrSeq: 16154
+        }
+      }]
+    });
+
+    assert.deepEqual(book.getBalanceChange(meta.getNodes()[0]), {
+      account: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+      balance: '9999999990',
+      isValid: true
+    });
+  });
+
+  it('Update funded amounts', function(done) {
+    var remote = new Remote();
+
+    var book = remote.createOrderBook({
+      currency_gets: 'USD',
+      issuer_gets: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+      currency_pays: 'XRP'
+    });
+
+    var message = {
+      mmeta: new Meta({
+        AffectedNodes: [{
+          ModifiedNode: {
+            FinalFields: {
+              Balance: {
+                currency: 'USD',
+                issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+                value: '10'
+              },
+              Flags: 131072,
+              HighLimit: {
+                currency: 'USD',
+                issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+                value: '100'
+              },
+              HighNode: '0000000000000000',
+              LowLimit: {
+                currency: 'USD',
+                issuer: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+                value: '0'
+              },
+              LowNode: '0000000000000000'
+            },
+            LedgerEntryType: 'RippleState',
+            LedgerIndex: 'EA4BF03B4700123CDFFB6EB09DC1D6E28D5CEB7F680FB00FC24BC1C3BB2DB959',
+            PreviousFields: {
+              Balance: {
+                currency: 'USD',
+                issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+                value: '0'
+              }
+            },
+            PreviousTxnID: '53354D84BAE8FDFC3F4DA879D984D24B929E7FEB9100D2AD9EFCD2E126BCCDC8',
+            PreviousTxnLgrSeq: 343570
+          }
+        }]
+      })
+    };
+
+    book._issuerTransferRate = 1000000000;
+    book._synchronized = true;
+
+    book._offers = [
+      {
+      Account: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+      BookDirectory: '4627DFFCFF8B5A265EDBD8AE8C14A52325DBFEDAF4F5C32E5D06F15E821839FB',
+      BookNode: '0000000000000000',
+      Flags: 0,
+      LedgerEntryType: 'Offer',
+      OwnerNode: '0000000000001897',
+      PreviousTxnID: '11BA57676711A42C2FC2191EAEE98023B04627DFA84926B0C8E9D61A9CAF13AD',
+      PreviousTxnLgrSeq: 8265601,
+      Sequence: 531927,
+      TakerGets: {
+        currency: 'USD',
+        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+        value: '19.84580331'
+      },
+      taker_gets_funded: '100',
+      is_fully_funded: true,
+      TakerPays: '3878342440',
+      index: '06AFB03237286C1566CD649CFD5388C2C1F5BEFC5C3302A1962682803A9946FA',
+      owner_funds: '318.3643710638508',
+      quality: '195423807.2109563'
+    },
+    {
+      Account: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+      BookDirectory: '4627DFFCFF8B5A265EDBD8AE8C14A52325DBFEDAF4F5C32E5D06F4C3362FE1D0',
+      BookNode: '0000000000000000',
+      Flags: 0,
+      LedgerEntryType: 'Offer',
+      OwnerNode: '00000000000063CC',
+      PreviousTxnID: 'CD77500EF28984BFC123E8A257C10E44FF486EA8FC43E1356C42BD6DB853A602',
+      PreviousTxnLgrSeq: 8265523,
+      Sequence: 1139002,
+      TakerGets: {
+        currency: 'USD',
+        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+        value: '4.9656112525'
+      },
+      taker_gets_funded: '100',
+      is_fully_funded: true,
+      TakerPays: '972251352',
+      index: 'D3338DA77BA23122FB5647B74B53636AB54BE246D4B21707C9D6887DEB334252',
+      owner_funds: '235.0194163432668',
+      quality: '195796912.5171664'
+    },
+    {
+      Account: 'r8cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+      BookDirectory: '4627DFFCFF8B5A265EDBD8AE8C14A52325DBFEDAF4F5C32E5D06F4C3362FE1D0',
+      BookNode: '0000000000000000',
+      Flags: 0,
+      LedgerEntryType: 'Offer',
+      OwnerNode: '00000000000063CC',
+      PreviousTxnID: 'CD77500EF28984BFC123E8A257C10E44FF486EA8FC43E1356C42BD6DB853A602',
+      PreviousTxnLgrSeq: 8265523,
+      Sequence: 1139002,
+      TakerGets: {
+        currency: 'USD',
+        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+        value: '4.9656112525'
+      },
+      taker_gets_funded: '100',
+      is_fully_funded: true,
+      TakerPays: '972251352',
+      index: 'D3338DA77BA23122FB5647B74B53636AB54BE246D4B21707C9D6887DEB334252',
+      owner_funds: '235.0194163432668',
+      quality: '195796912.5171664'
+    },
+    ];
+
+    var receivedChangedEvents = 0;
+    var receivedFundsChangedEvents = 0;
+
+    book.on('offer_changed', function(offer) {
+      receivedChangedEvents += 1;
+    });
+
+    book.on('offer_funds_changed', function(offer, previousFunds, newFunds) {
+      assert.strictEqual(previousFunds, '100');
+      assert.strictEqual(newFunds, '10');
+      switch (++receivedFundsChangedEvents) {
+        case 1:
+          assert(!offer.is_fully_funded);
+          break;
+        case 2:
+          assert(offer.is_fully_funded);
+          break;
+      }
+    });
+
+    book.addCachedFunds('r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59', '100');
+    book.updateFundedAmounts(message);
+
+    setImmediate(function() {
+      book.getCachedFunds('r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59', '10');
+      assert.strictEqual(receivedChangedEvents, 2);
+      assert.strictEqual(receivedFundsChangedEvents, 2);
+      done();
+    });
+  });
+
+  it('Update funded amounts - native currency', function(done) {
+    var remote = new Remote();
+
+    var book = remote.createOrderBook({
+      currency_gets: 'XRP',
+      issuer_pays: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+      currency_pays: 'USD'
+    });
+
+    var message = {
+      mmeta: new Meta({
+        AffectedNodes: [{
+          ModifiedNode: {
+            FinalFields: {
+              Account: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+              Balance: '25',
+              Flags: 0,
+              OwnerCount: 1,
+              Sequence: 2
+            },
+            LedgerEntryType: 'AccountRoot',
+            LedgerIndex: '4F83A2CF7E70F77F79A307E6A472BFC2585B806A70833CCD1C26105BAE0D6E05',
+            PreviousFields: {
+              Balance: '100',
+              OwnerCount: 0,
+              Sequence: 1
+            },
+            PreviousTxnID: 'B24159F8552C355D35E43623F0E5AD965ADBF034D482421529E2703904E1EC09',
+            PreviousTxnLgrSeq: 16154
+          }
+        }]
+      })
+    };
+
+    book._synchronized = true;
+
+    book._offers = [
+      {
+      Account: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+      BookDirectory: 'DFA3B6DDAB58C7E8E5D944E736DA4B7046C30E4F460FD9DE4C124AF94ED1781B',
+      BookNode: '0000000000000000',
+      Flags: 0,
+      LedgerEntryType: 'Offer',
+      OwnerNode: '00000000000063CA',
+      PreviousTxnID: '51C64E0B300E9C0E877BA3E79B4ED1DBD5FDDCE58FA1A8FDA5F8DDF139787A24',
+      PreviousTxnLgrSeq: 8265275,
+      Sequence: 1138918,
+      TakerGets: '50',
+      taker_gets_funded: '100',
+      is_fully_funded: true,
+      TakerPays: {
+        currency: 'USD',
+        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+        value: '5'
+      },
+      index: 'DC003E09AD1306FBBD1957C955EE668E429CC85B0EC0EC17297F6676E6108DE7',
+      owner_funds: '162110617177',
+      quality: '0.000000005148984210454555'
+    },
+    {
+      Account: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+      BookDirectory: 'DFA3B6DDAB58C7E8E5D944E736DA4B7046C30E4F460FD9DE4C124B054BAD1D79',
+      BookNode: '0000000000000000',
+      Flags: 0,
+      LedgerEntryType: 'Offer',
+      OwnerNode: '0000000000001896',
+      PreviousTxnID: '9B21C7A4B66DC1CD5FC9D85C821C4CAA8F80E437582BAD11E88A1E9E6C7AA59C',
+      PreviousTxnLgrSeq: 8265118,
+      Sequence: 531856,
+      TakerGets: '10',
+      taker_gets_funded: '100',
+      is_fully_funded: true,
+      TakerPays: {
+        currency: 'USD',
+        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+        value: '20'
+      },
+      index: '7AC0458676A54E99FAA5ED0A56CD0CB814D3DEFE1C7874F0BB39875D60668E41',
+      owner_funds: '430527438338',
+      quality: '0.000000005149035697347961'
+    },
+    {
+      Account: 'r8cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+      BookDirectory: '4627DFFCFF8B5A265EDBD8AE8C14A52325DBFEDAF4F5C32E5D06F4C3362FE1D0',
+      BookNode: '0000000000000000',
+      Flags: 0,
+      LedgerEntryType: 'Offer',
+      OwnerNode: '00000000000063CC',
+      PreviousTxnID: 'CD77500EF28984BFC123E8A257C10E44FF486EA8FC43E1356C42BD6DB853A602',
+      PreviousTxnLgrSeq: 8265523,
+      Sequence: 1139002,
+      TakerGets: {
+        currency: 'USD',
+        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+        value: '4.9656112525'
+      },
+      TakerPays: '972251352',
+      index: 'D3338DA77BA23122FB5647B74B53636AB54BE246D4B21707C9D6887DEB334252',
+      owner_funds: '235.0194163432668',
+      quality: '195796912.5171664'
+    },
+    ];
+
+    var receivedChangedEvents = 0;
+    var receivedFundsChangedEvents = 0;
+
+    book.on('offer_changed', function(offer) {
+      receivedChangedEvents += 1;
+    });
+
+    book.on('offer_funds_changed', function(offer, previousFunds, newFunds) {
+      assert.strictEqual(previousFunds, '100');
+      assert.strictEqual(newFunds, '25');
+      switch (++receivedFundsChangedEvents) {
+        case 1:
+          assert(!offer.is_fully_funded);
+          break;
+        case 2:
+          assert(offer.is_fully_funded);
+          break;
+      }
+    });
+
+    book.addCachedFunds('r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59', '100');
+    book.updateFundedAmounts(message);
+
+    setImmediate(function() {
+      book.getCachedFunds('r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59', '25');
+      assert.strictEqual(receivedChangedEvents, 2);
+      assert.strictEqual(receivedFundsChangedEvents, 2);
+      done();
+    });
+  });
+});