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

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)
   })

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) =>

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

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,

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) => {
+  'getTrustlines - more than 400 items': async (client, address, mockRippled) => {
-  //   const options = {limit: 401}
+    mockRippled.addResponse({command: 'account_lines'}, rippled.manyItems)
-  //   const result = await client.getTrustlines(addresses.THIRD_ACCOUNT, options)
+    const options = {limit: 401}
-  //   assertResultMatch(
+    const result = await client.getTrustlines(address, options)
-  //     result,
+    assertResultMatch(
-  //     RESPONSE_FIXTURES.moreThan400Items,
+      result,
-  //     'getTrustlines'
+      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) => {
+  'getTrustlines - ripplingDisabled works properly': async (client, address, mockRippled) => {
-    const result = await client.getTrustlines(addresses.FOURTH_ACCOUNT)
+    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) => {
+  'getTrustlines - ledger version option': async (client, address, mockRippled) => {
-  //   const result = await client.getTrustlines(addresses.FOURTH_ACCOUNT, {ledgerVersion: 5})
+    mockRippled.addResponse({command: 'account_lines'}, rippled.manyItems)
-  //   assertResultMatch(
+    const result = await client.getTrustlines(addresses.FOURTH_ACCOUNT, {ledgerVersion: 5})
-  //     result,
+    assertResultMatch(
-  //     RESPONSE_FIXTURES.moreThan400Items,
+      result,
-  //     'getTrustlines'
+      RESPONSE_FIXTURES.moreThan400Items,
-  //   )
+      'getTrustlines'
-  // },
+    )
+  },
 }

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(

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',

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',

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',

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',

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',

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',

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,

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,

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 = {

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,

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',

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',

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,

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"}',

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',

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',

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(

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: {

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.')

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}]
     }
-  });
+  };
 };

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
     }
-  })
+  }
 }

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')

test/fixtures/rippled/ledgerCurrent.json

@@ -0,0 +1,8 @@
+{
+  "id": 0,
+  "status": "success",
+  "type": "response",
+  "result": {
+    "ledger_current_index": 8819951
+  }
+}

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'
       ]
     }
-  });
+  };
 };

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) {
+function ping(conn, request) {
-  const newResponse = JSON.parse(createResponse(request, response))
+  setTimeout(() => {
-  if (newResponse.result && newResponse.result.ledger) {
+    conn.send(
-    if (!request.transactions) {
+      createResponse(request, {
-      delete newResponse.result.ledger.transactions
+        result: {},
-    }
+        status: 'success',
-    if (!request.accounts) {
+        type: 'response'
-      delete newResponse.result.ledger.accountState
+      })
-    }
+    )
-    // the following fields were not in the ledger response in the past
+  }, 1000 * 2)
-    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)
 }
 
 // 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) {
+        if (request.command === 'ping') {
-          conn.send(createResponse(request, mock.responses[request.command]))
+          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
+          throw new Error(`No event handler registered in mock rippled for ${request.command}`)
-          mock.emit('request_' + request.command, request, conn)
         }
       } 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) {
+  mock.getResponse = (request: Request) : object => {
-    if (this.event.indexOf('request_') !== 0) {
+    if (!(request.command in mock.responses)) {
-      return
+      throw new Error(`No handler for ${request.command}`)
     }
-    if (mock.listeners(this.event).length === 0) {
+    const functionOrObject = mock.responses[request.command]
-      throw new Error('No event handler registered in mock rippled for ' + this.event)
+    if (typeof functionOrObject === 'function') {
+      return functionOrObject(request)
     }
-    if (mock.expectedRequests == null) {
+    return functionOrObject
-      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
-  })
 
-  mock.on('request_test_command', function (request, conn) {
+  mock.testCommand = function testCommand(conn, request) {
-    assert.strictEqual(request.command, 'test_command')
     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
 }