refactor: move fixtures closer to tests (part 2) (#1561)

* move echo * move fee * move subscribe/unsubscribe * move ledger_current * move ledger_data * move submit/submit_multisigned * remove account_tx/account_offers/gateway_balances * move account_info * remove ledger_entry * remove tx * remove account_lines * remove ripple_path_find * remove ledger * remove book_offers * move ping * remove global_config * move test_command * additional mock-rippled cleanup * add explanatory comment to mock.addResponse
2025-11-19 19:55:51 +00:00 · 2021-08-26 14:02:48 -04:00
parent f9fe5936b1
commit 09ef8595e7
31 changed files with 657 additions and 752 deletions
--- a/test/broadcastClient.ts
+++ b/test/broadcastClient.ts
@@ -25,8 +25,6 @@ describe('BroadcastClient', function () {
    this.mocks.forEach((mock) => {
      mock.addResponse({command: 'server_info'}, rippled.server_info.normal)
    })
-    const expected = {request_server_info: 1}
-    this.mocks.forEach((mock) => mock.expect(Object.assign({}, expected)))
    assert(this.client.isConnected())
    return this.client
      .request({command: "server_info"})
@@ -36,6 +34,10 @@ describe('BroadcastClient', function () {
  })

  it('error propagation', function (done) {
+    const data = {error: 'type', error_message: 'info'}
+    this.mocks.forEach((mock) => {
+      mock.addResponse({command: 'echo'}, data)
+    })
    this.client.once('error', (type, info) => {
      assert.strictEqual(type, 'type')
      assert.strictEqual(info, 'info')
@@ -44,7 +46,7 @@ describe('BroadcastClient', function () {
    this.client._clients[1].connection
      .request({
        command: 'echo',
-        data: {error: 'type', error_message: 'info'}
+        data
      })
      .catch(ignoreWebSocketDisconnect)
  })
--- a/test/client/getBalances.ts
+++ b/test/client/getBalances.ts
@@ -1,4 +1,6 @@
 import responses from '../fixtures/responses'
+import rippled from '../fixtures/rippled'
+import rippledAccountLines from '../fixtures/rippled/accountLines'
 import {assertResultMatch, TestSuite} from '../testUtils'

 /**
@@ -7,20 +9,29 @@ import {assertResultMatch, TestSuite} from '../testUtils'
 * - Check out "test/client/index.ts" for more information about the test runner.
 */
 export default <TestSuite>{
-  'getBalances': async (client, address) => {
+  'getBalances': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
+    mockRippled.addResponse({command: 'account_lines'}, rippledAccountLines.normal)
+    mockRippled.addResponse({command: 'ledger'}, rippled.ledger.normal)
    const result = await client.getBalances(address)
    assertResultMatch(result, responses.getBalances, 'getBalances')
  },

-  'getBalances - limit': async (client, address) => {
+  'getBalances - limit': async (client, address, mockRippled) => {
    const options = {limit: 3, ledgerVersion: 123456}
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
+    mockRippled.addResponse({command: 'account_lines'}, rippledAccountLines.normal)
+    mockRippled.addResponse({command: 'ledger'}, rippled.ledger.normal)
    const expectedResponse = responses.getBalances.slice(0, 3)
    const result = await client.getBalances(address, options)
    assertResultMatch(result, expectedResponse, 'getBalances')
  },

-  'getBalances - limit & currency': async (client, address) => {
+  'getBalances - limit & currency': async (client, address, mockRippled) => {
    const options = {currency: 'USD', limit: 3}
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
+    mockRippled.addResponse({command: 'account_lines'}, rippledAccountLines.normal)
+    mockRippled.addResponse({command: 'ledger'}, rippled.ledger.normal)
    const expectedResponse = responses.getBalances
      .filter((item) => item.currency === 'USD')
      .slice(0, 3)
@@ -28,12 +39,16 @@ export default <TestSuite>{
    assertResultMatch(result, expectedResponse, 'getBalances')
  },

-  'getBalances - limit & currency & issuer': async (client, address) => {
+  'getBalances - limit & currency & issuer': async (client, address, mockRippled) => {
    const options = {
      currency: 'USD',
      counterparty: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
      limit: 3
    }
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
+    mockRippled.addResponse({command: 'account_lines'}, rippledAccountLines.normal)
+    mockRippled.addResponse({command: 'ledger'}, rippled.ledger.normal)
+    
    const expectedResponse = responses.getBalances
      .filter(
        (item) =>
--- a/test/client/getOrderbook.ts
+++ b/test/client/getOrderbook.ts
@@ -1,7 +1,9 @@
 import assert from 'assert-diff'
 import responses from '../fixtures/responses'
 import requests from '../fixtures/requests'
+import rippled from '../fixtures/rippled'
 import {TestSuite, assertResultMatch, assertRejects} from '../testUtils'
+import { BookOffersRequest } from '../../src'
 // import BigNumber from 'bignumber.js'

 // function checkSortingOfOrders(orders) {
@@ -38,13 +40,46 @@ import {TestSuite, assertResultMatch, assertRejects} from '../testUtils'
 //   return true
 // }

+function isUSD(currency: string) {
+  return currency === 'USD' || currency === '0000000000000000000000005553440000000000'
+}
+
+function isBTC(currency: string) {
+  return currency === 'BTC' || currency === '0000000000000000000000004254430000000000'
+}
+
+function normalRippledResponse(request: BookOffersRequest): object {
+  if (
+    isBTC(request.taker_gets.currency) &&
+    isUSD(request.taker_pays.currency)
+  ) {
+    return rippled.book_offers.fabric.requestBookOffersBidsResponse(request)
+  } else if (
+    isUSD(request.taker_gets.currency) &&
+    isBTC(request.taker_pays.currency)
+  ) {
+    return rippled.book_offers.fabric.requestBookOffersAsksResponse(request)
+  }
+}
+
+function xrpRippledResponse(request: BookOffersRequest): object {
+  if (request.taker_pays.issuer === 'rp8rJYTpodf8qbSCHVTNacf8nSW8mRakFw') {
+    return rippled.book_offers.xrp_usd
+  } else if (
+    request.taker_gets.issuer === 'rp8rJYTpodf8qbSCHVTNacf8nSW8mRakFw'
+  ) {
+    return rippled.book_offers.usd_xrp
+  }
+}
+
 /**
 * Every test suite exports their tests in the default object.
 * - Check out the "TestSuite" type for documentation on the interface.
 * - Check out "test/client/index.ts" for more information about the test runner.
 */
 export default <TestSuite>{
-  'normal': async (client, address) => {
+  'normal': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'book_offers'}, normalRippledResponse)
    const response = await client.getOrderbook(
      address,
      requests.getOrderbook.normal,
@@ -53,7 +88,8 @@ export default <TestSuite>{
    assertResultMatch(response, responses.getOrderbook.normal, 'getOrderbook')
  },

-  'invalid options': async (client, address) => {
+  'invalid options': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'book_offers'}, normalRippledResponse)
    assertRejects(
      client.getOrderbook(address, requests.getOrderbook.normal, {
        // @ts-ignore
@@ -63,7 +99,8 @@ export default <TestSuite>{
    )
  },

-  'with XRP': async (client, address) => {
+  'with XRP': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'book_offers'}, xrpRippledResponse)
    const response = await client.getOrderbook(
      address,
      requests.getOrderbook.withXRP
@@ -71,7 +108,7 @@ export default <TestSuite>{
    assertResultMatch(response, responses.getOrderbook.withXRP, 'getOrderbook')
  },

-  // 'sample XRP/JPY book has orders sorted correctly': async (client, address) => {
+  // 'sample XRP/JPY book has orders sorted correctly': async (client, address, mockRippled) => {
  //   const orderbookInfo = {
  //     base: {
  //       // the first currency in pair
@@ -88,7 +125,7 @@ export default <TestSuite>{
  //   checkSortingOfOrders(response.asks)
  // },

-  // 'sample USD/XRP book has orders sorted correctly': async (client, address) => {
+  // 'sample USD/XRP book has orders sorted correctly': async (client, address, mockRippled) => {
  //   const orderbookInfo = {
  //     counter: {currency: 'XRP'},
  //     base: {
@@ -103,7 +140,8 @@ export default <TestSuite>{
  // },

  // WARNING: This test fails to catch the sorting bug, issue #766
-  'sorted so that best deals come first [bad test]': async (client, address) => {
+  'sorted so that best deals come first [bad test]': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'book_offers'}, normalRippledResponse)
    const response = await client.getOrderbook(
      address,
      requests.getOrderbook.normal
@@ -127,7 +165,8 @@ export default <TestSuite>{
    )
  },

-  'currency & counterparty are correct': async (client, address) => {
+  'currency & counterparty are correct': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'book_offers'}, normalRippledResponse)
    const response = await client.getOrderbook(
      address,
      requests.getOrderbook.normal
@@ -143,7 +182,8 @@ export default <TestSuite>{
    })
  },

-  'direction is correct for bids and asks': async (client, address) => {
+  'direction is correct for bids and asks': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'book_offers'}, normalRippledResponse)
    const response = await client.getOrderbook(
      address,
      requests.getOrderbook.normal
--- a/test/client/getPaths.ts
+++ b/test/client/getPaths.ts
@@ -2,10 +2,18 @@ import assert from 'assert-diff'
 import { assertRejects, TestSuite } from '../testUtils'
 import requests from '../fixtures/requests'
 // import responses from '../fixtures/responses'
+import rippled from '../fixtures/rippled'
 import addresses from '../fixtures/addresses.json'
 const {getPaths: REQUEST_FIXTURES} = requests
 // const {getPaths: RESPONSE_FIXTURES} = responses

+const rippledResponse = rippled.path_find.generate.generateIOUPaymentPaths(
+  0,
+  REQUEST_FIXTURES.normal.source.address,
+  REQUEST_FIXTURES.normal.destination.address,
+  REQUEST_FIXTURES.normal.destination.amount
+)
+
 /**
 * Every test suite exports their tests in the default object.
 * - Check out the "TestSuite" type for documentation on the interface.
@@ -38,7 +46,8 @@ export default <TestSuite>{
  //   const response = await client.getPaths(REQUEST_FIXTURES.XrpToXrp)
  //   assertResultMatch(response, RESPONSE_FIXTURES.XrpToXrp, 'getPaths')
  // },
-  'source with issuer': async (client) => {
+  'source with issuer': async (client, _, mockRippled) => {
+    mockRippled.addResponse({command: 'ripple_path_find'}, rippledResponse)
    return assertRejects(
      client.getPaths(REQUEST_FIXTURES.issuer),
      client.errors.NotFoundError
@@ -50,36 +59,42 @@ export default <TestSuite>{
  //     client.errors.NotFoundError
  //   )
  // },
-  'invalid PathFind': async (client) => {
+  'invalid PathFind': async (client, _, mockRippled) => {
+    mockRippled.addResponse({command: 'ripple_path_find'}, rippledResponse)
    assert.throws(() => {
      client.getPaths(REQUEST_FIXTURES.invalid)
    }, /Cannot specify both source.amount/)
  },
-  'does not accept currency': async (client) => {
+  'does not accept currency': async (client, _, mockRippled) => {
+    mockRippled.addResponse({command: 'ripple_path_find'}, rippledResponse)
    return assertRejects(
      client.getPaths(REQUEST_FIXTURES.NotAcceptCurrency),
      client.errors.NotFoundError
    )
  },
-  'no paths': async (client) => {
+  'no paths': async (client, _, mockRippled) => {
+    mockRippled.addResponse({command: 'ripple_path_find'}, rippledResponse)
    return assertRejects(
      client.getPaths(REQUEST_FIXTURES.NoPaths),
      client.errors.NotFoundError
    )
  },
-  'no paths source amount': async (client) => {
+  'no paths source amount': async (client, _, mockRippled) => {
+    mockRippled.addResponse({command: 'ripple_path_find'}, rippledResponse)
    return assertRejects(
      client.getPaths(REQUEST_FIXTURES.NoPathsSource),
      client.errors.NotFoundError
    )
  },
-  'no paths with source currencies': async (client) => {
+  'no paths with source currencies': async (client, _, mockRippled) => {
+    mockRippled.addResponse({command: 'ripple_path_find'}, rippledResponse)
    return assertRejects(
      client.getPaths(REQUEST_FIXTURES.NoPathsWithCurrencies),
      client.errors.NotFoundError
    )
  },
-  'error: srcActNotFound': async (client) => {
+  'error: srcActNotFound': async (client, _, mockRippled) => {
+    mockRippled.addResponse({command: 'ripple_path_find'}, rippledResponse)
    return assertRejects(
      client.getPaths({
        ...REQUEST_FIXTURES.normal,
--- a/test/client/getTrustlines.ts
+++ b/test/client/getTrustlines.ts
@@ -1,5 +1,6 @@
 import addresses from '../fixtures/addresses.json'
 import responses from '../fixtures/responses'
+import rippled from '../fixtures/rippled/accountLines'
 import {assertResultMatch, TestSuite} from '../testUtils'
 const {getTrustlines: RESPONSE_FIXTURES} = responses

@@ -9,28 +10,32 @@ const {getTrustlines: RESPONSE_FIXTURES} = responses
 * - Check out "test/client/index.ts" for more information about the test runner.
 */
 export default <TestSuite>{
-  'getTrustlines - filtered': async (client, address) => {
+  'getTrustlines - filtered': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'account_lines'}, rippled.normal)
    const options = {currency: 'USD'}
    const result = await client.getTrustlines(address, options)
    assertResultMatch(result, RESPONSE_FIXTURES.filtered, 'getTrustlines')
  },

-  // 'getTrustlines - more than 400 items': async (client, address) => {
-  //   const options = {limit: 401}
-  //   const result = await client.getTrustlines(addresses.THIRD_ACCOUNT, options)
-  //   assertResultMatch(
-  //     result,
-  //     RESPONSE_FIXTURES.moreThan400Items,
-  //     'getTrustlines'
-  //   )
-  // },
+  'getTrustlines - more than 400 items': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'account_lines'}, rippled.manyItems)
+    const options = {limit: 401}
+    const result = await client.getTrustlines(address, options)
+    assertResultMatch(
+      result,
+      RESPONSE_FIXTURES.moreThan400Items,
+      'getTrustlines'
+    )
+  },

-  'getTrustlines - no options': async (client, address) => {
+  'getTrustlines - no options': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'account_lines'}, rippled.normal)
    await client.getTrustlines(address)
  },

-  'getTrustlines - ripplingDisabled works properly': async (client, address) => {
-    const result = await client.getTrustlines(addresses.FOURTH_ACCOUNT)
+  'getTrustlines - ripplingDisabled works properly': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'account_lines'}, rippled.ripplingDisabled)
+    const result = await client.getTrustlines(address)
    assertResultMatch(
      result,
      RESPONSE_FIXTURES.ripplingDisabled,
@@ -38,12 +43,13 @@ export default <TestSuite>{
    )
  },

-  // 'getTrustlines - ledger version option': async (client, address) => {
-  //   const result = await client.getTrustlines(addresses.FOURTH_ACCOUNT, {ledgerVersion: 5})
-  //   assertResultMatch(
-  //     result,
-  //     RESPONSE_FIXTURES.moreThan400Items,
-  //     'getTrustlines'
-  //   )
-  // },
+  'getTrustlines - ledger version option': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'account_lines'}, rippled.manyItems)
+    const result = await client.getTrustlines(addresses.FOURTH_ACCOUNT, {ledgerVersion: 5})
+    assertResultMatch(
+      result,
+      RESPONSE_FIXTURES.moreThan400Items,
+      'getTrustlines'
+    )
+  },
 }
--- a/test/client/hasNextPage.ts
+++ b/test/client/hasNextPage.ts
@@ -1,5 +1,6 @@
 import assert from 'assert-diff'
 import {TestSuite} from '../testUtils'
+import rippled from '../fixtures/rippled'

 /**
 * Every test suite exports their tests in the default object.
@@ -7,13 +8,22 @@ import {TestSuite} from '../testUtils'
 * - Check out "test/client/index.ts" for more information about the test runner.
 */
 export default <TestSuite>{
-  'returns true when there is another page': async (client, address) => {
+  'returns true when there is another page': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'ledger_data'}, rippled.ledger_data.first_page)
    // @ts-ignore
    const response = await client.request({command: 'ledger_data'})
    assert(client.hasNextPage(response))
  },

-  'returns false when there are no more pages': async (client, address) => {
+  'returns false when there are no more pages': async (client, address, mockRippled) => {
+    const rippledResponse = function(request: Request) : object {
+      if ('marker' in request) {
+        return rippled.ledger_data.last_page
+      } else {
+        return rippled.ledger_data.first_page
+      }
+    }
+    mockRippled.addResponse({command: 'ledger_data'}, rippledResponse)
    // @ts-ignore
    const response = await client.request({command: 'ledger_data'})
    const responseNextPage = await client.requestNextPage(
--- a/test/client/prepareCheckCancel.ts
+++ b/test/client/prepareCheckCancel.ts
@@ -12,6 +12,9 @@ const instructionsWithMaxLedgerVersionOffset = {maxLedgerVersionOffset: 100}
 export default <TestSuite>{
  'prepareCheckCancel': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareCheckCancel(
      address,
      requests.prepareCheckCancel.normal
@@ -21,6 +24,9 @@ export default <TestSuite>{

  'with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
--- a/test/client/prepareCheckCash.ts
+++ b/test/client/prepareCheckCash.ts
@@ -12,6 +12,9 @@ const instructionsWithMaxLedgerVersionOffset = {maxLedgerVersionOffset: 100}
 export default <TestSuite>{
  'prepareCheckCash amount': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareCheckCash(
      address,
      requests.prepareCheckCash.amount
@@ -21,6 +24,9 @@ export default <TestSuite>{

  'prepareCheckCash deliverMin': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareCheckCash(
      address,
      requests.prepareCheckCash.deliverMin
@@ -30,6 +36,9 @@ export default <TestSuite>{

  'with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
--- a/test/client/prepareCheckCreate.ts
+++ b/test/client/prepareCheckCreate.ts
@@ -12,6 +12,9 @@ const instructionsWithMaxLedgerVersionOffset = {maxLedgerVersionOffset: 100}
 export default <TestSuite>{
  'prepareCheckCreate': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -26,6 +29,9 @@ export default <TestSuite>{

  'prepareCheckCreate full': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareCheckCreate(
      address,
      requests.prepareCheckCreate.full
@@ -35,6 +41,9 @@ export default <TestSuite>{

  'prepareCheckCreate with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
--- a/test/client/prepareEscrowCancellation.ts
+++ b/test/client/prepareEscrowCancellation.ts
@@ -12,6 +12,9 @@ const instructionsWithMaxLedgerVersionOffset = {maxLedgerVersionOffset: 100}
 export default <TestSuite>{
  'prepareEscrowCancellation': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareEscrowCancellation(
      address,
      requests.prepareEscrowCancellation.normal,
@@ -26,6 +29,9 @@ export default <TestSuite>{

  'prepareEscrowCancellation with memos': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareEscrowCancellation(
      address,
      requests.prepareEscrowCancellation.memos
@@ -39,6 +45,9 @@ export default <TestSuite>{

  'with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
--- a/test/client/prepareEscrowCreation.ts
+++ b/test/client/prepareEscrowCreation.ts
@@ -19,6 +19,9 @@ export const config = {
 export default <TestSuite>{
  'prepareEscrowCreation': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -33,6 +36,9 @@ export default <TestSuite>{

  'prepareEscrowCreation full': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareEscrowCreation(
      address,
      requests.prepareEscrowCreation.full
@@ -42,6 +48,9 @@ export default <TestSuite>{

  'prepareEscrowCreation - invalid': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const escrow = Object.assign({}, requests.prepareEscrowCreation.full)
    delete escrow.amount // Make invalid
    await assertRejects(
@@ -53,6 +62,9 @@ export default <TestSuite>{

  'with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000396',
--- a/test/client/prepareEscrowExecution.ts
+++ b/test/client/prepareEscrowExecution.ts
@@ -12,6 +12,9 @@ const instructionsWithMaxLedgerVersionOffset = {maxLedgerVersionOffset: 100}
 export default <TestSuite>{
  'prepareEscrowExecution': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareEscrowExecution(
      address,
      requests.prepareEscrowExecution.normal,
@@ -26,6 +29,9 @@ export default <TestSuite>{

  'prepareEscrowExecution - simple': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareEscrowExecution(
      address,
      requests.prepareEscrowExecution.simple
@@ -39,6 +45,9 @@ export default <TestSuite>{

  'prepareEscrowExecution - no condition': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    await assertRejects(
      client.prepareEscrowExecution(
        address,
@@ -52,6 +61,9 @@ export default <TestSuite>{

  'prepareEscrowExecution - no fulfillment': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    await assertRejects(
      client.prepareEscrowExecution(
        address,
@@ -65,6 +77,9 @@ export default <TestSuite>{

  'with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000396',
--- a/test/client/prepareOrder.ts
+++ b/test/client/prepareOrder.ts
@@ -12,6 +12,9 @@ const instructionsWithMaxLedgerVersionOffset = {maxLedgerVersionOffset: 100}
 export default <TestSuite>{
  'buy order': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const request = requests.prepareOrder.buy
    const result = await client.prepareOrder(address, request)
    assertResultMatch(result, responses.prepareOrder.buy, 'prepare')
@@ -19,6 +22,9 @@ export default <TestSuite>{

  'buy order with expiration': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const request = requests.prepareOrder.expiration
    const response = responses.prepareOrder.expiration
    const result = await client.prepareOrder(
@@ -31,6 +37,9 @@ export default <TestSuite>{

  'sell order': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const request = requests.prepareOrder.sell
    const result = await client.prepareOrder(
      address,
@@ -42,6 +51,9 @@ export default <TestSuite>{

  'invalid': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const request = Object.assign({}, requests.prepareOrder.sell)
    delete request.direction // Make invalid
    await assertRejects(
@@ -57,6 +69,9 @@ export default <TestSuite>{

  'with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const request = requests.prepareOrder.sell
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
--- a/test/client/prepareOrderCancellation.ts
+++ b/test/client/prepareOrderCancellation.ts
@@ -12,6 +12,9 @@ const instructionsWithMaxLedgerVersionOffset = {maxLedgerVersionOffset: 100}
 export default <TestSuite>{
  'prepareOrderCancellation': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const request = requests.prepareOrderCancellation.simple
    const result = await client.prepareOrderCancellation(
      address,
@@ -27,6 +30,9 @@ export default <TestSuite>{

  'no instructions': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const request = requests.prepareOrderCancellation.simple
    const result = await client.prepareOrderCancellation(address, request)
    assertResultMatch(
@@ -38,6 +44,9 @@ export default <TestSuite>{

  'with memos': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const request = requests.prepareOrderCancellation.withMemos
    const result = await client.prepareOrderCancellation(address, request)
    assertResultMatch(
@@ -49,6 +58,9 @@ export default <TestSuite>{

  'invalid': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const request = Object.assign(
      {},
      requests.prepareOrderCancellation.withMemos
@@ -64,6 +76,9 @@ export default <TestSuite>{

  'with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const request = requests.prepareOrderCancellation.simple
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
--- a/test/client/preparePayment.ts
+++ b/test/client/preparePayment.ts
@@ -21,6 +21,9 @@ const RECIPIENT_ADDRESS = 'rpZc4mVfWUif9CRoHRKKcmhu1nx2xktxBo'
 export default <TestSuite>{
  'normal': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -35,6 +38,9 @@ export default <TestSuite>{

  'min amount xrp': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -49,6 +55,9 @@ export default <TestSuite>{

  'min amount xrp2xrp': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const response = await client.preparePayment(
      address,
      REQUEST_FIXTURES.minAmount,
@@ -59,6 +68,9 @@ export default <TestSuite>{

  'XRP to XRP': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const payment = {
      source: {
        address: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
@@ -88,6 +100,9 @@ export default <TestSuite>{

  'XRP drops to XRP drops': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const payment = {
      source: {
        address: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
@@ -117,6 +132,9 @@ export default <TestSuite>{

  'XRP drops to XRP': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const payment = {
      source: {
        address: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
@@ -146,6 +164,9 @@ export default <TestSuite>{

  'XRP to XRP drops': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const payment = {
      source: {
        address: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
@@ -180,6 +201,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const payment = {
      source: {
        address: address,
@@ -205,6 +229,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    // Marking as "any" to get around the fact that TS won't allow this.
    const payment: any = {
      source: {address: address},
@@ -227,6 +254,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const payment = {
      source: {
        address: address,
@@ -246,6 +276,9 @@ export default <TestSuite>{

  'XRP to XRP no partial': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    return assertRejects(
      client.preparePayment(address, REQUEST_FIXTURES.wrongPartial),
      ValidationError,
@@ -255,6 +288,9 @@ export default <TestSuite>{

  'address must match payment.source.address': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    return assertRejects(
      client.preparePayment(address, REQUEST_FIXTURES.wrongAddress),
      ValidationError,
@@ -264,6 +300,9 @@ export default <TestSuite>{

  'wrong amount': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    return assertRejects(
      client.preparePayment(address, REQUEST_FIXTURES.wrongAmount),
      ValidationError,
@@ -273,6 +312,9 @@ export default <TestSuite>{

  'throws when fee exceeds 2 XRP': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      fee: '2.1'
@@ -301,6 +343,9 @@ export default <TestSuite>{

  'preparePayment without counterparty set': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      sequence: 23
@@ -319,6 +364,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    // See also: 'sign succeeds with source.amount/destination.minAmount'

    const localInstructions = {
@@ -369,6 +417,9 @@ export default <TestSuite>{

  'destination.minAmount': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const response = await client.preparePayment(
      address,
      responses.getPaths.sendAll[0],
@@ -379,6 +430,9 @@ export default <TestSuite>{

  'caps fee at 2 XRP by default': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    client._feeCushion = 1000000
    const expectedResponse = {
      txJSON:
@@ -403,6 +457,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    client._maxFeeXRP = '2.2'
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
@@ -427,6 +484,9 @@ export default <TestSuite>{

  'fee - default maxFee of 2 XRP': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    client._feeCushion = 1000000
    const expectedResponse = {
      txJSON:
@@ -451,6 +511,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    client._feeCushion = 1000000
    client._maxFeeXRP = '3'
    const localInstructions = {
@@ -476,6 +539,9 @@ export default <TestSuite>{

  'fee - capped to maxFee': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    client._feeCushion = 1000000
    client._maxFeeXRP = '5'
    const localInstructions = {
--- a/test/client/preparePaymentChannelClaim.ts
+++ b/test/client/preparePaymentChannelClaim.ts
@@ -15,6 +15,9 @@ const {preparePaymentChannelClaim: RESPONSE_FIXTURES} = responses
 export default <TestSuite>{
  'default': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -29,6 +32,9 @@ export default <TestSuite>{

  'with renew': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -43,6 +49,9 @@ export default <TestSuite>{

  'with close': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -57,6 +66,9 @@ export default <TestSuite>{

  'with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
@@ -76,6 +88,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    try {
      const prepared = await client.preparePaymentChannelClaim(
        address,
@@ -100,6 +115,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    try {
      const prepared = await client.preparePaymentChannelClaim(
        address,
--- a/test/client/preparePaymentChannelCreate.ts
+++ b/test/client/preparePaymentChannelCreate.ts
@@ -19,6 +19,9 @@ export const config = {
 export default <TestSuite>{
  'preparePaymentChannelCreate': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -37,6 +40,9 @@ export default <TestSuite>{

  'preparePaymentChannelCreate full': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.preparePaymentChannelCreate(
      address,
      requests.preparePaymentChannelCreate.full
@@ -50,6 +56,9 @@ export default <TestSuite>{

  'preparePaymentChannelCreate with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
--- a/test/client/preparePaymentChannelFund.ts
+++ b/test/client/preparePaymentChannelFund.ts
@@ -12,6 +12,9 @@ const instructionsWithMaxLedgerVersionOffset = {maxLedgerVersionOffset: 100}
 export default <TestSuite>{
  'preparePaymentChannelFund': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -30,6 +33,9 @@ export default <TestSuite>{

  'preparePaymentChannelFund full': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.preparePaymentChannelFund(
      address,
      requests.preparePaymentChannelFund.full
@@ -43,6 +49,9 @@ export default <TestSuite>{

  'with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
--- a/test/client/prepareSettings.ts
+++ b/test/client/prepareSettings.ts
@@ -13,6 +13,9 @@ const instructionsWithMaxLedgerVersionOffset = {maxLedgerVersionOffset: 100}
 export default <TestSuite>{
  'simple test': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const response = await client.prepareSettings(
      address,
      requests.prepareSettings.domain,
@@ -22,6 +25,9 @@ export default <TestSuite>{
  },
  'no maxLedgerVersion': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const response = await client.prepareSettings(
      address,
      requests.prepareSettings.domain,
@@ -37,6 +43,9 @@ export default <TestSuite>{
  },
  'no instructions': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const response = await client.prepareSettings(
      address,
      requests.prepareSettings.domain
@@ -49,6 +58,9 @@ export default <TestSuite>{
  },
  'regularKey': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const regularKey = {regularKey: 'rAR8rR8sUkBoCZFawhkWzY4Y5YoyuznwD'}
    const response = await client.prepareSettings(
      address,
@@ -59,6 +71,9 @@ export default <TestSuite>{
  },
  'remove regularKey': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const regularKey = {regularKey: null}
    const response = await client.prepareSettings(
      address,
@@ -73,6 +88,9 @@ export default <TestSuite>{
  },
  'flag set': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const settings = {requireDestinationTag: true}
    const response = await client.prepareSettings(
      address,
@@ -83,6 +101,9 @@ export default <TestSuite>{
  },
  'flag clear': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const settings = {requireDestinationTag: false}
    const response = await client.prepareSettings(
      address,
@@ -93,6 +114,9 @@ export default <TestSuite>{
  },
  'set depositAuth flag': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const settings = {depositAuth: true}
    const response = await client.prepareSettings(
      address,
@@ -107,6 +131,9 @@ export default <TestSuite>{
  },
  'clear depositAuth flag': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const settings = {depositAuth: false}
    const response = await client.prepareSettings(
      address,
@@ -121,6 +148,9 @@ export default <TestSuite>{
  },
  'integer field clear': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const settings = {transferRate: null}
    const response = await client.prepareSettings(
      address,
@@ -132,6 +162,9 @@ export default <TestSuite>{
  },
  'set transferRate': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const settings = {transferRate: 1}
    const response = await client.prepareSettings(
      address,
@@ -146,6 +179,9 @@ export default <TestSuite>{
  },
  'set signers': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const settings = requests.prepareSettings.signers.normal
    const response = await client.prepareSettings(
      address,
@@ -156,6 +192,9 @@ export default <TestSuite>{
  },
  'signers no threshold': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const settings = requests.prepareSettings.signers.noThreshold
    try {
      const response = await client.prepareSettings(
@@ -177,6 +216,9 @@ export default <TestSuite>{
  },
  'signers no weights': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const settings = requests.prepareSettings.signers.noWeights
    const localInstructions = {
      signersCount: 1,
@@ -191,6 +233,9 @@ export default <TestSuite>{
  },
  'fee for multisign': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      signersCount: 4,
      ...instructionsWithMaxLedgerVersionOffset
@@ -208,6 +253,9 @@ export default <TestSuite>{
  },
  'no signer list': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const settings = requests.prepareSettings.noSignerEntries
    const localInstructions = {
      signersCount: 1,
@@ -226,6 +274,9 @@ export default <TestSuite>{
  },
  'invalid': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    // domain must be a string
    const settings = Object.assign({}, requests.prepareSettings.domain, {
      domain: 123
@@ -255,6 +306,9 @@ export default <TestSuite>{
  },
  'offline': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const secret = 'shsWGZcmZz6YsWWmcnpfr6fLTdtFV'

    const settings = requests.prepareSettings.domain
@@ -272,6 +326,9 @@ export default <TestSuite>{
  },
  'prepare settings with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const instructions = {
      ticketSequence: 23,
      maxLedgerVersion: 8820051,
--- a/test/client/prepareTicket.ts
+++ b/test/client/prepareTicket.ts
@@ -25,6 +25,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const expected = {
      txJSON:
        '{"TransactionType":"TicketCreate", "TicketCount": 2, "Account":"r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59","Flags":2147483648,"LastLedgerSequence":8819954,"Sequence":23,"Fee":"12"}',
@@ -40,6 +43,9 @@ export default <TestSuite>{

  'creates a ticket successfully with another ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const expected = {
      txJSON:
        '{"TransactionType":"TicketCreate", "TicketCount": 1, "Account":"r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59","Flags":2147483648,"LastLedgerSequence":8819954,"Sequence": 0,"TicketSequence":23,"Fee":"12"}',
--- a/test/client/prepareTransaction.ts
+++ b/test/client/prepareTransaction.ts
@@ -25,6 +25,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = instructionsWithMaxLedgerVersionOffset
    const txJSON = {
      TransactionType: 'DepositPreauth',
@@ -46,6 +49,9 @@ export default <TestSuite>{

  'does not overwrite Fee in Instructions': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      fee: '0.000014' // CAUTION: This `fee` is specified in XRP, not drops.
@@ -73,6 +79,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      fee: '0.000016'
@@ -96,6 +105,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      fee: '0.000018'
@@ -119,6 +131,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      Fee: '0.000022' // Intentionally capitalized in this test, but the correct field would be `fee`
@@ -141,6 +156,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = instructionsWithMaxLedgerVersionOffset
    const txJSON = {
      TransactionType: 'DepositPreauth',
@@ -157,6 +175,9 @@ export default <TestSuite>{

  'does not overwrite Sequence in txJSON': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -181,6 +202,9 @@ export default <TestSuite>{

  'does not overwrite Sequence in Instructions': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
@@ -209,6 +233,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
@@ -238,6 +265,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
@@ -262,6 +292,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
@@ -283,6 +316,9 @@ export default <TestSuite>{

  'does not overwrite LastLedgerSequence in txJSON': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {}
    const txJSON = {
      TransactionType: 'DepositPreauth',
@@ -309,6 +345,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      maxLedgerVersion: 8890000
    }
@@ -335,6 +374,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxLedgerVersionOffset: 124
@@ -362,6 +404,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      maxLedgerVersion: 8900000
    }
@@ -385,6 +430,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxLedgerVersionOffset: 123
@@ -409,6 +457,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxLedgerVersion: 8900000,
@@ -433,6 +484,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxLedgerVersion: 8900000,
@@ -458,6 +512,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      MaxLedgerVersion: 8900000 // Intentionally capitalized in this test, but the correct field would be `maxLedgerVersion`
@@ -480,6 +537,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = instructionsWithMaxLedgerVersionOffset
    const txJSON = {
      TransactionType: 'DepositPreauth',
@@ -500,6 +560,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = instructionsWithMaxLedgerVersionOffset
    const txJSON = {
      TransactionType: 'DepositPreauth',
@@ -520,6 +583,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = instructionsWithMaxLedgerVersionOffset
    const txJSON = {
      TransactionType: 'DepositPreauth',
@@ -544,6 +610,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
@@ -563,6 +632,9 @@ export default <TestSuite>{

  'rejects Promise when Account is missing': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -581,6 +653,9 @@ export default <TestSuite>{

  'rejects Promise when Account is not a string': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -600,6 +675,9 @@ export default <TestSuite>{

  'rejects Promise when Account is invalid': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -637,6 +715,9 @@ export default <TestSuite>{

  'rejects Promise when TransactionType is missing': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -660,6 +741,9 @@ export default <TestSuite>{
  // at Function.from (ripple-binary-codec/distrib/npm/enums/index.js:43:15)
  'prepares tx when TransactionType is invalid': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -687,6 +771,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -726,6 +813,9 @@ export default <TestSuite>{
  //     'C181D470684311658852713DA81F8201062535C8DE2FF853F7DD9981BB85312F' } })]
  'prepares tx when a required field is missing': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -749,6 +839,9 @@ export default <TestSuite>{

  'DepositPreauth - Authorize': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -775,6 +868,9 @@ export default <TestSuite>{

  'DepositPreauth - Unauthorize': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -803,6 +899,9 @@ export default <TestSuite>{

  'AccountDelete': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '5.0' // 5 XRP fee for AccountDelete
@@ -832,6 +931,9 @@ export default <TestSuite>{
  // prepareTransaction - Payment
  'Payment - normal': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -860,6 +962,9 @@ export default <TestSuite>{

  'min amount xrp': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -893,6 +998,9 @@ export default <TestSuite>{

  'min amount xrp2xrp': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const txJSON = {
      TransactionType: 'Payment',
      Account: address,
@@ -955,6 +1063,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    client._feeCushion = 1000000

    const txJSON = {
@@ -994,6 +1105,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    client._feeCushion = 1000000

    const txJSON = {
@@ -1038,6 +1152,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    client._feeCushion = 1000000
    client._maxFeeXRP = '3'
    const localInstructions = {
@@ -1079,6 +1196,9 @@ export default <TestSuite>{
  // prepareTransaction - Payment
  'fee is capped to maxFee': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    client._feeCushion = 1000000
    client._maxFeeXRP = '5'
    const localInstructions = {
@@ -1147,6 +1267,9 @@ export default <TestSuite>{

  'xaddress-issuer': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -1175,6 +1298,9 @@ export default <TestSuite>{

  'PaymentChannelCreate': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -1205,6 +1331,9 @@ export default <TestSuite>{

  'PaymentChannelCreate full': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const txJSON = {
      Account: address,
      TransactionType: 'PaymentChannelCreate',
@@ -1228,6 +1357,9 @@ export default <TestSuite>{

  'PaymentChannelFund': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -1249,6 +1381,9 @@ export default <TestSuite>{

  'PaymentChannelFund full': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const txJSON = {
      Account: address,
      TransactionType: 'PaymentChannelFund',
@@ -1268,6 +1403,9 @@ export default <TestSuite>{

  'PaymentChannelClaim': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -1291,6 +1429,9 @@ export default <TestSuite>{

  'PaymentChannelClaim with renew': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -1321,6 +1462,9 @@ export default <TestSuite>{

  'PaymentChannelClaim with close': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012'
@@ -1355,6 +1499,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ticketSequence: 23,
      sequence: 23
@@ -1374,6 +1521,9 @@ export default <TestSuite>{

  'sets sequence to 0 if a ticketSequence is passed': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
@@ -1407,6 +1557,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
--- a/test/client/prepareTrustline.ts
+++ b/test/client/prepareTrustline.ts
@@ -12,6 +12,9 @@ const instructionsWithMaxLedgerVersionOffset = {maxLedgerVersionOffset: 100}
 export default <TestSuite>{
  'simple': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareTrustline(
      address,
      requests.prepareTrustline.simple,
@@ -22,6 +25,9 @@ export default <TestSuite>{

  'frozen': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareTrustline(
      address,
      requests.prepareTrustline.frozen
@@ -31,6 +37,9 @@ export default <TestSuite>{

  'complex': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareTrustline(
      address,
      requests.prepareTrustline.complex,
@@ -41,6 +50,9 @@ export default <TestSuite>{

  'invalid': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const trustline = Object.assign({}, requests.prepareTrustline.complex)
    delete trustline.limit // Make invalid

@@ -57,6 +69,9 @@ export default <TestSuite>{

  'xaddress-issuer': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const result = await client.prepareTrustline(
      address,
      requests.prepareTrustline.issuedXAddress,
@@ -67,6 +82,9 @@ export default <TestSuite>{

  'with ticket': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const localInstructions = {
      ...instructionsWithMaxLedgerVersionOffset,
      maxFee: '0.000012',
--- a/test/client/requestNextPage.ts
+++ b/test/client/requestNextPage.ts
@@ -1,5 +1,14 @@
 import assert from 'assert-diff'
 import {assertRejects, TestSuite} from '../testUtils'
+import rippled from '../fixtures/rippled'
+
+const rippledResponse = function(request: Request) : object {
+  if ('marker' in request) {
+    return rippled.ledger_data.last_page
+  } else {
+    return rippled.ledger_data.first_page
+  }
+}

 /**
 * Every test suite exports their tests in the default object.
@@ -7,7 +16,8 @@ import {assertRejects, TestSuite} from '../testUtils'
 * - Check out "test/client/index.ts" for more information about the test runner.
 */
 export default <TestSuite>{
-  'requests the next page': async (client, address) => {
+  'requests the next page': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'ledger_data'}, rippledResponse)
    // @ts-ignore
    const response = await client.request({command: 'ledger_data'})
    const responseNextPage = await client.requestNextPage(
@@ -22,7 +32,8 @@ export default <TestSuite>{
    )
  },

-  'rejects when there are no more pages': async (client, address) => {
+  'rejects when there are no more pages': async (client, address, mockRippled) => {
+    mockRippled.addResponse({command: 'ledger_data'}, rippledResponse)
    // @ts-ignore
    const response = await client.request({command: 'ledger_data'})
    const responseNextPage = await client.requestNextPage(
--- a/test/client/sign.ts
+++ b/test/client/sign.ts
@@ -60,6 +60,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const secret = 'shsWGZcmZz6YsWWmcnpfr6fLTdtFV'
    const payment = {
      source: {
@@ -168,6 +171,9 @@ export default <TestSuite>{

  'succeeds - prepared payment': async (client, address, mockRippled) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const payment = await client.preparePayment(address, {
      source: {
        address: address,
@@ -244,6 +250,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const payment = await client.preparePayment(address, {
      source: {
        address: address,
@@ -272,6 +281,9 @@ export default <TestSuite>{
    mockRippled
  ) => {
    mockRippled.addResponse({command: 'server_info'}, rippled.server_info.normal)
+    mockRippled.addResponse({command: 'fee'}, rippled.fee)
+    mockRippled.addResponse({command: 'ledger_current'}, rippled.ledger_current)
+    mockRippled.addResponse({command: 'account_info'}, rippled.account_info.normal)
    const order = {
      direction: 'sell',
      quantity: {
--- a/test/connection.ts
+++ b/test/connection.ts
@@ -4,6 +4,7 @@ import assert from 'assert-diff'
 import setupClient from './setupClient'
 import {Client} from 'xrpl-local'
 import {ignoreWebSocketDisconnect} from './testUtils'
+import rippled from './fixtures/rippled'
 const utils = Client._PRIVATE.ledgerUtils

 const TIMEOUT = 200000 // how long before each test case times out
@@ -158,6 +159,7 @@ describe('Connection', function () {
  })

  it('DisconnectedError', async function () {
+    this.mockRippled.suppressOutput = true
    this.mockRippled.on(`request_server_info`, function (request, conn) {
      assert.strictEqual(request.command, 'server_info')
      conn.close()
@@ -505,7 +507,9 @@ describe('Connection', function () {
  })

  it('propagates RippledError data', function (done) {
-    this.client.request({command: 'subscribe', streams: 'validations'}).catch((error) => {
+    const request = {command: 'subscribe', streams: 'validations'}
+    this.mockRippled.addResponse(request, rippled.subscribe.error)
+    this.client.request(request).catch((error) => {
      assert.strictEqual(error.name, 'RippledError')
      assert.strictEqual(error.data.error, 'invalidParams')
      assert.strictEqual(error.message, 'Invalid parameters.')
--- a/test/fixtures/rippled/accountLines.js
+++ b/test/fixtures/rippled/accountLines.js
@@ -35,7 +35,7 @@ module.exports.normal = function(request, options = {}) {
    ledger: BASE_LEDGER_INDEX
  });

-  return JSON.stringify({
+  return {
    id: request.id,
    status: 'success',
    type: 'response',
@@ -281,7 +281,7 @@ module.exports.normal = function(request, options = {}) {
      }
      ].filter(item => !request.peer || item.account === request.peer)
    }
-  });
+  };
 };

 module.exports.counterparty = function(request, options = {}) {
@@ -289,7 +289,7 @@ module.exports.counterparty = function(request, options = {}) {
    ledger: BASE_LEDGER_INDEX
  });

-  return JSON.stringify({
+  return {
    id: request.id,
    status: 'success',
    type: 'response',
@@ -347,7 +347,7 @@ module.exports.counterparty = function(request, options = {}) {
      }
      ]
    }
-  });
+  };
 };

 module.exports.manyItems = function(request, options = {}) {
@@ -357,7 +357,7 @@ module.exports.manyItems = function(request, options = {}) {

  const {marker, lines} = getMarkerAndLinesFromRequest(request);

-  return JSON.stringify({
+  return {
    id: request.id,
    status: 'success',
    type: 'response',
@@ -368,7 +368,7 @@ module.exports.manyItems = function(request, options = {}) {
      ledger_index: options.ledger,
      lines
    }
-  });
+  };
 };


@@ -377,7 +377,7 @@ module.exports.ripplingDisabled = function(request, options = {}) {
    ledger: BASE_LEDGER_INDEX
  });

-  return JSON.stringify({
+  return {
    id: request.id,
    status: 'success',
    type: 'response',
@@ -405,5 +405,5 @@ module.exports.ripplingDisabled = function(request, options = {}) {
            'quality_in': 0,
            'quality_out': 0}]
    }
-  });
+  };
 };
--- a/test/fixtures/rippled/bookOffers.js
+++ b/test/fixtures/rippled/bookOffers.js
@@ -8,7 +8,7 @@ module.exports.requestBookOffersBidsResponse = function(request) {
    pays: request.taker_pays
  }

-  return JSON.stringify({
+  return {
    id: request.id,
    status: 'success',
    type: 'response',
@@ -320,7 +320,7 @@ module.exports.requestBookOffersBidsResponse = function(request) {
      ],
      validated: false
    }
-  })
+  }
 }

 module.exports.requestBookOffersBidsPartialFundedResponse = function(
@@ -338,7 +338,7 @@ module.exports.requestBookOffersBidsPartialFundedResponse = function(
    }
  })

-  return JSON.stringify({
+  return {
    id: request.id,
    status: 'success',
    type: 'response',
@@ -384,7 +384,7 @@ module.exports.requestBookOffersBidsPartialFundedResponse = function(
        }
      ]
    }
-  })
+  }
 }

 module.exports.requestBookOffersAsksPartialFundedResponse = function(
@@ -402,7 +402,7 @@ module.exports.requestBookOffersAsksPartialFundedResponse = function(
    }
  })

-  return JSON.stringify({
+  return {
    id: request.id,
    status: 'success',
    type: 'response',
@@ -448,7 +448,7 @@ module.exports.requestBookOffersAsksPartialFundedResponse = function(
        }
      ]
    }
-  })
+  }
 }

 module.exports.requestBookOffersAsksResponse = function(request) {
@@ -457,7 +457,7 @@ module.exports.requestBookOffersAsksResponse = function(request) {
    pays: request.taker_pays
  }

-  return JSON.stringify({
+  return {
    id: request.id,
    result: {
      ledger_index: 10716345,
@@ -767,11 +767,11 @@ module.exports.requestBookOffersAsksResponse = function(request) {
    },
    status: 'success',
    type: 'response'
-  })
+  }
 }

 module.exports.requestBookOffersXRPBaseResponse = function(request) {
-  return JSON.stringify({
+  return {
    id: request.id,
    status: 'success',
    type: 'response',
@@ -1039,11 +1039,11 @@ module.exports.requestBookOffersXRPBaseResponse = function(request) {
      ],
      validated: true
    }
-  })
+  }
 }

 module.exports.requestBookOffersXRPCounterResponse = function(request) {
-  return JSON.stringify({
+  return {
    id: request.id,
    status: 'success',
    type: 'response',
@@ -1295,5 +1295,5 @@ module.exports.requestBookOffersXRPCounterResponse = function(request) {
      ],
      validated: true
    }
-  })
+  }
 }
--- a/test/fixtures/rippled/index.js
+++ b/test/fixtures/rippled/index.js
@@ -42,6 +42,7 @@ module.exports = {
    usd_xrp: require('./bookOffersUsdXrp'),
    xrp_usd: require('./bookOffersXrpUsd')
  },
+  ledger_current: require('./ledgerCurrent'),
  ledger_data: {
    first_page: require('./ledgerDataFirstPage'),
    last_page: require('./ledgerDataLastPage')
--- a/test/fixtures/rippled/ledgerCurrent.json
+++ b/test/fixtures/rippled/ledgerCurrent.json
@@ -0,0 +1,8 @@
+{
+  "id": 0,
+  "status": "success",
+  "type": "response",
+  "result": {
+    "ledger_current_index": 8819951
+  }
+}
--- a/test/fixtures/rippled/pathFind.js
+++ b/test/fixtures/rippled/pathFind.js
@@ -2,7 +2,7 @@

 module.exports.generateIOUPaymentPaths =
 function(request_id, sendingAccount, destinationAccount, destinationAmount) {
-  return JSON.stringify({
+  return {
    'id': request_id,
    'status': 'success',
    'type': 'response',
@@ -301,12 +301,12 @@ function(request_id, sendingAccount, destinationAccount, destinationAmount) {
        'XRP'
      ]
    }
-  });
+  };
 };

 module.exports.generateXRPPaymentPaths =
 function(request_id, sendingAccount, destinationAccount) {
-  return JSON.stringify({
+  return {
    'id': request_id,
    'status': 'success',
    'type': 'response',
@@ -410,5 +410,5 @@ function(request_id, sendingAccount, destinationAccount) {
        'XRP'
      ]
    }
-  });
+  };
 };
--- a/test/mockRippled.ts
+++ b/test/mockRippled.ts
@@ -1,24 +1,9 @@
 import _ from 'lodash'
-import fs from 'fs'
-import assert from 'assert'
 import {Server as WebSocketServer} from 'ws'
 import {EventEmitter2} from 'eventemitter2'
-import fixtures from './fixtures/rippled'
-import addresses from './fixtures/addresses.json'
-import hashes from './fixtures/hashes.json'
-import transactionsResponse from './fixtures/rippled/accountTx'
-import accountLinesResponse from './fixtures/rippled/accountLines'
-import fullLedger from './fixtures/rippled/ledgerFull38129.json'
 import {getFreePort} from './testUtils'
 import { Request } from '../src'

-function isUSD(json) {
-  return json === 'USD' || json === '0000000000000000000000005553440000000000'
-}
-
-function isBTC(json) {
-  return json === 'BTC' || json === '0000000000000000000000004254430000000000'
-}

 function createResponse(request, response, overrides = {}) {
  const result = Object.assign({}, response.result, overrides)
@@ -29,26 +14,16 @@ function createResponse(request, response, overrides = {}) {
  return JSON.stringify(Object.assign({}, response, change))
 }

-function createLedgerResponse(request, response) {
-  const newResponse = JSON.parse(createResponse(request, response))
-  if (newResponse.result && newResponse.result.ledger) {
-    if (!request.transactions) {
-      delete newResponse.result.ledger.transactions
-    }
-    if (!request.accounts) {
-      delete newResponse.result.ledger.accountState
-    }
-    // the following fields were not in the ledger response in the past
-    if (newResponse.result.ledger.close_flags == null) {
-      newResponse.result.ledger.close_flags = 0
-    }
-    if (newResponse.result.ledger.parent_close_time == null) {
-      newResponse.result.ledger.parent_close_time =
-        newResponse.result.ledger.close_time - 10
-    }
-    newResponse.result.ledger_index = newResponse.result.ledger.ledger_index
-  }
-  return JSON.stringify(newResponse)
+function ping(conn, request) {
+  setTimeout(() => {
+    conn.send(
+      createResponse(request, {
+        result: {},
+        status: 'success',
+        type: 'response'
+      })
+    )
+  }, 1000 * 2)
 }

 // We mock out WebSocketServer in these tests and add a lot of custom
@@ -60,52 +35,21 @@ export function createMockRippled(port) {
  Object.assign(mock, EventEmitter2.prototype)

  mock.responses = {}
-
-  mock.addResponse = (request: Request, response: object) => {
-    const command = request.command
-    mock.responses[command] = response
-  }
-
-  const close = mock.close
-  mock.close = function () {
-    if (mock.expectedRequests != null) {
-      const allRequestsMade = Object.entries(mock.expectedRequests).every(function (
-        _, counter
-      ) {
-        return counter === 0
-      })
-      if (!allRequestsMade) {
-        const json = JSON.stringify(mock.expectedRequests, null, 2)
-        const indent = '      '
-        const indented = indent + json.replace(/\n/g, '\n' + indent)
-        assert(false, 'Not all expected requests were made:\n' + indented)
-      }
-    }
-    close.call(mock)
-  }
-
-  mock.expect = function (expectedRequests) {
-    mock.expectedRequests = expectedRequests
-  }
-
  mock.suppressOutput = false

  mock.on('connection', function (this: MockedWebSocketServer, conn: any) {
-    if (mock.config.breakNextConnection) {
-      mock.config.breakNextConnection = false
-      conn.terminate()
-      return
-    }
    this.socket = conn
-    conn.config = {}
    conn.on('message', function (requestJSON) {
      try {
        const request = JSON.parse(requestJSON)
-        if (request.command in mock.responses) {
-          conn.send(createResponse(request, mock.responses[request.command]))
+        if (request.command === 'ping') {
+          ping(conn, request)
+        } else if (request.command === 'test_command') {
+          mock.testCommand(conn, request)
+        }else if (request.command in mock.responses) {
+          conn.send(createResponse(request, mock.getResponse(request)))
        } else {
-          // TODO: remove this block once all the handlers have been removed
-          mock.emit('request_' + request.command, request, conn)
+          throw new Error(`No event handler registered in mock rippled for ${request.command}`)
        }
      } catch (err) {
        if (!mock.suppressOutput)
@@ -115,27 +59,26 @@ export function createMockRippled(port) {
    })
  })

-  mock.config = {}
+  // Adds a mocked response
+  // If an object is passed in for `response`, then the response is static for the command
+  // If a function is passed in for `response`, then the response can be determined by the exact request shape
+  mock.addResponse = (request: Request, response: object | ((r: Request) => object)) => {
+    const command = request.command
+    mock.responses[command] = response
+  }

-  mock.onAny(function (this: MockedWebSocketServer) {
-    if (this.event.indexOf('request_') !== 0) {
-      return
+  mock.getResponse = (request: Request) : object => {
+    if (!(request.command in mock.responses)) {
+      throw new Error(`No handler for ${request.command}`)
    }
-    if (mock.listeners(this.event).length === 0) {
-      throw new Error('No event handler registered in mock rippled for ' + this.event)
+    const functionOrObject = mock.responses[request.command]
+    if (typeof functionOrObject === 'function') {
+      return functionOrObject(request)
    }
-    if (mock.expectedRequests == null) {
-      return // TODO: fail here to require expectedRequests
-    }
-    const expectedCount = mock.expectedRequests[this.event]
-    if (expectedCount == null || expectedCount === 0) {
-      throw new Error('Unexpected request: ' + this.event)
-    }
-    mock.expectedRequests[this.event] -= 1
-  })
+    return functionOrObject
+  }

-  mock.on('request_test_command', function (request, conn) {
-    assert.strictEqual(request.command, 'test_command')
+  mock.testCommand = function testCommand(conn, request) {
    if (request.data.disconnectIn) {
      setTimeout(conn.terminate.bind(conn), request.data.disconnectIn)
      conn.send(
@@ -159,7 +102,7 @@ export function createMockRippled(port) {
    } else if (request.data.closeServerAndReopen) {
      setTimeout(() => {
        conn.terminate()
-        close.call(mock, () => {
+        mock.close.call(mock, () => {
          setTimeout(() => {
            createMockRippled(port)
          }, request.data.closeServerAndReopen)
@@ -174,595 +117,7 @@ export function createMockRippled(port) {
        })
      )
    }
-  })
-
-  mock.on('request_global_config', function (request, conn) {
-    assert.strictEqual(request.command, 'global_config')
-    mock.config = Object.assign(conn.config, request.data)
-    conn.send(
-      createResponse(request, {
-        status: 'success',
-        type: 'response',
-        result: {}
-      })
-    )
-  })
-
-  mock.on('request_echo', function (request, conn) {
-    assert.strictEqual(request.command, 'echo')
-    conn.send(JSON.stringify(request.data))
-  })
-
-  mock.on('request_subscribe', function (request, conn) {
-    assert.strictEqual(request.command, 'subscribe')
-    if (request && request.streams === 'validations') {
-      conn.send(createResponse(request, fixtures.subscribe.error))
-    } else if (mock.config.returnEmptySubscribeRequest) {
-      mock.config.returnEmptySubscribeRequest--
-      conn.send(createResponse(request, fixtures.empty))
-    } else if (request.accounts) {
-      assert(Object.values(addresses).indexOf(request.accounts[0]) !== -1)
-    }
-    conn.send(createResponse(request, fixtures.subscribe.success))
-  })
-
-  mock.on('request_fee', function (request, conn) {
-    assert.strictEqual(request.command, 'fee')
-    conn.send(createResponse(request, fixtures.fee))
-  })
-
-  mock.on('request_unsubscribe', function (request, conn) {
-    assert.strictEqual(request.command, 'unsubscribe')
-    if (request.accounts) {
-      assert(Object.values(addresses).indexOf(request.accounts[0]) !== -1)
-    } else {
-      assert.deepEqual(request.streams, ['ledger', 'server'])
-    }
-    conn.send(createResponse(request, fixtures.unsubscribe))
-  })
-
-  // TODO: remove this and move fixtures closer when the prepare functions are gone
-  mock.on('request_account_info', function (request, conn) {
-    assert.strictEqual(request.command, 'account_info')
-    conn.send(createResponse(request, fixtures.account_info.normal))
-  })
-
-  mock.on('request_ledger', function (request, conn) {
-    assert.strictEqual(request.command, 'ledger')
-    if (request.ledger_index === 34) {
-      conn.send(createLedgerResponse(request, fixtures.ledger.notFound))
-    } else if (request.ledger_index === 6) {
-      conn.send(createResponse(request, fixtures.ledger.withStateAsHashes))
-    } else if (request.ledger_index === 9038215) {
-      conn.send(createLedgerResponse(request, fixtures.ledger.withoutCloseTime))
-    } else if (request.ledger_index === 4181996) {
-      conn.send(createLedgerResponse(request, fixtures.ledger.withSettingsTx))
-    } else if (
-      request.ledger_index === 22420574 &&
-      request.expand === true &&
-      request.transactions === true
-    ) {
-      conn.send(
-        createLedgerResponse(request, fixtures.ledger.withPartialPayment)
-      )
-    } else if (request.ledger_index === 100001) {
-      conn.send(
-        createLedgerResponse(request, fixtures.ledger.pre2014withPartial)
-      )
-    } else if (request.ledger_index === 38129) {
-      const response = Object.assign({}, fixtures.ledger.normal, {
-        result: {ledger: fullLedger}
-      })
-      conn.send(createLedgerResponse(request, response))
-    } else if (
-      request.ledger_hash ===
-      '15F20E5FA6EA9770BBFFDBD62787400960B04BE32803B20C41F117F41C13830D'
-    ) {
-      conn.send(createLedgerResponse(request, fixtures.ledger.normalByHash))
-    } else if (
-      request.ledger_index === 'validated' ||
-      request.ledger_index === 14661789 ||
-      request.ledger_index === 14661788 /* getTransaction - order */
-    ) {
-      conn.send(createLedgerResponse(request, fixtures.ledger.normal))
-    } else {
-      assert(false, 'Unrecognized ledger request: ' + JSON.stringify(request))
-    }
-  })
-
-  mock.on('request_ledger_current', function (request, conn) {
-    assert.strictEqual(request.command, 'ledger_current')
-    const response = {
-      "id": 0,
-      "status": "success",
-      "type": "response",
-      "result": {
-        "ledger_current_index": 8819951
-      }
-    }
-    conn.send(createResponse(request, response))
-  })
-
-  mock.on('request_ledger_data', function (request, conn) {
-    assert.strictEqual(request.command, 'ledger_data')
-    if (request.marker) {
-      conn.send(createResponse(request, fixtures.ledger_data.last_page))
-    } else {
-      conn.send(createResponse(request, fixtures.ledger_data.first_page))
-    }
-  })
-
-  mock.on('request_ledger_entry', function (request, conn) {
-    assert.strictEqual(request.command, 'ledger_entry')
-    if (
-      request.index ===
-      'E30E709CF009A1F26E0E5C48F7AA1BFB79393764F15FB108BDC6E06D3CBD8415'
-    ) {
-      conn.send(createResponse(request, fixtures.payment_channel.normal))
-    } else if (
-      request.index ===
-      'D77CD4713AA08195E6B6D0E5BC023DA11B052EBFF0B5B22EDA8AE85345BCF661'
-    ) {
-      conn.send(createResponse(request, fixtures.payment_channel.full))
-    } else if (
-      request.index ===
-      '8EF9CCB9D85458C8D020B3452848BBB42EAFDDDB69A93DD9D1223741A4CA562B'
-    ) {
-      conn.send(createResponse(request, fixtures.escrow))
-    } else {
-      conn.send(createResponse(request, fixtures.ledger_entry.error))
-    }
-  })
-
-  mock.on('request_ping', function (request, conn) {
-    // NOTE: We give the response a timeout of 2 second, so that tests can
-    // set their timeout threshold to greater than or less than this number
-    // to test timeouts.
-    setTimeout(() => {
-      conn.send(
-        createResponse(request, {
-          result: {},
-          status: 'success',
-          type: 'response'
-        })
-      )
-    }, 1000 * 2)
-  })
-
-  mock.on('request_tx', function (request, conn) {
-    assert.strictEqual(request.command, 'tx')
-    if (request.transaction === hashes.VALID_TRANSACTION_HASH) {
-      conn.send(createResponse(request, fixtures.tx.Payment))
-    } else if (
-      request.transaction ===
-      '4FB3ADF22F3C605E23FAEFAA185F3BD763C4692CAC490D9819D117CD33BFAA1B'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.AccountSet))
-    } else if (
-      request.transaction ===
-      '8925FC8844A1E930E2CC76AD0A15E7665AFCC5425376D548BB1413F484C31B8C'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.AccountSetTrackingOn))
-    } else if (
-      request.transaction ===
-      'C8C5E20DFB1BF533D0D81A2ED23F0A3CBD1EF2EE8A902A1D760500473CC9C582'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.AccountSetTrackingOff))
-    } else if (
-      request.transaction ===
-      '278E6687C1C60C6873996210A6523564B63F2844FB1019576C157353B1813E60'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.RegularKey))
-    } else if (
-      request.transaction ===
-      '10A6FB4A66EE80BED46AAE4815D7DC43B97E944984CCD5B93BCF3F8538CABC51'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.OfferCreate))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_OFFER_CREATE_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.OfferCreateWithMemo))
-    } else if (
-      request.transaction ===
-      '458101D51051230B1D56E9ACAFAA34451BF65FA000F95DF6F0FF5B3A62D83FC2'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.OfferCreateSell))
-    } else if (
-      request.transaction ===
-      '809335DD3B0B333865096217AA2F55A4DF168E0198080B3A090D12D88880FF0E'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.OfferCancel))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_ORDER_CANCELLATION_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.OfferCancelWithMemo))
-    } else if (
-      request.transaction ===
-      '635A0769BD94710A1F6A76CDE65A3BC661B20B798807D1BBBDADCEA26420538D'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.TrustSet))
-    } else if (
-      request.transaction ===
-      '4FB3ADF22F3C605E23FAEFAA185F3BD763C4692CAC490D9819D117CD33BFAA11'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.NoLedgerIndex))
-    } else if (
-      request.transaction ===
-      '4FB3ADF22F3C605E23FAEFAA185F3BD763C4692CAC490D9819D117CD33BFAA12'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.NoLedgerFound))
-    } else if (
-      request.transaction ===
-      '0F7ED9F40742D8A513AE86029462B7A6768325583DF8EE21B7EC663019DD6A04'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.LedgerWithoutTime))
-    } else if (
-      request.transaction ===
-      'FE72FAD0FA7CA904FB6C633A1666EDF0B9C73B2F5A4555D37EEF2739A78A531B'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.TrustSetFrozenOff))
-    } else if (
-      request.transaction ===
-      'BAF1C678323C37CCB7735550C379287667D8288C30F83148AD3C1CB019FC9002'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.TrustSetNoQuality))
-    } else if (
-      request.transaction ===
-      '9D6AC5FD6545B2584885B85E36759EB6440CDD41B6C55859F84AFDEE2B428220'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.TrustSetAddMemo))
-    } else if (
-      request.transaction ===
-      '4FB3ADF22F3C605E23FAEFAA185F3BD763C4692CAC490D9819D117CD33BFAA10'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.NotValidated))
-    } else if (request.transaction === hashes.NOTFOUND_TRANSACTION_HASH) {
-      conn.send(createResponse(request, fixtures.tx.NotFound))
-    } else if (request.transaction === hashes.WITH_MEMOS_ACCOUNT_DELETE_TRANSACTION_HASH) {
-      conn.send(createResponse(request, fixtures.tx.AccountDeleteWithMemo))
-    } else if (
-      request.transaction ===
-      '097B9491CC76B64831F1FEA82EAA93BCD728106D90B65A072C933888E946C40B'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.OfferWithExpiration))
-    } else if (
-      request.transaction === hashes.WITH_MEMO_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.WithMemo))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.WithMemos))
-    }
-
-
-    // Checks
-    else if (
-      request.transaction ===
-      '605A2E2C8E48AECAF5C56085D1AEAA0348DC838CE122C9188F94EB19DA05C2FE'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.CheckCreate))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_CHECK_CREATE_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.CheckCreateWithMemo))
-    } else if (
-      request.transaction ===
-      'B4105D1B2D83819647E4692B7C5843D674283F669524BD50C9614182E3A12CD4'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.CheckCancel))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_CHECK_CANCEL_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.CheckCancelWithMemo))
-    } else if (
-      request.transaction ===
-      '8321208465F70BA52C28BCC4F646BAF3B012BA13B57576C0336F42D77E3E0749'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.CheckCash))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_CHECK_CASH_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.CheckCashWithMemo))
-    }
-
-    // Escrows
-    else if (
-      request.transaction ===
-      '144F272380BDB4F1BD92329A2178BABB70C20F59042C495E10BF72EBFB408EE1'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.EscrowCreation))
-    } else if (
-      request.transaction ===
-      'F346E542FFB7A8398C30A87B952668DAB48B7D421094F8B71776DA19775A3B22'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.EscrowCancellation))
-    } else if (
-      request.transaction ===
-      'CC5277137B3F25EE8B86259C83CB0EAADE818505E4E9BCBF19B1AC6FD136993B'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.EscrowExecution))
-    } else if (
-      request.transaction ===
-      'CC5277137B3F25EE8B86259C83CB0EAADE818505E4E9BCBF19B1AC6FD1369931'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.EscrowExecutionSimple))
-    }
-
-    // Payment Channels
-    else if (
-      request.transaction ===
-      '0E9CA3AB1053FC0C1CBAA75F636FE1EC92F118C7056BBEF5D63E4C116458A16D'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.PaymentChannelCreate))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_PAYMENT_CHANNEL_CREATE_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.PaymentChannelCreateWithMemo))
-    } else if (
-      request.transaction ===
-      'CD053D8867007A6A4ACB7A432605FE476D088DCB515AFFC886CF2B4EB6D2AE8B'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.PaymentChannelFund))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_PAYMENT_CHANNEL_FUND_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.PaymentChannelFundWithMemo))
-    } else if (
-      request.transaction ===
-      '81B9ECAE7195EB6E8034AEDF44D8415A7A803E14513FDBB34FA984AB37D59563'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.PaymentChannelClaim))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_PAYMENT_CHANNEL_CLAIM_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.PaymentChannelClaimWithMemo))
-    } else if (
-      request.transaction ===
-      'EC2AB14028DC84DE525470AB4DAAA46358B50A8662C63804BFF38244731C0CB9'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.AccountDelete))
-    } else if (
-      request.transaction ===
-      'AFB3ADF22F3C605E23FAEFAA185F3BD763C4692CAC490D9819D117CD33BFAA11'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.Unrecognized))
-    } else if (
-      request.transaction ===
-      'AFB3ADF22F3C605E23FAEFAA185F3BD763C4692CAC490D9819D117CD33BFAA1B'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.NoMeta))
-    } else if (
-      request.transaction ===
-      '4FB3ADF22F3C605E23FAEFAA185F3BD763C4692CAC490D9819D117CD33BFAA13'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.LedgerZero))
-    } else if (
-      request.transaction ===
-      'A971B83ABED51D83749B73F3C1AAA627CD965AFF74BE8CD98299512D6FB0658F'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.Amendment))
-    } else if (
-      request.transaction ===
-      'C6A40F56127436DCD830B1B35FF939FD05B5747D30D6542572B7A835239817AF'
-    ) {
-      conn.send(createResponse(request, fixtures.tx.SetFee))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_FEE_UPDATE_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.SetFeeWithMemo))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_TICKET_CREATE_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.TicketCreateWithMemo))
-    } else if (
-      request.transaction === hashes.WITH_MEMOS_DEPOSIT_PREAUTH_TRANSACTION_HASH
-    ) {
-      conn.send(createResponse(request, fixtures.tx.DepositPreauthWithMemo))
-    } else {
-      assert(false, 'Unrecognized transaction hash: ' + request.transaction)
-    }
-  })
-
-  mock.on('request_submit', function (request, conn) {
-    assert.strictEqual(request.command, 'submit')
-    if (request.tx_blob === 'BAD') {
-      conn.send(createResponse(request, fixtures.submit.failure))
-    } else {
-      conn.send(createResponse(request, fixtures.submit.success))
-    }
-  })
-
-  mock.on('request_submit_multisigned', function (request, conn) {
-    assert.strictEqual(request.command, 'submit_multisigned')
-    conn.send(createResponse(request, fixtures.submit.success))
-  })
-
-  mock.on('request_account_lines', function (request, conn) {
-    if (request.account === addresses.ACCOUNT) {
-      conn.send(accountLinesResponse.normal(request))
-    } else if (request.account === addresses.OTHER_ACCOUNT) {
-      conn.send(accountLinesResponse.counterparty(request))
-    } else if (request.account === addresses.THIRD_ACCOUNT) {
-      conn.send(accountLinesResponse.manyItems(request))
-    } else if (request.account === addresses.FOURTH_ACCOUNT) {
-      if (request.ledger_index === 5) {
-        conn.send(accountLinesResponse.manyItems(request))
-      } else {
-        conn.send(accountLinesResponse.ripplingDisabled(request))
-      }
-    } else if (request.account === addresses.NOTFOUND) {
-      conn.send(createResponse(request, fixtures.account_info.notfound))
-    } else {
-      assert(false, 'Unrecognized account address: ' + request.account)
-    }
-  })
-
-  mock.on('request_account_tx', function (request, conn) {
-    if (request.account === addresses.ACCOUNT) {
-      conn.send(transactionsResponse(request))
-    } else if (request.account === addresses.OTHER_ACCOUNT) {
-      conn.send(createResponse(request, fixtures.account_tx.one))
-    } else {
-      assert(false, 'Unrecognized account address: ' + request.account)
-    }
-  })
-
-  mock.on('request_account_offers', function (request, conn) {
-    if (request.account === addresses.ACCOUNT) {
-      conn.send(fixtures.account_offers(request))
-    } else {
-      assert(false, 'Unrecognized account address: ' + request.account)
-    }
-  })
-
-  let requestsCache = undefined
-
-  mock.on('request_book_offers', function (request, conn) {
-    if (request.taker_pays.issuer === 'rp8rJYTpodf8qbSCHVTNacf8nSW8mRakFw') {
-      conn.send(createResponse(request, fixtures.book_offers.xrp_usd))
-    } else if (
-      request.taker_gets.issuer === 'rp8rJYTpodf8qbSCHVTNacf8nSW8mRakFw'
-    ) {
-      conn.send(createResponse(request, fixtures.book_offers.usd_xrp))
-    } else if (
-      isBTC(request.taker_gets.currency) &&
-      isUSD(request.taker_pays.currency)
-    ) {
-      conn.send(
-        fixtures.book_offers.fabric.requestBookOffersBidsResponse(request)
-      )
-    } else if (
-      isUSD(request.taker_gets.currency) &&
-      isBTC(request.taker_pays.currency)
-    ) {
-      conn.send(
-        fixtures.book_offers.fabric.requestBookOffersAsksResponse(request)
-      )
-    } else {
-      const rippledDir = 'test/fixtures/rippled'
-      if (!requestsCache) {
-        requestsCache = fs.readdirSync(rippledDir + '/requests')
-      }
-      for (var i = 0; i < requestsCache.length; i++) {
-        const file = requestsCache[i]
-        const json = fs.readFileSync(rippledDir + '/requests/' + file, 'utf8')
-        const r = JSON.parse(json)
-        const requestWithoutId = _.omit(Object.assign({}, request), 'id')
-        if (_.isEqual(requestWithoutId, r)) {
-          const responseFile =
-            rippledDir + '/responses/' + file.split('.')[0] + '-res.json'
-          const res = fs.readFileSync(responseFile, 'utf8')
-          const response = createResponse(request, {
-            id: 0,
-            type: 'response',
-            status: 'success',
-            result: JSON.parse(res)
-          })
-          conn.send(response)
-          return
-        }
-      }
-
-      assert(false, 'Unrecognized order book: ' + JSON.stringify(request))
-    }
-  })
-
-  mock.on('request_ripple_path_find', function (request, conn) {
-    let response = null
-    if (request.subcommand === 'close') {
-      // for path_find command
-      return
-    }
-    if (request.source_account === 'rB2NTuTTS3eNCsWxZYzJ4wqRqxNLZqA9Vx') {
-      // getPaths - result path has source_amount in drops
-      response = createResponse(request, {
-        id: 0,
-        type: 'response',
-        status: 'success',
-        result: {
-          alternatives: [
-            {
-              destination_amount: {
-                currency: 'EUR',
-                issuer: 'rGpGaj4sxEZGenW1prqER25EUi7x4fqK9u',
-                value: '1'
-              },
-              paths_canonical: [],
-              paths_computed: [
-                [
-                  {
-                    currency: 'USD',
-                    issuer: 'rGpGaj4sxEZGenW1prqER25EUi7x4fqK9u',
-                    type: 48,
-                    type_hex: '0000000000000030'
-                  },
-                  {
-                    currency: 'EUR',
-                    issuer: 'rGpGaj4sxEZGenW1prqER25EUi7x4fqK9u',
-                    type: 48,
-                    type_hex: '0000000000000030'
-                  }
-                ]
-              ],
-              source_amount: '1000000'
-            }
-          ],
-          destination_account: 'rhpJkBfZGQyT1xeDbwtKEuSrSXw3QZSAy5',
-          destination_amount: {
-            currency: 'EUR',
-            issuer: 'rGpGaj4sxEZGenW1prqER25EUi7x4fqK9u',
-            value: '-1'
-          },
-          destination_currencies: ['EUR', 'XRP'],
-          full_reply: true,
-          id: 2,
-          source_account: 'rB2NTuTTS3eNCsWxZYzJ4wqRqxNLZqA9Vx',
-          status: 'success'
-        }
-      })
-    } else if (request.source_account === addresses.NOTFOUND) {
-      response = createResponse(request, fixtures.path_find.srcActNotFound)
-    } else if (request.source_account === addresses.SOURCE_LOW_FUNDS) {
-      response = createResponse(request, fixtures.path_find.sourceAmountLow)
-    } else if (request.source_account === addresses.OTHER_ACCOUNT) {
-      response = createResponse(request, fixtures.path_find.sendUSD)
-    } else if (request.source_account === addresses.THIRD_ACCOUNT) {
-      response = createResponse(request, fixtures.path_find.XrpToXrp, {
-        destination_amount: request.destination_amount,
-        destination_address: request.destination_address
-      })
-    } else if (request.source_account === addresses.ACCOUNT) {
-      if (
-        request.destination_account === 'ra5nK24KXen9AHvsdFTKHSANinZseWnPcX' &&
-        // Important: Ensure that destination_amount.value is correct
-        request.destination_amount.value === '-1'
-      ) {
-        response = createResponse(request, fixtures.path_find.sendAll)
-      } else {
-        response = fixtures.path_find.generate.generateIOUPaymentPaths(
-          request.id,
-          request.source_account,
-          request.destination_account,
-          request.destination_amount
-        )
-      }
-    } else {
-      assert(
-        false,
-        'Unrecognized path find request: ' + JSON.stringify(request)
-      )
-    }
-    conn.send(response)
-  })
-
-  mock.on('request_gateway_balances', function (request, conn) {
-    if (request.ledger_index === 123456) {
-      conn.send(createResponse(request, fixtures.unsubscribe))
-    } else {
-      conn.send(createResponse(request, fixtures.gateway_balances))
-    }
-  })
+  }

  return mock
 }