bump version to 0.13.0-rc10

Add pattern for servers option

Gulpfile.js

@@ -26,6 +26,9 @@ function webpackConfig(extension, overrides) {
         test: /\.js$/,
         exclude: /node_modules/,
         loader: 'babel-loader?optional=runtime'
+      }, {
+        test: /\.json/,
+        loader: 'json-loader'
       }]
     }
   };

HISTORY.md

@@ -1,3 +1,14 @@
+##0.13.0 (release candidate)
+
++ [Fix: Emit error events and return error on pathfind](https://github.com/ripple/ripple-lib/commit/1ccbaf677631a1944eb05d90f7afc5f3690a03dd)
++ [Deprecate core and remove snake case method copying](https://github.com/ripple/ripple-lib/commit/fb8dc44ec1d49bb05cd0cdbe6dd4ab211195868a)
++ Add new RippleAPI interface
+    - [RippleAPI README and samples](https://github.com/ripple/ripple-lib/tree/develop/docs/samples)
+    - [Method documentation](https://rawgit.com/ripple/ripple-lib/develop/docs/api.html)
++ [Fix RangeSet for validated_ledger as single ledger](https://github.com/ripple/ripple-lib/commit/9f9e76f8b933201651af59307135f67cfa7d60e8)
++ [Fix bug where the paths would be set with an empty array](https://github.com/ripple/ripple-lib/commit/83874ec0962da311b76f2385623e51c68bc39035)
++ [Fix reserve calculation](https://github.com/ripple/ripple-lib/commit/52879febb92d876f01f2e4d70871baa07af631fb)
+
 ##0.12.6
 
 + [Fix webpack require failure due to "./" notation](https://github.com/ripple/ripple-lib/commit/8d9746d7b10be203ee613df523c2522012ff1baf)

README.md

@@ -2,7 +2,7 @@
 
 A JavaScript API for interacting with Ripple in Node.js and the browser
 
-[![Build Status](https://travis-ci.org/ripple/ripple-lib.svg?branch=develop)](https://travis-ci.org/ripple/ripple-lib) [![Coverage Status](https://coveralls.io/repos/ripple/ripple-lib/badge.png?branch=develop)](https://coveralls.io/r/ripple/ripple-lib?branch=develop)
+[![Circle CI](https://circleci.com/gh/ripple/ripple-lib/tree/develop.svg?style=svg)](https://circleci.com/gh/ripple/ripple-lib/tree/develop) [![Coverage Status](https://coveralls.io/repos/ripple/ripple-lib/badge.png?branch=develop)](https://coveralls.io/r/ripple/ripple-lib?branch=develop)
 
 [![NPM](https://nodei.co/npm/ripple-lib.png)](https://www.npmjs.org/package/ripple-lib)
 

bin/ci.sh

@@ -5,19 +5,32 @@ TOTAL_NODES="$2"
 
 typecheck() {
   npm install -g flow-bin
+  flow --version
   npm run typecheck
 }
 
 lint() {
+  echo "eslint $(node_modules/.bin/eslint --version)"
+  npm list babel-eslint | grep babel-eslint
   REPO_URL="https://raw.githubusercontent.com/ripple/javascript-style-guide"
   curl "$REPO_URL/es6/eslintrc" > ./eslintrc
-  echo "plugins: [flowtype]" >> ./eslintrc
-  node_modules/.bin/eslint --reset -c ./eslintrc $(git --no-pager diff --name-only -M100% --diff-filter=AM --relative $(git merge-base FETCH_HEAD origin/HEAD) FETCH_HEAD | grep "\.js$")
+  echo "parser: babel-eslint" >> ./eslintrc
+  node_modules/.bin/eslint -c ./eslintrc $(git --no-pager diff --name-only -M100% --diff-filter=AM --relative $(git merge-base FETCH_HEAD origin/HEAD) FETCH_HEAD | grep "\.js$")
 }
 
 unittest() {
+  # test "src"
   npm test --coverage
   npm run coveralls
+
+  # test compiled version in "dist/npm"
+  babel -D --optional runtime --ignore "**/node_modules/**" -d test-compiled/ test/
+  echo "--reporter spec --timeout 5000 --slow 500" > test-compiled/mocha.opts
+  mkdir -p test-compiled/node_modules
+  ln -nfs ../../dist/npm/core test-compiled/node_modules/ripple-lib
+  ln -nfs ../../dist/npm test-compiled/node_modules/ripple-api
+  mocha --opts test-compiled/mocha.opts test-compiled
+  rm -rf test-compiled
 }
 
 oneNode() {

docs/api.html

@@ -28,11 +28,11 @@ function toggle(element) {
 <h2><a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/index.js">RippleAPI</a></h2>
 
 <div class="method">
-connect(callback)
+connect()
 </div>
 
 <div class="method">
-disconnect(callback)
+disconnect()
 </div>
 
 <div class="method">
@@ -40,7 +40,7 @@ isConnected()
 </div>
 
 <div class="method">
-getServerInfo(callback)
+getServerInfo()
 </div>
 
 <div class="method">
@@ -53,9 +53,9 @@ getLedgerVersion()
 
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-transaction.json">getTransaction</a>(
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/hash256.json">identifier</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/transaction-options.json">options</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/hash256.json">identifier</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/transaction-options.json">options</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   identifier: txhash
@@ -65,9 +65,9 @@ callback)
 
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-transactions.json">getTransactions</a>(
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/transactions-options.json">options</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/transactions-options.json">options</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   options: {
@@ -87,9 +87,9 @@ callback)
 
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-trustlines.json">getTrustlines</a>(
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/trustlines-options.json">options</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/trustlines-options.json">options</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   options: {counterparty: address, currency: string, limit: int, ledgerVersion: int}
@@ -98,9 +98,9 @@ callback)
 
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-balances.json">getBalances</a>(
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/trustlines-options.json">options</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/trustlines-options.json">options</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   options: {counterparty: address, currency: string, limit: int, ledgerVersion: int}
@@ -109,8 +109,8 @@ callback)
 
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-paths.json">getPaths</a>(
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/pathfind.json">pathfind</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/pathfind.json">pathfind</a>
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   pathfind: {
@@ -131,9 +131,9 @@ callback)
 
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-orders.json">getOrders</a>(
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/orders-options.json">options</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/orders-options.json">options</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   options: {limit: int, ledverVersion: int}
@@ -143,9 +143,9 @@ callback)
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-orderbook.json">getOrderbook</a>(
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/orderbook.json">orderbook</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/orders-options.json">options</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/orderbook.json">orderbook</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/orders-options.json">options</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   orderbook: {
@@ -164,9 +164,9 @@ callback)
 
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-settings.json">getSettings</a>(
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/settings-options.json">options</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/settings-options.json">options</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   options: {ledgerVersion: int}
@@ -175,9 +175,9 @@ callback)
 
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-account-info.json">getAccountInfo</a>(
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/settings-options.json">options</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/settings-options.json">options</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   options: {ledgerVersion: int}
@@ -187,9 +187,9 @@ callback)
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/tx.json">preparePayment</a>(
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/payment.json">payment</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/payment.json">payment</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   payment: {
@@ -224,9 +224,9 @@ callback)
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/tx.json">prepareTrustline</a>(
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/trustline.json">trustline</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/trustline.json">trustline</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   trustline: {
@@ -253,9 +253,9 @@ callback)
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/tx.json">prepareOrder</a>(
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/order.json">order</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/order.json">order</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   order: {
@@ -282,9 +282,9 @@ callback)
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/tx.json">prepareOrderCancellation</a>(
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/sequence.json">sequence</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/sequence.json">sequence</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   sequence: int
@@ -302,9 +302,9 @@ callback)
 <div class="method">
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/tx.json">prepareSettings</a>(
 <a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/settings.json">settings</a>,
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/settings.json">settings</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>]
+)
 <a href="#" onclick="javascript:toggle(this)">+</a>
 <div class="details">
   settings: {
@@ -345,8 +345,8 @@ secret)
 
 <div class="method">
 submit(
-<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/blob.json">txBlob</a>,
-callback)
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/blob.json">txBlob</a>
+)
 </div>
 
 <div class="method">

docs/samples/balances.js

@@ -4,8 +4,8 @@ const RippleAPI = require('../../src').RippleAPI; // require('ripple-lib')
 const api = new RippleAPI({servers: ['wss://s1.ripple.com:443']});
 const address = 'r3kmLJN5D28dHuH8vZNUZpMC43pEHpaocV';
 
-api.connect(() => {
-  api.getBalances(address, {}, (error, balances) => {
+api.connect().then(() => {
+  api.getBalances(address).then(balances => {
     console.log(JSON.stringify(balances, null, 2));
     process.exit();
   });

docs/samples/payment.js

@@ -1,8 +1,8 @@
 'use strict';
 const RippleAPI = require('../../src').RippleAPI; // require('ripple-lib')
 
-const address = 'ENTER ADDRESS HERE';
-const secret = 'ENTER SECRET HERE';
+const address = 'INSERT ADDRESS HERE';
+const secret = 'INSERT SECRET HERE';
 
 const api = new RippleAPI({servers: ['wss://s1.ripple.com:443']});
 const instructions = {maxLedgerVersionOffset: 5};
@@ -24,15 +24,18 @@ const payment = {
   }
 };
 
-api.connect(() => {
+api.connect().then(() => {
   console.log('Connected...');
-  api.preparePayment(address, payment, instructions, (error, txJSON) => {
+  api.preparePayment(address, payment, instructions).then(txJSON => {
     console.log('Payment transaction prepared...');
     const signedTransaction = api.sign(txJSON, secret).signedTransaction;
     console.log('Payment transaction signed...');
-    api.submit(signedTransaction, (submitError, response) => {
-      console.log(submitError ? submitError : response);
-      process.exit(submitError ? 1 : 0);
+    api.submit(signedTransaction).then(response => {
+      console.log(response);
+      process.exit(0);
+    }).catch(error => {
+      console.log(error);
+      process.exit(1);
     });
   });
 });

npm-shrinkwrap.json

@@ -1,6 +1,6 @@
 {
   "name": "ripple-lib",
-  "version": "0.13.0-rc2",
+  "version": "0.13.0-rc10",
   "npm-shrinkwrap-version": "5.4.0",
   "node-version": "v0.12.7",
   "dependencies": {
@@ -9,12 +9,12 @@
       "resolved": "https://registry.npmjs.org/async/-/async-0.9.2.tgz"
     },
     "babel-runtime": {
-      "version": "5.8.19",
-      "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-5.8.19.tgz",
+      "version": "5.8.24",
+      "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-5.8.24.tgz",
       "dependencies": {
         "core-js": {
-          "version": "0.9.18",
-          "resolved": "https://registry.npmjs.org/core-js/-/core-js-0.9.18.tgz"
+          "version": "1.1.4",
+          "resolved": "https://registry.npmjs.org/core-js/-/core-js-1.1.4.tgz"
         }
       }
     },
@@ -22,21 +22,45 @@
       "version": "2.0.7",
       "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-2.0.7.tgz"
     },
+    "bn.js": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-3.1.2.tgz"
+    },
+    "es6-promisify": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/es6-promisify/-/es6-promisify-2.0.0.tgz",
+      "dependencies": {
+        "es6-promise": {
+          "version": "2.3.0",
+          "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-2.3.0.tgz"
+        }
+      }
+    },
     "extend": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/extend/-/extend-1.2.1.tgz"
     },
+    "hash.js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.0.3.tgz",
+      "dependencies": {
+        "inherits": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
+        }
+      }
+    },
     "https-proxy-agent": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-1.0.0.tgz",
       "dependencies": {
         "agent-base": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-2.0.0.tgz",
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-2.0.1.tgz",
           "dependencies": {
             "semver": {
-              "version": "4.3.6",
-              "resolved": "https://registry.npmjs.org/semver/-/semver-4.3.6.tgz"
+              "version": "5.0.3",
+              "resolved": "https://registry.npmjs.org/semver/-/semver-5.0.3.tgz"
             }
           }
         },
@@ -57,8 +81,8 @@
       }
     },
     "is-my-json-valid": {
-      "version": "2.12.1",
-      "resolved": "https://registry.npmjs.org/is-my-json-valid/-/is-my-json-valid-2.12.1.tgz",
+      "version": "2.12.2",
+      "resolved": "https://registry.npmjs.org/is-my-json-valid/-/is-my-json-valid-2.12.2.tgz",
       "dependencies": {
         "generate-function": {
           "version": "2.0.0",
@@ -75,8 +99,8 @@
           }
         },
         "jsonpointer": {
-          "version": "1.1.0",
-          "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-1.1.0.tgz"
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-2.0.0.tgz"
         },
         "xtend": {
           "version": "4.0.0",
@@ -85,16 +109,52 @@
       }
     },
     "lodash": {
-      "version": "3.10.0",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-3.10.0.tgz"
+      "version": "3.10.1",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-3.10.1.tgz"
     },
     "lru-cache": {
       "version": "2.5.2",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-2.5.2.tgz"
     },
+    "ripple-address-codec": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/ripple-address-codec/-/ripple-address-codec-1.6.0.tgz",
+      "dependencies": {
+        "x-address-codec": {
+          "version": "0.6.0",
+          "resolved": "https://registry.npmjs.org/x-address-codec/-/x-address-codec-0.6.0.tgz",
+          "dependencies": {
+            "base-x": {
+              "version": "1.0.1",
+              "resolved": "https://registry.npmjs.org/base-x/-/base-x-1.0.1.tgz"
+            }
+          }
+        }
+      }
+    },
+    "ripple-keypairs": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/ripple-keypairs/-/ripple-keypairs-0.8.0.tgz",
+      "dependencies": {
+        "brorand": {
+          "version": "1.0.5",
+          "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.0.5.tgz"
+        },
+        "elliptic": {
+          "version": "5.1.0",
+          "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-5.1.0.tgz",
+          "dependencies": {
+            "inherits": {
+              "version": "2.0.1",
+              "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
+            }
+          }
+        }
+      }
+    },
     "ripple-lib-transactionparser": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/ripple-lib-transactionparser/-/ripple-lib-transactionparser-0.4.0.tgz",
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/ripple-lib-transactionparser/-/ripple-lib-transactionparser-0.5.0.tgz",
       "dependencies": {
         "bignumber.js": {
           "version": "1.4.1",
@@ -102,20 +162,9 @@
         }
       }
     },
-    "ripple-wallet-generator": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/ripple-wallet-generator/-/ripple-wallet-generator-1.0.3.tgz"
-    },
-    "sjcl-extended": {
-      "version": "1.0.3",
-      "from": "sjcl-extended@git://github.com/ripple/sjcl-extended.git#d8cf8b22e7d97193c54e1f65113e3edcf200ca17",
-      "resolved": "git://github.com/ripple/sjcl-extended.git#d8cf8b22e7d97193c54e1f65113e3edcf200ca17",
-      "dependencies": {
-        "sjcl": {
-          "version": "1.0.3",
-          "resolved": "https://registry.npmjs.org/sjcl/-/sjcl-1.0.3.tgz"
-        }
-      }
+    "sjcl-codec": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/sjcl-codec/-/sjcl-codec-0.1.0.tgz"
     },
     "ws": {
       "version": "0.7.2",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ripple-lib",
-  "version": "0.13.0-rc2",
+  "version": "0.13.0-rc10",
   "license": "ISC",
   "description": "A JavaScript API for interacting with Ripple in Node.js and the browser",
   "files": [
@@ -18,24 +18,28 @@
     "async": "~0.9.0",
     "babel-runtime": "^5.5.4",
     "bignumber.js": "^2.0.3",
+    "bn.js": "^3.1.1",
+    "es6-promisify": "^2.0.0",
     "extend": "~1.2.1",
+    "hash.js": "^1.0.3",
     "https-proxy-agent": "^1.0.0",
-    "is-my-json-valid": "^2.12.0",
+    "is-my-json-valid": "^2.12.2",
     "lodash": "^3.1.0",
     "lru-cache": "~2.5.0",
-    "ripple-lib-transactionparser": "^0.4",
-    "ripple-wallet-generator": "^1.0.3",
-    "sjcl-extended": "ripple/sjcl-extended#1.0.3",
+    "ripple-address-codec": "^1.6.0",
+    "ripple-keypairs": "^0.8.0",
+    "ripple-lib-transactionparser": "^0.5.0",
+    "sjcl-codec": "0.1.0",
     "ws": "~0.7.1"
   },
   "devDependencies": {
     "assert-diff": "^1.0.1",
-    "babel": "^5.5.4",
-    "babel-core": "^5.5.4",
-    "babel-eslint": "^3.1.23",
-    "babel-loader": "^5.0.0",
+    "babel": "^5.8.21",
+    "babel-core": "^5.8.22",
+    "babel-eslint": "^4.0.5",
+    "babel-loader": "^5.3.2",
     "coveralls": "~2.10.0",
-    "eslint": "^0.24.0",
+    "eslint": "^1.3.0",
     "eslint-plugin-flowtype": "^1.0.0",
     "eventemitter2": "^0.4.14",
     "flow-bin": "^0.14",
@@ -44,6 +48,7 @@
     "gulp-rename": "~1.2.0",
     "gulp-uglify": "~1.1.0",
     "istanbul": "~0.3.5",
+    "json-loader": "^0.5.2",
     "mocha": "~2.1.0",
     "webpack": "~1.5.3",
     "yargs": "~1.3.1"
@@ -52,12 +57,13 @@
     "build": "gulp",
     "clean": "rm -rf dist/npm && rm -rf build/flow",
     "typecheck": "babel --optional runtime --blacklist flow -d build/flow/ src/ && flow check",
-    "compile": "babel --optional runtime -d dist/npm/ src/ && cp -r src/api/common/schemas/ dist/npm/api/common/schemas/",
-    "compile-with-source-maps": "babel --optional runtime -s -t -d dist/npm/ src/",
+    "compile": "babel -D --optional runtime -d dist/npm/ src/",
+    "watch": "babel -w -D --optional runtime -d dist/npm/ src/",
+    "compile-with-source-maps": "babel -D --optional runtime -s -t -d dist/npm/ src/",
     "prepublish": "npm run clean && npm run compile",
     "test": "istanbul test _mocha",
     "coveralls": "cat ./coverage/lcov.info | coveralls",
-    "lint": "if ! [ -f eslintrc ]; then curl -o eslintrc 'https://raw.githubusercontent.com/ripple/javascript-style-guide/es6/eslintrc'; echo 'plugins:\n  - flowtype' >> eslintrc; fi; eslint --reset -c eslintrc src/",
+    "lint": "if ! [ -f eslintrc ]; then curl -o eslintrc 'https://raw.githubusercontent.com/ripple/javascript-style-guide/es6/eslintrc'; echo 'parser: babel-eslint' >> eslintrc; fi; eslint -c eslintrc src/",
     "perf": "./scripts/perf_test.sh"
   },
   "repository": {

scripts/verify_ledger_json.js

@@ -2,12 +2,13 @@
 'use strict';
 
 var fs = require('fs');
-var Amount = require('../dist/npm').Amount;
-var Ledger = require('../dist/npm').Ledger;
+var ripple = require('../dist/npm')._DEPRECATED;
+var Amount = ripple.Amount;
+var Ledger = ripple.Ledger;
 
 function parse_options(from, flags) {
-  var argv = from.slice(),
-      opts_ = {argv: argv};
+  var argv = from.slice();
+  var opts_ = {argv: argv};
 
   flags.forEach(function(f) {
     // Do we have the flag?

src/api/common/errors.js

@@ -58,6 +58,13 @@ function MissingLedgerHistoryError(message) {
 MissingLedgerHistoryError.prototype = new RippleError();
 MissingLedgerHistoryError.prototype.name = 'MissingLedgerHistoryError';
 
+function PendingLedgerVersionError(message) {
+  this.message = message ||
+    'maxLedgerVersion is greater than server\'s most recent validated ledger';
+}
+PendingLedgerVersionError.prototype = new RippleError();
+PendingLedgerVersionError.prototype.name = 'PendingLedgerVersionError';
+
 /**
  * Request timed out
  */
@@ -77,13 +84,14 @@ ApiError.prototype = new RippleError();
 ApiError.prototype.name = 'ApiError';
 
 module.exports = {
-  ValidationError: ValidationError,
-  NetworkError: NetworkError,
-  TransactionError: TransactionError,
-  RippledNetworkError: RippledNetworkError,
-  NotFoundError: NotFoundError,
-  MissingLedgerHistoryError: MissingLedgerHistoryError,
-  TimeOutError: TimeOutError,
-  ApiError: ApiError,
-  RippleError: RippleError
+  ValidationError,
+  NetworkError,
+  TransactionError,
+  RippledNetworkError,
+  NotFoundError,
+  PendingLedgerVersionError,
+  MissingLedgerHistoryError,
+  TimeOutError,
+  ApiError,
+  RippleError
 };

src/api/common/index.js

@@ -9,8 +9,12 @@ module.exports = {
   dropsToXrp: utils.dropsToXrp,
   xrpToDrops: utils.xrpToDrops,
   toRippledAmount: utils.toRippledAmount,
-  wrapCatch: utils.wrapCatch,
+  generateAddress: utils.generateAddress,
   composeAsync: utils.composeAsync,
+  wrapCatch: utils.wrapCatch,
+  convertErrors: utils.convertErrors,
   convertExceptions: utils.convertExceptions,
-  convertKeysFromSnakeCaseToCamelCase: utils.convertKeysFromSnakeCaseToCamelCase
+  convertKeysFromSnakeCaseToCamelCase:
+    utils.convertKeysFromSnakeCaseToCamelCase,
+  promisify: utils.promisify
 };

src/api/common/schema-validator.js

@@ -1,38 +1,92 @@
-/* @flow */
+// flow is disabled for this file until support for requiring json is added:
+// https://github.com/facebook/flow/issues/167
 'use strict';
-
 const _ = require('lodash');
-const fs = require('fs');
-const path = require('path');
+const assert = require('assert');
 const validator = require('is-my-json-valid');
 const core = require('./utils').core;
 const ValidationError = require('./errors').ValidationError;
 
 let SCHEMAS = {};
 
-function isValidAddress(address) {
-  return core.UInt160.is_valid(address);
+function isValidAddress(address: string): boolean {
+  return typeof address === 'string' && address.length > 0 &&
+    address[0] === 'r' &&
+    core.UInt160.is_valid(address);
 }
 
 function isValidLedgerHash(ledgerHash) {
   return core.UInt256.is_valid(ledgerHash);
 }
 
-function loadSchema(filepath: string): {} {
-  try {
-    return JSON.parse(fs.readFileSync(filepath, 'utf8'));
-  } catch (e) {
-    throw new Error('Failed to parse schema: ' + filepath);
-  }
-}
-
-function endsWith(str, suffix) {
-  return str.indexOf(suffix, str.length - suffix.length) !== -1;
-}
-
-function loadSchemas(dir) {
-  const filenames = fs.readdirSync(dir).filter(name => endsWith(name, '.json'));
-  const schemas = filenames.map(name => loadSchema(path.join(dir, name)));
+function loadSchemas() {
+  // listed explicitly for webpack (instead of scanning schemas directory)
+  const schemas = [
+    require('./schemas/address.json'),
+    require('./schemas/adjustment.json'),
+    require('./schemas/amount.json'),
+    require('./schemas/amountbase.json'),
+    require('./schemas/balance.json'),
+    require('./schemas/blob.json'),
+    require('./schemas/currency.json'),
+    require('./schemas/get-account-info.json'),
+    require('./schemas/get-balances.json'),
+    require('./schemas/get-ledger.json'),
+    require('./schemas/get-orderbook.json'),
+    require('./schemas/get-orders.json'),
+    require('./schemas/get-paths.json'),
+    require('./schemas/get-server-info.json'),
+    require('./schemas/get-settings.json'),
+    require('./schemas/get-transaction.json'),
+    require('./schemas/get-transactions.json'),
+    require('./schemas/get-trustlines.json'),
+    require('./schemas/hash128.json'),
+    require('./schemas/hash256.json'),
+    require('./schemas/instructions.json'),
+    require('./schemas/issue.json'),
+    require('./schemas/ledger-options.json'),
+    require('./schemas/ledgerversion.json'),
+    require('./schemas/max-adjustment.json'),
+    require('./schemas/memo.json'),
+    require('./schemas/order-cancellation-transaction.json'),
+    require('./schemas/order-cancellation.json'),
+    require('./schemas/order-change.json'),
+    require('./schemas/order-transaction.json'),
+    require('./schemas/order.json'),
+    require('./schemas/orderbook-orders.json'),
+    require('./schemas/orderbook.json'),
+    require('./schemas/orders-options.json'),
+    require('./schemas/outcome.json'),
+    require('./schemas/pathfind.json'),
+    require('./schemas/payment-transaction.json'),
+    require('./schemas/payment.json'),
+    require('./schemas/quality.json'),
+    require('./schemas/remote-options.json'),
+    require('./schemas/sequence.json'),
+    require('./schemas/settings-options.json'),
+    require('./schemas/settings-transaction.json'),
+    require('./schemas/settings.json'),
+    require('./schemas/sign.json'),
+    require('./schemas/signed-value.json'),
+    require('./schemas/submit.json'),
+    require('./schemas/suspended-payment-cancellation.json'),
+    require('./schemas/suspended-payment-execution.json'),
+    require('./schemas/suspended-payment-creation.json'),
+    require('./schemas/timestamp.json'),
+    require('./schemas/transaction-options.json'),
+    require('./schemas/transactions-options.json'),
+    require('./schemas/trustline-transaction.json'),
+    require('./schemas/trustline.json'),
+    require('./schemas/trustlines-options.json'),
+    require('./schemas/tx.json'),
+    require('./schemas/uint32.json'),
+    require('./schemas/value.json'),
+    require('./schemas/prepare.json'),
+    require('./schemas/ledger-closed.json')
+  ];
+  const titles = _.map(schemas, schema => schema.title);
+  const duplicates = _.keys(_.pick(_.countBy(titles), count => count > 1));
+  assert(duplicates.length === 0, 'Duplicate schemas for: ' + duplicates);
   return _.indexBy(schemas, 'title');
 }
 
@@ -61,9 +115,8 @@ function schemaValidate(schemaName: string, object: any): void {
   }
 }
 
-SCHEMAS = loadSchemas(path.join(__dirname, './schemas'));
+SCHEMAS = loadSchemas();
 module.exports = {
   schemaValidate: schemaValidate,
-  loadSchema: loadSchema,
   SCHEMAS: SCHEMAS
 };

src/api/common/schemas/adjustment.json

@@ -4,7 +4,16 @@
   "type": "object",
   "properties": {
     "address": {"$ref": "address"},
-    "amount": {"$ref": "amount"},
+    "amount": {
+      "type": "object",
+      "properties": {
+        "currency": {"$ref": "currency"},
+        "counterparty": {"$ref": "address"},
+        "value": {"$ref": "value"}
+      },
+      "required": ["currency", "value"],
+      "additionalProperties": false
+    },
     "tag": {
       "description": "A string representing an unsigned 32-bit integer most commonly used to refer to a sender's hosted account at a Ripple gateway",
       "$ref": "uint32"

src/api/common/schemas/balance.json

@@ -6,7 +6,7 @@
   "properties": {
     "value": {
       "description": "The balance on the trustline",
-      "$ref": "signed-value"
+      "$ref": "signedValue"
     },
     "currency": {
       "description": "The three-character code or hex string used to denote currencies",

src/api/common/schemas/get-ledger.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getLedger",
+  "type": "object",
+  "properties": {
+    "accepted": {"type": "boolean"},
+    "closed": {"type": "boolean"},
+    "stateHash": {"$ref": "hash256"},
+    "closeTime": {"type": "integer", "minimum": 0},
+    "closeTimeResolution": {"type": "integer", "minimum": 1},
+    "closeFlags": {"type": "integer", "minimum": 0},
+    "ledgerHash": {"$ref": "hash256"},
+    "ledgerVersion": {"$ref": "ledgerVersion"},
+    "parentLedgerHash": {"$ref": "hash256"},
+    "parentCloseTime": {"type": "integer", "minimum": 0},
+    "totalDrops": {"$ref": "value"},
+    "transactionHash": {"$ref": "hash256"},
+    "transactions": {"type": "array", "items": {"type": "object"}},
+    "rawTransactions": {"type": "string"},
+    "transactionHashes": {"type": "array", "items": {"$ref": "hash256"}},
+    "rawState": {"type": "string"},
+    "stateHashes": {"type": "array", "items": {"$ref": "hash256"}}
+  },
+  "required": [
+    "accepted",
+    "closed",
+    "stateHash",
+    "closeTime",
+    "closeTimeResolution",
+    "closeFlags",
+    "ledgerHash",
+    "ledgerVersion",
+    "parentLedgerHash",
+    "parentCloseTime",
+    "totalDrops",
+    "transactionHash"
+  ],
+  "additionalProperties": false
+}

src/api/common/schemas/get-paths.json

@@ -5,7 +5,7 @@
   "items": {
     "type": "object",
     "properties": {
-      "source": {"$ref": "adjustment"},
+      "source": {"$ref": "maxAdjustment"},
       "destination": {"$ref": "adjustment"},
       "paths": {"type": "string"}
     },

src/api/common/schemas/get-server-info.json

@@ -10,7 +10,7 @@
     "load": {
       "type": "object",
       "properties": {
-        "job_types": {
+        "jobTypes": {
           "type": "array",
           "items": {"type": "object"}
         },

src/api/common/schemas/ledger-closed.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "ledgerClosed",
+  "description": "A ledgerClosed event message",
+  "type": "object",
+  "properties": {
+    "feeBase": {"type": "integer", "minimum": 0},
+    "feeReference": {"type": "integer", "minimum": 0},
+    "ledgerHash": {"$ref": "ledgerHash"},
+    "ledgerVersion": {"$ref": "ledgerVersion"},
+    "ledgerTimestamp": {"type": "string", "format": "date-time"},
+    "reserveBase": {"type": "integer", "minimum": 0},
+    "reserveIncrement": {"type": "integer", "minimum": 0},
+    "transactionCount": {"type": "integer", "minimum": 0},
+    "validatedLedgerVersions": {"type": "string"}
+  },
+  "addtionalProperties": false,
+  "required": ["feeBase", "feeReference", "ledgerHash", "ledgerTimestamp",
+    "reserveBase", "reserveIncrement", "transactionCount",
+    "ledgerVersion", "validatedLedgerVersions"]
+}

src/api/common/schemas/ledger-options.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "ledger-options",
+  "description": "Options for getLedger",
+  "type": "object",
+  "properties": {
+    "ledgerVersion": {"$ref": "ledgerVersion"},
+    "includeAllData": {"type": "boolean"},
+    "includeTransactions": {"type": "boolean"},
+    "includeState": {"type": "boolean"}
+  },
+  "additionalProperties": false
+}

src/api/common/schemas/max-adjustment.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "maxAdjustment",
+  "type": "object",
+  "properties": {
+    "address": {"$ref": "address"},
+    "maxAmount": {
+      "type": "object",
+      "properties": {
+        "currency": {"$ref": "currency"},
+        "counterparty": {"$ref": "address"},
+        "value": {"$ref": "value"}
+      },
+      "required": ["currency", "value"],
+      "additionalProperties": false
+    },
+    "tag": {
+      "description": "A string representing an unsigned 32-bit integer most commonly used to refer to a sender's hosted account at a Ripple gateway",
+      "$ref": "uint32"
+    }
+  },
+  "required": ["address", "maxAmount"],
+  "additionalProperties": false
+}

src/api/common/schemas/order-change.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "orderChange",
+  "type": "object",
+  "properties": {
+    "direction": {
+      "type": "string",
+      "enum": ["buy", "sell"]
+    },
+    "quantity": {"$ref": "balance"},
+    "totalPrice": {"$ref": "balance"},
+    "sequence": {"$ref": "sequence"},
+    "status": {"enum": ["created", "open", "closed", "canceled"]}
+  },
+  "required": ["direction", "quantity", "totalPrice", "sequence", "status"],
+  "additionalProperties": false
+}

src/api/common/schemas/outcome.json

@@ -4,10 +4,24 @@
   "type": "object",
   "properties": {
     "result": {"type": "string"},
-    "timestamp": {"type": "string"},
+    "timestamp": {"type": "string", "format": "date-time"},
     "fee": {"$ref": "value"},
-    "balanceChanges": {"type": "object"},
-    "orderbookChanges": {"type": "object"},
+    "balanceChanges": {
+      "type": "object",
+      "description": "Key is the ripple address; value is an array of changes",
+      "additionalProperties": {
+        "type": "array",
+        "items": {"$ref": "balance"}
+      }
+    },
+    "orderbookChanges": {
+      "type": "object",
+      "description": "Key is the maker's ripple address; value is an array of changes",
+      "additionalProperties": {
+        "type": "array",
+        "items": {"$ref": "orderChange"}
+      }
+    },
     "ledgerVersion": {"$ref": "ledgerVersion"},
     "indexInLedger": {"type": "integer", "minimum": 0}
   },

src/api/common/schemas/pathfind.json

@@ -24,32 +24,7 @@
       "additionalProperties": false,
       "required": ["address"]
     },
-    "destination": {
-      "type": "object",
-      "properties": {
-        "address": {"$ref": "address"},
-        "amount": {
-          "type": "object",
-          "properties": {
-            "value": {
-              "description": "The quantity of the currency, denoted as a string to retain floating point precision",
-              "$ref": "value"
-            },
-            "currency": {
-              "description": "The three-character code or hex string used to denote currencies",
-              "$ref": "currency"
-            },
-            "counterparty": {
-              "description": "The Ripple account address of the currency's issuer or gateway",
-              "$ref": "address"
-            },
-            "required": ["currency", "value"]
-          },
-          "additionalProperties": false
-        }
-      },
-      "required": ["address", "amount"]
-    }
+    "destination": {"$ref": "adjustment"}
   },
   "required": ["source", "destination"],
   "additionalProperties": false

src/api/common/schemas/payment.json

@@ -3,13 +3,9 @@
   "title": "payment",
   "type": "object",
   "properties": {
-    "source": {"$ref": "adjustment"},
+    "source": {"$ref": "maxAdjustment"},
     "destination": {"$ref": "adjustment"},
     "paths": {"type": "string"},
-    "slippage": {
-      "description": "An optional cushion for the source_amount to increase the likelihood that the payment will succeed. The source_account will never be charged more than source_amount.value + source_slippage",
-      "$ref": "value"
-    },
     "memos": {
       "type": "array",
       "items": {

src/api/common/schemas/prepare.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "prepare",
+  "description": "Result of prepare function",
+  "type": "object",
+  "properties": {
+    "txJSON": {"type": "string"},
+    "instructions": {
+      "type": "object",
+      "properties": {
+        "fee": {"$ref": "value"},
+        "sequence": {"$ref": "sequence"},
+        "maxLedgerVersion": {"$ref": "ledgerVersion"}
+      },
+      "additionalProperties": false,
+      "required": ["fee", "sequence"]
+    }
+  },
+  "additionalProperties": false,
+  "required": ["txJSON", "instructions"]
+}

src/api/common/schemas/remote-options.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "remote-options",
+  "type": "object",
+  "properties": {
+    "trace": {"type": "boolean"},
+    "servers": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "format": "uri",
+        "pattern": "^wss?://"
+      }
+    }
+  },
+  "additionalProperties": false
+}

src/api/common/schemas/settings-transaction.json

@@ -10,6 +10,6 @@
     "address": {"$ref": "address"},
     "sequence": {"$ref": "sequence"}
   },
-  "required": ["type", "id", "address", "sequence", "specification", "outcome"],
+  "required": ["type", "id", "address", "sequence", "specification"],
   "additionalProperties": false
 }

src/api/common/schemas/signed-value.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-04/schema#",
-  "title": "value",
+  "title": "signedValue",
   "description": "A string representation of a floating point number",
   "type": "string",
-  "pattern": "[-]?^[0-9]*[.]?[0-9]+([eE][-+]?[0-9]+)?$"
+  "pattern": "^[-]?[0-9]*[.]?[0-9]+([eE][-+]?[0-9]+)?$"
 }

src/api/common/schemas/suspended-payment-cancellation.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "suspended-payment-cancellation",
+  "type": "object",
+  "properties": {
+    "memos": {
+      "type": "array",
+      "items": {
+        "$ref": "memo"
+      }
+    },
+    "owner": {"$ref": "address"},
+    "paymentSequence": {"$ref": "uint32"}
+  },
+  "required": ["owner", "paymentSequence"],
+  "additionalProperties": false
+}

src/api/common/schemas/suspended-payment-creation.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "suspended-payment-creation",
+  "type": "object",
+  "properties": {
+    "source": {"$ref": "maxAdjustment"},
+    "destination": {"$ref": "adjustment"},
+    "memos": {
+      "type": "array",
+      "items": {
+        "$ref": "memo"
+      }
+    },
+    "digest": {"$ref": "hash256"},
+    "allowCancelAfter": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "milliseconds since unix epoch"
+    },
+    "allowExecuteAfter": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "milliseconds since unix epoch"
+    }
+  },
+  "required": ["source", "destination"],
+  "additionalProperties": false
+}

src/api/common/schemas/suspended-payment-execution.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "suspended-payment-execution",
+  "type": "object",
+  "properties": {
+    "memos": {
+      "type": "array",
+      "items": {
+        "$ref": "memo"
+      }
+    },
+    "owner": {"$ref": "address"},
+    "paymentSequence": {"$ref": "uint32"},
+    "method": {"type": "integer", "minimum": 0, "maximum": 255},
+    "digest": {"$ref": "hash256"},
+    "proof": {"type": "string"}
+  },
+  "required": ["owner", "paymentSequence"],
+  "additionalProperties": false
+}

src/api/common/utils.js

@@ -4,6 +4,8 @@ const _ = require('lodash');
 const BigNumber = require('bignumber.js');
 const core = require('../../core');
 const errors = require('./errors');
+const es6promisify = require('es6-promisify');
+const keypairs = require('ripple-keypairs');
 
 type Amount = {currency: string, issuer: string, value: string}
 
@@ -26,6 +28,11 @@ function toRippledAmount(amount: Amount): string|Amount {
   };
 }
 
+function generateAddress(options?: Object): Object {
+  const {accountID, seed} = keypairs.generateWallet(options);
+  return {secret: seed, address: accountID};
+}
+
 type AsyncFunction = (...x: any) => void
 
 function wrapCatch(asyncFunction: AsyncFunction): AsyncFunction {
@@ -45,7 +52,7 @@ type Wrapper = (data: any) => any
 function composeAsync(wrapper: Wrapper, callback: Callback): Callback {
   return function(error, data) {
     if (error) {
-      callback(error);
+      callback(error, data);
       return;
     }
     let result;
@@ -59,6 +66,21 @@ function composeAsync(wrapper: Wrapper, callback: Callback): Callback {
   };
 }
 
+function convertErrors(callback: Callback): () => void {
+  return function(error, data) {
+    if (error && !(error instanceof errors.RippleError)) {
+      const error_ = new errors.RippleError(error);
+      error_.data = data;
+      callback(error_, data);
+    } else if (error) {
+      error.data = data;
+      callback(error, data);
+    } else {
+      callback(error, data);
+    }
+  };
+}
+
 function convertExceptions<T>(f: () => T): () => T {
   return function() {
     try {
@@ -85,13 +107,20 @@ function convertKeysFromSnakeCaseToCamelCase(obj: any): any {
   return obj;
 }
 
+function promisify(asyncFunction: AsyncFunction): Function {
+  return es6promisify(wrapCatch(asyncFunction));
+}
+
 module.exports = {
   core,
   dropsToXrp,
   xrpToDrops,
   toRippledAmount,
-  wrapCatch,
+  generateAddress,
   composeAsync,
+  wrapCatch,
   convertExceptions,
-  convertKeysFromSnakeCaseToCamelCase
+  convertErrors,
+  convertKeysFromSnakeCaseToCamelCase,
+  promisify
 };

src/api/common/validate.js

@@ -9,17 +9,16 @@ function error(text) {
   return new ValidationError(text);
 }
 
-function validateAddressAndSecret(obj: {address: string, secret: string}): void {
+function validateAddressAndSecret(obj: {address: string, secret: string}
+): void {
   const address = obj.address;
   const secret = obj.secret;
   schemaValidate('address', address);
   if (!secret) {
     throw error('Parameter missing: secret');
   }
-  try {
-    core.Seed.from_json(secret).get_key(address);
-  } catch (exception) {
-    throw error('secret does not match address');
+  if (!core.Seed.from_json(secret).is_valid()) {
+    throw error('secret is invalid');
   }
 }
 
@@ -57,10 +56,17 @@ module.exports = {
   secret: validateSecret,
   currency: _.partial(schemaValidate, 'currency'),
   identifier: _.partial(schemaValidate, 'hash256'),
+  ledgerVersion: _.partial(schemaValidate, 'ledgerVersion'),
   sequence: _.partial(schemaValidate, 'sequence'),
   order: _.partial(schemaValidate, 'order'),
   orderbook: _.partial(schemaValidate, 'orderbook'),
   payment: _.partial(schemaValidate, 'payment'),
+  suspendedPaymentCreation:
+    _.partial(schemaValidate, 'suspended-payment-creation'),
+  suspendedPaymentExecution:
+    _.partial(schemaValidate, 'suspended-payment-execution'),
+  suspendedPaymentCancellation:
+    _.partial(schemaValidate, 'suspended-payment-cancellation'),
   pathfind: _.partial(schemaValidate, 'pathfind'),
   settings: _.partial(schemaValidate, 'settings'),
   trustline: _.partial(schemaValidate, 'trustline'),
@@ -74,6 +80,8 @@ module.exports = {
   getOrdersOptions: _.partial(validateOptions, 'orders-options'),
   getOrderbookOptions: _.partial(validateOptions, 'orders-options'),
   getTransactionOptions: _.partial(validateOptions, 'transaction-options'),
+  getLedgerOptions: _.partial(validateOptions, 'ledger-options'),
   options: _.partial(validateOptions, 'options'),
+  remoteOptions: _.partial(schemaValidate, 'remote-options'),
   instructions: _.partial(schemaValidate, 'instructions')
 };

src/api/index.js

@@ -2,7 +2,9 @@
 
 'use strict';
 const _ = require('lodash');
-const core = require('./common').core;
+const util = require('util');
+const EventEmitter = require('events').EventEmitter;
+const common = require('./common');
 const server = require('./server/server');
 const connect = server.connect;
 const disconnect = server.disconnect;
@@ -23,19 +25,36 @@ const preparePayment = require('./transaction/payment');
 const prepareTrustline = require('./transaction/trustline');
 const prepareOrder = require('./transaction/order');
 const prepareOrderCancellation = require('./transaction/ordercancellation');
+const prepareSuspendedPaymentCreation =
+  require('./transaction/suspended-payment-creation');
+const prepareSuspendedPaymentExecution =
+  require('./transaction/suspended-payment-execution');
+const prepareSuspendedPaymentCancellation =
+  require('./transaction/suspended-payment-cancellation');
 const prepareSettings = require('./transaction/settings');
 const sign = require('./transaction/sign');
 const submit = require('./transaction/submit');
 const errors = require('./common').errors;
 const convertExceptions = require('./common').convertExceptions;
-const generateWallet = convertExceptions(core.Wallet.generate);
+const generateAddress = convertExceptions(common.generateAddress);
+const computeLedgerHash = require('./offline/ledgerhash');
+const getLedger = require('./ledger/ledger');
 
 function RippleAPI(options: {}) {
+  common.validate.remoteOptions(options);
+  if (EventEmitter instanceof Function) { // always true, needed for flow
+    EventEmitter.call(this);
+  }
   const _options = _.assign({}, options, {automatic_resubmission: false});
-  this.remote = new core.Remote(_options);
+  this.remote = new common.core.Remote(_options);
+  this.remote.on('ledger_closed', message => {
+    this.emit('ledgerClosed', server.formatLedgerClose(message));
+  });
 }
 
-RippleAPI.prototype = {
+util.inherits(RippleAPI, EventEmitter);
+
+_.assign(RippleAPI.prototype, {
   connect,
   disconnect,
   isConnected,
@@ -52,17 +71,29 @@ RippleAPI.prototype = {
   getOrderbook,
   getSettings,
   getAccountInfo,
+  getLedger,
 
   preparePayment,
   prepareTrustline,
   prepareOrder,
   prepareOrderCancellation,
+  prepareSuspendedPaymentCreation,
+  prepareSuspendedPaymentExecution,
+  prepareSuspendedPaymentCancellation,
   prepareSettings,
   sign,
   submit,
 
-  generateWallet,
+  generateAddress,
   errors
+});
+
+// these are exposed only for use by unit tests; they are not part of the API
+RippleAPI._PRIVATE = {
+  common,
+  computeLedgerHash,
+  ledgerUtils: require('./ledger/utils'),
+  schemaValidator: require('./common/schema-validator')
 };
 
 module.exports = RippleAPI;

src/api/ledger/accountinfo.js

@@ -5,8 +5,45 @@ const utils = require('./utils');
 const removeUndefined = require('./parse/utils').removeUndefined;
 const validate = utils.common.validate;
 const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
 
-function formatAccountInfo(response) {
+type AccountData = {
+  Sequence: number,
+  Account: string,
+  Balance: string,
+  Flags: number,
+  LedgerEntryType: string,
+  OwnerCount: number,
+  PreviousTxnID: string,
+  AccountTxnID?: string,
+  PreviousTxnLgrSeq: number,
+  index: string
+}
+
+type AccountDataResponse = {
+  account_data: AccountData,
+  ledger_current_index?: number,
+  ledger_hash?: string,
+  ledger_index: number,
+  validated: boolean
+}
+
+type AccountInfoOptions = {
+  ledgerVersion?: number
+}
+
+type AccountInfoCallback = (err: any, data: AccountInfoResponse) => void
+
+type AccountInfoResponse = {
+  sequence: number,
+  xrpBalance: string,
+  ownerCount: number,
+  previousInitiatedTransactionID: string,
+  previousAffectingTransactionID: string,
+  previousAffectingTransactionLedgerVersion: number
+}
+
+function formatAccountInfo(response: AccountDataResponse) {
   const data = response.account_data;
   return removeUndefined({
     sequence: data.Sequence,
@@ -18,17 +55,24 @@ function formatAccountInfo(response) {
   });
 }
 
-function getAccountInfo(account, options, callback) {
+function getAccountInfoAsync(account: string, options: AccountInfoOptions,
+                             callback: AccountInfoCallback
+) {
   validate.address(account);
   validate.getAccountInfoOptions(options);
 
   const request = {
     account: account,
-    ledger: options.ledgerVersion
+    ledger: options.ledgerVersion || 'validated'
   };
 
   this.remote.requestAccountInfo(request,
-    composeAsync(formatAccountInfo, callback));
+    composeAsync(formatAccountInfo, convertErrors(callback)));
 }
 
-module.exports = utils.wrapCatch(getAccountInfo);
+function getAccountInfo(account: string, options: AccountInfoOptions = {}
+): Promise<AccountInfoResponse> {
+  return utils.promisify(getAccountInfoAsync).call(this, account, options);
+}
+
+module.exports = getAccountInfo;

src/api/ledger/balances.js

@@ -6,6 +6,7 @@ const utils = require('./utils');
 const getTrustlines = require('./trustlines');
 const validate = utils.common.validate;
 const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
 
 function getTrustlineBalanceAmount(trustline) {
   return {
@@ -24,7 +25,13 @@ function formatBalances(balances) {
     balances.trustlines.map(getTrustlineBalanceAmount));
 }
 
-function getBalances(account, options, callback) {
+function getTrustlinesAsync(account, options, callback) {
+  getTrustlines.call(this, account, options)
+    .then(data => callback(null, data))
+    .catch(callback);
+}
+
+function getBalancesAsync(account, options, callback) {
   validate.address(account);
   validate.getBalancesOptions(options);
 
@@ -32,8 +39,12 @@ function getBalances(account, options, callback) {
                       || this.remote.getLedgerSequence();
   async.parallel({
     xrp: _.partial(utils.getXRPBalance, this.remote, account, ledgerVersion),
-    trustlines: _.partial(getTrustlines.bind(this), account, options)
-  }, composeAsync(formatBalances, callback));
+    trustlines: _.partial(getTrustlinesAsync.bind(this), account, options)
+  }, composeAsync(formatBalances, convertErrors(callback)));
 }
 
-module.exports = utils.wrapCatch(getBalances);
+function getBalances(account: string, options = {}) {
+  return utils.promisify(getBalancesAsync).call(this, account, options);
+}
+
+module.exports = getBalances;

src/api/ledger/ledger.js

@@ -0,0 +1,28 @@
+/* @flow */
+'use strict';
+const utils = require('./utils');
+const validate = utils.common.validate;
+const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
+const parseLedger = require('./parse/ledger');
+
+function getLedgerAsync(options, callback) {
+  validate.getLedgerOptions(options);
+
+  const request = {
+    ledger: options.ledgerVersion || 'validated',
+    expand: options.includeAllData,
+    transactions: options.includeTransactions,
+    accounts: options.includeState
+  };
+
+  this.remote.requestLedger(request,
+    composeAsync(response => parseLedger(response.ledger),
+    convertErrors(callback)));
+}
+
+function getLedger(options = {}) {
+  return utils.promisify(getLedgerAsync).call(this, options);
+}
+
+module.exports = getLedger;

src/api/ledger/orderbook.js

@@ -3,21 +3,23 @@
 const _ = require('lodash');
 const async = require('async');
 const utils = require('./utils');
-const parseOrderbookOrder = require('./parse/orderbook-order');
 const validate = utils.common.validate;
 const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
+const parseOrderbookOrder = require('./parse/orderbook-order');
 
 // account is to specify a "perspective", which affects which unfunded offers
 // are returned
 function getBookOffers(remote, account, ledgerVersion, limit,
-    takerGets, takerPays, callback) {
+    takerGets, takerPays, callback
+) {
   remote.requestBookOffers(utils.renameCounterpartyToIssuerInOrder({
     taker_gets: takerGets,
     taker_pays: takerPays,
     ledger: ledgerVersion || 'validated',
     limit: limit,
     taker: account
-  }), composeAsync(data => data.offers, callback));
+  }), composeAsync(data => data.offers, convertErrors(callback)));
 }
 
 function isSameIssue(a, b) {
@@ -62,7 +64,7 @@ function formatBidsAndAsks(orderbook, offers) {
   return {bids, asks};
 }
 
-function getOrderbook(account, orderbook, options, callback) {
+function getOrderbookAsync(account, orderbook, options, callback) {
   validate.address(account);
   validate.orderbook(orderbook);
   validate.getOrderbookOptions(options);
@@ -76,4 +78,9 @@ function getOrderbook(account, orderbook, options, callback) {
                  callback));
 }
 
-module.exports = utils.wrapCatch(getOrderbook);
+function getOrderbook(account: string, orderbook: Object, options = {}) {
+  return utils.promisify(getOrderbookAsync).call(this,
+    account, orderbook, options);
+}
+
+module.exports = getOrderbook;

src/api/ledger/orders.js

@@ -4,10 +4,12 @@ const _ = require('lodash');
 const utils = require('./utils');
 const validate = utils.common.validate;
 const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
 const parseAccountOrder = require('./parse/account-order');
 
-function requestAccountOffers(remote, address, ledgerVersion, options,
-    marker, limit, callback) {
+function requestAccountOffers(remote, address, ledgerVersion, marker, limit,
+  callback
+) {
   remote.requestAccountOffers({
     account: address,
     marker: marker,
@@ -17,20 +19,24 @@ function requestAccountOffers(remote, address, ledgerVersion, options,
   composeAsync((data) => ({
     marker: data.marker,
     results: data.offers.map(_.partial(parseAccountOrder, address))
-  }), callback));
+  }), convertErrors(callback)));
 }
 
-function getOrders(account, options, callback) {
+function getOrdersAsync(account, options, callback) {
   validate.address(account);
   validate.getOrdersOptions(options);
 
   const ledgerVersion = options.ledgerVersion
                       || this.remote.getLedgerSequence();
   const getter = _.partial(requestAccountOffers, this.remote, account,
-                           ledgerVersion, options);
+                           ledgerVersion);
   utils.getRecursive(getter, options.limit,
     composeAsync((orders) => _.sortBy(orders,
       (order) => order.properties.sequence), callback));
 }
 
-module.exports = utils.wrapCatch(getOrders);
+function getOrders(account: string, options = {}) {
+  return utils.promisify(getOrdersAsync).call(this, account, options);
+}
+
+module.exports = getOrders;

src/api/ledger/parse/ledger.js

@@ -0,0 +1,50 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const removeUndefined = require('./utils').removeUndefined;
+const parseTransaction = require('./transaction');
+
+function parseTransactions(transactions) {
+  if (_.isEmpty(transactions)) {
+    return {};
+  }
+  if (_.isString(transactions[0])) {
+    return {transactionHashes: transactions};
+  }
+  return {
+    transactions: _.map(transactions, parseTransaction),
+    rawTransactions: JSON.stringify(transactions)
+  };
+}
+
+function parseState(state) {
+  if (_.isEmpty(state)) {
+    return {};
+  }
+  if (_.isString(state[0])) {
+    return {stateHashes: state};
+  }
+  return {rawState: JSON.stringify(state)};
+}
+
+function parseLedger(ledger: Object): Object {
+  return removeUndefined(_.assign({
+    accepted: ledger.accepted,
+    closed: ledger.closed,
+    stateHash: ledger.account_hash,
+    closeTime: ledger.close_time,
+    closeTimeResolution: ledger.close_time_resolution,
+    closeFlags: ledger.close_flags,
+    ledgerHash: ledger.hash || ledger.ledger_hash,
+    ledgerVersion: parseInt(ledger.ledger_index || ledger.seqNum, 10),
+    parentLedgerHash: ledger.parent_hash,
+    parentCloseTime: ledger.parent_close_time,
+    totalDrops: ledger.total_coins || ledger.totalCoins,
+    transactionHash: ledger.transaction_hash
+  },
+  parseTransactions(ledger.transactions),
+  parseState(ledger.accountState)
+  ));
+}
+
+module.exports = parseLedger;

src/api/ledger/parse/pathfind.js

@@ -9,12 +9,13 @@ function parsePaths(paths) {
 }
 
 function parsePathfind(sourceAddress: string,
-    destinationAmount: Object, pathfindResult: Object): Object {
+    destinationAmount: Object, pathfindResult: Object
+): Object {
   return pathfindResult.alternatives.map(function(alternative) {
     return {
       source: {
         address: sourceAddress,
-        amount: parseAmount(alternative.source_amount)
+        maxAmount: parseAmount(alternative.source_amount)
       },
       destination: {
         address: pathfindResult.destination_account,

src/api/ledger/parse/payment.js

@@ -1,5 +1,6 @@
 /* @flow */
 'use strict';
+const _ = require('lodash');
 const assert = require('assert');
 const utils = require('./utils');
 const parseAmount = require('./amount');
@@ -17,17 +18,9 @@ function isQualityLimited(tx) {
   return (tx.Flags & Transaction.flags.Payment.LimitQuality) !== 0;
 }
 
-function parsePaymentMemos(tx) {
-  if (!Array.isArray(tx.Memos) || tx.Memos.length === 0) {
-    return undefined;
-  }
-  return tx.Memos.map((m) => {
-    return utils.removeUndefined({
-      type: m.Memo.parsed_memo_type,
-      format: m.Memo.parsed_memo_format,
-      data: m.Memo.parsed_memo_data
-    });
-  });
+function removeGenericCounterparty(amount, address) {
+  return amount.counterparty === address ?
+    _.omit(amount, 'counterparty') : amount;
 }
 
 function parsePayment(tx: Object): Object {
@@ -35,20 +28,21 @@ function parsePayment(tx: Object): Object {
 
   const source = {
     address: tx.Account,
-    amount: parseAmount(tx.SendMax || tx.Amount),
+    maxAmount: removeGenericCounterparty(
+      parseAmount(tx.SendMax || tx.Amount), tx.Account),
     tag: tx.SourceTag
   };
 
   const destination = {
     address: tx.Destination,
-    amount: parseAmount(tx.Amount),
+    amount: removeGenericCounterparty(parseAmount(tx.Amount), tx.Destination),
     tag: tx.DestinationTag
   };
 
   return utils.removeUndefined({
     source: utils.removeUndefined(source),
     destination: utils.removeUndefined(destination),
-    memos: parsePaymentMemos(tx),
+    memos: utils.parseMemos(tx),
     invoiceID: tx.InvoiceID,
     paths: tx.Paths ? JSON.stringify(tx.Paths) : undefined,
     allowPartialPayment: isPartialPayment(tx) || undefined,

src/api/ledger/parse/suspended-payment-cancellation.js

@@ -0,0 +1,16 @@
+/* @flow */
+'use strict';
+const assert = require('assert');
+const utils = require('./utils');
+
+function parseSuspendedPaymentCancellation(tx: Object): Object {
+  assert(tx.TransactionType === 'SuspendedPaymentCancel');
+
+  return utils.removeUndefined({
+    memos: utils.parseMemos(tx),
+    owner: tx.Owner,
+    paymentSequence: tx.OfferSequence
+  });
+}
+
+module.exports = parseSuspendedPaymentCancellation;

src/api/ledger/parse/suspended-payment-creation.js

@@ -0,0 +1,39 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const assert = require('assert');
+const utils = require('./utils');
+const parseAmount = require('./amount');
+
+function removeGenericCounterparty(amount, address) {
+  return amount.counterparty === address ?
+    _.omit(amount, 'counterparty') : amount;
+}
+
+function parseSuspendedPaymentCreation(tx: Object): Object {
+  assert(tx.TransactionType === 'SuspendedPaymentCreate');
+
+  const source = {
+    address: tx.Account,
+    maxAmount: removeGenericCounterparty(
+      parseAmount(tx.SendMax || tx.Amount), tx.Account),
+    tag: tx.SourceTag
+  };
+
+  const destination = {
+    address: tx.Destination,
+    amount: removeGenericCounterparty(parseAmount(tx.Amount), tx.Destination),
+    tag: tx.DestinationTag
+  };
+
+  return utils.removeUndefined({
+    source: utils.removeUndefined(source),
+    destination: utils.removeUndefined(destination),
+    memos: utils.parseMemos(tx),
+    digest: tx.Digest,
+    allowCancelAfter: tx.CancelAfter,
+    allowExecuteAfter: tx.FinishAfter
+  });
+}
+
+module.exports = parseSuspendedPaymentCreation;

src/api/ledger/parse/suspended-payment-execution.js

@@ -0,0 +1,25 @@
+/* @flow */
+'use strict';
+const assert = require('assert');
+const sjclcodec = require('sjcl-codec');
+const utils = require('./utils');
+
+function convertHexToString(hexString) {
+  const bits = sjclcodec.hex.toBits(hexString);
+  return sjclcodec.utf8String.fromBits(bits);
+}
+
+function parseSuspendedPaymentExecution(tx: Object): Object {
+  assert(tx.TransactionType === 'SuspendedPaymentFinish');
+
+  return utils.removeUndefined({
+    memos: utils.parseMemos(tx),
+    owner: tx.Owner,
+    paymentSequence: tx.OfferSequence,
+    method: tx.Method,
+    digest: tx.Digest,
+    proof: tx.Proof ? convertHexToString(tx.Proof) : undefined
+  });
+}
+
+module.exports = parseSuspendedPaymentExecution;

src/api/ledger/parse/transaction.js

@@ -7,6 +7,10 @@ const parseTrustline = require('./trustline');
 const parseOrder = require('./order');
 const parseOrderCancellation = require('./cancellation');
 const parseSettings = require('./settings');
+const parseSuspendedPaymentCreation = require('./suspended-payment-creation');
+const parseSuspendedPaymentExecution = require('./suspended-payment-execution');
+const parseSuspendedPaymentCancellation =
+  require('./suspended-payment-cancellation');
 
 function parseTransactionType(type) {
   const mapping = {
@@ -15,7 +19,10 @@ function parseTransactionType(type) {
     OfferCreate: 'order',
     OfferCancel: 'orderCancellation',
     AccountSet: 'settings',
-    SetRegularKey: 'settings'
+    SetRegularKey: 'settings',
+    SuspendedPaymentCreate: 'suspendedPaymentCreation',
+    SuspendedPaymentFinish: 'suspendedPaymentExecution',
+    SuspendedPaymentCancel: 'suspendedPaymentCancellation'
   };
   return mapping[type] || null;
 }
@@ -27,7 +34,10 @@ function parseTransaction(tx: Object): Object {
     'trustline': parseTrustline,
     'order': parseOrder,
     'orderCancellation': parseOrderCancellation,
-    'settings': parseSettings
+    'settings': parseSettings,
+    'suspendedPaymentCreation': parseSuspendedPaymentCreation,
+    'suspendedPaymentExecution': parseSuspendedPaymentExecution,
+    'suspendedPaymentCancellation': parseSuspendedPaymentCancellation
   };
   const parser = mapping[type];
   assert(parser !== undefined, 'Unrecognized transaction type');

src/api/ledger/parse/trustline.js

@@ -15,8 +15,11 @@ function parseFlag(flagsValue, trueValue, falseValue) {
   return undefined;
 }
 
-function parseQuality(quality) {
-  return (new BigNumber(quality)).shift(-9).toNumber();
+function parseQuality(quality?: number) {
+  if (typeof quality === 'number') {
+    return (new BigNumber(quality)).shift(-9).toNumber();
+  }
+  return undefined;
 }
 
 function parseTrustline(tx: Object): Object {

src/api/ledger/parse/utils.js

@@ -6,8 +6,9 @@ const toTimestamp = require('../../../core/utils').toTimestamp;
 const utils = require('../utils');
 const BigNumber = require('bignumber.js');
 
-function adjustQualityForXRP(quality: string, takerGetsCurrency: string,
-    takerPaysCurrency: string) {
+function adjustQualityForXRP(
+  quality: string, takerGetsCurrency: string, takerPaysCurrency: string
+) {
   // quality = takerPays.value/takerGets.value
   // using drops (1e-6 XRP) for XRP values
   const numeratorShift = (takerPaysCurrency === 'XRP' ? -6 : 0);
@@ -51,7 +52,7 @@ function parseOutcome(tx: Object): ?Object {
   }
 
   const balanceChanges = transactionParser.parseBalanceChanges(tx.meta);
-  const orderbookChanges = transactionParser.parseOrderBookChanges(tx.meta);
+  const orderbookChanges = transactionParser.parseOrderbookChanges(tx.meta);
   removeEmptyCounterpartyInBalanceChanges(balanceChanges);
   removeEmptyCounterpartyInOrderbookChanges(orderbookChanges);
 
@@ -66,8 +67,22 @@ function parseOutcome(tx: Object): ?Object {
   };
 }
 
+function parseMemos(tx: Object): ?Array<Object> {
+  if (!Array.isArray(tx.Memos) || tx.Memos.length === 0) {
+    return undefined;
+  }
+  return tx.Memos.map((m) => {
+    return removeUndefined({
+      type: m.Memo.parsed_memo_type,
+      format: m.Memo.parsed_memo_format,
+      data: m.Memo.parsed_memo_data
+    });
+  });
+}
+
 module.exports = {
   parseOutcome,
+  parseMemos,
   removeUndefined,
   adjustQualityForXRP,
   dropsToXrp: utils.common.dropsToXrp,

src/api/ledger/pathfind.js

@@ -8,6 +8,7 @@ const validate = utils.common.validate;
 const parsePathfind = require('./parse/pathfind');
 const NotFoundError = utils.common.errors.NotFoundError;
 const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
 
 type PathFindParams = {
   src_currencies?: Array<string>, src_account: string, dst_amount: string,
@@ -46,8 +47,8 @@ function requestPathFind(remote, pathfind: PathFind, callback) {
       _.omit(utils.common.toRippledAmount(amount), 'value'));
   }
 
-  remote.requestRipplePathFind(params,
-    composeAsync(_.partial(addParams, params), callback));
+  remote.createPathFind(params,
+    composeAsync(_.partial(addParams, params), convertErrors(callback)));
 }
 
 function addDirectXrpPath(paths, xrpBalance) {
@@ -78,19 +79,13 @@ function conditionallyAddDirectXRPPath(remote, address, paths, callback) {
   }
 }
 
-function addDestinationCounterparty(amount, address) {
-  return amount.currency === 'XRP' || amount.counterparty ? amount :
-    _.assign({counterparty: address}, amount);
-}
-
 function formatResponse(pathfind, paths) {
   if (paths.alternatives && paths.alternatives.length > 0) {
     const address = pathfind.source.address;
-    const destinationAmount = addDestinationCounterparty(
-      pathfind.destination.amount, pathfind.destination.address);
-    return parsePathfind(address, destinationAmount, paths);
+    return parsePathfind(address, pathfind.destination.amount, paths);
   }
-  if (!_.includes(paths.destination_currencies,
+  if (paths.destination_currencies !== undefined &&
+      !_.includes(paths.destination_currencies,
       pathfind.destination.amount.currency)) {
     throw new NotFoundError('No paths found. ' +
       'The destination_account does not accept ' +
@@ -110,7 +105,7 @@ function formatResponse(pathfind, paths) {
   }
 }
 
-function getPaths(pathfind, callback) {
+function getPathsAsync(pathfind, callback) {
   validate.pathfind(pathfind);
 
   const address = pathfind.source.address;
@@ -120,4 +115,8 @@ function getPaths(pathfind, callback) {
   ], composeAsync(_.partial(formatResponse, pathfind), callback));
 }
 
-module.exports = utils.wrapCatch(getPaths);
+function getPaths(pathfind: Object) {
+  return utils.promisify(getPathsAsync).call(this, pathfind);
+}
+
+module.exports = getPaths;

src/api/ledger/settings.js

@@ -6,6 +6,7 @@ const validate = utils.common.validate;
 const parseFields = require('./parse/fields');
 const composeAsync = utils.common.composeAsync;
 const AccountFlags = utils.common.constants.AccountFlags;
+const convertErrors = utils.common.convertErrors;
 
 function parseFlags(value) {
   const settings = {};
@@ -24,17 +25,21 @@ function formatSettings(response) {
   return _.assign({}, parsedFlags, parsedFields);
 }
 
-function getSettings(account, options, callback) {
+function getSettingsAsync(account, options, callback) {
   validate.address(account);
   validate.getSettingsOptions(options);
 
   const request = {
     account: account,
-    ledger: options.ledgerVersion
+    ledger: options.ledgerVersion || 'validated'
   };
 
   this.remote.requestAccountInfo(request,
-    composeAsync(formatSettings, callback));
+    composeAsync(formatSettings, convertErrors(callback)));
 }
 
-module.exports = utils.wrapCatch(getSettings);
+function getSettings(account: string, options = {}) {
+  return utils.promisify(getSettingsAsync).call(this, account, options);
+}
+
+module.exports = getSettings;

src/api/ledger/transaction-types.js

@@ -0,0 +1,147 @@
+/* @flow */
+'use strict';
+
+type Outcome = {
+  result: string,
+  timestamp?: string,
+  fee: string,
+  balanceChanges: Object,
+  orderbookChanges: Object,
+  ledgerVersion: number,
+  indexInLedger: number
+}
+
+type Adjustment = {
+  address: string,
+  amount: {
+   currency: string,
+   counterparty?: string,
+   value: string
+ },
+  tag?: number
+}
+
+type Trustline = {
+  currency: string,
+  counterparty: string,
+  limit: string,
+  qualityIn?: number,
+  qualityOut?: number,
+  ripplingDisabled?: boolean,
+  authorized?: boolean,
+  frozen?: boolean
+}
+
+type Settings = {
+  passwordSpent?: boolean,
+  requireDestinationTag?: boolean,
+  requireAuthorization?: boolean,
+  disallowIncomingXRP?: boolean,
+  disableMasterKey?: boolean,
+  enableTransactionIDTracking?: boolean,
+  noFreeze?: boolean,
+  globalFreeze?: boolean,
+  defaultRipple?: boolean,
+  emailHash?: string,
+  walletLocator?: string,
+  walletSize?: number,
+  messageKey?: string,
+  domain?: string,
+  transferRate?: number,
+  signers?: string,
+  regularKey?: string
+}
+
+type OrderCancellation = {
+  orderSequence: number
+}
+
+type Memo = {
+  type?: string,
+  format?: string,
+  data?: string
+}
+
+type Amount = {
+  value: string,
+  currency: string,
+  counterparty?: string
+}
+
+type Payment = {
+  source: Adjustment,
+  destination: Adjustment,
+  paths?: string,
+  memos?: Array<Memo>,
+  invoiceID?: string,
+  allowPartialPayment?: boolean,
+  noDirectRipple?: boolean,
+  limitQuality?: boolean
+}
+
+type PaymentTransaction = {
+  type: string,
+  specification: Payment,
+  outcome: Outcome,
+  id: string,
+  address: string,
+  sequence: number
+}
+
+type Order = {
+  direction: string,
+  quantity: Amount,
+  totalPrice: Amount,
+  immediateOrCancel?: boolean,
+  fillOrKill?: boolean,
+  passive?: boolean
+}
+
+type OrderTransaction = {
+  type: string,
+  specification: Order,
+  outcome: Outcome,
+  id: string,
+  address: string,
+  sequence: number
+}
+
+type OrderCancellationTransaction = {
+  type: string,
+  specification: OrderCancellation,
+  outcome: Outcome,
+  id: string,
+  address: string,
+  sequence: number
+}
+
+type TrustlineTransaction = {
+  type: string,
+  specification: Trustline,
+  outcome: Outcome,
+  id: string,
+  address: string,
+  sequence: number
+}
+
+type SettingsTransaction = {
+  type: string,
+  specification: Settings,
+  outcome: Outcome,
+  id: string,
+  address: string,
+  sequence: number
+}
+
+export type TransactionOptions = {
+  minLedgerVersion?: number,
+  maxLedgerVersion?: number
+}
+
+export type GetTransactionResponse = PaymentTransaction | OrderTransaction |
+  OrderCancellationTransaction | TrustlineTransaction | SettingsTransaction
+
+export type GetTransactionResponseCallback =
+  (err?: ?Error, data?: GetTransactionResponse) => void
+
+export type CallbackType = (err?: ?Error, data?: Object) => void

src/api/ledger/transaction.js

@@ -6,9 +6,18 @@ const utils = require('./utils');
 const parseTransaction = require('./parse/transaction');
 const validate = utils.common.validate;
 const errors = utils.common.errors;
+const convertErrors = utils.common.convertErrors;
 const RippleError = require('../../core/rippleerror').RippleError;
 
-function attachTransactionDate(remote, tx, callback) {
+import type {Remote} from '../../core/remote';
+
+import type {CallbackType, GetTransactionResponse,
+  GetTransactionResponseCallback, TransactionOptions}
+  from './transaction-types';
+
+function attachTransactionDate(remote: Remote, tx: Object,
+                              callback: CallbackType
+) {
   if (tx.date) {
     callback(null, tx);
     return;
@@ -29,46 +38,68 @@ function attachTransactionDate(remote, tx, callback) {
   });
 }
 
-function isTransactionInRange(tx, options) {
+function isTransactionInRange(tx: Object, options: TransactionOptions) {
   return (!options.minLedgerVersion
           || tx.ledger_index >= options.minLedgerVersion)
       && (!options.maxLedgerVersion
           || tx.ledger_index <= options.maxLedgerVersion);
 }
 
-function getTransaction(identifier, options, callback) {
+function getTransactionAsync(identifier: string, options: TransactionOptions,
+                             callback: GetTransactionResponseCallback
+) {
   validate.identifier(identifier);
   validate.getTransactionOptions(options);
 
   const remote = this.remote;
-  const maxLedgerVersion = Math.min(options.maxLedgerVersion,
-    remote.getLedgerSequence());
+  const maxLedgerVersion =
+    options.maxLedgerVersion || remote.getLedgerSequence();
 
-  function callbackWrapper(error_, tx) {
+  function callbackWrapper(error_?: Error, tx?: Object) {
     let error = error_;
+
+    if (!error && tx && tx.validated !== true) {
+      return callback(new errors.NotFoundError('Transaction not found'));
+    }
+
     if (error instanceof RippleError && error.remote &&
       error.remote.error === 'txnNotFound') {
       error = new errors.NotFoundError('Transaction not found');
     }
 
+    // Missing complete ledger range
     if (error instanceof errors.NotFoundError
-        && !utils.hasCompleteLedgerRange(remote,
-            options.minLedgerVersion, maxLedgerVersion)) {
-      callback(new errors.MissingLedgerHistoryError('Transaction not found,'
-        + ' but the server\'s ledger history is incomplete'));
-    } else if (!error && !isTransactionInRange(tx, options)) {
+        && !utils.hasCompleteLedgerRange(remote, options.minLedgerVersion,
+                                         maxLedgerVersion)) {
+      if (utils.isPendingLedgerVersion(remote, maxLedgerVersion)) {
+        callback(new errors.PendingLedgerVersionError());
+      } else {
+        callback(new errors.MissingLedgerHistoryError());
+      }
+      // Transaction is found, but not in specified range
+    } else if (!error && tx && !isTransactionInRange(tx, options)) {
       callback(new errors.NotFoundError('Transaction not found'));
+      // Transaction is not found
     } else if (error) {
-      callback(error);
+      convertErrors(callback)(error);
+    } else if (!tx) {
+      callback(new errors.ApiError('Internal error'));
     } else {
       callback(error, parseTransaction(tx));
     }
   }
 
   async.waterfall([
-    _.partial(remote.requestTx.bind(remote), {hash: identifier, binary: false}),
+    _.partial(remote.requestTx.bind(remote),
+      {hash: identifier, binary: false}),
     _.partial(attachTransactionDate, remote)
   ], callbackWrapper);
 }
 
-module.exports = utils.wrapCatch(getTransaction);
+function getTransaction(identifier: string,
+                        options: TransactionOptions = {}
+): Promise<GetTransactionResponse> {
+  return utils.promisify(getTransactionAsync).call(this, identifier, options);
+}
+
+module.exports = getTransaction;

src/api/ledger/transactions.js

@@ -7,6 +7,7 @@ const parseTransaction = require('./parse/transaction');
 const getTransaction = require('./transaction');
 const validate = utils.common.validate;
 const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
 
 function parseAccountTxTransaction(tx) {
   // rippled uses a different response format for 'account_tx' than 'tx'
@@ -15,6 +16,21 @@ function parseAccountTxTransaction(tx) {
   return parseTransaction(tx.tx);
 }
 
+function counterpartyFilter(filters, tx) {
+  if (!filters.counterparty) {
+    return true;
+  }
+  if (tx.address === filters.counterparty || (
+    tx.specification && (
+      (tx.specification.destination &&
+        tx.specification.destination.address === filters.counterparty) ||
+      (tx.specification.counterparty === filters.counterparty)
+    ))) {
+    return true;
+  }
+  return false;
+}
+
 function transactionFilter(address, filters, tx) {
   if (filters.excludeFailures && tx.outcome.result !== 'tesSUCCESS') {
     return false;
@@ -28,8 +44,7 @@ function transactionFilter(address, filters, tx) {
   if (filters.initiated === false && tx.address === address) {
     return false;
   }
-  if (filters.counterparty && tx.address !== filters.counterparty
-      && tx.specification.destination.address !== filters.counterparty) {
+  if (filters.counterparty && !counterpartyFilter(filters, tx)) {
     return false;
   }
   return true;
@@ -41,27 +56,31 @@ function orderFilter(options, tx) {
     utils.compareTransactions(tx, options.startTx) < 0);
 }
 
+function formatPartialResponse(address, options, data) {
+  return {
+    marker: data.marker,
+    results: data.transactions
+      .filter((tx) => tx.validated)
+      .map(parseAccountTxTransaction)
+      .filter(_.partial(transactionFilter, address, options))
+      .filter(_.partial(orderFilter, options))
+  };
+}
+
 function getAccountTx(remote, address, options, marker, limit, callback) {
   const params = {
     account: address,
     ledger_index_min: options.minLedgerVersion || -1,
-    ledger_index_max: options.maxLedgerVersion || -1,
+    ledger_index_max: options.maxLedgerVersion || remote.getLedgerSequence(),
     forward: options.earliestFirst,
     binary: options.binary,
     limit: utils.clamp(limit, 10, 400),
     marker: marker
   };
 
-  remote.requestAccountTx(params, (error, data) => {
-    return error ? callback(error) : callback(null, {
-      marker: data.marker,
-      results: data.transactions
-        .filter((tx) => tx.validated)
-        .map(parseAccountTxTransaction)
-        .filter(_.partial(transactionFilter, address, options))
-        .filter(_.partial(orderFilter, options))
-    });
-  });
+  remote.requestAccountTx(params,
+    composeAsync(_.partial(formatPartialResponse, address, options),
+      convertErrors(callback)));
 }
 
 function checkForLedgerGaps(remote, options, transactions) {
@@ -98,27 +117,27 @@ function getTransactionsInternal(remote, address, options, callback) {
   utils.getRecursive(getter, options.limit, composeAsync(format, callback));
 }
 
-function getTransactions(account, options, callback) {
+function getTransactionsAsync(account, options, callback) {
   validate.address(account);
   validate.getTransactionsOptions(options);
 
   const defaults = {maxLedgerVersion: this.remote.getLedgerSequence()};
   if (options.start) {
-    getTransaction.bind(this)(options.start, {}, (error, tx) => {
-      if (error) {
-        callback(error);
-        return;
-      }
+    getTransaction.call(this, options.start).then(tx => {
       const ledgerVersion = tx.outcome.ledgerVersion;
       const bound = options.earliestFirst ?
         {minLedgerVersion: ledgerVersion} : {maxLedgerVersion: ledgerVersion};
       const newOptions = _.assign(defaults, options, {startTx: tx}, bound);
       getTransactionsInternal(this.remote, account, newOptions, callback);
-    });
+    }).catch(callback);
   } else {
     const newOptions = _.assign(defaults, options);
     getTransactionsInternal(this.remote, account, newOptions, callback);
   }
 }
 
-module.exports = utils.wrapCatch(getTransactions);
+function getTransactions(account: string, options = {}) {
+  return utils.promisify(getTransactionsAsync).call(this, account, options);
+}
+
+module.exports = getTransactions;

src/api/ledger/trustlines.js

@@ -3,14 +3,25 @@
 const _ = require('lodash');
 const utils = require('./utils');
 const validate = utils.common.validate;
+const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
 const parseAccountTrustline = require('./parse/account-trustline');
 
 function currencyFilter(currency, trustline) {
   return currency === null || trustline.specification.currency === currency;
 }
 
+function formatResponse(options, data) {
+  return {
+    marker: data.marker,
+    results: data.lines.map(parseAccountTrustline)
+      .filter(_.partial(currencyFilter, options.currency || null))
+  };
+}
+
 function getAccountLines(remote, address, ledgerVersion, options, marker, limit,
-    callback) {
+    callback
+) {
   const requestOptions = {
     account: address,
     ledger: ledgerVersion,
@@ -19,19 +30,15 @@ function getAccountLines(remote, address, ledgerVersion, options, marker, limit,
     peer: options.counterparty
   };
 
-  remote.requestAccountLines(requestOptions, (error, data) => {
-    return error ? callback(error) :
-      callback(null, {
-        marker: data.marker,
-        results: data.lines.map(parseAccountTrustline)
-          .filter(_.partial(currencyFilter, options.currency || null))
-      });
-  });
+  remote.requestAccountLines(requestOptions,
+    composeAsync(_.partial(formatResponse, options),
+      convertErrors(callback)));
 }
 
-function getTrustlines(account: string, options: {currency: string,
+function getTrustlinesAsync(account: string, options: {currency: string,
     counterparty: string, limit: number, ledgerVersion: number},
-    callback: () => void): void {
+    callback: () => void
+): void {
   validate.address(account);
   validate.getTrustlinesOptions(options);
 
@@ -42,4 +49,8 @@ function getTrustlines(account: string, options: {currency: string,
   utils.getRecursive(getter, options.limit, callback);
 }
 
-module.exports = utils.wrapCatch(getTrustlines);
+function getTrustlines(account: string, options = {}) {
+  return utils.promisify(getTrustlinesAsync).call(this, account, options);
+}
+
+module.exports = getTrustlines;

src/api/ledger/utils.js

@@ -5,6 +5,7 @@ const assert = require('assert');
 const common = require('../common');
 const dropsToXrp = common.dropsToXrp;
 const composeAsync = common.composeAsync;
+import type {Remote} from '../../core/remote';
 
 type Callback = (err: any, data: any) => void
 
@@ -13,7 +14,9 @@ function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
 }
 
-function getXRPBalance(remote: any, address: string, ledgerVersion?: number, callback: Callback): void {
+function getXRPBalance(remote: Remote, address: string, ledgerVersion?: number,
+                       callback: Callback
+): void {
   remote.requestAccountInfo({account: address, ledger: ledgerVersion},
     composeAsync((data) => dropsToXrp(data.account_data.Balance), callback));
 }
@@ -22,7 +25,9 @@ type Getter = (marker: ?string, limit: number, callback: Callback) => void
 
 // If the marker is omitted from a response, you have reached the end
 // getter(marker, limit, callback), callback(error, {marker, results})
-function getRecursiveRecur(getter: Getter, marker?: string, limit: number, callback: Callback): void {
+function getRecursiveRecur(getter: Getter, marker?: string, limit: number,
+                          callback: Callback
+): void {
   getter(marker, limit, (error, data) => {
     if (error) {
       return callback(error);
@@ -79,25 +84,34 @@ function signum(num) {
  *  @returns {Number} [-1, 0, 1]
  */
 
-type Outcome = {outcome: {ledgerVersion: string, indexInLedger: string}};
+type Outcome = {outcome: {ledgerVersion: number, indexInLedger: number}};
 
 function compareTransactions(first: Outcome, second: Outcome): number {
-  if (first.outcome.ledgerVersion === second.outcome.ledgerVersion) {
-    return signum(Number(first.outcome.indexInLedger) -
-      Number(second.outcome.indexInLedger));
+  if (!first.outcome || !second.outcome) {
+    return 0;
   }
-  return Number(first.outcome.ledgerVersion) <
-    Number(second.outcome.ledgerVersion) ? -1 : 1;
+  if (first.outcome.ledgerVersion === second.outcome.ledgerVersion) {
+    return signum(first.outcome.indexInLedger - second.outcome.indexInLedger);
+  }
+  return first.outcome.ledgerVersion < second.outcome.ledgerVersion ? -1 : 1;
 }
 
-function hasCompleteLedgerRange(remote: any, minLedgerVersion: number,
-                                maxLedgerVersion: number): boolean {
+function hasCompleteLedgerRange(remote: Remote, minLedgerVersion?: number,
+                                maxLedgerVersion?: number
+): boolean {
+
   const firstLedgerVersion = 32570; // earlier versions have been lost
   return remote.getServer().hasLedgerRange(
     minLedgerVersion || firstLedgerVersion,
     maxLedgerVersion || remote.getLedgerSequence());
 }
 
+function isPendingLedgerVersion(remote: Remote, maxLedgerVersion: ?number
+): boolean {
+  const currentLedger = remote.getLedgerSequence();
+  return currentLedger < (maxLedgerVersion || 0);
+}
+
 module.exports = {
   getXRPBalance,
   compareTransactions,
@@ -105,7 +119,8 @@ module.exports = {
   renameCounterpartyToIssuerInOrder,
   getRecursive,
   hasCompleteLedgerRange,
-  wrapCatch: common.wrapCatch,
+  isPendingLedgerVersion,
+  promisify: common.promisify,
   clamp: clamp,
   common: common
 };

src/api/offline/ledgerhash.js

@@ -0,0 +1,74 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const common = require('../common');
+
+function convertLedgerHeader(header) {
+  return {
+    accepted: header.accepted,
+    closed: header.closed,
+    account_hash: header.stateHash,
+    close_time: header.closeTime,
+    close_time_resolution: header.closeTimeResolution,
+    close_flags: header.closeFlags,
+    hash: header.ledgerHash,
+    ledger_hash: header.ledgerHash,
+    ledger_index: header.ledgerVersion.toString(),
+    seqNum: header.ledgerVersion.toString(),
+    parent_hash: header.parentLedgerHash,
+    parent_close_time: header.parentCloseTime,
+    total_coins: header.totalDrops,
+    totalCoins: header.totalDrops,
+    transaction_hash: header.transactionHash
+  };
+}
+
+function hashLedgerHeader(ledgerHeader) {
+  const header = convertLedgerHeader(ledgerHeader);
+  return common.core.Ledger.calculateLedgerHash(header);
+}
+
+function computeTransactionHash(ledger) {
+  if (ledger.rawTransactions === undefined) {
+    return ledger.transactionHash;
+  }
+  const transactions = JSON.parse(ledger.rawTransactions);
+  const txs = _.map(transactions, tx => {
+    const mergeTx = _.assign({}, _.omit(tx, 'tx'), tx.tx || {});
+    const renameMeta = _.assign({}, _.omit(mergeTx, 'meta'),
+      tx.meta ? {metaData: tx.meta} : {});
+    return renameMeta;
+  });
+  const ledgerObject = common.core.Ledger.from_json({transactions: txs});
+  const transactionHash = ledgerObject.calc_tx_hash().to_hex();
+  if (ledger.transactionHash !== undefined
+      && ledger.transactionHash !== transactionHash) {
+    throw new common.errors.ValidationError('transactionHash in header'
+      + ' does not match computed hash of transactions');
+  }
+  return transactionHash;
+}
+
+function computeStateHash(ledger) {
+  if (ledger.rawState === undefined) {
+    return ledger.stateHash;
+  }
+  const state = JSON.parse(ledger.rawState);
+  const ledgerObject = common.core.Ledger.from_json({accountState: state});
+  const stateHash = ledgerObject.calc_account_hash().to_hex();
+  if (ledger.stateHash !== undefined && ledger.stateHash !== stateHash) {
+    throw new common.errors.ValidationError('stateHash in header'
+      + ' does not match computed hash of state');
+  }
+  return stateHash;
+}
+
+function computeLedgerHash(ledger: Object): string {
+  const hashes = {
+    transactionHash: computeTransactionHash(ledger),
+    stateHash: computeStateHash(ledger)
+  };
+  return hashLedgerHeader(_.assign({}, ledger, hashes));
+}
+
+module.exports = computeLedgerHash;

src/api/server/server.js

@@ -4,19 +4,41 @@
 
 const _ = require('lodash');
 const common = require('../common');
+import type {Remote} from '../../core/remote';
 
 // If a ledger is not received in this time, consider the connection offline
 const CONNECTION_TIMEOUT = 1000 * 30;
 
-function connect(callback: (err: any, data: any) => void): void {
-  this.remote.connect(callback);
+type GetServerInfoResponse = {
+  buildVersion: string,
+  completeLedgers: string,
+  hostid: string,
+  ioLatencyMs: number,
+  load?: {
+    jobTypes: Array<Object>,
+    threads: number
+  },
+  lastClose: {
+    convergeTimeS: number,
+    proposers: number
+  },
+  loadFactor: number,
+  peers: number,
+  pubkeyNode: string,
+  pubkeyValidator?: string,
+  serverState: string,
+  validatedLedger: {
+    age: number,
+    baseFeeXrp: number,
+    hash: string,
+    reserveBaseXrp: number,
+    reserveIncXrp: number,
+    seq: number
+  },
+  validationQuorum: number
 }
 
-function disconnect(callback: (err: any, data: any) => void): void {
-  this.remote.disconnect(callback);
-}
-
-function isUpToDate(remote): boolean {
+function isUpToDate(remote: Remote): boolean {
   const server = remote.getServer();
   return Boolean(server) && (remote._stand_alone
     || (Date.now() - server._lastLedgerClose) <= CONNECTION_TIMEOUT);
@@ -26,13 +48,17 @@ function isConnected(): boolean {
   return Boolean(this.remote._ledger_current_index) && isUpToDate(this.remote);
 }
 
-function getServerInfo(callback: (err: any, data: any) => void): void {
+function getServerInfoAsync(
+  callback: (err: any, data?: GetServerInfoResponse) => void
+): void {
   this.remote.requestServerInfo((error, response) => {
     if (error) {
-      const message = _.get(error, ['remote', 'error_message'], error.message);
+      const message =
+        _.get(error, ['remote', 'error_message'], error.message);
       callback(new common.errors.RippledNetworkError(message));
     } else {
-      callback(null, common.convertKeysFromSnakeCaseToCamelCase(response.info));
+      callback(null,
+        common.convertKeysFromSnakeCaseToCamelCase(response.info));
     }
   });
 }
@@ -45,11 +71,46 @@ function getLedgerVersion(): number {
   return this.remote.getLedgerSequence();
 }
 
+function connect(): Promise<void> {
+  return common.promisify(callback => {
+    this.remote.connect(() => callback(null));
+  })();
+}
+
+function disconnect(): Promise<void> {
+  return common.promisify(callback => {
+    this.remote.disconnect(() => callback(null));
+  })();
+}
+
+function getServerInfo(): Promise<GetServerInfoResponse> {
+  return common.promisify(getServerInfoAsync.bind(this))();
+}
+
+function rippleTimeToISO8601(rippleTime: string): string {
+  return new Date(common.core.utils.toTimestamp(rippleTime)).toISOString();
+}
+
+function formatLedgerClose(ledgerClose: Object): Object {
+  return {
+    feeBase: ledgerClose.fee_base,
+    feeReference: ledgerClose.fee_ref,
+    ledgerHash: ledgerClose.ledger_hash,
+    ledgerVersion: ledgerClose.ledger_index,
+    ledgerTimestamp: rippleTimeToISO8601(ledgerClose.ledger_time),
+    reserveBase: ledgerClose.reserve_base,
+    reserveIncrement: ledgerClose.reserve_inc,
+    transactionCount: ledgerClose.txn_count,
+    validatedLedgerVersions: ledgerClose.validated_ledgers
+  };
+}
+
 module.exports = {
   connect,
   disconnect,
   isConnected,
   getServerInfo,
   getFee,
-  getLedgerVersion
+  getLedgerVersion,
+  formatLedgerClose
 };

src/api/transaction/order.js

@@ -30,9 +30,14 @@ function createOrderTransaction(account, order) {
   return transaction;
 }
 
-function prepareOrder(account, order, instructions, callback) {
+function prepareOrderAsync(account, order, instructions, callback) {
   const transaction = createOrderTransaction(account, order);
-  utils.createTxJSON(transaction, this.remote, instructions, callback);
+  utils.prepareTransaction(transaction, this.remote, instructions, callback);
 }
 
-module.exports = utils.wrapCatch(prepareOrder);
+function prepareOrder(account: string, order: Object, instructions = {}) {
+  return utils.promisify(prepareOrderAsync.bind(this))(
+    account, order, instructions);
+}
+
+module.exports = prepareOrder;

src/api/transaction/ordercancellation.js

@@ -13,9 +13,18 @@ function createOrderCancellationTransaction(account, sequence) {
   return transaction;
 }
 
-function prepareOrderCancellation(account, sequence, instructions, callback) {
+function prepareOrderCancellationAsync(account, sequence, instructions,
+  callback
+) {
   const transaction = createOrderCancellationTransaction(account, sequence);
-  utils.createTxJSON(transaction, this.remote, instructions, callback);
+  utils.prepareTransaction(transaction, this.remote, instructions, callback);
 }
 
-module.exports = utils.wrapCatch(prepareOrderCancellation);
+function prepareOrderCancellation(account: string, sequence: number,
+    instructions = {}
+) {
+  return utils.promisify(prepareOrderCancellationAsync.bind(this))(
+    account, sequence, instructions);
+}
+
+module.exports = prepareOrderCancellation;

src/api/transaction/payment.js

@@ -1,21 +1,15 @@
 /* @flow */
 'use strict';
 const _ = require('lodash');
-const BigNumber = require('bignumber.js');
 const utils = require('./utils');
 const validate = utils.common.validate;
 const toRippledAmount = utils.common.toRippledAmount;
 const Transaction = utils.common.core.Transaction;
 
-function isSendMaxAllowed(payment) {
-  const srcAmt = payment.source.amount;
-  const dstAmt = payment.destination.amount;
-
-  // Don't set SendMax for XRP->XRP payment
-  // temREDUNDANT_SEND_MAX removed in:
-  // https://github.com/ripple/rippled/commit/
-  //  c522ffa6db2648f1d8a987843e7feabf1a0b7de8/
-  return srcAmt && !(srcAmt.currency === 'XRP' && dstAmt.currency === 'XRP');
+function isXRPToXRPPayment(payment) {
+  const sourceCurrency = _.get(payment, 'source.maxAmount.currency');
+  const destinationCurrency = _.get(payment, 'destination.amount.currency');
+  return sourceCurrency === 'XRP' && destinationCurrency === 'XRP';
 }
 
 function isIOUWithoutCounterparty(amount) {
@@ -29,8 +23,8 @@ function applyAnyCounterpartyEncoding(payment) {
   // https://ripple.com/build/transactions/
   //    #special-issuer-values-for-sendmax-and-amount
   // https://ripple.com/build/ripple-rest/#counterparties-in-payments
-  if (isIOUWithoutCounterparty(payment.source.amount)) {
-    payment.source.amount.counterparty = payment.source.address;
+  if (isIOUWithoutCounterparty(payment.source.maxAmount)) {
+    payment.source.maxAmount.counterparty = payment.source.address;
   }
   if (isIOUWithoutCounterparty(payment.destination.amount)) {
     payment.destination.amount.counterparty = payment.destination.address;
@@ -58,9 +52,6 @@ function createPaymentTransaction(account, payment) {
   if (payment.destination.tag) {
     transaction.destinationTag(payment.destination.tag);
   }
-  if (payment.paths) {
-    transaction.paths(JSON.parse(payment.paths));
-  }
   if (payment.memos) {
     _.forEach(payment.memos, memo =>
       transaction.addMemo(memo.type, memo.format, memo.data)
@@ -75,19 +66,29 @@ function createPaymentTransaction(account, payment) {
   if (payment.limitQuality) {
     transaction.setFlags(['LimitQuality']);
   }
-  if (isSendMaxAllowed(payment)) {
-    const maxValue = new BigNumber(payment.source.amount.value)
-      .plus(payment.source.slippage || 0).toString();
-    const maxAmount = _.assign({}, payment.source.amount, {value: maxValue});
-    transaction.sendMax(toRippledAmount(maxAmount));
+  if (!isXRPToXRPPayment(payment)) {
+    // Don't set SendMax for XRP->XRP payment
+    // temREDUNDANT_SEND_MAX removed in:
+    // https://github.com/ripple/rippled/commit/
+    //  c522ffa6db2648f1d8a987843e7feabf1a0b7de8/
+    transaction.sendMax(toRippledAmount(payment.source.maxAmount));
+
+    if (payment.paths) {
+      transaction.paths(JSON.parse(payment.paths));
+    }
   }
 
   return transaction;
 }
 
-function preparePayment(account, payment, instructions, callback) {
+function preparePaymentAsync(account, payment, instructions, callback) {
   const transaction = createPaymentTransaction(account, payment);
-  utils.createTxJSON(transaction, this.remote, instructions, callback);
+  utils.prepareTransaction(transaction, this.remote, instructions, callback);
 }
 
-module.exports = utils.wrapCatch(preparePayment);
+function preparePayment(account: string, payment: Object, instructions = {}) {
+  return utils.promisify(preparePaymentAsync.bind(this))(
+    account, payment, instructions);
+}
+
+module.exports = preparePayment;

src/api/transaction/settings.js

@@ -90,9 +90,14 @@ function createSettingsTransaction(account, settings) {
   return transaction;
 }
 
-function prepareSettings(account, settings, instructions, callback) {
+function prepareSettingsAsync(account, settings, instructions, callback) {
   const transaction = createSettingsTransaction(account, settings);
-  utils.createTxJSON(transaction, this.remote, instructions, callback);
+  utils.prepareTransaction(transaction, this.remote, instructions, callback);
 }
 
-module.exports = utils.wrapCatch(prepareSettings);
+function prepareSettings(account: string, settings: Object, instructions = {}) {
+  return utils.promisify(prepareSettingsAsync.bind(this))(
+    account, settings, instructions);
+}
+
+module.exports = prepareSettings;

src/api/transaction/sign.js

@@ -15,15 +15,13 @@ const validate = utils.common.validate;
  * some arbitrary string. For example "TXN".
  */
 const HASH_TX_ID = 0x54584E00; // 'TXN'
-const HASH_TX_SIGN = 0x53545800; // 'STX'
-const HASH_TX_SIGN_TESTNET = 0x73747800; // 'stx'
 
 function getKeyPair(secret) {
   return core.Seed.from_json(secret).get_key();
 }
 
 function getPublicKeyHex(keypair) {
-  return keypair.to_hex_pub();
+  return keypair.pubKeyHex();
 }
 
 function serialize(txJSON) {
@@ -34,31 +32,26 @@ function hashSerialization(serialized, prefix) {
   return serialized.hash(prefix || HASH_TX_ID).to_hex();
 }
 
-function hashJSON(txJSON, prefix) {
-  return hashSerialization(serialize(txJSON), prefix);
-}
-
-function signingHash(txJSON, isTestNet=false) {
-  return hashJSON(txJSON, isTestNet ? HASH_TX_SIGN_TESTNET : HASH_TX_SIGN);
+function signingData(txJSON) {
+  return core.Transaction.from_json(txJSON).signingData().buffer;
 }
 
 function computeSignature(txJSON, keypair) {
-  const signature = keypair.sign(signingHash(txJSON));
-  return core.sjcl.codec.hex.fromBits(signature).toUpperCase();
+  return keypair.signHex(signingData(txJSON));
 }
 
-function sign(txJSON: {Account: string; SigningPubKey: string,
-    TxnSignature: string}, secret: string):
-    {signedTransaction: string; id: string} {
-  validate.txJSON(txJSON);
+function sign(txJSON: string, secret: string
+): {signedTransaction: string; id: string} {
+  const tx = JSON.parse(txJSON);
+  validate.txJSON(tx);
   validate.secret(secret);
 
   const keypair = getKeyPair(secret);
-  if (txJSON.SigningPubKey === undefined) {
-    txJSON.SigningPubKey = getPublicKeyHex(keypair);
+  if (tx.SigningPubKey === undefined) {
+    tx.SigningPubKey = getPublicKeyHex(keypair);
   }
-  txJSON.TxnSignature = computeSignature(txJSON, keypair);
-  const serialized = serialize(txJSON);
+  tx.TxnSignature = computeSignature(tx, keypair);
+  const serialized = serialize(tx);
   return {
     signedTransaction: serialized.to_hex(),
     id: hashSerialization(serialized, HASH_TX_ID)

src/api/transaction/submit.js

@@ -1,17 +1,44 @@
 /* @flow */
 'use strict';
+const _ = require('lodash');
 const utils = require('./utils');
 const validate = utils.common.validate;
 const Request = utils.common.core.Request;
+const convertErrors = utils.common.convertErrors;
 
-function submit(txBlob: string, callback: (err: any, data: any) => void): void {
+function isImmediateRejection(engineResult) {
+  // note: "tel" errors mean the local server refused to process the
+  // transaction *at that time*, but it could potentially buffer the
+  // transaction and then process it at a later time, for example
+  // if the required fee changes (this does not occur at the time of
+  // this writing, but it could change in the future)
+  // all other error classes can potentially result in transcation validation
+  return _.startsWith(engineResult, 'tem') || _.startsWith(engineResult, 'tej');
+}
+
+function convertSubmitErrors(callback) {
+  return function(error, data) {
+    if (isImmediateRejection(data.engineResult)) {
+      callback(new utils.common.errors.RippleError('Submit failed'), data);
+    } else {
+      callback(error, data);
+    }
+  };
+}
+
+function submitAsync(txBlob: string, callback: (err: any, data: any) => void
+): void {
   validate.blob(txBlob);
   const request = new Request(this.remote, 'submit');
   request.message.tx_blob = txBlob;
   request.request(null,
     utils.common.composeAsync(
       data => utils.common.convertKeysFromSnakeCaseToCamelCase(data),
-      callback));
+      convertSubmitErrors(convertErrors(callback))));
+}
+
+function submit(txBlob: string) {
+  return utils.promisify(submitAsync.bind(this))(txBlob);
 }
 
 module.exports = submit;

src/api/transaction/suspended-payment-cancellation.js

@@ -0,0 +1,40 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const utils = require('./utils');
+const validate = utils.common.validate;
+const Transaction = utils.common.core.Transaction;
+
+function createSuspendedPaymentCancellationTransaction(account, payment) {
+  validate.address(account);
+  validate.suspendedPaymentCancellation(payment);
+
+  const transaction = new Transaction();
+  transaction.suspendedPaymentCancel({
+    account: account,
+    owner: payment.owner,
+    paymentSequence: payment.paymentSequence
+  });
+
+  if (payment.memos) {
+    _.forEach(payment.memos, memo =>
+      transaction.addMemo(memo.type, memo.format, memo.data)
+    );
+  }
+  return transaction;
+}
+
+function prepareSuspendedPaymentCancellationAsync(account, payment,
+instructions, callback) {
+  const transaction =
+    createSuspendedPaymentCancellationTransaction(account, payment);
+  utils.prepareTransaction(transaction, this.remote, instructions, callback);
+}
+
+function prepareSuspendedPaymentCancellation(account: string, payment: Object,
+instructions = {}) {
+  return utils.promisify(prepareSuspendedPaymentCancellationAsync)
+    .call(this, account, payment, instructions);
+}
+
+module.exports = prepareSuspendedPaymentCancellation;

src/api/transaction/suspended-payment-creation.js

@@ -0,0 +1,57 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const utils = require('./utils');
+const validate = utils.common.validate;
+const toRippledAmount = utils.common.toRippledAmount;
+const Transaction = utils.common.core.Transaction;
+
+function createSuspendedPaymentCreationTransaction(account, payment) {
+  validate.address(account);
+  validate.suspendedPaymentCreation(payment);
+
+  const transaction = new Transaction();
+  transaction.suspendedPaymentCreate({
+    account: account,
+    destination: payment.destination.address,
+    amount: toRippledAmount(payment.destination.amount)
+  });
+
+  if (payment.digest) {
+    transaction.setDigest(payment.digest);
+  }
+  if (payment.allowCancelAfter) {
+    transaction.setAllowCancelAfter(payment.allowCancelAfter);
+  }
+  if (payment.allowExecuteAfter) {
+    transaction.setAllowExecuteAfter(payment.allowExecuteAfter);
+  }
+
+  if (payment.source.tag) {
+    transaction.sourceTag(payment.source.tag);
+  }
+  if (payment.destination.tag) {
+    transaction.destinationTag(payment.destination.tag);
+  }
+  if (payment.memos) {
+    _.forEach(payment.memos, memo =>
+      transaction.addMemo(memo.type, memo.format, memo.data)
+    );
+  }
+  return transaction;
+}
+
+function prepareSuspendedPaymentCreationAsync(account, payment, instructions,
+callback) {
+  const transaction =
+    createSuspendedPaymentCreationTransaction(account, payment);
+  utils.prepareTransaction(transaction, this.remote, instructions, callback);
+}
+
+function prepareSuspendedPaymentCreation(account: string, payment: Object,
+instructions = {}) {
+  return utils.promisify(prepareSuspendedPaymentCreationAsync)
+    .call(this, account, payment, instructions);
+}
+
+module.exports = prepareSuspendedPaymentCreation;

src/api/transaction/suspended-payment-execution.js

@@ -0,0 +1,50 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const utils = require('./utils');
+const validate = utils.common.validate;
+const Transaction = utils.common.core.Transaction;
+
+function createSuspendedPaymentExecutionTransaction(account, payment) {
+  validate.address(account);
+  validate.suspendedPaymentExecution(payment);
+
+  const transaction = new Transaction();
+  transaction.suspendedPaymentFinish({
+    account: account,
+    owner: payment.owner,
+    paymentSequence: payment.paymentSequence
+  });
+
+  if (payment.method) {
+    transaction.setMethod(payment.method);
+  }
+  if (payment.digest) {
+    transaction.setDigest(payment.digest);
+  }
+  if (payment.proof) {
+    transaction.setProof(payment.proof);
+  }
+
+  if (payment.memos) {
+    _.forEach(payment.memos, memo =>
+      transaction.addMemo(memo.type, memo.format, memo.data)
+    );
+  }
+  return transaction;
+}
+
+function prepareSuspendedPaymentExecutionAsync(account, payment, instructions,
+callback) {
+  const transaction =
+    createSuspendedPaymentExecutionTransaction(account, payment);
+  utils.prepareTransaction(transaction, this.remote, instructions, callback);
+}
+
+function prepareSuspendedPaymentExecution(account: string, payment: Object,
+instructions = {}) {
+  return utils.promisify(prepareSuspendedPaymentExecutionAsync)
+    .call(this, account, payment, instructions);
+}
+
+module.exports = prepareSuspendedPaymentExecution;

src/api/transaction/trustline.js

@@ -12,7 +12,8 @@ const TrustSetFlags = {
 };
 
 function convertQuality(quality) {
-  return (new BigNumber(quality)).shift(9).truncated().toNumber();
+  return quality === undefined ? undefined :
+    (new BigNumber(quality)).shift(9).truncated().toNumber();
 }
 
 function createTrustlineTransaction(account, trustline) {
@@ -32,9 +33,15 @@ function createTrustlineTransaction(account, trustline) {
   return transaction;
 }
 
-function prepareTrustline(account, trustline, instructions, callback) {
+function prepareTrustlineAsync(account, trustline, instructions, callback) {
   const transaction = createTrustlineTransaction(account, trustline);
-  utils.createTxJSON(transaction, this.remote, instructions, callback);
+  utils.prepareTransaction(transaction, this.remote, instructions, callback);
 }
 
-module.exports = utils.wrapCatch(prepareTrustline);
+function prepareTrustline(account: string, trustline: Object, instructions = {}
+) {
+  return utils.promisify(prepareTrustlineAsync.bind(this))(
+    account, trustline, instructions);
+}
+
+module.exports = prepareTrustline;

src/api/transaction/utils.js

@@ -1,10 +1,11 @@
 /* @flow */
 'use strict';
+const _ = require('lodash');
 const BigNumber = require('bignumber.js');
 const common = require('../common');
 
-function setTransactionBitFlags(transaction: any, values: any, flags: any):
-    void {
+function setTransactionBitFlags(transaction: any, values: any, flags: any
+): void {
   for (const flagName in flags) {
     const flagValue = values[flagName];
     const flagConversions = flags[flagName];
@@ -23,8 +24,22 @@ function getFeeDrops(remote) {
   return remote.feeTx(feeUnits).to_text();
 }
 
-function createTxJSON(transaction: any, remote: any, instructions: any,
-    callback: (err: ?(typeof Error), data: {tx_json: any}) => void): void {
+function formatPrepareResponse(txJSON) {
+  const instructions = {
+    fee: txJSON.Fee,
+    sequence: txJSON.Sequence,
+    maxLedgerVersion: txJSON.LastLedgerSequence
+  };
+  return {
+    txJSON: JSON.stringify(txJSON),
+    instructions: _.omit(instructions, _.isUndefined)
+  };
+}
+
+type Callback = (err: ?(typeof Error),
+                 data: {txJSON: string, instructions: any}) => void;
+function prepareTransaction(transaction: any, remote: any, instructions: any,
+    callback: Callback): void {
   common.validate.instructions(instructions);
 
   transaction.complete();
@@ -53,18 +68,18 @@ function createTxJSON(transaction: any, remote: any, instructions: any,
 
   if (instructions.sequence !== undefined) {
     txJSON.Sequence = parseInt(instructions.sequence, 10);
-    callback(null, txJSON);
+    callback(null, formatPrepareResponse(txJSON));
   } else {
     remote.findAccount(account).getNextSequence(function(error, sequence) {
       txJSON.Sequence = sequence;
-      callback(null, txJSON);
+      callback(error, formatPrepareResponse(txJSON));
     });
   }
 }
 
 module.exports = {
-  setTransactionBitFlags: setTransactionBitFlags,
-  createTxJSON: createTxJSON,
-  wrapCatch: common.wrapCatch,
-  common: common
+  setTransactionBitFlags,
+  prepareTransaction,
+  common,
+  promisify: common.promisify
 };

src/core/account.js

@@ -12,13 +12,14 @@
 
 const _ = require('lodash');
 const async = require('async');
-const util = require('util');
 const extend = require('extend');
-const EventEmitter = require('events').EventEmitter;
-const UInt160 = require('./uint160').UInt160;
-const TransactionManager = require('./transactionmanager').TransactionManager;
-const sjcl = require('./utils').sjcl;
-const Base = require('./base').Base;
+const util = require('util');
+const {createAccountID} = require('ripple-keypairs');
+const {encodeAccountID} = require('ripple-address-codec');
+const {EventEmitter} = require('events');
+const {hexToArray} = require('./utils');
+const {TransactionManager} = require('./transactionmanager');
+const {UInt160} = require('./uint160');
 
 /**
  * @constructor Account
@@ -41,7 +42,7 @@ function Account(remote, account) {
   this._entry = { };
 
   function listenerAdded(type) {
-    if (~Account.subscribeEvents.indexOf(type)) {
+    if (_.includes(Account.subscribeEvents, type)) {
       if (!self._subs && self._remote._connected) {
         self._remote.requestSubscribe()
         .addAccount(self._account_id)
@@ -54,7 +55,7 @@ function Account(remote, account) {
   this.on('newListener', listenerAdded);
 
   function listenerRemoved(type) {
-    if (~Account.subscribeEvents.indexOf(type)) {
+    if (_.includes(Account.subscribeEvents, type)) {
       self._subs -= 1;
       if (!self._subs && self._remote._connected) {
         self._remote.requestUnsubscribe()
@@ -68,7 +69,7 @@ function Account(remote, account) {
 
   function attachAccount(request) {
     if (self._account.is_valid() && self._subs) {
-      request.add_account(self._account_id);
+      request.addAccount(self._account_id);
     }
   }
 
@@ -376,12 +377,7 @@ Account.prototype.publicKeyIsActive = function(public_key, callback) {
 Account._publicKeyToAddress = function(public_key) {
   // Based on functions in /src/js/ripple/keypair.js
   function hexToUInt160(publicKey) {
-    const bits = sjcl.codec.hex.toBits(publicKey);
-    const hash = sjcl.hash.ripemd160.hash(sjcl.hash.sha256.hash(bits));
-    const address = UInt160.from_bits(hash);
-    address.set_version(Base.VER_ACCOUNT_ID);
-
-    return address.to_json();
+    return encodeAccountID(createAccountID(hexToArray(publicKey)));
   }
 
   if (UInt160.is_valid(public_key)) {

src/core/amount.js

@@ -49,13 +49,13 @@ const consts = {
   // Maximum possible amount for non-XRP currencies using the maximum mantissa
   // with maximum exponent. Corresponds to hex 0xEC6386F26FC0FFFF.
   max_value: '9999999999999999e80',
-  // Minimum possible amount for non-XRP currencies.
-  min_value: '-1000000000000000e-96'
+  // Minimum nonzero absolute value for non-XRP currencies.
+  min_value: '1000000000000000e-96'
 };
 
 const MAX_XRP_VALUE = new XRPValue(1e11);
 const MAX_IOU_VALUE = new IOUValue(consts.max_value);
-const MIN_IOU_VALUE = new IOUValue(consts.min_value).abs();
+const MIN_IOU_VALUE = new IOUValue(consts.min_value);
 
 const bi_xns_unit = new IOUValue(1e6);
 
@@ -105,6 +105,19 @@ Amount.NaN = function() {
   return result;                      // but let's be careful
 };
 
+Amount.from_components_unsafe = function(value: Value, currency: Currency,
+  issuer: UInt160, isNative: boolean
+) {
+  const result = new Amount(value);
+  result._is_native = isNative;
+  result._currency = currency;
+  result._issuer = issuer;
+
+  result._value = value.isZero() && value.isNegative() ?
+      value.negate() : value;
+  return result;
+};
+
 // be sure that _is_native is set properly BEFORE calling _set_value
 Amount.prototype._set_value = function(value: Value) {
 
@@ -122,27 +135,30 @@ Amount.prototype.abs = function() {
 };
 
 Amount.prototype.add = function(addend) {
-  const addendAmount = Amount.from_json(addend);
+  const addendAmount = addend instanceof Amount ?
+    addend : Amount.from_json(addend);
 
   if (!this.is_comparable(addendAmount)) {
     return new Amount();
   }
 
   return this._copy(this._value.add(addendAmount._value));
-
 };
 
 Amount.prototype.subtract = function(subtrahend) {
   // Correctness over speed, less code has less bugs, reuse add code.
-  return this.add(Amount.from_json(subtrahend).negate());
+  const subsAmount = subtrahend instanceof Amount ?
+    subtrahend : Amount.from_json(subtrahend);
+  return this.add(subsAmount.negate());
 };
 
 // XXX Diverges from cpp.
 Amount.prototype.multiply = function(multiplicand) {
+  const multiplicandValue = multiplicand instanceof Amount ?
+    multiplicand._value :
+    Amount.from_json(multiplicand)._value;
 
-  const multiplicandAmount = Amount.from_json(multiplicand);
-
-  return this._copy(this._value.multiply(multiplicandAmount._value));
+  return this._copy(this._value.multiply(multiplicandValue));
 
 };
 
@@ -151,9 +167,11 @@ Amount.prototype.scale = function(scaleFactor) {
 };
 
 Amount.prototype.divide = function(divisor) {
-  const divisorAmount = Amount.from_json(divisor);
+  const divisorValue = divisor instanceof Amount ?
+    divisor._value :
+    Amount.from_json(divisor)._value;
 
-  return this._copy(this._value.divide(divisorAmount._value));
+  return this._copy(this._value.divide(divisorValue));
 };
 
 /**
@@ -344,7 +362,7 @@ Amount.prototype._check_limits = function() {
 };
 
 Amount.prototype.clone = function(negate) {
-  return this.copyTo(new Amount(), negate);
+  return this.copyTo(new Amount(this._value), negate);
 };
 
 Amount.prototype._copy = function(value) {
@@ -354,9 +372,10 @@ Amount.prototype._copy = function(value) {
 };
 
 Amount.prototype.compareTo = function(to) {
-  const toAmount = Amount.from_json(to);
+  const toAmount = to instanceof Amount ? to : Amount.from_json(to);
+
   if (!this.is_comparable(toAmount)) {
-    return new Amount();
+    throw new Error('Not comparable');
   }
   return this._value.comparedTo(toAmount._value);
 };
@@ -730,6 +749,14 @@ Amount.prototype.to_number = function() {
   return Number(this.to_text());
 };
 
+
+// this one is needed because Value.abs creates new BigNumber,
+// and BigNumber constructor is very slow, so we want to
+// call it only if absolutely necessary
+function absValue(value: Value): Value {
+  return value.isNegative() ? value.abs() : value;
+}
+
 // Convert only value to JSON wire format.
 Amount.prototype.to_text = function() {
   if (!this.is_valid()) {
@@ -743,8 +770,8 @@ Amount.prototype.to_text = function() {
   // not native
   const offset = this._value.getExponent() - 15;
   const sign = this._value.isNegative() ? '-' : '';
-  const mantissa = utils.getMantissa16FromString(
-    this._value.abs().toString());
+  const mantissa =
+    utils.getMantissa16FromString(absValue(this._value).toString());
   if (offset !== 0 && (offset < -25 || offset > -4)) {
     // Use e notation.
     // XXX Clamp output.

src/core/autobridgecalculator.js

@@ -18,17 +18,24 @@ function assertValidLegOneOffer(legOneOffer, message) {
 }
 
 function AutobridgeCalculator(currencyGets, currencyPays,
-  legOneOffers, legTwoOffers, issuerGets, issuerPays) {
+  legOneOffers, legTwoOffers, issuerGets, issuerPays
+) {
   this._currencyGets = currencyGets;
   this._currencyPays = currencyPays;
+  this._currencyGetsHex = currencyGets.to_hex();
+  this._currencyPaysHex = currencyPays.to_hex();
   this._issuerGets = issuerGets;
+  this._issuerGetsObj = UInt160.from_json(issuerGets);
   this._issuerPays = issuerPays;
+  this._issuerPaysObj = UInt160.from_json(issuerPays);
   this.legOneOffers = _.cloneDeep(legOneOffers);
   this.legTwoOffers = _.cloneDeep(legTwoOffers);
 
   this._ownerFundsLeftover = {};
 }
 
+const NULL_AMOUNT = Utils.normalizeAmount('0');
+
 /**
  * Calculates an ordered array of autobridged offers by quality
  *
@@ -36,10 +43,13 @@ function AutobridgeCalculator(currencyGets, currencyPays,
  */
 
 AutobridgeCalculator.prototype.calculate = function() {
+  const oldMode = Amount.strict_mode;
+  Amount.strict_mode = false;
+
   let legOnePointer = 0;
   let legTwoPointer = 0;
 
-  let offersAutobridged = [];
+  const offersAutobridged = [];
 
   this.clearOwnerFundsLeftover();
 
@@ -55,8 +65,10 @@ AutobridgeCalculator.prototype.calculate = function() {
       this.adjustLegOneFundedAmount(legOneOffer);
     }
 
-    const legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
-    const legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer);
+    const legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer,
+      this._currencyPays, this._issuerPaysObj);
+    const legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer,
+      this._currencyGets, this._issuerGetsObj);
 
     if (legOneTakerGetsFunded.is_zero()) {
       legOnePointer++;
@@ -70,14 +82,17 @@ AutobridgeCalculator.prototype.calculate = function() {
       continue;
     }
 
-    if (legOneTakerGetsFunded.compareTo(legTwoTakerPaysFunded) > 0) {
+    //  using private fields for speed
+    if (legOneTakerGetsFunded._value.comparedTo(
+      legTwoTakerPaysFunded._value) > 0) {
       autobridgedOffer = this.getAutobridgedOfferWithClampedLegOne(
         legOneOffer,
         legTwoOffer
       );
 
       legTwoPointer++;
-    } else if (legTwoTakerPaysFunded.compareTo(legOneTakerGetsFunded) > 0) {
+    } else if (legTwoTakerPaysFunded._value.comparedTo(
+      legOneTakerGetsFunded._value) > 0) {
       autobridgedOffer = this.getAutobridgedOfferWithClampedLegTwo(
         legOneOffer,
         legTwoOffer
@@ -97,6 +112,7 @@ AutobridgeCalculator.prototype.calculate = function() {
     offersAutobridged.push(autobridgedOffer);
   }
 
+  Amount.strict_mode = oldMode;
   return offersAutobridged;
 };
 
@@ -112,15 +128,20 @@ AutobridgeCalculator.prototype.calculate = function() {
 
 AutobridgeCalculator.prototype.getAutobridgedOfferWithClampedLegOne =
 function(legOneOffer, legTwoOffer) {
-  const legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
-  const legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer);
-  const legOneQuality = Utils.getOfferQuality(legOneOffer, this._currencyGets);
+  const legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer,
+    this._currencyPays, this._issuerPaysObj);
+  const legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer,
+    this._currencyGets, this._issuerGetsObj);
+  const legOneQuality = Utils.getOfferQuality(legOneOffer, this._currencyGets,
+    this._currencyPays, this._issuerPaysObj);
 
-  const autobridgedTakerGets = Utils.getOfferTakerGetsFunded(legTwoOffer);
+  const autobridgedTakerGets = Utils.getOfferTakerGetsFunded(legTwoOffer,
+    this._currencyGets, this._issuerGetsObj);
   const autobridgedTakerPays = legTwoTakerPaysFunded.multiply(legOneQuality);
 
   if (legOneOffer.Account === legTwoOffer.Account) {
-    const legOneTakerGets = Utils.getOfferTakerGets(legOneOffer);
+    const legOneTakerGets = Utils.getOfferTakerGets(legOneOffer,
+      this._currencyPays, this._issuerPaysObj);
     const updatedTakerGets = legOneTakerGets.subtract(legTwoTakerPaysFunded);
 
     this.setLegOneTakerGets(legOneOffer, updatedTakerGets);
@@ -152,15 +173,20 @@ function(legOneOffer, legTwoOffer) {
 
 AutobridgeCalculator.prototype.getAutobridgedOfferWithClampedLegTwo =
 function(legOneOffer, legTwoOffer) {
-  const legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
-  const legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer);
-  const legTwoQuality = Utils.getOfferQuality(legTwoOffer, this._currencyGets);
+  const legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer,
+    this._currencyPays, this._issuerPaysObj);
+  const legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer,
+    this._currencyGets, this._issuerGetsObj);
+  const legTwoQuality = Utils.getOfferQuality(legTwoOffer, this._currencyGets,
+    this._currencyGets, this._issuerGetsObj);
 
   const autobridgedTakerGets = legOneTakerGetsFunded.divide(legTwoQuality);
-  const autobridgedTakerPays = Utils.getOfferTakerPaysFunded(legOneOffer);
+  const autobridgedTakerPays = Utils.getOfferTakerPaysFunded(legOneOffer,
+    this._currencyPays, this._issuerPaysObj);
 
   // Update funded amount since leg two offer was not completely consumed
-  legTwoOffer.taker_gets_funded = Utils.getOfferTakerGetsFunded(legTwoOffer)
+  legTwoOffer.taker_gets_funded = Utils.getOfferTakerGetsFunded(legTwoOffer,
+    this._currencyGets, this._issuerGetsObj)
     .subtract(autobridgedTakerGets)
     .to_text();
   legTwoOffer.taker_pays_funded = legTwoTakerPaysFunded
@@ -184,8 +210,10 @@ function(legOneOffer, legTwoOffer) {
 
 AutobridgeCalculator.prototype.getAutobridgedOfferWithoutClamps =
 function(legOneOffer, legTwoOffer) {
-  const autobridgedTakerGets = Utils.getOfferTakerGetsFunded(legTwoOffer);
-  const autobridgedTakerPays = Utils.getOfferTakerPaysFunded(legOneOffer);
+  const autobridgedTakerGets = Utils.getOfferTakerGetsFunded(legTwoOffer,
+    this._currencyGets, this._issuerGetsObj);
+  const autobridgedTakerPays = Utils.getOfferTakerPaysFunded(legOneOffer,
+    this._currencyPays, this._issuerPaysObj);
 
   return this.formatAutobridgedOffer(
     autobridgedTakerGets,
@@ -210,9 +238,7 @@ AutobridgeCalculator.prototype.clearOwnerFundsLeftover = function() {
  */
 
 AutobridgeCalculator.prototype.resetOwnerFundsLeftover = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
-
-  this._ownerFundsLeftover[account] = Utils.normalizeAmount('0');
+  this._ownerFundsLeftover[account] = NULL_AMOUNT.clone();
 
   return this._ownerFundsLeftover[account];
 };
@@ -226,12 +252,10 @@ AutobridgeCalculator.prototype.resetOwnerFundsLeftover = function(account) {
  */
 
 AutobridgeCalculator.prototype.getLeftoverOwnerFunds = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
-
   let amount = this._ownerFundsLeftover[account];
 
   if (!amount) {
-    amount = Utils.normalizeAmount('0');
+    amount = NULL_AMOUNT.clone();
   }
 
   return amount;
@@ -248,7 +272,6 @@ AutobridgeCalculator.prototype.getLeftoverOwnerFunds = function(account) {
 
 AutobridgeCalculator.prototype.addLeftoverOwnerFunds =
 function(account, amount) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   assert(amount instanceof Amount, 'Amount is invalid');
 
   this._ownerFundsLeftover[account] = this.getLeftoverOwnerFunds(account)
@@ -266,7 +289,6 @@ function(account, amount) {
 
 AutobridgeCalculator.prototype.setLeftoverOwnerFunds =
 function(account, amount) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   assert(amount instanceof Amount, 'Amount is invalid');
 
   this._ownerFundsLeftover[account] = amount;
@@ -291,13 +313,13 @@ function(takerGets, takerPays) {
 
   autobridgedOffer.TakerGets = {
     value: takerGets.to_text(),
-    currency: this._currencyGets.to_hex(),
+    currency: this._currencyGetsHex,
     issuer: this._issuerGets
   };
 
   autobridgedOffer.TakerPays = {
     value: takerPays.to_text(),
-    currency: this._currencyPays.to_hex(),
+    currency: this._currencyPaysHex,
     issuer: this._issuerPays
   };
 
@@ -308,7 +330,9 @@ function(takerGets, takerPays) {
 
   autobridgedOffer.autobridged = true;
 
-  autobridgedOffer.BookDirectory = Utils.convertOfferQualityToHex(quality);
+  autobridgedOffer.BookDirectory =
+    Utils.convertOfferQualityToHexFromText(autobridgedOffer.quality);
+  autobridgedOffer.qualityHex = autobridgedOffer.BookDirectory;
 
   return autobridgedOffer;
 };
@@ -325,11 +349,13 @@ function(takerGets, takerPays) {
 AutobridgeCalculator.prototype.unclampLegOneOwnerFunds = function(legOneOffer) {
   assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
 
-  legOneOffer.initTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
+  legOneOffer.initTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer,
+    this._currencyPays, this._issuerPaysObj);
 
   this.setLegOneTakerGetsFunded(
     legOneOffer,
-    Utils.getOfferTakerGets(legOneOffer)
+    Utils.getOfferTakerGets(legOneOffer, this._currencyPays,
+      this._issuerPaysObj)
   );
 };
 
@@ -350,7 +376,8 @@ AutobridgeCalculator.prototype.unclampLegOneOwnerFunds = function(legOneOffer) {
 AutobridgeCalculator.prototype.clampLegOneOwnerFunds = function(legOneOffer) {
   assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
 
-  const takerGets = Utils.getOfferTakerGets(legOneOffer);
+  const takerGets = Utils.getOfferTakerGets(legOneOffer, this._currencyPays,
+    this._issuerPaysObj);
 
   if (takerGets.compareTo(legOneOffer.initTakerGetsFunded) > 0) {
     // After clamping, TakerGets is still greater than initial funded amount
@@ -375,12 +402,16 @@ function(legOneOffer) {
   assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
   assert(!legOneOffer.is_fully_funded, 'Leg one offer cannot be fully funded');
 
-  const fundedSum = Utils.getOfferTakerGetsFunded(legOneOffer)
+  const fundedSum = Utils.getOfferTakerGetsFunded(legOneOffer,
+    this._currencyPays, this._issuerPaysObj)
     .add(this.getLeftoverOwnerFunds(legOneOffer.Account));
 
-  if (fundedSum.compareTo(Utils.getOfferTakerGets(legOneOffer)) >= 0) {
+  if (fundedSum.compareTo(Utils.getOfferTakerGets(legOneOffer,
+    this._currencyPays, this._issuerPaysObj)) >= 0
+  ) {
     // There are enough extra funds to fully fund the offer
-    const legOneTakerGets = Utils.getOfferTakerGets(legOneOffer);
+    const legOneTakerGets = Utils.getOfferTakerGets(legOneOffer,
+      this._currencyPays, this._issuerPaysObj);
     const updatedLeftover = fundedSum.subtract(legOneTakerGets);
 
     this.setLegOneTakerGetsFunded(legOneOffer, legOneTakerGets);
@@ -407,8 +438,9 @@ function setLegOneTakerGetsFunded(legOneOffer, takerGetsFunded) {
 
   legOneOffer.taker_gets_funded = takerGetsFunded.to_text();
   legOneOffer.taker_pays_funded = takerGetsFunded
-    .multiply(Utils.getOfferQuality(legOneOffer, this._currencyGets))
-    .to_text();
+    .multiply(Utils.getOfferQuality(legOneOffer, this._currencyGets,
+      this._currencyPays, this._issuerPaysObj))
+      .to_text();
 
   if (legOneOffer.taker_gets_funded === legOneOffer.TakerGets.value) {
     legOneOffer.is_fully_funded = true;
@@ -428,10 +460,11 @@ function(legOneOffer, takerGets) {
   assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
   assert(takerGets instanceof Amount, 'Taker gets funded is invalid');
 
-  const legOneQuality = Utils.getOfferQuality(legOneOffer, this._currencyGets);
+  const legOneQuality = Utils.getOfferQuality(legOneOffer, this._currencyGets,
+    this._currencyPays, this._issuerPaysObj);
 
   legOneOffer.TakerGets = takerGets.to_text();
-  legOneOffer.TakerPays = takerGets.multiply(legOneQuality);
+  legOneOffer.TakerPays = takerGets.multiply(legOneQuality).to_json();
 };
 
 module.exports = AutobridgeCalculator;

src/core/base.js

@@ -1,18 +1,11 @@
 'use strict';
-const _ = require('lodash');
-const sjcl = require('./utils').sjcl;
-const utils = require('./utils');
+
+const BN = require('bn.js');
 const extend = require('extend');
-const convertBase = require('./baseconverter');
+const {encode, decode} = require('ripple-address-codec');
 
 const Base = {};
 
-const alphabets = Base.alphabets = {
-  ripple: 'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz',
-  tipple: 'RPShNAF39wBUDnEGHJKLM4pQrsT7VWXYZ2bcdeCg65jkm8ofqi1tuvaxyz',
-  bitcoin: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-};
-
 extend(Base, {
   VER_NONE: 1,
   VER_NODE_PUBLIC: 28,
@@ -21,134 +14,44 @@ extend(Base, {
   VER_ACCOUNT_PUBLIC: 35,
   VER_ACCOUNT_PRIVATE: 34,
   VER_FAMILY_GENERATOR: 41,
-  VER_FAMILY_SEED: 33
-});
-
-function sha256(bytes) {
-  return sjcl.codec.bytes.fromBits(
-    sjcl.hash.sha256.hash(sjcl.codec.bytes.toBits(bytes)));
-}
-
-function encodeString(alphabet, input) {
-  if (input.length === 0) {
-    return '';
-  }
-
-  const leadingZeros = _.takeWhile(input, function(d) {
-    return d === 0;
-  });
-  const out = convertBase(input, 256, 58).map(function(digit) {
-    if (digit < 0 || digit >= alphabet.length) {
-      throw new Error('Value ' + digit + ' is out of bounds for encoding');
-    }
-    return alphabet[digit];
-  });
-  const prefix = leadingZeros.map(function() {
-    return alphabet[0];
-  });
-  return prefix.concat(out).join('');
-}
-
-function decodeString(indexes, input) {
-  if (input.length === 0) {
-    return [];
-  }
-
-  const input58 = input.split('').map(function(c) {
-    const charCode = c.charCodeAt(0);
-    if (charCode >= indexes.length || indexes[charCode] === -1) {
-      throw new Error('Character ' + c + ' is not valid for encoding');
-    }
-    return indexes[charCode];
-  });
-  const leadingZeros = _.takeWhile(input58, function(d) {
-    return d === 0;
-  });
-  const out = convertBase(input58, 58, 256);
-  return leadingZeros.concat(out);
-}
-
-function Base58(alphabet) {
-  const indexes = utils.arraySet(128, -1);
-  for (let i = 0; i < alphabet.length; i++) {
-    indexes[alphabet.charCodeAt(i)] = i;
-  }
-  return {
-    decode: decodeString.bind(null, indexes),
-    encode: encodeString.bind(null, alphabet)
-  };
-}
-
-Base.encoders = {};
-Object.keys(alphabets).forEach(function(alphabet) {
-  Base.encoders[alphabet] = new Base58(alphabets[alphabet]);
+  VER_FAMILY_SEED: 33,
+  VER_ED25519_SEED: [0x01, 0xE1, 0x4B]
 });
 
 // --> input: big-endian array of bytes.
 // <-- string at least as long as input.
-Base.encode = function(input, alpha) {
-  return this.encoders[alpha || 'ripple'].encode(input);
+Base.encode = function(input, alphabet) {
+  return encode(input, {alphabet});
 };
 
 // --> input: String
 // <-- array of bytes or undefined.
-Base.decode = function(input, alpha) {
+Base.decode = function(input, alphabet) {
   if (typeof input !== 'string') {
     return undefined;
   }
   try {
-    return this.encoders[alpha || 'ripple'].decode(input);
+    return decode(input, {alphabet});
   } catch (e) {
     return undefined;
   }
 };
 
-Base.verify_checksum = function(bytes) {
-  const computed = sha256(sha256(bytes.slice(0, -4))).slice(0, 4);
-  const checksum = bytes.slice(-4);
-  return _.isEqual(computed, checksum);
-};
-
 // --> input: Array
 // <-- String
 Base.encode_check = function(version, input, alphabet) {
-  const buffer = [].concat(version, input);
-  const check = sha256(sha256(buffer)).slice(0, 4);
-
-  return Base.encode([].concat(buffer, check), alphabet);
+  return encode(input, {version, alphabet});
 };
 
 // --> input : String
-// <-- NaN || sjcl.bn
+// <-- NaN || BN
 Base.decode_check = function(version, input, alphabet) {
-  const buffer = Base.decode(input, alphabet);
-
-  if (!buffer || buffer.length < 5) {
+  try {
+    const decoded = decode(input, {version, alphabet});
+    return new BN(decoded);
+  } catch (e) {
     return NaN;
   }
-
-  // Single valid version
-  if (typeof version === 'number' && buffer[0] !== version) {
-    return NaN;
-  }
-
-  // Multiple allowed versions
-  if (Array.isArray(version) && _.every(version, function(v) {
-    return v !== buffer[0];
-  })) {
-    return NaN;
-  }
-
-  if (!Base.verify_checksum(buffer)) {
-    return NaN;
-  }
-
-  // We'll use the version byte to add a leading zero, this ensures JSBN doesn't
-  // intrepret the value as a negative number
-  buffer[0] = 0;
-
-  return sjcl.bn.fromBits(
-      sjcl.codec.bytes.toBits(buffer.slice(0, -4)));
 };
 
 exports.Base = Base;

src/core/baseconverter.js

@@ -1,28 +1,41 @@
 'use strict';
 
+
 function normalize(digitArray) {
-  while (digitArray[0] === 0) {
-    digitArray.shift();
+  let i = 0;
+  while (digitArray[i] === 0) {
+    ++i;
+  }
+  if (i > 0) {
+    digitArray.splice(0, i);
   }
   return digitArray;
 }
 
 function divmod(digitArray, base, divisor) {
-  var remainder = 0;
-  var quotient = [];
-  for (var j = 0; j < digitArray.length; j++) {
-    var temp = remainder * base + parseInt(digitArray[j], 10);
-    quotient.push(Math.floor(temp / divisor));
+  let remainder = 0;
+  let temp;
+  let divided;
+  let j = -1;
+
+  const length = digitArray.length;
+  const quotient = new Array(length);
+
+  while (++j < length) {
+    temp = remainder * base + digitArray[j];
+    divided = temp / divisor;
+    quotient[j] = divided << 0;
     remainder = temp % divisor;
   }
   return {quotient: normalize(quotient), remainder: remainder};
 }
 
 function convertBase(digitArray, fromBase, toBase) {
-  var result = [];
-  var dividend = digitArray;
+  const result = [];
+  let dividend = digitArray;
+  let qr;
   while (dividend.length > 0) {
-    var qr = divmod(dividend, fromBase, toBase);
+    qr = divmod(dividend, fromBase, toBase);
     result.unshift(qr.remainder);
     dividend = qr.quotient;
   }

src/core/binformat.js

@@ -1,6 +1,8 @@
 'use strict';
 
-/*eslint no-multi-spaces:0,space-in-brackets:0,key-spacing:0,comma-spacing:0*/
+/*eslint-disable max-len,spaced-comment,array-bracket-spacing,key-spacing*/
+/*eslint-disable no-multi-spaces,comma-spacing*/
+/*eslint-disable no-multi-spaces:0,space-in-brackets:0,key-spacing:0,comma-spacing:0*/
 
 /**
  * Data type map.
@@ -52,7 +54,8 @@ const FIELDS_MAP = exports.fields = {
   // Common types
   1: { // Int16
     1: 'LedgerEntryType',
-    2: 'TransactionType'
+    2: 'TransactionType',
+    3: 'SignerWeight'
   },
   2: { // Int32
     2: 'Flags',
@@ -87,7 +90,11 @@ const FIELDS_MAP = exports.fields = {
     31: 'ReserveBase',
     32: 'ReserveIncrement',
     33: 'SetFlag',
-    34: 'ClearFlag'
+    34: 'ClearFlag',
+    35: 'SignerQuorum',
+    36: 'CancelAfter',
+    37: 'FinishAfter',
+    38: 'SignerListID'
   },
   3: { // Int64
     1: 'IndexNext',
@@ -116,7 +123,8 @@ const FIELDS_MAP = exports.fields = {
     17: 'InvoiceID',
     18: 'Nickname',
     19: 'Amendment',
-    20: 'TicketID'
+    20: 'TicketID',
+    21: 'Digest'
   },
   6: { // Amount
     1: 'Amount',
@@ -146,7 +154,8 @@ const FIELDS_MAP = exports.fields = {
     11: 'CreateCode',
     12: 'MemoType',
     13: 'MemoData',
-    14: 'MemoFormat'
+    14: 'MemoFormat',
+    17: 'Proof'
   },
   8: { // Account
     1: 'Account',
@@ -166,13 +175,15 @@ const FIELDS_MAP = exports.fields = {
     7: 'FinalFields',
     8: 'NewFields',
     9: 'TemplateEntry',
-    10: 'Memo'
+    10: 'Memo',
+    11: 'SignerEntry',
+    16: 'Signer'
   },
   15: { // Array
     1: undefined,  // end of Array
     2: 'SigningAccounts',
-    3: 'TxnSignatures',
-    4: 'Signatures',
+    3: 'Signers',
+    4: 'SignerEntries',
     5: 'Template',
     6: 'Necessary',
     7: 'Sufficient',
@@ -183,7 +194,7 @@ const FIELDS_MAP = exports.fields = {
   // Uncommon types
   16: { // Int8
     1: 'CloseResolution',
-    2: 'TemplateEntryType',
+    2: 'Method',
     3: 'TransactionResult'
   },
   17: { // Hash160
@@ -202,17 +213,17 @@ const FIELDS_MAP = exports.fields = {
   }
 };
 
-let INVERSE_FIELDS_MAP = exports.fieldsInverseMap = { };
+const INVERSE_FIELDS_MAP = exports.fieldsInverseMap = { };
 
 Object.keys(FIELDS_MAP).forEach(function(k1) {
   Object.keys(FIELDS_MAP[k1]).forEach(function(k2) {
-    INVERSE_FIELDS_MAP[FIELDS_MAP[k1][k2]] = [ Number(k1), Number(k2) ];
+    INVERSE_FIELDS_MAP[FIELDS_MAP[k1][k2]] = [Number(k1), Number(k2)];
   });
 });
 
-const REQUIRED = exports.REQUIRED = 0,
-      OPTIONAL = exports.OPTIONAL = 1,
-      DEFAULT  = exports.DEFAULT  = 2;
+const REQUIRED = exports.REQUIRED = 0;
+const OPTIONAL = exports.OPTIONAL = 1;
+const DEFAULT  = exports.DEFAULT  = 2;
 
 const base = [
   [ 'TransactionType'    , REQUIRED ],
@@ -226,76 +237,100 @@ const base = [
   [ 'SigningPubKey'      , REQUIRED ],
   [ 'TxnSignature'       , OPTIONAL ],
   [ 'AccountTxnID'       , OPTIONAL ],
-  [ 'Memos'              , OPTIONAL ]
+  [ 'Memos'              , OPTIONAL ],
+  [ 'Signers'            , OPTIONAL ]
 ];
 
 exports.tx = {
   AccountSet: [3].concat(base, [
-    [ 'EmailHash'          , OPTIONAL ],
-    [ 'WalletLocator'      , OPTIONAL ],
-    [ 'WalletSize'         , OPTIONAL ],
-    [ 'MessageKey'         , OPTIONAL ],
-    [ 'Domain'             , OPTIONAL ],
-    [ 'TransferRate'       , OPTIONAL ],
-    [ 'SetFlag'            , OPTIONAL ],
-    [ 'ClearFlag'          , OPTIONAL ]
+    ['EmailHash'          , OPTIONAL],
+    ['WalletLocator'      , OPTIONAL],
+    ['WalletSize'         , OPTIONAL],
+    ['MessageKey'         , OPTIONAL],
+    ['Domain'             , OPTIONAL],
+    ['TransferRate'       , OPTIONAL],
+    ['SetFlag'            , OPTIONAL],
+    ['ClearFlag'          , OPTIONAL]
   ]),
   TrustSet: [20].concat(base, [
-    [ 'LimitAmount'        , OPTIONAL ],
-    [ 'QualityIn'          , OPTIONAL ],
-    [ 'QualityOut'         , OPTIONAL ]
+    ['LimitAmount'        , OPTIONAL],
+    ['QualityIn'          , OPTIONAL],
+    ['QualityOut'         , OPTIONAL]
   ]),
   OfferCreate: [7].concat(base, [
-    [ 'TakerPays'          , REQUIRED ],
-    [ 'TakerGets'          , REQUIRED ],
-    [ 'Expiration'         , OPTIONAL ],
-    [ 'OfferSequence'      , OPTIONAL ]
+    ['TakerPays'          , REQUIRED],
+    ['TakerGets'          , REQUIRED],
+    ['Expiration'         , OPTIONAL],
+    ['OfferSequence'      , OPTIONAL]
   ]),
   OfferCancel: [8].concat(base, [
-    [ 'OfferSequence'      , REQUIRED ]
+    ['OfferSequence'      , REQUIRED]
   ]),
   SetRegularKey: [5].concat(base, [
-    [ 'RegularKey'         , OPTIONAL ]
+    ['RegularKey'         , OPTIONAL]
   ]),
   Payment: [0].concat(base, [
-    [ 'Destination'        , REQUIRED ],
-    [ 'Amount'             , REQUIRED ],
-    [ 'SendMax'            , OPTIONAL ],
-    [ 'Paths'              , DEFAULT  ],
-    [ 'InvoiceID'          , OPTIONAL ],
-    [ 'DestinationTag'     , OPTIONAL ]
+    ['Destination'        , REQUIRED],
+    ['Amount'             , REQUIRED],
+    ['SendMax'            , OPTIONAL],
+    ['Paths'              , DEFAULT],
+    ['InvoiceID'          , OPTIONAL],
+    ['DestinationTag'     , OPTIONAL]
   ]),
   Contract: [9].concat(base, [
-    [ 'Expiration'         , REQUIRED ],
-    [ 'BondAmount'         , REQUIRED ],
-    [ 'StampEscrow'        , REQUIRED ],
-    [ 'RippleEscrow'       , REQUIRED ],
-    [ 'CreateCode'         , OPTIONAL ],
-    [ 'FundCode'           , OPTIONAL ],
-    [ 'RemoveCode'         , OPTIONAL ],
-    [ 'ExpireCode'         , OPTIONAL ]
+    ['Expiration'         , REQUIRED],
+    ['BondAmount'         , REQUIRED],
+    ['StampEscrow'        , REQUIRED],
+    ['RippleEscrow'       , REQUIRED],
+    ['CreateCode'         , OPTIONAL],
+    ['FundCode'           , OPTIONAL],
+    ['RemoveCode'         , OPTIONAL],
+    ['ExpireCode'         , OPTIONAL]
   ]),
   RemoveContract: [10].concat(base, [
-    [ 'Target'             , REQUIRED ]
+    ['Target'             , REQUIRED]
   ]),
   EnableFeature: [100].concat(base, [
-    [ 'Feature'            , REQUIRED ]
+    ['Feature'            , REQUIRED]
   ]),
   EnableAmendment: [100].concat(base, [
-    [ 'Amendment'          , REQUIRED ]
+    ['Amendment'          , REQUIRED]
   ]),
   SetFee: [101].concat(base, [
-    [ 'BaseFee'            , REQUIRED ],
-    [ 'ReferenceFeeUnits'  , REQUIRED ],
-    [ 'ReserveBase'        , REQUIRED ],
-    [ 'ReserveIncrement'   , REQUIRED ]
+    ['BaseFee'            , REQUIRED],
+    ['ReferenceFeeUnits'  , REQUIRED],
+    ['ReserveBase'        , REQUIRED],
+    ['ReserveIncrement'   , REQUIRED]
   ]),
   TicketCreate: [10].concat(base, [
-    [ 'Target'             , OPTIONAL ],
-    [ 'Expiration'         , OPTIONAL ]
+    ['Target'             , OPTIONAL],
+    ['Expiration'         , OPTIONAL]
   ]),
   TicketCancel: [11].concat(base, [
-    [ 'TicketID'           , REQUIRED ]
+    ['TicketID'           , REQUIRED]
+  ]),
+  SignerListSet: [12].concat(base, [
+    ['SignerQuorum', REQUIRED],
+    ['SignerEntries', OPTIONAL]
+  ]),
+  SuspendedPaymentCreate: [1].concat(base, [
+    ['Destination'        , REQUIRED],
+    ['Amount'             , REQUIRED],
+    ['Digest'             , OPTIONAL],
+    ['CancelAfter'        , OPTIONAL],
+    ['FinishAfter'        , OPTIONAL],
+    ['DestinationTag'     , OPTIONAL]
+  ]),
+  SuspendedPaymentFinish: [2].concat(base, [
+    ['Owner'              , REQUIRED],
+    ['OfferSequence'      , REQUIRED],
+    ['Method'             , OPTIONAL],
+    ['Digest'             , OPTIONAL],
+    ['Proof'              , OPTIONAL]
+  ]),
+  SuspendedPaymentCancel: [4].concat(base, [
+    ['Owner'              , REQUIRED],
+    ['OfferSequence'      , REQUIRED]
   ])
 };
 
@@ -396,13 +431,22 @@ exports.ledger = {
     ['LedgerIndex',         OPTIONAL],
     ['Balance',             REQUIRED],
     ['LowLimit',            REQUIRED],
-    ['HighLimit',           REQUIRED]])
+    ['HighLimit',           REQUIRED]]),
+  SignerList: [83].concat(sleBase,[
+    ['OwnerNode',           REQUIRED],
+    ['SignerQuorum',        REQUIRED],
+    ['SignerEntries',       REQUIRED],
+    ['SignerListID',        REQUIRED],
+    ['PreviousTxnID',       REQUIRED],
+    ['PreviousTxnLgrSeq',   REQUIRED]
+  ])
 };
 
 exports.metadata = [
-  [ 'TransactionIndex'     , REQUIRED ],
-  [ 'TransactionResult'    , REQUIRED ],
-  [ 'AffectedNodes'        , REQUIRED ]
+  ['DeliveredAmount'      , OPTIONAL],
+  ['TransactionIndex'     , REQUIRED],
+  ['TransactionResult'    , REQUIRED],
+  ['AffectedNodes'        , REQUIRED]
 ];
 
 exports.ter = {
@@ -422,7 +466,7 @@ exports.ter = {
   tecNO_LINE_REDUNDANT     : 127,
   tecPATH_DRY              : 128,
   tecUNFUNDED              : 129,  // Deprecated, old ambiguous unfunded.
-  tecMASTER_DISABLED       : 130,
+  tecNO_ALTERNATIVE_KEY    : 130,
   tecNO_REGULAR_KEY        : 131,
   tecOWNERS                : 132,
   tecNO_ISSUER             : 133,
@@ -436,5 +480,6 @@ exports.ter = {
   tecINSUFFICIENT_RESERVE  : 141,
   tecNEED_MASTER_KEY       : 142,
   tecDST_TAG_NEEDED        : 143,
-  tecINTERNAL              : 144
+  tecINTERNAL              : 144,
+  tecOVERSIZE              : 145
 };

src/core/currency.js

@@ -1,15 +1,15 @@
 'use strict';
 
-var extend = require('extend');
-var UInt160 = require('./uint160').UInt160;
-var utils = require('./utils');
-var Float = require('./ieee754').Float;
+const extend = require('extend');
+const UInt160 = require('./uint160').UInt160;
+const utils = require('./utils');
+const Float = require('./ieee754').Float;
 
 //
 // Currency support
 //
 
-var Currency = extend(function() {
+const Currency = extend(function() {
   // Internal form: 0 = XRP. 3 letter-code.
   // XXX Internal should be 0 or hex with three letter annotation when valid.
 
@@ -22,7 +22,7 @@ var Currency = extend(function() {
   this._update();
 }, UInt160);
 
-Currency.prototype = extend({}, UInt160.prototype);
+Currency.prototype = Object.create(extend({}, UInt160.prototype));
 Currency.prototype.constructor = Currency;
 
 Currency.HEX_CURRENCY_BAD = '0000000000000000000000005852500000000000';
@@ -61,12 +61,12 @@ Currency.HEX_CURRENCY_BAD = '0000000000000000000000005852500000000000';
  *
  */
 
-/*eslint-disable max-len*/
+/* eslint-disable max-len*/
 Currency.prototype.human_RE = /^\s*([a-zA-Z0-9\<\>\(\)\{\}\[\]\|\?\!\@\#\$\%\^\&]{3})(\s*-\s*[- \w]+)?(\s*\(-?\d+\.?\d*%pa\))?\s*$/;
-/*eslint-enable max-len*/
+/* eslint-enable max-len*/
 
 Currency.from_json = function(j, shouldInterpretXrpAsIou) {
-    return (new Currency()).parse_json(j, shouldInterpretXrpAsIou);
+  return (new Currency()).parse_json(j, shouldInterpretXrpAsIou);
 };
 
 Currency.from_human = function(j, opts) {
@@ -78,7 +78,7 @@ Currency.prototype.parse_json = function(j, shouldInterpretXrpAsIou) {
   this._value = NaN;
 
   if (j instanceof Currency) {
-    this._value = j.copyTo({})._value;
+    this._value = j._value;
     this._update();
     return this;
   }
@@ -111,10 +111,10 @@ Currency.prototype.parse_json = function(j, shouldInterpretXrpAsIou) {
       }
 
       // match the given string to see if it's in an allowed format
-      var matches = j.match(this.human_RE);
+      const matches = j.match(this.human_RE);
 
       if (matches) {
-        var currencyCode = matches[1];
+        let currencyCode = matches[1];
 
         // for the currency 'XRP' case
         // we drop everything else that could have been provided
@@ -131,14 +131,14 @@ Currency.prototype.parse_json = function(j, shouldInterpretXrpAsIou) {
         // the full currency is matched as it is part of the valid currency
         // format, but not stored
         // var full_currency = matches[2] || '';
-        var interest = matches[3] || '';
+        const interest = matches[3] || '';
 
         // interest is defined as interest per year, per annum (pa)
-        var percentage = interest.match(/(-?\d+\.?\d+)/);
+        let percentage = interest.match(/(-?\d+\.?\d+)/);
 
         currencyCode = currencyCode.toUpperCase();
 
-        var currencyData = utils.arraySet(20, 0);
+        const currencyData = utils.arraySet(20, 0);
 
         if (percentage) {
           /*
@@ -164,15 +164,15 @@ Currency.prototype.parse_json = function(j, shouldInterpretXrpAsIou) {
 
           // the interest or demurrage is expressed as a yearly (per annum)
           // value
-          var secondsPerYear = 31536000; // 60 * 60 * 24 * 365
+          const secondsPerYear = 31536000; // 60 * 60 * 24 * 365
 
           // Calculating the interest e-fold
           // 0.5% demurrage is expressed 0.995, 0.005 less than 1
           // 0.5% interest is expressed as 1.005, 0.005 more than 1
-          var interestEfold = secondsPerYear / Math.log(1 + percentage / 100);
-          var bytes = Float.toIEEE754Double(interestEfold);
+          const interestEfold = secondsPerYear / Math.log(1 + percentage / 100);
+          const bytes = Float.toIEEE754Double(interestEfold);
 
-          for (var i = 0; i <= bytes.length; i++) {
+          for (let i = 0; i <= bytes.length; i++) {
             currencyData[8 + i] = bytes[i] & 0xff;
           }
 
@@ -204,10 +204,10 @@ Currency.prototype.parse_human = function(j) {
  */
 
 Currency.prototype._update = function() {
-  var bytes = this.to_bytes();
+  const bytes = this.to_bytes();
 
   // is it 0 everywhere except 12, 13, 14?
-  var isZeroExceptInStandardPositions = true;
+  let isZeroExceptInStandardPositions = true;
 
   if (!bytes) {
     return;
@@ -219,7 +219,7 @@ Currency.prototype._update = function() {
   this._interest_period = NaN;
   this._iso_code = '';
 
-  for (var i = 0; i < 20; i++) {
+  for (let i = 0; i < 20; i++) {
     isZeroExceptInStandardPositions = isZeroExceptInStandardPositions
     && (i === 12 || i === 13 || i === 14 || bytes[i] === 0);
   }
@@ -249,6 +249,34 @@ Currency.prototype._update = function() {
   }
 };
 
+/**
+ * Returns copy.
+ *
+ * This copies code from UInt.copyTo so we do not call _update,
+ * bvecause to_bytes is very expensive.
+ */
+
+Currency.prototype.copyTo = function(d) {
+  d._value = this._value;
+
+  if (this._version_byte !== undefined) {
+    d._version_byte = this._version_byte;
+  }
+
+  if (!d.is_valid()) {
+    return d;
+  }
+
+  d._native = this._native;
+  d._type = this._type;
+  d._interest_start = this._interest_start;
+  d._interest_period = this._interest_period;
+  d._iso_code = this._iso_code;
+
+  return d;
+};
+
+
 // XXX Probably not needed anymore?
 /*
 Currency.prototype.parse_bytes = function(byte_array) {
@@ -300,18 +328,20 @@ Currency.prototype.has_interest = function() {
 
 /**
  *
- * @param {number} referenceDate number of seconds since the Ripple Epoch
+ * @param {number} referenceDate_ number of seconds since the Ripple Epoch
  * (0:00 on January 1, 2000 UTC) used to calculate the
  * interest over provided interval pass in one years
  * worth of seconds to ge the yearly interest
  * @returns {number} interest for provided interval, can be negative for
  * demurred currencies
  */
-Currency.prototype.get_interest_at = function(referenceDate) {
+Currency.prototype.get_interest_at = function(referenceDate_) {
   if (!this.has_interest()) {
     return 0;
   }
 
+  let referenceDate = referenceDate_;
+
   // use one year as a default period
   if (!referenceDate) {
     referenceDate = this._interest_start + 3600 * 24 * 365;
@@ -326,13 +356,14 @@ Currency.prototype.get_interest_at = function(referenceDate) {
                 / this._interest_period);
 };
 
-Currency.prototype.get_interest_percentage_at
-= function(referenceDate, decimals) {
-  var interest = this.get_interest_at(referenceDate, decimals);
+Currency.prototype.get_interest_percentage_at = function(referenceDate,
+  decimals
+) {
+  let interest = this.get_interest_at(referenceDate, decimals);
 
   // convert to percentage
   interest = (interest * 100) - 100;
-  var decimalMultiplier = decimals ? Math.pow(10, decimals) : 100;
+  const decimalMultiplier = decimals ? Math.pow(10, decimals) : 100;
 
   // round to two decimals behind the dot
   return Math.round(interest * decimalMultiplier) / decimalMultiplier;
@@ -347,18 +378,14 @@ Currency.prototype.get_interest_percentage_at
 //  return UInt.prototype.is_valid() && ...;
 // };
 
-Currency.prototype.to_json = function(opts) {
+Currency.prototype.to_json = function(opts = {}) {
   if (!this.is_valid()) {
     // XXX This is backwards compatible behavior, but probably not very good.
     return 'XRP';
   }
 
-  if (!opts) {
-    opts = {};
-  }
-
-  var currency;
-  var fullName = opts && opts.full_name ? ' - ' + opts.full_name : '';
+  let currency;
+  const fullName = opts && opts.full_name ? ' - ' + opts.full_name : '';
   opts.show_interest = opts.show_interest !== undefined
   ? opts.show_interest
   : this.has_interest();
@@ -366,8 +393,8 @@ Currency.prototype.to_json = function(opts) {
   if (!opts.force_hex && /^[A-Z0-9]{3}$/.test(this._iso_code)) {
     currency = this._iso_code + fullName;
     if (opts.show_interest) {
-      var decimals = !isNaN(opts.decimals) ? opts.decimals : undefined;
-      var interestPercentage = this.has_interest()
+      const decimals = !isNaN(opts.decimals) ? opts.decimals : undefined;
+      const interestPercentage = this.has_interest()
       ? this.get_interest_percentage_at(
           this._interest_start + 3600 * 24 * 365, decimals
         )

src/core/hashprefixes.js

@@ -30,6 +30,8 @@ exports.HASH_LEAF_NODE = 0x4D4C4E00; // 'MLN'
 exports.HASH_TX_SIGN = 0x53545800; // 'STX'
 // inner transaction to sign (TESTNET)
 exports.HASH_TX_SIGN_TESTNET = 0x73747800; // 'stx'
+// inner transaction to multisign
+exports.HASH_TX_MULTISIGN = 0x534D5400; // 'SMT'
 
 Object.keys(exports).forEach(function(k) {
   exports[k + '_BYTES'] = toBytes(exports[k]);

src/core/index.js

@@ -21,47 +21,12 @@ exports.TransactionQueue = require('./transactionqueue').TransactionQueue;
 exports.convertBase = require('./baseconverter');
 
 exports._test = {
+  IOUValue: require('./iouvalue').IOUValue,
   Log: require('./log'),
   PathFind: require('./pathfind').PathFind,
   TransactionManager: require('./transactionmanager').TransactionManager,
-  RangeSet: require('./rangeset').RangeSet
+  RangeSet: require('./rangeset').RangeSet,
+  HashPrefixes: require('./hashprefixes')
 };
 
-// Important: We do not guarantee any specific version of SJCL or for any
-// specific features to be included. The version and configuration may change at
-// any time without warning.
-//
-// However, for programs that are tied to a specific version of ripple.js like
-// the official client, it makes sense to expose the SJCL instance so we don't
-// have to include it twice.
-exports.sjcl = require('./utils').sjcl;
-exports.Wallet = require('ripple-wallet-generator')({sjcl: exports.sjcl});
 exports.types = require('./serializedtypes');
-
-// camelCase to under_scored API conversion
-function attachUnderscored(name) {
-  const o = exports[name];
-
-  Object.keys(o.prototype).forEach(function(key) {
-    const UPPERCASE = /([A-Z]{1})[a-z]+/g;
-
-    if (!UPPERCASE.test(key)) {
-      return;
-    }
-
-    const underscored = key.replace(UPPERCASE, function(c) {
-      return '_' + c.toLowerCase();
-    });
-
-    o.prototype[underscored] = o.prototype[key];
-  });
-}
-
-['Remote',
- 'Request',
- 'Transaction',
- 'Account',
- 'Server'
-].forEach(attachUnderscored);
-
-// vim:sw=2:sts=2:ts=8:et

src/core/keypair.js

@@ -1,102 +0,0 @@
-'use strict';
-
-/*eslint new-cap: 1*/
-
-var sjcl = require('./utils').sjcl;
-
-var UInt160 = require('./uint160').UInt160;
-var UInt256 = require('./uint256').UInt256;
-var Base = require('./base').Base;
-
-function KeyPair() {
-  this._curve = sjcl.ecc.curves.k256;
-  this._secret = null;
-  this._pubkey = null;
-}
-
-KeyPair.from_bn_secret = function(j) {
-  return (j instanceof this) ? j.clone() : (new this()).parse_bn_secret(j);
-};
-
-KeyPair.prototype.parse_bn_secret = function(j) {
-  this._secret = new sjcl.ecc.ecdsa.secretKey(sjcl.ecc.curves.k256, j);
-  return this;
-};
-
-/**
- * @private
- *
- * @return {sjcl.ecc.ecdsa.publicKey} public key
- */
-KeyPair.prototype._pub = function() {
-  var curve = this._curve;
-
-  if (!this._pubkey && this._secret) {
-    var exponent = this._secret._exponent;
-
-    this._pubkey = new sjcl.ecc.ecdsa.publicKey(curve, curve.G.mult(exponent));
-  }
-
-  return this._pubkey;
-};
-
-/**
- * @private
- *
- * @return {sjcl.bitArray} public key bits in compressed form
- */
-KeyPair.prototype._pub_bits = function() {
-  var pub = this._pub();
-
-  if (!pub) {
-    return null;
-  }
-
-  var point = pub._point, y_even = point.y.mod(2).equals(0);
-
-  return sjcl.bitArray.concat(
-    [sjcl.bitArray.partial(8, y_even ? 0x02 : 0x03)],
-    point.x.toBits(this._curve.r.bitLength())
-  );
-};
-
-/**
- * @return {String} public key bytes in compressed form, hex encoded.
- */
-KeyPair.prototype.to_hex_pub = function() {
-  var bits = this._pub_bits();
-
-  if (!bits) {
-    return null;
-  }
-
-  return sjcl.codec.hex.fromBits(bits).toUpperCase();
-};
-
-function sha256_ripemd160(bits) {
-  return sjcl.hash.ripemd160.hash(sjcl.hash.sha256.hash(bits));
-}
-
-KeyPair.prototype.get_address = function() {
-  var bits = this._pub_bits();
-
-  if (!bits) {
-    return null;
-  }
-
-  var hash = sha256_ripemd160(bits);
-
-  var address = UInt160.from_bits(hash);
-  address.set_version(Base.VER_ACCOUNT_ID);
-  return address;
-};
-
-KeyPair.prototype.sign = function(hash) {
-  var PARANOIA_256_BITS = 6; // sjcl constant for ensuring 256 bits of entropy
-  hash = UInt256.from_json(hash);
-  var sig = this._secret.sign(hash.to_bits(), PARANOIA_256_BITS);
-  sig = this._secret.canonicalizeSignature(sig);
-  return this._secret.encodeDER(sig);
-};
-
-exports.KeyPair = KeyPair;

src/core/ledger.js

@@ -1,19 +1,19 @@
-/* eslint-disable valid-jsdoc */
 'use strict';
-var Transaction = require('./transaction').Transaction;
-var SHAMap = require('./shamap').SHAMap;
-var SHAMapTreeNode = require('./shamap').SHAMapTreeNode;
-var SerializedObject = require('./serializedobject').SerializedObject;
-var stypes = require('./serializedtypes');
-var UInt160 = require('./uint160').UInt160;
-var Currency = require('./currency').Currency;
+const BigNumber = require('bignumber.js');
+const Transaction = require('./transaction').Transaction;
+const SHAMap = require('./shamap').SHAMap;
+const SHAMapTreeNode = require('./shamap').SHAMapTreeNode;
+const SerializedObject = require('./serializedobject').SerializedObject;
+const stypes = require('./serializedtypes');
+const UInt160 = require('./uint160').UInt160;
+const Currency = require('./currency').Currency;
 
 function Ledger() {
   this.ledger_json = {};
 }
 
 Ledger.from_json = function(v) {
-  var ledger = new Ledger();
+  const ledger = new Ledger();
   ledger.parse_json(v);
   return ledger;
 };
@@ -23,14 +23,13 @@ Ledger.space = require('./ledgerspaces');
 /**
  * Generate the key for an AccountRoot entry.
  *
- * @param {String|UInt160} account Ripple Account
+ * @param {String|UInt160} accountArg - Ripple Account
  * @return {UInt256}
  */
 Ledger.calcAccountRootEntryHash =
-Ledger.prototype.calcAccountRootEntryHash = function(account) {
-  account = UInt160.from_json(account);
-
-  var index = new SerializedObject();
+Ledger.prototype.calcAccountRootEntryHash = function(accountArg) {
+  const account = UInt160.from_json(accountArg);
+  const index = new SerializedObject();
 
   index.append([0, Ledger.space.account.charCodeAt(0)]);
   index.append(account.to_bytes());
@@ -41,17 +40,15 @@ Ledger.prototype.calcAccountRootEntryHash = function(account) {
 /**
  * Generate the key for an Offer entry.
  *
- * @param {String|UInt160} account Ripple Account
- * @param {Number} sequence Sequence number of the OfferCreate transaction
+ * @param {String|UInt160} accountArg - Ripple Account
+ * @param {Number} sequence - Sequence number of the OfferCreate transaction
  *   that instantiated this offer.
  * @return {UInt256}
  */
 Ledger.calcOfferEntryHash =
-Ledger.prototype.calcOfferEntryHash = function(account, sequence) {
-  account = UInt160.from_json(account);
-  sequence = parseInt(sequence, 10);
-
-  var index = new SerializedObject();
+Ledger.prototype.calcOfferEntryHash = function(accountArg, sequence) {
+  const account = UInt160.from_json(accountArg);
+  const index = new SerializedObject();
 
   index.append([0, Ledger.space.offer.charCodeAt(0)]);
   index.append(account.to_bytes());
@@ -65,17 +62,17 @@ Ledger.prototype.calcOfferEntryHash = function(account, sequence) {
  *
  * The ordering of the two account parameters does not matter.
  *
- * @param {String|UInt160} account1 First Ripple Account
- * @param {String|UInt160} account2 Second Ripple Account
- * @param {String|Currency} currency The currency code
+ * @param {String|UInt160} _account1 - First Ripple Account
+ * @param {String|UInt160} _account2 - Second Ripple Account
+ * @param {String|Currency} _currency - The currency code
  * @return {UInt256}
  */
 Ledger.calcRippleStateEntryHash =
 Ledger.prototype.calcRippleStateEntryHash = function(
-    account1, account2, currency) {
-  currency = Currency.from_json(currency);
-  account1 = UInt160.from_json(account1);
-  account2 = UInt160.from_json(account2);
+    _account1, _account2, _currency) {
+  const currency = Currency.from_json(_currency);
+  const account1 = UInt160.from_json(_account1);
+  const account2 = UInt160.from_json(_account2);
 
   if (!account1.is_valid()) {
     throw new Error('Invalid first account');
@@ -87,18 +84,14 @@ Ledger.prototype.calcRippleStateEntryHash = function(
     throw new Error('Invalid currency');
   }
 
-  // The lower ID has to come first
-  if (account1.to_bn().greaterEquals(account2.to_bn())) {
-    var tmp = account2;
-    account2 = account1;
-    account1 = tmp;
-  }
-
-  var index = new SerializedObject();
+  const swap = account1.greater_than(account2);
+  const lowAccount = swap ? account2 : account1;
+  const highAccount = swap ? account1 : account2;
+  const index = new SerializedObject();
 
   index.append([0, Ledger.space.rippleState.charCodeAt(0)]);
-  index.append(account1.to_bytes());
-  index.append(account2.to_bytes());
+  index.append(lowAccount.to_bytes());
+  index.append(highAccount.to_bytes());
   index.append(currency.to_bytes());
 
   return index.hash();
@@ -109,13 +102,13 @@ Ledger.prototype.parse_json = function(v) {
 };
 
 Ledger.prototype.calc_tx_hash = function() {
-  var tx_map = new SHAMap();
+  const tx_map = new SHAMap();
 
   this.ledger_json.transactions.forEach(function(tx_json) {
-    var tx = Transaction.from_json(tx_json);
-    var meta = SerializedObject.from_json(tx_json.metaData);
+    const tx = Transaction.from_json(tx_json);
+    const meta = SerializedObject.from_json(tx_json.metaData);
 
-    var data = new SerializedObject();
+    const data = new SerializedObject();
     stypes.VariableLength.serialize(data, tx.serialize().to_hex());
     stypes.VariableLength.serialize(data, meta.to_hex());
     tx_map.add_item(tx.hash(), data, SHAMapTreeNode.TYPE_TRANSACTION_MD);
@@ -125,22 +118,23 @@ Ledger.prototype.calc_tx_hash = function() {
 };
 
 /**
-* @param options .sanity_test {Boolean}
-* @return hash of shamap
+* @param {Object} options - object
 *
-*   If `true`, will serialize each accountState item to binary and then back to
-*   json before finally serializing for hashing. This is mostly to expose any
-*   issues with ripple-lib's binary <--> json codecs.
+* @param {Boolean} [options.sanity_test=false] - If `true`, will serialize each
+*   accountState item to binary and then back to json before finally
+*   serializing for hashing. This is mostly to expose any issues with
+*   ripple-lib's binary <--> json codecs.
 *
+* @return {UInt256} - hash of shamap
 */
 Ledger.prototype.calc_account_hash = function(options) {
-  var account_map = new SHAMap();
-  var erred;
+  const account_map = new SHAMap();
+  let erred;
 
   this.ledger_json.accountState.forEach(function(le) {
-    var data = SerializedObject.from_json(le);
+    let data = SerializedObject.from_json(le);
 
-    var json;
+    let json;
     if (options && options.sanity_test) {
       try {
         json = data.to_json();
@@ -163,4 +157,24 @@ Ledger.prototype.calc_account_hash = function(options) {
   return account_map.hash();
 };
 
+// see rippled Ledger::updateHash()
+Ledger.calculateLedgerHash =
+Ledger.prototype.calculateLedgerHash = function(ledgerHeader) {
+  const so = new SerializedObject();
+  const prefix = 0x4C575200;
+  const totalCoins = (new BigNumber(ledgerHeader.total_coins)).toString(16);
+
+  stypes.Int32.serialize(so, Number(ledgerHeader.ledger_index));
+  stypes.Int64.serialize(so, totalCoins);
+  stypes.Hash256.serialize(so, ledgerHeader.parent_hash);
+  stypes.Hash256.serialize(so, ledgerHeader.transaction_hash);
+  stypes.Hash256.serialize(so, ledgerHeader.account_hash);
+  stypes.Int32.serialize(so, ledgerHeader.parent_close_time);
+  stypes.Int32.serialize(so, ledgerHeader.close_time);
+  stypes.Int8.serialize(so, ledgerHeader.close_time_resolution);
+  stypes.Int8.serialize(so, ledgerHeader.close_flags);
+
+  return so.hash(prefix).to_hex();
+};
+
 exports.Ledger = Ledger;

src/core/orderbook.js

@@ -24,8 +24,15 @@ const OrderBookUtils = require('./orderbookutils');
 const log = require('./log').internal.sub('orderbook');
 const IOUValue = require('./iouvalue').IOUValue;
 
-function assertValidNumber(number, message) {
-  assert(!_.isNull(number) && !isNaN(number), message);
+function _sortOffers(a, b) {
+  const aQuality = OrderBookUtils.getOfferQuality(a, this._currencyGets);
+  const bQuality = OrderBookUtils.getOfferQuality(b, this._currencyGets);
+
+  return aQuality._value.comparedTo(bQuality._value);
+}
+
+function _sortOffersQuick(a, b) {
+  return a.qualityHex.localeCompare(b.qualityHex);
 }
 
 /**
@@ -36,11 +43,13 @@ function assertValidNumber(number, message) {
  * @param {String} bid currency
  * @param {String} bid issuer
  * @param {String} orderbook key
+ * @param {Boolean} fire 'model' event after receiving transaction
+                    only once in 10 seconds
  */
 
 function OrderBook(remote,
-                   currencyGets, issuerGets, currencyPays, issuerPays,
-                   key) {
+                   currencyGets, issuerGets, currencyPays, issuerPays, key
+) {
   EventEmitter.call(this);
 
   const self = this;
@@ -61,6 +70,8 @@ function OrderBook(remote,
   this._ownerFundsUnadjusted = {};
   this._ownerFunds = {};
   this._ownerOffersTotal = {};
+  this._validAccounts = {};
+  this._validAccountsCount = 0;
 
   // We consider ourselves synced if we have a current
   // copy of the offers, we are online and subscribed to updates
@@ -73,13 +84,44 @@ function OrderBook(remote,
   // books that we must keep track of to compute autobridged offers
   this._legOneBook = null;
   this._legTwoBook = null;
+  this._gotOffersFromLegOne = false;
+  this._gotOffersFromLegTwo = false;
+
+  this.sortOffers = this._currencyGets.has_interest() ?
+    _sortOffers.bind(this) : _sortOffersQuick;
+
+  this.notifyDirectOffersChanged =
+    _.debounce(
+      this.notifyDirectOffersChangedInternal,
+      OrderBook.NOTIFY_TIMEOUT,
+      {maxWait: OrderBook.NOTIFY_MAXWAIT});
 
   this._isAutobridgeable = !this._currencyGets.is_native()
     && !this._currencyPays.is_native();
 
-  function computeAutobridgedOffersWrapper() {
-    self.computeAutobridgedOffers();
-    self.mergeDirectAndAutobridgedBooks();
+  this._autobridgeThrottleTimeMultiplier = 1;
+  this.createDebouncedOffersWrapper();
+
+  function computeAutobridgedOffersWrapperOne() {
+    self._gotOffersFromLegOne = true;
+    self.computeAutobridgedOffersThrottled();
+  }
+
+  function computeAutobridgedOffersWrapperTwo() {
+    self._gotOffersFromLegTwo = true;
+    self.computeAutobridgedOffersThrottled();
+  }
+
+  function onDisconnect() {
+    self.resetCache();
+    self._gotOffersFromLegOne = false;
+    self._gotOffersFromLegTwo = false;
+    if (!self._destroyed) {
+      self._remote.once('disconnect', onDisconnect);
+      self._remote.once('connect', function() {
+        self.subscribe();
+      });
+    }
   }
 
   if (this._isAutobridgeable) {
@@ -89,15 +131,15 @@ function OrderBook(remote,
       issuer_pays: issuerPays
     });
 
-    this._legOneBook.on('model', computeAutobridgedOffersWrapper);
-
     this._legTwoBook = remote.createOrderBook({
       currency_gets: currencyGets,
       issuer_gets: issuerGets,
       currency_pays: 'XRP'
     });
+  }
 
-    this._legTwoBook.on('model', computeAutobridgedOffersWrapper);
+  function updateFundedAmountsWrapper(transaction) {
+    self.updateFundedAmounts(transaction);
   }
 
   function listenersModified(action, event) {
@@ -107,7 +149,16 @@ function OrderBook(remote,
       switch (action) {
         case 'add':
           if (++self._listeners === 1) {
+            self._shouldSubscribe = true;
             self.subscribe();
+
+            self._remote.on('transaction', updateFundedAmountsWrapper);
+            self._remote.once('disconnect', onDisconnect);
+
+            if (self._isAutobridgeable) {
+              self._legOneBook.on('model', computeAutobridgedOffersWrapperOne);
+              self._legTwoBook.on('model', computeAutobridgedOffersWrapperTwo);
+            }
           }
           break;
         case 'remove':
@@ -119,10 +170,6 @@ function OrderBook(remote,
     }
   }
 
-  function updateFundedAmountsWrapper(transaction) {
-    self.updateFundedAmounts(transaction);
-  }
-
   this.on('newListener', function(event) {
     listenersModified('add', event);
   });
@@ -131,23 +178,21 @@ function OrderBook(remote,
     listenersModified('remove', event);
   });
 
-  this._remote.on('transaction', updateFundedAmountsWrapper);
-
   this.on('unsubscribe', function() {
     self.resetCache();
 
     self._remote.removeListener('transaction', updateFundedAmountsWrapper);
-  });
+    self._remote.removeListener('disconnect', onDisconnect);
 
-  this._remote.once('prepare_subscribe', function() {
-    self.subscribe();
-  });
+    self._gotOffersFromLegOne = false;
+    self._gotOffersFromLegTwo = false;
 
-  this._remote.on('disconnect', function() {
-    self.resetCache();
-    self._remote.once('prepare_subscribe', function() {
-      self.subscribe();
-    });
+    if (self._isAutobridgeable) {
+      self._legOneBook.removeListener('model',
+        computeAutobridgedOffersWrapperOne);
+      self._legTwoBook.removeListener('model',
+        computeAutobridgedOffersWrapperTwo);
+    }
   });
 
   return this;
@@ -165,7 +210,21 @@ OrderBook.EVENTS = [
   'offer_changed', 'offer_funds_changed'
 ];
 
-OrderBook.DEFAULT_TRANSFER_RATE = 1000000000;
+OrderBook.DEFAULT_TRANSFER_RATE = new IOUValue(1000000000);
+
+OrderBook.NOTIFY_TIMEOUT = 100;
+
+OrderBook.NOTIFY_MAXWAIT = 250;
+
+OrderBook.AUTOBRIDGE_CALCULATE_THROTTLE_TIME = 1000;
+
+OrderBook.AUTOBRIDGE_CALCULATE_DEBOUNCE_TIME = 250;
+
+OrderBook.AUTOBRIDGE_CALCULATE_DEBOUNCE_MAXWAIT = 500;
+
+OrderBook.ZERO_NATIVE_AMOUNT = Amount.from_json('0');
+
+OrderBook.ZERO_NORMALIZED_AMOUNT = OrderBookUtils.normalizeAmount('0');
 
 /**
  * Normalize offers from book_offers and transaction stream
@@ -192,18 +251,20 @@ OrderBook.offerRewrite = function(offer) {
   result.Flags = result.Flags || 0;
   result.OwnerNode = result.OwnerNode || new Array(16 + 1).join('0');
   result.BookNode = result.BookNode || new Array(16 + 1).join('0');
+  result.qualityHex = result.BookDirectory.slice(-16);
 
   return result;
 };
 
 /**
  * Initialize orderbook. Get orderbook offers and subscribe to transactions
+ * @api private
  */
 
 OrderBook.prototype.subscribe = function() {
   const self = this;
 
-  if (!this._shouldSubscribe) {
+  if (!this._shouldSubscribe || this._destroyed) {
     return;
   }
 
@@ -216,7 +277,7 @@ OrderBook.prototype.subscribe = function() {
       self.requestTransferRate(callback);
     },
     function(callback) {
-      self.requestOffers(callback);
+      self.requestOffers(callback, true);
     },
     function(callback) {
       self.subscribeTransactions(callback);
@@ -229,6 +290,7 @@ OrderBook.prototype.subscribe = function() {
 /**
  * Unhook event listeners and prevent ripple-lib from further work on this
  * orderbook. There is no more orderbook stream, so "unsubscribe" is nominal
+ * @api private
  */
 
 OrderBook.prototype.unsubscribe = function() {
@@ -250,33 +312,75 @@ OrderBook.prototype.unsubscribe = function() {
   this.emit('unsubscribe');
 };
 
+/**
+ * After that you can't use this object.
+ */
+
+OrderBook.prototype.destroy = function() {
+  this._destroyed = true;
+  if (this._subscribed) {
+    this.unsubscribe();
+  }
+
+  if (this._remote._books.hasOwnProperty(this._key)) {
+    delete this._remote._books[this._key];
+  }
+
+  if (this._isAutobridgeable) {
+    this._legOneBook.destroy();
+    this._legTwoBook.destroy();
+  }
+};
+
 /**
  * Request orderbook entries from server
  *
  * @param {Function} callback
  */
 
-OrderBook.prototype.requestOffers = function(callback=function() {}) {
+OrderBook.prototype.requestOffers = function(callback = function() {},
+  internal = false) {
   const self = this;
 
+  if (!this._remote.isConnected()) {
+    // do not make request if not online.
+    // that requests will be queued and
+    // eventually all of them will fire back
+    return undefined;
+  }
+
   if (!this._shouldSubscribe) {
-    return callback(new Error('Should not request offers'));
+    callback(new Error('Should not request offers'));
+    return undefined;
   }
 
   if (this._remote.trace) {
     log.info('requesting offers', this._key);
   }
 
+  if (this._isAutobridgeable && !internal) {
+    this._gotOffersFromLegOne = false;
+    this._gotOffersFromLegTwo = false;
+
+    this._legOneBook.requestOffers();
+    this._legTwoBook.requestOffers();
+  }
+
+
   function handleOffers(res) {
+    if (self._destroyed) {
+      return;
+    }
+
     if (!Array.isArray(res.offers)) {
       // XXX What now?
-      return callback(new Error('Invalid response'));
+      callback(new Error('Invalid response'));
+      return;
     }
 
     if (self._remote.trace) {
       log.info('requested offers', self._key, 'offers: ' + res.offers.length);
     }
-
     self.setOffers(res.offers);
     self.notifyDirectOffersChanged();
 
@@ -331,8 +435,10 @@ OrderBook.prototype.requestTransferRate = function(callback) {
 
     // When transfer rate is not explicitly set on account, it implies the
     // default transfer rate
-    self._issuerTransferRate = info.account_data.TransferRate ||
-                               OrderBook.DEFAULT_TRANSFER_RATE;
+    self._issuerTransferRate =
+      info.account_data.TransferRate ?
+        new IOUValue(info.account_data.TransferRate) :
+        OrderBook.DEFAULT_TRANSFER_RATE;
 
     callback(null, self._issuerTransferRate);
   }
@@ -392,7 +498,7 @@ OrderBook.prototype.subscribeTransactions = function(callback) {
  * books, an additional merge step is also performed
  */
 
-OrderBook.prototype.notifyDirectOffersChanged = function() {
+OrderBook.prototype.notifyDirectOffersChangedInternal = function() {
   if (this._isAutobridgeable) {
     this.mergeDirectAndAutobridgedBooks();
   } else {
@@ -409,6 +515,12 @@ OrderBook.prototype.resetCache = function() {
   this._ownerOffersTotal = {};
   this._offerCounts = {};
   this._synced = false;
+  this._offers = [];
+
+  if (this._validAccountsCount > 3000) {
+    this._validAccounts = {};
+    this._validAccountsCount = 0;
+  }
 };
 
 /**
@@ -418,7 +530,6 @@ OrderBook.prototype.resetCache = function() {
  */
 
 OrderBook.prototype.hasOwnerFunds = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   return this._ownerFunds[account] !== undefined;
 };
 
@@ -430,7 +541,6 @@ OrderBook.prototype.hasOwnerFunds = function(account) {
  */
 
 OrderBook.prototype.setOwnerFunds = function(account, fundedAmount) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   assert(!isNaN(fundedAmount), 'Funded amount is invalid');
 
   this._ownerFundsUnadjusted[account] = fundedAmount;
@@ -447,11 +557,10 @@ OrderBook.prototype.setOwnerFunds = function(account, fundedAmount) {
 
 OrderBook.prototype.applyTransferRate = function(balance) {
   assert(!isNaN(balance), 'Balance is invalid');
-  assertValidNumber(this._issuerTransferRate, 'Transfer rate is invalid');
 
   const adjustedBalance = (new IOUValue(balance))
-  .divide(new IOUValue(this._issuerTransferRate))
-  .multiply(new IOUValue(OrderBook.DEFAULT_TRANSFER_RATE)).toString();
+  .divide(this._issuerTransferRate)
+  .multiply(OrderBook.DEFAULT_TRANSFER_RATE).toString();
 
   return adjustedBalance;
 };
@@ -464,7 +573,6 @@ OrderBook.prototype.applyTransferRate = function(balance) {
  */
 
 OrderBook.prototype.getOwnerFunds = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   if (this.hasOwnerFunds(account)) {
     if (this._currencyGets.is_native()) {
       return Amount.from_json(this._ownerFunds[account]);
@@ -481,7 +589,6 @@ OrderBook.prototype.getOwnerFunds = function(account) {
  */
 
 OrderBook.prototype.getUnadjustedOwnerFunds = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   return this._ownerFundsUnadjusted[account];
 };
 
@@ -492,7 +599,6 @@ OrderBook.prototype.getUnadjustedOwnerFunds = function(account) {
  */
 
 OrderBook.prototype.deleteOwnerFunds = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   this._ownerFunds[account] = undefined;
 };
 
@@ -504,7 +610,6 @@ OrderBook.prototype.deleteOwnerFunds = function(account) {
  */
 
 OrderBook.prototype.getOwnerOfferCount = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   return this._offerCounts[account] || 0;
 };
 
@@ -516,7 +621,6 @@ OrderBook.prototype.getOwnerOfferCount = function(account) {
  */
 
 OrderBook.prototype.incrementOwnerOfferCount = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   const result = (this._offerCounts[account] || 0) + 1;
   this._offerCounts[account] = result;
   return result;
@@ -531,7 +635,6 @@ OrderBook.prototype.incrementOwnerOfferCount = function(account) {
  */
 
 OrderBook.prototype.decrementOwnerOfferCount = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   const result = (this._offerCounts[account] || 1) - 1;
   this._offerCounts[account] = result;
 
@@ -552,8 +655,6 @@ OrderBook.prototype.decrementOwnerOfferCount = function(account) {
  */
 
 OrderBook.prototype.addOwnerOfferTotal = function(account, amount) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
-
   const previousAmount = this.getOwnerOfferTotal(account);
   const currentAmount = previousAmount.add(Amount.from_json(amount));
 
@@ -572,14 +673,12 @@ OrderBook.prototype.addOwnerOfferTotal = function(account, amount) {
  */
 
 OrderBook.prototype.subtractOwnerOfferTotal = function(account, amount) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
-
   const previousAmount = this.getOwnerOfferTotal(account);
   const newAmount = previousAmount.subtract(Amount.from_json(amount));
+
   this._ownerOffersTotal[account] = newAmount;
 
   assert(!newAmount.is_negative(), 'Offer total cannot be negative');
-
   return newAmount;
 };
 
@@ -591,15 +690,14 @@ OrderBook.prototype.subtractOwnerOfferTotal = function(account, amount) {
  */
 
 OrderBook.prototype.getOwnerOfferTotal = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   const amount = this._ownerOffersTotal[account];
   if (amount) {
     return amount;
   }
   if (this._currencyGets.is_native()) {
-    return Amount.from_json('0');
+    return OrderBook.ZERO_NATIVE_AMOUNT.clone();
   }
-  return OrderBookUtils.normalizeAmount('0');
+  return OrderBook.ZERO_NORMALIZED_AMOUNT.clone();
 };
 
 /**
@@ -610,11 +708,10 @@ OrderBook.prototype.getOwnerOfferTotal = function(account) {
  */
 
 OrderBook.prototype.resetOwnerOfferTotal = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
   if (this._currencyGets.is_native()) {
-    this._ownerOffersTotal[account] = Amount.from_json('0');
+    this._ownerOffersTotal[account] = OrderBook.ZERO_NATIVE_AMOUNT.clone();
   } else {
-    this._ownerOffersTotal[account] = OrderBookUtils.normalizeAmount('0');
+    this._ownerOffersTotal[account] = OrderBook.ZERO_NORMALIZED_AMOUNT.clone();
   }
 };
 
@@ -632,17 +729,18 @@ OrderBook.prototype.resetOwnerOfferTotal = function(account) {
 OrderBook.prototype.setOfferFundedAmount = function(offer) {
   assert.strictEqual(typeof offer, 'object', 'Offer is invalid');
 
+  const takerGets = Amount.from_json(offer.TakerGets);
   const fundedAmount = this.getOwnerFunds(offer.Account);
   const previousOfferSum = this.getOwnerOfferTotal(offer.Account);
-  const currentOfferSum = previousOfferSum.add(
-    Amount.from_json(offer.TakerGets));
+  const currentOfferSum = previousOfferSum.add(takerGets);
 
   offer.owner_funds = this.getUnadjustedOwnerFunds(offer.Account);
 
-  offer.is_fully_funded = fundedAmount.compareTo(currentOfferSum) >= 0;
+  offer.is_fully_funded = fundedAmount.is_comparable(currentOfferSum) &&
+    fundedAmount.compareTo(currentOfferSum) >= 0;
 
   if (offer.is_fully_funded) {
-    offer.taker_gets_funded = Amount.from_json(offer.TakerGets).to_text();
+    offer.taker_gets_funded = takerGets.to_text();
     offer.taker_pays_funded = Amount.from_json(offer.TakerPays).to_text();
   } else if (previousOfferSum.compareTo(fundedAmount) < 0) {
     offer.taker_gets_funded = fundedAmount.subtract(previousOfferSum).to_text();
@@ -698,7 +796,11 @@ OrderBook.prototype.parseAccountBalanceFromNode = function(node) {
   }
 
   assert(!isNaN(result.balance), 'node has an invalid balance');
-  assert(UInt160.is_valid(result.account), 'node has an invalid account');
+  if (this._validAccounts[result.Account] === undefined) {
+    assert(UInt160.is_valid(result.account), 'node has an invalid account');
+    this._validAccounts[result.Account] = true;
+    this._validAccountsCount++;
+  }
 
   return result;
 };
@@ -786,6 +888,7 @@ OrderBook.prototype.updateFundedAmounts = function(transaction) {
   });
 };
 
+
 /**
  * Update offers' funded amount with their owner's funds
  *
@@ -793,10 +896,15 @@ OrderBook.prototype.updateFundedAmounts = function(transaction) {
  */
 
 OrderBook.prototype.updateOwnerOffersFundedAmount = function(account) {
-  assert(UInt160.is_valid(account), 'Account is invalid');
+  // assert(UInt160.is_valid(account), 'Account is invalid');
 
   const self = this;
 
+  if (!this.hasOwnerFunds(account)) {
+    // We are only updating owner funds that are already cached
+    return;
+  }
+
   if (this._remote.trace) {
     const ownerFunds = this.getOwnerFunds(account);
     log.info('updating offer funds', this._key, account,
@@ -848,7 +956,7 @@ OrderBook.prototype.updateOwnerOffersFundedAmount = function(account) {
 OrderBook.prototype.notify = function(transaction) {
   const self = this;
 
-  if (!(this._subscribed && this._synced)) {
+  if (!(this._subscribed && this._synced) || this._destroyed) {
     return;
   }
 
@@ -884,6 +992,12 @@ OrderBook.prototype.notify = function(transaction) {
   function handleNode(node) {
     switch (node.nodeType) {
       case 'DeletedNode':
+        if (self._validAccounts[node.fields.Account] === undefined) {
+          assert(UInt160.is_valid(node.fields.Account),
+            'node has an invalid account');
+          self._validAccounts[node.fields.Account] = true;
+          self._validAccountsCount++;
+        }
         self.deleteOffer(node, isOfferCancel);
 
         // We don't want to count an OfferCancel as a trade
@@ -894,6 +1008,12 @@ OrderBook.prototype.notify = function(transaction) {
         break;
 
       case 'ModifiedNode':
+        if (self._validAccounts[node.fields.Account] === undefined) {
+          assert(UInt160.is_valid(node.fields.Account),
+            'node has an invalid account');
+          self._validAccounts[node.fields.Account] = true;
+          self._validAccountsCount++;
+        }
         self.modifyOffer(node);
 
         takerGetsTotal = takerGetsTotal
@@ -906,6 +1026,12 @@ OrderBook.prototype.notify = function(transaction) {
         break;
 
       case 'CreatedNode':
+        if (self._validAccounts[node.fields.Account] === undefined) {
+          assert(UInt160.is_valid(node.fields.Account),
+            'node has an invalid account');
+          self._validAccounts[node.fields.Account] = true;
+          self._validAccountsCount++;
+        }
         // rippled does not set owner_funds if the order maker is the issuer
         // because the value would be infinite
         const fundedAmount = transactionOwnerFunds !== undefined ?
@@ -919,7 +1045,9 @@ OrderBook.prototype.notify = function(transaction) {
   _.each(affectedNodes, handleNode);
 
   this.emit('transaction', transaction);
+
   this.notifyDirectOffersChanged();
+
   if (!takerGetsTotal.is_zero()) {
     this.emit('trade', takerPaysTotal, takerGetsTotal);
   }
@@ -951,17 +1079,27 @@ OrderBook.prototype.insertOffer = function(node) {
 
   const originalLength = this._offers.length;
 
-  for (let i = 0; i < originalLength; i++) {
-    const quality = OrderBookUtils.getOfferQuality(offer, this._currencyGets);
-    const existingOfferQuality = OrderBookUtils.getOfferQuality(
-      this._offers[i],
-      this._currencyGets
-    );
+  if (!this._currencyGets.has_interest()) {
+    // use fast path
+    for (let i = 0; i < originalLength; i++) {
+      if (offer.qualityHex <= this._offers[i].qualityHex) {
+        this._offers.splice(i, 0, offer);
+        break;
+      }
+    }
+  } else {
+    for (let i = 0; i < originalLength; i++) {
+      const quality = OrderBookUtils.getOfferQuality(offer, this._currencyGets);
+      const existingOfferQuality = OrderBookUtils.getOfferQuality(
+        this._offers[i],
+        this._currencyGets
+      );
 
-    if (quality.compareTo(existingOfferQuality) <= 0) {
-      this._offers.splice(i, 0, offer);
+      if (quality.compareTo(existingOfferQuality) <= 0) {
+        this._offers.splice(i, 0, offer);
 
-      break;
+        break;
+      }
     }
   }
 
@@ -1067,28 +1205,34 @@ OrderBook.prototype.deleteOffer = function(node, isOfferCancel) {
 OrderBook.prototype.setOffers = function(offers) {
   assert(Array.isArray(offers), 'Offers is not an array');
 
-  const self = this;
-
   this.resetCache();
 
-  const newOffers = _.map(offers, function(rawOffer) {
-    const offer = OrderBook.offerRewrite(rawOffer);
+  let i = -1;
+  let offer;
+  const l = offers.length;
 
-    if (offer.hasOwnProperty('owner_funds')) {
+  while (++i < l) {
+    offer = OrderBook.offerRewrite(offers[i]);
+
+    if (this._validAccounts[offer.Account] === undefined) {
+      assert(UInt160.is_valid(offer.Account), 'Account is invalid');
+      this._validAccounts[offer.Account] = true;
+      this._validAccountsCount++;
+    }
+    if (offer.owner_funds !== undefined) {
       // The first offer of each owner from book_offers contains owner balance
       // of offer's output
-      self.setOwnerFunds(offer.Account, offer.owner_funds);
+      this.setOwnerFunds(offer.Account, offer.owner_funds);
     }
 
-    self.incrementOwnerOfferCount(offer.Account);
+    this.incrementOwnerOfferCount(offer.Account);
 
-    self.setOfferFundedAmount(offer);
-    self.addOwnerOfferTotal(offer.Account, offer.TakerGets);
+    this.setOfferFundedAmount(offer);
+    this.addOwnerOfferTotal(offer.Account, offer.TakerGets);
+    offers[i] = offer;
+  }
 
-    return offer;
-  });
-
-  this._offers = newOffers;
+  this._offers = offers;
   this._synced = true;
 };
 
@@ -1191,6 +1335,14 @@ OrderBook.prototype.computeAutobridgedOffers = function() {
   assert(!this._currencyGets.is_native() && !this._currencyPays.is_native(),
     'Autobridging is only for IOU:IOU orderbooks');
 
+  if (this._destroyed) {
+    return;
+  }
+
+  if (!this._gotOffersFromLegOne || !this._gotOffersFromLegTwo) {
+    return;
+  }
+
   const autobridgeCalculator = new AutobridgeCalculator(
     this._currencyGets,
     this._currencyPays,
@@ -1203,6 +1355,33 @@ OrderBook.prototype.computeAutobridgedOffers = function() {
   this._offersAutobridged = autobridgeCalculator.calculate();
 };
 
+OrderBook.prototype.computeAutobridgedOffersWrapper = function() {
+  const startTime = Date.now();
+  this.computeAutobridgedOffers();
+  this.mergeDirectAndAutobridgedBooks();
+  const lasted = (Date.now() - startTime);
+
+  const newMult =
+    Math.floor(lasted * 2 / OrderBook.AUTOBRIDGE_CALCULATE_THROTTLE_TIME) + 1;
+  if (newMult !== this._autobridgeThrottleTimeMultiplier) {
+    this._autobridgeThrottleTimeMultiplier = newMult;
+    this.createDebouncedOffersWrapper();
+  }
+};
+
+OrderBook.prototype.createDebouncedOffersWrapper = function() {
+  const m = this._autobridgeThrottleTimeMultiplier;
+  this.computeAutobridgedOffersThrottled =
+    _.debounce(
+      _.throttle(
+        this.computeAutobridgedOffersWrapper,
+        OrderBook.AUTOBRIDGE_CALCULATE_THROTTLE_TIME * m,
+        {leading: true, trailing: true}),
+      OrderBook.AUTOBRIDGE_CALCULATE_DEBOUNCE_TIME,
+      {maxWait: OrderBook.AUTOBRIDGE_CALCULATE_DEBOUNCE_MAXWAIT});
+};
+
+
 /**
  * Merge direct and autobridged offers into a combined orderbook
  *
@@ -1210,22 +1389,24 @@ OrderBook.prototype.computeAutobridgedOffers = function() {
  */
 
 OrderBook.prototype.mergeDirectAndAutobridgedBooks = function() {
-  const self = this;
+
+  if (this._destroyed) {
+    return;
+  }
 
   if (_.isEmpty(this._offers) && _.isEmpty(this._offersAutobridged)) {
-    // still emit empty offers list to indicate that load is completed
-    this.emit('model', []);
+    if (this._synced && this._gotOffersFromLegOne &&
+      this._gotOffersFromLegTwo) {
+      // emit empty model to indicate to listeners that we've got offers,
+      // just there was no one
+      this.emit('model', []);
+    }
     return;
   }
 
   this._mergedOffers = this._offers
     .concat(this._offersAutobridged)
-    .sort(function(a, b) {
-      const aQuality = OrderBookUtils.getOfferQuality(a, self._currencyGets);
-      const bQuality = OrderBookUtils.getOfferQuality(b, self._currencyGets);
-
-      return aQuality.compareTo(bQuality);
-    });
+    .sort(this.sortOffers);
 
   this.emit('model', this._mergedOffers);
 };

src/core/orderbookutils.js

@@ -5,6 +5,9 @@ const assert = require('assert');
 const SerializedObject = require('./serializedobject').SerializedObject;
 const Types = require('./serializedtypes');
 const Amount = require('./amount').Amount;
+const Currency = require('./currency').Currency;
+const UInt160 = require('./uint160').UInt160;
+const IOUValue = require('./iouvalue').IOUValue;
 const OrderBookUtils = {};
 
 function assertValidNumber(number, message) {
@@ -19,10 +22,18 @@ function assertValidNumber(number, message) {
 * @return JSON amount object
 */
 
-function createAmount(value, currency, counterparty) {
-  const newJSON =
-  {'value': value, 'currency': currency, 'issuer': counterparty};
-  return Amount.from_json(newJSON);
+function createAmount(value, currency_, counterparty_) {
+
+  const currency = currency_ instanceof Currency ?
+    currency_ :
+    Currency.from_json(currency_);
+
+  const counterparty = counterparty_ instanceof UInt160 ?
+    counterparty_ :
+    UInt160.from_json(counterparty_);
+
+  return Amount.from_components_unsafe(new IOUValue(value),
+    currency, counterparty, false);
 }
 
 /**
@@ -52,11 +63,11 @@ function getIssuerFromOffer(offer) {
  * @return {Amount}
  */
 
-OrderBookUtils.getOfferTakerGetsFunded = function(offer) {
+OrderBookUtils.getOfferTakerGetsFunded = function(offer, currency_, issuer_) {
   assertValidNumber(offer.taker_gets_funded, 'Taker gets funded is invalid');
 
-  const currency = getCurrencyFromOffer(offer);
-  const issuer = getIssuerFromOffer(offer);
+  const currency = currency_ || getCurrencyFromOffer(offer);
+  const issuer = issuer_ || getIssuerFromOffer(offer);
 
   return createAmount(offer.taker_gets_funded, currency, issuer);
 };
@@ -68,11 +79,11 @@ OrderBookUtils.getOfferTakerGetsFunded = function(offer) {
  * @return {Amount}
  */
 
-OrderBookUtils.getOfferTakerPaysFunded = function(offer) {
+OrderBookUtils.getOfferTakerPaysFunded = function(offer, currency_, issuer_) {
   assertValidNumber(offer.taker_pays_funded, 'Taker gets funded is invalid');
 
-  const currency = getCurrencyFromOffer(offer);
-  const issuer = getIssuerFromOffer(offer);
+  const currency = currency_ || getCurrencyFromOffer(offer);
+  const issuer = issuer_ || getIssuerFromOffer(offer);
 
   return createAmount(offer.taker_pays_funded, currency, issuer);
 };
@@ -85,11 +96,11 @@ OrderBookUtils.getOfferTakerPaysFunded = function(offer) {
  * @return {Amount}
  */
 
-OrderBookUtils.getOfferTakerGets = function(offer) {
+OrderBookUtils.getOfferTakerGets = function(offer, currency_, issuer_) {
   assert(typeof offer, 'object', 'Offer is invalid');
 
-  const currency = offer.TakerPays.currency;
-  const issuer = offer.TakerPays.issuer;
+  const currency = currency_ || offer.TakerPays.currency;
+  const issuer = issuer_ || offer.TakerPays.issuer;
 
   return createAmount(offer.TakerGets, currency, issuer);
 };
@@ -101,7 +112,9 @@ OrderBookUtils.getOfferTakerGets = function(offer) {
  * @param {Currency} currencyGets
  */
 
-OrderBookUtils.getOfferQuality = function(offer, currencyGets) {
+OrderBookUtils.getOfferQuality = function(offer, currencyGets, currency_,
+  issuer_
+) {
   let amount;
 
   if (currencyGets.has_interest()) {
@@ -113,8 +126,8 @@ OrderBookUtils.getOfferQuality = function(offer, currencyGets) {
     });
   } else {
 
-    const currency = getCurrencyFromOffer(offer);
-    const issuer = getIssuerFromOffer(offer);
+    const currency = currency_ || getCurrencyFromOffer(offer);
+    const issuer = issuer_ || getIssuerFromOffer(offer);
 
     amount = createAmount(offer.quality, currency, issuer);
   }
@@ -140,13 +153,35 @@ OrderBookUtils.convertOfferQualityToHex = function(quality) {
   return so.to_hex();
 };
 
+/**
+ * Formats an offer quality amount to a hex that can be parsed by
+ * Amount.parse_quality
+ *
+ * @param {String} quality
+ *
+ * @return {String}
+ */
+
+OrderBookUtils.convertOfferQualityToHexFromText = function(quality) {
+
+  const so = new SerializedObject();
+  Types.Quality.serialize(so, quality);
+
+  return so.to_hex();
+};
+
+
+OrderBookUtils.CURRENCY_ONE = Currency.from_json(1);
+
+OrderBookUtils.ISSUER_ONE = UInt160.from_json(1);
+
 /**
  *
  */
 
 OrderBookUtils.normalizeAmount = function(value) {
-
-  return Amount.from_number(value);
+  return Amount.from_components_unsafe(new IOUValue(value),
+    OrderBookUtils.CURRENCY_ONE, OrderBookUtils.ISSUER_ONE, false);
 };
 
 module.exports = OrderBookUtils;

src/core/pathfind.js

@@ -1,7 +1,7 @@
-var EventEmitter = require('events').EventEmitter;
-var util         = require('util');
-var Amount       = require('./amount').Amount;
-var extend       = require('extend');
+'use strict';
+const EventEmitter = require('events').EventEmitter;
+const util = require('util');
+const Amount = require('./amount').Amount;
 
 /**
  * Represents a persistent path finding request.
@@ -10,16 +10,18 @@ var extend       = require('extend');
  * find request is triggered it will supercede the existing one, making it emit
  * the 'end' and 'superceded' events.
  */
-function PathFind(remote, src_account, dst_account, dst_amount, src_currencies) {
+
+function PathFind(remote, src_account, dst_account, dst_amount, src_currencies
+) {
   EventEmitter.call(this);
 
   this.remote = remote;
 
-  this.src_account    = src_account;
-  this.dst_account    = dst_account;
-  this.dst_amount     = dst_amount;
+  this.src_account = src_account;
+  this.dst_account = dst_account;
+  this.dst_amount = dst_amount;
   this.src_currencies = src_currencies;
-};
+}
 
 util.inherits(PathFind, EventEmitter);
 
@@ -32,14 +34,16 @@ util.inherits(PathFind, EventEmitter);
  * so you should only have to call it if the path find was closed or superceded
  * and you wish to restart it.
  */
-PathFind.prototype.create = function () {
-  var self = this;
 
-  var req = this.remote.request_path_find_create(
-    this.src_account,
-    this.dst_account,
-    this.dst_amount,
-    this.src_currencies);
+PathFind.prototype.create = function() {
+  const self = this;
+
+  const req = this.remote.requestPathFindCreate({
+    source_account: this.src_account,
+    destination_account: this.dst_account,
+    destination_amount: this.dst_amount,
+    source_currencies: this.src_currencies
+  });
 
   req.once('error', function(err) {
     self.emit('error', err);
@@ -54,27 +58,28 @@ PathFind.prototype.create = function () {
   req.broadcast().request();
 };
 
-PathFind.prototype.close = function () {
-  this.remote.request_path_find_close().broadcast().request();
+PathFind.prototype.close = function() {
+  this.removeAllListeners('update');
+  this.remote.requestPathFindClose().broadcast().request();
   this.emit('end');
   this.emit('close');
 };
 
-PathFind.prototype.notify_update = function (message) {
-  var src_account = message.source_account;
-  var dst_account = message.destination_account;
-  var dst_amount  = Amount.from_json(message.destination_amount);
+PathFind.prototype.notify_update = function(message) {
+  const src_account = message.source_account;
+  const dst_account = message.destination_account;
+  const dst_amount = Amount.from_json(message.destination_amount);
 
   // Only pass the event along if this path find response matches what we were
   // looking for.
   if (this.src_account === src_account &&
       this.dst_account === dst_account &&
-      this.dst_amount.equals(dst_amount)) {
+      dst_amount.equals(this.dst_amount)) {
     this.emit('update', message);
   }
 };
 
-PathFind.prototype.notify_superceded = function () {
+PathFind.prototype.notify_superceded = function() {
   // XXX If we're set to re-subscribe whenever we connect to a new server, then
   // we should cancel that behavior here. See PathFind#create.
 

src/core/rangeset.js

@@ -45,7 +45,7 @@ class RangeSet {
     const rangeStrings = rangesString.split(',');
     _.forEach(rangeStrings, rangeString => {
       const range = rangeString.split('-').map(Number);
-      this.addRange(range[0], range[1]);
+      this.addRange(range[0], range.length === 1 ? range[0] : range[1]);
     });
   }
 

src/core/request.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const _ = require('lodash');
 const EventEmitter = require('events').EventEmitter;
 const util = require('util');
 const async = require('async');
@@ -38,7 +39,10 @@ function Request(remote, command) {
 util.inherits(Request, EventEmitter);
 
 // Send the request to a remote.
-Request.prototype.request = function(servers, callback) {
+Request.prototype.request = function(servers, callback_) {
+  const self = this;
+  const callback = typeof servers === 'function' ? servers : callback_;
+
   this.emit('before');
   this.callback(callback);
 
@@ -50,18 +54,39 @@ Request.prototype.request = function(servers, callback) {
   this.on('error', function() {});
   this.emit('request', this.remote);
 
-  if (Array.isArray(servers)) {
-    servers.forEach(function(server) {
-      this.setServer(server);
-      this.remote.request(this);
-    }, this);
-  } else {
-    this.remote.request(this);
+  function doRequest() {
+    if (Array.isArray(servers)) {
+      servers.forEach(function(server) {
+        self.setServer(server);
+        self.remote.request(self);
+      }, self);
+    } else {
+      self.remote.request(self);
+    }
   }
 
+  function onReconnect() {
+    doRequest();
+  }
+
+  function onResponse() {
+    self.remote.removeListener('connected', onReconnect);
+  }
+
+  if (this.remote.isConnected()) {
+    this.remote.on('connected', onReconnect);
+  }
+  this.once('response', onResponse);
+
+  doRequest();
+
   return this;
 };
 
+function isResponseNotError(res) {
+  return typeof res === 'object' && !res.hasOwnProperty('error');
+}
+
 /**
  * Broadcast request to all servers, filter responses if a function is
  * provided. Return first response that satisfies the filter. Pre-filter
@@ -73,22 +98,23 @@ Request.prototype.request = function(servers, callback) {
  * @param [Function] fn
  */
 
+
 Request.prototype.filter =
 Request.prototype.addFilter =
-Request.prototype.broadcast = function(filterFn=Boolean) {
+Request.prototype.broadcast = function(isResponseSuccess = isResponseNotError) {
   const self = this;
 
   if (!this.requested) {
     // Defer until requested, and prevent the normal request() from executing
     this.once('before', function() {
       self.requested = true;
-      self.broadcast(filterFn);
+      self.broadcast(isResponseSuccess);
     });
     return this;
   }
 
   let lastResponse = new Error('No servers available');
-  let connectTimeouts = { };
+  const connectTimeouts = { };
   const emit = this.emit;
 
   this.emit = function(event, a, b) {
@@ -110,7 +136,7 @@ Request.prototype.broadcast = function(filterFn=Boolean) {
       // Listen for proxied success/error event and apply filter
       self.once('proposed', function(res) {
         lastResponse = res;
-        callback(filterFn(res));
+        callback(isResponseSuccess(res));
       });
 
       return server._request(self);
@@ -222,7 +248,9 @@ Request.prototype.callback = function(callback, successEvent, errorEvent) {
 
   this.once(this.successEvent, requestSuccess);
   this.once(this.errorEvent, requestError);
-  this.request();
+  if (!this.requested) {
+    this.request();
+  }
 
   return this;
 };
@@ -266,26 +294,13 @@ Request.prototype.timeout = function(duration, callback) {
 Request.prototype.setServer = function(server) {
   let selected = null;
 
-  switch (typeof server) {
-    case 'object':
-      selected = server;
-      break;
-
-    case 'string':
-      // Find server by URL
-      const servers = this.remote._servers;
-
-      for (let i = 0, s; (s = servers[i]); i++) {
-        if (s._url === server) {
-          selected = s;
-          break;
-        }
-      }
-      break;
+  if (_.isString(server)) {
+    selected = _.find(this.remote._servers, s => s._url === server) || null;
+  } else if (_.isObject(server)) {
+    selected = server;
   }
 
   this.server = selected;
-
   return this;
 };
 
@@ -336,26 +351,30 @@ Request.prototype.ledgerIndex = function(ledger_index) {
 /**
  * Set either ledger_index or ledger_hash based on heuristic
  *
- * @param {Number|String} ledger identifier
+ * @param {Number|String} ledger - identifier
+ * @param {Object} options -
+ * @param {Number|String} defaultValue - default if `ledger` unspecifed
  */
+Request.prototype.ledgerSelect =
+Request.prototype.selectLedger = function(ledger, defaultValue) {
+  const selected = ledger || defaultValue;
 
-Request.prototype.selectLedger =
-Request.prototype.ledgerSelect = function(ledger) {
-  switch (ledger) {
+  switch (selected) {
     case 'current':
     case 'closed':
     case 'validated':
-      this.message.ledger_index = ledger;
+      this.message.ledger_index = selected;
       break;
     default:
-      if (Number(ledger) && isFinite(Number(ledger))) {
-        this.message.ledger_index = Number(ledger);
-      } else if (/^[A-F0-9]{64}$/.test(ledger)) {
-        this.message.ledger_hash = ledger;
+      if (Number(selected) && isFinite(Number(selected))) {
+        this.message.ledger_index = Number(selected);
+      } else if (/^[A-F0-9]{64}$/.test(selected)) {
+        this.message.ledger_hash = selected;
+      } else if (selected !== undefined) {
+        throw new Error('unknown ledger format: ' + selected);
       }
       break;
   }
-
   return this;
 };
 
@@ -535,7 +554,7 @@ Request.prototype.addStream = function(stream, values) {
         break;
     }
   } else if (arguments.length > 1) {
-    for (let arg in arguments) {
+    for (const arg in arguments) {
       this.addStream(arguments[arg]);
     }
     return this;

src/core/seed.js

@@ -4,22 +4,22 @@
 // Seed support
 //
 
+const {KeyPair, KeyType} = require('ripple-keypairs');
+const {decodeSeed, encodeSeed} = require('ripple-address-codec');
 const extend = require('extend');
-const utils = require('./utils');
-const sjcl = utils.sjcl;
+const sjclcodec = require('sjcl-codec');
+const BN = require('bn.js');
+const hashjs = require('hash.js');
 
-const Base = require('./base').Base;
 const UInt = require('./uint').UInt;
-const UInt160 = require('./uint160').UInt160;
-const KeyPair = require('./keypair').KeyPair;
 
 const Seed = extend(function() {
-  this._curve = sjcl.ecc.curves.k256;
   this._value = NaN;
+  this._type = KeyType.secp256k1;
 }, UInt);
 
 Seed.width = 16;
-Seed.prototype = extend({}, UInt.prototype);
+Seed.prototype = Object.create(extend({}, UInt.prototype));
 Seed.prototype.constructor = Seed;
 
 // value = NaN on error.
@@ -34,7 +34,7 @@ Seed.prototype.parse_json = function(j) {
         this.parse_hex(j);
         // XXX Should also try 1751
       }
-      if (!this.is_valid()) {
+      if (!this.is_valid() && j[0] !== 's') {
         this.parse_passphrase(j);
       }
     }
@@ -52,9 +52,19 @@ Seed.prototype.parse_base58 = function(j) {
   if (!j.length || j[0] !== 's') {
     this._value = NaN;
   } else {
-    this._value = Base.decode_check(Base.VER_FAMILY_SEED, j);
+    try {
+      const {bytes, type} = decodeSeed(j);
+      this._value = new BN(bytes);
+      this._type = type;
+    } catch (e) {
+      this._value = NaN;
+    }
   }
+  return this;
+};
 
+Seed.prototype.set_ed25519 = function() {
+  this._type = KeyType.ed25519;
   return this;
 };
 
@@ -63,10 +73,9 @@ Seed.prototype.parse_passphrase = function(j) {
     throw new Error('Passphrase must be a string');
   }
 
-  const hash = sjcl.hash.sha512.hash(sjcl.codec.utf8String.toBits(j));
-  const bits = sjcl.bitArray.bitSlice(hash, 0, 128);
-
-  this.parse_bits(bits);
+  const phraseBytes = sjclcodec.bytes.fromBits(sjclcodec.utf8String.toBits(j));
+  const hash = hashjs.sha512().update(phraseBytes).digest();
+  this.parse_bytes(hash.slice(0, 16));
 
   return this;
 };
@@ -75,100 +84,14 @@ Seed.prototype.to_json = function() {
   if (!(this.is_valid())) {
     return NaN;
   }
-
-  const output = Base.encode_check(Base.VER_FAMILY_SEED, this.to_bytes());
-
-  return output;
+  return encodeSeed(this.to_bytes(), this._type);
 };
 
-function append_int(a, i) {
-  return [].concat(a, i >> 24, (i >> 16) & 0xff, (i >> 8) & 0xff, i & 0xff);
-}
-
-function firstHalfOfSHA512(bytes) {
-  return sjcl.bitArray.bitSlice(
-    sjcl.hash.sha512.hash(sjcl.codec.bytes.toBits(bytes)),
-    0, 256
-  );
-}
-
-// Removed a `*` so this JSDoc-ish syntax is ignored.
-// This will soon all change anyway.
-/*
-* @param account
-*        {undefined}                 take first, default, KeyPair
-*
-*        {Number}                    specifies the account number of the KeyPair
-*                                    desired.
-*
-*        {Uint160} (from_json able), specifies the address matching the KeyPair
-*                                    that is desired.
-*
-* @param maxLoops (optional)
-*        {Number}                    specifies the amount of attempts taken
-*                                    to generate a matching KeyPair
-*
-*/
-Seed.prototype.get_key = function(account, maxLoops) {
-  let account_number = 0, address;
-  let max_loops = maxLoops || 1;
-
+Seed.prototype.get_key = function() {
   if (!this.is_valid()) {
     throw new Error('Cannot generate keys from invalid seed!');
   }
-  if (account) {
-    if (typeof account === 'number') {
-      account_number = account;
-      max_loops = account_number + 1;
-    } else {
-      address = UInt160.from_json(account);
-    }
-  }
-
-  let private_gen, public_gen;
-  const curve = this._curve;
-  let i = 0;
-
-  do {
-    private_gen = sjcl.bn.fromBits(
-            firstHalfOfSHA512(append_int(this.to_bytes(), i)));
-    i++;
-  } while (!curve.r.greaterEquals(private_gen));
-
-  public_gen = curve.G.mult(private_gen);
-
-  let sec;
-  let key_pair;
-
-  do {
-
-    i = 0;
-
-    do {
-      sec = sjcl.bn.fromBits(
-              firstHalfOfSHA512(
-                  append_int(
-                    append_int(public_gen.toBytesCompressed(), account_number)
-                    ,
-                    i
-                  )));
-      i++;
-    } while (!curve.r.greaterEquals(sec));
-
-    account_number++;
-    sec = sec.add(private_gen).mod(curve.r);
-    key_pair = KeyPair.from_bn_secret(sec);
-
-    if (max_loops-- <= 0) {
-      // We are almost certainly looking for an account that would take same
-      // value of $too_long {forever, ...}
-      throw new Error('Too many loops looking for KeyPair yielding ' +
-                      address.to_json() + ' from ' + this.to_json());
-    }
-
-  } while (address && !key_pair.get_address().equals(address));
-
-  return key_pair;
+  return KeyPair.fromSeed(this.to_bytes(), this._type);
 };
 
 exports.Seed = Seed;

src/core/serializedobject.js

@@ -1,15 +1,15 @@
 'use strict';
 
-const _ = require('lodash');
 const assert = require('assert');
 const extend = require('extend');
+const BN = require('bn.js');
+const hashjs = require('hash.js');
+const sjclcodec = require('sjcl-codec');
 const binformat = require('./binformat');
 const stypes = require('./serializedtypes');
 const utils = require('./utils');
 const UInt256 = require('./uint256').UInt256;
 
-const sjcl = utils.sjcl;
-
 const TRANSACTION_TYPES = { };
 
 Object.keys(binformat.tx).forEach(function(key) {
@@ -28,20 +28,16 @@ Object.keys(binformat.ter).forEach(function(key) {
   TRANSACTION_RESULTS[binformat.ter[key]] = key;
 });
 
-function normalize_sjcl_bn_hex(string) {
-  const hex = string.slice(2);    // remove '0x' prefix
-  // now strip leading zeros
-  const i = _.findIndex(hex, function(c) {
-    return c !== '0';
-  });
-  return i >= 0 ? hex.slice(i) : '0';
+function fieldType(fieldName) {
+  const fieldDef = binformat.fieldsInverseMap[fieldName];
+  return binformat.types[fieldDef[0]];
 }
 
 function SerializedObject(buf) {
   if (Array.isArray(buf) || (Buffer && Buffer.isBuffer(buf))) {
     this.buffer = buf;
   } else if (typeof buf === 'string') {
-    this.buffer = sjcl.codec.bytes.fromBits(sjcl.codec.hex.toBits(buf));
+    this.buffer = sjclcodec.bytes.fromBits(sjclcodec.hex.toBits(buf));
   } else if (!buf) {
     this.buffer = [];
   } else {
@@ -205,11 +201,11 @@ SerializedObject.prototype.read = readOrPeek(true);
 SerializedObject.prototype.peek = readOrPeek(false);
 
 SerializedObject.prototype.to_bits = function() {
-  return sjcl.codec.bytes.toBits(this.buffer);
+  return sjclcodec.bytes.toBits(this.buffer);
 };
 
 SerializedObject.prototype.to_hex = function() {
-  return sjcl.codec.hex.fromBits(this.to_bits()).toUpperCase();
+  return sjclcodec.hex.fromBits(this.to_bits()).toUpperCase();
 };
 
 SerializedObject.prototype.to_json = function() {
@@ -231,12 +227,12 @@ SerializedObject.prototype.to_json = function() {
   return output;
 };
 
-SerializedObject.jsonify_structure = function(structure, field_name) {
+SerializedObject.jsonify_structure = function(structure, fieldName) {
   let output;
 
   switch (typeof structure) {
     case 'number':
-      switch (field_name) {
+      switch (fieldName) {
         case 'LedgerEntryType':
           output = LEDGER_ENTRY_TYPES[structure];
           break;
@@ -257,11 +253,10 @@ SerializedObject.jsonify_structure = function(structure, field_name) {
 
       if (typeof structure.to_json === 'function') {
         output = structure.to_json();
-      } else if (structure instanceof sjcl.bn) {
-        output = ('0000000000000000' +
-                   normalize_sjcl_bn_hex(structure.toString())
-                  .toUpperCase()
-                  ).slice(-16);
+      } else if (structure instanceof BN) {
+        // We assume that any BN is a UInt64 field
+        assert.equal(fieldType(fieldName), 'Int64');
+        output = utils.arrayToHex(structure.toArray('bn', 8));
       } else {
         // new Array or Object
         output = new structure.constructor();
@@ -307,11 +302,9 @@ SerializedObject.prototype.hash = function(prefix) {
 
   // Copy buffer to temporary buffer
   sign_buffer.append(this.buffer);
+  const bytes = hashjs.sha512().update(sign_buffer.buffer).digest();
 
-  const bits = sjcl.codec.bytes.toBits(sign_buffer.buffer);
-  const sha512hex = sjcl.codec.hex.fromBits(sjcl.hash.sha512.hash(bits));
-
-  return UInt256.from_hex(sha512hex.substr(0, 64).toUpperCase());
+  return UInt256.from_bytes(bytes.slice(0, 32));
 };
 
 // DEPRECATED

src/core/serializedtypes.js

@@ -8,15 +8,16 @@
  * SerializedObject.parse() or SerializedObject.serialize().
  */
 
+const _ = require('lodash');
 const assert = require('assert');
 const extend = require('extend');
+const BN = require('bn.js');
 const GlobalBigNumber = require('bignumber.js');
+const sjclcodec = require('sjcl-codec');
 const Amount = require('./amount').Amount;
 const Currency = require('./currency').Currency;
 const binformat = require('./binformat');
 const utils = require('./utils');
-const sjcl = utils.sjcl;
-const SJCL_BN = sjcl.bn;
 
 const UInt128 = require('./uint128').UInt128;
 const UInt160 = require('./uint160').UInt160;
@@ -44,8 +45,7 @@ function isHexInt64String(val) {
   return isString(val) && /^[0-9A-F]{0,16}$/i.test(val);
 }
 
-function serializeBits(so, bits, noLength) {
-  const byteData = sjcl.codec.bytes.fromBits(bits);
+function serializeBytes(so, byteData, noLength) {
   if (!noLength) {
     SerializedType.serialize_varint(so, byteData.length);
   }
@@ -53,23 +53,12 @@ function serializeBits(so, bits, noLength) {
 }
 
 function serializeHex(so, hexData, noLength) {
-  serializeBits(so, sjcl.codec.hex.toBits(hexData), noLength);
-}
-
-/**
- * parses bytes as hex
- *
- * @param {Array} byte_array bytes
- * @return {String} hex string
- */
-function convertByteArrayToHex(byte_array) {
-  return sjcl.codec.hex.fromBits(sjcl.codec.bytes.toBits(byte_array))
-  .toUpperCase();
+  serializeBytes(so, utils.hexToArray(hexData), noLength);
 }
 
 function convertHexToString(hexString) {
-  const bits = sjcl.codec.hex.toBits(hexString);
-  return sjcl.codec.utf8String.fromBits(bits);
+  const bits = sjclcodec.hex.toBits(hexString);
+  return sjclcodec.utf8String.fromBits(bits);
 }
 
 function sort_fields(keys) {
@@ -308,25 +297,27 @@ const STInt64 = exports.Int64 = new SerializedType({
       if (value < 0) {
         throw new Error('Negative value for unsigned Int64 is invalid.');
       }
-      bigNumObject = new SJCL_BN(value, 10);
+      bigNumObject = new BN(value, 10);
     } else if (isString(value)) {
       if (!isHexInt64String(value)) {
         throw new Error('Not a valid hex Int64.');
       }
-      bigNumObject = new SJCL_BN(value, 16);
-    } else if (value instanceof SJCL_BN) {
-      if (!value.greaterEquals(0)) {
+      bigNumObject = new BN(value, 16);
+    } else if (value instanceof BN) {
+      if (value.cmpn(0) < 0) {
         throw new Error('Negative value for unsigned Int64 is invalid.');
       }
       bigNumObject = value;
     } else {
-      throw new Error('Invalid type for Int64');
+      throw new Error('Invalid type for Int64: ' + (typeof value) + ' value');
     }
-    serializeBits(so, bigNumObject.toBits(64), true); // noLength = true
+    // `'be'` means big endian, and the following arg is the byte length, which
+    // it will pad with 0s to if not enough bytes, or throw if over
+    serializeBytes(so, bigNumObject.toArray('be', 8), /* noLength= */true);
   },
   parse: function(so) {
     const bytes = so.read(8);
-    return SJCL_BN.fromBits(sjcl.codec.bytes.toBits(bytes));
+    return new BN(bytes);
   }
 });
 
@@ -338,7 +329,7 @@ const STHash128 = exports.Hash128 = new SerializedType({
     if (!hash.is_valid()) {
       throw new Error('Invalid Hash128');
     }
-    serializeBits(so, hash.to_bits(), true); // noLength = true
+    serializeBytes(so, hash.to_bytes(), true); // noLength = true
   },
   parse: function(so) {
     return UInt128.from_bytes(so.read(16));
@@ -353,7 +344,7 @@ const STHash256 = exports.Hash256 = new SerializedType({
     if (!hash.is_valid()) {
       throw new Error('Invalid Hash256');
     }
-    serializeBits(so, hash.to_bits(), true); // noLength = true
+    serializeBytes(so, hash.to_bytes(), true); // noLength = true
   },
   parse: function(so) {
     return UInt256.from_bytes(so.read(32));
@@ -368,7 +359,7 @@ const STHash160 = exports.Hash160 = new SerializedType({
     if (!hash.is_valid()) {
       throw new Error('Invalid Hash160');
     }
-    serializeBits(so, hash.to_bits(), true); // noLength = true
+    serializeBytes(so, hash.to_bytes(), true); // noLength = true
   },
   parse: function(so) {
     return UInt160.from_bytes(so.read(20));
@@ -414,7 +405,7 @@ exports.Quality = new SerializedType({
   serialize: function(so, val) {
     let value;
     // if in format: amount/currency/issuer
-    if (val.includes('/')) {
+    if (_.includes(val, '/')) {
       const amount = Amount.from_json(val);
 
       if (!amount.is_valid()) {
@@ -442,7 +433,7 @@ exports.Quality = new SerializedType({
       lo = parseInt(mantissaHex.slice(-8), 16);
     }
 
-    const valueBytes = sjcl.codec.bytes.fromBits([hi, lo]);
+    const valueBytes = sjclcodec.bytes.fromBits([hi, lo]);
 
     so.append(valueBytes);
   }
@@ -482,7 +473,7 @@ const STAmount = exports.Amount = new SerializedType({
         valueHex = '0' + valueHex;
       }
 
-      valueBytes = sjcl.codec.bytes.fromBits(sjcl.codec.hex.toBits(valueHex));
+      valueBytes = sjclcodec.bytes.fromBits(sjclcodec.hex.toBits(valueHex));
       // Clear most significant two bits - these bits should already be 0 if
       // Amount enforces the range correctly, but we'll clear them anyway just
       // so this code can make certain guarantees about the encoded value.
@@ -516,7 +507,7 @@ const STAmount = exports.Amount = new SerializedType({
         lo = parseInt(mantissaHex.slice(-8), 16);
       }
 
-      valueBytes = sjcl.codec.bytes.fromBits([hi, lo]);
+      valueBytes = sjclcodec.bytes.fromBits([hi, lo]);
     }
 
     so.append(valueBytes);
@@ -582,7 +573,7 @@ const STVL = exports.VariableLength = exports.VL = new SerializedType({
   },
   parse: function(so) {
     const len = this.parse_varint(so);
-    return convertByteArrayToHex(so.read(len));
+    return utils.arrayToHex(so.read(len));
   }
 });
 
@@ -594,7 +585,7 @@ const STAccount = exports.Account = new SerializedType({
     if (!account.is_valid()) {
       throw new Error('Invalid account!');
     }
-    serializeBits(so, account.to_bits());
+    serializeBytes(so, account.to_bytes());
   },
   parse: function(so) {
     const len = this.parse_varint(so);
@@ -807,27 +798,27 @@ exports.STMemo = new SerializedType({
         if (parsedType !== 'unformatted_memo') {
           output.parsed_memo_type = parsedType;
         }
-        /*eslint-disable no-empty*/
+        /* eslint-disable no-empty */
       } catch (e) {
         // empty
         // we don't know what's in the binary, apparently it's not a UTF-8
         // string
         // this is fine, we won't add the parsed_memo_type field
       }
-      /*eslint-enable no-empty*/
+      /* eslint-enable no-empty */
     }
 
     if (output.MemoFormat !== undefined) {
       try {
         output.parsed_memo_format = convertHexToString(output.MemoFormat);
-        /*eslint-disable no-empty*/
+        /* eslint-disable no-empty */
       } catch (e) {
         // empty
         // we don't know what's in the binary, apparently it's not a UTF-8
         // string
         // this is fine, we won't add the parsed_memo_format field
       }
-      /*eslint-enable no-empty*/
+      /* eslint-enable no-empty */
     }
 
     if (output.MemoData !== undefined) {
@@ -842,7 +833,7 @@ exports.STMemo = new SerializedType({
           // otherwise see if we can parse text
           output.parsed_memo_data = convertHexToString(output.MemoData);
         }
-        /*eslint-disable no-empty*/
+        /* eslint-disable no-empty */
       } catch(e) {
         // empty
         // we'll fail in case the content does not match what the MemoFormat
@@ -850,7 +841,7 @@ exports.STMemo = new SerializedType({
         // this is fine, we won't add the parsed_memo_data, the user has to
         // parse themselves
       }
-      /*eslint-enable no-empty*/
+      /* eslint-enable no-empty */
     }
 
     so.read(1);

src/core/server.js

@@ -1,9 +1,9 @@
 'use strict';
 
 const _ = require('lodash');
+const assert = require('assert');
 const util = require('util');
 const url = require('url');
-const HttpsProxyAgent = require('https-proxy-agent');
 const LRU = require('lru-cache');
 const EventEmitter = require('events').EventEmitter;
 const RippleError = require('./rippleerror').RippleError;
@@ -47,6 +47,14 @@ function Server(remote, opts_) {
       'Server host is malformed, use "host" and "port" server configuration');
   }
 
+  if (typeof opts.secure !== 'boolean') {
+    opts.secure = true;
+  }
+
+  if (!Boolean(opts.port)) {
+    opts.port = opts.secure ? 443 : 80;
+  }
+
   // We want to allow integer strings as valid port numbers for backward
   // compatibility
   opts.port = Number(opts.port);
@@ -58,10 +66,6 @@ function Server(remote, opts_) {
     throw new TypeError('Server "port" must be an integer in range 1-65535');
   }
 
-  if (typeof opts.secure !== 'boolean') {
-    opts.secure = true;
-  }
-
   this._remote = remote;
   this._opts = opts;
   this._ws = undefined;
@@ -125,6 +129,7 @@ function Server(remote, opts_) {
   });
 
   this.on('response_ping', function onPingResponse(message, request) {
+    _.noop(message);
     self._updateScore('response', request);
   });
 
@@ -441,6 +446,12 @@ Server.prototype.connect = function() {
     const parsed = url.parse(this._opts.url);
     const opts = url.parse(this._remote.proxy);
     opts.secureEndpoint = parsed.protocol === 'wss:';
+    let HttpsProxyAgent;
+    try {
+      HttpsProxyAgent = require('https-proxy-agent');
+    } catch (error) {
+      throw new Error('"proxy" option is not supported in the browser');
+    }
     const agent = new HttpsProxyAgent(opts);
 
     this._ws = new WebSocket(this._opts.url, {agent: agent});
@@ -621,7 +632,7 @@ Server.prototype._handleLedgerClosed = function(message) {
 Server.prototype._handleServerStatus = function(message) {
   // This message is only received when online.
   // As we are connected, it is the definitive final state.
-  const isOnline = ~Server.onlineStates.indexOf(message.server_status);
+  const isOnline = _.includes(Server.onlineStates, message.server_status);
 
   this._setState(isOnline ? 'online' : 'offline');
 
@@ -681,6 +692,7 @@ Server.prototype._handleResponse = function(message) {
       remote: message
     });
   }
+  request.emit('response', message);
 };
 
 Server.prototype._handlePathFind = function(message) {
@@ -732,7 +744,7 @@ Server.prototype._handleResponseSubscribe = function(message) {
     this._ledgerRanges.parseAndAddRanges(message.validated_ledgers);
   }
 
-  if (~Server.onlineStates.indexOf(message.server_status)) {
+  if (_.includes(Server.onlineStates, message.server_status)) {
     this._setState('online');
   }
 };
@@ -905,6 +917,9 @@ Server.prototype._feeTxUnit = function() {
  */
 
 Server.prototype._reserve = function(ownerCount) {
+  // We should be in a valid state before calling this method
+  assert(this._reserve_base && this._reserve_inc);
+
   const reserve_base = Amount.from_json(String(this._reserve_base));
   const reserve_inc = Amount.from_json(String(this._reserve_inc));
   const owner_count = ownerCount || 0;
@@ -913,7 +928,7 @@ Server.prototype._reserve = function(ownerCount) {
     throw new Error('Owner count must not be negative.');
   }
 
-  return reserve_base.add(reserve_inc.product_human(owner_count));
+  return reserve_base.add(reserve_inc.multiply(owner_count));
 };
 
 /**

src/core/transaction.js

@@ -1,14 +1,16 @@
 'use strict';
 
+const assert = require('assert');
 const util = require('util');
-const lodash = require('lodash');
+const _ = require('lodash');
 const EventEmitter = require('events').EventEmitter;
 const utils = require('./utils');
-const sjcl = require('./utils').sjcl;
+const sjclcodec = require('sjcl-codec');
 const Amount = require('./amount').Amount;
 const Currency = require('./amount').Currency;
 const UInt160 = require('./amount').UInt160;
 const Seed = require('./seed').Seed;
+const KeyPair = require('ripple-keypairs').KeyPair;
 const SerializedObject = require('./serializedobject').SerializedObject;
 const RippleError = require('./rippleerror').RippleError;
 const hashprefixes = require('./hashprefixes');
@@ -199,7 +201,7 @@ Transaction.from_json = function(j) {
 
 Transaction.prototype.setJson =
 Transaction.prototype.parseJson = function(v) {
-  this.tx_json = v;
+  this.tx_json = _.merge({}, v);
   return this;
 };
 
@@ -358,7 +360,6 @@ Transaction.prototype._computeFee = function() {
   });
 
   const midInd = Math.floor(fees.length / 2);
-
   const median = fees.length % 2 === 0
   ? Math.floor(0.5 + (fees[midInd] + fees[midInd - 1]) / 2)
   : fees[midInd];
@@ -377,56 +378,86 @@ Transaction.prototype._computeFee = function() {
  * return `false`
  */
 
+Transaction.prototype.err = function(error, errorMessage) {
+  this.emit('error', new RippleError(error, errorMessage));
+  return false;
+};
+
 Transaction.prototype.complete = function() {
-  if (this.remote) {
-    if (!this.remote.trusted && !this.remote.local_signing) {
-      this.emit('error', new RippleError(
-        'tejServerUntrusted', 'Attempt to give secret to untrusted server'));
-      return false;
-    }
+  // Auto-fill the secret
+  this._secret = this._secret || this.getSecret();
+
+  if (_.isUndefined(this._secret)) {
+    return this.err('tejSecretUnknown', 'Missing secret');
   }
 
-  if (!this._secret) {
-    this._secret = this.getSecret();
+  if (this.remote && !(this.remote.local_signing || this.remote.trusted)) {
+    return this.err(
+      'tejServerUntrusted',
+      'Attempt to give secret to untrusted server');
   }
 
-  // Try to auto-fill the secret
-  if (!this._secret) {
-    this.emit('error', new RippleError('tejSecretUnknown', 'Missing secret'));
-    return false;
-  }
-
-  if (typeof this.tx_json.SigningPubKey === 'undefined') {
+  if (_.isUndefined(this.tx_json.SigningPubKey)) {
     try {
-      const seed = Seed.from_json(this._secret);
-      const key = seed.get_key(this.tx_json.Account);
-      this.tx_json.SigningPubKey = key.to_hex_pub();
-    } catch(e) {
-      this.emit('error', new RippleError(
-        'tejSecretInvalid', 'Invalid secret'));
-      return false;
+      this.setSigningPubKey(this.getSigningPubKey());
+    } catch (e) {
+      return this.err('tejSecretInvalid', 'Invalid secret');
     }
   }
 
-  // If the Fee hasn't been set, one needs to be computed by
-  // an assigned server
-  if (this.remote && typeof this.tx_json.Fee === 'undefined') {
-    if (this.remote.local_fee || !this.remote.trusted) {
-      this.tx_json.Fee = this._computeFee();
-      if (!this.tx_json.Fee) {
-        this.emit('error', new RippleError('tejUnconnected'));
-        return false;
+  // Auto-fill transaction Fee
+  if (_.isUndefined(this.tx_json.Fee)) {
+    if (this.remote && (this.remote.local_fee || !this.remote.trusted)) {
+      const computedFee = this._computeFee();
+
+      if (!computedFee) {
+        // Unable to compute fee due to no connected servers
+        return this.err('tejUnconnected');
       }
+
+      this.tx_json.Fee = computedFee;
     }
   }
 
   if (Number(this.tx_json.Fee) > this._maxFee) {
-    this.emit('error', new RippleError(
-      'tejMaxFeeExceeded', 'Max fee exceeded'));
-    return false;
+    return this.err('tejMaxFeeExceeded', 'Max fee exceeded');
   }
 
   // Set canonical flag - this enables canonicalized signature checking
+  this.setCanonicalFlag();
+
+  return this.tx_json;
+};
+
+Transaction.prototype.getKeyPair = function(secret_) {
+  if (this._keyPair) {
+    return this._keyPair;
+  }
+
+  const secret = secret_ || this._secret;
+  assert(secret, 'Secret missing');
+
+  const keyPair = Seed.from_json(secret).get_key();
+  this._keyPair = keyPair;
+
+  return keyPair;
+};
+
+Transaction.prototype.getSigningPubKey = function(secret) {
+  return this.getKeyPair(secret).pubKeyHex();
+};
+
+Transaction.prototype.setSigningPubKey = function(key) {
+  if (_.isString(key)) {
+    this.tx_json.SigningPubKey = key;
+  } else if (key instanceof KeyPair) {
+    this.tx_json.SigningPubKey = key.pubKeyHex();
+  }
+
+  return this;
+};
+
+Transaction.prototype.setCanonicalFlag = function() {
   if (this.remote && this.remote.local_signing && this.canonical) {
     this.tx_json.Flags |= Transaction.flags.Universal.FullyCanonicalSig;
 
@@ -435,7 +466,7 @@ Transaction.prototype.complete = function() {
     this.tx_json.Flags = this.tx_json.Flags >>> 0;
   }
 
-  return this.tx_json;
+  return this;
 };
 
 Transaction.prototype.serialize = function() {
@@ -453,6 +484,14 @@ Transaction.prototype.signingData = function() {
   return so;
 };
 
+Transaction.prototype.multiSigningData = function(account) {
+  const so = new SerializedObject();
+  so.append(hashprefixes.HASH_TX_MULTISIGN_BYTES);
+  so.parse_json(this.tx_json);
+  so.append(UInt160.from_json(account).to_bytes());
+  return so;
+};
+
 Transaction.prototype.hash = function(prefix_, asUINT256, serialized) {
   let prefix;
 
@@ -469,13 +508,17 @@ Transaction.prototype.hash = function(prefix_, asUINT256, serialized) {
   return asUINT256 ? hash : hash.to_hex();
 };
 
-Transaction.prototype.sign = function(testnet) {
-  const seed = Seed.from_json(this._secret);
+Transaction.prototype.sign = function() {
+  if (this.hasMultiSigners()) {
+    return this;
+  }
+
+  const keyPair = this.getKeyPair();
   const prev_sig = this.tx_json.TxnSignature;
 
   delete this.tx_json.TxnSignature;
 
-  const hash = this.signingHash(testnet);
+  const hash = this.signingHash();
 
   // If the hash is the same, we can re-use the previous signature
   if (prev_sig && hash === this.previousSigningHash) {
@@ -483,11 +526,7 @@ Transaction.prototype.sign = function(testnet) {
     return this;
   }
 
-  const key = seed.get_key(this.tx_json.Account);
-  const sig = key.sign(hash);
-  const hex = sjcl.codec.hex.fromBits(sig).toUpperCase();
-
-  this.tx_json.TxnSignature = hex;
+  this.tx_json.TxnSignature = keyPair.signHex(this.signingData().buffer);
   this.previousSigningHash = hash;
 
   return this;
@@ -501,7 +540,7 @@ Transaction.prototype.sign = function(testnet) {
  */
 
 Transaction.prototype.addId = function(id) {
-  if (!lodash.contains(this.submittedIDs, id)) {
+  if (!_.contains(this.submittedIDs, id)) {
     this.submittedIDs.unshift(id);
   }
 };
@@ -517,7 +556,7 @@ Transaction.prototype.addId = function(id) {
  */
 
 Transaction.prototype.findId = function(cache) {
-  const cachedTransactionID = lodash.detect(this.submittedIDs, function(id) {
+  const cachedTransactionID = _.detect(this.submittedIDs, function(id) {
     return cache.hasOwnProperty(id);
   });
   return cache[cachedTransactionID];
@@ -584,9 +623,24 @@ Transaction.prototype.maxFee = function(fee) {
  * @returns {Transaction} calling instance for chaining
  */
 Transaction.prototype.setFixedFee = function(fee) {
-  if (typeof fee === 'number' && fee >= 0) {
-    this._setFixedFee = true;
+  return this.setFee(fee, {fixed: true});
+};
+
+Transaction.prototype.setFee = function(fee, options = {}) {
+  if (_.isNumber(fee) && fee >= 0) {
     this.tx_json.Fee = String(fee);
+    if (options.fixed) {
+      this._setFixedFee = true;
+    }
+  }
+
+  return this;
+};
+
+Transaction.prototype.setSequence = function(sequence) {
+  if (_.isNumber(sequence)) {
+    this._setUInt32('Sequence', sequence);
+    this._setSequence = true;
   }
 
   return this;
@@ -608,7 +662,7 @@ Transaction.prototype.secret = function(secret) {
 };
 
 Transaction.prototype.setType = function(type) {
-  if (lodash.isUndefined(Transaction.formats, type)) {
+  if (_.isUndefined(Transaction.formats, type)) {
     throw new Error('TransactionType must be a valid transaction type');
   }
 
@@ -618,14 +672,14 @@ Transaction.prototype.setType = function(type) {
 };
 
 Transaction.prototype._setUInt32 = function(name, value, options_) {
-  const options = lodash.merge({}, options_);
+  const options = _.merge({}, options_);
   const isValidUInt32 = typeof value === 'number'
   && value >= 0 && value < Math.pow(256, 4);
 
   if (!isValidUInt32) {
     throw new Error(name + ' must be a valid UInt32');
   }
-  if (!lodash.isUndefined(options.min_value) && value < options.min_value) {
+  if (!_.isUndefined(options.min_value) && value < options.min_value) {
     throw new Error(name + ' must be >= ' + options.min_value);
   }
 
@@ -662,7 +716,7 @@ Transaction.prototype.setAccount = function(account) {
 };
 
 Transaction.prototype._setAmount = function(name, amount, options_) {
-  const options = lodash.merge({no_native: false}, options_);
+  const options = _.merge({no_native: false}, options_);
   const parsedAmount = Amount.from_json(amount);
 
   if (parsedAmount.is_negative()) {
@@ -691,7 +745,7 @@ Transaction.prototype._setHash256 = function(name, value, options_) {
     throw new Error(name + ' must be a valid Hash256');
   }
 
-  const options = lodash.merge({pad: false}, options_);
+  const options = _.merge({pad: false}, options_);
   let hash256 = value;
 
   if (options.pad) {
@@ -754,6 +808,11 @@ Transaction.prototype.setFlags = function(flags) {
   return this;
 };
 
+function convertStringToHex(string) {
+  const utf8String = sjclcodec.utf8String.toBits(string);
+  return sjclcodec.hex.fromBits(utf8String).toUpperCase();
+}
+
 /**
  * Add a Memo to transaction.
  *
@@ -771,7 +830,7 @@ Transaction.prototype.addMemo = function(options_) {
   let options;
 
   if (typeof options_ === 'object') {
-    options = lodash.merge({}, options_);
+    options = _.merge({}, options_);
   } else {
     options = {
       memoType: arguments[0],
@@ -780,11 +839,6 @@ Transaction.prototype.addMemo = function(options_) {
     };
   }
 
-  function convertStringToHex(string) {
-    const utf8String = sjcl.codec.utf8String.toBits(string);
-    return sjcl.codec.hex.fromBits(utf8String).toUpperCase();
-  }
-
   const memo = {};
   const memoRegex = Transaction.MEMO_REGEX;
   let memoType = options.memoType;
@@ -792,7 +846,7 @@ Transaction.prototype.addMemo = function(options_) {
   let memoData = options.memoData;
 
   if (memoType) {
-    if (!(lodash.isString(memoType) && memoRegex.test(memoType))) {
+    if (!(_.isString(memoType) && memoRegex.test(memoType))) {
       throw new Error(
         'MemoType must be a string containing only valid URL characters');
     }
@@ -805,7 +859,7 @@ Transaction.prototype.addMemo = function(options_) {
   }
 
   if (memoFormat) {
-    if (!(lodash.isString(memoFormat) && memoRegex.test(memoFormat))) {
+    if (!(_.isString(memoFormat) && memoRegex.test(memoFormat))) {
       throw new Error(
         'MemoFormat must be a string containing only valid URL characters');
     }
@@ -859,15 +913,15 @@ Transaction.prototype.accountSet = function(options_) {
   let options;
 
   if (typeof options_ === 'object') {
-    options = lodash.merge({}, options_);
+    options = _.merge({}, options_);
 
-    if (lodash.isUndefined(options.account)) {
+    if (_.isUndefined(options.account)) {
       options.account = options.src;
     }
-    if (lodash.isUndefined(options.set_flag)) {
+    if (_.isUndefined(options.set_flag)) {
       options.set_flag = options.set;
     }
-    if (lodash.isUndefined(options.clear_flag)) {
+    if (_.isUndefined(options.clear_flag)) {
       options.clear_flag = options.clear;
     }
   } else {
@@ -881,10 +935,10 @@ Transaction.prototype.accountSet = function(options_) {
   this.setType('AccountSet');
   this.setAccount(options.account);
 
-  if (!lodash.isUndefined(options.set_flag)) {
+  if (!_.isUndefined(options.set_flag)) {
     this.setSetFlag(options.set_flag);
   }
-  if (!lodash.isUndefined(options.clear_flag)) {
+  if (!_.isUndefined(options.clear_flag)) {
     this.setClearFlag(options.clear_flag);
   }
 
@@ -901,7 +955,7 @@ Transaction.prototype.setAccountSetFlag = function(name, value) {
     : accountSetFlags['asf' + flagValue];
   }
 
-  if (!lodash.contains(lodash.values(accountSetFlags), flagValue)) {
+  if (!_.contains(_.values(accountSetFlags), flagValue)) {
     throw new Error(name + ' must be a valid AccountSet flag');
   }
 
@@ -958,9 +1012,9 @@ Transaction.prototype.setRegularKey = function(options_) {
   let options;
 
   if (typeof options_ === 'object') {
-    options = lodash.merge({}, options_);
+    options = _.merge({}, options_);
 
-    if (lodash.isUndefined(options.account)) {
+    if (_.isUndefined(options.account)) {
       options.account = options.src;
     }
   } else {
@@ -973,7 +1027,7 @@ Transaction.prototype.setRegularKey = function(options_) {
   this.setType('SetRegularKey');
   this.setAccount(options.account);
 
-  if (!lodash.isUndefined(options.regular_key)) {
+  if (!_.isUndefined(options.regular_key)) {
     this._setAccount('RegularKey', options.regular_key);
   }
 
@@ -994,9 +1048,9 @@ Transaction.prototype.rippleLineSet = function(options_) {
   let options;
 
   if (typeof options_ === 'object') {
-    options = lodash.merge({}, options_);
+    options = _.merge({}, options_);
 
-    if (lodash.isUndefined(options.account)) {
+    if (_.isUndefined(options.account)) {
       options.account = options.src;
     }
   } else {
@@ -1011,13 +1065,13 @@ Transaction.prototype.rippleLineSet = function(options_) {
   this.setType('TrustSet');
   this.setAccount(options.account);
 
-  if (!lodash.isUndefined(options.limit)) {
+  if (!_.isUndefined(options.limit)) {
     this.setLimit(options.limit);
   }
-  if (!lodash.isUndefined(options.quality_in)) {
+  if (!_.isUndefined(options.quality_in)) {
     this.setQualityIn(options.quality_in);
   }
-  if (!lodash.isUndefined(options.quality_out)) {
+  if (!_.isUndefined(options.quality_out)) {
     this.setQualityOut(options.quality_out);
   }
 
@@ -1059,12 +1113,12 @@ Transaction.prototype.payment = function(options_) {
   let options;
 
   if (typeof options_ === 'object') {
-    options = lodash.merge({}, options_);
+    options = _.merge({}, options_);
 
-    if (lodash.isUndefined(options.account)) {
+    if (_.isUndefined(options.account)) {
       options.account = options.src || options.from;
     }
-    if (lodash.isUndefined(options.destination)) {
+    if (_.isUndefined(options.destination)) {
       options.destination = options.dst || options.to;
     }
   } else {
@@ -1181,6 +1235,10 @@ Transaction.prototype.paths = function(paths) {
     throw new Error('Paths must be an array');
   }
 
+  if (paths.length === 0) {
+    return this;
+  }
+
   this.tx_json.Paths = [];
   paths.forEach(this.addPath, this);
 
@@ -1239,18 +1297,18 @@ Transaction.prototype.offerCreate = function(options_) {
   let options;
 
   if (typeof options_ === 'object') {
-    options = lodash.merge({}, options_);
+    options = _.merge({}, options_);
 
-    if (lodash.isUndefined(options.account)) {
+    if (_.isUndefined(options.account)) {
       options.account = options.src;
     }
-    if (lodash.isUndefined(options.taker_pays)) {
+    if (_.isUndefined(options.taker_pays)) {
       options.taker_pays = options.buy;
     }
-    if (lodash.isUndefined(options.taker_gets)) {
+    if (_.isUndefined(options.taker_gets)) {
       options.taker_gets = options.sell;
     }
-    if (lodash.isUndefined(options.offer_sequence)) {
+    if (_.isUndefined(options.offer_sequence)) {
       options.offer_sequence = options.cancel_sequence || options.sequence;
     }
   } else {
@@ -1268,10 +1326,10 @@ Transaction.prototype.offerCreate = function(options_) {
   this.setTakerGets(options.taker_gets);
   this.setTakerPays(options.taker_pays);
 
-  if (!lodash.isUndefined(options.expiration)) {
+  if (!_.isUndefined(options.expiration)) {
     this.setExpiration(options.expiration);
   }
-  if (!lodash.isUndefined(options.offer_sequence)) {
+  if (!_.isUndefined(options.offer_sequence)) {
     this.setOfferSequence(options.offer_sequence);
   }
 
@@ -1309,12 +1367,12 @@ Transaction.prototype.offerCancel = function(options_) {
   let options;
 
   if (typeof options_ === 'object') {
-    options = lodash.merge({}, options_);
+    options = _.merge({}, options_);
 
-    if (lodash.isUndefined(options.account)) {
+    if (_.isUndefined(options.account)) {
       options.account = options.src;
     }
-    if (lodash.isUndefined(options.offer_sequence)) {
+    if (_.isUndefined(options.offer_sequence)) {
       options.offer_sequence = options.sequence || options.cancel_sequence;
     }
   } else {
@@ -1331,16 +1389,48 @@ Transaction.prototype.offerCancel = function(options_) {
   return this;
 };
 
+Transaction._prepareSignerEntry = function(signer) {
+  const {account, weight} = signer;
+
+  assert(UInt160.is_valid(account), 'Signer account invalid');
+  assert(_.isNumber(weight), 'Signer weight missing');
+  assert(weight > 0 && weight <= 65535, 'Signer weight must be 1-65535');
+
+  return {
+    SignerEntry: {
+      Account: account,
+      SignerWeight: weight
+    }
+  };
+};
+
+Transaction.prototype.setSignerList = function(options = {}) {
+  this.setType('SignerListSet');
+  this.setAccount(options.account);
+  this.setSignerQuorum(options.signerQuorum);
+
+  if (!_.isEmpty(options.signers)) {
+    this.tx_json.SignerEntries =
+      options.signers.map(Transaction._prepareSignerEntry);
+  }
+
+  return this;
+};
+
+Transaction.prototype.setSignerQuorum = function(quorum) {
+  this._setUInt32('SignerQuorum', quorum);
+};
+
 /**
  * Submit transaction to the network
  *
  * @param [Function] callback
  */
 
-Transaction.prototype.submit = function(callback) {
+Transaction.prototype.submit = function(callback = function() {}) {
   const self = this;
 
-  this.callback = (typeof callback === 'function') ? callback : function() {};
+  this.callback = callback;
 
   this._errorHandler = function transactionError(error_, message) {
     let error = error_;
@@ -1411,6 +1501,163 @@ Transaction.prototype.summary = function() {
   return txSummary;
 };
 
-exports.Transaction = Transaction;
+/**
+ * Construct a 'SuspendedPaymentCreate' transaction
+ *
+ * Relevant setters:
+ *  - setSourceTag()
+ *  - setFlags()
+ *  - setDigest()
+ *  - setAllowCancelAfter()
+ *  - setAllowExecuteAfter()
+ *
+ *  @param {String} options.account source account
+ *  @param {String} options.destination account
+ *  @param {Amount} options.amount payment amount
+ */
 
-// vim:sw=2:sts=2:ts=8:et
+Transaction.prototype.suspendedPaymentCreate = function(options) {
+  this.setType('SuspendedPaymentCreate');
+  this.setAccount(options.account);
+  this.setDestination(options.destination);
+  this.setAmount(options.amount);
+  return this;
+};
+
+/**
+ * Construct a 'SuspendedPaymentFinish' transaction
+ *
+ * Relevant setters:
+ *  - setSourceTag()
+ *  - setFlags()
+ *  - setOwner()
+ *  - setOfferSequence()
+ *  - setMethod()
+ *  - setDigest()
+ *  - setProof()
+ *
+ *  @param {String} options.account source account
+ *  @param {String} options.owner SuspendedPaymentCreate's Account
+ *  @param {Integer} options.paymentSequence SuspendedPaymentCreate's Sequence
+ */
+
+Transaction.prototype.suspendedPaymentFinish = function(options) {
+  this.setType('SuspendedPaymentFinish');
+  this.setAccount(options.account);
+  this.setOwner(options.owner);
+  this.setOfferSequence(options.paymentSequence);
+  return this;
+};
+
+/**
+ * Construct a 'SuspendedPaymentCancel' transaction
+ *
+ * Relevant setters:
+ *  - setSourceTag()
+ *  - setFlags()
+ *  - setOwner()
+ *  - setOfferSequence()
+ *
+ *  @param {String} options.account source account
+ *  @param {String} options.owner SuspendedPaymentCreate's Account
+ *  @param {Integer} options.paymentSequence SuspendedPaymentCreate's Sequence
+ */
+
+Transaction.prototype.suspendedPaymentCancel = function(options) {
+  this.setType('SuspendedPaymentCancel');
+  this.setAccount(options.account);
+  this.setOwner(options.owner);
+  this.setOfferSequence(options.paymentSequence);
+  return this;
+};
+
+Transaction.prototype.setDigest = function(digest) {
+  return this._setHash256('Digest', digest);
+};
+
+Transaction.prototype.setAllowCancelAfter = function(after) {
+  return this._setUInt32('CancelAfter', utils.time.toRipple(after));
+};
+
+Transaction.prototype.setAllowExecuteAfter = function(after) {
+  return this._setUInt32('FinishAfter', utils.time.toRipple(after));
+};
+
+Transaction.prototype.setOwner = function(owner) {
+  return this._setAccount('Owner', owner);
+};
+
+Transaction.prototype.setMethod = function(method) {
+  return this._setUInt8('Method', method);
+};
+
+Transaction.prototype.setProof = function(proof) {
+  this.tx_json.Proof = convertStringToHex(proof);
+  return this;
+};
+
+Transaction.prototype._setUInt8 = function(name, value) {
+  const isValidUInt8 = typeof value === 'number' && value >= 0 && value < 256;
+  if (!isValidUInt8) {
+    throw new Error(name + ' must be a valid UInt8');
+  }
+  this.tx_json[name] = value;
+  return this;
+};
+
+Transaction.prototype.setSigners = function(signers) {
+  if (_.isArray(signers)) {
+    this.tx_json.Signers = signers;
+  }
+
+  return this;
+};
+
+Transaction.prototype.addMultiSigner = function(signer) {
+  assert(UInt160.is_valid(signer.Account), 'Signer must have a valid Account');
+
+  if (_.isUndefined(this.multi_signers)) {
+    this.multi_signers = [];
+  }
+
+  this.multi_signers.push({Signer: signer});
+
+  this.multi_signers.sort((a, b) => {
+    return UInt160.from_json(a.Signer.Account)
+    .cmp(UInt160.from_json(b.Signer.Account));
+  });
+};
+
+Transaction.prototype.hasMultiSigners = function() {
+  return !_.isEmpty(this.multi_signers);
+};
+Transaction.prototype.getMultiSigners = function() {
+  return this.multi_signers;
+};
+
+Transaction.prototype.getMultiSigningJson = function() {
+  assert(this.tx_json.Sequence, 'Sequence must be set before multi-signing');
+  assert(this.tx_json.Fee, 'Fee must be set before multi-signing');
+
+  const signingTx = Transaction.from_json(this.tx_json);
+  signingTx.remote = this.remote;
+  signingTx.setSigningPubKey('');
+  signingTx.setCanonicalFlag();
+
+  return signingTx.tx_json;
+};
+
+Transaction.prototype.multiSign = function(account, secret) {
+  const signingData = this.multiSigningData(account);
+  const keyPair = Seed.from_json(secret).get_key();
+
+  const signer = {
+    Account: account,
+    TxnSignature: keyPair.signHex(signingData.buffer),
+    SigningPubKey: keyPair.pubKeyHex()
+  };
+
+  return signer;
+};
+
+exports.Transaction = Transaction;

src/core/transactionmanager.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const _ = require('lodash');
 const util = require('util');
 const assert = require('assert');
 const async = require('async');
@@ -520,11 +521,22 @@ TransactionManager.prototype._resubmit = function(ledgers_, pending_) {
 TransactionManager.prototype._prepareRequest = function(tx) {
   const submitRequest = this._remote.requestSubmit();
 
+  if (tx.hasMultiSigners()) {
+    tx.setSigningPubKey('');
+
+    if (this._remote.local_signing) {
+      tx.setSigners(tx.getMultiSigners());
+    } else {
+      submitRequest.message.command = 'submit_multisigned';
+      submitRequest.message.Signers = tx.getMultiSigners();
+    }
+  }
+
   if (this._remote.local_signing) {
     tx.sign();
 
     const serialized = tx.serialize();
-    submitRequest.tx_blob(serialized.to_hex());
+    submitRequest.txBlob(serialized.to_hex());
 
     const hash = tx.hash(null, null, serialized);
     tx.addId(hash);
@@ -534,9 +546,9 @@ TransactionManager.prototype._prepareRequest = function(tx) {
     // sealed and delivered, and the txn unmodified.
     // TODO: perhaps an exception should be raised if build_path is attempted
     // while local signing
-    submitRequest.build_path(tx._build_path);
+    submitRequest.buildPath(tx._build_path);
     submitRequest.secret(tx._secret);
-    submitRequest.tx_json(tx.tx_json);
+    submitRequest.txJson(tx.tx_json);
   }
 
   return submitRequest;
@@ -678,7 +690,7 @@ TransactionManager.prototype._request = function(tx) {
     tx.initialSubmitIndex = tx.submitIndex;
   }
 
-  if (!tx._setLastLedger) {
+  if (!tx._setLastLedger && !tx.hasMultiSigners()) {
     // Honor LastLedgerSequence set with tx.lastLedger()
     tx.tx_json.LastLedgerSequence = tx.initialSubmitIndex
     + this._lastLedgerOffset;
@@ -726,9 +738,13 @@ TransactionManager.prototype.submit = function(tx) {
     return;
   }
 
-  if (typeof tx.tx_json.Sequence !== 'number') {
+  if (!_.isNumber(tx.tx_json.Sequence)) {
     // Honor manually-set sequences
-    tx.tx_json.Sequence = this._nextSequence++;
+    tx.setSequence(this._nextSequence++);
+  }
+
+  if (tx.hasMultiSigners()) {
+    tx.setResubmittable(false);
   }
 
   tx.once('cleanup', function() {

src/core/uint.js

@@ -1,11 +1,12 @@
 'use strict';
 
-/*eslint new-cap: 1*/
+/* eslint new-cap: 1 */
 
 const assert = require('assert');
 const lodash = require('lodash');
+const sjclcodec = require('sjcl-codec');
 const utils = require('./utils');
-const sjcl = utils.sjcl;
+const BN = require('bn.js');
 
 //
 // Abstract UInt class
@@ -14,7 +15,7 @@ const sjcl = utils.sjcl;
 //
 
 function UInt() {
-  // Internal form: NaN or sjcl.bn
+  // Internal form: NaN or BN
   this._value = NaN;
 }
 
@@ -67,15 +68,6 @@ UInt.from_bytes = function(j) {
   return (new this()).parse_bytes(j);
 };
 
-// Return a new UInt from j.
-UInt.from_bn = function(j) {
-  if (j instanceof this) {
-    return j.clone();
-  }
-
-  return (new this()).parse_bn(j);
-};
-
 // Return a new UInt from j.
 UInt.from_number = function(j) {
   if (j instanceof this) {
@@ -108,16 +100,33 @@ UInt.prototype.copyTo = function(d) {
   return d;
 };
 
-UInt.prototype.equals = function(d) {
-  return this.is_valid() && d.is_valid() && this._value.equals(d._value);
+UInt.prototype.equals = function(o) {
+  return this.is_valid() &&
+         o.is_valid() &&
+         // This throws but the expression will short circuit
+         this.cmp(o) === 0;
+};
+
+UInt.prototype.cmp = function(o) {
+  assert(this.is_valid() && o.is_valid());
+  return this._value.cmp(o._value);
+};
+
+UInt.prototype.greater_than = function(o) {
+  return this.cmp(o) > 0;
+};
+
+UInt.prototype.less_than = function(o) {
+  return this.cmp(o) < 0;
 };
 
 UInt.prototype.is_valid = function() {
-  return this._value instanceof sjcl.bn;
+  return this._value instanceof BN;
 };
 
 UInt.prototype.is_zero = function() {
-  return this.is_valid() && this._value.equals(new sjcl.bn(0));
+  // cmpn means cmp with N)umber
+  return this.is_valid() && this._value.cmpn(0) === 0;
 };
 
 /**
@@ -150,14 +159,14 @@ UInt.prototype.parse_generic = function(j) {
     case subclass.STR_ZERO:
     case subclass.ACCOUNT_ZERO:
     case subclass.HEX_ZERO:
-      this._value = new sjcl.bn(0);
+      this._value = new BN(0);
       break;
 
     case '1':
     case subclass.STR_ONE:
     case subclass.ACCOUNT_ONE:
     case subclass.HEX_ONE:
-      this._value = new sjcl.bn(1);
+      this._value = new BN(1);
       break;
 
     default:
@@ -165,7 +174,7 @@ UInt.prototype.parse_generic = function(j) {
         switch (j.length) {
           case subclass.width:
             const hex = utils.arrayToHex(utils.stringToArray(j));
-            this._value = new sjcl.bn(hex, 16);
+            this._value = new BN(hex, 16);
             break;
           case subclass.width * 2:
             // Assume hex, check char set
@@ -187,7 +196,7 @@ UInt.prototype.parse_generic = function(j) {
 
 UInt.prototype.parse_hex = function(j) {
   if (new RegExp(`^[0-9A-Fa-f]{${this.constructor.width * 2}}$`).test(j)) {
-    this._value = new sjcl.bn(j, 16);
+    this._value = new BN(j, 16);
   } else {
     this._value = NaN;
   }
@@ -198,24 +207,12 @@ UInt.prototype.parse_hex = function(j) {
 };
 
 UInt.prototype.parse_bits = function(j) {
-  if (sjcl.bitArray.bitLength(j) === this.constructor.width * 8) {
-    this._value = sjcl.bn.fromBits(j);
-    // let bytes = sjcl.codec.bytes.fromBits(j);
-    // this.parse_bytes(bytes);
-  } else {
-    this._value = NaN;
-  }
-
-  this._update();
-
-  return this;
+  return this.parse_bytes(sjclcodec.bytes.fromBits(j));
 };
 
-
 UInt.prototype.parse_bytes = function(j) {
   if (Array.isArray(j) && j.length === this.constructor.width) {
-    const bits = sjcl.codec.bytes.toBits(j);
-    this._value = sjcl.bn.fromBits(bits);
+    this._value = new BN(j);
   } else {
     this._value = NaN;
   }
@@ -225,26 +222,13 @@ UInt.prototype.parse_bytes = function(j) {
   return this;
 };
 
-
 UInt.prototype.parse_json = UInt.prototype.parse_hex;
 
-UInt.prototype.parse_bn = function(j) {
-  if ((j instanceof sjcl.bn) && j.bitLength() <= this.constructor.width * 8) {
-    this._value = new sjcl.bn(j);
-  } else {
-    this._value = NaN;
-  }
-
-  this._update();
-
-  return this;
-};
-
 UInt.prototype.parse_number = function(j) {
   this._value = NaN;
 
   if (typeof j === 'number' && isFinite(j) && j >= 0) {
-    this._value = new sjcl.bn(j);
+    this._value = new BN(j);
   }
 
   this._update();
@@ -258,7 +242,7 @@ UInt.prototype.to_bytes = function() {
     return null;
   }
 
-  return sjcl.codec.bytes.fromBits(this.to_bits());
+  return this._value.toArray('be', this.constructor.width);
 };
 
 UInt.prototype.to_hex = function() {
@@ -266,27 +250,18 @@ UInt.prototype.to_hex = function() {
     return null;
   }
 
-  return sjcl.codec.hex.fromBits(this.to_bits()).toUpperCase();
+  return utils.arrayToHex(this.to_bytes());
 };
 
 UInt.prototype.to_json = UInt.prototype.to_hex;
 
+// Convert from internal form.
 UInt.prototype.to_bits = function() {
   if (!this.is_valid()) {
     return null;
   }
 
-  return this._value.toBits(this.constructor.width * 8);
-};
-
-UInt.prototype.to_bn = function() {
-  if (!this.is_valid()) {
-    return null;
-  }
-
-  const bits = this.to_bits();
-
-  return sjcl.bn.fromBits(bits);
+  return sjclcodec.bytes.toBits(this.to_bytes());
 };
 
 exports.UInt = UInt;

src/core/uint128.js

@@ -1,23 +1,23 @@
 'use strict';
 
-var utils = require('./utils');
-var extend = require('extend');
-var UInt = require('./uint').UInt;
+const utils = require('./utils');
+const extend = require('extend');
+const UInt = require('./uint').UInt;
 
 //
 // UInt128 support
 //
 
-var UInt128 = extend(function() {
+const UInt128 = extend(function() {
   this._value = NaN;
 }, UInt);
 
 UInt128.width = 16;
-UInt128.prototype = extend({}, UInt.prototype);
+UInt128.prototype = Object.create(extend({}, UInt.prototype));
 UInt128.prototype.constructor = UInt128;
 
-var HEX_ZERO = UInt128.HEX_ZERO = '00000000000000000000000000000000';
-var HEX_ONE = UInt128.HEX_ONE = '00000000000000000000000000000000';
+const HEX_ZERO = UInt128.HEX_ZERO = '00000000000000000000000000000000';
+const HEX_ONE = UInt128.HEX_ONE = '00000000000000000000000000000000';
 
 UInt128.STR_ZERO = utils.hexToString(HEX_ZERO);
 UInt128.STR_ONE = utils.hexToString(HEX_ONE);

src/core/uint160.js

@@ -1,27 +1,27 @@
 'use strict';
 
-var utils = require('./utils');
-var extend = require('extend');
+const utils = require('./utils');
+const extend = require('extend');
 
-var UInt = require('./uint').UInt;
-var Base = require('./base').Base;
+const UInt = require('./uint').UInt;
+const Base = require('./base').Base;
 
 //
 // UInt160 support
 //
 
-var UInt160 = extend(function() {
+const UInt160 = extend(function() {
   this._value = NaN;
   this._version_byte = undefined;
   this._update();
 }, UInt);
 
 UInt160.width = 20;
-UInt160.prototype = extend({}, UInt.prototype);
+UInt160.prototype = Object.create(extend({}, UInt.prototype));
 UInt160.prototype.constructor = UInt160;
 
-var HEX_ZERO = UInt160.HEX_ZERO = '0000000000000000000000000000000000000000';
-var HEX_ONE = UInt160.HEX_ONE = '0000000000000000000000000000000000000001';
+const HEX_ZERO = UInt160.HEX_ZERO = '0000000000000000000000000000000000000000';
+const HEX_ONE = UInt160.HEX_ONE = '0000000000000000000000000000000000000001';
 
 UInt160.ACCOUNT_ZERO = 'rrrrrrrrrrrrrrrrrrrrrhoLvTp';
 UInt160.ACCOUNT_ONE = 'rrrrrrrrrrrrrrrrrrrrBZbvji';
@@ -74,13 +74,12 @@ UInt160.prototype.parse_generic = function(j) {
 };
 
 // XXX Json form should allow 0 and 1, C++ doesn't currently allow it.
-UInt160.prototype.to_json = function(opts) {
-  opts = opts || {};
+UInt160.prototype.to_json = function(opts = {}) {
 
   if (this.is_valid()) {
     // If this value has a type, return a Base58 encoded string.
     if (typeof this._version_byte === 'number') {
-      var output = Base.encode_check(this._version_byte, this.to_bytes());
+      let output = Base.encode_check(this._version_byte, this.to_bytes());
 
       if (opts.gateways && output in opts.gateways) {
         output = opts.gateways[output];

src/core/uint256.js

@@ -1,25 +1,25 @@
 'use strict';
 
-var utils = require('./utils');
-var extend = require('extend');
-var UInt = require('./uint').UInt;
+const utils = require('./utils');
+const extend = require('extend');
+const UInt = require('./uint').UInt;
 
 //
 // UInt256 support
 //
 
-var UInt256 = extend(function() {
+const UInt256 = extend(function() {
   this._value = NaN;
 }, UInt);
 
 UInt256.width = 32;
-UInt256.prototype = extend({}, UInt.prototype);
+UInt256.prototype = Object.create(extend({}, UInt.prototype));
 UInt256.prototype.constructor = UInt256;
 
-var HEX_ZERO = UInt256.HEX_ZERO = '00000000000000000000000000000000' +
+const HEX_ZERO = UInt256.HEX_ZERO = '00000000000000000000000000000000' +
                                   '00000000000000000000000000000000';
 
-var HEX_ONE = UInt256.HEX_ONE = '00000000000000000000000000000000' +
+const HEX_ONE = UInt256.HEX_ONE = '00000000000000000000000000000000' +
                                 '00000000000000000000000000000001';
 
 UInt256.STR_ZERO = utils.hexToString(HEX_ZERO);

src/core/utils.js

@@ -77,7 +77,7 @@ function hexToArray(h) {
 
 function arrayToHex(a) {
   return a.map(function(byteValue) {
-    const hex = byteValue.toString(16);
+    const hex = byteValue.toString(16).toUpperCase();
     return hex.length > 1 ? hex : '0' + hex;
   }).join('');
 }
@@ -166,6 +166,4 @@ exports.fromTimestamp = fromTimestamp;
 exports.getMantissaDecimalString = getMantissaDecimalString;
 exports.getMantissa16FromString = getMantissa16FromString;
 
-exports.sjcl = require('sjcl-extended');
-
 // vim:sw=2:sts=2:ts=8:et

src/index.js

@@ -1,6 +1,8 @@
 'use strict';
-const _ = require('lodash');
 const core = require('./core');
 const RippleAPI = require('./api');
 
-module.exports = _.assign({}, core, {RippleAPI: RippleAPI});
+module.exports = {
+  RippleAPI,
+  _DEPRECATED: core   // WARNING: this will be removed soon
+};

test/amount-test-error.js

@@ -0,0 +1,46 @@
+'use strict';
+const assert = require('assert');
+const Amount = require('ripple-lib').Amount;
+const Remote = require('ripple-lib').Remote;
+
+const data = require('./fixtures/negative-error');
+
+
+describe.skip('Amount ', function() {
+  it('Show "Offer total cannot be negative" error', function() {
+    const a1 = {
+      currency: 'JPY',
+      issuer: 'r94s8px6kSw1uZ1MV98dhSRTvc6VMPoPcN',
+      value: '66436.33517689175'
+    };
+    const a2 = {
+      currency: 'JPY',
+      issuer: 'r94s8px6kSw1uZ1MV98dhSRTvc6VMPoPcN',
+      value: '66435.49665972557'
+    };
+    const a1a = Amount.from_json(a1);
+    const res = a1a.add(a2).subtract(a2).subtract(a1);
+
+    console.log(res.to_human());
+    assert(!res.is_negative(), 'Offer total cannot be negative');
+  });
+
+  it('Show Details of "Offer total cannot be negative" error', function() {
+    const book = new Remote().createOrderBook({
+      currency_gets: 'JPY',
+      issuer_gets: 'r94s8px6kSw1uZ1MV98dhSRTvc6VMPoPcN',
+      currency_pays: 'XRP'
+    });
+    book._subscribed = true;
+    book._synced = true;
+    book._offers = data._offers;
+    book._offerCounts = data._offerCounts;
+    book._ownerFundsUnadjusted = data._ownerFundsUnadjusted;
+    book._ownerFunds = data._ownerFunds;
+    book._ownerOffersTotal = data._ownerOffersTotal;
+    book._issuerTransferRate = 1000000000;
+    book._remote._handleTransaction(data.message1);
+    book._remote._handleTransaction(data.lastMessage);
+  });
+
+});

test/amount-test.js

@@ -1223,29 +1223,52 @@ describe('Amount', function() {
       });
     });
 
-    it('from_json minimum IOU', function() {
-      const amt = Amount.from_json('-1e-81/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
-      assert.strictEqual(amt.to_text(), '-1000000000000000e-96');
+    it('from_json minimum positive IOU', function() {
+      const amt = Amount.from_json('1e-81/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
+      assert.strictEqual(amt.to_text(), '1000000000000000e-96');
       assert.strictEqual(amt.to_text(), Amount.min_value);
     });
 
-    it('from_json exceed minimum IOU', function() {
-      assert.throws(function() {
-        Amount.from_json('-1e-82/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
-      }, 'Exceeding min value of ' + Amount.min_value);
+    it('from_json smallest-absolute-value negative IOU', function() {
+      const amt = Amount.from_json('-1e-81/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
+      assert.strictEqual(amt.to_text(), '-1000000000000000e-96');
+      assert.strictEqual(amt.negate().to_text(), Amount.min_value);
     });
 
-    it('from_json maximum IOU', function() {
+    it('from_json exceeding minimum positive IOU', function() {
+      assert.throws(function() {
+        Amount.from_json('1e-82/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
+      }, 'Exceeding min absolute value of ' + Amount.min_value);
+    });
+
+    it('from_json exceeding minimum-absolute-value negative IOU', function() {
+      assert.throws(function() {
+        Amount.from_json('-1e-82/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
+      }, 'Exceeding min absolute value of ' + Amount.min_value);
+    });
+
+    it('from_json maximum positive IOU', function() {
       const amt = Amount.from_json('9999999999999999e80/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
       assert.strictEqual(amt.to_text(), '9999999999999999e80');
     });
 
-    it('from_json exceed maximum IOU', function() {
+    it('from_json exceed maximum positive IOU', function() {
       assert.throws(function() {
         Amount.from_json('9999999999999999e81/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
       }, 'Exceeding max value of ' + Amount.max_value);
     });
 
+    it('from_json largest-absolute-value negative IOU', function() {
+      const amt = Amount.from_json('-9999999999999999e80/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
+      assert.strictEqual(amt.to_text(), '-9999999999999999e80');
+    });
+
+    it('from_json exceed largest-absolute-value negative IOU', function() {
+      assert.throws(function() {
+        Amount.from_json('-9999999999999999e81/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
+      }, 'Exceeding max value of ' + Amount.max_value);
+    });
+
     it('from_json normalize mantissa to valid max range, lost significant digits', function() {
       const amt = Amount.from_json('99999999999999999999999999999999/USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
       assert.strictEqual(amt.to_text(), '9999999999999999e16');