diff --git a/src/log.js b/src/log.js
index c209b2c5..88adeac8 100644
--- a/src/log.js
+++ b/src/log.js
@@ -1,6 +1,6 @@
 'use strict';
 
-var assert = require('assert');
+const assert = require('assert');
 
 /**
  * Logging functionality for ripple-lib and any applications built on it.
@@ -36,13 +36,13 @@ function Log(namespace) {
  * @return {Log} sub logger
  */
 Log.prototype.sub = function(namespace) {
-  var subNamespace = this._namespace.slice();
+  const subNamespace = this._namespace.slice();
 
   if (namespace && typeof namespace === 'string') {
     subNamespace.push(namespace);
   }
 
-  var subLogger = new Log(subNamespace);
+  const subLogger = new Log(subNamespace);
   subLogger._setParent(this);
   return subLogger;
 };
@@ -53,7 +53,7 @@ Log.prototype._setParent = function(parentLogger) {
 
 Log.makeLevel = function(level) {
   return function() {
-    var args = Array.prototype.slice.apply(arguments);
+    const args = Array.prototype.slice.apply(arguments);
     args[0] = this._prefix + args[0];
     Log.engine.logObject.apply(Log, [level].concat(args[0], [args.slice(2)]));
   };
@@ -71,7 +71,7 @@ Log.prototype.error = Log.makeLevel(4);
  */
 
 function getLogInfo(message, args) {
-  var stack = new Error().stack;
+  const stack = new Error().stack;
 
   return [
     // Timestamp
@@ -104,7 +104,7 @@ function logMessage(logLevel, args) {
   }
 }
 
-var engines = {};
+const engines = {};
 
 /**
  * Basic logging connector.
@@ -113,8 +113,8 @@ var engines = {};
  * implementations. This is the logging engine used in Node.js.
  */
 engines.basic = {
-  logObject: function logObject(level, message, args) {
-    args = args.map(function(arg) {
+  logObject: function logObject(level, message, args_) {
+    const args = args_.map(function(arg) {
       return JSON.stringify(arg, null, 2);
     });
 
@@ -130,8 +130,8 @@ engines.basic = {
  * function without any stringification.
  */
 engines.interactive = {
-  logObject: function(level, message, args) {
-    args = args.map(function(arg) {
+  logObject: function(level, message, args_) {
+    const args = args_.map(function(arg) {
       return /MSIE/.test(navigator.userAgent)
       ? JSON.stringify(arg, null, 2)
       : arg;
diff --git a/src/remote.js b/src/remote.js
index a07b8eab..ff2a8039 100644
--- a/src/remote.js
+++ b/src/remote.js
@@ -13,28 +13,28 @@
 // has not yet been implemented. However, this class has been designed for it
 // to be a very simple drop option.
 
-var EventEmitter = require('events').EventEmitter;
-var util = require('util');
-var assert = require('assert');
-var LRU = require('lru-cache');
-var async = require('async');
-var lodash = require('lodash');
-var Server = require('./server').Server;
-var Request = require('./request').Request;
-var Amount = require('./amount').Amount;
-var Currency = require('./currency').Currency;
-var UInt160 = require('./uint160').UInt160;
-var UInt256 = require('./uint256').UInt256;
-var Transaction = require('./transaction').Transaction;
-var Account = require('./account').Account;
-var Meta = require('./meta').Meta;
-var OrderBook = require('./orderbook').OrderBook;
-var PathFind = require('./pathfind').PathFind;
-var SerializedObject = require('./serializedobject').SerializedObject;
-var RippleError = require('./rippleerror').RippleError;
-var utils = require('./utils');
-var hashprefixes = require('./hashprefixes');
-var log = require('./log').internal.sub('remote');
+const EventEmitter = require('events').EventEmitter;
+const util = require('util');
+const assert = require('assert');
+const LRU = require('lru-cache');
+const async = require('async');
+const lodash = require('lodash');
+const Server = require('./server').Server;
+const Request = require('./request').Request;
+const Amount = require('./amount').Amount;
+const Currency = require('./currency').Currency;
+const UInt160 = require('./uint160').UInt160;
+const UInt256 = require('./uint256').UInt256;
+const Transaction = require('./transaction').Transaction;
+const Account = require('./account').Account;
+const Meta = require('./meta').Meta;
+const OrderBook = require('./orderbook').OrderBook;
+const PathFind = require('./pathfind').PathFind;
+const SerializedObject = require('./serializedobject').SerializedObject;
+const RippleError = require('./rippleerror').RippleError;
+const utils = require('./utils');
+const hashprefixes = require('./hashprefixes');
+const log = require('./log').internal.sub('remote');
 
 /**
  * Interface to manage connections to rippled servers
@@ -42,19 +42,12 @@ var log = require('./log').internal.sub('remote');
  * @param {Object} Options
  */
 
-function Remote(opts) {
+function Remote(options = {}) {
   EventEmitter.call(this);
 
-  var self = this;
-  opts = opts || { };
+  const self = this;
 
-  Object.keys(Remote.DEFAULTS).forEach(function(option) {
-    if (opts.hasOwnProperty(option)) {
-      this[option] = opts[option];
-    } else {
-      this[option] = Remote.DEFAULTS[option];
-    }
-  }, this);
+  lodash.merge(this, lodash.defaults(options, Remote.DEFAULTS));
 
   this.state = 'offline'; // 'online', 'offline'
   this._server_fatal = false; // server exited
@@ -152,7 +145,7 @@ function Remote(opts) {
   this.setMaxListeners(this.max_listeners);
 
   this.servers.forEach(function(serverOptions) {
-    var server = self.addServer(serverOptions);
+    const server = self.addServer(serverOptions);
     server.setMaxListeners(self.max_listeners);
   });
 
@@ -362,10 +355,9 @@ Remote.prototype.setSecret = function(account, secret) {
   this.secrets[account] = secret;
 };
 
-Remote.prototype.addServer = function(opts) {
-  var self = this;
-
-  var server = new Server(this, opts);
+Remote.prototype.addServer = function(options) {
+  const self = this;
+  const server = new Server(this, options);
 
   function serverMessage(data) {
     self._handleMessage(data, server);
@@ -376,7 +368,7 @@ Remote.prototype.addServer = function(opts) {
   function serverConnect() {
     self._connection_count += 1;
 
-    if (opts.primary) {
+    if (options.primary) {
       self._setPrimaryServer(server);
     }
     if (self._connection_count === 1) {
@@ -451,14 +443,14 @@ Remote.prototype.connect = function(callback) {
  * @api public
  */
 
-Remote.prototype.disconnect = function(callback) {
+Remote.prototype.disconnect = function(callback_) {
   if (!this._servers.length) {
     throw new Error('No servers available, not disconnecting');
   }
 
-  if (typeof callback !== 'function') {
-    callback = function() {};
-  }
+  let callback = lodash.isFunction(callback_)
+  ? callback_
+  : function() {};
 
   this._should_connect = false;
 
@@ -492,7 +484,7 @@ Remote.prototype.disconnect = function(callback) {
 Remote.prototype._handleMessage = function(message, server) {
   if (!Remote.isValidMessage(message)) {
     // Unexpected response from remote.
-    var error = new RippleError('remoteUnexpected',
+    const error = new RippleError('remoteUnexpected',
       'Unexpected response from remote: ' + JSON.stringify(message));
 
     this.emit('error', error);
@@ -537,7 +529,7 @@ Remote.prototype.getLedgerSequence = function() {
  */
 
 Remote.prototype._handleLedgerClosed = function(message, server) {
-  var self = this;
+  const self = this;
 
   // XXX If not trusted, need to verify we consider ledger closed.
   // XXX Also need to consider a slow server or out of order response.
@@ -547,7 +539,7 @@ Remote.prototype._handleLedgerClosed = function(message, server) {
     return;
   }
 
-  var ledgerAdvanced = message.ledger_index >= this._ledger_current_index;
+  const ledgerAdvanced = message.ledger_index >= this._ledger_current_index;
 
   if (isNaN(this._ledger_current_index) || ledgerAdvanced) {
     this._ledger_time = message.ledger_time;
@@ -583,7 +575,7 @@ Remote.prototype._handleServerStatus = function(message, server) {
 
 Remote.prototype._handleTransaction = function(message, server) {
   // XXX If not trusted, need proof.
-  var transactionHash = message.transaction.hash;
+  const transactionHash = message.transaction.hash;
 
   if (this._received_tx.get(transactionHash)) {
     // De-duplicate transactions
@@ -598,7 +590,7 @@ Remote.prototype._handleTransaction = function(message, server) {
     log.info('tx:', message);
   }
 
-  var metadata = message.meta || message.metadata;
+  const metadata = message.meta || message.metadata;
 
   if (metadata) {
     // Process metadata
@@ -688,13 +680,9 @@ Remote.prototype.isConnected = function() {
  */
 
 Remote.prototype.getConnectedServers = function() {
-  var servers = [ ];
-  for (var i = 0; i < this._servers.length; i++) {
-    if (this._servers[i].isConnected()) {
-      servers.push(this._servers[i]);
-    }
-  }
-  return servers;
+  return this._servers.filter(function(server) {
+    return server.isConnected();
+  });
 };
 
 /**
@@ -712,17 +700,17 @@ Remote.prototype.getServer = function() {
     return null;
   }
 
-  var connectedServers = this.getConnectedServers();
+  const connectedServers = this.getConnectedServers();
   if (connectedServers.length === 0 || !connectedServers[0]) {
     return null;
   }
 
-  var server = connectedServers[0];
-  var cScore = server._score + server._fee;
+  let server = connectedServers[0];
+  let cScore = server._score + server._fee;
 
-  for (var i = 1; i < connectedServers.length; i++) {
-    var _server = connectedServers[i];
-    var bScore = _server._score + _server._fee;
+  for (let i = 1; i < connectedServers.length; i++) {
+    const _server = connectedServers[i];
+    const bScore = _server._score + _server._fee;
     if (bScore < cScore) {
       server = _server;
       cScore = bScore;
@@ -740,14 +728,16 @@ Remote.prototype.getServer = function() {
  * @param {Request} request
  */
 
-Remote.prototype.request = function(request) {
+Remote.prototype.request = function(request_) {
+  let request = request_;
+
   if (typeof request === 'string') {
     if (!/^request_/.test(request)) {
       request = 'request_' + request;
     }
 
     if (typeof this[request] === 'function') {
-      var args = Array.prototype.slice.call(arguments, 1);
+      const args = Array.prototype.slice.call(arguments, 1);
       return this[request].apply(this, args);
     }
 
@@ -768,7 +758,7 @@ Remote.prototype.request = function(request) {
     return request.emit('error', new Error('Server does not exist'));
   }
 
-  var server = request.server || this.getServer();
+  const server = request.server || this.getServer();
   if (server) {
     server._request(request);
   } else {
@@ -785,8 +775,9 @@ Remote.prototype.request = function(request) {
  */
 
 Remote.prototype.ping =
-Remote.prototype.requestPing = function(host, callback) {
-  var request = new Request(this, 'ping');
+Remote.prototype.requestPing = function(host, callback_) {
+  const request = new Request(this, 'ping');
+  let callback = callback_;
 
   switch (typeof host) {
     case 'function':
@@ -797,7 +788,7 @@ Remote.prototype.requestPing = function(host, callback) {
       break;
   }
 
-  var then = Date.now();
+  const then = Date.now();
 
   request.once('success', function() {
     request.emit('pong', Date.now() - then);
@@ -825,12 +816,13 @@ Remote.prototype.requestServerInfo = function(callback) {
  * @return {Request} request
  */
 
-Remote.prototype.requestLedger = function(options, callback) {
+Remote.prototype.requestLedger = function(options, callback_) {
   // XXX This is a bad command. Some variants don't scale.
   // XXX Require the server to be trusted.
   // utils.assert(this.trusted);
 
-  var request = new Request(this, 'ledger');
+  const request = new Request(this, 'ledger');
+  let callback = callback_;
 
   switch (typeof options) {
     case 'undefined': break;
@@ -939,7 +931,7 @@ Remote.prototype.requestLedgerCurrent = function(callback) {
  */
 
 Remote.prototype.requestLedgerData = function(options, callback) {
-  var request = new Request(this, 'ledger_data');
+  const request = new Request(this, 'ledger_data');
 
   request.message.binary = options.binary !== false;
   request.selectLedger(options.ledger);
@@ -982,16 +974,14 @@ Remote.prototype.requestLedgerData = function(options, callback) {
  * @return {Request} request
  */
 
-Remote.prototype.requestLedgerEntry = function(type, callback) {
+Remote.prototype.requestLedgerEntry = function(type, callback_) {
   // utils.assert(this.trusted);
   // If not trusted, need to check proof, maybe talk packet protocol.
 
-  var self = this;
-  var request = new Request(this, 'ledger_entry');
+  const self = this;
 
-  if (typeof type === 'function') {
-    callback = type;
-  }
+  let request = new Request(this, 'ledger_entry');
+  const callback = lodash.isFunction(type) ? type : callback_;
 
   // Transparent caching. When .request() is invoked, look in the Remote object
   // for the result.  If not found, listen, cache result, and emit it.
@@ -1002,16 +992,16 @@ Remote.prototype.requestLedgerEntry = function(type, callback) {
 
     request.request = function() {
       // Intercept default request.
-      var bDefault = true;
+      let bDefault = true;
 
       if (!self._ledger_hash && type === 'account_root') {
-        var cache = self.ledgers.current.account_root;
+        let cache = self.ledgers.current.account_root;
 
         if (!cache) {
           cache = self.ledgers.current.account_root = {};
         }
 
-        var node = self.ledgers.current
+        const node = self.ledgers.current
         .account_root[request.message.account_root];
 
         if (node) {
@@ -1060,7 +1050,7 @@ Remote.prototype.requestLedgerEntry = function(type, callback) {
  */
 
 Remote.prototype.requestSubscribe = function(streams, callback) {
-  var request = new Request(this, 'subscribe');
+  const request = new Request(this, 'subscribe');
 
   if (streams) {
     request.message.streams = Array.isArray(streams) ? streams : [streams];
@@ -1080,7 +1070,7 @@ Remote.prototype.requestSubscribe = function(streams, callback) {
  */
 
 Remote.prototype.requestUnsubscribe = function(streams, callback) {
-  var request = new Request(this, 'unsubscribe');
+  const request = new Request(this, 'unsubscribe');
 
   if (streams) {
     request.message.streams = Array.isArray(streams) ? streams : [streams];
@@ -1100,36 +1090,44 @@ Remote.prototype.requestUnsubscribe = function(streams, callback) {
  * @return {Request} request
  */
 
-Remote.prototype.requestTransactionEntry =
-function(hash, ledgerHash, callback) {
+Remote.prototype.requestTransactionEntry = function(options_, callback_) {
   // If not trusted, need to check proof, maybe talk packet protocol.
   // utils.assert(this.trusted);
-  var request = new Request(this, 'transaction_entry');
+  let options, callback = callback_;
 
-  if (typeof hash === 'object') {
-    ledgerHash = hash.ledger || hash.ledger_hash || hash.ledger_index;
-    hash = hash.hash || hash.tx || hash.transaction;
+  if (lodash.isPlainObject(options_)) {
+    options = lodash.merge({
+      ledger: options_.ledger_index || options_.ledger_hash
+    }, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
+
+    const args = Array.prototype.slice.call(arguments);
+
+    if (lodash.isFunction(lodash.last(args))) {
+      callback = args.pop();
+    }
+
+    options = {
+      hash: args.shift(),
+      ledger: args.shift()
+    };
   }
 
-  request.txHash(hash);
+  const request = new Request(this, 'transaction_entry');
+  request.txHash(options.hash);
 
-  switch (typeof ledgerHash) {
+  switch (typeof options.ledger) {
     case 'string':
     case 'number':
-      request.selectLedger(ledgerHash);
+      request.selectLedger(options.ledger);
       break;
-
     case 'undefined':
-    case 'function':
       request.ledgerIndex('validated');
-      callback = ledgerHash;
       break;
-
     default:
-      throw new Error('Invalid ledger_hash type');
+      throw new Error('ledger must be a ledger index or hash');
   }
 
   request.callback(callback);
@@ -1149,19 +1147,28 @@ function(hash, ledgerHash, callback) {
  */
 
 Remote.prototype.requestTransaction =
-Remote.prototype.requestTx = function(hash, callback) {
-  var options;
+Remote.prototype.requestTx = function(options_, callback_) {
+  let options, callback = callback_;
 
-  if (typeof hash === 'string') {
-    options = {hash: hash};
+  if (lodash.isPlainObject(options_)) {
+    options = lodash.merge({}, options_);
+  } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
-  } else {
-    options = hash;
+
+    const args = Array.prototype.slice.call(arguments);
+
+    if (lodash.isFunction(lodash.last(args))) {
+      callback = args.pop();
+    }
+
+    options = {
+      hash: args.shift(),
+      binary: args.shift()
+    };
   }
 
-  var request = new Request(this, 'tx');
-
+  const request = new Request(this, 'tx');
   request.message.binary = options.binary !== false;
   request.message.transaction = options.hash;
 
@@ -1190,8 +1197,8 @@ Remote.prototype.requestTx = function(hash, callback) {
  * when paging to ensure a complete response
  *
  * @param {String} type - request name, e.g. 'account_lines'
- * @param {String} account - ripple address
  * @param {Object} options - all optional
+ *   @param {String} account - ripple address
  *   @param {String} peer - ripple address
  *   @param [String|Number] ledger identifier
  *   @param [Number] limit - max results per response
@@ -1201,20 +1208,32 @@ Remote.prototype.requestTx = function(hash, callback) {
  * @throws {Error} if a marker is provided, but no ledger_index or ledger_hash
  */
 
-Remote.accountRequest = function(type, options, callback) {
-  var account, ledger, peer, limit, marker;
+Remote.accountRequest = function(command, options_, callback_) {
+  let options, callback = callback_;
 
-  if (typeof options === 'object') {
-    account = options.account;
-    ledger = options.ledger;
-    peer = options.peer;
-    limit = options.limit;
-    marker = options.marker;
+  if (lodash.isPlainObject(options_)) {
+    options = lodash.merge({}, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
+
+    const args = Array.prototype.slice.call(arguments);
+
+    if (lodash.isFunction(lodash.last(args))) {
+      callback = args.pop();
+    }
+
+    options = {
+      account: args.shift(),
+      peer: args.shift(),
+      ledger: args.shift(),
+      limit: args.shift(),
+      marker: args.shift()
+    };
   }
 
+  let {account, ledger, peer, limit, marker} = options;
+
   // if a marker is given, we need a ledger
   // check if a valid ledger_index or ledger_hash is provided
   if (marker) {
@@ -1224,13 +1243,7 @@ Remote.accountRequest = function(type, options, callback) {
     }
   }
 
-  var lastArg = arguments[arguments.length - 1];
-
-  if (typeof lastArg === 'function') {
-    callback = lastArg;
-  }
-
-  var request = new Request(this, type);
+  const request = new Request(this, command);
 
   if (account) {
     account = UInt160.json_rewrite(account);
@@ -1265,6 +1278,7 @@ Remote.accountRequest = function(type, options, callback) {
   }
 
   request.callback(callback);
+
   return request;
 };
 
@@ -1279,9 +1293,9 @@ Remote.accountRequest = function(type, options, callback) {
  * @return {Request}
  */
 
-Remote.prototype.requestAccountInfo = function() {
-  var args = Array.prototype.concat.apply(['account_info'], arguments);
-  return Remote.accountRequest.apply(this, args);
+Remote.prototype.requestAccountInfo = function(...args) {
+  const options = ['account_info', ...args];
+  return Remote.accountRequest.apply(this, options);
 };
 
 /**
@@ -1295,9 +1309,9 @@ Remote.prototype.requestAccountInfo = function() {
  * @return {Request}
  */
 
-Remote.prototype.requestAccountCurrencies = function() {
-  var args = Array.prototype.concat.apply(['account_currencies'], arguments);
-  return Remote.accountRequest.apply(this, args);
+Remote.prototype.requestAccountCurrencies = function(...args) {
+  const options = ['account_currencies', ...args];
+  return Remote.accountRequest.apply(this, options);
 };
 
 /**
@@ -1320,11 +1334,11 @@ Remote.prototype.requestAccountCurrencies = function() {
  * @return {Request}
  */
 
-Remote.prototype.requestAccountLines = function() {
+Remote.prototype.requestAccountLines = function(...args) {
   // XXX Does this require the server to be trusted?
   // utils.assert(this.trusted);
-  var args = Array.prototype.concat.apply(['account_lines'], arguments);
-  return Remote.accountRequest.apply(this, args);
+  const options = ['account_lines', ...args];
+  return Remote.accountRequest.apply(this, options);
 };
 
 /**
@@ -1346,9 +1360,9 @@ Remote.prototype.requestAccountLines = function() {
  * @return {Request}
  */
 
-Remote.prototype.requestAccountOffers = function() {
-  var args = Array.prototype.concat.apply(['account_offers'], arguments);
-  return Remote.accountRequest.apply(this, args);
+Remote.prototype.requestAccountOffers = function(...args) {
+  const options = ['account_offers', ...args];
+  return Remote.accountRequest.apply(this, options);
 };
 
 /**
@@ -1375,7 +1389,7 @@ Remote.prototype.requestAccountTx = function(options, callback) {
   // XXX Does this require the server to be trusted?
   // utils.assert(this.trusted);
 
-  var request = new Request(this, 'account_tx');
+  const request = new Request(this, 'account_tx');
 
   options.binary = options.binary !== false;
 
@@ -1445,11 +1459,11 @@ Remote.prototype.requestAccountTx = function(options, callback) {
  */
 
 Remote.parseBinaryAccountTransaction = function(transaction) {
-  var tx_obj = new SerializedObject(transaction.tx_blob);
-  var tx_obj_json = tx_obj.to_json();
-  var meta = new SerializedObject(transaction.meta).to_json();
+  const tx_obj = new SerializedObject(transaction.tx_blob);
+  const tx_obj_json = tx_obj.to_json();
+  const meta = new SerializedObject(transaction.meta).to_json();
 
-  var tx_result = {
+  const tx_result = {
     validated: transaction.validated
   };
 
@@ -1474,10 +1488,10 @@ Remote.parseBinaryAccountTransaction = function(transaction) {
 };
 
 Remote.parseBinaryTransaction = function(transaction) {
-  var tx_obj = new SerializedObject(transaction.tx).to_json();
-  var meta = new SerializedObject(transaction.meta).to_json();
+  const tx_obj = new SerializedObject(transaction.tx).to_json();
+  const meta = new SerializedObject(transaction.meta).to_json();
 
-  var tx_result = tx_obj;
+  const tx_result = tx_obj;
 
   tx_result.date = transaction.date;
   tx_result.hash = transaction.hash;
@@ -1514,12 +1528,9 @@ Remote.parseBinaryTransaction = function(transaction) {
  */
 
 Remote.parseBinaryLedgerData = function(ledgerData) {
-  var data = new SerializedObject(ledgerData.data);
-
-  var state = data.to_json();
-  state.index = ledgerData.index;
-
-  return state;
+  const data = new SerializedObject(ledgerData.data).to_json();
+  data.index = ledgerData.index;
+  return data;
 };
 
 /**
@@ -1534,13 +1545,15 @@ Remote.parseBinaryLedgerData = function(ledgerData) {
  */
 
 Remote.prototype.requestTransactionHistory =
-Remote.prototype.requestTxHistory = function(start, callback) {
+Remote.prototype.requestTxHistory = function(start_, callback_) {
   // XXX Does this require the server to be trusted?
   // utils.assert(this.trusted);
 
-  var request = new Request(this, 'tx_history');
+  const request = new Request(this, 'tx_history');
+  let start = start_;
+  let callback = callback_;
 
-  if (typeof start === 'object') {
+  if (lodash.isPlainObject(start)) {
     start = start.start;
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
@@ -1566,32 +1579,36 @@ Remote.prototype.requestTxHistory = function(start, callback) {
  * @return {Request}
  */
 
-Remote.prototype.requestBookOffers = function(gets, pays, taker, callback) {
-  var ledger;
-  var limit;
-  var lastArg = arguments[arguments.length - 1];
+Remote.prototype.requestBookOffers = function(options_, callback_) {
+  let options, callback = callback_;
 
-  if (gets.hasOwnProperty('gets') || gets.hasOwnProperty('taker_gets')) {
-    var options = gets;
-    // This would mutate the `lastArg` in `arguments` to be `null` and is
-    // redundant. Once upon a time, some awkward code was written f(g, null,
-    // null, cb) ...
-    callback = pays;
-    taker = options.taker;
-    pays = options.pays || options.taker_pays;
-    gets = options.gets || options.taker_gets;
-    ledger = options.ledger;
-    limit = options.limit;
+  if (options_.gets || options_.taker_gets) {
+    options = lodash.merge({
+      pays: options_.taker_pays,
+      gets: options_.taker_gets
+    }, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
+
+    const args = Array.prototype.slice.call(arguments);
+
+    if (lodash.isFunction(lodash.last(args))) {
+      callback = args.pop();
+    }
+
+    options = {
+      gets: args.shift(),
+      pays: args.shift(),
+      taker: args.shift(),
+      ledger: args.shift(),
+      limit: args.shift()
+    };
   }
 
-  if (typeof lastArg === 'function') {
-    callback = lastArg;
-  }
+  let {gets, pays, taker, ledger, limit} = options;
 
-  var request = new Request(this, 'book_offers');
+  const request = new Request(this, 'book_offers');
 
   request.message.taker_gets = {
     currency: Currency.json_rewrite(gets.currency, {force_hex: true})
@@ -1641,19 +1658,24 @@ Remote.prototype.requestBookOffers = function(gets, pays, taker, callback) {
  * @return {Request}
  */
 
-Remote.prototype.requestWalletAccounts = function(seed, callback) {
+Remote.prototype.requestWalletAccounts = function(options_, callback_) {
   utils.assert(this.trusted); // Don't send secrets.
 
-  var request = new Request(this, 'wallet_accounts');
+  let options, callback = callback_;
 
-  if (typeof seed === 'object') {
-    seed = seed.seed;
+  if (lodash.isPlainObject(options_)) {
+    options = lodash.merge({}, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
+
+    options = {
+      seed: arguments[0]
+    };
   }
 
-  request.message.seed = seed;
+  const request = new Request(this, 'wallet_accounts');
+  request.message.seed = options.seed;
   request.callback(callback);
 
   return request;
@@ -1668,21 +1690,28 @@ Remote.prototype.requestWalletAccounts = function(seed, callback) {
  * @return {Request}
  */
 
-Remote.prototype.requestSign = function(secret, tx_json, callback) {
+Remote.prototype.requestSign = function(options_, callback_) {
   utils.assert(this.trusted); // Don't send secrets.
 
-  var request = new Request(this, 'sign');
+  let options, callback = callback_;
 
-  if (typeof secret === 'object') {
-    tx_json = secret.tx_json;
-    secret = secret.secret;
+  if (lodash.isPlainObject(options_)) {
+    options = lodash.merge({}, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
+
+    options = {
+      secret: arguments[0],
+      tx_json: arguments[1]
+    };
+
+    callback = arguments[2];
   }
 
-  request.message.secret = secret;
-  request.message.tx_json = tx_json;
+  const request = new Request(this, 'sign');
+  request.message.secret = options.secret;
+  request.message.tx_json = options.tx_json;
   request.callback(callback);
 
   return request;
@@ -1711,19 +1740,16 @@ Remote.prototype.requestSubmit = function(callback) {
  * @api private
  */
 
-Remote.prototype._serverPrepareSubscribe = function(server, callback) {
-  var self = this;
-  var feeds = ['ledger', 'server'];
-
-  if (typeof server === 'function') {
-    callback = server;
-  }
+Remote.prototype._serverPrepareSubscribe = function(server, callback_) {
+  const self = this;
+  const feeds = ['ledger', 'server'];
+  const callback = lodash.isFunction(server) ? server : callback_;
 
   if (this._transaction_listeners) {
     feeds.push('transactions');
   }
 
-  var request = this.requestSubscribe(feeds);
+  const request = this.requestSubscribe(feeds);
 
   function serverSubscribed(message) {
     self._stand_alone = !!message.stand_alone;
@@ -1759,7 +1785,7 @@ Remote.prototype._serverPrepareSubscribe = function(server, callback) {
 Remote.prototype.ledgerAccept =
 Remote.prototype.requestLedgerAccept = function(callback) {
   /* eslint-disable consistent-return */
-  var request = new Request(this, 'ledger_accept');
+  const request = new Request(this, 'ledger_accept');
 
   if (!this._stand_alone) {
     // XXX This should emit error on the request
@@ -1785,33 +1811,36 @@ Remote.prototype.requestLedgerAccept = function(callback) {
  * @api private
  */
 
-Remote.accountRootRequest =
-function(type, responseFilter, account, ledger, callback) {
-  if (typeof account === 'object') {
-    callback = ledger;
-    ledger = account.ledger;
-    account = account.account;
+Remote.accountRootRequest = function(command, filter, options_, callback_) {
+  let options, callback = callback_;
+
+  if (lodash.isPlainObject(options_)) {
+    options = lodash.merge({}, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
+
+    const args = Array.prototype.slice.call(arguments);
+
+    if (lodash.isFunction(lodash.last(args))) {
+      callback = args.pop();
+    }
+
+    options = {
+      account: args.shift(),
+      ledger: args.shift()
+    };
   }
 
-  var lastArg = arguments[arguments.length - 1];
-
-  if (typeof lastArg === 'function') {
-    callback = lastArg;
-  }
-
-  var request = this.requestLedgerEntry('account_root');
-
-  request.accountRoot(account);
-  request.selectLedger(ledger);
+  const request = this.requestLedgerEntry('account_root');
+  request.accountRoot(options.account);
+  request.selectLedger(options.ledger);
 
   request.once('success', function(message) {
-    request.emit(type, responseFilter(message));
+    request.emit(command, filter(message));
   });
 
-  request.callback(callback, type);
+  request.callback(callback, command);
 
   return request;
 };
@@ -1825,18 +1854,13 @@ function(type, responseFilter, account, ledger, callback) {
  * @return {Request}
  */
 
-Remote.prototype.requestAccountBalance = function() {
+Remote.prototype.requestAccountBalance = function(...args) {
   function responseFilter(message) {
     return Amount.from_json(message.node.Balance);
   }
 
-  var args = Array.prototype.concat.apply(
-    ['account_balance', responseFilter],
-    arguments);
-
-  var request = Remote.accountRootRequest.apply(this, args);
-
-  return request;
+  const options = ['account_balance', responseFilter, ...args];
+  return Remote.accountRootRequest.apply(this, options);
 };
 
 /**
@@ -1848,18 +1872,13 @@ Remote.prototype.requestAccountBalance = function() {
  * @return {Request}
  */
 
-Remote.prototype.requestAccountFlags = function() {
+Remote.prototype.requestAccountFlags = function(...args) {
   function responseFilter(message) {
     return message.node.Flags;
   }
 
-  var args = Array.prototype.concat.apply(
-    ['account_flags', responseFilter],
-    arguments);
-
-  var request = Remote.accountRootRequest.apply(this, args);
-
-  return request;
+  const options = ['account_flags', responseFilter, ...args];
+  return Remote.accountRootRequest.apply(this, options);
 };
 
 /**
@@ -1871,18 +1890,13 @@ Remote.prototype.requestAccountFlags = function() {
  * @return {Request}
  */
 
-Remote.prototype.requestOwnerCount = function() {
+Remote.prototype.requestOwnerCount = function(...args) {
   function responseFilter(message) {
     return message.node.OwnerCount;
   }
 
-  var args = Array.prototype.concat.apply(
-    ['owner_count', responseFilter],
-    arguments);
-
-  var request = Remote.accountRootRequest.apply(this, args);
-
-  return request;
+  const options = ['owner_count', responseFilter, ...args];
+  return Remote.accountRootRequest.apply(this, options);
 };
 
 /**
@@ -1905,7 +1919,7 @@ Remote.prototype.getAccount = function(accountID) {
  */
 
 Remote.prototype.addAccount = function(accountID) {
-  var account = new Account(this, accountID);
+  const account = new Account(this, accountID);
 
   if (account.isValid()) {
     this._accounts[accountID] = account;
@@ -1924,7 +1938,7 @@ Remote.prototype.addAccount = function(accountID) {
 
 Remote.prototype.account =
 Remote.prototype.findAccount = function(accountID) {
-  var account = this.getAccount(accountID);
+  const account = this.getAccount(accountID);
   return account ? account : this.addAccount(accountID);
 };
 
@@ -1935,23 +1949,26 @@ Remote.prototype.findAccount = function(accountID) {
  * @return {PathFind}
  */
 
-Remote.prototype.pathFind =
-Remote.prototype.createPathFind =
-function(src_account, dst_account, dst_amount, src_currencies) {
-  if (typeof src_account === 'object') {
-    var options = src_account;
-    src_currencies = options.src_currencies;
-    dst_amount = options.dst_amount;
-    dst_account = options.dst_account;
-    src_account = options.src_account;
+function createPathFind(options_) {
+  let options;
+
+  if (lodash.isPlainObject(options_)) {
+    options = lodash.merge({}, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
+
+    options = {
+      src_account: arguments[0],
+      dst_account: arguments[1],
+      dst_amount: arguments[2],
+      src_currencies: arguments[3]
+    };
   }
 
-  var pathFind = new PathFind(this,
-    src_account, dst_account,
-    dst_amount, src_currencies);
+  const pathFind = new PathFind(this,
+    options.src_account, options.dst_account,
+    options.dst_amount, options.src_currencies);
 
   if (this._cur_path_find) {
     this._cur_path_find.notify_superceded();
@@ -1962,10 +1979,12 @@ function(src_account, dst_account, dst_amount, src_currencies) {
   this._cur_path_find = pathFind;
 
   return pathFind;
-};
+}
+
+Remote.prototype.pathFind = Remote.prototype.createPathFind = createPathFind;
 
 Remote.prepareTrade = function(currency, issuer) {
-  var suffix = Currency.from_json(currency).is_native() ? '' : ('/' + issuer);
+  const suffix = Currency.from_json(currency).is_native() ? '' : ('/' + issuer);
   return currency + suffix;
 };
 
@@ -1977,31 +1996,33 @@ Remote.prepareTrade = function(currency, issuer) {
  * @return {OrderBook}
  */
 
-Remote.prototype.book =
-Remote.prototype.createOrderBook =
-function(currency_gets, issuer_gets, currency_pays, issuer_pays) {
-  if (typeof currency_gets === 'object') {
-    var options = currency_gets;
-    issuer_pays = options.issuer_pays;
-    currency_pays = options.currency_pays;
-    issuer_gets = options.issuer_gets;
-    currency_gets = options.currency_gets;
+Remote.prototype.book = Remote.prototype.createOrderBook = function(options_) {
+  let options;
+
+  if (arguments.length === 1) {
+    options = lodash.merge({}, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
-      + ' an object containing request properties');
+             + ' an object containing request properties');
+    options = {
+      currency_gets: arguments[0],
+      issuer_gets: arguments[1],
+      currency_pays: arguments[2],
+      issuer_pays: arguments[3]
+    };
   }
 
-  var gets = Remote.prepareTrade(currency_gets, issuer_gets);
-  var pays = Remote.prepareTrade(currency_pays, issuer_pays);
-  var key = gets + ':' + pays;
+  const gets = Remote.prepareTrade(options.currency_gets, options.issuer_gets);
+  const pays = Remote.prepareTrade(options.currency_pays, options.issuer_pays);
+  const key = gets + ':' + pays;
 
   if (this._books.hasOwnProperty(key)) {
     return this._books[key];
   }
 
-  var book = new OrderBook(this,
-    currency_gets, issuer_gets,
-    currency_pays, issuer_pays,
+  const book = new OrderBook(this,
+    options.currency_gets, options.issuer_gets,
+    options.currency_pays, options.issuer_pays,
     key);
 
   if (book.is_valid()) {
@@ -2020,16 +2041,16 @@ function(currency_gets, issuer_gets, currency_pays, issuer_pays) {
  */
 
 Remote.prototype.accountSeq =
-Remote.prototype.getAccountSequence = function(account, advance) {
-  account = UInt160.json_rewrite(account);
-  var accountInfo = this.accounts[account];
+Remote.prototype.getAccountSequence = function(account_, advance) {
+  const account = UInt160.json_rewrite(account_);
+  const accountInfo = this.accounts[account];
 
   if (!accountInfo) {
     return NaN;
   }
 
-  var seq = accountInfo.seq;
-  var change = {ADVANCE: 1, REWIND: -1}[advance.toUpperCase()] || 0;
+  const seq = accountInfo.seq;
+  const change = {ADVANCE: 1, REWIND: -1}[advance.toUpperCase()] || 0;
 
   accountInfo.seq += change;
 
@@ -2044,8 +2065,8 @@ Remote.prototype.getAccountSequence = function(account, advance) {
  */
 
 Remote.prototype.setAccountSequence =
-Remote.prototype.setAccountSeq = function(account, sequence) {
-  account = UInt160.json_rewrite(account);
+Remote.prototype.setAccountSeq = function(account_, sequence) {
+  const account = UInt160.json_rewrite(account_);
 
   if (!this.accounts.hasOwnProperty(account)) {
     this.accounts[account] = { };
@@ -2063,28 +2084,38 @@ Remote.prototype.setAccountSeq = function(account, sequence) {
  * @return {Request}
  */
 
-Remote.prototype.accountSeqCache = function(account, ledger, callback) {
-  if (typeof account === 'object') {
-    var options = account;
-    callback = ledger;
-    ledger = options.ledger;
-    account = options.account;
+Remote.prototype.accountSeqCache = function(options_, callback_) {
+  let options, callback = callback_;
+
+  if (lodash.isPlainObject(options_)) {
+    options = lodash.merge({}, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
+
+    const args = Array.prototype.slice.call(arguments);
+
+    if (lodash.isFunction(lodash.last(args))) {
+      callback = args.pop();
+    }
+
+    options = {
+      account: args.shift(),
+      ledger: args.shift()
+    };
   }
 
-  if (!this.accounts.hasOwnProperty(account)) {
-    this.accounts[account] = { };
+  if (!this.accounts.hasOwnProperty(options.account)) {
+    this.accounts[options.account] = { };
   }
 
-  var account_info = this.accounts[account];
-  var request = account_info.caching_seq_request;
+  const account_info = this.accounts[options.account];
+  let request = account_info.caching_seq_request;
 
   function accountRootSuccess(message) {
     delete account_info.caching_seq_request;
 
-    var seq = message.node.Sequence;
+    const seq = message.node.Sequence;
     account_info.seq = seq;
 
     request.emit('success_cache', message);
@@ -2098,8 +2129,12 @@ Remote.prototype.accountSeqCache = function(account, ledger, callback) {
 
   if (!request) {
     request = this.requestLedgerEntry('account_root');
-    request.accountRoot(account);
-    request.selectLedger(ledger);
+    request.accountRoot(options.account);
+
+    if (!lodash.isUndefined(options.ledger)) {
+      request.selectLedger(options.ledger);
+    }
+
     request.once('success', accountRootSuccess);
     request.once('error', accountRootError);
 
@@ -2117,8 +2152,8 @@ Remote.prototype.accountSeqCache = function(account, ledger, callback) {
  * @param {String} account
  */
 
-Remote.prototype.dirtyAccountRoot = function(account) {
-  account = UInt160.json_rewrite(account);
+Remote.prototype.dirtyAccountRoot = function(account_) {
+  const account = UInt160.json_rewrite(account_);
   delete this.ledgers.current.account_root[account];
 };
 
@@ -2140,7 +2175,7 @@ Remote.prototype.dirtyAccountRoot = function(account) {
  */
 
 Remote.prototype.requestOffer = function(options, callback) {
-  var request = this.requestLedgerEntry('offer');
+  const request = this.requestLedgerEntry('offer');
 
   if (options.account && options.sequence) {
     request.offerId(options.account, options.sequence);
@@ -2171,51 +2206,63 @@ Remote.prototype.requestOffer = function(options, callback) {
  * @return {Request}
  */
 
-Remote.prototype.requestRippleBalance =
-function(account, issuer, currency, ledger, callback) {
-  if (typeof account === 'object') {
-    var options = account;
-    callback = issuer;
-    ledger = options.ledger;
-    currency = options.currency;
-    issuer = options.issuer;
-    account = options.account;
+Remote.prototype.requestRippleBalance = function(options_, callback_) {
+  let options, callback = callback_;
+
+  if (lodash.isPlainObject(options_)) {
+    options = lodash.merge({}, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
+
+    const args = Array.prototype.slice.call(arguments);
+
+    if (lodash.isFunction(lodash.last(args))) {
+      callback = args.pop();
+    }
+
+    options = {
+      account: args.shift(),
+      issuer: args.shift(),
+      currency: args.shift(),
+      ledger: args.shift()
+    };
   }
 
   // YYY Could be cached per ledger.
-  var request = this.requestLedgerEntry('ripple_state');
+  const request = this.requestLedgerEntry('ripple_state');
+  request.rippleState(options.account, options.issuer, options.currency);
 
-  request.rippleState(account, issuer, currency);
-  request.selectLedger(ledger);
+  if (!lodash.isUndefined(options.ledger)) {
+    request.selectLedger(options.ledger);
+  }
 
   function rippleState(message) {
-    var node = message.node;
-    var lowLimit = Amount.from_json(node.LowLimit);
-    var highLimit = Amount.from_json(node.HighLimit);
+    const node = message.node;
+    const lowLimit = Amount.from_json(node.LowLimit);
+    const highLimit = Amount.from_json(node.HighLimit);
 
     // The amount the low account holds of issuer.
-    var balance = Amount.from_json(node.Balance);
+    const balance = Amount.from_json(node.Balance);
 
     // accountHigh implies for account: balance is negated.  highLimit is the
     // limit set by account.
-    var accountHigh = UInt160.from_json(account).equals(highLimit.issuer());
+    const accountHigh = UInt160.from_json(options.account)
+    .equals(highLimit.issuer());
 
     request.emit('ripple_state', {
       account_balance: (accountHigh
         ? balance.negate()
-        : balance.clone()).parse_issuer(account),
+        : balance.clone()).parse_issuer(options.account),
       peer_balance: (!accountHigh
         ? balance.negate()
-        : balance.clone()).parse_issuer(issuer),
+        : balance.clone()).parse_issuer(options.issuer),
       account_limit: (accountHigh
         ? highLimit
-        : lowLimit).clone().parse_issuer(issuer),
+        : lowLimit).clone().parse_issuer(options.issuer),
       peer_limit: (!accountHigh
         ? highLimit
-        : lowLimit).clone().parse_issuer(account),
+        : lowLimit).clone().parse_issuer(options.account),
       account_quality_in: (accountHigh
         ? node.HighQualityIn
         : node.LowQualityIn),
@@ -2239,7 +2286,7 @@ function(account, issuer, currency, ledger, callback) {
 
 Remote.prepareCurrency =
 Remote.prepareCurrencies = function(currency) {
-  var newCurrency = { };
+  const newCurrency = { };
 
   if (currency.hasOwnProperty('issuer')) {
     newCurrency.issuer = UInt160.json_rewrite(currency.issuer);
@@ -2261,29 +2308,47 @@ Remote.prepareCurrencies = function(currency) {
  * @return {Request}
  */
 
-Remote.prototype.requestRipplePathFind =
-function(src_account, dst_account, dst_amount, src_currencies, callback) {
-  if (typeof src_account === 'object') {
-    var options = src_account;
-    callback = dst_account;
-    src_currencies = options.src_currencies;
-    dst_amount = options.dst_amount;
-    dst_account = options.dst_account;
-    src_account = options.src_account;
+Remote.prototype.requestRipplePathFind = function(options_, callback_) {
+  let options, callback = callback_;
+
+  if (lodash.isPlainObject(options_)) {
+    options = lodash.merge({
+      source_account: options_.src_account,
+      destination_account: options_.dst_account,
+      destination_amount: options_.dst_amount,
+      source_currencies: options_.src_currencies
+      }, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
+
+    const args = Array.prototype.slice.call(arguments);
+
+    if (lodash.isFunction(lodash.last(args))) {
+      callback = args.pop();
+    }
+
+    options = {
+      source_account: args.shift(),
+      destination_account: args.shift(),
+      destination_amount: args.shift(),
+      source_currencies: args.shift()
+    };
   }
 
-  var request = new Request(this, 'ripple_path_find');
+  const request = new Request(this, 'ripple_path_find');
 
-  request.message.source_account = UInt160.json_rewrite(src_account);
-  request.message.destination_account = UInt160.json_rewrite(dst_account);
-  request.message.destination_amount = Amount.json_rewrite(dst_amount);
+  request.message.source_account = UInt160.json_rewrite(options.source_account);
 
-  if (src_currencies) {
+  request.message.destination_account =
+    UInt160.json_rewrite(options.destination_account);
+
+  request.message.destination_amount =
+    Amount.json_rewrite(options.destination_amount);
+
+  if (Array.isArray(options.source_currencies)) {
     request.message.source_currencies =
-      src_currencies.map(Remote.prepareCurrencies);
+      options.source_currencies.map(Remote.prepareCurrency);
   }
 
   request.callback(callback);
@@ -2299,30 +2364,48 @@ function(src_account, dst_account, dst_amount, src_currencies, callback) {
  * @return {Request}
  */
 
-Remote.prototype.requestPathFindCreate =
-function(src_account, dst_account, dst_amount, src_currencies, callback) {
-  if (typeof src_account === 'object') {
-    var options = src_account;
-    callback = dst_account;
-    src_currencies = options.src_currencies;
-    dst_amount = options.dst_amount;
-    dst_account = options.dst_account;
-    src_account = options.src_account;
+Remote.prototype.requestPathFindCreate = function(options_, callback_) {
+  let options, callback = callback_;
+
+  if (lodash.isPlainObject(options_)) {
+    options = lodash.merge({
+      source_account: options_.src_account,
+      destination_account: options_.dst_account,
+      destination_amount: options_.dst_amount,
+      source_currencies: options_.src_currencies
+      }, options_);
   } else {
     log.warn('DEPRECATED: First argument to request constructor should be'
       + ' an object containing request properties');
+
+    const args = Array.prototype.slice.call(arguments);
+
+    if (lodash.isFunction(lodash.last(args))) {
+      callback = args.pop();
+    }
+
+    options = {
+      source_account: args.shift(),
+      destination_account: args.shift(),
+      destination_amount: args.shift(),
+      source_currencies: args.shift()
+    };
   }
 
-  var request = new Request(this, 'path_find');
-
+  const request = new Request(this, 'path_find');
   request.message.subcommand = 'create';
-  request.message.source_account = UInt160.json_rewrite(src_account);
-  request.message.destination_account = UInt160.json_rewrite(dst_account);
-  request.message.destination_amount = Amount.json_rewrite(dst_amount);
 
-  if (src_currencies) {
+  request.message.source_account = UInt160.json_rewrite(options.source_account);
+
+  request.message.destination_account =
+    UInt160.json_rewrite(options.destination_account);
+
+  request.message.destination_amount =
+    Amount.json_rewrite(options.destination_amount);
+
+  if (Array.isArray(options.source_currencies)) {
     request.message.source_currencies =
-      src_currencies.map(Remote.prepareCurrencies);
+      options.source_currencies.map(Remote.prepareCurrency);
   }
 
   request.callback(callback);
@@ -2338,7 +2421,7 @@ function(src_account, dst_account, dst_amount, src_currencies, callback) {
  */
 
 Remote.prototype.requestPathFindClose = function(callback) {
-  var request = new Request(this, 'path_find');
+  const request = new Request(this, 'path_find');
 
   request.message.subcommand = 'close';
   request.callback(callback);
@@ -2367,7 +2450,7 @@ Remote.prototype.requestUnlList = function(callback) {
  */
 
 Remote.prototype.requestUnlAdd = function(address, comment, callback) {
-  var request = new Request(this, 'unl_add');
+  const request = new Request(this, 'unl_add');
 
   request.message.node = address;
 
@@ -2390,7 +2473,7 @@ Remote.prototype.requestUnlAdd = function(address, comment, callback) {
  */
 
 Remote.prototype.requestUnlDelete = function(node, callback) {
-  var request = new Request(this, 'unl_delete');
+  const request = new Request(this, 'unl_delete');
 
   request.message.node = node;
   request.callback(callback);
@@ -2419,7 +2502,7 @@ Remote.prototype.requestPeers = function(callback) {
  */
 
 Remote.prototype.requestConnect = function(ip, port, callback) {
-  var request = new Request(this, 'connect');
+  const request = new Request(this, 'connect');
 
   request.message.ip = ip;
 
@@ -2441,36 +2524,32 @@ Remote.prototype.requestConnect = function(ip, port, callback) {
  */
 
 Remote.prototype.transaction =
-Remote.prototype.createTransaction = function(type, options) {
+Remote.prototype.createTransaction = function(type, options = {}) {
+  const transaction = new Transaction(this);
+
   if (arguments.length === 0) {
     // Fallback
-    return new Transaction(this);
+    return transaction;
   }
 
-  assert.strictEqual(typeof type, 'string',
-    'TransactionType must be a string');
-  assert.strictEqual(typeof options, 'object',
-    'Transaction options must be an object');
+  assert.strictEqual(typeof type, 'string', 'TransactionType must be a string');
 
-  var transaction = new Transaction(this);
-
-  var transactionTypes = {
-    payment: 'payment',
-    accountset: 'accountSet',
-    trustset: 'trustSet',
-    offercreate: 'offerCreate',
-    offercancel: 'offerCancel',
-    setregularkey: 'setRegularKey',
-    sign: 'sign'
+  const constructorMap = {
+    Payment: transaction.payment,
+    AccountSet: transaction.accountSet,
+    TrustSet: transaction.trustSet,
+    OfferCreate: transaction.offerCreate,
+    OfferCancel: transaction.offerCancel,
+    SetRegularkey: transaction.setRegularKey
   };
 
-  var transactionConstructor = transactionTypes[type.toLowerCase()];
+  const transactionConstructor = constructorMap[type];
 
   if (!transactionConstructor) {
-    throw new Error('Invalid transaction type: ' + type);
+    throw new Error('TransactionType must be a valid transaction type');
   }
 
-  return transaction[transactionConstructor](options);
+  return transactionConstructor.call(transaction, options);
 };
 
 /**
@@ -2483,7 +2562,7 @@ Remote.prototype.createTransaction = function(type, options) {
  */
 
 Remote.prototype.feeTx = function(units) {
-  var server = this.getServer();
+  const server = this.getServer();
 
   if (!server) {
     throw new Error('No connected servers');
@@ -2502,7 +2581,7 @@ Remote.prototype.feeTx = function(units) {
  */
 
 Remote.prototype.feeTxUnit = function() {
-  var server = this.getServer();
+  const server = this.getServer();
 
   if (!server) {
     throw new Error('No connected servers');
@@ -2521,7 +2600,7 @@ Remote.prototype.feeTxUnit = function() {
  */
 
 Remote.prototype.reserve = function(owner_count) {
-  var server = this.getServer();
+  const server = this.getServer();
 
   if (!server) {
     throw new Error('No connected servers');
diff --git a/src/server.js b/src/server.js
index 0ed85222..ca678280 100644
--- a/src/server.js
+++ b/src/server.js
@@ -5,6 +5,7 @@ const util = require('util');
 const url = require('url');
 const LRU = require('lru-cache');
 const EventEmitter = require('events').EventEmitter;
+const RippleError = require('./').RippleError;
 const Amount = require('./amount').Amount;
 const RangeSet = require('./rangeset').RangeSet;
 const log = require('./log').internal.sub('server');
@@ -442,12 +443,12 @@ Server.prototype.connect = function() {
   self.emit('connecting');
 
   ws.onmessage = function onMessage(msg) {
-    var message = msg.data;
+    let message = msg.data;
 
     try {
       message = JSON.parse(message);
     } catch (e) {
-      var error = new RippleError('unexpected',
+      const error = new RippleError('unexpected',
         'Unexpected response from server: ' + JSON.stringify(message));
 
       self.emit('unexpected', message);
diff --git a/test/remote-test.js b/test/remote-test.js
index 6cd422d1..6fdcb9bb 100644
--- a/test/remote-test.js
+++ b/test/remote-test.js
@@ -2,29 +2,29 @@
 
 'use strict';
 
-var assert = require('assert');
-var Remote = require('ripple-lib').Remote;
-var Server = require('ripple-lib').Server;
-var Transaction = require('ripple-lib').Transaction;
-var UInt160 = require('ripple-lib').UInt160;
-var Currency = require('ripple-lib').Currency;
-var Amount = require('ripple-lib').Amount;
-var PathFind = require('ripple-lib')._test.PathFind;
-var Log = require('ripple-lib')._test.Log;
+const assert = require('assert-diff');
+const Remote = require('ripple-lib').Remote;
+const Server = require('ripple-lib').Server;
+const Transaction = require('ripple-lib').Transaction;
+const UInt160 = require('ripple-lib').UInt160;
+const Currency = require('ripple-lib').Currency;
+const Amount = require('ripple-lib').Amount;
+const PathFind = require('ripple-lib')._test.PathFind;
+const Log = require('ripple-lib')._test.Log;
 
-var options, remote, callback;
+let options, remote, callback;
 
-var ADDRESS = 'r4qLSAzv4LZ9TLsR7diphGwKnSEAMQTSjS';
-var LEDGER_INDEX = 9592219;
-var LEDGER_HASH =
+const ADDRESS = 'r4qLSAzv4LZ9TLsR7diphGwKnSEAMQTSjS';
+const LEDGER_INDEX = 9592219;
+const LEDGER_HASH =
   'B4FD84A73DBD8F0DA9E320D137176EBFED969691DC0AAC7882B76B595A0841AE';
-var PAGING_MARKER =
+const PAGING_MARKER =
   '29F992CC252056BF690107D1E8F2D9FBAFF29FF107B62B1D1F4E4E11ADF2CC73';
-var TRANSACTION_HASH =
+const TRANSACTION_HASH =
   '14576FFD5D59FFA73CAA90547BE4DE09926AAB59E981306C32CCE04408CBF8EA';
 
 describe('Remote', function() {
-  var initialLogEngine = Log.getEngine();
+  let initialLogEngine = Log.getEngine();
 
   beforeEach(function() {
     options = {
@@ -291,7 +291,7 @@ describe('Remote', function() {
   });
 
   it('Automatic transactions subscription', function(done) {
-    var i = 0;
+    let i = 0;
 
     remote.request = function(request) {
       switch (++i) {
@@ -365,7 +365,7 @@ describe('Remote', function() {
   });
 
   it('Set state', function() {
-    var i = 0;
+    let i = 0;
     remote.on('state', function(state) {
       switch (++i) {
         case 1:
@@ -399,10 +399,10 @@ describe('Remote', function() {
   });
 
   it('Add server', function() {
-    var server = remote.addServer('wss://s1.ripple.com:443');
+    const server = remote.addServer('wss://s1.ripple.com:443');
     assert(server instanceof Server);
 
-    var i = 0;
+    let i = 0;
     remote.once('connect', function() {
       assert.strictEqual(remote._connection_count, 1);
       ++i;
@@ -418,7 +418,7 @@ describe('Remote', function() {
     assert.strictEqual(i, 2, 'Remote did not receive all server events');
   });
   it('Add server -- primary server', function() {
-    var server = remote.addServer({
+    const server = remote.addServer({
       host: 's1.ripple.com',
       port: 443,
       secure: true,
@@ -429,7 +429,7 @@ describe('Remote', function() {
     assert.strictEqual(remote._servers.length, 2);
     assert.strictEqual(remote._servers[1], server);
 
-    var i = 0;
+    let i = 0;
     remote.once('connect', function() {
       assert.strictEqual(remote._connection_count, 1);
       assert.strictEqual(remote._primary_server, server);
@@ -447,7 +447,7 @@ describe('Remote', function() {
   it('Connect', function() {
     remote.addServer('wss://s1.ripple.com:443');
 
-    var i = 0;
+    let i = 0;
     remote._servers.forEach(function(s) {
       s.connect = function() {
         ++i;
@@ -463,7 +463,7 @@ describe('Remote', function() {
   it('Connect -- with callback', function(done) {
     remote.addServer('wss://s1.ripple.com:443');
 
-    var i = 0;
+    let i = 0;
     remote._servers.forEach(function(s) {
       s.connect = function() {
         ++i;
@@ -488,7 +488,7 @@ describe('Remote', function() {
   it('Disconnect', function() {
     remote.addServer('wss://s1.ripple.com:443');
 
-    var i = 0;
+    let i = 0;
     remote._servers.forEach(function(s) {
       s.disconnect = function() {
         ++i;
@@ -504,7 +504,7 @@ describe('Remote', function() {
   it('Disconnect -- with callback', function(done) {
     remote.addServer('wss://s1.ripple.com:443');
 
-    var i = 0;
+    let i = 0;
     remote._servers.forEach(function(s) {
       s.disconnect = function() {
         ++i;
@@ -524,7 +524,7 @@ describe('Remote', function() {
   it('Disconnect -- unconnected', function(done) {
     remote.addServer('wss://s1.ripple.com:443');
 
-    var i = 0;
+    let i = 0;
     remote._servers.forEach(function(s) {
       s.disconnect = function() {
         ++i;
@@ -543,7 +543,7 @@ describe('Remote', function() {
   });
 
   it('Handle server message -- ledger', function() {
-    var message = {
+    const message = {
       type: 'ledgerClosed',
       fee_base: 10,
       fee_ref: 10,
@@ -565,7 +565,7 @@ describe('Remote', function() {
     remote._servers[0].emit('message', message);
   });
   it('Handle server message -- ledger', function(done) {
-    var message = {
+    const message = {
       type: 'ledgerClosed',
       fee_base: 10,
       fee_ref: 10,
@@ -590,7 +590,7 @@ describe('Remote', function() {
     });
   });
   it('Handle server message -- server status', function() {
-    var message = {
+    const message = {
       type: 'serverStatus',
       load_base: 256,
       load_factor: 256,
@@ -604,7 +604,7 @@ describe('Remote', function() {
     remote._servers[0].emit('connect');
   });
   it('Handle server message -- transaction', function() {
-    var message = require('./fixtures/transaction');
+    const message = require('./fixtures/transaction');
 
     remote.once('transaction', function(l) {
       assert.deepEqual(l, message);
@@ -613,8 +613,8 @@ describe('Remote', function() {
     remote._servers[0].emit('message', message);
   });
   it('Handle server message -- transaction -- duplicate hashes', function() {
-    var message = require('./fixtures/transaction');
-    var i = 0;
+    const message = require('./fixtures/transaction');
+    let i = 0;
 
     remote.once('transaction', function(l) {
       assert.deepEqual(l, message);
@@ -629,9 +629,9 @@ describe('Remote', function() {
   });
   it('Handle server message -- '
      + 'transaction -- with account notification', function() {
-    var message = require('./fixtures/transaction');
-    var i = 0;
-    var account = remote.addAccount(message.transaction.Account);
+    const message = require('./fixtures/transaction');
+    let i = 0;
+    const account = remote.addAccount(message.transaction.Account);
 
     account.once('transaction', function(t) {
       assert.deepEqual(t, message);
@@ -649,9 +649,9 @@ describe('Remote', function() {
   });
   it('Handle server message -- '
      + 'transaction proposed -- with account notification', function() {
-    var message = require('./fixtures/transaction-proposed');
-    var i = 0;
-    var account = remote.addAccount(message.transaction.Account);
+    const message = require('./fixtures/transaction-proposed');
+    let i = 0;
+    const account = remote.addAccount(message.transaction.Account);
 
     account.once('transaction', function(t) {
       assert.deepEqual(t, message);
@@ -669,9 +669,9 @@ describe('Remote', function() {
   });
   it('Handle server message -- transaction -- with orderbook notification',
      function() {
-    var message = require('./fixtures/transaction-offercreate');
-    var i = 0;
-    var orderbook = remote.createOrderBook({
+    const message = require('./fixtures/transaction-offercreate');
+    let i = 0;
+    const orderbook = remote.createOrderBook({
       currency_gets: 'USD',
       issuer_gets: 'rJy64aCJLP3vf8o3WPKn4iQKtfpjh6voAR',
       currency_pays: 'XRP'
@@ -694,15 +694,15 @@ describe('Remote', function() {
     assert.strictEqual(i, 2);
   });
   it('Handle server message -- path find', function() {
-    var message = require('./fixtures/pathfind');
-    var i = 0;
+    const message = require('./fixtures/pathfind');
+    let i = 0;
 
-    var amount = Amount.from_json({
+    const amount = Amount.from_json({
       currency: 'USD',
       issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
       value: '0.001'
     });
-    var path = new PathFind(remote,
+    const path = new PathFind(remote,
       'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
       'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
       amount
@@ -728,7 +728,7 @@ describe('Remote', function() {
     Log.setEngine(Log.engines.none);
 
     require('./fixtures/pathfind');
-    var i = 0;
+    let i = 0;
 
     remote.on('error', function(e) {
       assert(/^Unexpected response from remote/.test(e.message));
@@ -751,7 +751,7 @@ describe('Remote', function() {
       s._connected = true;
     });
 
-    var message = {
+    const message = {
       type: 'ledgerClosed',
       fee_base: 10,
       fee_ref: 10,
@@ -782,7 +782,7 @@ describe('Remote', function() {
     assert.strictEqual(remote.getServer(), null);
   });
   it('Get server -- primary server', function() {
-    var server = remote.addServer({
+    const server = remote.addServer({
       host: 'sasdf.ripple.com',
       port: 443,
       secure: true,
@@ -796,28 +796,28 @@ describe('Remote', function() {
   });
 
   it('Parse binary transaction', function() {
-    var binaryTransaction = require('./fixtures/binary-transaction.json');
+    const binaryTransaction = require('./fixtures/binary-transaction.json');
 
-    var parsedSourceTag = Remote.parseBinaryTransaction(
+    const parsedSourceTag = Remote.parseBinaryTransaction(
       binaryTransaction.PaymentWithSourceTag.binary);
     assert.deepEqual(parsedSourceTag,
                      binaryTransaction.PaymentWithSourceTag.parsed);
 
-    var parsedMemosAndPaths = Remote.parseBinaryTransaction(
+    const parsedMemosAndPaths = Remote.parseBinaryTransaction(
       binaryTransaction.PaymentWithMemosAndPaths.binary);
     assert.deepEqual(parsedMemosAndPaths,
                      binaryTransaction.PaymentWithMemosAndPaths.parsed);
 
-    var parsedPartialPayment = Remote.parseBinaryTransaction(
+    const parsedPartialPayment = Remote.parseBinaryTransaction(
       binaryTransaction.PartialPayment.binary);
     assert.deepEqual(parsedPartialPayment,
                      binaryTransaction.PartialPayment.parsed);
 
-    var parsedOfferCreate = Remote.parseBinaryTransaction(
+    const parsedOfferCreate = Remote.parseBinaryTransaction(
       binaryTransaction.OfferCreate.binary);
     assert.deepEqual(parsedOfferCreate, binaryTransaction.OfferCreate.parsed);
 
-    var parsedPartialPaymentWithXRPDelieveredAmount =
+    const parsedPartialPaymentWithXRPDelieveredAmount =
       Remote.parseBinaryTransaction(
         binaryTransaction.PartialPaymentWithXRPDeliveredAmount.binary);
 
@@ -828,40 +828,40 @@ describe('Remote', function() {
   });
 
   it('Parse binary account transaction', function() {
-    var binaryAccountTransaction =
+    const binaryAccountTransaction =
       require('./fixtures/binary-account-transaction.json');
 
-    var parsed = Remote.parseBinaryAccountTransaction(
+    const parsed = Remote.parseBinaryAccountTransaction(
       binaryAccountTransaction.OfferCreate.binary);
     assert.deepEqual(parsed, binaryAccountTransaction.OfferCreate.parsed);
 
-    var parsedPartialPayment = Remote.parseBinaryAccountTransaction(
+    const parsedPartialPayment = Remote.parseBinaryAccountTransaction(
       binaryAccountTransaction.PartialPayment.binary);
     assert.deepEqual(parsedPartialPayment,
                      binaryAccountTransaction.PartialPayment.parsed);
 
-    var parsedPayment = Remote.parseBinaryAccountTransaction(
+    const parsedPayment = Remote.parseBinaryAccountTransaction(
       binaryAccountTransaction.Payment.binary);
     assert.deepEqual(parsedPayment, binaryAccountTransaction.Payment.parsed);
   });
 
   it('Parse binary ledger', function() {
-    var binaryLedgerData = require('./fixtures/binary-ledger-data.json');
+    const binaryLedgerData = require('./fixtures/binary-ledger-data.json');
 
-    var parsedAccountRoot =
+    const parsedAccountRoot =
       Remote.parseBinaryLedgerData(binaryLedgerData.AccountRoot.binary);
     assert.deepEqual(parsedAccountRoot, binaryLedgerData.AccountRoot.parsed);
 
-    var parsedOffer =
+    const parsedOffer =
       Remote.parseBinaryLedgerData(binaryLedgerData.Offer.binary);
     assert.deepEqual(parsedOffer, binaryLedgerData.Offer.parsed);
 
-    var parsedDirectoryNode =
+    const parsedDirectoryNode =
       Remote.parseBinaryLedgerData(binaryLedgerData.DirectoryNode.binary);
     assert.deepEqual(parsedDirectoryNode,
                      binaryLedgerData.DirectoryNode.parsed);
 
-    var parsedRippleState =
+    const parsedRippleState =
       Remote.parseBinaryLedgerData(binaryLedgerData.RippleState.binary);
     assert.deepEqual(parsedRippleState, binaryLedgerData.RippleState.parsed);
   });
@@ -906,14 +906,14 @@ describe('Remote', function() {
   });
 
   it('Initiate request', function() {
-    var request = remote.requestServerInfo();
+    const request = remote.requestServerInfo();
 
     assert.deepEqual(request.message, {
       command: 'server_info',
       id: undefined
     });
 
-    var i = 0;
+    let i = 0;
     remote._connected = true;
     remote._servers[0]._connected = true;
     remote._servers[0]._request = function() {
@@ -924,14 +924,14 @@ describe('Remote', function() {
     assert.strictEqual(i, 1, 'Did not initiate request');
   });
   it('Initiate request -- with request name', function() {
-    var request = remote.request('server_info');
+    const request = remote.request('server_info');
 
     assert.deepEqual(request.message, {
       command: 'server_info',
       id: undefined
     });
 
-    var i = 0;
+    let i = 0;
     remote._connected = true;
     remote._servers[0]._connected = true;
     remote._servers[0]._request = function() {
@@ -955,7 +955,7 @@ describe('Remote', function() {
     });
   });
   it('Initiate request -- set non-existent servers', function() {
-    var request = remote.requestServerInfo();
+    const request = remote.requestServerInfo();
     request.setServer('wss://s-east.ripple.com:443');
     assert.strictEqual(request.server, null);
     assert.throws(function() {
@@ -965,14 +965,14 @@ describe('Remote', function() {
   });
 
   it('Construct ledger request', function() {
-    var request = remote.requestLedger();
+    const request = remote.requestLedger();
     assert.deepEqual(request.message, {
       command: 'ledger',
       id: undefined
     });
   });
   it('Construct ledger request -- with ledger index', function() {
-    var request = remote.requestLedger({ledger: 1});
+    let request = remote.requestLedger({ledger: 1});
     assert.deepEqual(request.message, {
       command: 'ledger',
       id: undefined,
@@ -997,7 +997,7 @@ describe('Remote', function() {
     });
   });
   it('Construct ledger request -- with ledger hash', function() {
-    var request = remote.requestLedger({ledger: LEDGER_HASH});
+    let request = remote.requestLedger({ledger: LEDGER_HASH});
     assert.deepEqual(request.message, {
       command: 'ledger',
       id: undefined,
@@ -1021,7 +1021,7 @@ describe('Remote', function() {
     });
   });
   it('Construct ledger request -- with ledger identifier', function() {
-    var request = remote.requestLedger({ledger: 'validated'});
+    let request = remote.requestLedger({ledger: 'validated'});
 
     assert.deepEqual(request.message, {
       command: 'ledger',
@@ -1054,7 +1054,7 @@ describe('Remote', function() {
     });
   });
   it('Construct ledger request -- with transactions', function() {
-    var request = remote.requestLedger({
+    let request = remote.requestLedger({
       ledger: 'validated',
       transactions: true
     });
@@ -1067,21 +1067,21 @@ describe('Remote', function() {
   });
 
   it('Construct ledger_closed request', function() {
-    var request = remote.requestLedgerClosed();
+    let request = remote.requestLedgerClosed();
     assert.deepEqual(request.message, {
       command: 'ledger_closed',
       id: undefined
     });
   });
   it('Construct ledger_header request', function() {
-    var request = remote.requestLedgerHeader();
+    let request = remote.requestLedgerHeader();
     assert.deepEqual(request.message, {
       command: 'ledger_header',
       id: undefined
     });
   });
   it('Construct ledger_current request', function() {
-    var request = remote.requestLedgerCurrent();
+    let request = remote.requestLedgerCurrent();
     assert.deepEqual(request.message, {
       command: 'ledger_current',
       id: undefined
@@ -1089,7 +1089,7 @@ describe('Remote', function() {
   });
 
   it('Construct ledger_data request -- with ledger hash', function() {
-    var request = remote.requestLedgerData({
+    let request = remote.requestLedgerData({
       ledger: LEDGER_HASH,
       limit: 5
     });
@@ -1104,7 +1104,7 @@ describe('Remote', function() {
   });
 
   it('Construct ledger_data request -- with ledger index', function() {
-    var request = remote.requestLedgerData({
+    let request = remote.requestLedgerData({
       ledger: LEDGER_INDEX,
       limit: 5
     });
@@ -1119,7 +1119,7 @@ describe('Remote', function() {
   });
 
   it('Construct ledger_data request -- no binary', function() {
-    var request = remote.requestLedgerData({
+    let request = remote.requestLedgerData({
       ledger: LEDGER_HASH,
       limit: 5,
       binary: false
@@ -1135,7 +1135,7 @@ describe('Remote', function() {
   });
 
   it('Construct server_info request', function() {
-    var request = remote.requestServerInfo();
+    let request = remote.requestServerInfo();
     assert.deepEqual(request.message, {
       command: 'server_info',
       id: undefined
@@ -1143,7 +1143,7 @@ describe('Remote', function() {
   });
 
   it('Construct peers request', function() {
-    var request = remote.requestPeers();
+    let request = remote.requestPeers();
     assert.deepEqual(request.message, {
       command: 'peers',
       id: undefined
@@ -1151,7 +1151,7 @@ describe('Remote', function() {
   });
 
   it('Construct connection request', function() {
-    var request = remote.requestConnect('0.0.0.0', '443');
+    let request = remote.requestConnect('0.0.0.0', '443');
     assert.deepEqual(request.message, {
       command: 'connect',
       id: undefined,
@@ -1161,7 +1161,7 @@ describe('Remote', function() {
   });
 
   it('Construct unl_add request', function() {
-    var request = remote.requestUnlAdd('0.0.0.0');
+    let request = remote.requestUnlAdd('0.0.0.0');
     assert.deepEqual(request.message, {
       command: 'unl_add',
       node: '0.0.0.0',
@@ -1170,7 +1170,7 @@ describe('Remote', function() {
   });
 
   it('Construct unl_list request', function() {
-    var request = remote.requestUnlList();
+    let request = remote.requestUnlList();
     assert.deepEqual(request.message, {
       command: 'unl_list',
       id: undefined
@@ -1178,7 +1178,7 @@ describe('Remote', function() {
   });
 
   it('Construct unl_delete request', function() {
-    var request = remote.requestUnlDelete('0.0.0.0');
+    let request = remote.requestUnlDelete('0.0.0.0');
     assert.deepEqual(request.message, {
       command: 'unl_delete',
       node: '0.0.0.0',
@@ -1187,7 +1187,7 @@ describe('Remote', function() {
   });
 
   it('Construct subscribe request', function() {
-    var request = remote.requestSubscribe(['server', 'ledger']);
+    let request = remote.requestSubscribe(['server', 'ledger']);
     assert.deepEqual(request.message, {
       command: 'subscribe',
       id: undefined,
@@ -1195,7 +1195,7 @@ describe('Remote', function() {
     });
   });
   it('Construct unsubscribe request', function() {
-    var request = remote.requestUnsubscribe(['server', 'ledger']);
+    let request = remote.requestUnsubscribe(['server', 'ledger']);
     assert.deepEqual(request.message, {
       command: 'unsubscribe',
       id: undefined,
@@ -1204,14 +1204,14 @@ describe('Remote', function() {
   });
 
   it('Construct ping request', function() {
-    var request = remote.requestPing();
+    let request = remote.requestPing();
     assert.deepEqual(request.message, {
       command: 'ping',
       id: undefined
     });
   });
   it('Construct ping request -- with server', function() {
-    var request = remote.requestPing('wss://s1.ripple.com:443');
+    let request = remote.requestPing('wss://s1.ripple.com:443');
     assert.strictEqual(request.server, remote._servers[0]);
     assert.deepEqual(request.message, {
       command: 'ping',
@@ -1220,7 +1220,7 @@ describe('Remote', function() {
   });
 
   it('Construct account_currencies request -- with ledger index', function() {
-    var request = remote.requestAccountCurrencies({
+    let request = remote.requestAccountCurrencies({
       account: ADDRESS
     });
     assert.strictEqual(request.message.command, 'account_currencies');
@@ -1228,7 +1228,7 @@ describe('Remote', function() {
   });
 
   it('Construct account_info request -- with ledger index', function() {
-    var request = remote.requestAccountInfo({
+    let request = remote.requestAccountInfo({
       account: ADDRESS,
       ledger: 9592219
     });
@@ -1237,7 +1237,7 @@ describe('Remote', function() {
     assert.strictEqual(request.message.ledger_index, 9592219);
   });
   it('Construct account_info request -- with ledger hash', function() {
-    var request = remote.requestAccountInfo({
+    let request = remote.requestAccountInfo({
       account: ADDRESS,
       ledger: LEDGER_HASH
     });
@@ -1246,7 +1246,7 @@ describe('Remote', function() {
     assert.strictEqual(request.message.ledger_hash, LEDGER_HASH);
   });
   it('Construct account_info request -- with ledger identifier', function() {
-    var request = remote.requestAccountInfo({
+    let request = remote.requestAccountInfo({
       account: ADDRESS,
       ledger: 'validated'
     });
@@ -1256,7 +1256,7 @@ describe('Remote', function() {
   });
 
   it('Construct account balance request -- with ledger index', function() {
-    var request = remote.requestAccountBalance({
+    let request = remote.requestAccountBalance({
       account: ADDRESS,
       ledger: 9592219
     });
@@ -1265,7 +1265,7 @@ describe('Remote', function() {
     assert.strictEqual(request.message.ledger_index, 9592219);
   });
   it('Construct account balance request -- with ledger hash', function() {
-    var request = remote.requestAccountBalance({
+    let request = remote.requestAccountBalance({
       account: ADDRESS,
       ledger: LEDGER_HASH
     });
@@ -1274,7 +1274,7 @@ describe('Remote', function() {
     assert.strictEqual(request.message.ledger_hash, LEDGER_HASH);
   });
   it('Construct account balance request -- with ledger identifier', function() {
-    var request = remote.requestAccountBalance({
+    let request = remote.requestAccountBalance({
       account: ADDRESS,
       ledger: 'validated'
     });
@@ -1284,18 +1284,18 @@ describe('Remote', function() {
   });
 
   it('Construct account flags request', function() {
-    var request = remote.requestAccountFlags({account: ADDRESS});
+    let request = remote.requestAccountFlags({account: ADDRESS});
     assert.strictEqual(request.message.command, 'ledger_entry');
     assert.strictEqual(request.message.account_root, ADDRESS);
   });
   it('Construct account owner count request', function() {
-    var request = remote.requestOwnerCount({account: ADDRESS});
+    let request = remote.requestOwnerCount({account: ADDRESS});
     assert.strictEqual(request.message.command, 'ledger_entry');
     assert.strictEqual(request.message.account_root, ADDRESS);
   });
 
   it('Construct account_lines request', function() {
-    var request = remote.requestAccountLines({account: ADDRESS});
+    let request = remote.requestAccountLines({account: ADDRESS});
     assert.deepEqual(request.message, {
       command: 'account_lines',
       id: undefined,
@@ -1303,7 +1303,7 @@ describe('Remote', function() {
     });
   });
   it('Construct account_lines request -- with peer', function() {
-    var request = remote.requestAccountLines({
+    let request = remote.requestAccountLines({
       account: ADDRESS,
       peer: ADDRESS
     });
@@ -1315,7 +1315,7 @@ describe('Remote', function() {
     });
   });
   it('Construct account_lines request -- with limit', function() {
-    var request = remote.requestAccountLines({
+    let request = remote.requestAccountLines({
       account: ADDRESS,
       limit: 100
     });
@@ -1327,7 +1327,7 @@ describe('Remote', function() {
     });
   });
   it('Construct account_lines request -- with limit and marker', function() {
-    var request = remote.requestAccountLines({
+    let request = remote.requestAccountLines({
       account: ADDRESS,
       limit: 100,
       marker: PAGING_MARKER,
@@ -1408,7 +1408,7 @@ describe('Remote', function() {
     }, 'A ledger_index or ledger_hash must be provided when using a marker');
   });
   it('Construct account_lines request -- with callback', function() {
-    var request = remote.requestAccountLines({
+    let request = remote.requestAccountLines({
       account: ADDRESS
     }, callback);
 
@@ -1420,7 +1420,7 @@ describe('Remote', function() {
   });
 
   it('Construct account_tx request', function() {
-    var request = remote.requestAccountTransactions({
+    let request = remote.requestAccountTransactions({
       account: UInt160.ACCOUNT_ONE,
       ledger_index_min: -1,
       ledger_index_max: -1,
@@ -1456,7 +1456,7 @@ describe('Remote', function() {
     });
   });
   it('Construct account_tx request -- no binary', function() {
-    var request = remote.requestAccountTransactions({
+    let request = remote.requestAccountTransactions({
       account: UInt160.ACCOUNT_ONE,
       ledger_index_min: -1,
       ledger_index_max: -1,
@@ -1480,7 +1480,7 @@ describe('Remote', function() {
   });
 
   it('Construct account_offers request -- no binary', function() {
-    var request = remote.requestAccountOffers({account: ADDRESS});
+    let request = remote.requestAccountOffers({account: ADDRESS});
     assert.deepEqual(request.message, {
       command: 'account_offers',
       id: undefined,
@@ -1489,7 +1489,7 @@ describe('Remote', function() {
   });
 
   it('Construct offer request -- with ledger index', function() {
-    var request = remote.requestOffer({
+    let request = remote.requestOffer({
       index: TRANSACTION_HASH, ledger: LEDGER_INDEX
     });
     assert.strictEqual(request.message.command, 'ledger_entry');
@@ -1497,7 +1497,7 @@ describe('Remote', function() {
     assert.strictEqual(request.message.ledger_index, LEDGER_INDEX);
   });
   it('Construct offer request -- with ledger index and sequence', function() {
-    var request = remote.requestOffer({
+    let request = remote.requestOffer({
       account: ADDRESS, ledger: LEDGER_INDEX, sequence: 5
     });
     assert.strictEqual(request.message.command, 'ledger_entry');
@@ -1506,7 +1506,7 @@ describe('Remote', function() {
     assert.strictEqual(request.message.ledger_index, LEDGER_INDEX);
   });
   it('Construct offer request -- with ledger hash', function() {
-    var request = remote.requestOffer({
+    let request = remote.requestOffer({
       account: ADDRESS, ledger: LEDGER_HASH, sequence: 5
     });
     assert.strictEqual(request.message.command, 'ledger_entry');
@@ -1516,7 +1516,7 @@ describe('Remote', function() {
   });
   it('Construct offer request -- with ledger identifier and sequence',
      function() {
-    var request = remote.requestOffer({
+    let request = remote.requestOffer({
       account: ADDRESS, ledger: 'validated', sequence: 5
     });
     assert.strictEqual(request.message.command, 'ledger_entry');
@@ -1526,7 +1526,7 @@ describe('Remote', function() {
   });
 
   it('Construct book_offers request', function() {
-    var request = remote.requestBookOffers({
+    let request = remote.requestBookOffers({
       taker_gets: {
         currency: 'USD',
         issuer: ADDRESS
@@ -1551,7 +1551,7 @@ describe('Remote', function() {
   });
 
   it('Construct book_offers request -- with ledger and limit', function() {
-    var request = remote.requestBookOffers({
+    let request = remote.requestBookOffers({
       taker_gets: {
         currency: 'USD',
         issuer: ADDRESS
@@ -1580,7 +1580,7 @@ describe('Remote', function() {
   });
 
   it('Construct tx request', function() {
-    var request = remote.requestTransaction({
+    let request = remote.requestTransaction({
       hash: TRANSACTION_HASH
     });
 
@@ -1592,7 +1592,7 @@ describe('Remote', function() {
     });
   });
   it('Construct tx request -- no binary', function() {
-    var request = remote.requestTransaction({
+    let request = remote.requestTransaction({
       hash: TRANSACTION_HASH,
       binary: false
     });
@@ -1606,7 +1606,7 @@ describe('Remote', function() {
   });
 
   it('Construct transaction_entry request', function() {
-    var request = remote.requestTransactionEntry({
+    let request = remote.requestTransactionEntry({
       hash: TRANSACTION_HASH
     });
 
@@ -1618,7 +1618,7 @@ describe('Remote', function() {
     });
   });
   it('Construct transaction_entry request -- with ledger index', function() {
-    var request = remote.requestTransactionEntry({
+    let request = remote.requestTransactionEntry({
       hash: TRANSACTION_HASH,
       ledger: 1
     });
@@ -1631,7 +1631,7 @@ describe('Remote', function() {
     });
   });
   it('Construct transaction_entry request -- with ledger hash', function() {
-    var request = remote.requestTransactionEntry({
+    let request = remote.requestTransactionEntry({
       hash: TRANSACTION_HASH,
       ledger: LEDGER_HASH
     });
@@ -1653,7 +1653,7 @@ describe('Remote', function() {
   });
 
   it('Construct tx_history request', function() {
-    var request = remote.requestTransactionHistory({
+    let request = remote.requestTransactionHistory({
       start: 1
     });
 
@@ -1665,7 +1665,7 @@ describe('Remote', function() {
   });
 
   it('Construct wallet_accounts request', function() {
-    var request = remote.requestWalletAccounts({
+    let request = remote.requestWalletAccounts({
       seed: 'shmnpxY42DaoyNbNQDoGuymNT1T9U'
     });
 
@@ -1686,7 +1686,7 @@ describe('Remote', function() {
   });
 
   it('Construct sign request', function() {
-    var request = remote.requestSign({
+    let request = remote.requestSign({
       secret: 'shmnpxY42DaoyNbNQDoGuymNT1T9U',
       tx_json: {
         Flags: 0,
@@ -1722,7 +1722,7 @@ describe('Remote', function() {
   });
 
   it('Construct submit request', function() {
-    var request = remote.requestSubmit();
+    let request = remote.requestSubmit();
     assert.deepEqual(request.message, {
       command: 'submit',
       id: undefined
@@ -1730,7 +1730,7 @@ describe('Remote', function() {
   });
 
   it('Construct transaction', function() {
-    var tx = remote.createTransaction('AccountSet', {
+    let tx = remote.createTransaction('AccountSet', {
       account: 'rwLZs9MUVv28XZdYXDk9uNRUpAh1c6jij8',
       flags: 0
     });
@@ -1758,7 +1758,7 @@ describe('Remote', function() {
 
   it('Construct ledger_accept request', function() {
     remote._stand_alone = true;
-    var request = remote.requestLedgerAccept();
+    let request = remote.requestLedgerAccept();
 
     assert.deepEqual(request.message, {
       command: 'ledger_accept',
@@ -1787,7 +1787,7 @@ describe('Remote', function() {
   });
 
   it('Construct ripple balance request', function() {
-    var request = remote.requestRippleBalance({
+    let request = remote.requestRippleBalance({
       account: 'rGr9PjmVe7MqEXTSbd3njhgJc2s5vpHV54',
       issuer: 'rwxBjBC9fPzyQ9GgPZw6YYLNeRTSx5c2W6',
       ledger: 1,
@@ -1809,7 +1809,7 @@ describe('Remote', function() {
   });
 
   it('Construct ripple_path_find request', function() {
-    var request = remote.requestRipplePathFind({
+    let request = remote.requestRipplePathFind({
       src_account: 'rGr9PjmVe7MqEXTSbd3njhgJc2s5vpHV54',
       dst_account: 'rwxBjBC9fPzyQ9GgPZw6YYLNeRTSx5c2W6',
       dst_amount: '1/USD/rGr9PjmVe7MqEXTSbd3njhgJc2s5vpHV54',
@@ -1836,7 +1836,7 @@ describe('Remote', function() {
   });
 
   it('Construct path_find create request', function() {
-    var request = remote.requestPathFindCreate({
+    let request = remote.requestPathFindCreate({
       src_account: 'rGr9PjmVe7MqEXTSbd3njhgJc2s5vpHV54',
       dst_account: 'rwxBjBC9fPzyQ9GgPZw6YYLNeRTSx5c2W6',
       dst_amount: '1/USD/rGr9PjmVe7MqEXTSbd3njhgJc2s5vpHV54',
@@ -1864,7 +1864,7 @@ describe('Remote', function() {
   });
 
   it('Construct path_find close request', function() {
-    var request = remote.requestPathFindClose();
+    let request = remote.requestPathFindClose();
 
     assert.deepEqual(request.message, {
       command: 'path_find',