[Feat] [DO NOT MERGE] MV3 migration

packages/background/package.json

@@ -8,15 +8,15 @@
         "@block-wallet/explorer-link": "https://github.com/block-wallet/explorer-link#v2.2.2",
         "@block-wallet/remote-configs": "https://github.com/block-wallet/remote-configs#v1.1.0",
         "@ethereumjs/tx": "^3.5.2",
+        "@metamask/browser-passworder": "https://github.com/block-wallet/browser-passworder#v1.0.1",
+        "@metamask/eth-keyring-controller": "^10.0.0",
         "@metamask/eth-sig-util": "^5.0.2",
         "@unstoppabledomains/resolution": "^8.3.3",
         "async-mutex": "^0.3.2",
         "bip39": "^3.0.3",
-        "browser-passworder": "^2.0.3",
         "compare-versions": "^3.6.0",
         "eslint-webpack-plugin": "^3.2.0",
         "eth-ens-namehash": "^2.0.8",
-        "eth-keyring-controller": "^6.2.0",
         "eth-trezor-keyring": "https://github.com/block-wallet/eth-trezor-keyring#v0.10.2",
         "ethereumjs-util": "^7.0.7",
         "ethereumjs-wallet": "^1.0.1",

packages/background/src/controllers/AppStateController.ts

@@ -17,6 +17,11 @@ export enum AppStateEvents {
     APP_UNLOCKED = 'APP_UNLOCKED',
 }
 
+export type SessionToken = {
+    encryptionKey: string;
+    encryptionSalt: string;
+};
+
 export default class AppStateController extends BaseController<AppStateControllerState> {
     private _timer: ReturnType<typeof setTimeout> | null;
 
@@ -117,19 +122,15 @@ export default class AppStateController extends BaseController<AppStateControlle
     public unlock = async (password: string): Promise<void> => {
         try {
             // Unlock vault
-            const loginToken = await this._keyringController.submitPassword(
+            const sessionToken = await this._keyringController.submitPassword(
                 password
             );
 
             if (isManifestV3()) {
-                // @ts-ignore
-                chrome.storage.session &&
-                    // @ts-ignore
-                    chrome.storage.session
-                        .set({ loginToken })
-                        .catch((err: any) => {
-                            log.error('error setting loginToken', err);
-                        });
+                this._storeSessionToken({
+                    encryptionKey: sessionToken.encryptionKey,
+                    encryptionSalt: sessionToken.encryptionSalt,
+                });
             }
 
             await this._postLoginAction();
@@ -138,24 +139,76 @@ export default class AppStateController extends BaseController<AppStateControlle
         }
     };
 
+    private _getSessionToken(): Promise<SessionToken | undefined> {
+        return new Promise((resolve) => {
+            // @ts-ignore
+            if (chrome.storage.session) {
+                // @ts-ignore
+                chrome.storage.session.get(
+                    ['sessionToken'],
+                    async ({ sessionToken }: { [key: string]: any }) => {
+                        if (!sessionToken) {
+                            resolve(undefined);
+                        }
+                        resolve(sessionToken as SessionToken);
+                    }
+                );
+            } else {
+                resolve(undefined);
+            }
+        });
+    }
+
+    private async _storeSessionToken(
+        sessionToken: SessionToken
+    ): Promise<SessionToken> {
+        // @ts-ignore
+        if (chrome.storage.session) {
+            // @ts-ignore
+            await chrome.storage.session
+                .set({
+                    sessionToken: {
+                        encryptionKey: sessionToken.encryptionKey,
+                        encryptionSalt: sessionToken.encryptionSalt,
+                    },
+                })
+                .catch((err: any) => {
+                    log.error('error setting sessionToken', err);
+                });
+        }
+
+        return sessionToken;
+    }
+
     public autoUnlock = async (): Promise<void> => {
         if (isManifestV3()) {
             const { isAppUnlocked } = this.store.getState();
-            if (!isAppUnlocked) {
-                // @ts-ignore
-                chrome.storage.session &&
-                    // @ts-ignore
-                    chrome.storage.session.get(
-                        ['loginToken'],
-                        async ({ loginToken }: { [key: string]: string }) => {
-                            if (loginToken) {
-                                await (this._keyringController as any)[
-                                    'submitEncryptionKey'
-                                ](loginToken);
-                                await this._postLoginAction();
-                            }
-                        }
-                    );
+            if (isAppUnlocked) {
+                let forceLock = true;
+                try {
+                    const sessionToken = await this._getSessionToken();
+                    if (sessionToken) {
+                        const newSessionToken =
+                            await this._keyringController.submitEncryptionKey(
+                                sessionToken.encryptionKey,
+                                sessionToken.encryptionSalt
+                            );
+                        await this._storeSessionToken({
+                            encryptionKey: newSessionToken.encryptionKey,
+                            encryptionSalt: newSessionToken.encryptionSalt,
+                        });
+                        await this._postLoginAction();
+                        forceLock = false;
+                    }
+                } catch (e) {
+                    log.error('Unable to autoUnlock keyring', e);
+                } finally {
+                    // if we were unable to unlock keyring we should lock the wallet
+                    // the user needs to unlock the keyring and the wallet by his own
+                    if (forceLock) {
+                        this.lock();
+                    }
+                }
             }
         }
     };

packages/background/src/controllers/KeyringControllerDerivated.ts

@@ -1,7 +1,10 @@
-import KeyringController, {
+import {
+    KeyringController,
+    keyringBuilderFactory,
     KeyringControllerProps,
     KeyringControllerState,
-} from 'eth-keyring-controller';
+} from '@metamask/eth-keyring-controller';
+import * as customEncryptor from '@metamask/browser-passworder';
 import { Hash, Hasheable } from '../utils/hasher';
 import { Mutex } from 'async-mutex';
 import LedgerBridgeKeyring from '@block-wallet/eth-ledger-bridge-keyring';
@@ -10,6 +13,9 @@ import { Devices } from '../utils/types/hardware';
 import log from 'loglevel';
 import { HDPaths, BIP44_PATH } from '../utils/types/hardware';
 import { TypedTransaction } from '@ethereumjs/tx';
+import { isManifestV3 } from '../utils/manifest';
+import { bufferToHex } from 'ethereumjs-util';
+import { hexToString } from '../utils/signature';
 /**
  * Available keyring types
  */
@@ -24,7 +30,12 @@ export default class KeyringControllerDerivated extends KeyringController {
     private readonly _mutex: Mutex;
 
     constructor(opts: KeyringControllerProps) {
-        opts.keyringTypes = [LedgerBridgeKeyring, TrezorKeyring];
+        opts.keyringBuilders = [
+            keyringBuilderFactory(LedgerBridgeKeyring),
+            keyringBuilderFactory(TrezorKeyring),
+        ];
+        opts.cacheEncryptionKey = isManifestV3();
+        opts.encryptor = customEncryptor;
         super(opts);
 
         this._mutex = new Mutex();
@@ -155,8 +166,7 @@ export default class KeyringControllerDerivated extends KeyringController {
             KeyringTypes.HD_KEY_TREE
         )[0];
         const serialized = await primaryKeyring.serialize();
-        const seedPhrase = serialized.mnemonic;
-
+        const seedPhrase = hexToString(bufferToHex(serialized.mnemonic));
         return seedPhrase;
     }
 
@@ -252,15 +262,20 @@ export default class KeyringControllerDerivated extends KeyringController {
 
         // Generate a new keyring
         const keyringController = new KeyringController({});
-        const Keyring = keyringController.getKeyringClassForType(
-            KeyringTypes.HD_KEY_TREE
-        );
+
         const opts = {
             mnemonic: seedPhrase,
             numberOfAccounts: createdAccounts.length,
         };
 
-        const keyring = new Keyring(opts);
+        const keyring = await keyringController._newKeyring(
+            KeyringTypes.HD_KEY_TREE,
+            opts
+        );
+        if (!keyring) {
+            throw new Error('Unable to generate keyring of type HD_KEY_TREE');
+        }
+
         const restoredAccounts = await keyring.getAccounts();
 
         if (restoredAccounts.length !== createdAccounts.length) {

packages/background/src/controllers/OnboardingController.ts

@@ -1,4 +1,4 @@
-import { KeyringControllerState } from 'eth-keyring-controller';
+import { KeyringControllerState } from '@metamask/eth-keyring-controller';
 import { BaseController } from '../infrastructure/BaseController';
 import KeyringControllerDerivated from './KeyringControllerDerivated';
 

packages/background/src/index.ts

@@ -191,11 +191,30 @@ chrome.runtime.onInstalled.addListener(({ reason }) => {
     }
 });
 
+const registerBlankProviderContentScript = async () => {
+    try {
+        await (chrome.scripting as any).registerContentScripts([
+            {
+                id: 'blankProvider',
+                matches: ['file://*/*', 'http://*/*', 'https://*/*'],
+                js: ['blankProvider.js'],
+                runAt: 'document_start',
+                world: 'MAIN',
+            },
+        ]);
+    } catch (err) {
+        console.warn(
+            `Dropped attempt to register blankProvider content script. ${err}`
+        );
+    }
+};
+
 if (isManifestV3()) {
     // this keeps alive the service worker.
     // when it goes 'inactive' it is restarted.
     chrome.alarms.create({ delayInMinutes: 0.5, periodInMinutes: 0.05 });
     chrome.alarms.onAlarm.addListener(() => {
         fetch(chrome.runtime.getURL('keep-alive'));
     });
+    registerBlankProviderContentScript();
 }

packages/background/src/typings/browser-passworder.d.ts

@@ -1,4 +1,4 @@
-declare module 'browser-passworder' {
+declare module '@metamask/browser-passworder' {
     declare function encrypt<T>(password: string, dataObj: T): Promise<string>;
     declare function decrypt<T>(
         password: string,

packages/background/src/typings/eth-keyring-controller.d.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 /* eslint-disable @typescript-eslint/ban-types */
-declare module 'eth-keyring-controller' {
+
+declare module '@metamask/eth-keyring-controller' {
     import { TypedTransaction } from '@ethereumjs/tx';
     import { IObservableStore } from '../infrastructure/stores/ObservableStore';
     import { EventEmitter } from 'events';
@@ -10,6 +11,8 @@ declare module 'eth-keyring-controller' {
         keyringTypes: any;
         keyrings: any[];
         vault: string;
+        encryptionKey: string;
+        encryptionSalt: string;
     }
 
     export interface KeyringControllerMemState {
@@ -18,15 +21,27 @@ declare module 'eth-keyring-controller' {
         keyrings: any[];
     }
 
+    export type Keyring = any;
+
+    export type KeyringBuilder = {
+        (): Keyring;
+        type: KeyringTypes;
+    };
+
+    export type KeyringBuilderFactoryType = (
+        keyring: Keyring
+    ) => KeyringBuilder;
+
+    export const keyringBuilderFactory: KeyringBuilderFactoryType;
+
     export interface KeyringControllerProps {
         initState?: Partial<KeyringControllerState>;
         encryptor?: any;
-        keyringTypes?: any;
+        cacheEncryptionKey?: boolean;
+        keyringBuilders?: KeyringBuilderFactory[];
     }
 
-    export type Keyring = any;
-
-    export default class KeyringController extends EventEmitter {
+    export class KeyringController extends EventEmitter {
         memStore: IObservableStore<KeyringControllerMemState>;
         store: IObservableStore<KeyringControllerState>;
 
@@ -125,6 +140,22 @@ declare module 'eth-keyring-controller' {
          */
         submitPassword(password: string): Promise<KeyringControllerState>;
 
+        /**
+         * Submit Encryption Key.
+         *
+         * Attempts to decrypt the current vault and load its keyrings
+         * into memory based on the vault and CryptoKey information.
+         *
+         * @fires KeyringController#unlock
+         * @param {string} encryptionKey - The encrypted key information used to decrypt the vault.
+         * @param {string} encryptionSalt - The salt used to generate the last key.
+         * @returns {Promise<object>} A Promise that resolves to the state.
+         */
+        submitEncryptionKey(
+            encryptionKey: string,
+            encryptionSalt: string
+        ): Promise<KeyringControllerState>;
+
         /**
          * Verify Password
          *
@@ -205,19 +236,6 @@ declare module 'eth-keyring-controller' {
          */
         removeAccount(address: string | string[]): Promise<void>;
 
-        /**
-         * Get Keyring Class For Type
-         *
-         * Searches the current `keyringTypes` array
-         * for a Keyring class whose unique `type` property
-         * matches the provided `type`,
-         * returning it if it exists.
-         *
-         * @param {string} type - The type whose class to get.
-         * @returns {Keyring|undefined} The class, if it exists.
-         */
-        getKeyringClassForType(type: string): Keyring | undefined;
-
         /**
          * Sign Ethereum Transaction
          *
@@ -386,6 +404,19 @@ declare module 'eth-keyring-controller' {
          */
         restoreKeyring(serialized: any): Promise<any>;
 
+        /**
+         * Get Keyring Class For Type
+         *
+         * Searches the current `keyringBuilders` array
+         * for a Keyring builder whose unique `type` property
+         * matches the provided `type`,
+         * returning it if it exists.
+         *
+         * @param {string} type - The type whose class to get.
+         * @returns {Keyring|undefined} The class, if it exists.
+         */
+        getKeyringBuilderForType(type: string): KeyringBuilder | undefined;
+
         /**
          * Display For Keyring
          *
@@ -402,5 +433,7 @@ declare module 'eth-keyring-controller' {
          * Used before initializing a new vault.
          */
         clearKeyrings(): Promise<void>;
+
+        _newKeyring(type: string, data: any): Promise<Keyring | undefined>;
     }
 }