Run prettier (yarn format)

src/common/connection.ts

@@ -13,7 +13,7 @@ import {
   RippledNotInitializedError,
   RippleError
 } from './errors'
-import {ExponentialBackoff} from './backoff';
+import {ExponentialBackoff} from './backoff'
 
 /**
  * ConnectionOptions is the configuration for the Connection class.
@@ -387,7 +387,7 @@ export class Connection extends EventEmitter {
    */
   private _heartbeat = () => {
     return this.request({command: 'ping'}).catch(() => {
-        this.reconnect().catch((error) => {
+      this.reconnect().catch(error => {
         this.emit('error', 'reconnect', error.message, error)
       })
     })
@@ -550,8 +550,8 @@ export class Connection extends EventEmitter {
    * If no open websocket connection exists, resolve with no code (`undefined`).
    */
   disconnect(): Promise<number | undefined> {
-    clearTimeout(this._reconnectTimeoutID);
+    clearTimeout(this._reconnectTimeoutID)
-    this._reconnectTimeoutID = null;
+    this._reconnectTimeoutID = null
     if (this._state === WebSocket.CLOSED || !this._ws) {
       return Promise.resolve(undefined)
     }

src/common/constants.ts

@@ -59,14 +59,14 @@ const AccountFlags = {
 }
 
 export interface Settings {
-  passwordSpent?: boolean,
+  passwordSpent?: boolean
-  requireDestinationTag?: boolean,
+  requireDestinationTag?: boolean
-  requireAuthorization?: boolean,
+  requireAuthorization?: boolean
-  depositAuth?: boolean,
+  depositAuth?: boolean
-  disallowIncomingXRP?: boolean,
+  disallowIncomingXRP?: boolean
-  disableMasterKey?: boolean,
+  disableMasterKey?: boolean
-  noFreeze?: boolean,
+  noFreeze?: boolean
-  globalFreeze?: boolean,
+  globalFreeze?: boolean
   defaultRipple?: boolean
 }
 

src/ledger/settings.ts

@@ -4,7 +4,7 @@ import {validate, constants, ensureClassicAddress} from '../common'
 import {FormattedSettings} from '../common/types/objects'
 import {AccountInfoResponse} from '../common/types/commands'
 import {RippleAPI} from '..'
-import { Settings } from '../common/constants'
+import {Settings} from '../common/constants'
 
 const AccountFlags = constants.AccountFlags
 

src/offline/generate-address.ts

@@ -28,7 +28,10 @@ export interface GenerateAddressOptions {
 function generateAddressAPI(options: GenerateAddressOptions): GeneratedAddress {
   validate.generateAddress({options})
   try {
-    const generateSeedOptions: { entropy?: Uint8Array; algorithm?: "ecdsa-secp256k1" | "ed25519"; } = {
+    const generateSeedOptions: {
+      entropy?: Uint8Array
+      algorithm?: 'ecdsa-secp256k1' | 'ed25519'
+    } = {
       algorithm: options.algorithm
     }
     if (options.entropy) {

test/api/generateAddress/index.ts

@@ -1,7 +1,7 @@
 import assert from 'assert-diff'
 import responses from '../../fixtures/responses'
 import {TestSuite} from '../../utils'
-import { GenerateAddressOptions } from '../../../src/offline/generate-address'
+import {GenerateAddressOptions} from '../../../src/offline/generate-address'
 const {generateAddress: RESPONSE_FIXTURES} = responses
 
 /**
@@ -10,7 +10,7 @@ const {generateAddress: RESPONSE_FIXTURES} = responses
  * - Check out "test/api/index.ts" for more information about the test runner.
  */
 export default <TestSuite>{
-  'generateAddress': async (api) => {
+  'generateAddress': async api => {
     // GIVEN entropy of all zeros
     function random() {
       return new Array(16).fill(0)
@@ -25,7 +25,7 @@ export default <TestSuite>{
     )
   },
 
-  'generateAddress invalid entropy': async (api) => {
+  'generateAddress invalid entropy': async api => {
     assert.throws(() => {
       // GIVEN entropy of 1 byte
       function random() {
@@ -40,7 +40,7 @@ export default <TestSuite>{
     }, api.errors.UnexpectedError)
   },
 
-  'generateAddress with no options object': async (api) => {
+  'generateAddress with no options object': async api => {
     // GIVEN no options
 
     // WHEN generating an address
@@ -51,7 +51,7 @@ export default <TestSuite>{
     assert(account.secret.startsWith('s'), 'Secret must start with `s`')
   },
 
-  'generateAddress with empty options object': async (api) => {
+  'generateAddress with empty options object': async api => {
     // GIVEN an empty options object
     const options = {}
 
@@ -63,7 +63,7 @@ export default <TestSuite>{
     assert(account.secret.startsWith('s'), 'Secret must start with `s`')
   },
 
-  'generateAddress with algorithm `ecdsa-secp256k1`': async (api) => {
+  'generateAddress with algorithm `ecdsa-secp256k1`': async api => {
     // GIVEN we want to use 'ecdsa-secp256k1'
     const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1'}
 
@@ -72,11 +72,19 @@ export default <TestSuite>{
 
     // THEN we get an object with an address starting with 'r' and a secret starting with 's' (not 'sEd')
     assert(account.address.startsWith('r'), 'Address must start with `r`')
-    assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`)
+    assert.deepEqual(
-    assert.notStrictEqual(account.secret.slice(0, 3), 'sEd', `secp256k1 secret ${account.secret} must not start with 'sEd'`)
+      account.secret.slice(0, 1),
+      's',
+      `Secret ${account.secret} must start with 's'`
+    )
+    assert.notStrictEqual(
+      account.secret.slice(0, 3),
+      'sEd',
+      `secp256k1 secret ${account.secret} must not start with 'sEd'`
+    )
   },
 
-  'generateAddress with algorithm `ed25519`': async (api) => {
+  'generateAddress with algorithm `ed25519`': async api => {
     // GIVEN we want to use 'ed25519'
     const options: GenerateAddressOptions = {algorithm: 'ed25519'}
 
@@ -85,12 +93,19 @@ export default <TestSuite>{
 
     // THEN we get an object with an address starting with 'r' and a secret starting with 'sEd'
     assert(account.address.startsWith('r'), 'Address must start with `r`')
-    assert.deepEqual(account.secret.slice(0, 3), 'sEd', `Ed25519 secret ${account.secret} must start with 'sEd'`)
+    assert.deepEqual(
+      account.secret.slice(0, 3),
+      'sEd',
+      `Ed25519 secret ${account.secret} must start with 'sEd'`
+    )
   },
 
-  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy': async (api) => {
+  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy': async api => {
     // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0)}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0)
+    }
 
     // WHEN generating an address
     const account = api.generateAddress(options)
@@ -99,28 +114,34 @@ export default <TestSuite>{
     assert.deepEqual(account, responses.generateAddress)
   },
 
-  'generateAddress with algorithm `ed25519` and given entropy': async (api) => {
+  'generateAddress with algorithm `ed25519` and given entropy': async api => {
     // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0)}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0)
+    }
 
     // WHEN generating an address
     const account = api.generateAddress(options)
 
     // THEN we get the expected return value
     assert.deepEqual(account, {
-
       // generateAddress return value always includes xAddress to encourage X-address adoption
       xAddress: 'X7xq1YJ4xmLSGGLhuakFQB9CebWYthQkgsvFC4LGFH871HB',
 
-      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
+      classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
-      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
+      address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
       secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE'
     })
   },
 
-  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async (api) => {
+  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async api => {
     // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true
+    }
 
     // WHEN generating an address
     const account = api.generateAddress(options)
@@ -129,62 +150,72 @@ export default <TestSuite>{
     assert.deepEqual(account, responses.generateAddress)
   },
 
-  'generateAddress with algorithm `ed25519` and given entropy; include classic address': async (api) => {
+  'generateAddress with algorithm `ed25519` and given entropy; include classic address': async api => {
     // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true
+    }
 
     // WHEN generating an address
     const account = api.generateAddress(options)
 
     // THEN we get the expected return value
     assert.deepEqual(account, {
-
       // generateAddress return value always includes xAddress to encourage X-address adoption
       xAddress: 'X7xq1YJ4xmLSGGLhuakFQB9CebWYthQkgsvFC4LGFH871HB',
 
       secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE',
-      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
+      classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
-      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+      address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7'
     })
   },
 
-  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async (api) => {
+  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async api => {
     // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true,
+      test: true
+    }
 
     // WHEN generating an address
     const account = api.generateAddress(options)
 
     // THEN we get the expected return value
     const response = Object.assign({}, responses.generateAddress, {
-
       // generateAddress return value always includes xAddress to encourage X-address adoption
       xAddress: 'TVG3TcCD58BD6MZqsNuTihdrhZwR8SzvYS8U87zvHsAcNw4'
-
     })
     assert.deepEqual(account, response)
   },
 
-  'generateAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async (api) => {
+  'generateAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async api => {
     // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true,
+      test: true
+    }
 
     // WHEN generating an address
     const account = api.generateAddress(options)
 
     // THEN we get the expected return value
     assert.deepEqual(account, {
-
       // generateAddress return value always includes xAddress to encourage X-address adoption
       xAddress: 'T7t4HeTMF5tT68agwuVbJwu23ssMPeh8dDtGysZoQiij1oo',
 
       secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE',
-      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
+      classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
-      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+      address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7'
     })
   },
 
-  'generateAddress for test network use': async (api) => {
+  'generateAddress for test network use': async api => {
     // GIVEN we want an address for test network use
     const options: GenerateAddressOptions = {test: true}
 
@@ -194,8 +225,16 @@ export default <TestSuite>{
     // THEN we get an object with xAddress starting with 'T' and a secret starting with 's'
 
     // generateAddress return value always includes xAddress to encourage X-address adoption
-    assert.deepEqual(account.xAddress.slice(0, 1), 'T', 'Test addresses start with T')
+    assert.deepEqual(
+      account.xAddress.slice(0, 1),
+      'T',
+      'Test addresses start with T'
+    )
 
-    assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`)
+    assert.deepEqual(
+      account.secret.slice(0, 1),
+      's',
+      `Secret ${account.secret} must start with 's'`
+    )
   }
 }

test/api/generateXAddress/index.ts

@@ -1,7 +1,7 @@
 import assert from 'assert-diff'
 import responses from '../../fixtures/responses'
 import {TestSuite} from '../../utils'
-import { GenerateAddressOptions } from '../../../src/offline/generate-address'
+import {GenerateAddressOptions} from '../../../src/offline/generate-address'
 
 /**
  * Every test suite exports their tests in the default object.
@@ -9,7 +9,7 @@ import { GenerateAddressOptions } from '../../../src/offline/generate-address'
  * - Check out "test/api/index.ts" for more information about the test runner.
  */
 export default <TestSuite>{
-  'generateXAddress': async (api) => {
+  'generateXAddress': async api => {
     // GIVEN entropy of all zeros
     function random() {
       return new Array(16).fill(0)
@@ -24,7 +24,7 @@ export default <TestSuite>{
     )
   },
 
-  'generateXAddress invalid entropy': async (api) => {
+  'generateXAddress invalid entropy': async api => {
     assert.throws(() => {
       // GIVEN entropy of 1 byte
       function random() {
@@ -39,18 +39,21 @@ export default <TestSuite>{
     }, api.errors.UnexpectedError)
   },
 
-  'generateXAddress with no options object': async (api) => {
+  'generateXAddress with no options object': async api => {
     // GIVEN no options
 
     // WHEN generating an X-address
     const account = api.generateXAddress()
 
     // THEN we get an object with an xAddress starting with 'X' and a secret starting with 's'
-    assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X')
+    assert(
+      account.xAddress.startsWith('X'),
+      'By default X-addresses start with X'
+    )
     assert(account.secret.startsWith('s'), 'Secrets start with s')
   },
 
-  'generateXAddress with empty options object': async (api) => {
+  'generateXAddress with empty options object': async api => {
     // GIVEN an empty options object
     const options = {}
 
@@ -58,11 +61,14 @@ export default <TestSuite>{
     const account = api.generateXAddress(options)
 
     // THEN we get an object with an xAddress starting with 'X' and a secret starting with 's'
-    assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X')
+    assert(
+      account.xAddress.startsWith('X'),
+      'By default X-addresses start with X'
+    )
     assert(account.secret.startsWith('s'), 'Secrets start with s')
   },
 
-  'generateXAddress with algorithm `ecdsa-secp256k1`': async (api) => {
+  'generateXAddress with algorithm `ecdsa-secp256k1`': async api => {
     // GIVEN we want to use 'ecdsa-secp256k1'
     const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1'}
 
@@ -70,12 +76,23 @@ export default <TestSuite>{
     const account = api.generateXAddress(options)
 
     // THEN we get an object with an xAddress starting with 'X' and a secret starting with 's'
-    assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X')
+    assert(
-    assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`)
+      account.xAddress.startsWith('X'),
-    assert.notStrictEqual(account.secret.slice(0, 3), 'sEd', `secp256k1 secret ${account.secret} must not start with 'sEd'`)
+      'By default X-addresses start with X'
+    )
+    assert.deepEqual(
+      account.secret.slice(0, 1),
+      's',
+      `Secret ${account.secret} must start with 's'`
+    )
+    assert.notStrictEqual(
+      account.secret.slice(0, 3),
+      'sEd',
+      `secp256k1 secret ${account.secret} must not start with 'sEd'`
+    )
   },
 
-  'generateXAddress with algorithm `ed25519`': async (api) => {
+  'generateXAddress with algorithm `ed25519`': async api => {
     // GIVEN we want to use 'ed25519'
     const options: GenerateAddressOptions = {algorithm: 'ed25519'}
 
@@ -83,13 +100,23 @@ export default <TestSuite>{
     const account = api.generateXAddress(options)
 
     // THEN we get an object with an xAddress starting with 'X' and a secret starting with 'sEd'
-    assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X')
+    assert(
-    assert.deepEqual(account.secret.slice(0, 3), 'sEd', `Ed25519 secret ${account.secret} must start with 'sEd'`)
+      account.xAddress.startsWith('X'),
+      'By default X-addresses start with X'
+    )
+    assert.deepEqual(
+      account.secret.slice(0, 3),
+      'sEd',
+      `Ed25519 secret ${account.secret} must start with 'sEd'`
+    )
   },
 
-  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy': async (api) => {
+  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy': async api => {
     // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0)}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0)
+    }
 
     // WHEN generating an X-address
     const account = api.generateXAddress(options)
@@ -98,9 +125,12 @@ export default <TestSuite>{
     assert.deepEqual(account, responses.generateXAddress)
   },
 
-  'generateXAddress with algorithm `ed25519` and given entropy': async (api) => {
+  'generateXAddress with algorithm `ed25519` and given entropy': async api => {
     // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0)}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0)
+    }
 
     // WHEN generating an X-address
     const account = api.generateXAddress(options)
@@ -112,9 +142,13 @@ export default <TestSuite>{
     })
   },
 
-  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async (api) => {
+  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async api => {
     // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true
+    }
 
     // WHEN generating an X-address
     const account = api.generateXAddress(options)
@@ -123,9 +157,13 @@ export default <TestSuite>{
     assert.deepEqual(account, responses.generateAddress)
   },
 
-  'generateXAddress with algorithm `ed25519` and given entropy; include classic address': async (api) => {
+  'generateXAddress with algorithm `ed25519` and given entropy; include classic address': async api => {
     // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true
+    }
 
     // WHEN generating an X-address
     const account = api.generateXAddress(options)
@@ -134,14 +172,19 @@ export default <TestSuite>{
     assert.deepEqual(account, {
       xAddress: 'X7xq1YJ4xmLSGGLhuakFQB9CebWYthQkgsvFC4LGFH871HB',
       secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE',
-      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
+      classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
-      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+      address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7'
     })
   },
 
-  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async (api) => {
+  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async api => {
     // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true,
+      test: true
+    }
 
     // WHEN generating an X-address
     const account = api.generateXAddress(options)
@@ -153,9 +196,14 @@ export default <TestSuite>{
     assert.deepEqual(account, response)
   },
 
-  'generateXAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async (api) => {
+  'generateXAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async api => {
     // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true,
+      test: true
+    }
 
     // WHEN generating an X-address
     const account = api.generateXAddress(options)
@@ -164,12 +212,12 @@ export default <TestSuite>{
     assert.deepEqual(account, {
       xAddress: 'T7t4HeTMF5tT68agwuVbJwu23ssMPeh8dDtGysZoQiij1oo',
       secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE',
-      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
+      classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
-      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+      address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7'
     })
   },
 
-  'generateXAddress for test network use': async (api) => {
+  'generateXAddress for test network use': async api => {
     // GIVEN we want an X-address for test network use
     const options: GenerateAddressOptions = {test: true}
 
@@ -177,7 +225,15 @@ export default <TestSuite>{
     const account = api.generateXAddress(options)
 
     // THEN we get an object with xAddress starting with 'T' and a secret starting with 's'
-    assert.deepEqual(account.xAddress.slice(0, 1), 'T', 'Test X-addresses start with T')
+    assert.deepEqual(
-    assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`)
+      account.xAddress.slice(0, 1),
+      'T',
+      'Test X-addresses start with T'
+    )
+    assert.deepEqual(
+      account.secret.slice(0, 1),
+      's',
+      `Secret ${account.secret} must start with 's'`
+    )
   }
 }

test/api/getTransaction/index.ts

@@ -355,7 +355,8 @@ export default <TestSuite>{
   },
 
   'AccountDelete': async (api, address) => {
-    const hash = 'EC2AB14028DC84DE525470AB4DAAA46358B50A8662C63804BFF38244731C0CB9'
+    const hash =
+      'EC2AB14028DC84DE525470AB4DAAA46358B50A8662C63804BFF38244731C0CB9'
     const response = await api.getTransaction(hash)
     assertResultMatch(
       response,

test/connection-test.ts

@@ -224,26 +224,29 @@ describe('Connection', function() {
   it('DisconnectedError on initial _onOpen send', async function() {
     // _onOpen previously could throw PromiseRejectionHandledWarning: Promise rejection was handled asynchronously
     // do not rely on the api.setup hook to test this as it bypasses the case, disconnect api connection first
-    await this.api.disconnect();
+    await this.api.disconnect()
 
     // stub _onOpen to only run logic relevant to test case
     this.api.connection._onOpen = () => {
       // overload websocket send on open when _ws exists
       this.api.connection._ws.send = function(data, options, cb) {
         // recent ws throws this error instead of calling back
-        throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+        throw new Error('WebSocket is not open: readyState 0 (CONNECTING)')
       }
-      const request = {command: 'subscribe', streams: ['ledger']};
+      const request = {command: 'subscribe', streams: ['ledger']}
-      return this.api.connection.request(request);
+      return this.api.connection.request(request)
     }
 
     try {
-      await this.api.connect();
+      await this.api.connect()
     } catch (error) {
-      assert(error instanceof this.api.errors.DisconnectedError);
+      assert(error instanceof this.api.errors.DisconnectedError)
-      assert.strictEqual(error.message, 'WebSocket is not open: readyState 0 (CONNECTING)');
+      assert.strictEqual(
+        error.message,
+        'WebSocket is not open: readyState 0 (CONNECTING)'
+      )
     }
-  });
+  })
 
   it('ResponseFormatError', function() {
     return this.api
@@ -380,7 +383,7 @@ describe('Connection', function() {
     }
     // Hook up a listener for the reconnect error event
     this.api.on('error', (error, message) => {
-      if(error === 'reconnect' && message === 'error on reconnect') {
+      if (error === 'reconnect' && message === 'error on reconnect') {
         return done()
       }
       return done(new Error('Expected error on reconnect'))
@@ -592,20 +595,20 @@ describe('Connection', function() {
   )
 
   it('should clean up websocket connection if error after websocket is opened', async function() {
-    await this.api.disconnect();
+    await this.api.disconnect()
     // fail on connection
     this.api.connection._subscribeToLedger = async () => {
       throw new Error('error on _subscribeToLedger')
     }
     try {
-      await this.api.connect();
+      await this.api.connect()
       throw new Error('expected connect() to reject, but it resolved')
     } catch (err) {
-      assert(err.message === 'error on _subscribeToLedger');
+      assert(err.message === 'error on _subscribeToLedger')
       // _ws.close event listener should have cleaned up the socket when disconnect _ws.close is run on connection error
       // do not fail on connection anymore
       this.api.connection._subscribeToLedger = async () => {}
-      await this.api.connection.reconnect();
+      await this.api.connection.reconnect()
     }
   })