@metamask-previews/keyring-controller 19.0.5-preview-d21875e1 → 19.0.5-preview-37653b42

package/dist/KeyringController.cjs

@@ -36,9 +36,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _KeyringController_instances, _KeyringController_controllerOperationMutex, _KeyringController_vaultOperationMutex, _KeyringController_keyringBuilders, _KeyringController_unsupportedKeyrings, _KeyringController_encryptor, _KeyringController_cacheEncryptionKey, _KeyringController_keyrings, _KeyringController_password, _KeyringController_qrKeyringStateListener, _KeyringController_registerMessageHandlers, _KeyringController_getKeyringBuilderForType, _KeyringController_addQRKeyring, _KeyringController_subscribeToQRKeyringEvents, _KeyringController_unsubscribeFromQRKeyringsEvents, _KeyringController_createNewVaultWithKeyring, _KeyringController_verifySeedPhrase, _KeyringController_getUpdatedKeyrings, _KeyringController_getSerializedKeyrings, _KeyringController_restoreSerializedKeyrings, _KeyringController_unlockKeyrings, _KeyringController_updateVault, _KeyringController_getAccountsFromKeyrings, _KeyringController_createKeyringWithFirstAccount, _KeyringController_newKeyring, _KeyringController_clearKeyrings, _KeyringController_restoreKeyring, _KeyringController_destroyKeyring, _KeyringController_removeEmptyKeyrings, _KeyringController_checkForDuplicate, _KeyringController_setUnlocked, _KeyringController_persistOrRollback, _KeyringController_withRollback, _KeyringController_assertControllerMutexIsLocked, _KeyringController_withControllerLock, _KeyringController_withVaultLock;
+var _KeyringController_instances, _KeyringController_controllerOperationMutex, _KeyringController_vaultOperationMutex, _KeyringController_keyringBuilders, _KeyringController_keyrings, _KeyringController_unsupportedKeyrings, _KeyringController_password, _KeyringController_encryptor, _KeyringController_cacheEncryptionKey, _KeyringController_qrKeyringStateListener, _KeyringController_registerMessageHandlers, _KeyringController_getKeyringBuilderForType, _KeyringController_addQRKeyring, _KeyringController_subscribeToQRKeyringEvents, _KeyringController_unsubscribeFromQRKeyringsEvents, _KeyringController_createNewVaultWithKeyring, _KeyringController_verifySeedPhrase, _KeyringController_getUpdatedKeyrings, _KeyringController_getSerializedKeyrings, _KeyringController_restoreSerializedKeyrings, _KeyringController_unlockKeyrings, _KeyringController_updateVault, _KeyringController_getAccountsFromKeyrings, _KeyringController_createKeyringWithFirstAccount, _KeyringController_newKeyring, _KeyringController_clearKeyrings, _KeyringController_restoreKeyring, _KeyringController_destroyKeyring, _KeyringController_removeEmptyKeyrings, _KeyringController_checkForDuplicate, _KeyringController_setUnlocked, _KeyringController_persistOrRollback, _KeyringController_withRollback, _KeyringController_assertControllerMutexIsLocked, _KeyringController_withControllerLock, _KeyringController_withVaultLock;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyringController = exports.getDefaultKeyringState = exports.keyringBuilderFactory = exports.SignTypedDataVersion = exports.AccountImportStrategy = exports.isCustodyKeyring = exports.KeyringTypes = void 0;
+exports.KeyringController = exports.getKeyringByFingerprint = exports.displayForKeyring = exports.getDefaultKeyringState = exports.keyringBuilderFactory = exports.SignTypedDataVersion = exports.AccountImportStrategy = exports.isCustodyKeyring = exports.KeyringTypes = void 0;
 const util_1 = require("@ethereumjs/util");
 const base_controller_1 = require("@metamask/base-controller");
 const encryptorUtils = __importStar(require("@metamask/browser-passworder"));
@@ -55,18 +55,31 @@ const name = 'KeyringController';
  */
 var KeyringTypes;
 (function (KeyringTypes) {
+    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     KeyringTypes["simple"] = "Simple Key Pair";
+    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     KeyringTypes["hd"] = "HD Key Tree";
+    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     KeyringTypes["qr"] = "QR Hardware Wallet Device";
+    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     KeyringTypes["trezor"] = "Trezor Hardware";
+    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     KeyringTypes["ledger"] = "Ledger Hardware";
+    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     KeyringTypes["lattice"] = "Lattice Hardware";
+    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     KeyringTypes["snap"] = "Snap Keyring";
 })(KeyringTypes || (exports.KeyringTypes = KeyringTypes = {}));
 /**
  * Custody keyring types are a special case, as they are not a single type
  * but they all start with the prefix "Custody".
- *
  * @param keyringType - The type of the keyring.
  * @returns Whether the keyring type is a custody keyring.
  */
@@ -79,7 +92,11 @@ exports.isCustodyKeyring = isCustodyKeyring;
  */
 var AccountImportStrategy;
 (function (AccountImportStrategy) {
+    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     AccountImportStrategy["privateKey"] = "privateKey";
+    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     AccountImportStrategy["json"] = "json";
 })(AccountImportStrategy || (exports.AccountImportStrategy = AccountImportStrategy = {}));
 /**
@@ -187,8 +204,30 @@ async function displayForKeyring(keyring) {
         // Cast to `string[]` here is safe here because `accounts` has no nullish
         // values, and `normalize` returns `string` unless given a nullish value
         accounts: accounts.map(normalize),
+        // @ts-expect-error TODO: update type in @metamask/utils
+        fingerprint: await keyring?.getFingerprint?.(),
     };
 }
+exports.displayForKeyring = displayForKeyring;
+/**
+ * Retrieves a keyring from an array of keyrings based on its fingerprint.
+ *
+ * @param keyrings - Array of keyrings to search through.
+ * @param fingerprint - The fingerprint to match against.
+ * @returns Promise resolving to the matching keyring, or undefined if not found.
+ */
+async function getKeyringByFingerprint(keyrings, fingerprint) {
+    // Do not attempt to return a keyring if the fingerprint is not provided
+    if (!fingerprint) {
+        return undefined;
+    }
+    const fingerprints = await Promise.all(
+    // @ts-expect-error TODO: update type in @metamask/utils
+    keyrings.map((kr) => kr?.getFingerprint?.()));
+    const index = fingerprints.indexOf(fingerprint);
+    return keyrings[index];
+}
+exports.getKeyringByFingerprint = getKeyringByFingerprint;
 /**
  * Check if address is an ethereum address
  *
@@ -259,11 +298,11 @@ class KeyringController extends base_controller_1.BaseController {
         _KeyringController_controllerOperationMutex.set(this, new async_mutex_1.Mutex());
         _KeyringController_vaultOperationMutex.set(this, new async_mutex_1.Mutex());
         _KeyringController_keyringBuilders.set(this, void 0);
+        _KeyringController_keyrings.set(this, void 0);
         _KeyringController_unsupportedKeyrings.set(this, void 0);
+        _KeyringController_password.set(this, void 0);
         _KeyringController_encryptor.set(this, void 0);
         _KeyringController_cacheEncryptionKey.set(this, void 0);
-        _KeyringController_keyrings.set(this, void 0);
-        _KeyringController_password.set(this, void 0);
         _KeyringController_qrKeyringStateListener.set(this, void 0);
         __classPrivateFieldSet(this, _KeyringController_keyringBuilders, keyringBuilders
             ? keyringBuilders.concat(defaultKeyringBuilders)
@@ -365,7 +404,6 @@ class KeyringController extends base_controller_1.BaseController {
      * If there is a pre-existing locked vault, it will be replaced.
      *
      * @param password - Password to unlock the new vault.
-     * @returns Promise resolving when the operation ends successfully.
      */
     async createNewVaultAndKeychain(password) {
         return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
@@ -415,12 +453,27 @@ class KeyringController extends base_controller_1.BaseController {
      * Gets the seed phrase of the HD keyring.
      *
      * @param password - Password of the keyring.
+     * @param keyringId - The keyring identifier.
      * @returns Promise resolving to the seed phrase.
      */
-    async exportSeedPhrase(password) {
+    async exportSeedPhrase(password, keyringId) {
         await this.verifyPassword(password);
-        assertHasUint8ArrayMnemonic(__classPrivateFieldGet(this, _KeyringController_keyrings, "f")[0]);
-        return __classPrivateFieldGet(this, _KeyringController_keyrings, "f")[0].mnemonic;
+        let keyring;
+        if (keyringId) {
+            keyring = await getKeyringByFingerprint(__classPrivateFieldGet(this, _KeyringController_keyrings, "f"), keyringId);
+            if (!keyring) {
+                throw new Error(constants_1.KeyringControllerError.KeyringNotFound);
+            }
+            if (keyring.type !== KeyringTypes.hd) {
+                throw new Error(constants_1.KeyringControllerError.UnsupportedExportSeedPhrase);
+            }
+        }
+        else {
+            // There will always be an HD keyring
+            keyring = this.getKeyringsByType(KeyringTypes.hd)[0];
+        }
+        assertHasUint8ArrayMnemonic(keyring);
+        return keyring.mnemonic;
     }
     /**
      * Gets the private key from the keyring controlling an address.
@@ -546,7 +599,7 @@ class KeyringController extends base_controller_1.BaseController {
         return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
             let privateKey;
             switch (strategy) {
-                case AccountImportStrategy.privateKey:
+                case 'privateKey':
                     const [importedKey] = args;
                     if (!importedKey) {
                         throw new Error('Cannot import an empty key.');
@@ -566,7 +619,7 @@ class KeyringController extends base_controller_1.BaseController {
                     }
                     privateKey = (0, utils_1.remove0x)(prefixed);
                     break;
-                case AccountImportStrategy.json:
+                case 'json':
                     let wallet;
                     const [input, password] = args;
                     try {
@@ -578,7 +631,7 @@ class KeyringController extends base_controller_1.BaseController {
                     privateKey = (0, utils_1.bytesToHex)(wallet.getPrivateKey());
                     break;
                 default:
-                    throw new Error(`Unexpected import strategy: '${String(strategy)}'`);
+                    throw new Error(`Unexpected import strategy: '${strategy}'`);
             }
             const newKeyring = (await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_newKeyring).call(this, KeyringTypes.simple, [
                 privateKey,
@@ -603,6 +656,7 @@ class KeyringController extends base_controller_1.BaseController {
             }
             // The `removeAccount` method of snaps keyring is async. We have to update
             // the interface of the other keyrings to be async as well.
+            // eslint-disable-next-line @typescript-eslint/await-thenable
             // FIXME: We do cast to `Hex` to makes the type checker happy here, and
             // because `Keyring<State>.removeAccount` requires address to be `Hex`. Those
             // type would need to be updated for a full non-EVM support.
@@ -833,6 +887,9 @@ class KeyringController extends base_controller_1.BaseController {
             if ('address' in selector) {
                 keyring = (await this.getKeyringForAccount(selector.address));
             }
+            else if ('fingerprint' in selector) {
+                keyring = (await getKeyringByFingerprint(__classPrivateFieldGet(this, _KeyringController_keyrings, "f"), selector.fingerprint));
+            }
             else {
                 keyring = this.getKeyringsByType(selector.type)[selector.index || 0];
                 if (!keyring && options.createIfMissing) {
@@ -1038,7 +1095,7 @@ class KeyringController extends base_controller_1.BaseController {
     }
 }
 exports.KeyringController = KeyringController;
-_KeyringController_controllerOperationMutex = new WeakMap(), _KeyringController_vaultOperationMutex = new WeakMap(), _KeyringController_keyringBuilders = new WeakMap(), _KeyringController_unsupportedKeyrings = new WeakMap(), _KeyringController_encryptor = new WeakMap(), _KeyringController_cacheEncryptionKey = new WeakMap(), _KeyringController_keyrings = new WeakMap(), _KeyringController_password = new WeakMap(), _KeyringController_qrKeyringStateListener = new WeakMap(), _KeyringController_instances = new WeakSet(), _KeyringController_registerMessageHandlers = function _KeyringController_registerMessageHandlers() {
+_KeyringController_controllerOperationMutex = new WeakMap(), _KeyringController_vaultOperationMutex = new WeakMap(), _KeyringController_keyringBuilders = new WeakMap(), _KeyringController_keyrings = new WeakMap(), _KeyringController_unsupportedKeyrings = new WeakMap(), _KeyringController_password = new WeakMap(), _KeyringController_encryptor = new WeakMap(), _KeyringController_cacheEncryptionKey = new WeakMap(), _KeyringController_qrKeyringStateListener = new WeakMap(), _KeyringController_instances = new WeakSet(), _KeyringController_registerMessageHandlers = function _KeyringController_registerMessageHandlers() {
     this.messagingSystem.registerActionHandler(`${name}:signMessage`, this.signMessage.bind(this));
     this.messagingSystem.registerActionHandler(`${name}:signPersonalMessage`, this.signPersonalMessage.bind(this));
     this.messagingSystem.registerActionHandler(`${name}:signTypedMessage`, this.signTypedMessage.bind(this));
@@ -1373,6 +1430,9 @@ async function _KeyringController_newKeyring(type, data) {
         // NOTE: Not all keyrings implement this method in a asynchronous-way. Using `await` for
         // non-thenable will still be valid (despite not being really useful). It allows us to cover both
         // cases and allow retro-compatibility too.
+        // FIXME: For some reason, it seems that eslint is complaining about this call being non-thenable
+        // even though it is... For now, we just disable it:
+        // eslint-disable-next-line @typescript-eslint/await-thenable
         await keyring.generateRandomMnemonic();
         await keyring.addAccounts(1);
     }
@@ -1487,12 +1547,14 @@ async function _KeyringController_checkForDuplicate(type, newAccountArray) {
  * and save the keyrings to state after it, or rollback to their
  * previous state in case of error.
  *
- * @param callback - The function to execute.
+ * @param fn - The function to execute.
  * @returns The result of the function.
  */
-async function _KeyringController_persistOrRollback(callback) {
+// TODO: Either fix this lint violation or explain why it's necessary to ignore.
+// eslint-disable-next-line @typescript-eslint/naming-convention
+async function _KeyringController_persistOrRollback(fn) {
     return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withRollback).call(this, async ({ releaseLock }) => {
-        const callbackResult = await callback({ releaseLock });
+        const callbackResult = await fn({ releaseLock });
         // State is committed only if the operation is successful
         await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_updateVault).call(this);
         return callbackResult;
@@ -1502,15 +1564,17 @@ async function _KeyringController_persistOrRollback(callback) {
  * Execute the given function after acquiring the controller lock
  * and rollback keyrings and password states in case of error.
  *
- * @param callback - The function to execute atomically.
+ * @param fn - The function to execute atomically.
  * @returns The result of the function.
  */
-async function _KeyringController_withRollback(callback) {
+// TODO: Either fix this lint violation or explain why it's necessary to ignore.
+// eslint-disable-next-line @typescript-eslint/naming-convention
+async function _KeyringController_withRollback(fn) {
     return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withControllerLock).call(this, async ({ releaseLock }) => {
         const currentSerializedKeyrings = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getSerializedKeyrings).call(this);
         const currentPassword = __classPrivateFieldGet(this, _KeyringController_password, "f");
         try {
-            return await callback({ releaseLock });
+            return await fn({ releaseLock });
         }
         catch (e) {
             // Keyrings and password are restored to their previous state
@@ -1533,11 +1597,13 @@ async function _KeyringController_withRollback(callback) {
  * controller and that changes its state is executed in a mutually exclusive way,
  * preventing unsafe concurrent access that could lead to unpredictable behavior.
  *
- * @param callback - The function to execute while the controller mutex is locked.
+ * @param fn - The function to execute while the controller mutex is locked.
  * @returns The result of the function.
  */
-async function _KeyringController_withControllerLock(callback) {
-    return withLock(__classPrivateFieldGet(this, _KeyringController_controllerOperationMutex, "f"), callback);
+// TODO: Either fix this lint violation or explain why it's necessary to ignore.
+// eslint-disable-next-line @typescript-eslint/naming-convention
+async function _KeyringController_withControllerLock(fn) {
+    return withLock(__classPrivateFieldGet(this, _KeyringController_controllerOperationMutex, "f"), fn);
 }, _KeyringController_withVaultLock = 
 /**
  * Lock the vault mutex before executing the given function,
@@ -1547,12 +1613,14 @@ async function _KeyringController_withControllerLock(callback) {
  * This ensures that each operation that interacts with the vault
  * is executed in a mutually exclusive way.
  *
- * @param callback - The function to execute while the vault mutex is locked.
+ * @param fn - The function to execute while the vault mutex is locked.
  * @returns The result of the function.
  */
-async function _KeyringController_withVaultLock(callback) {
+// TODO: Either fix this lint violation or explain why it's necessary to ignore.
+// eslint-disable-next-line @typescript-eslint/naming-convention
+async function _KeyringController_withVaultLock(fn) {
     __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
-    return withLock(__classPrivateFieldGet(this, _KeyringController_vaultOperationMutex, "f"), callback);
+    return withLock(__classPrivateFieldGet(this, _KeyringController_vaultOperationMutex, "f"), fn);
 };
 /**
  * Lock the given mutex before executing the given function,
@@ -1560,13 +1628,15 @@ async function _KeyringController_withVaultLock(callback) {
  * error is thrown.
  *
  * @param mutex - The mutex to lock.
- * @param callback - The function to execute while the mutex is locked.
+ * @param fn - The function to execute while the mutex is locked.
  * @returns The result of the function.
  */
-async function withLock(mutex, callback) {
+// TODO: Either fix this lint violation or explain why it's necessary to ignore.
+// eslint-disable-next-line @typescript-eslint/naming-convention
+async function withLock(mutex, fn) {
     const releaseLock = await mutex.acquire();
     try {
-        return await callback({ releaseLock });
+        return await fn({ releaseLock });
     }
     finally {
         releaseLock();