Merge remote-tracking branch 'origin/master' into Version-v10.13.0

CHANGELOG.md

@@ -32,6 +32,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fix token icon when going from token detail page to Swaps view ([#14062](https://github.com/MetaMask/metamask-extension/pull/14062))
 - Fix issue where the contract address is shown as recipient when calling safe transfer method on erc721 or erc1155 contracts ([#13535](https://github.com/MetaMask/metamask-extension/pull/13535))
 - Ensure accounts still line up in dropdown ([#13986](https://github.com/MetaMask/metamask-extension/pull/13986))
+## [10.12.4]
+### Fixed
+- Fix MetaMask internal error reporting (#14344)
+
+## [10.12.3]
+### Changed
+- This version was used to rollback from v10.12.0 to v10.11.3.
+
+## [10.12.2]
+### Fixed
+- Fix error where unlock failed after update to v10.12.0
+
+## [10.12.1]
+### Changed
+- This version was used to rollback from v10.12.0 to v10.11.4.
 
 ## [10.12.0]
 ### Added
@@ -2870,6 +2885,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 [Unreleased]: https://github.com/MetaMask/metamask-extension/compare/v10.13.0...HEAD
 [10.13.0]: https://github.com/MetaMask/metamask-extension/compare/v10.12.0...v10.13.0
+[Unreleased]: https://github.com/MetaMask/metamask-extension/compare/v10.12.4...HEAD
+[10.12.4]: https://github.com/MetaMask/metamask-extension/compare/v10.12.3...v10.12.4
+[10.12.3]: https://github.com/MetaMask/metamask-extension/compare/v10.12.2...v10.12.3
+[10.12.2]: https://github.com/MetaMask/metamask-extension/compare/v10.12.1...v10.12.2
+[10.12.1]: https://github.com/MetaMask/metamask-extension/compare/v10.12.0...v10.12.1
 [10.12.0]: https://github.com/MetaMask/metamask-extension/compare/v10.11.4...v10.12.0
 [10.11.4]: https://github.com/MetaMask/metamask-extension/compare/v10.11.3...v10.11.4
 [10.11.3]: https://github.com/MetaMask/metamask-extension/compare/v10.11.2...v10.11.3

app/scripts/lib/seed-phrase-verifier.js

@@ -11,10 +11,10 @@ const seedPhraseVerifier = {
    * - The keyring always creates the accounts in the same sequence.
    *
    * @param {Array} createdAccounts - The accounts to restore
-   * @param {string} seedWords - The seed words to verify
+   * @param {Buffer} seedPhrase - The seed words to verify, encoded as a Buffer
-   * @returns {Promise<void>} Promises undefined
+   * @returns {Promise<void>}
    */
-  async verifyAccounts(createdAccounts, seedWords) {
+  async verifyAccounts(createdAccounts, seedPhrase) {
     if (!createdAccounts || createdAccounts.length < 1) {
       throw new Error('No created accounts defined.');
     }
@@ -22,7 +22,7 @@ const seedPhraseVerifier = {
     const keyringController = new KeyringController({});
     const Keyring = keyringController.getKeyringClassForType('HD Key Tree');
     const opts = {
-      mnemonic: seedWords,
+      mnemonic: seedPhrase,
       numberOfAccounts: createdAccounts.length,
     };
 

app/scripts/lib/setupSentry.js

@@ -68,9 +68,9 @@ export const SENTRY_STATE = {
 };
 
 export default function setupSentry({ release, getState }) {
-  let sentryTarget;
+  if (!release) {
-
+    throw new Error('Missing release');
-  if (METAMASK_DEBUG) {
+  } else if (METAMASK_DEBUG) {
     return undefined;
   }
 
@@ -79,6 +79,7 @@ export default function setupSentry({ release, getState }) {
       ? METAMASK_ENVIRONMENT
       : `${METAMASK_ENVIRONMENT}-${METAMASK_BUILD_TYPE}`;
 
+  let sentryTarget;
   if (METAMASK_ENVIRONMENT === 'production') {
     if (!process.env.SENTRY_DSN) {
       throw new Error(

app/scripts/metamask-controller.js

@@ -1881,13 +1881,16 @@ export default class MetamaskController extends EventEmitter {
    * Create a new Vault and restore an existent keyring.
    *
    * @param {string} password
-   * @param {string} seed
+   * @param {number[]} encodedSeedPhrase - The seed phrase, encoded as an array
+   * of UTF-8 bytes.
    */
-  async createNewVaultAndRestore(password, seed) {
+  async createNewVaultAndRestore(password, encodedSeedPhrase) {
     const releaseLock = await this.createVaultMutex.acquire();
     try {
       let accounts, lastBalance;
 
+      const seedPhraseAsBuffer = Buffer.from(encodedSeedPhrase);
+
       const { keyringController } = this;
 
       // clear known identities
@@ -1908,7 +1911,7 @@ export default class MetamaskController extends EventEmitter {
       // create new vault
       const vault = await keyringController.createNewVaultAndRestore(
         password,
-        seed,
+        seedPhraseAsBuffer,
       );
 
       const ethQuery = new EthQuery(this.provider);
@@ -2416,7 +2419,8 @@ export default class MetamaskController extends EventEmitter {
    *
    * Called when the first account is created and on unlocking the vault.
    *
-   * @returns {Promise<string>} Seed phrase to be confirmed by the user.
+   * @returns {Promise<number[]>} The seed phrase to be confirmed by the user,
+   * encoded as an array of UTF-8 bytes.
    */
   async verifySeedPhrase() {
     const primaryKeyring = this.keyringController.getKeyringsByType(
@@ -2427,7 +2431,7 @@ export default class MetamaskController extends EventEmitter {
     }
 
     const serialized = await primaryKeyring.serialize();
-    const seedWords = serialized.mnemonic;
+    const seedPhraseAsBuffer = Buffer.from(serialized.mnemonic);
 
     const accounts = await primaryKeyring.getAccounts();
     if (accounts.length < 1) {
@@ -2435,8 +2439,8 @@ export default class MetamaskController extends EventEmitter {
     }
 
     try {
-      await seedPhraseVerifier.verifyAccounts(accounts, seedWords);
+      await seedPhraseVerifier.verifyAccounts(accounts, seedPhraseAsBuffer);
-      return seedWords;
+      return Array.from(seedPhraseAsBuffer.values());
     } catch (err) {
       log.error(err.message);
       throw err;

development/build/scripts.js

@@ -269,6 +269,7 @@ function createScriptTasks({
       testing,
       policyOnly,
       shouldLintFenceFiles,
+      version,
     });
   }
 
@@ -285,6 +286,7 @@ function createScriptTasks({
       testing,
       policyOnly,
       shouldLintFenceFiles,
+      version,
     });
   }
 
@@ -301,6 +303,7 @@ function createScriptTasks({
       testing,
       policyOnly,
       shouldLintFenceFiles,
+      version,
     });
   }
 
@@ -320,6 +323,7 @@ function createScriptTasks({
         policyOnly,
         shouldLintFenceFiles,
         testing,
+        version,
       }),
       createNormalBundle({
         buildType,
@@ -332,6 +336,7 @@ function createScriptTasks({
         policyOnly,
         shouldLintFenceFiles,
         testing,
+        version,
       }),
     );
   }
@@ -532,6 +537,7 @@ function createNormalBundle({
   modulesToExpose,
   shouldLintFenceFiles,
   testing,
+  version,
 }) {
   return async function () {
     // create bundler setup and apply defaults
@@ -543,7 +549,12 @@ function createNormalBundle({
     const reloadOnChange = Boolean(devMode);
     const minify = Boolean(devMode) === false;
 
-    const envVars = getEnvironmentVariables({ buildType, devMode, testing });
+    const envVars = getEnvironmentVariables({
+      buildType,
+      devMode,
+      testing,
+      version,
+    });
     setupBundlerDefaults(buildConfiguration, {
       buildType,
       devMode,

lavamoat/browserify/beta/policy.json

@@ -1178,6 +1178,9 @@
       }
     },
     "bip39": {
+      "globals": {
+        "console.log": true
+      },
       "packages": {
         "buffer": true,
         "create-hash": true,
@@ -1892,6 +1895,7 @@
     "eth-hd-keyring": {
       "packages": {
         "bip39": true,
+        "buffer": true,
         "eth-sig-util": true,
         "eth-simple-keyring": true,
         "ethereumjs-wallet": true
@@ -1950,6 +1954,7 @@
       "packages": {
         "bip39": true,
         "browser-passworder": true,
+        "buffer": true,
         "eth-hd-keyring": true,
         "eth-sig-util": true,
         "eth-simple-keyring": true,

lavamoat/browserify/flask/policy.json

@@ -1196,6 +1196,9 @@
       }
     },
     "bip39": {
+      "globals": {
+        "console.log": true
+      },
       "packages": {
         "buffer": true,
         "create-hash": true,
@@ -1910,6 +1913,7 @@
     "eth-hd-keyring": {
       "packages": {
         "bip39": true,
+        "buffer": true,
         "eth-sig-util": true,
         "eth-simple-keyring": true,
         "ethereumjs-wallet": true
@@ -1968,6 +1972,7 @@
       "packages": {
         "bip39": true,
         "browser-passworder": true,
+        "buffer": true,
         "eth-hd-keyring": true,
         "eth-sig-util": true,
         "eth-simple-keyring": true,

lavamoat/browserify/main/policy.json

@@ -1178,6 +1178,9 @@
       }
     },
     "bip39": {
+      "globals": {
+        "console.log": true
+      },
       "packages": {
         "buffer": true,
         "create-hash": true,
@@ -1892,6 +1895,7 @@
     "eth-hd-keyring": {
       "packages": {
         "bip39": true,
+        "buffer": true,
         "eth-sig-util": true,
         "eth-simple-keyring": true,
         "ethereumjs-wallet": true
@@ -1950,6 +1954,7 @@
       "packages": {
         "bip39": true,
         "browser-passworder": true,
+        "buffer": true,
         "eth-hd-keyring": true,
         "eth-sig-util": true,
         "eth-simple-keyring": true,

patches/bip39+2.5.0.patch

@@ -0,0 +1,99 @@
+diff --git a/node_modules/bip39/index.js b/node_modules/bip39/index.js
+index aa0f29f..bee8008 100644
+--- a/node_modules/bip39/index.js
++++ b/node_modules/bip39/index.js
+@@ -48,7 +48,9 @@ function salt (password) {
+ }
+ 
+ function mnemonicToSeed (mnemonic, password) {
+-  var mnemonicBuffer = Buffer.from(unorm.nfkd(mnemonic), 'utf8')
++  var mnemonicBuffer = typeof mnemonic === 'string'
++    ? Buffer.from(unorm.nfkd(mnemonic), 'utf8')
++    : mnemonic
+   var saltBuffer = Buffer.from(salt(unorm.nfkd(password)), 'utf8')
+ 
+   return pbkdf2(mnemonicBuffer, saltBuffer, 2048, 64, 'sha512')
+@@ -61,12 +63,28 @@ function mnemonicToSeedHex (mnemonic, password) {
+ function mnemonicToEntropy (mnemonic, wordlist) {
+   wordlist = wordlist || DEFAULT_WORDLIST
+ 
+-  var words = unorm.nfkd(mnemonic).split(' ')
++  var mnemonicAsBuffer = typeof mnemonic === 'string'
++    ? Buffer.from(unorm.nfkd(mnemonic), 'utf8')
++    : mnemonic
++
++  var words = [];
++  var currentWord = [];
++  for (const byte of mnemonicAsBuffer.values()) {
++    // split at space or \u3000 (ideographic space, for Japanese wordlists)
++    if (byte === 0x20 || byte === 0x3000) {
++      words.push(Buffer.from(currentWord));
++      currentWord = [];
++    } else {
++      currentWord.push(byte);
++    }
++  }
++  words.push(Buffer.from(currentWord));
++
+   if (words.length % 3 !== 0) throw new Error(INVALID_MNEMONIC)
+ 
+   // convert word indices to 11 bit binary strings
+   var bits = words.map(function (word) {
+-    var index = wordlist.indexOf(word)
++    var index = wordlist.indexOf(word.toString('utf8'))
+     if (index === -1) throw new Error(INVALID_MNEMONIC)
+ 
+     return lpad(index.toString(2), '0', 11)
+@@ -104,12 +122,41 @@ function entropyToMnemonic (entropy, wordlist) {
+ 
+   var bits = entropyBits + checksumBits
+   var chunks = bits.match(/(.{1,11})/g)
+-  var words = chunks.map(function (binary) {
++  var wordsAsBuffers = chunks.map(function (binary) {
+     var index = binaryToByte(binary)
+-    return wordlist[index]
++    return Buffer.from(wordlist[index], 'utf8')
+   })
+ 
+-  return wordlist === JAPANESE_WORDLIST ? words.join('\u3000') : words.join(' ')
++  var bufferSize = wordsAsBuffers.reduce(function (bufferSize, wordAsBuffer, i) {
++    var shouldAddSeparator = i < wordsAsBuffers.length - 1
++    return (
++      bufferSize +
++      wordAsBuffer.length +
++      (shouldAddSeparator ? 1 : 0)
++    )
++  }, 0)
++  var separator = wordlist === JAPANESE_WORDLIST ? '\u3000' : ' '
++  var result = wordsAsBuffers.reduce(function (result, wordAsBuffer, i) {
++    var shouldAddSeparator = i < wordsAsBuffers.length - 1
++    result.workingBuffer.set(wordAsBuffer, result.offset)
++    if (shouldAddSeparator) {
++      result.workingBuffer.write(
++        separator,
++        result.offset + wordAsBuffer.length,
++        separator.length,
++        'utf8'
++      )
++    }
++    return {
++      workingBuffer: result.workingBuffer,
++      offset: (
++        result.offset +
++        wordAsBuffer.length +
++        (shouldAddSeparator ? 1 : 0)
++      )
++    }
++  }, { workingBuffer: Buffer.alloc(bufferSize), offset: 0 })
++  return result.workingBuffer;
+ }
+ 
+ function generateMnemonic (strength, rng, wordlist) {
+@@ -124,6 +171,7 @@ function validateMnemonic (mnemonic, wordlist) {
+   try {
+     mnemonicToEntropy(mnemonic, wordlist)
+   } catch (e) {
++    console.log('could not validate mnemonic', e)
+     return false
+   }
+ 

patches/eth-hd-keyring+3.6.0.patch

@@ -0,0 +1,43 @@
+diff --git a/node_modules/eth-hd-keyring/index.js b/node_modules/eth-hd-keyring/index.js
+index 19d1d7f..350d6b8 100644
+--- a/node_modules/eth-hd-keyring/index.js
++++ b/node_modules/eth-hd-keyring/index.js
+@@ -17,8 +17,11 @@ class HdKeyring extends SimpleKeyring {
+   }
+ 
+   serialize () {
++    const mnemonicAsBuffer = typeof this.mnemonic === 'string'
++      ? Buffer.from(this.mnemonic, 'utf8')
++      : this.mnemonic
+     return Promise.resolve({
+-      mnemonic: this.mnemonic,
++      mnemonic: Array.from(mnemonicAsBuffer.values()),
+       numberOfAccounts: this.wallets.length,
+       hdPath: this.hdPath,
+     })
+@@ -69,9 +72,22 @@ class HdKeyring extends SimpleKeyring {
+ 
+   /* PRIVATE METHODS */
+ 
+-  _initFromMnemonic (mnemonic) {
+-    this.mnemonic = mnemonic
+-    const seed = bip39.mnemonicToSeed(mnemonic)
++  /**
++   * Sets appropriate properties for the keyring based on the given
++   * BIP39-compliant mnemonic.
++   *
++   * @param {string|Array<number>|Buffer} mnemonic - A seed phrase represented
++   * as a string, an array of UTF-8 bytes, or a Buffer.
++   */
++  _initFromMnemonic(mnemonic) {
++    if (typeof mnemonic === 'string') {
++      this.mnemonic = Buffer.from(mnemonic, 'utf8')
++    } else if (Array.isArray(mnemonic)) {
++      this.mnemonic = Buffer.from(mnemonic)
++    } else {
++      this.mnemonic = mnemonic
++    }
++    const seed = bip39.mnemonicToSeed(this.mnemonic)
+     this.hdWallet = hdkey.fromMasterSeed(seed)
+     this.root = this.hdWallet.derivePath(this.hdPath)
+   }

patches/eth-keyring-controller+6.2.1.patch

@@ -0,0 +1,37 @@
+diff --git a/node_modules/eth-keyring-controller/index.js b/node_modules/eth-keyring-controller/index.js
+index 250ab98..38615aa 100644
+--- a/node_modules/eth-keyring-controller/index.js
++++ b/node_modules/eth-keyring-controller/index.js
+@@ -84,15 +84,20 @@ class KeyringController extends EventEmitter {
+    *
+    * @emits KeyringController#unlock
+    * @param {string} password - The password to encrypt the vault with
+-   * @param {string} seed - The BIP44-compliant seed phrase.
++   * @param {string|Array<number>} seedPhrase - The BIP39-compliant seed phrase,
++   * either as a string or an array of UTF-8 bytes that represent the string.
+    * @returns {Promise<Object>} A Promise that resolves to the state.
+    */
+-  createNewVaultAndRestore (password, seed) {
++  createNewVaultAndRestore(password, seedPhrase) {
++    const seedPhraseAsBuffer = typeof seedPhrase === 'string'
++      ? Buffer.from(seedPhrase, 'utf8')
++      : Buffer.from(seedPhrase)
++
+     if (typeof password !== 'string') {
+       return Promise.reject(new Error('Password must be text.'))
+     }
+ 
+-    if (!bip39.validateMnemonic(seed)) {
++    if (!bip39.validateMnemonic(seedPhraseAsBuffer)) {
+       return Promise.reject(new Error('Seed phrase is invalid.'))
+     }
+ 
+@@ -101,7 +106,7 @@ class KeyringController extends EventEmitter {
+     return this.persistAllKeyrings(password)
+       .then(() => {
+         return this.addNewKeyring('HD Key Tree', {
+-          mnemonic: seed,
++          mnemonic: seedPhraseAsBuffer,
+           numberOfAccounts: 1,
+         })
+       })

ui/store/actions.js

@@ -80,20 +80,39 @@ export function tryUnlockMetamask(password) {
   };
 }
 
-export function createNewVaultAndRestore(password, seed) {
+/**
+ * Adds a new account where all data is encrypted using the given password and
+ * where all addresses are generated from a given seed phrase.
+ *
+ * @param {string} password - The password.
+ * @param {string} seedPhrase - The seed phrase.
+ * @returns {Object} The updated state of the keyring controller.
+ */
+export function createNewVaultAndRestore(password, seedPhrase) {
   return (dispatch) => {
     dispatch(showLoadingIndication());
     log.debug(`background.createNewVaultAndRestore`);
+
+    // Encode the secret recovery phrase as an array of integers so that it is
+    // serialized as JSON properly.
+    const encodedSeedPhrase = Array.from(
+      Buffer.from(seedPhrase, 'utf8').values(),
+    );
+
     let vault;
     return new Promise((resolve, reject) => {
-      background.createNewVaultAndRestore(password, seed, (err, _vault) => {
+      background.createNewVaultAndRestore(
-        if (err) {
+        password,
-          reject(err);
+        encodedSeedPhrase,
-          return;
+        (err, _vault) => {
-        }
+          if (err) {
-        vault = _vault;
+            reject(err);
-        resolve();
+            return;
-      });
+          }
+          vault = _vault;
+          resolve();
+        },
+      );
     })
       .then(() => dispatch(unMarkPasswordForgotten()))
       .then(() => {
@@ -115,8 +134,8 @@ export function createNewVaultAndGetSeedPhrase(password) {
 
     try {
       await createNewVault(password);
-      const seedWords = await verifySeedPhrase();
+      const seedPhrase = await verifySeedPhrase();
-      return seedWords;
+      return seedPhrase;
     } catch (error) {
       dispatch(displayWarning(error.message));
       throw new Error(error.message);
@@ -132,9 +151,9 @@ export function unlockAndGetSeedPhrase(password) {
 
     try {
       await submitPassword(password);
-      const seedWords = await verifySeedPhrase();
+      const seedPhrase = await verifySeedPhrase();
       await forceUpdateMetamaskState(dispatch);
-      return seedWords;
+      return seedPhrase;
     } catch (error) {
       dispatch(displayWarning(error.message));
       throw new Error(error.message);
@@ -183,17 +202,9 @@ export function verifyPassword(password) {
   });
 }
 
-export function verifySeedPhrase() {
+export async function verifySeedPhrase() {
-  return new Promise((resolve, reject) => {
+  const encodedSeedPhrase = await promisifiedBackground.verifySeedPhrase();
-    background.verifySeedPhrase((error, seedWords) => {
+  return Buffer.from(encodedSeedPhrase).toString('utf8');
-      if (error) {
-        reject(error);
-        return;
-      }
-
-      resolve(seedWords);
-    });
-  });
 }
 
 export function requestRevealSeedWords(password) {
@@ -203,11 +214,11 @@ export function requestRevealSeedWords(password) {
 
     try {
       await verifyPassword(password);
-      const seedWords = await verifySeedPhrase();
+      const seedPhrase = await verifySeedPhrase();
-      return seedWords;
+      return seedPhrase;
     } catch (error) {
       dispatch(displayWarning(error.message));
-      throw new Error(error.message);
+      throw error;
     } finally {
       dispatch(hideLoadingIndication());
     }

ui/store/actions.test.js

@@ -111,7 +111,9 @@ describe('Actions', () => {
 
       actions._setBackgroundConnection(background);
 
-      await store.dispatch(actions.createNewVaultAndRestore());
+      await store.dispatch(
+        actions.createNewVaultAndRestore('password', 'test'),
+      );
       expect(createNewVaultAndRestore.callCount).toStrictEqual(1);
     });
 
@@ -134,7 +136,9 @@ describe('Actions', () => {
         { type: 'HIDE_LOADING_INDICATION' },
       ];
 
-      await store.dispatch(actions.createNewVaultAndRestore());
+      await store.dispatch(
+        actions.createNewVaultAndRestore('password', 'test'),
+      );
 
       expect(store.getActions()).toStrictEqual(expectedActions);
     });
@@ -155,7 +159,7 @@ describe('Actions', () => {
       ];
 
       await expect(
-        store.dispatch(actions.createNewVaultAndRestore()),
+        store.dispatch(actions.createNewVaultAndRestore('password', 'test')),
       ).rejects.toThrow('error');
 
       expect(store.getActions()).toStrictEqual(expectedActions);
@@ -174,7 +178,7 @@ describe('Actions', () => {
         cb(),
       );
       const verifySeedPhrase = background.verifySeedPhrase.callsFake((cb) =>
-        cb(),
+        cb(null, Array.from(Buffer.from('test').values())),
       );
 
       actions._setBackgroundConnection(background);