Delete core, move "api" directory up to "src", and remove unused dependencies

src/ledger/parse/account-order.js

@@ -0,0 +1,41 @@
+/* @flow */
+'use strict';
+const utils = require('./utils');
+const flags = require('./flags').orderFlags;
+const parseAmount = require('./amount');
+const BigNumber = require('bignumber.js');
+
+// TODO: remove this function once rippled provides quality directly
+function computeQuality(takerGets, takerPays) {
+  const quotient = new BigNumber(takerPays.value).dividedBy(takerGets.value);
+  return quotient.toDigits(16, BigNumber.ROUND_HALF_UP).toString();
+}
+
+// rippled 'account_offers' returns a different format for orders than 'tx'
+// the flags are also different
+function parseAccountOrder(address: string, order: Object): Object {
+  const direction = (order.flags & flags.Sell) === 0 ? 'buy' : 'sell';
+  const takerGetsAmount = parseAmount(order.taker_gets);
+  const takerPaysAmount = parseAmount(order.taker_pays);
+  const quantity = (direction === 'buy') ? takerPaysAmount : takerGetsAmount;
+  const totalPrice = (direction === 'buy') ? takerGetsAmount : takerPaysAmount;
+
+  // note: immediateOrCancel and fillOrKill orders cannot enter the order book
+  // so we can omit those flags here
+  const specification = utils.removeUndefined({
+    direction: direction,
+    quantity: quantity,
+    totalPrice: totalPrice,
+    passive: ((order.flags & flags.Passive) !== 0) || undefined
+  });
+
+  const properties = {
+    maker: address,
+    sequence: order.seq,
+    makerExchangeRate: computeQuality(takerGetsAmount, takerPaysAmount)
+  };
+
+  return {specification, properties};
+}
+
+module.exports = parseAccountOrder;

src/ledger/parse/account-trustline.js

@@ -0,0 +1,46 @@
+/* @flow */
+'use strict';
+const utils = require('./utils');
+
+type Trustline = {
+  account: string, limit: number, currency: string, quality_in: ?number,
+  quality_out: ?number, no_ripple: boolean, freeze: boolean,
+  authorized: boolean, limit_peer: string, no_ripple_peer: boolean,
+  freeze_peer: boolean, peer_authorized: boolean, balance: any
+}
+
+type TrustlineSpecification = {}
+type TrustlineCounterParty = {}
+type TrustlineState = {balance: number}
+type AccountTrustline = {
+  specification: TrustlineSpecification, counterparty: TrustlineCounterParty,
+  state: TrustlineState
+}
+
+// rippled 'account_lines' returns a different format for
+// trustlines than 'tx'
+function parseAccountTrustline(trustline: Trustline): AccountTrustline {
+  const specification = utils.removeUndefined({
+    limit: trustline.limit,
+    currency: trustline.currency,
+    counterparty: trustline.account,
+    qualityIn: trustline.quality_in || undefined,
+    qualityOut: trustline.quality_out || undefined,
+    ripplingDisabled: trustline.no_ripple || undefined,
+    frozen: trustline.freeze || undefined,
+    authorized: trustline.authorized || undefined
+  });
+  // rippled doesn't provide the counterparty's qualities
+  const counterparty = utils.removeUndefined({
+    limit: trustline.limit_peer,
+    ripplingDisabled: trustline.no_ripple_peer || undefined,
+    frozen: trustline.freeze_peer || undefined,
+    authorized: trustline.peer_authorized || undefined
+  });
+  const state = {
+    balance: trustline.balance
+  };
+  return {specification, counterparty, state};
+}
+
+module.exports = parseAccountTrustline;

src/ledger/parse/amount.js

@@ -0,0 +1,21 @@
+/* @flow */
+'use strict';
+const utils = require('./utils');
+import type {Amount, RippledAmount} from '../../common/types.js';
+
+
+function parseAmount(amount: RippledAmount): Amount {
+  if (typeof amount === 'string') {
+    return {
+      currency: 'XRP',
+      value: utils.dropsToXrp(amount)
+    };
+  }
+  return {
+    currency: amount.currency,
+    value: amount.value,
+    counterparty: amount.issuer
+  };
+}
+
+module.exports = parseAmount;

src/ledger/parse/cancellation.js

@@ -0,0 +1,12 @@
+/* @flow */
+'use strict';
+const assert = require('assert');
+
+function parseOrderCancellation(tx: Object): Object {
+  assert(tx.TransactionType === 'OfferCancel');
+  return {
+    orderSequence: tx.OfferSequence
+  };
+}
+
+module.exports = parseOrderCancellation;

src/ledger/parse/fields.js

@@ -0,0 +1,28 @@
+/* @flow */
+'use strict';
+const BigNumber = require('bignumber.js');
+const AccountFields = require('./utils').constants.AccountFields;
+
+function parseField(info, value) {
+  if (info.encoding === 'hex' && !info.length) {
+    return new Buffer(value, 'hex').toString('ascii');
+  }
+  if (info.shift) {
+    return (new BigNumber(value)).shift(-info.shift).toNumber();
+  }
+  return value;
+}
+
+function parseFields(data: Object): Object {
+  const settings = {};
+  for (const fieldName in AccountFields) {
+    const fieldValue = data[fieldName];
+    if (fieldValue !== undefined) {
+      const info = AccountFields[fieldName];
+      settings[info.name] = parseField(info, fieldValue);
+    }
+  }
+  return settings;
+}
+
+module.exports = parseFields;

src/ledger/parse/flags.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const orderFlags = {
+  Passive: 0x00010000,
+  Sell: 0x00020000  // offer was placed as a sell
+};
+
+const trustlineFlags = {
+  LowReserve: 0x00010000, // entry counts toward reserve
+  HighReserve: 0x00020000,
+  LowAuth: 0x00040000,
+  HighAuth: 0x00080000,
+  LowNoRipple: 0x00100000,
+  HighNoRipple: 0x00200000,
+  LowFreeze: 0x00400000,
+  HighFreeze: 0x00800000
+};
+
+module.exports = {
+  orderFlags,
+  trustlineFlags
+};

src/ledger/parse/ledger.js

@@ -0,0 +1,57 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const removeUndefined = require('./utils').removeUndefined;
+const parseTransaction = require('./transaction');
+import type {GetLedger} from '../types.js';
+
+function parseTransactionWrapper(tx) {
+  const transaction = _.assign({}, _.omit(tx, 'metaData'),
+    {meta: tx.metaData});
+  return parseTransaction(transaction);
+}
+
+function parseTransactions(transactions) {
+  if (_.isEmpty(transactions)) {
+    return {};
+  }
+  if (_.isString(transactions[0])) {
+    return {transactionHashes: transactions};
+  }
+  return {
+    transactions: _.map(transactions, parseTransactionWrapper),
+    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): GetLedger {
+  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/ledger/parse/order.js

@@ -0,0 +1,28 @@
+/* @flow */
+'use strict';
+const assert = require('assert');
+const utils = require('./utils');
+const parseAmount = require('./amount');
+const flags = utils.txFlags.OfferCreate;
+
+function parseOrder(tx: Object): Object {
+  assert(tx.TransactionType === 'OfferCreate');
+
+  const direction = (tx.Flags & flags.Sell) === 0 ? 'buy' : 'sell';
+  const takerGetsAmount = parseAmount(tx.TakerGets);
+  const takerPaysAmount = parseAmount(tx.TakerPays);
+  const quantity = (direction === 'buy') ? takerPaysAmount : takerGetsAmount;
+  const totalPrice = (direction === 'buy') ? takerGetsAmount : takerPaysAmount;
+
+  return utils.removeUndefined({
+    direction: direction,
+    quantity: quantity,
+    totalPrice: totalPrice,
+    passive: ((tx.Flags & flags.Passive) !== 0) || undefined,
+    immediateOrCancel: ((tx.Flags & flags.ImmediateOrCancel) !== 0)
+      || undefined,
+    fillOrKill: ((tx.Flags & flags.FillOrKill) !== 0) || undefined
+  });
+}
+
+module.exports = parseOrder;

src/ledger/parse/orderbook-order.js

@@ -0,0 +1,43 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const utils = require('./utils');
+const flags = require('./flags').orderFlags;
+const parseAmount = require('./amount');
+
+function parseOrderbookOrder(order: Object): Object {
+  const direction = (order.Flags & flags.Sell) === 0 ? 'buy' : 'sell';
+  const takerGetsAmount = parseAmount(order.TakerGets);
+  const takerPaysAmount = parseAmount(order.TakerPays);
+  const quantity = (direction === 'buy') ? takerPaysAmount : takerGetsAmount;
+  const totalPrice = (direction === 'buy') ? takerGetsAmount : takerPaysAmount;
+
+  // note: immediateOrCancel and fillOrKill orders cannot enter the order book
+  // so we can omit those flags here
+  const specification = utils.removeUndefined({
+    direction: direction,
+    quantity: quantity,
+    totalPrice: totalPrice,
+    passive: ((order.Flags & flags.Passive) !== 0) || undefined
+  });
+
+  const properties = {
+    maker: order.Account,
+    sequence: order.Sequence,
+    makerExchangeRate: utils.adjustQualityForXRP(order.quality,
+      takerGetsAmount.currency, takerPaysAmount.currency)
+  };
+
+  const takerGetsFunded = order.taker_gets_funded ?
+      parseAmount(order.taker_gets_funded) : undefined;
+  const takerPaysFunded = order.taker_pays_funded ?
+      parseAmount(order.taker_pays_funded) : undefined;
+  const available = utils.removeUndefined({
+    fundedAmount: takerGetsFunded,
+    priceOfFundedAmount: takerPaysFunded
+  });
+  const state = _.isEmpty(available) ? undefined : available;
+  return utils.removeUndefined({specification, properties, state});
+}
+
+module.exports = parseOrderbookOrder;

src/ledger/parse/pathfind.js

@@ -0,0 +1,51 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const parseAmount = require('./amount');
+import type {Amount, RippledAmount} from '../../common/types.js';
+import type {GetPaths, RippledPathsResponse} from '../pathfind-types.js';
+
+function parsePaths(paths) {
+  return paths.map(steps => steps.map(step =>
+    _.omit(step, ['type', 'type_hex'])));
+}
+
+function removeAnyCounterpartyEncoding(address: string, amount: Amount) {
+  return amount.counterparty === address ?
+    _.omit(amount, 'counterparty') : amount;
+}
+
+function createAdjustment(address: string, adjustmentWithoutAddress: Object) {
+  const amountKey = _.keys(adjustmentWithoutAddress)[0];
+  const amount = adjustmentWithoutAddress[amountKey];
+  return _.set({address: address}, amountKey,
+               removeAnyCounterpartyEncoding(address, amount));
+}
+
+function parseAlternative(sourceAddress: string, destinationAddress: string,
+  destinationAmount: RippledAmount, alternative: Object
+) {
+  // we use "maxAmount"/"minAmount" here so that the result can be passed
+  // directly to preparePayment
+  const amounts = (alternative.destination_amount !== undefined) ?
+    {source: {amount: parseAmount(alternative.source_amount)},
+     destination: {minAmount: parseAmount(alternative.destination_amount)}} :
+    {source: {maxAmount: parseAmount(alternative.source_amount)},
+     destination: {amount: parseAmount(destinationAmount)}};
+
+  return {
+    source: createAdjustment(sourceAddress, amounts.source),
+    destination: createAdjustment(destinationAddress, amounts.destination),
+    paths: JSON.stringify(parsePaths(alternative.paths_computed))
+  };
+}
+
+function parsePathfind(pathfindResult: RippledPathsResponse): GetPaths {
+  const sourceAddress = pathfindResult.source_account;
+  const destinationAddress = pathfindResult.destination_account;
+  const destinationAmount = pathfindResult.destination_amount;
+  return pathfindResult.alternatives.map(_.partial(parseAlternative,
+    sourceAddress, destinationAddress, destinationAmount));
+}
+
+module.exports = parsePathfind;

src/ledger/parse/payment.js

@@ -0,0 +1,54 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const assert = require('assert');
+const utils = require('./utils');
+const parseAmount = require('./amount');
+const txFlags = utils.txFlags;
+
+function isPartialPayment(tx) {
+  return (tx.Flags & txFlags.Payment.PartialPayment) !== 0;
+}
+
+function isNoDirectRipple(tx) {
+  return (tx.Flags & txFlags.Payment.NoRippleDirect) !== 0;
+}
+
+function isQualityLimited(tx) {
+  return (tx.Flags & txFlags.Payment.LimitQuality) !== 0;
+}
+
+function removeGenericCounterparty(amount, address) {
+  return amount.counterparty === address ?
+    _.omit(amount, 'counterparty') : amount;
+}
+
+function parsePayment(tx: Object): Object {
+  assert(tx.TransactionType === 'Payment');
+
+  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),
+    invoiceID: tx.InvoiceID,
+    paths: tx.Paths ? JSON.stringify(tx.Paths) : undefined,
+    allowPartialPayment: isPartialPayment(tx) || undefined,
+    noDirectRipple: isNoDirectRipple(tx) || undefined,
+    limitQuality: isQualityLimited(tx) || undefined
+  });
+}
+
+module.exports = parsePayment;

src/ledger/parse/settings.js

@@ -0,0 +1,61 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const assert = require('assert');
+const AccountFlags = require('./utils').constants.AccountFlags;
+const parseFields = require('./fields');
+
+function getAccountRootModifiedNode(tx: Object) {
+  const modifiedNodes = tx.meta.AffectedNodes.filter(node =>
+    node.ModifiedNode.LedgerEntryType === 'AccountRoot');
+  assert(modifiedNodes.length === 1);
+  return modifiedNodes[0].ModifiedNode;
+}
+
+function parseFlags(tx: Object) {
+  const settings = {};
+  if (tx.TransactionType !== 'AccountSet') {
+    return settings;
+  }
+
+  const node = getAccountRootModifiedNode(tx);
+  const oldFlags = _.get(node.PreviousFields, 'Flags');
+  const newFlags = _.get(node.FinalFields, 'Flags');
+
+  if (oldFlags !== undefined && newFlags !== undefined) {
+    const changedFlags = oldFlags ^ newFlags;
+    const setFlags = newFlags & changedFlags;
+    const clearedFlags = oldFlags & changedFlags;
+    _.forEach(AccountFlags, (flagValue, flagName) => {
+      if (setFlags & flagValue) {
+        settings[flagName] = true;
+      } else if (clearedFlags & flagValue) {
+        settings[flagName] = false;
+      }
+    });
+  }
+
+  // enableTransactionIDTracking requires a special case because it
+  // does not affect the Flags field; instead it adds/removes a field called
+  // "AccountTxnID" to/from the account root.
+
+  const oldField = _.get(node.PreviousFields, 'AccountTxnID');
+  const newField = _.get(node.FinalFields, 'AccountTxnID');
+  if (newField && !oldField) {
+    settings.enableTransactionIDTracking = true;
+  } else if (oldField && !newField) {
+    settings.enableTransactionIDTracking = false;
+  }
+
+  return settings;
+}
+
+function parseSettings(tx: Object) {
+  const txType = tx.TransactionType;
+  assert(txType === 'AccountSet' || txType === 'SetRegularKey');
+
+  const regularKey = tx.RegularKey ? {regularKey: tx.RegularKey} : {};
+  return _.assign(regularKey, parseFlags(tx), parseFields(tx));
+}
+
+module.exports = parseSettings;

src/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/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/ledger/parse/suspended-payment-execution.js

@@ -0,0 +1,19 @@
+/* @flow */
+'use strict';
+const assert = require('assert');
+const utils = require('./utils');
+
+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 ? utils.hexToString(tx.Proof) : undefined
+  });
+}
+
+module.exports = parseSuspendedPaymentExecution;

src/ledger/parse/transaction.js

@@ -0,0 +1,56 @@
+/* @flow */
+'use strict';
+const assert = require('assert');
+const utils = require('./utils');
+const parsePayment = require('./payment');
+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 = {
+    Payment: 'payment',
+    TrustSet: 'trustline',
+    OfferCreate: 'order',
+    OfferCancel: 'orderCancellation',
+    AccountSet: 'settings',
+    SetRegularKey: 'settings',
+    SuspendedPaymentCreate: 'suspendedPaymentCreation',
+    SuspendedPaymentFinish: 'suspendedPaymentExecution',
+    SuspendedPaymentCancel: 'suspendedPaymentCancellation'
+  };
+  return mapping[type] || null;
+}
+
+function parseTransaction(tx: Object): Object {
+  const type = parseTransactionType(tx.TransactionType);
+  const mapping = {
+    'payment': parsePayment,
+    'trustline': parseTrustline,
+    'order': parseOrder,
+    'orderCancellation': parseOrderCancellation,
+    'settings': parseSettings,
+    'suspendedPaymentCreation': parseSuspendedPaymentCreation,
+    'suspendedPaymentExecution': parseSuspendedPaymentExecution,
+    'suspendedPaymentCancellation': parseSuspendedPaymentCancellation
+  };
+  const parser = mapping[type];
+  assert(parser !== undefined, 'Unrecognized transaction type');
+  const specification = parser(tx);
+  const outcome = utils.parseOutcome(tx);
+  return utils.removeUndefined({
+    type: type,
+    address: tx.Account,
+    sequence: tx.Sequence,
+    id: tx.hash,
+    specification: utils.removeUndefined(specification),
+    outcome: outcome ? utils.removeUndefined(outcome) : undefined
+  });
+}
+
+module.exports = parseTransaction;

src/ledger/parse/trustline.js

@@ -0,0 +1,41 @@
+/* @flow */
+'use strict';
+const assert = require('assert');
+const utils = require('./utils');
+const flags = utils.txFlags.TrustSet;
+const BigNumber = require('bignumber.js');
+
+function parseFlag(flagsValue, trueValue, falseValue) {
+  if (flagsValue & trueValue) {
+    return true;
+  }
+  if (flagsValue & falseValue) {
+    return false;
+  }
+  return undefined;
+}
+
+function parseQuality(quality?: number) {
+  if (typeof quality === 'number') {
+    return (new BigNumber(quality)).shift(-9).toNumber();
+  }
+  return undefined;
+}
+
+function parseTrustline(tx: Object): Object {
+  assert(tx.TransactionType === 'TrustSet');
+
+  return utils.removeUndefined({
+    limit: tx.LimitAmount.value,
+    currency: tx.LimitAmount.currency,
+    counterparty: tx.LimitAmount.issuer,
+    qualityIn: parseQuality(tx.QualityIn),
+    qualityOut: parseQuality(tx.QualityOut),
+    ripplingDisabled: parseFlag(
+      tx.Flags, flags.SetNoRipple, flags.ClearNoRipple),
+    frozen: parseFlag(tx.Flags, flags.SetFreeze, flags.ClearFreeze),
+    authorized: parseFlag(tx.Flags, flags.SetAuth, 0)
+  });
+}
+
+module.exports = parseTrustline;

src/ledger/parse/utils.js

@@ -0,0 +1,93 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const transactionParser = require('ripple-lib-transactionparser');
+const utils = require('../utils');
+const rippleToUnixTimestamp = utils.common.rippleToUnixTimestamp;
+const BigNumber = require('bignumber.js');
+
+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);
+  const denominatorShift = (takerGetsCurrency === 'XRP' ? -6 : 0);
+  const shift = numeratorShift - denominatorShift;
+  return shift === 0 ? quality :
+    (new BigNumber(quality)).shift(shift).toString();
+}
+
+function parseTimestamp(tx: {date: string}): string | void {
+  return tx.date ? (new Date(rippleToUnixTimestamp(tx.date))).toISOString()
+    : undefined;
+}
+
+function removeEmptyCounterparty(amount) {
+  if (amount.counterparty === '') {
+    delete amount.counterparty;
+  }
+}
+
+function removeEmptyCounterpartyInBalanceChanges(balanceChanges) {
+  _.forEach(balanceChanges, (changes) => {
+    _.forEach(changes, removeEmptyCounterparty);
+  });
+}
+
+function removeEmptyCounterpartyInOrderbookChanges(orderbookChanges) {
+  _.forEach(orderbookChanges, (changes) => {
+    _.forEach(changes, (change) => {
+      _.forEach(change, removeEmptyCounterparty);
+    });
+  });
+}
+
+function parseOutcome(tx: Object): ?Object {
+  if (!tx.validated) {
+    return undefined;
+  }
+
+  const balanceChanges = transactionParser.parseBalanceChanges(tx.meta);
+  const orderbookChanges = transactionParser.parseOrderbookChanges(tx.meta);
+  removeEmptyCounterpartyInBalanceChanges(balanceChanges);
+  removeEmptyCounterpartyInOrderbookChanges(orderbookChanges);
+
+  return {
+    result: tx.meta.TransactionResult,
+    timestamp: parseTimestamp(tx),
+    fee: utils.common.dropsToXrp(tx.Fee),
+    balanceChanges: balanceChanges,
+    orderbookChanges: orderbookChanges,
+    ledgerVersion: tx.ledger_index,
+    indexInLedger: tx.meta.TransactionIndex
+  };
+}
+
+function hexToString(hex: string): ?string {
+  return hex ? new Buffer(hex, 'hex').toString('utf-8') : undefined;
+}
+
+function parseMemos(tx: Object): ?Array<Object> {
+  if (!Array.isArray(tx.Memos) || tx.Memos.length === 0) {
+    return undefined;
+  }
+  return tx.Memos.map((m) => {
+    return utils.common.removeUndefined({
+      type: m.Memo.parsed_memo_type || hexToString(m.Memo.MemoType),
+      format: m.Memo.parsed_memo_format || hexToString(m.Memo.MemoFormat),
+      data: m.Memo.parsed_memo_data || hexToString(m.Memo.MemoData)
+    });
+  });
+}
+
+module.exports = {
+  parseOutcome,
+  parseMemos,
+  hexToString,
+  adjustQualityForXRP,
+  dropsToXrp: utils.common.dropsToXrp,
+  constants: utils.common.constants,
+  txFlags: utils.common.txFlags,
+  removeUndefined: utils.common.removeUndefined
+};