@metamask-previews/accounts-controller 31.0.0-preview-a5e5a801 → 31.0.0-preview-1d5c2cf9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -9,7 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
9
9
 
10
10
  ### Added
11
11
 
12
- - Add `groupIndex` to EVM HD account options ([#6122](https://github.com/MetaMask/core/pull/6122))
12
+ - Use new typed `KeyringAccount.options` for BIP-44 compatible accounts ([#6122](https://github.com/MetaMask/core/pull/6122)), ([#6147](https://github.com/MetaMask/core/pull/6147))
13
13
 
14
14
  ### Changed
15
15
 
@@ -4,7 +4,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
4
4
  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");
5
5
  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
6
6
  };
7
- var _AccountsController_instances, _AccountsController_assertAccountCanBeRenamed, _AccountsController_generateInternalAccountForNonSnapAccount, _AccountsController_getSnapKeyring, _AccountsController_listSnapAccounts, _AccountsController_listNormalAccounts, _AccountsController_handleOnSnapKeyringAccountEvent, _AccountsController_handleOnKeyringStateChange, _AccountsController_update, _AccountsController_handleOnSnapStateChange, _AccountsController_getAccountsByKeyringType, _AccountsController_getLastSelectedAccount, _AccountsController_getLastSelectedIndex, _AccountsController_getInternalAccountFromAddressAndType, _AccountsController_handleOnMultichainNetworkDidChange, _AccountsController_populateExistingMetadata, _AccountsController_subscribeToMessageEvents, _AccountsController_registerMessageHandlers;
7
+ var _AccountsController_instances, _AccountsController_assertAccountCanBeRenamed, _AccountsController_getInternalAccountForNonSnapAccount, _AccountsController_getSnapKeyring, _AccountsController_handleOnSnapKeyringAccountEvent, _AccountsController_handleOnKeyringStateChange, _AccountsController_update, _AccountsController_handleOnSnapStateChange, _AccountsController_getAccountsByKeyringType, _AccountsController_getLastSelectedAccount, _AccountsController_getLastSelectedIndex, _AccountsController_getInternalAccountFromAddressAndType, _AccountsController_handleOnMultichainNetworkDidChange, _AccountsController_subscribeToMessageEvents, _AccountsController_registerMessageHandlers;
8
8
  Object.defineProperty(exports, "__esModule", { value: true });
9
9
  exports.AccountsController = exports.EMPTY_ACCOUNT = void 0;
10
10
  const base_controller_1 = require("@metamask/base-controller");
@@ -13,6 +13,7 @@ const keyring_api_1 = require("@metamask/keyring-api");
13
13
  const keyring_controller_1 = require("@metamask/keyring-controller");
14
14
  const keyring_utils_1 = require("@metamask/keyring-utils");
15
15
  const utils_1 = require("@metamask/utils");
16
+ const lodash_1 = require("lodash");
16
17
  const utils_2 = require("./utils.cjs");
17
18
  const controllerName = 'AccountsController';
18
19
  const accountsControllerMetadata = {
@@ -269,38 +270,44 @@ class AccountsController extends base_controller_1.BaseController {
269
270
  * @returns A Promise that resolves when the accounts have been updated.
270
271
  */
271
272
  async updateAccounts() {
272
- const snapAccounts = await __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_listSnapAccounts).call(this);
273
- const normalAccounts = await __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_listNormalAccounts).call(this);
274
- // keyring type map.
275
- const keyringTypes = new Map();
276
- const previousAccounts = this.state.internalAccounts.accounts;
277
- const accounts = [
278
- ...normalAccounts,
279
- ...snapAccounts,
280
- ].reduce((internalAccountMap, internalAccount) => {
281
- const keyringTypeName = (0, utils_2.keyringTypeToName)(internalAccount.metadata.keyring.type);
282
- const keyringAccountIndex = keyringTypes.get(keyringTypeName) ?? 0;
283
- if (keyringAccountIndex) {
284
- keyringTypes.set(keyringTypeName, keyringAccountIndex + 1);
285
- }
286
- else {
287
- keyringTypes.set(keyringTypeName, 1);
273
+ const keyringAccountIndexes = new Map();
274
+ const existingInternalAccounts = this.state.internalAccounts.accounts;
275
+ const internalAccounts = {};
276
+ const { keyrings } = this.messagingSystem.call('KeyringController:getState');
277
+ for (const keyring of keyrings) {
278
+ const keyringTypeName = (0, utils_2.keyringTypeToName)(keyring.type);
279
+ for (const address of keyring.accounts) {
280
+ const internalAccount = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountFromAddressAndType).call(this, address, keyring);
281
+ // This should never really happen, but if for some reason we're not
282
+ // able to get the Snap keyring reference, this would return an
283
+ // undefined account.
284
+ // So we just skip it, even though, this should not really happen.
285
+ if (!internalAccount) {
286
+ continue;
287
+ }
288
+ const keyringAccountIndex = keyringAccountIndexes.get(keyringTypeName) ?? 0;
289
+ if (keyringAccountIndex) {
290
+ keyringAccountIndexes.set(keyringTypeName, keyringAccountIndex + 1);
291
+ }
292
+ else {
293
+ keyringAccountIndexes.set(keyringTypeName, 1);
294
+ }
295
+ const existingAccount = existingInternalAccounts[internalAccount.id];
296
+ internalAccounts[internalAccount.id] = {
297
+ ...internalAccount,
298
+ metadata: {
299
+ ...internalAccount.metadata,
300
+ // Re-use existing metadata if any.
301
+ name: existingAccount?.metadata.name ??
302
+ `${keyringTypeName} ${keyringAccountIndex + 1}`,
303
+ importTime: existingAccount?.metadata.importTime ?? Date.now(),
304
+ lastSelected: existingAccount?.metadata.lastSelected ?? 0,
305
+ },
306
+ };
288
307
  }
289
- const existingAccount = previousAccounts[internalAccount.id];
290
- internalAccountMap[internalAccount.id] = {
291
- ...internalAccount,
292
- metadata: {
293
- ...internalAccount.metadata,
294
- name: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, existingAccount?.id, 'name') ??
295
- `${keyringTypeName} ${keyringAccountIndex + 1}`,
296
- importTime: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, existingAccount?.id, 'importTime') ?? Date.now(),
297
- lastSelected: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, existingAccount?.id, 'lastSelected') ?? 0,
298
- },
299
- };
300
- return internalAccountMap;
301
- }, {});
308
+ }
302
309
  __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
303
- state.internalAccounts.accounts = accounts;
310
+ state.internalAccounts.accounts = internalAccounts;
304
311
  });
305
312
  }
306
313
  /**
@@ -349,11 +356,63 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
349
356
  internalAccount.id !== account.id)) {
350
357
  throw new Error('Account name already exists');
351
358
  }
352
- }, _AccountsController_generateInternalAccountForNonSnapAccount = function _AccountsController_generateInternalAccountForNonSnapAccount(address, type) {
359
+ }, _AccountsController_getInternalAccountForNonSnapAccount = function _AccountsController_getInternalAccountForNonSnapAccount(address, keyring) {
360
+ const id = (0, utils_2.getUUIDFromAddressOfNormalAccount)(address);
361
+ // We might have an account for this ID already, so we'll just re-use
362
+ // the same metadata
363
+ const account = this.getAccount(id);
364
+ const metadata = {
365
+ name: account?.metadata.name ?? '',
366
+ ...(account?.metadata.nameLastUpdatedAt
367
+ ? {
368
+ nameLastUpdatedAt: account?.metadata.nameLastUpdatedAt,
369
+ }
370
+ : {}),
371
+ importTime: account?.metadata.importTime ?? Date.now(),
372
+ lastSelected: account?.metadata.lastSelected ?? 0,
373
+ keyring: {
374
+ type: keyring.type,
375
+ },
376
+ };
377
+ let options = {};
378
+ if ((0, utils_2.isHdKeyringType)(keyring.type)) {
379
+ // We need to find the account index from its HD keyring.
380
+ const groupIndex = (0, utils_2.getEvmGroupIndexFromAddressIndex)(keyring, address);
381
+ // If for some reason, we cannot find this address, then the caller made a mistake
382
+ // and it did not use the proper keyring object. For now, we do not fail and just
383
+ // consider this account as "simple account".
384
+ if (groupIndex !== undefined) {
385
+ // NOTE: We are not using the `hdPath` from the associated keyring here and
386
+ // getting the keyring instance here feels a bit overkill.
387
+ // This will be naturally fixed once every keyring start using `KeyringAccount` and implement the keyring API.
388
+ const derivationPath = (0, utils_2.getEvmDerivationPathForIndex)(groupIndex);
389
+ // Those are "legacy options" and they were used before `KeyringAccount` added
390
+ // support for type options. We keep those temporarily until we update everything
391
+ // to use the new typed options.
392
+ const legacyOptions = {
393
+ entropySource: keyring.metadata.id,
394
+ derivationPath,
395
+ groupIndex,
396
+ };
397
+ // New typed entropy options. This is required for multichain accounts.
398
+ const entropyOptions = {
399
+ entropy: {
400
+ type: keyring_api_1.KeyringAccountEntropyTypeOption.Mnemonic,
401
+ id: keyring.metadata.id,
402
+ derivationPath,
403
+ groupIndex,
404
+ },
405
+ };
406
+ options = {
407
+ ...legacyOptions,
408
+ ...entropyOptions,
409
+ };
410
+ }
411
+ }
353
412
  return {
354
- id: (0, utils_2.getUUIDFromAddressOfNormalAccount)(address),
413
+ id,
355
414
  address,
356
- options: {},
415
+ options,
357
416
  methods: [
358
417
  keyring_api_1.EthMethod.PersonalSign,
359
418
  keyring_api_1.EthMethod.Sign,
@@ -364,90 +423,13 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
364
423
  ],
365
424
  scopes: [keyring_api_1.EthScope.Eoa],
366
425
  type: keyring_api_1.EthAccountType.Eoa,
367
- metadata: {
368
- name: '',
369
- importTime: Date.now(),
370
- keyring: {
371
- type,
372
- },
373
- },
426
+ metadata,
374
427
  };
375
428
  }, _AccountsController_getSnapKeyring = function _AccountsController_getSnapKeyring() {
376
429
  const [snapKeyring] = this.messagingSystem.call('KeyringController:getKeyringsByType', eth_snap_keyring_1.SnapKeyring.type);
377
430
  // Snap keyring is not available until the first account is created in the keyring
378
431
  // controller, so this might be undefined.
379
432
  return snapKeyring;
380
- }, _AccountsController_listSnapAccounts =
381
- /**
382
- * Returns a list of internal accounts created using the SnapKeyring.
383
- *
384
- * @returns A promise that resolves to an array of InternalAccount objects.
385
- */
386
- async function _AccountsController_listSnapAccounts() {
387
- const keyring = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getSnapKeyring).call(this);
388
- if (!keyring) {
389
- return [];
390
- }
391
- return keyring.listAccounts();
392
- }, _AccountsController_listNormalAccounts =
393
- /**
394
- * Returns a list of normal accounts.
395
- * Note: listNormalAccounts is a temporary method until the keyrings all implement the InternalAccount interface.
396
- * Once all keyrings implement the InternalAccount interface, this method can be removed and getAccounts can be used instead.
397
- *
398
- * @returns A Promise that resolves to an array of InternalAccount objects.
399
- */
400
- async function _AccountsController_listNormalAccounts() {
401
- const internalAccounts = [];
402
- const { keyrings } = this.messagingSystem.call('KeyringController:getState');
403
- for (const keyring of keyrings) {
404
- const keyringType = keyring.type;
405
- if (!(0, utils_2.isNormalKeyringType)(keyringType)) {
406
- // We only consider "normal accounts" here, so keep looping
407
- continue;
408
- }
409
- for (const [accountIndex, address] of keyring.accounts.entries()) {
410
- const id = (0, utils_2.getUUIDFromAddressOfNormalAccount)(address);
411
- let options = {};
412
- if ((0, utils_2.isHdKeyringType)(keyring.type)) {
413
- options = {
414
- entropySource: keyring.metadata.id,
415
- // NOTE: We are not using the `hdPath` from the associated keyring here and
416
- // getting the keyring instance here feels a bit overkill.
417
- // This will be naturally fixed once every keyring start using `KeyringAccount` and implement the keyring API.
418
- derivationPath: (0, utils_2.getDerivationPathForIndex)(accountIndex),
419
- // Required now for multichain accounts.
420
- groupIndex: accountIndex,
421
- };
422
- }
423
- const nameLastUpdatedAt = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, id, 'nameLastUpdatedAt');
424
- internalAccounts.push({
425
- id,
426
- address,
427
- options,
428
- methods: [
429
- keyring_api_1.EthMethod.PersonalSign,
430
- keyring_api_1.EthMethod.Sign,
431
- keyring_api_1.EthMethod.SignTransaction,
432
- keyring_api_1.EthMethod.SignTypedDataV1,
433
- keyring_api_1.EthMethod.SignTypedDataV3,
434
- keyring_api_1.EthMethod.SignTypedDataV4,
435
- ],
436
- scopes: [keyring_api_1.EthScope.Eoa],
437
- type: keyring_api_1.EthAccountType.Eoa,
438
- metadata: {
439
- name: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, id, 'name') ?? '',
440
- ...(nameLastUpdatedAt && { nameLastUpdatedAt }),
441
- importTime: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, id, 'importTime') ?? Date.now(),
442
- lastSelected: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, id, 'lastSelected') ?? 0,
443
- keyring: {
444
- type: keyringType,
445
- },
446
- },
447
- });
448
- }
449
- }
450
- return internalAccounts;
451
433
  }, _AccountsController_handleOnSnapKeyringAccountEvent = function _AccountsController_handleOnSnapKeyringAccountEvent(event, ...payload) {
452
434
  this.messagingSystem.publish(event, ...payload);
453
435
  }, _AccountsController_handleOnKeyringStateChange = function _AccountsController_handleOnKeyringStateChange({ isUnlocked, keyrings, }) {
@@ -474,7 +456,7 @@ async function _AccountsController_listNormalAccounts() {
474
456
  // Gets the patch object based on the keyring type (since Snap accounts and other accounts
475
457
  // are handled differently).
476
458
  const patchOf = (type) => {
477
- if (type === keyring_controller_1.KeyringTypes.snap) {
459
+ if ((0, utils_2.isSnapKeyringType)(type)) {
478
460
  return patches.snap;
479
461
  }
480
462
  return patches.normal;
@@ -501,11 +483,7 @@ async function _AccountsController_listNormalAccounts() {
501
483
  // Otherwise, that's a new account.
502
484
  patch.added.push({
503
485
  address,
504
- type: keyring.type,
505
- // Automatically injects `entropySource` for HD accounts only.
506
- options: keyring.type === keyring_controller_1.KeyringTypes.hd
507
- ? { entropySource: keyring.metadata.id }
508
- : {},
486
+ keyring,
509
487
  });
510
488
  }
511
489
  // Keep track of those address to check for removed accounts later.
@@ -535,7 +513,7 @@ async function _AccountsController_listNormalAccounts() {
535
513
  diff.removed.push(account.id);
536
514
  }
537
515
  for (const added of patch.added) {
538
- const account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountFromAddressAndType).call(this, added.address, added.type);
516
+ const account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountFromAddressAndType).call(this, added.address, added.keyring);
539
517
  if (account) {
540
518
  // Re-compute the list of accounts everytime, so we can make sure new names
541
519
  // are also considered.
@@ -552,10 +530,6 @@ async function _AccountsController_listNormalAccounts() {
552
530
  importTime: Date.now(),
553
531
  lastSelected,
554
532
  },
555
- options: {
556
- ...account.options,
557
- ...added.options,
558
- },
559
533
  };
560
534
  diff.added.push(internalAccounts.accounts[account.id]);
561
535
  }
@@ -640,10 +614,9 @@ async function _AccountsController_listNormalAccounts() {
640
614
  return (accounts ?? this.listMultichainAccounts()).filter((internalAccount) => {
641
615
  // We do consider `hd` and `simple` keyrings to be of same type. So we check those 2 types
642
616
  // to group those accounts together!
643
- if (keyringType === keyring_controller_1.KeyringTypes.hd ||
644
- keyringType === keyring_controller_1.KeyringTypes.simple) {
645
- return (internalAccount.metadata.keyring.type === keyring_controller_1.KeyringTypes.hd ||
646
- internalAccount.metadata.keyring.type === keyring_controller_1.KeyringTypes.simple);
617
+ if ((0, utils_2.isHdKeyringType)(keyringType) || (0, utils_2.isSimpleKeyringType)(keyringType)) {
618
+ return ((0, utils_2.isHdKeyringType)(internalAccount.metadata.keyring.type) ||
619
+ (0, utils_2.isSimpleKeyringType)(internalAccount.metadata.keyring.type));
647
620
  }
648
621
  return internalAccount.metadata.keyring.type === keyringType;
649
622
  });
@@ -658,18 +631,40 @@ async function _AccountsController_listNormalAccounts() {
658
631
  // NOTE: For now we use the current date, since we know this value
659
632
  // will always be higher than any already selected account index.
660
633
  return Date.now();
661
- }, _AccountsController_getInternalAccountFromAddressAndType = function _AccountsController_getInternalAccountFromAddressAndType(address, type) {
662
- if (type === keyring_controller_1.KeyringTypes.snap) {
663
- const keyring = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getSnapKeyring).call(this);
634
+ }, _AccountsController_getInternalAccountFromAddressAndType = function _AccountsController_getInternalAccountFromAddressAndType(address, keyring) {
635
+ if ((0, utils_2.isSnapKeyringType)(keyring.type)) {
636
+ const snapKeyring = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getSnapKeyring).call(this);
664
637
  // We need the Snap keyring to retrieve the account from its address.
665
- if (!keyring) {
638
+ if (!snapKeyring) {
666
639
  return undefined;
667
640
  }
668
641
  // This might be undefined if the Snap deleted the account before
669
642
  // reaching that point.
670
- return keyring.getAccountByAddress(address);
643
+ let account = snapKeyring.getAccountByAddress(address);
644
+ if (account) {
645
+ // We force the copy here, to avoid mutating the reference returned by the Snap keyring.
646
+ account = (0, lodash_1.cloneDeep)(account);
647
+ // MIGRATION: To avoid any existing Snap account migration, we are
648
+ // just "adding" the new typed options that we need for multichain
649
+ // accounts. Ultimately, we would need a real Snap account migrations
650
+ // (being handled by each Snaps).
651
+ if ((0, utils_2.isHdSnapKeyringAccount)(account)) {
652
+ const options = {
653
+ ...account.options,
654
+ entropy: {
655
+ type: keyring_api_1.KeyringAccountEntropyTypeOption.Mnemonic,
656
+ id: account.options.entropySource,
657
+ groupIndex: account.options.index,
658
+ derivationPath: account.options.derivationPath,
659
+ },
660
+ };
661
+ // Inject the new typed options to the internal account copy.
662
+ account.options = options;
663
+ }
664
+ }
665
+ return account;
671
666
  }
672
- return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_generateInternalAccountForNonSnapAccount).call(this, address, type);
667
+ return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountForNonSnapAccount).call(this, address, keyring);
673
668
  }, _AccountsController_handleOnMultichainNetworkDidChange = function _AccountsController_handleOnMultichainNetworkDidChange(id) {
674
669
  let accountId;
675
670
  // We only support non-EVM Caip chain IDs at the moment. Ex Solana and Bitcoin
@@ -691,9 +686,6 @@ async function _AccountsController_listNormalAccounts() {
691
686
  currentState.internalAccounts.selectedAccount = accountId;
692
687
  });
693
688
  // DO NOT publish AccountsController:setSelectedAccount to prevent circular listener loops
694
- }, _AccountsController_populateExistingMetadata = function _AccountsController_populateExistingMetadata(accountId, metadataKey, account) {
695
- const internalAccount = account ?? this.getAccount(accountId);
696
- return internalAccount ? internalAccount.metadata[metadataKey] : undefined;
697
689
  }, _AccountsController_subscribeToMessageEvents = function _AccountsController_subscribeToMessageEvents() {
698
690
  this.messagingSystem.subscribe('SnapController:stateChange', (snapStateState) => __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_handleOnSnapStateChange).call(this, snapStateState));
699
691
  this.messagingSystem.subscribe('KeyringController:stateChange', (keyringState) => __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_handleOnKeyringStateChange).call(this, keyringState));