Release 1.6.4

Bumps [@typescript-eslint/eslint-plugin](https://github.com/typescript-eslint/typescript-eslint/tree/HEAD/packages/eslint-plugin) from 2.19.2 to 2.20.0.
- [Release notes](https://github.com/typescript-eslint/typescript-eslint/releases)
- [Changelog](https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/CHANGELOG.md)
- [Commits](https://github.com/typescript-eslint/typescript-eslint/commits/v2.20.0/packages/eslint-plugin)

Signed-off-by: dependabot-preview[bot] <support@dependabot.com>

HISTORY.md

@@ -1,5 +1,14 @@
 # ripple-lib Release History
 
+## 1.6.4 (2020-02-18)
+
+* Fix generateXAddress() and generateAddress() with no entropy (#1211, #1209)
+* Internal
+  * Improve unit tests
+* Dependencies
+  * Update webpack-cli, @types/node, webpack, @typescript-eslint/eslint-plugin,
+    typescript, ripple-keypairs
+
 ## 1.6.3 (2020-02-05)
 
 * Update ripple-keypairs to 1.0.0

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ripple-lib",
-  "version": "1.6.3",
+  "version": "1.6.4",
   "license": "ISC",
   "description": "A TypeScript/JavaScript API for interacting with the XRP Ledger in Node.js and the browser",
   "files": [
@@ -29,7 +29,7 @@
     "lodash.isequal": "^4.5.0",
     "ripple-address-codec": "^4.0.0",
     "ripple-binary-codec": "^0.2.5",
-    "ripple-keypairs": "^1.0.0-beta.6",
+    "ripple-keypairs": "^1.0.0",
     "ripple-lib-transactionparser": "0.8.2",
     "ws": "^7.2.0"
   },
@@ -49,7 +49,7 @@
     "nyc": "^15.0.0",
     "prettier": "^1.19.1",
     "ts-node": "^8.4.1",
-    "typescript": "^3.6.4",
+    "typescript": "^3.7.5",
     "webpack": "^4.41.2",
     "webpack-bundle-analyzer": "^3.6.0",
     "webpack-cli": "^3.3.9"

src/offline/generate-address.ts

@@ -28,10 +28,13 @@ export interface GenerateAddressOptions {
 function generateAddressAPI(options: GenerateAddressOptions): GeneratedAddress {
   validate.generateAddress({options})
   try {
-    const secret = keypairs.generateSeed({
-      entropy: Uint8Array.from(options.entropy),
+    const generateSeedOptions: { entropy?: Uint8Array; algorithm?: "ecdsa-secp256k1" | "ed25519"; } = {
       algorithm: options.algorithm
-    })
+    }
+    if (options.entropy) {
+      generateSeedOptions.entropy = Uint8Array.from(options.entropy)
+    }
+    const secret = keypairs.generateSeed(generateSeedOptions)
     const keypair = keypairs.deriveKeypair(secret)
     const classicAddress = keypairs.deriveAddress(keypair.publicKey)
     const returnValue: any = {

test/api/generateAddress/index.ts

@@ -1,6 +1,7 @@
 import assert from 'assert-diff'
 import responses from '../../fixtures/responses'
 import {TestSuite} from '../../utils'
+import { GenerateAddressOptions } from '../../../src/offline/generate-address'
 const {generateAddress: RESPONSE_FIXTURES} = responses
 
 /**
@@ -9,22 +10,192 @@ const {generateAddress: RESPONSE_FIXTURES} = responses
  * - Check out "test/api/index.ts" for more information about the test runner.
  */
 export default <TestSuite>{
-  'generateAddress': async (api, address) => {
-    function random(): number[] {
+  'generateAddress': async (api) => {
+    // GIVEN entropy of all zeros
+    function random() {
       return new Array(16).fill(0)
     }
+
     assert.deepEqual(
+      // WHEN generating an address
       api.generateAddress({entropy: random()}),
+
+      // THEN we get the expected return value
       RESPONSE_FIXTURES
     )
   },
 
-  'generateAddress invalid': async (api, address) => {
+  'generateAddress invalid entropy': async (api) => {
     assert.throws(() => {
+      // GIVEN entropy of 1 byte
       function random() {
         return new Array(1).fill(0)
       }
+
+      // WHEN generating an address
       api.generateAddress({entropy: random()})
+
+      // THEN an UnexpectedError is thrown
+      // because 16 bytes of entropy are required
     }, api.errors.UnexpectedError)
+  },
+
+  'generateAddress with no options object': async (api) => {
+    // GIVEN no options
+
+    // WHEN generating an address
+    const account = api.generateAddress()
+
+    // THEN we get an object with an address starting with 'r' and a secret starting with 's'
+    assert(account.address.startsWith('r'), 'Address must start with `r`')
+    assert(account.secret.startsWith('s'), 'Secret must start with `s`')
+  },
+
+  'generateAddress with empty options object': async (api) => {
+    // GIVEN an empty options object
+    const options = {}
+
+    // WHEN generating an address
+    const account = api.generateAddress(options)
+
+    // THEN we get an object with an address starting with 'r' and a secret starting with 's'
+    assert(account.address.startsWith('r'), 'Address must start with `r`')
+    assert(account.secret.startsWith('s'), 'Secret must start with `s`')
+  },
+
+  'generateAddress with algorithm `ecdsa-secp256k1`': async (api) => {
+    // GIVEN we want to use 'ecdsa-secp256k1'
+    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1'}
+
+    // WHEN generating an address
+    const account = api.generateAddress(options)
+
+    // 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.notStrictEqual(account.secret.slice(0, 3), 'sEd', `secp256k1 secret ${account.secret} must not start with 'sEd'`)
+  },
+
+  'generateAddress with algorithm `ed25519`': async (api) => {
+    // GIVEN we want to use 'ed25519'
+    const options: GenerateAddressOptions = {algorithm: 'ed25519'}
+
+    // WHEN generating an address
+    const account = api.generateAddress(options)
+
+    // 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'`)
+  },
+
+  '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)}
+
+    // WHEN generating an address
+    const account = api.generateAddress(options)
+
+    // THEN we get the expected return value
+    assert.deepEqual(account, responses.generateAddress)
+  },
+
+  '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)}
+
+    // 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",
+      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
+      secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE'
+    })
+  },
+
+  '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}
+
+    // WHEN generating an address
+    const account = api.generateAddress(options)
+
+    // THEN we get the expected return value
+    assert.deepEqual(account, responses.generateAddress)
+  },
+
+  '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}
+
+    // 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",
+      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+    })
+  },
+
+  '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}
+
+    // 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) => {
+    // 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}
+
+    // 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",
+      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+    })
+  },
+
+  'generateAddress for test network use': async (api) => {
+    // GIVEN we want an address for test network use
+    const options: GenerateAddressOptions = {test: true}
+
+    // WHEN generating an address
+    const account = api.generateAddress(options)
+
+    // 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.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`)
   }
 }

test/api/generateXAddress/index.ts

@@ -1,6 +1,7 @@
 import assert from 'assert-diff'
 import responses from '../../fixtures/responses'
 import {TestSuite} from '../../utils'
+import { GenerateAddressOptions } from '../../../src/offline/generate-address'
 
 /**
  * Every test suite exports their tests in the default object.
@@ -8,22 +9,175 @@ import {TestSuite} from '../../utils'
  * - Check out "test/api/index.ts" for more information about the test runner.
  */
 export default <TestSuite>{
-  'generateXAddress': async (api, address) => {
+  'generateXAddress': async (api) => {
+    // GIVEN entropy of all zeros
     function random() {
       return new Array(16).fill(0)
     }
+
     assert.deepEqual(
+      // WHEN generating an X-address
       api.generateXAddress({entropy: random()}),
+
+      // THEN we get the expected return value
       responses.generateXAddress
     )
   },
 
-  'generateXAddress invalid': async (api, address) => {
+  'generateXAddress invalid entropy': async (api) => {
     assert.throws(() => {
+      // GIVEN entropy of 1 byte
       function random() {
         return new Array(1).fill(0)
       }
+
+      // WHEN generating an X-address
       api.generateXAddress({entropy: random()})
+
+      // THEN an UnexpectedError is thrown
+      // because 16 bytes of entropy are required
     }, api.errors.UnexpectedError)
+  },
+
+  '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.secret.startsWith('s'), 'Secrets start with s')
+  },
+
+  'generateXAddress with empty options object': async (api) => {
+    // GIVEN an empty options object
+    const options = {}
+
+    // WHEN generating an X-address
+    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.secret.startsWith('s'), 'Secrets start with s')
+  },
+
+  'generateXAddress with algorithm `ecdsa-secp256k1`': async (api) => {
+    // GIVEN we want to use 'ecdsa-secp256k1'
+    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1'}
+
+    // WHEN generating an X-address
+    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.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) => {
+    // GIVEN we want to use 'ed25519'
+    const options: GenerateAddressOptions = {algorithm: 'ed25519'}
+
+    // WHEN generating an X-address
+    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.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) => {
+    // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
+    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0)}
+
+    // WHEN generating an X-address
+    const account = api.generateXAddress(options)
+
+    // THEN we get the expected return value
+    assert.deepEqual(account, responses.generateXAddress)
+  },
+
+  '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)}
+
+    // WHEN generating an X-address
+    const account = api.generateXAddress(options)
+
+    // THEN we get the expected return value
+    assert.deepEqual(account, {
+      xAddress: 'X7xq1YJ4xmLSGGLhuakFQB9CebWYthQkgsvFC4LGFH871HB',
+      secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE'
+    })
+  },
+
+  '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}
+
+    // WHEN generating an X-address
+    const account = api.generateXAddress(options)
+
+    // THEN we get the expected return value
+    assert.deepEqual(account, responses.generateAddress)
+  },
+
+  '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}
+
+    // WHEN generating an X-address
+    const account = api.generateXAddress(options)
+
+    // THEN we get the expected return value
+    assert.deepEqual(account, {
+      xAddress: 'X7xq1YJ4xmLSGGLhuakFQB9CebWYthQkgsvFC4LGFH871HB',
+      secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE',
+      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
+      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+    })
+  },
+
+  '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}
+
+    // WHEN generating an X-address
+    const account = api.generateXAddress(options)
+
+    // THEN we get the expected return value
+    const response = Object.assign({}, responses.generateAddress, {
+      xAddress: 'TVG3TcCD58BD6MZqsNuTihdrhZwR8SzvYS8U87zvHsAcNw4'
+    })
+    assert.deepEqual(account, response)
+  },
+
+  '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}
+
+    // WHEN generating an X-address
+    const account = api.generateXAddress(options)
+
+    // THEN we get the expected return value
+    assert.deepEqual(account, {
+      xAddress: 'T7t4HeTMF5tT68agwuVbJwu23ssMPeh8dDtGysZoQiij1oo',
+      secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE',
+      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
+      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+    })
+  },
+
+  'generateXAddress for test network use': async (api) => {
+    // GIVEN we want an X-address for test network use
+    const options: GenerateAddressOptions = {test: true}
+
+    // WHEN generating an X-address
+    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(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`)
   }
 }

test/ripple-api-test.ts

@@ -32,21 +32,33 @@ describe('RippleAPI [Test Runner]', function() {
   // Run all the tests:
   for (const {name: methodName, tests, config} of allTestSuites) {
     describe(`api.${methodName}`, () => {
-      // Run each test with the original-style address.
-      describe(`[Original Address]`, () => {
-        for (const [testName, fn] of tests) {
+      // Run each test that does not use an address.
+      for (const [testName, fn] of tests) {
+        if (fn.length === 1) {
           it(testName, function() {
             return fn(this.api, addresses.ACCOUNT)
           })
         }
+      }
+      // Run each test with a classic address.
+      describe(`[Classic Address]`, () => {
+        for (const [testName, fn] of tests) {
+          if (fn.length === 2) {
+            it(testName, function() {
+              return fn(this.api, addresses.ACCOUNT)
+            })
+          }
+        }
       })
-      // Run each test with the newer, x-address style.
+      // Run each test with an X-address.
       if (!config.skipXAddress) {
         describe(`[X-address]`, () => {
           for (const [testName, fn] of tests) {
-            it(testName, function() {
-              return fn(this.api, addresses.ACCOUNT_X)
-            })
+            if (fn.length === 2) {
+              it(testName, function() {
+                return fn(this.api, addresses.ACCOUNT_X)
+              })
+            }
           }
         })
       }

yarn.lock

@@ -177,9 +177,9 @@
   integrity sha512-L/Nw/2e5KUaprNJoRA33oly+M8X8n0K+FwLTbYqwTcR14wdPWeRkigBLfSFpN/Asf9ENZTMZwLxjtjeYucAA4Q==
 
 "@types/node@*", "@types/node@^13.1.1":
-  version "13.7.0"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-13.7.0.tgz#b417deda18cf8400f278733499ad5547ed1abec4"
-  integrity sha512-GnZbirvmqZUzMgkFn70c74OQpTTUcCzlhQliTzYjQMqg+hVKcDnxdL19Ne3UdYzdMA/+W3eb646FWn/ZaT1NfQ==
+  version "13.7.1"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-13.7.1.tgz#238eb34a66431b71d2aaddeaa7db166f25971a0d"
+  integrity sha512-Zq8gcQGmn4txQEJeiXo/KiLpon8TzAl0kmKH4zdWctPj05nWwp1ClMdAVEloqrQKfaC48PNLdgN/aVaLqUrluA==
 
 "@types/ws@^7.2.0":
   version "7.2.1"
@@ -189,11 +189,11 @@
     "@types/node" "*"
 
 "@typescript-eslint/eslint-plugin@^2.3.3":
-  version "2.19.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-2.19.0.tgz#bf743448a4633e4b52bee0c40148ba072ab3adbd"
-  integrity sha512-u7IcQ9qwsB6U806LupZmINRnQjC+RJyv36sV/ugaFWMHTbFm/hlLTRx3gGYJgHisxcGSTnf+I/fPDieRMhPSQQ==
+  version "2.20.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-2.20.0.tgz#a522d0e1e4898f7c9c6a8e1ed3579b60867693fa"
+  integrity sha512-cimIdVDV3MakiGJqMXw51Xci6oEDEoPkvh8ggJe2IIzcc0fYqAxOXN6Vbeanahz6dLZq64W+40iUEc9g32FLDQ==
   dependencies:
-    "@typescript-eslint/experimental-utils" "2.19.0"
+    "@typescript-eslint/experimental-utils" "2.20.0"
     eslint-utils "^1.4.3"
     functional-red-black-tree "^1.0.1"
     regexpp "^3.0.0"
@@ -208,13 +208,13 @@
     "@typescript-eslint/typescript-estree" "2.14.0"
     eslint-scope "^5.0.0"
 
-"@typescript-eslint/experimental-utils@2.19.0":
-  version "2.19.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/experimental-utils/-/experimental-utils-2.19.0.tgz#d5ca732f22c009e515ba09fcceb5f2127d841568"
-  integrity sha512-zwpg6zEOPbhB3+GaQfufzlMUOO6GXCNZq6skk+b2ZkZAIoBhVoanWK255BS1g5x9bMwHpLhX0Rpn5Fc3NdCZdg==
+"@typescript-eslint/experimental-utils@2.20.0":
+  version "2.20.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/experimental-utils/-/experimental-utils-2.20.0.tgz#3b6fa5a6b8885f126d5a4280e0d44f0f41e73e32"
+  integrity sha512-fEBy9xYrwG9hfBLFEwGW2lKwDRTmYzH3DwTmYbT+SMycmxAoPl0eGretnBFj/s+NfYBG63w/5c3lsvqqz5mYag==
   dependencies:
     "@types/json-schema" "^7.0.3"
-    "@typescript-eslint/typescript-estree" "2.19.0"
+    "@typescript-eslint/typescript-estree" "2.20.0"
     eslint-scope "^5.0.0"
 
 "@typescript-eslint/parser@^2.3.3":
@@ -240,10 +240,10 @@
     semver "^6.3.0"
     tsutils "^3.17.1"
 
-"@typescript-eslint/typescript-estree@2.19.0":
-  version "2.19.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-2.19.0.tgz#6bd7310b9827e04756fe712909f26956aac4b196"
-  integrity sha512-n6/Xa37k0jQdwpUszffi19AlNbVCR0sdvCs3DmSKMD7wBttKY31lhD2fug5kMD91B2qW4mQldaTEc1PEzvGu8w==
+"@typescript-eslint/typescript-estree@2.20.0":
+  version "2.20.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-2.20.0.tgz#90a0f5598826b35b966ca83483b1a621b1a4d0c9"
+  integrity sha512-WlFk8QtI8pPaE7JGQGxU7nGcnk1ccKAJkhbVookv94ZcAef3m6oCE/jEDL6dGte3JcD7reKrA0o55XhBRiVT3A==
   dependencies:
     debug "^4.1.1"
     eslint-visitor-keys "^1.1.0"
@@ -4121,7 +4121,7 @@ ripple-binary-codec@^0.2.5:
     lodash "^4.17.15"
     ripple-address-codec "^4.0.0"
 
-ripple-keypairs@^1.0.0-beta.6:
+ripple-keypairs@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/ripple-keypairs/-/ripple-keypairs-1.0.0.tgz#8f1c604f89daeac5e61b7eebbbca2da99da2bacf"
   integrity sha512-MQ3d6fU3D+Cqu5ma4dfkfa+KakN2sKpVVVN0FeJyAYPVIGXu8Rcvd1g028TdwYAZcSYk0tGn5UhHxd0gUG3T8g==
@@ -4801,7 +4801,7 @@ typedarray@^0.0.6:
   resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
   integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
 
-typescript@^3.6.4:
+typescript@^3.7.5:
   version "3.7.5"
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.7.5.tgz#0692e21f65fd4108b9330238aac11dd2e177a1ae"
   integrity sha512-/P5lkRXkWHNAbcJIiHPfRoKqyd7bsyCma1hZNUGfn20qm64T6ZBlrzprymeu918H+mB/0rIg2gGK/BXkhhYgBw==
@@ -5034,9 +5034,9 @@ webpack-bundle-analyzer@^3.6.0:
     ws "^6.0.0"
 
 webpack-cli@^3.3.9:
-  version "3.3.10"
-  resolved "https://registry.yarnpkg.com/webpack-cli/-/webpack-cli-3.3.10.tgz#17b279267e9b4fb549023fae170da8e6e766da13"
-  integrity sha512-u1dgND9+MXaEt74sJR4PR7qkPxXUSQ0RXYq8x1L6Jg1MYVEmGPrH6Ah6C4arD4r0J1P5HKjRqpab36k0eIzPqg==
+  version "3.3.11"
+  resolved "https://registry.yarnpkg.com/webpack-cli/-/webpack-cli-3.3.11.tgz#3bf21889bf597b5d82c38f215135a411edfdc631"
+  integrity sha512-dXlfuml7xvAFwYUPsrtQAA9e4DOe58gnzSxhgrO/ZM/gyXTBowrsYeubyN4mqGhYdpXMFNyQ6emjJS9M7OBd4g==
   dependencies:
     chalk "2.4.2"
     cross-spawn "6.0.5"
@@ -5059,9 +5059,9 @@ webpack-sources@^1.4.0, webpack-sources@^1.4.1:
     source-map "~0.6.1"
 
 webpack@^4.41.2:
-  version "4.41.4"
-  resolved "https://registry.yarnpkg.com/webpack/-/webpack-4.41.4.tgz#4bec4125224bdf50efa8be6226c19047599cd034"
-  integrity sha512-Lc+2uB6NjpCWsHI3trkoISOI64h9QYIXenbEWj3bn3oyjfB1lEBXjWAfAyY2sM0rZn41oD5V91OLwKRwS6Wp8Q==
+  version "4.41.6"
+  resolved "https://registry.yarnpkg.com/webpack/-/webpack-4.41.6.tgz#12f2f804bf6542ef166755050d4afbc8f66ba7e1"
+  integrity sha512-yxXfV0Zv9WMGRD+QexkZzmGIh54bsvEs+9aRWxnN8erLWEOehAKUTeNBoUbA6HPEZPlRo7KDi2ZcNveoZgK9MA==
   dependencies:
     "@webassemblyjs/ast" "1.8.5"
     "@webassemblyjs/helper-module-context" "1.8.5"