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

package/dist/KeyringController.mjs

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-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;
 function $importDefault(module) {
     if (module?.__esModule) {
         return module.default;
@@ -19,8 +19,7 @@ function $importDefault(module) {
 import { isValidPrivate, toBuffer, getBinarySize } from "@ethereumjs/util";
 import { BaseController } from "@metamask/base-controller";
 import * as encryptorUtils from "@metamask/browser-passworder";
-import $HDKeyring from "@metamask/eth-hd-keyring";
-const HDKeyring = $importDefault($HDKeyring);
+import HDKeyring from "@metamask/eth-hd-keyring";
 import { normalize as ethNormalize } from "@metamask/eth-sig-util";
 import $SimpleKeyring from "@metamask/eth-simple-keyring";
 const SimpleKeyring = $importDefault($SimpleKeyring);
@@ -36,18 +35,31 @@ const name = 'KeyringController';
  */
 export 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 || (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.
  */
@@ -59,7 +71,11 @@ export const isCustodyKeyring = (keyringType) => {
  */
 export 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 || (AccountImportStrategy = {}));
 /**
@@ -158,15 +174,35 @@ function isSerializedKeyringsArray(array) {
  * @param keyring - The keyring to display.
  * @returns A keyring display object, with type and accounts properties.
  */
-async function displayForKeyring(keyring) {
+export async function displayForKeyring(keyring) {
     const accounts = await keyring.getAccounts();
     return {
         type: keyring.type,
         // 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?.(),
     };
 }
+/**
+ * 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.
+ */
+export 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];
+}
 /**
  * Check if address is an ethereum address
  *
@@ -237,11 +273,11 @@ export class KeyringController extends BaseController {
         _KeyringController_controllerOperationMutex.set(this, new Mutex());
         _KeyringController_vaultOperationMutex.set(this, new 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)
@@ -343,7 +379,6 @@ export class KeyringController extends 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 () => {
@@ -393,12 +428,27 @@ export class KeyringController extends 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(KeyringControllerError.KeyringNotFound);
+            }
+            if (keyring.type !== KeyringTypes.hd) {
+                throw new Error(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.
@@ -524,7 +574,7 @@ export class KeyringController extends 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.');
@@ -544,7 +594,7 @@ export class KeyringController extends BaseController {
                     }
                     privateKey = remove0x(prefixed);
                     break;
-                case AccountImportStrategy.json:
+                case 'json':
                     let wallet;
                     const [input, password] = args;
                     try {
@@ -556,7 +606,7 @@ export class KeyringController extends BaseController {
                     privateKey = 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,
@@ -581,6 +631,7 @@ export class KeyringController extends 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.
@@ -811,6 +862,9 @@ export class KeyringController extends 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) {
@@ -1015,7 +1069,7 @@ export class KeyringController extends BaseController {
         });
     }
 }
-_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));
@@ -1350,6 +1404,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);
     }
@@ -1464,12 +1521,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;
@@ -1479,15 +1538,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
@@ -1510,11 +1571,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,
@@ -1524,12 +1587,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,
@@ -1537,13 +1602,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();