AccountTreeController.test.ts

import type {
  AccountGroupId,
  AccountWalletId,
  Bip44Account,
} from '@metamask/account-api';
import {
  AccountGroupType,
  AccountWalletType,
  toAccountGroupId,
  toAccountWalletId,
  toMultichainAccountGroupId,
  toMultichainAccountWalletId,
} from '@metamask/account-api';
import type { AccountId } from '@metamask/accounts-controller';
import { deriveStateFromMetadata } from '@metamask/base-controller';
import {
  BtcAccountType,
  EthAccountType,
  EthMethod,
  EthScope,
  KeyringAccountEntropyTypeOption,
  SolAccountType,
  SolMethod,
  SolScope,
  TrxAccountType,
  TrxMethod,
  TrxScope,
} from '@metamask/keyring-api';
import type { KeyringObject } from '@metamask/keyring-controller';
import { KeyringTypes } from '@metamask/keyring-controller';
import type { InternalAccount } from '@metamask/keyring-internal-api';
import type { GetSnap as SnapControllerGetSnap } from '@metamask/snaps-controllers';

import {
  AccountTreeController,
  getDefaultAccountTreeControllerState,
} from './AccountTreeController';
import type { BackupAndSyncAnalyticsEventPayload } from './backup-and-sync/analytics';
import { BackupAndSyncService } from './backup-and-sync/service';
import { isAccountGroupNameUnique } from './group';
import { getAccountWalletNameFromKeyringType } from './rules/keyring';
import type { AccountTreeControllerState } from './types';
import {
  getAccountTreeControllerMessenger,
  getRootMessenger,
} from '../tests/mockMessenger';

// Local mock of EMPTY_ACCOUNT to avoid circular dependency
const EMPTY_ACCOUNT_MOCK: InternalAccount = {
  id: '',
  address: '',
  options: {},
  methods: [],
  type: EthAccountType.Eoa,
  scopes: [EthScope.Eoa],
  metadata: {
    name: '',
    keyring: {
      type: '',
    },
    importTime: 0,
  },
};

const ETH_EOA_METHODS = [
  EthMethod.PersonalSign,
  EthMethod.Sign,
  EthMethod.SignTransaction,
  EthMethod.SignTypedDataV1,
  EthMethod.SignTypedDataV3,
  EthMethod.SignTypedDataV4,
] as const;

const MOCK_SNAP_1 = {
  id: 'local:mock-snap-id-1',
  name: 'Mock Snap 1',
  enabled: true,
  manifest: {
    proposedName: 'Mock Snap 1',
  },
};

const MOCK_SNAP_2 = {
  id: 'local:mock-snap-id-2',
  name: 'Mock Snap 2',
  enabled: true,
  manifest: {
    proposedName: 'Mock Snap 2',
  },
};

const MOCK_SNAP_3 = {
  id: 'local:mock-snap-id-3',
  name: 'Mock Snap 3',
  enabled: true,
  manifest: {
    proposedName: 'Mock Snap 3',
  },
};

const MOCK_HD_KEYRING_1 = {
  type: KeyringTypes.hd,
  metadata: { id: 'mock-keyring-id-1', name: 'HD Keyring 1' },
  accounts: ['0x123'],
};

const MOCK_HD_KEYRING_2 = {
  type: KeyringTypes.hd,
  metadata: { id: 'mock-keyring-id-2', name: 'HD Keyring 1' },
  accounts: ['0x456'],
};

const MOCK_HD_ACCOUNT_1: Bip44Account<InternalAccount> = {
  id: 'mock-id-1',
  address: '0x123',
  options: {
    entropy: {
      type: KeyringAccountEntropyTypeOption.Mnemonic,
      id: MOCK_HD_KEYRING_1.metadata.id,
      groupIndex: 0,
      derivationPath: '',
    },
  },
  methods: [...ETH_EOA_METHODS],
  type: EthAccountType.Eoa,
  scopes: [EthScope.Eoa],
  metadata: {
    name: '',
    keyring: { type: KeyringTypes.hd },
    importTime: 0,
    lastSelected: 0,
    nameLastUpdatedAt: 0,
  },
};

const MOCK_HD_ACCOUNT_2: Bip44Account<InternalAccount> = {
  id: 'mock-id-2',
  address: '0x456',
  options: {
    entropy: {
      type: KeyringAccountEntropyTypeOption.Mnemonic,
      id: MOCK_HD_KEYRING_2.metadata.id,
      groupIndex: 0,
      derivationPath: '',
    },
  },
  methods: [...ETH_EOA_METHODS],
  type: EthAccountType.Eoa,
  scopes: [EthScope.Eoa],
  metadata: {
    name: '',
    keyring: { type: KeyringTypes.hd },
    importTime: 0,
    lastSelected: 0,
    nameLastUpdatedAt: 0,
  },
};

const MOCK_SNAP_ACCOUNT_1: Bip44Account<InternalAccount> = {
  id: 'mock-snap-id-1',
  address: 'aabbccdd',
  options: {
    entropy: {
      type: KeyringAccountEntropyTypeOption.Mnemonic,
      id: MOCK_HD_KEYRING_2.metadata.id,
      groupIndex: 1,
      derivationPath: '',
    },
  },
  methods: [...Object.values(SolMethod)],
  type: SolAccountType.DataAccount,
  scopes: [SolScope.Mainnet],
  metadata: {
    name: '',
    keyring: { type: KeyringTypes.snap },
    snap: MOCK_SNAP_1,
    importTime: 0,
    lastSelected: 0,
  },
};

const MOCK_SNAP_ACCOUNT_2: InternalAccount = {
  id: 'mock-snap-id-2',
  address: '0x789',
  options: {},
  methods: [...ETH_EOA_METHODS],
  type: EthAccountType.Eoa,
  scopes: [EthScope.Eoa],
  metadata: {
    name: '',
    keyring: { type: KeyringTypes.snap },
    snap: MOCK_SNAP_2,
    importTime: 0,
    lastSelected: 0,
  },
};

const MOCK_TRX_ACCOUNT_1: InternalAccount = {
  id: 'mock-trx-id-1',
  address: 'TROn11',
  options: {
    entropy: {
      type: KeyringAccountEntropyTypeOption.Mnemonic,
      id: MOCK_HD_KEYRING_1.metadata.id,
      groupIndex: 0,
      derivationPath: '',
    },
  },
  methods: [TrxMethod.SignMessageV2],
  type: TrxAccountType.Eoa,
  scopes: [TrxScope.Mainnet],
  metadata: {
    name: '',
    keyring: { type: KeyringTypes.snap },
    importTime: 0,
    lastSelected: 0,
    snap: MOCK_SNAP_3,
  },
};

const MOCK_HARDWARE_ACCOUNT_1: InternalAccount = {
  id: 'mock-hardware-id-1',
  address: '0xABC',
  options: {},
  methods: [...ETH_EOA_METHODS],
  type: EthAccountType.Eoa,
  scopes: [EthScope.Eoa],
  metadata: {
    name: '',
    keyring: { type: KeyringTypes.ledger },
    importTime: 0,
    lastSelected: 0,
  },
};

const mockGetSelectedMultichainAccountActionHandler = jest.fn();

/**
 * Sets up the AccountTreeController for testing.
 *
 * @param options - Configuration options for setup.
 * @param options.state - Partial initial state for the controller. Defaults to empty object.
 * @param options.messenger - An optional messenger instance to use. Defaults to a new Messenger.
 * @param options.accounts - Accounts to use for AccountsController:listMultichainAccounts handler.
 * @param options.keyrings - Keyring objects to use for KeyringController:getState handler.
 * @param options.config - Configuration options for the controller.
 * @param options.config.backupAndSync - Configuration options for backup and sync.
 * @param options.config.backupAndSync.onBackupAndSyncEvent - Event handler for backup and sync events.
 * @param options.config.backupAndSync.isAccountSyncingEnabled - Flag to enable account syncing.
 * @param options.config.backupAndSync.isBackupAndSyncEnabled - Flag to enable backup and sync.
 * @param options.config.accountOrderCallbacks - Callbacks to migrate hidden and pinned account information from the account order controller.
 * @param options.config.accountOrderCallbacks.isHiddenAccount - Callback to check if an account is hidden.
 * @param options.config.accountOrderCallbacks.isPinnedAccount - Callback to check if an account is pinned.
 * @returns An object containing the controller instance and the messenger.
 */
function setup({
  state = {},
  messenger = getRootMessenger(),
  accounts = [],
  keyrings = [],
  config = {
    backupAndSync: {
      isAccountSyncingEnabled: true,
      isBackupAndSyncEnabled: true,
      onBackupAndSyncEvent: jest.fn(),
    },
    accountOrderCallbacks: {
      isHiddenAccount: jest.fn().mockReturnValue(false),
      isPinnedAccount: jest.fn().mockReturnValue(false),
    },
  },
}: {
  state?: Partial<AccountTreeControllerState>;
  messenger?: ReturnType<typeof getRootMessenger>;
  accounts?: InternalAccount[];
  keyrings?: KeyringObject[];
  config?: {
    backupAndSync?: {
      isAccountSyncingEnabled?: boolean;
      isBackupAndSyncEnabled?: boolean;
      onBackupAndSyncEvent?: (
        event: BackupAndSyncAnalyticsEventPayload,
      ) => void;
    };
    accountOrderCallbacks?: {
      isHiddenAccount?: (accountId: AccountId) => boolean;
      isPinnedAccount?: (accountId: AccountId) => boolean;
    };
  };
} = {}): {
  controller: AccountTreeController;
  messenger: ReturnType<typeof getRootMessenger>;
  accountTreeControllerMessenger: ReturnType<
    typeof getAccountTreeControllerMessenger
  >;
  spies: {
    consoleWarn: jest.SpyInstance;
  };
  mocks: {
    KeyringController: {
      keyrings: KeyringObject[];
      getState: jest.Mock;
    };
    AccountsController: {
      accounts: InternalAccount[];
      listMultichainAccounts: jest.Mock;
      getSelectedMultichainAccount: jest.Mock;
      getAccount: jest.Mock;
    };
    UserStorageController: {
      performGetStorage: jest.Mock;
      performGetStorageAllFeatureEntries: jest.Mock;
      performSetStorage: jest.Mock;
      performBatchSetStorage: jest.Mock;
      syncInternalAccountsWithUserStorage: jest.Mock;
    };
    AuthenticationController: {
      getSessionProfile: jest.Mock;
    };
  };
} {
  const mocks = {
    KeyringController: {
      keyrings,
      getState: jest.fn(),
    },
    AccountsController: {
      accounts,
      listMultichainAccounts: jest.fn(),
      getAccount: jest.fn(),
      getSelectedMultichainAccount: jest.fn(),
    },
    UserStorageController: {
      getState: jest.fn(),
      performGetStorage: jest.fn(),
      performGetStorageAllFeatureEntries: jest.fn(),
      performSetStorage: jest.fn(),
      performBatchSetStorage: jest.fn(),
      syncInternalAccountsWithUserStorage: jest.fn(),
    },
    AuthenticationController: {
      getSessionProfile: jest.fn().mockResolvedValue({
        profileId: 'f88227bd-b615-41a3-b0be-467dd781a4ad',
        metaMetricsId: '561ec651-a844-4b36-a451-04d6eac35740',
        identifierId:
          'da9a9fc7b09edde9cc23cec9b7e11a71fb0ab4d2ddd8af8af905306f3e1456fb',
      }),
    },
  };

  if (accounts) {
    mocks.AccountsController.listMultichainAccounts.mockImplementation(
      () => mocks.AccountsController.accounts,
    );

    messenger.registerActionHandler(
      'AccountsController:listMultichainAccounts',
      mocks.AccountsController.listMultichainAccounts,
    );

    mocks.AccountsController.getAccount.mockImplementation((id) =>
      mocks.AccountsController.accounts.find((account) => account.id === id),
    );
    messenger.registerActionHandler(
      'AccountsController:getAccount',
      mocks.AccountsController.getAccount,
    );

    // Mock AccountsController:getSelectedMultichainAccount to return the first account
    mocks.AccountsController.getSelectedMultichainAccount.mockImplementation(
      () => accounts[0] || MOCK_HD_ACCOUNT_1,
    );
    messenger.registerActionHandler(
      'AccountsController:getSelectedMultichainAccount',
      mocks.AccountsController.getSelectedMultichainAccount,
    );

    // Mock AccountsController:setSelectedAccount
    messenger.registerActionHandler(
      'AccountsController:setSelectedAccount',
      jest.fn(),
    );

    // Mock AuthenticationController:getSessionProfile
    messenger.registerActionHandler(
      'AuthenticationController:getSessionProfile',
      mocks.AuthenticationController.getSessionProfile,
    );

    // Mock UserStorageController methods
    mocks.UserStorageController.getState.mockImplementation(() => ({
      isBackupAndSyncEnabled: config?.backupAndSync?.isBackupAndSyncEnabled,
      isAccountSyncingEnabled: config?.backupAndSync?.isAccountSyncingEnabled,
    }));
    messenger.registerActionHandler(
      'UserStorageController:getState',
      mocks.UserStorageController.getState,
    );

    messenger.registerActionHandler(
      'UserStorageController:performGetStorage',
      mocks.UserStorageController.performGetStorage,
    );
    messenger.registerActionHandler(
      'UserStorageController:performGetStorageAllFeatureEntries',
      mocks.UserStorageController.performGetStorageAllFeatureEntries,
    );
    messenger.registerActionHandler(
      'UserStorageController:performSetStorage',
      mocks.UserStorageController.performSetStorage,
    );
    messenger.registerActionHandler(
      'UserStorageController:performBatchSetStorage',
      mocks.UserStorageController.performBatchSetStorage,
    );
  }

  if (keyrings) {
    mocks.KeyringController.getState.mockImplementation(() => ({
      isUnlocked: true,
      keyrings: mocks.KeyringController.keyrings,
    }));
    messenger.registerActionHandler(
      'KeyringController:getState',
      mocks.KeyringController.getState,
    );
  }

  const accountTreeControllerMessenger =
    getAccountTreeControllerMessenger(messenger);
  const controller = new AccountTreeController({
    messenger: accountTreeControllerMessenger,
    state,
    ...(config && { config }),
  });

  const consoleWarnSpy = jest
    .spyOn(console, 'warn')
    .mockImplementation(() => undefined);

  return {
    controller,
    messenger,
    accountTreeControllerMessenger,
    spies: { consoleWarn: consoleWarnSpy },
    mocks,
  };
}

describe('AccountTreeController', () => {
  beforeEach(() => {
    jest.resetAllMocks();
  });

  describe('init', () => {
    it('groups accounts by entropy source, then snapId, then wallet type', () => {
      const { controller, messenger } = setup({
        accounts: [
          MOCK_HD_ACCOUNT_1,
          MOCK_HD_ACCOUNT_2,
          MOCK_SNAP_ACCOUNT_1, // Belongs to MOCK_HD_ACCOUNT_2's wallet due to shared entropySource
          MOCK_SNAP_ACCOUNT_2, // Has its own Snap wallet
          MOCK_HARDWARE_ACCOUNT_1, // Has its own Keyring wallet
        ],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      messenger.registerActionHandler(
        'SnapController:get',
        () =>
          // TODO: Update this to avoid the unknown cast if possible.
          MOCK_SNAP_2 as unknown as ReturnType<
            SnapControllerGetSnap['handler']
          >,
      );

      controller.init();

      const expectedWalletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedWalletId1Group = toMultichainAccountGroupId(
        expectedWalletId1,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );
      const expectedWalletId2 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const expectedWalletId2Group1 = toMultichainAccountGroupId(
        expectedWalletId2,
        MOCK_HD_ACCOUNT_2.options.entropy.groupIndex,
      );
      const expectedWalletId2Group2 = toMultichainAccountGroupId(
        expectedWalletId2,
        MOCK_SNAP_ACCOUNT_1.options.entropy.groupIndex,
      );
      const expectedSnapWalletId = toAccountWalletId(
        AccountWalletType.Snap,
        MOCK_SNAP_2.id,
      );
      const expectedSnapWalletIdGroup = toAccountGroupId(
        expectedSnapWalletId,
        MOCK_SNAP_ACCOUNT_2.address,
      );
      const expectedKeyringWalletId = toAccountWalletId(
        AccountWalletType.Keyring,
        KeyringTypes.ledger,
      );
      const expectedKeyringWalletIdGroup = toAccountGroupId(
        expectedKeyringWalletId,
        MOCK_HARDWARE_ACCOUNT_1.address,
      );

      expect(controller.state).toStrictEqual({
        accountTree: {
          wallets: {
            [expectedWalletId1]: {
              id: expectedWalletId1,
              type: AccountWalletType.Entropy,
              status: 'ready',
              groups: {
                [expectedWalletId1Group]: {
                  id: expectedWalletId1Group,
                  type: AccountGroupType.MultichainAccount,
                  accounts: [MOCK_HD_ACCOUNT_1.id],
                  metadata: {
                    name: 'Account 1',
                    entropy: {
                      groupIndex: MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
                    },
                    pinned: false,
                    hidden: false,
                  },
                },
              },
              metadata: {
                name: 'Wallet 1',
                entropy: {
                  id: MOCK_HD_KEYRING_1.metadata.id,
                },
              },
            },
            [expectedWalletId2]: {
              id: expectedWalletId2,
              type: AccountWalletType.Entropy,
              status: 'ready',
              groups: {
                [expectedWalletId2Group1]: {
                  id: expectedWalletId2Group1,
                  type: AccountGroupType.MultichainAccount,
                  accounts: [MOCK_HD_ACCOUNT_2.id],
                  metadata: {
                    name: 'Account 1', // Updated: per-wallet numbering (wallet 2, account 1)
                    entropy: {
                      groupIndex: MOCK_HD_ACCOUNT_2.options.entropy.groupIndex,
                    },
                    pinned: false,
                    hidden: false,
                  },
                },
                [expectedWalletId2Group2]: {
                  id: expectedWalletId2Group2,
                  type: AccountGroupType.MultichainAccount,
                  accounts: [MOCK_SNAP_ACCOUNT_1.id],
                  metadata: {
                    name: 'Account 2', // Updated: per-wallet sequential numbering (wallet 2, account 2)
                    entropy: {
                      groupIndex:
                        MOCK_SNAP_ACCOUNT_1.options.entropy.groupIndex,
                    },
                    pinned: false,
                    hidden: false,
                  },
                },
              },
              metadata: {
                name: 'Wallet 2',
                entropy: {
                  id: MOCK_HD_KEYRING_2.metadata.id,
                },
              },
            },
            [expectedSnapWalletId]: {
              id: expectedSnapWalletId,
              type: AccountWalletType.Snap,
              status: 'ready',
              groups: {
                [expectedSnapWalletIdGroup]: {
                  id: expectedSnapWalletIdGroup,
                  type: AccountGroupType.SingleAccount,
                  accounts: [MOCK_SNAP_ACCOUNT_2.id],
                  metadata: {
                    name: 'Snap Account 1', // Updated: per-wallet numbering (different wallet)
                    pinned: false,
                    hidden: false,
                  },
                },
              },
              metadata: {
                name: MOCK_SNAP_2.manifest.proposedName,
                snap: {
                  id: MOCK_SNAP_2.id,
                },
              },
            },
            [expectedKeyringWalletId]: {
              id: expectedKeyringWalletId,
              type: AccountWalletType.Keyring,
              status: 'ready',
              groups: {
                [expectedKeyringWalletIdGroup]: {
                  id: expectedKeyringWalletIdGroup,
                  type: AccountGroupType.SingleAccount,
                  accounts: [MOCK_HARDWARE_ACCOUNT_1.id],
                  metadata: {
                    name: 'Ledger Account 1', // Updated: per-wallet numbering (different wallet)
                    pinned: false,
                    hidden: false,
                  },
                },
              },
              metadata: {
                name: getAccountWalletNameFromKeyringType(
                  MOCK_HARDWARE_ACCOUNT_1.metadata.keyring.type as KeyringTypes,
                ),
                keyring: {
                  type: KeyringTypes.ledger,
                },
              },
            },
          },
          selectedAccountGroup: expect.any(String), // Will be set to some group after init
        },
        hasAccountTreeSyncingSyncedAtLeastOnce: false,
        isAccountTreeSyncingInProgress: false,
        accountGroupsMetadata: {
          // All accounts now get metadata entries with proper per-wallet names
          [expectedWalletId1Group]: {
            name: {
              value: 'Account 1',
              lastUpdatedAt: expect.any(Number),
            },
            pinned: {
              value: false,
              lastUpdatedAt: 0,
            },
            hidden: {
              value: false,
              lastUpdatedAt: 0,
            },
          },
          [expectedWalletId2Group1]: {
            name: {
              value: 'Account 1',
              lastUpdatedAt: expect.any(Number),
            },
            pinned: {
              value: false,
              lastUpdatedAt: 0,
            },
            hidden: {
              value: false,
              lastUpdatedAt: 0,
            },
          },
          [expectedWalletId2Group2]: {
            name: {
              value: 'Account 2', // Updated: per-wallet sequential numbering
              lastUpdatedAt: expect.any(Number),
            },
            pinned: {
              value: false,
              lastUpdatedAt: 0,
            },
            hidden: {
              value: false,
              lastUpdatedAt: 0,
            },
          },
          [expectedKeyringWalletIdGroup]: {
            name: {
              value: 'Ledger Account 1', // Updated: per-wallet numbering (different wallet)
              lastUpdatedAt: expect.any(Number),
            },
            pinned: {
              value: false,
              lastUpdatedAt: 0,
            },
            hidden: {
              value: false,
              lastUpdatedAt: 0,
            },
          },
          [expectedSnapWalletIdGroup]: {
            name: {
              value: 'Snap Account 1', // Updated: per-wallet numbering (different wallet)
              lastUpdatedAt: expect.any(Number),
            },
            pinned: {
              value: false,
              lastUpdatedAt: 0,
            },
            hidden: {
              value: false,
              lastUpdatedAt: 0,
            },
          },
        },
        accountWalletsMetadata: {},
      } as AccountTreeControllerState);
    });

    it('handles Snap accounts with entropy source', () => {
      const mockSnapAccountWithEntropy: Bip44Account<InternalAccount> = {
        ...MOCK_SNAP_ACCOUNT_2,
        options: {
          entropy: {
            type: KeyringAccountEntropyTypeOption.Mnemonic,
            id: MOCK_HD_KEYRING_2.metadata.id,
            groupIndex: 0,
            derivationPath: '',
          },
        },
        metadata: {
          ...MOCK_SNAP_ACCOUNT_2.metadata,
          snap: MOCK_SNAP_2,
        },
      } as const;

      const { controller, messenger } = setup({
        accounts: [mockSnapAccountWithEntropy],
        keyrings: [MOCK_HD_KEYRING_2],
      });

      messenger.registerActionHandler(
        'SnapController:get',
        () =>
          ({
            manifest: {
              proposedName: 'Test',
            },
          }) as ReturnType<SnapControllerGetSnap['handler']>,
      );

      controller.init();

      const expectedWalletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const expectedGroupId = toMultichainAccountGroupId(
        expectedWalletId,
        mockSnapAccountWithEntropy.options.entropy.groupIndex,
      );
      expect(
        controller.state.accountTree.wallets[expectedWalletId]?.groups[
          expectedGroupId
        ]?.accounts,
      ).toContain(mockSnapAccountWithEntropy.id);
    });

    it('fallback to Snap ID if Snap cannot be found', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_SNAP_ACCOUNT_1],
        keyrings: [],
      });

      messenger.registerActionHandler('SnapController:get', () => undefined); // Snap won't be found.

      controller.init();

      // Since no entropy sources will be found, it will be categorized as a
      // "Keyring" wallet
      const wallet1Id = toAccountWalletId(
        AccountWalletType.Snap,
        MOCK_SNAP_1.id,
      );

      // FIXME: Do we really want this behavior?
      expect(
        controller.state.accountTree.wallets[wallet1Id]?.metadata.name,
      ).toBe('mock-snap-id-1');
    });

    it('fallback to HD keyring category if entropy sources cannot be found', () => {
      // Create entropy wallets that will both get "Wallet" as base name, then get numbered
      const mockHdAccount1: InternalAccount = {
        ...MOCK_HD_ACCOUNT_1,
        options: { entropySource: MOCK_HD_KEYRING_1.metadata.id },
      };
      const mockHdAccount2: InternalAccount = {
        ...MOCK_HD_ACCOUNT_2,
        options: { entropySource: MOCK_HD_KEYRING_2.metadata.id },
      };

      const { controller } = setup({
        accounts: [mockHdAccount1, mockHdAccount2],
        keyrings: [],
      });

      controller.init();

      // Since no entropy sources will be found, it will be categorized as a
      // "Keyring" wallet
      const wallet1Id = toAccountWalletId(
        AccountWalletType.Keyring,
        mockHdAccount1.metadata.keyring.type,
      );
      const wallet2Id = toAccountWalletId(
        AccountWalletType.Keyring,
        mockHdAccount1.metadata.keyring.type,
      );

      // FIXME: Do we really want this behavior?
      expect(
        controller.state.accountTree.wallets[wallet1Id]?.metadata.name,
      ).toBe('HD Wallet');
      expect(
        controller.state.accountTree.wallets[wallet2Id]?.metadata.name,
      ).toBe('HD Wallet');
    });

    it('re-select a new group when tree is re-initialized and current selected group no longer exists', () => {
      const { controller, mocks } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      mocks.AccountsController.getSelectedMultichainAccount.mockImplementation(
        () => MOCK_HD_ACCOUNT_1,
      );

      controller.init();

      const defaultAccountGroupId = toMultichainAccountGroupId(
        toMultichainAccountWalletId(MOCK_HD_ACCOUNT_1.options.entropy.id),
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      expect(controller.state.accountTree.selectedAccountGroup).toStrictEqual(
        defaultAccountGroupId,
      );

      mocks.AccountsController.accounts = [MOCK_HD_ACCOUNT_2];
      mocks.KeyringController.keyrings = [MOCK_HD_KEYRING_2];
      mocks.AccountsController.getSelectedMultichainAccount.mockImplementation(
        () => MOCK_HD_ACCOUNT_2,
      );

      controller.reinit();

      const newDefaultAccountGroupId = toMultichainAccountGroupId(
        toMultichainAccountWalletId(MOCK_HD_ACCOUNT_2.options.entropy.id),
        MOCK_HD_ACCOUNT_2.options.entropy.groupIndex,
      );

      expect(controller.state.accountTree.selectedAccountGroup).toStrictEqual(
        newDefaultAccountGroupId,
      );
    });

    it('is a no-op if init is called twice', () => {
      const { controller, mocks } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();
      expect(
        mocks.AccountsController.listMultichainAccounts,
      ).toHaveBeenCalledTimes(1);
      expect(
        mocks.AccountsController.getSelectedMultichainAccount,
      ).toHaveBeenCalledTimes(1);

      // Calling init again is a no-op, so we're not fetching the list of accounts
      // a second time.
      controller.init();
      expect(
        mocks.AccountsController.listMultichainAccounts,
      ).toHaveBeenCalledTimes(1);
      expect(
        mocks.AccountsController.getSelectedMultichainAccount,
      ).toHaveBeenCalledTimes(1);
    });

    it('is re-fetching the list of accounts during re-init', () => {
      const { controller, mocks } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();
      expect(
        mocks.AccountsController.listMultichainAccounts,
      ).toHaveBeenCalledTimes(1);
      expect(
        mocks.AccountsController.getSelectedMultichainAccount,
      ).toHaveBeenCalledTimes(1);

      // Deep copy initial tree.
      const initialTree = JSON.parse(
        JSON.stringify(controller.state.accountTree),
      );

      // We now change the list of accounts entirely and call re-init to re-fetch
      // the new account list.
      mocks.AccountsController.accounts = [MOCK_HD_ACCOUNT_2];

      controller.reinit();
      expect(
        mocks.AccountsController.listMultichainAccounts,
      ).toHaveBeenCalledTimes(2);
      expect(
        mocks.AccountsController.getSelectedMultichainAccount,
      ).toHaveBeenCalledTimes(2);

      // Deep copy new tree.
      const updatedTree = JSON.parse(
        JSON.stringify(controller.state.accountTree),
      );

      expect(initialTree).not.toStrictEqual(updatedTree);
    });

    it('sorts out-of-order accounts to create group in the proper order', () => {
      const { controller, mocks } = setup({
        keyrings: [MOCK_HD_KEYRING_1],
      });

      const mockAccountWith = (
        groupIndex: number,
        importTime: number,
      ): InternalAccount => ({
        ...MOCK_HD_ACCOUNT_1,
        id: `mock-id-${groupIndex}`,
        address: '0x123',
        options: {
          entropy: {
            type: 'mnemonic',
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex,
            derivationPath: '',
          },
        },
        metadata: { ...MOCK_HD_ACCOUNT_1.metadata, importTime },
      });

      const now = Date.now();
      mocks.AccountsController.listMultichainAccounts.mockReturnValue([
        // Faking accounts to be out of order:
        mockAccountWith(1, now + 1000),
        mockAccountWith(2, now + 2000),
        mockAccountWith(0, now),
      ]);

      controller.init();

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );

      // Object `string` keys are by "inserting order".
      const groupIds = Object.keys(
        controller.state.accountTree.wallets[walletId].groups,
      );
      expect(groupIds[0]).toBe(toMultichainAccountGroupId(walletId, 0));
      expect(groupIds[1]).toBe(toMultichainAccountGroupId(walletId, 1));
      expect(groupIds[2]).toBe(toMultichainAccountGroupId(walletId, 2));
    });
  });

  describe('getAccountGroupObject', () => {
    it('returns a valid account group object', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const groupId = toMultichainAccountGroupId(
        walletId,
        MOCK_HD_ACCOUNT_2.options.entropy.groupIndex,
      );
      expect(controller.getAccountGroupObject(groupId)).toBeDefined();
    });

    it('returns undefined if group id is not found', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      const walletId = toAccountWalletId(
        AccountWalletType.Entropy,
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const groupId = toAccountGroupId(walletId, 'bad');
      expect(controller.getAccountGroupObject(groupId)).toBeUndefined();
    });
  });

  describe('getAccountContext', () => {
    it('returns account context for a valid account', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      const context = controller.getAccountContext(MOCK_HD_ACCOUNT_1.id);

      expect(context).toBeDefined();
      expect(context?.walletId).toBe(
        toMultichainAccountWalletId(MOCK_HD_KEYRING_1.metadata.id),
      );
      expect(context?.groupId).toBe(
        toMultichainAccountGroupId(
          toMultichainAccountWalletId(MOCK_HD_KEYRING_1.metadata.id),
          MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
        ),
      );
      expect(context?.sortOrder).toBeDefined();
    });

    it('returns undefined for an unknown account', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const context = controller.getAccountContext('unknown-account-id');

      expect(context).toBeUndefined();
    });

    it('returns correct context for different account types', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_SNAP_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      const hdContext = controller.getAccountContext(MOCK_HD_ACCOUNT_1.id);
      const snapContext = controller.getAccountContext(MOCK_SNAP_ACCOUNT_1.id);

      expect(hdContext).toBeDefined();
      expect(snapContext).toBeDefined();

      expect(hdContext?.walletId).toBe(
        toMultichainAccountWalletId(MOCK_HD_KEYRING_1.metadata.id),
      );
      expect(snapContext?.walletId).toBe(
        toMultichainAccountWalletId(MOCK_HD_KEYRING_2.metadata.id),
      );
    });
  });

  describe('getAccountsFromSelectAccountGroup', () => {
    it('selects account without a selector', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      expect(controller.getAccountsFromSelectedAccountGroup()).toStrictEqual([
        MOCK_HD_ACCOUNT_1,
      ]);

      const walletId = toAccountWalletId(
        AccountWalletType.Entropy,
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const groupId = toAccountGroupId(
        walletId,
        `${MOCK_HD_ACCOUNT_2.options.entropy.groupIndex}`,
      );
      controller.setSelectedAccountGroup(groupId);

      expect(controller.getAccountsFromSelectedAccountGroup()).toStrictEqual([
        MOCK_HD_ACCOUNT_2,
      ]);
    });

    it('selects account with a selector', () => {
      const mockSolAccount1: Bip44Account<InternalAccount> = {
        ...MOCK_SNAP_ACCOUNT_1,
        options: {
          entropy: {
            ...MOCK_SNAP_ACCOUNT_1.options.entropy,
            groupIndex: 0,
          },
        },
      };

      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_2, mockSolAccount1],
        keyrings: [MOCK_HD_KEYRING_2],
      });

      controller.init();

      expect(
        controller.getAccountsFromSelectedAccountGroup({
          scopes: [SolScope.Mainnet],
        }),
      ).toStrictEqual([mockSolAccount1]);

      expect(
        controller.getAccountsFromSelectedAccountGroup({
          scopes: [EthScope.Mainnet],
        }),
      ).toStrictEqual([MOCK_HD_ACCOUNT_2]);
    });

    it('returns no account if no group is selected', () => {
      const { controller } = setup({
        accounts: [],
        keyrings: [],
      });

      controller.init();

      expect(controller.getAccountsFromSelectedAccountGroup()).toHaveLength(0);
    });
  });

  describe('on AccountsController:accountRemoved', () => {
    it('removes an account from the tree', () => {
      // 2 accounts that share the same entropy source (thus, same wallet).
      const mockHdAccount1: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex: 0,
          },
        },
      };
      const mockHdAccount2 = {
        ...MOCK_HD_ACCOUNT_2,
        options: {
          ...MOCK_HD_ACCOUNT_2.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_2.options.entropy,
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex: 0,
          },
        },
      };

      const { controller, messenger } = setup({
        accounts: [mockHdAccount1, mockHdAccount2],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      // Create entropy wallets that will both get "Wallet" as base name, then get numbered
      controller.init();

      messenger.publish('AccountsController:accountRemoved', mockHdAccount1.id);

      const walletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const walletId1Group = toMultichainAccountGroupId(
        walletId1,
        mockHdAccount1.options.entropy.groupIndex,
      );
      expect(controller.state).toStrictEqual({
        accountTree: {
          wallets: {
            [walletId1]: {
              id: walletId1,
              type: AccountWalletType.Entropy,
              status: 'ready',
              groups: {
                [walletId1Group]: {
                  id: walletId1Group,
                  type: AccountGroupType.MultichainAccount,
                  metadata: {
                    name: 'Account 1',
                    entropy: {
                      groupIndex: mockHdAccount1.options.entropy.groupIndex,
                    },
                    pinned: false,
                    hidden: false,
                  },
                  accounts: [mockHdAccount2.id], // HD account 1 got removed.
                },
              },
              metadata: {
                name: 'Wallet 1',
                entropy: {
                  id: MOCK_HD_KEYRING_1.metadata.id,
                },
              },
            },
          },
          selectedAccountGroup: expect.any(String), // Will be set after init
        },
        isAccountTreeSyncingInProgress: false,
        hasAccountTreeSyncingSyncedAtLeastOnce: false,
        accountGroupsMetadata: {
          // Account groups now get metadata entries during init
          [walletId1Group]: {
            name: {
              value: 'Account 1',
              lastUpdatedAt: expect.any(Number),
            },
            pinned: {
              value: false,
              lastUpdatedAt: 0,
            },
            hidden: {
              value: false,
              lastUpdatedAt: 0,
            },
          },
        },
        accountWalletsMetadata: {},
      } as AccountTreeControllerState);
    });

    it('prunes an empty group if it holds no accounts', () => {
      const mockHdAccount1: Bip44Account<InternalAccount> = MOCK_HD_ACCOUNT_1;
      const mockHdAccount2 = {
        ...MOCK_HD_ACCOUNT_2,
        options: {
          entropy: {
            ...MOCK_HD_ACCOUNT_2.options.entropy,
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex: 1,
          },
        },
      };

      const { controller, messenger } = setup({
        accounts: [mockHdAccount1, mockHdAccount2],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      messenger.publish('AccountsController:accountRemoved', mockHdAccount1.id);

      const walletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );

      const walletId1Group2 = toMultichainAccountGroupId(
        walletId1,
        mockHdAccount2.options.entropy.groupIndex,
      );

      expect(controller.state).toStrictEqual({
        accountTree: {
          wallets: {
            [walletId1]: {
              id: walletId1,
              type: AccountWalletType.Entropy,
              status: 'ready',
              groups: {
                // First group gets removed as a result of pruning.
                [walletId1Group2]: {
                  id: walletId1Group2,
                  type: AccountGroupType.MultichainAccount,
                  metadata: {
                    name: 'Account 2',
                    entropy: {
                      groupIndex: mockHdAccount2.options.entropy.groupIndex,
                    },
                    pinned: false,
                    hidden: false,
                  },
                  accounts: [mockHdAccount2.id],
                },
              },
              metadata: {
                name: 'Wallet 1',
                entropy: {
                  id: MOCK_HD_KEYRING_1.metadata.id,
                },
              },
            },
          },
          selectedAccountGroup: expect.any(String), // Will be set after init
        },
        isAccountTreeSyncingInProgress: false,
        hasAccountTreeSyncingSyncedAtLeastOnce: false,
        accountGroupsMetadata: {
          // Both groups get metadata during init, but first group metadata gets cleaned up when pruned
          [walletId1Group2]: {
            name: {
              value: 'Account 2', // This is the second account in the wallet
              lastUpdatedAt: expect.any(Number),
            },
            pinned: {
              value: false,
              lastUpdatedAt: 0,
            },
            hidden: {
              value: false,
              lastUpdatedAt: 0,
            },
          },
        },
        accountWalletsMetadata: {},
      } as AccountTreeControllerState);
    });

    it('prunes an empty wallet if it holds no groups', () => {
      const mockHdAccount1: Bip44Account<InternalAccount> = MOCK_HD_ACCOUNT_1;

      const { controller, messenger } = setup({
        accounts: [mockHdAccount1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      messenger.publish('AccountsController:accountRemoved', mockHdAccount1.id);

      expect(controller.state).toStrictEqual({
        accountGroupsMetadata: {},
        accountWalletsMetadata: {},
        isAccountTreeSyncingInProgress: false,
        hasAccountTreeSyncingSyncedAtLeastOnce: false,
        accountTree: {
          // No wallets should be present.
          wallets: {},
          selectedAccountGroup: expect.any(String), // Will be set after init
        },
      } as AccountTreeControllerState);
    });

    it('prunes custom wallet metadata when wallet is removed', () => {
      const mockHdAccount1: Bip44Account<InternalAccount> = MOCK_HD_ACCOUNT_1;

      const { controller, messenger } = setup({
        accounts: [mockHdAccount1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );

      // Set custom wallet name
      controller.setAccountWalletName(walletId, 'My Custom Wallet');

      // Verify custom metadata was set
      expect(controller.state.accountWalletsMetadata[walletId]).toStrictEqual({
        name: {
          value: 'My Custom Wallet',
          lastUpdatedAt: expect.any(Number),
        },
      });

      // Remove the account, which should prune the wallet and its metadata
      messenger.publish('AccountsController:accountRemoved', mockHdAccount1.id);

      // Verify both wallet and its metadata are completely removed
      expect(controller.state.accountTree.wallets[walletId]).toBeUndefined();
      expect(controller.state.accountWalletsMetadata[walletId]).toBeUndefined();
      expect(controller.state.accountWalletsMetadata).toStrictEqual({});
    });

    it('does not remove account if init has not been called', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
      });

      // Force ref to the controller, even if we don't use it in this test.
      expect(controller).toBeDefined();

      const mockAccountTreeChange = jest.fn();
      messenger.subscribe(
        'AccountTreeController:accountTreeChange',
        mockAccountTreeChange,
      );

      messenger.publish(
        'AccountsController:accountRemoved',
        MOCK_HD_ACCOUNT_1.id,
      );

      expect(mockAccountTreeChange).not.toHaveBeenCalled();
    });
  });

  describe('account ordering by type', () => {
    it('orders accounts in group according to ACCOUNT_TYPE_TO_SORT_ORDER regardless of insertion order', () => {
      const evmAccount = MOCK_HD_ACCOUNT_1;

      const solAccount = {
        ...MOCK_SNAP_ACCOUNT_1,
        id: 'mock-sol-id-1',
        options: {
          ...MOCK_SNAP_ACCOUNT_1.options,
          entropy: {
            ...MOCK_SNAP_ACCOUNT_1.options.entropy,
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex: 0,
            derivationPath: '',
          },
        },
      };

      const tronAccount = MOCK_TRX_ACCOUNT_1;

      const { controller, messenger } = setup({
        accounts: [],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      // Publish in shuffled order: SOL, TRON, EVM
      messenger.publish('AccountsController:accountAdded', solAccount);
      messenger.publish('AccountsController:accountAdded', tronAccount);
      messenger.publish('AccountsController:accountAdded', evmAccount);

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const groupId = toMultichainAccountGroupId(walletId, 0);

      const group =
        controller.state.accountTree.wallets[walletId]?.groups[groupId];
      expect(group).toBeDefined();

      // Account order: EVM (0) < SOL (6) < TRON (7)
      expect(group?.accounts).toStrictEqual([
        'mock-id-1',
        'mock-sol-id-1',
        'mock-trx-id-1',
      ]);
    });
  });

  describe('on AccountsController:accountAdded', () => {
    it('adds an account to the tree', () => {
      // 2 accounts that share the same entropy source (thus, same wallet).
      const mockHdAccount1: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex: 0,
          },
        },
      };
      const mockHdAccount2 = {
        ...MOCK_HD_ACCOUNT_2,
        options: {
          ...MOCK_HD_ACCOUNT_2.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_2.options.entropy,
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex: 0,
          },
        },
      };

      const { controller, messenger } = setup({
        accounts: [mockHdAccount1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      // Create entropy wallets that will both get "Wallet" as base name, then get numbered
      controller.init();

      messenger.publish('AccountsController:accountAdded', mockHdAccount2);

      const walletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const walletId1Group = toMultichainAccountGroupId(
        walletId1,
        mockHdAccount1.options.entropy.groupIndex,
      );
      expect(controller.state).toStrictEqual({
        accountTree: {
          selectedAccountGroup: walletId1Group,
          wallets: {
            [walletId1]: {
              id: walletId1,
              type: AccountWalletType.Entropy,
              status: 'ready',
              groups: {
                [walletId1Group]: {
                  id: walletId1Group,
                  type: AccountGroupType.MultichainAccount,
                  metadata: {
                    name: 'Account 1',
                    entropy: {
                      groupIndex: mockHdAccount1.options.entropy.groupIndex,
                    },
                    pinned: false,
                    hidden: false,
                  },
                  accounts: [mockHdAccount1.id, mockHdAccount2.id], // HD account 2 got added.
                },
              },
              metadata: {
                name: 'Wallet 1',
                entropy: {
                  id: MOCK_HD_KEYRING_1.metadata.id,
                },
              },
            },
          },
        },
        accountGroupsMetadata: {
          // Account groups now get metadata entries during init
          [walletId1Group]: {
            name: {
              value: 'Account 1',
              lastUpdatedAt: expect.any(Number),
            },
            pinned: {
              value: false,
              lastUpdatedAt: 0,
            },
            hidden: {
              value: false,
              lastUpdatedAt: 0,
            },
          },
        },
        accountWalletsMetadata: {},
        isAccountTreeSyncingInProgress: false,
        hasAccountTreeSyncingSyncedAtLeastOnce: false,
      } as AccountTreeControllerState);
    });

    it('adds a new wallet to the tree', () => {
      // 2 accounts that share the same entropy source (thus, same wallet).
      const mockHdAccount1: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex: 0,
          },
        },
      };
      const mockHdAccount2 = {
        ...MOCK_HD_ACCOUNT_2,
        options: {
          ...MOCK_HD_ACCOUNT_2.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_2.options.entropy,
            id: MOCK_HD_KEYRING_2.metadata.id,
            groupIndex: 0,
          },
        },
      };

      const { controller, messenger, mocks } = setup({
        accounts: [mockHdAccount1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      // Create entropy wallets that will both get "Wallet" as base name, then get numbered
      controller.init();

      mocks.KeyringController.keyrings = [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2];
      mocks.AccountsController.accounts = [mockHdAccount1, mockHdAccount2];
      messenger.publish('AccountsController:accountAdded', mockHdAccount2);

      const walletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const walletId1Group = toMultichainAccountGroupId(
        walletId1,
        mockHdAccount1.options.entropy.groupIndex,
      );
      const walletId2 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const walletId2Group = toMultichainAccountGroupId(
        walletId2,
        mockHdAccount2.options.entropy.groupIndex,
      );
      expect(controller.state).toStrictEqual({
        accountTree: {
          wallets: {
            [walletId1]: {
              id: walletId1,
              type: AccountWalletType.Entropy,
              status: 'ready',
              groups: {
                [walletId1Group]: {
                  id: walletId1Group,
                  type: AccountGroupType.MultichainAccount,
                  metadata: {
                    name: 'Account 1',
                    entropy: {
                      groupIndex: mockHdAccount1.options.entropy.groupIndex,
                    },
                    pinned: false,
                    hidden: false,
                  },
                  accounts: [mockHdAccount1.id],
                },
              },
              metadata: {
                name: 'Wallet 1',
                entropy: {
                  id: MOCK_HD_KEYRING_1.metadata.id,
                },
              },
            },
            [walletId2]: {
              // New wallet automatically added.
              id: walletId2,
              type: AccountWalletType.Entropy,
              status: 'ready',
              groups: {
                [walletId2Group]: {
                  id: walletId2Group,
                  type: AccountGroupType.MultichainAccount,
                  metadata: {
                    name: 'Account 1', // Updated: per-wallet naming (different wallet)
                    entropy: {
                      groupIndex: mockHdAccount2.options.entropy.groupIndex,
                    },
                    pinned: false,
                    hidden: false,
                  },
                  accounts: [mockHdAccount2.id],
                },
              },
              metadata: {
                name: 'Wallet 2',
                entropy: {
                  id: MOCK_HD_KEYRING_2.metadata.id,
                },
              },
            },
          },
          selectedAccountGroup: expect.any(String), // Will be set after init
        },
        accountGroupsMetadata: {
          // Both wallets now get metadata entries during init
          [walletId1Group]: {
            name: {
              value: 'Account 1',
              lastUpdatedAt: expect.any(Number),
            },
            pinned: {
              value: false,
              lastUpdatedAt: 0,
            },
            hidden: {
              value: false,
              lastUpdatedAt: 0,
            },
          },
          [walletId2Group]: {
            name: {
              value: 'Account 1', // Per-wallet naming (different wallet)
              lastUpdatedAt: expect.any(Number),
            },
            pinned: {
              value: false,
              lastUpdatedAt: 0,
            },
            hidden: {
              value: false,
              lastUpdatedAt: 0,
            },
          },
        },
        accountWalletsMetadata: {},
        isAccountTreeSyncingInProgress: false,
        hasAccountTreeSyncingSyncedAtLeastOnce: false,
      } as AccountTreeControllerState);
    });

    it('does not add any account if init has not been called', () => {
      const { controller, messenger } = setup();

      expect(controller.state.accountTree.wallets).toStrictEqual({});
      messenger.publish('AccountsController:accountAdded', MOCK_HD_ACCOUNT_1);
      expect(controller.state.accountTree.wallets).toStrictEqual({});
    });
  });

  describe('on MultichainAccountService:walletStatusUpdate', () => {
    it('updates the wallet status accordingly', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });
      controller.init();

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );

      expect(controller.state.accountTree.wallets[walletId]?.status).toBe(
        'ready',
      );

      messenger.publish(
        'MultichainAccountService:walletStatusChange',
        walletId,
        'in-progress:alignment',
      );
      expect(controller.state.accountTree.wallets[walletId]?.status).toBe(
        'in-progress:alignment',
      );

      messenger.publish(
        'MultichainAccountService:walletStatusChange',
        walletId,
        'ready',
      );
      expect(controller.state.accountTree.wallets[walletId]?.status).toBe(
        'ready',
      );
    });
  });

  describe('getAccountWalletObject', () => {
    it('gets a wallet using its ID', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });
      controller.init();

      const walletId = toAccountWalletId(
        AccountWalletType.Entropy,
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const wallet = controller.getAccountWalletObject(walletId);
      expect(wallet).toBeDefined();
    });

    it('gets undefined is wallet ID if not matching any wallet', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });
      controller.init();

      const badGroupId: AccountWalletId = 'entropy:unknown';

      const wallet = controller.getAccountWalletObject(badGroupId);
      expect(wallet).toBeUndefined();
    });
  });

  describe('getAccountWalletObjects', () => {
    it('gets all wallets', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });
      controller.init();

      const wallets = controller.getAccountWalletObjects();
      expect(wallets).toHaveLength(2);
    });
  });

  describe('selectedAccountGroup bidirectional synchronization', () => {
    it('initializes selectedAccountGroup based on currently selected account', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      expect(controller.getSelectedAccountGroup()).not.toBe('');
    });

    it('updates selectedAccountGroup when AccountsController selected account changes', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();
      const initialGroup = controller.getSelectedAccountGroup();

      messenger.publish(
        'AccountsController:selectedAccountChange',
        MOCK_HD_ACCOUNT_2,
      );

      const newGroup = controller.getSelectedAccountGroup();
      expect(newGroup).not.toBe(initialGroup);
    });

    it('updates AccountsController selected account (with EVM account) when selectedAccountGroup changes', () => {
      const { controller, accountTreeControllerMessenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      const setSelectedAccountSpy = jest.spyOn(
        accountTreeControllerMessenger,
        'call',
      );

      controller.init();

      const expectedWalletId2 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const expectedGroupId2 = toMultichainAccountGroupId(
        expectedWalletId2,
        MOCK_HD_ACCOUNT_2.options.entropy.groupIndex,
      );

      controller.setSelectedAccountGroup(expectedGroupId2);

      expect(setSelectedAccountSpy).toHaveBeenCalledWith(
        'AccountsController:setSelectedAccount',
        expect.any(String),
      );
    });

    it('updates AccountsController selected account (with non-EVM account) when selectedAccountGroup changes', () => {
      const nonEvmAccount2 = {
        ...MOCK_SNAP_ACCOUNT_1,
        options: {
          ...MOCK_SNAP_ACCOUNT_1.options,
          entropy: {
            ...MOCK_SNAP_ACCOUNT_1.options.entropy,
            id: MOCK_HD_KEYRING_2.metadata.id, // Wallet 2.
            groupIndex: 0, // Account 1
          },
        },
      } as const;
      const { controller, accountTreeControllerMessenger } = setup({
        accounts: [
          MOCK_HD_ACCOUNT_1,
          nonEvmAccount2, // Wallet 2 > Account 1.
        ],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      const setSelectedAccountSpy = jest.spyOn(
        accountTreeControllerMessenger,
        'call',
      );

      controller.init();

      const expectedWalletId2 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const expectedGroupId2 = toMultichainAccountGroupId(
        expectedWalletId2,
        nonEvmAccount2.options.entropy.groupIndex,
      );

      controller.setSelectedAccountGroup(expectedGroupId2);

      expect(setSelectedAccountSpy).toHaveBeenLastCalledWith(
        'AccountsController:setSelectedAccount',
        nonEvmAccount2.id,
      );
    });

    it('is idempotent - setting same selectedAccountGroup should not trigger AccountsController update', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      const setSelectedAccountSpy = jest.spyOn(messenger, 'call');

      controller.init();

      const expectedWalletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId = toMultichainAccountGroupId(
        expectedWalletId,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      expect(controller.getSelectedAccountGroup()).toBe(expectedGroupId);

      setSelectedAccountSpy.mockClear();

      const initialState = { ...controller.state };

      controller.setSelectedAccountGroup(expectedGroupId);

      expect(setSelectedAccountSpy).not.toHaveBeenCalledWith(
        'AccountsController:setSelectedAccount',
        expect.any(String),
      );

      expect(controller.state).toStrictEqual(initialState);
      expect(controller.getSelectedAccountGroup()).toBe(expectedGroupId);
    });

    it('is idempotent - receiving selectedAccountChange for account in same group should not update state', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      const expectedWalletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId1 = toMultichainAccountGroupId(
        expectedWalletId1,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      controller.setSelectedAccountGroup(expectedGroupId1);

      const initialState = { ...controller.state };

      messenger.publish(
        'AccountsController:selectedAccountChange',
        MOCK_HD_ACCOUNT_1,
      );

      expect(controller.state).toStrictEqual(initialState);
      expect(controller.getSelectedAccountGroup()).toBe(expectedGroupId1);
    });

    it('throws error when trying to select non-existent group', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      expect(() => {
        controller.setSelectedAccountGroup(
          'non-existent-group-id' as AccountGroupId,
        );
      }).toThrow('No accounts found in group: non-existent-group-id');
    });

    it('handles AccountsController selectedAccountChange for account not in tree gracefully', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();
      const initialGroup = controller.getSelectedAccountGroup();

      const unknownAccount: InternalAccount = {
        ...MOCK_HD_ACCOUNT_2,
        id: 'unknown-account-id',
      };

      messenger.publish(
        'AccountsController:selectedAccountChange',
        unknownAccount,
      );

      expect(controller.getSelectedAccountGroup()).toBe(initialGroup);
    });

    it('falls back to first wallet first group when AccountsController returns EMPTY_ACCOUNT', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      // Mock action handler BEFORE init
      mockGetSelectedMultichainAccountActionHandler.mockReturnValue(
        EMPTY_ACCOUNT_MOCK,
      );

      controller.init();

      // Should fall back to first wallet's first group
      const expectedWalletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId1 = toMultichainAccountGroupId(
        expectedWalletId1,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      expect(controller.getSelectedAccountGroup()).toBe(expectedGroupId1);
    });

    it('falls back to first wallet first group when selected account is not in tree', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      // Mock getSelectedMultichainAccount to return an account not in the tree BEFORE init
      const unknownAccount: InternalAccount = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'unknown-account-id',
      };

      mockGetSelectedMultichainAccountActionHandler.mockReturnValue(
        unknownAccount,
      );

      controller.init();

      // Should fall back to first wallet's first group
      const expectedWalletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId1 = toMultichainAccountGroupId(
        expectedWalletId1,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      expect(controller.getSelectedAccountGroup()).toBe(expectedGroupId1);
    });

    it('returns empty string when no wallets exist and getSelectedMultichainAccount returns EMPTY_ACCOUNT', () => {
      const { controller } = setup({
        accounts: [],
        keyrings: [],
      });

      // Mock getSelectedAccount to return EMPTY_ACCOUNT_MOCK (id is '') BEFORE init
      mockGetSelectedMultichainAccountActionHandler.mockReturnValue(
        EMPTY_ACCOUNT_MOCK,
      );

      controller.init();

      // Should return empty string when no wallets exist
      expect(controller.getSelectedAccountGroup()).toBe('');
    });
  });

  describe('account removal and memory management', () => {
    it('cleans up reverse mapping and does not change selectedAccountGroup when removing from non-selected group', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      // Select the first group explicitly
      const expectedWalletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId1 = toMultichainAccountGroupId(
        expectedWalletId1,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );
      controller.setSelectedAccountGroup(expectedGroupId1);

      const initialSelectedGroup = controller.getSelectedAccountGroup();

      // Remove account from the second group (not selected) - tests false branch and reverse cleanup
      messenger.publish(
        'AccountsController:accountRemoved',
        MOCK_HD_ACCOUNT_2.id,
      );

      // selectedAccountGroup should remain unchanged (tests false branch of if condition)
      expect(controller.getSelectedAccountGroup()).toBe(initialSelectedGroup);

      // Test that subsequent selectedAccountChange for removed account is handled gracefully (indirect test of reverse cleanup)
      messenger.publish(
        'AccountsController:selectedAccountChange',
        MOCK_HD_ACCOUNT_2,
      );
      expect(controller.getSelectedAccountGroup()).toBe(initialSelectedGroup);
    });

    it('updates selectedAccountGroup when last account in selected group is removed and other groups exist', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      // Select the first group
      const expectedWalletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId1 = toMultichainAccountGroupId(
        expectedWalletId1,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );
      controller.setSelectedAccountGroup(expectedGroupId1);

      const expectedWalletId2 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const expectedGroupId2 = toMultichainAccountGroupId(
        expectedWalletId2,
        MOCK_HD_ACCOUNT_2.options.entropy.groupIndex,
      );

      // Remove the account from the selected group - tests true branch and findFirstNonEmptyGroup finding a group
      messenger.publish(
        'AccountsController:accountRemoved',
        MOCK_HD_ACCOUNT_1.id,
      );

      // Should automatically switch to the remaining group (tests findFirstNonEmptyGroup returning a group)
      expect(controller.getSelectedAccountGroup()).toBe(expectedGroupId2);
    });

    it('sets selectedAccountGroup to empty when no non-empty groups exist', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      // Remove the only account - tests findFirstNonEmptyGroup returning empty string
      messenger.publish(
        'AccountsController:accountRemoved',
        MOCK_HD_ACCOUNT_1.id,
      );

      // Should fall back to empty string when no groups have accounts
      expect(controller.getSelectedAccountGroup()).toBe('');
    });

    it('handles removal gracefully when account is not found in reverse mapping', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();
      const initialState = { ...controller.state };

      // Try to remove an account that was never added
      const unknownAccountId = 'unknown-account-id';
      messenger.publish('AccountsController:accountRemoved', unknownAccountId);

      // State should remain unchanged
      expect(controller.state).toStrictEqual(initialState);
    });

    it('handles edge cases gracefully in account removal', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      expect(() => {
        messenger.publish(
          'AccountsController:accountRemoved',
          'non-existent-account',
        );
      }).not.toThrow();

      expect(controller.getSelectedAccountGroup()).not.toBe('');
    });
  });

  describe('Persistence - Custom Names', () => {
    it('persists custom account group names across init calls', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      const expectedWalletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId1 = toMultichainAccountGroupId(
        expectedWalletId1,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      const customName = 'My Custom Trading Group';
      controller.setAccountGroupName(expectedGroupId1, customName);

      // Re-init to test persistence
      controller.reinit();

      const wallet = controller.state.accountTree.wallets[expectedWalletId1];
      const group = wallet?.groups[expectedGroupId1];
      expect(group?.metadata.name).toBe(customName);

      expect(
        controller.state.accountGroupsMetadata[expectedGroupId1],
      ).toStrictEqual({
        name: {
          value: customName,
          lastUpdatedAt: expect.any(Number),
        },
        pinned: {
          value: false,
          lastUpdatedAt: 0,
        },
        hidden: {
          value: false,
          lastUpdatedAt: 0,
        },
      });
    });

    it('persists custom account wallet names across init calls', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      const expectedWalletId1 = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );

      const customName = 'My Primary Wallet';
      controller.setAccountWalletName(expectedWalletId1, customName);

      controller.reinit();

      const wallet = controller.state.accountTree.wallets[expectedWalletId1];
      expect(wallet?.metadata.name).toBe(customName);

      expect(
        controller.state.accountWalletsMetadata[expectedWalletId1],
      ).toStrictEqual({
        name: {
          value: customName,
          lastUpdatedAt: expect.any(Number),
        },
      });
    });

    it('custom names take priority over default rule-generated names', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const expectedWalletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId = toMultichainAccountGroupId(
        expectedWalletId,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      // Check default names
      const walletBeforeCustom =
        controller.state.accountTree.wallets[expectedWalletId];
      const groupBeforeCustom = walletBeforeCustom?.groups[expectedGroupId];
      const defaultWalletName = walletBeforeCustom?.metadata.name;
      const defaultGroupName = groupBeforeCustom?.metadata.name;

      // Set custom names
      const customWalletName = 'Custom Wallet Name';
      const customGroupName = 'Custom Group Name';
      controller.setAccountWalletName(expectedWalletId, customWalletName);
      controller.setAccountGroupName(expectedGroupId, customGroupName);

      // Verify custom names override defaults
      const walletAfterCustom =
        controller.state.accountTree.wallets[expectedWalletId];
      const groupAfterCustom = walletAfterCustom?.groups[expectedGroupId];

      expect(walletAfterCustom?.metadata.name).toBe(customWalletName);
      expect(walletAfterCustom?.metadata.name).not.toBe(defaultWalletName);
      expect(groupAfterCustom?.metadata.name).toBe(customGroupName);
      expect(groupAfterCustom?.metadata.name).not.toBe(defaultGroupName);
    });

    it('updates lastUpdatedAt when setting custom names', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const expectedWalletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId = toMultichainAccountGroupId(
        expectedWalletId,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      const beforeTime = Date.now();

      controller.setAccountWalletName(expectedWalletId, 'Test Wallet');
      controller.setAccountGroupName(expectedGroupId, 'Test Group');

      const afterTime = Date.now();

      const walletMetadata =
        controller.state.accountWalletsMetadata[expectedWalletId];
      const groupMetadata =
        controller.state.accountGroupsMetadata[expectedGroupId];

      expect(walletMetadata?.name?.lastUpdatedAt).toBeGreaterThanOrEqual(
        beforeTime,
      );
      expect(walletMetadata?.name?.lastUpdatedAt).toBeLessThanOrEqual(
        afterTime,
      );
      expect(groupMetadata?.name?.lastUpdatedAt).toBeGreaterThanOrEqual(
        beforeTime,
      );
      expect(groupMetadata?.name?.lastUpdatedAt).toBeLessThanOrEqual(afterTime);
    });
  });

  describe('Persistence - Pinning and Hiding', () => {
    it('persists account group pinned state across init calls', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const expectedWalletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId = toMultichainAccountGroupId(
        expectedWalletId,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      // Set pinned state
      controller.setAccountGroupPinned(expectedGroupId, true);

      // Re-init to test persistence
      controller.reinit();

      // Verify pinned state persists
      expect(
        controller.state.accountGroupsMetadata[expectedGroupId],
      ).toStrictEqual({
        name: {
          value: 'Account 1', // Name now generated during init
          lastUpdatedAt: expect.any(Number),
        },
        pinned: {
          value: true,
          lastUpdatedAt: expect.any(Number),
        },
        hidden: {
          value: false,
          lastUpdatedAt: 0,
        },
      });
    });

    it('persists account group hidden state across init calls', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const expectedWalletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId = toMultichainAccountGroupId(
        expectedWalletId,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      // Set hidden state
      controller.setAccountGroupHidden(expectedGroupId, true);

      // Re-init to test persistence
      controller.reinit();

      // Verify hidden state persists
      expect(
        controller.state.accountGroupsMetadata[expectedGroupId],
      ).toStrictEqual({
        name: {
          value: 'Account 1', // Name now generated during init
          lastUpdatedAt: expect.any(Number),
        },
        pinned: {
          value: false,
          lastUpdatedAt: 0,
        },
        hidden: {
          value: true,
          lastUpdatedAt: expect.any(Number),
        },
      });
    });

    it('updates lastUpdatedAt when setting pinned/hidden state', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const expectedWalletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId = toMultichainAccountGroupId(
        expectedWalletId,
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      const beforeTime = Date.now();

      controller.setAccountGroupPinned(expectedGroupId, true);

      const afterTime = Date.now();

      const groupMetadata =
        controller.state.accountGroupsMetadata[expectedGroupId];
      expect(groupMetadata?.pinned?.lastUpdatedAt).toBeGreaterThanOrEqual(
        beforeTime,
      );
      expect(groupMetadata?.pinned?.lastUpdatedAt).toBeLessThanOrEqual(
        afterTime,
      );
    });
  });

  describe('Persistence - State Structure', () => {
    it('initializes with empty metadata maps', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      expect(controller.state.accountGroupsMetadata).toStrictEqual({});
      expect(controller.state.accountWalletsMetadata).toStrictEqual({});
    });

    it('preserves existing metadata when initializing with partial state', () => {
      const existingGroupMetadata = {
        'test-group-id': {
          name: {
            value: 'Existing Group',
            lastUpdatedAt: 123456789,
          },
          pinned: {
            value: true,
            lastUpdatedAt: 123456789,
          },
        },
      };
      const existingWalletMetadata = {
        'test-wallet-id': {
          name: {
            value: 'Existing Wallet',
            lastUpdatedAt: 123456789,
          },
        },
      };

      const { controller } = setup({
        state: {
          accountGroupsMetadata: existingGroupMetadata,
          accountWalletsMetadata: existingWalletMetadata,
        },
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      expect(controller.state.accountGroupsMetadata).toStrictEqual(
        existingGroupMetadata,
      );
      expect(controller.state.accountWalletsMetadata).toStrictEqual(
        existingWalletMetadata,
      );
    });

    it('throws error when setting metadata for non-existent groups/wallets', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const nonExistentGroupId = 'non-existent-group-id' as AccountGroupId;
      const nonExistentWalletId = 'non-existent-wallet-id' as AccountWalletId;

      // Should throw for non-existent group operations
      expect(() => {
        controller.setAccountGroupName(nonExistentGroupId, 'Test Name');
      }).toThrow(
        `Account group with ID "${nonExistentGroupId}" not found in tree`,
      );

      expect(() => {
        controller.setAccountGroupPinned(nonExistentGroupId, true);
      }).toThrow(
        `Account group with ID "${nonExistentGroupId}" not found in tree`,
      );

      expect(() => {
        controller.setAccountGroupHidden(nonExistentGroupId, true);
      }).toThrow(
        `Account group with ID "${nonExistentGroupId}" not found in tree`,
      );

      // Should throw for non-existent wallet operations
      expect(() => {
        controller.setAccountWalletName(nonExistentWalletId, 'Test Wallet');
      }).toThrow(
        `Account wallet with ID "${nonExistentWalletId}" not found in tree`,
      );

      // Metadata should NOT be stored since the operations threw
      expect(
        controller.state.accountGroupsMetadata[nonExistentGroupId],
      ).toBeUndefined();
      expect(
        controller.state.accountWalletsMetadata[nonExistentWalletId],
      ).toBeUndefined();
    });

    it('allows setting the same name for the same group', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const wallets = controller.getAccountWalletObjects();
      const groups = Object.values(wallets[0].groups);
      const groupId = groups[0].id;

      const customName = 'My Custom Group';

      // Set the name first time - should succeed
      controller.setAccountGroupName(groupId, customName);

      // Set the same name again for the same group - should succeed
      expect(() => {
        controller.setAccountGroupName(groupId, customName);
      }).not.toThrow();
    });

    it('allows duplicate names across different wallets', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      const wallets = controller.getAccountWalletObjects();

      // We should have 2 wallets (one for each keyring)
      expect(wallets).toHaveLength(2);

      const wallet1 = wallets[0];
      const wallet2 = wallets[1];
      const groups1 = Object.values(wallet1.groups);
      const groups2 = Object.values(wallet2.groups);

      expect(groups1.length).toBeGreaterThanOrEqual(1);
      expect(groups2.length).toBeGreaterThanOrEqual(1);

      const groupId1 = groups1[0].id;
      const groupId2 = groups2[0].id;
      const duplicateName = 'Duplicate Group Name';

      // Set name for first group - should succeed
      controller.setAccountGroupName(groupId1, duplicateName);

      // Set the same name for second group in different wallet - should succeed
      expect(() => {
        controller.setAccountGroupName(groupId2, duplicateName);
      }).not.toThrow();
    });

    it('ensures unique names when generating default names', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const wallets = controller.getAccountWalletObjects();
      const groups = Object.values(wallets[0].groups);

      // All groups should have unique names by default
      const names = groups.map((group) => group.metadata.name);
      const uniqueNames = new Set(names);

      expect(uniqueNames.size).toBe(names.length);
      expect(names.every((name) => name.length > 0)).toBe(true);
    });

    it('allows duplicate names with different spacing across different wallets', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      controller.init();

      const wallets = controller.getAccountWalletObjects();
      expect(wallets).toHaveLength(2);

      const wallet1 = wallets[0];
      const wallet2 = wallets[1];
      const groups1 = Object.values(wallet1.groups);
      const groups2 = Object.values(wallet2.groups);

      expect(groups1.length).toBeGreaterThanOrEqual(1);
      expect(groups2.length).toBeGreaterThanOrEqual(1);

      const groupId1 = groups1[0].id;
      const groupId2 = groups2[0].id;

      // Set name for first group with trailing spaces
      const nameWithSpaces = '  My Group Name  ';
      controller.setAccountGroupName(groupId1, nameWithSpaces);

      // Set the same name for second group with different spacing in different wallet - should succeed
      const nameWithDifferentSpacing = ' My Group Name ';
      expect(() => {
        controller.setAccountGroupName(groupId2, nameWithDifferentSpacing);
      }).not.toThrow();
    });

    it('prevents duplicate names within the same wallet', () => {
      // Create two accounts with the same entropy source to ensure they're in the same wallet
      const mockAccount1: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'mock-id-1',
        address: '0x123',
        options: {
          entropy: {
            type: KeyringAccountEntropyTypeOption.Mnemonic,
            id: 'mock-keyring-id-1',
            groupIndex: 0,
            derivationPath: '',
          },
        },
      };

      const mockAccount2: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_2,
        id: 'mock-id-2',
        address: '0x456',
        options: {
          entropy: {
            type: KeyringAccountEntropyTypeOption.Mnemonic,
            id: 'mock-keyring-id-1', // Same entropy ID as account1
            groupIndex: 1, // Different group index to create separate groups
            derivationPath: '',
          },
        },
      };

      const { controller } = setup({
        accounts: [mockAccount1, mockAccount2],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const wallets = controller.getAccountWalletObjects();
      expect(wallets).toHaveLength(1);

      const wallet = wallets[0];
      const groups = Object.values(wallet.groups);

      expect(groups.length).toBeGreaterThanOrEqual(2);

      const groupId1 = groups[0].id;
      const groupId2 = groups[1].id;
      const duplicateName = 'Duplicate Group Name';

      // Set name for first group - should succeed
      controller.setAccountGroupName(groupId1, duplicateName);

      // Try to set the same name for second group in same wallet - should throw
      expect(() => {
        controller.setAccountGroupName(groupId2, duplicateName);
      }).toThrow('Account group name already exists');
    });

    it('throws error for non-existent group ID', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      // Test the isAccountGroupNameUnique function directly with a non-existent group ID
      expect(() => {
        isAccountGroupNameUnique(
          controller.state,
          'non-existent-group-id' as AccountGroupId,
          'Some Name',
        );
      }).toThrow(
        'Account group with ID "non-existent-group-id" not found in tree',
      );
    });
  });

  describe('Fallback Naming', () => {
    it('uses consistent default naming regardless of account import time', () => {
      const mockAccount1: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex: 0,
          },
        },
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          importTime: Date.now() + 1000,
        },
      };

      const mockAccount2: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_2,
        options: {
          ...MOCK_HD_ACCOUNT_2.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_2.options.entropy,
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex: 1,
          },
        },
        metadata: {
          ...MOCK_HD_ACCOUNT_2.metadata,
          importTime: Date.now() - 1000,
        },
      };

      const { controller } = setup({
        accounts: [mockAccount2, mockAccount1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const expectedWalletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );

      const expectedGroupId1 = toMultichainAccountGroupId(
        expectedWalletId,
        mockAccount1.options.entropy.groupIndex,
      );

      const expectedGroupId2 = toMultichainAccountGroupId(
        expectedWalletId,
        mockAccount2.options.entropy.groupIndex,
      );

      const wallet = controller.state.accountTree.wallets[expectedWalletId];
      const group1 = wallet?.groups[expectedGroupId1];
      const group2 = wallet?.groups[expectedGroupId2];

      // Groups should use consistent default naming regardless of import time
      // Updated expectations based on per-wallet sequential naming logic
      expect(group1?.metadata.name).toBe('Account 2'); // Updated: reflects actual naming logic
      expect(group2?.metadata.name).toBe('Account 1'); // Updated: reflects actual naming logic
    });

    it('uses fallback naming when rule-based naming returns empty string', () => {
      // Create accounts with empty names to trigger fallback naming
      const mockAccountWithEmptyName1: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'account-1',
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: '', // Empty name will cause rule-based naming to fail
        },
      };

      const mockAccountWithEmptyName2: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'account-2',
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            groupIndex: 1, // Different group index
          },
        },
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: '', // Empty name will cause rule-based naming to fail
        },
      };

      const { controller } = setup({
        accounts: [mockAccountWithEmptyName1, mockAccountWithEmptyName2],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const expectedWalletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );

      const expectedGroupId1 = toMultichainAccountGroupId(
        expectedWalletId,
        0, // First group
      );

      const expectedGroupId2 = toMultichainAccountGroupId(
        expectedWalletId,
        1, // Second group
      );

      const wallet = controller.state.accountTree.wallets[expectedWalletId];
      const group1 = wallet?.groups[expectedGroupId1];
      const group2 = wallet?.groups[expectedGroupId2];

      // Verify fallback naming: "Account 1", "Account 2" within the same wallet
      expect(group1?.metadata.name).toBe('Account 1');
      expect(group2?.metadata.name).toBe('Account 2');
    });

    it('handles adding new accounts to existing groups correctly', () => {
      // Create an existing account
      const existingAccount: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'existing-account',
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex: 0,
          },
        },
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: '', // Empty name to trigger naming logic
          importTime: Date.now() - 1000,
        },
      };

      // Create a new account for the same group
      const newAccount: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'new-account',
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            id: MOCK_HD_KEYRING_1.metadata.id,
            groupIndex: 0, // Same group as existing account
          },
        },
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: '', // Empty name to trigger naming logic
          importTime: Date.now() + 1000,
        },
      };

      const { controller, messenger, mocks } = setup({
        accounts: [existingAccount],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      // Add the new account to the existing group
      mocks.AccountsController.accounts = [existingAccount, newAccount];
      messenger.publish('AccountsController:accountAdded', newAccount);

      const expectedWalletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId = toMultichainAccountGroupId(
        expectedWalletId,
        0, // Same group index
      );

      const wallet = controller.state.accountTree.wallets[expectedWalletId];
      const group = wallet?.groups[expectedGroupId];

      // The group should use consistent default naming
      expect(group?.metadata.name).toBe('Account 1');
      expect(group?.accounts).toHaveLength(2);
      expect(group?.accounts).toContain(existingAccount.id);
      expect(group?.accounts).toContain(newAccount.id);
    });

    it('uses default naming when rule-based naming returns empty', () => {
      // Create an account with empty name to trigger fallback to default naming
      const mockAccountWithEmptyName: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'account-with-empty-name',
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: '',
          importTime: Date.now() - 1000,
        },
      };

      const { controller } = setup({
        accounts: [mockAccountWithEmptyName],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const expectedWalletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const expectedGroupId = toMultichainAccountGroupId(expectedWalletId, 0);

      const wallet = controller.state.accountTree.wallets[expectedWalletId];
      const group = wallet?.groups[expectedGroupId];

      // Should use computed name first, then fallback to default
      // Since the account has empty name, computed name will be empty, so it falls back to default
      expect(group?.metadata.name).toBe('Account 1');
    });

    describe('Computed Account Group Name', () => {
      const mockSolAccount: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'solana-account-id',
        type: SolAccountType.DataAccount,
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: 'Solana Account 2', // This will become the group name
          importTime: Date.now() - 1000, // Old account
        },
      };

      const mockEvmAccount: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'evm-account-id',
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: 'My EVM Account', // This should become the group name
          importTime: Date.now() - 1000, // Old account
        },
      };

      const mockBtcAccount: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'bitcoin-account-id',
        type: BtcAccountType.P2wpkh,
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: 'Bitcoin Account 1', // This should NOT become the group name
          importTime: Date.now() - 1000, // Old account
        },
      };

      it('also considers chain-specific names like "Solana Account 2" to be used as group names', () => {
        const { controller } = setup({
          accounts: [mockSolAccount],
          keyrings: [MOCK_HD_KEYRING_1],
        });

        controller.init();

        const expectedWalletId = toMultichainAccountWalletId(
          MOCK_HD_KEYRING_1.metadata.id,
        );
        const expectedGroupId = toMultichainAccountGroupId(expectedWalletId, 0);

        const wallet = controller.state.accountTree.wallets[expectedWalletId];
        const group = wallet?.groups[expectedGroupId];

        // The group should use the computed name from the Solana account.
        expect(group?.metadata.name).toBe(mockSolAccount.metadata.name);
      });

      it('uses EVM account names over any other names', () => {
        const { controller } = setup({
          accounts: [mockSolAccount, mockEvmAccount, mockBtcAccount],
          keyrings: [MOCK_HD_KEYRING_1],
        });

        controller.init();

        const expectedWalletId = toMultichainAccountWalletId(
          MOCK_HD_KEYRING_1.metadata.id,
        );
        const expectedGroupId = toMultichainAccountGroupId(expectedWalletId, 0);

        const wallet = controller.state.accountTree.wallets[expectedWalletId];
        const group = wallet?.groups[expectedGroupId];

        // The group should use the computed name from the EVM account, even if there's a Solana
        // account custom name.
        expect(group?.metadata.name).toBe(mockEvmAccount.metadata.name);
      });

      it('uses the first non-EVM account name when there is no EVM account', () => {
        const { controller } = setup({
          accounts: [mockSolAccount, mockBtcAccount],
          keyrings: [MOCK_HD_KEYRING_1],
        });

        controller.init();

        const expectedWalletId = toMultichainAccountWalletId(
          MOCK_HD_KEYRING_1.metadata.id,
        );
        const expectedGroupId = toMultichainAccountGroupId(expectedWalletId, 0);

        const wallet = controller.state.accountTree.wallets[expectedWalletId];
        const group = wallet?.groups[expectedGroupId];

        // The group should use the computed name from the Solana account since it
        // is the first non-EVM account that has a valid account name (and that
        // no EVM account is present in that group).
        expect(group?.metadata.name).toBe(mockSolAccount.metadata.name);
      });
    });

    it('ensures consistent per-wallet numbering for multiple SRPs', () => {
      // This test reproduces a bug scenario where multiple SRPs
      // showed incorrect numbering like "Account 2, 2, 3, 4..."

      // Setup first SRP with multiple accounts
      const srp1Keyring: KeyringObject = {
        ...MOCK_HD_KEYRING_1,
        metadata: { ...MOCK_HD_KEYRING_1.metadata, id: 'srp1-id' },
      };

      const srp1Accounts: Bip44Account<InternalAccount>[] = [];
      for (let i = 0; i < 5; i++) {
        srp1Accounts.push({
          ...MOCK_HD_ACCOUNT_1,
          id: `srp1-account-${i}`,
          address: `0x1${i}`,
          metadata: {
            ...MOCK_HD_ACCOUNT_1.metadata,
            name: '', // Empty to force default naming
          },
          options: {
            ...MOCK_HD_ACCOUNT_1.options,
            entropy: {
              type: 'mnemonic',
              id: 'srp1-id',
              derivationPath: `m/44'/60'/${i}'/0/0`,
              groupIndex: i,
            },
          },
        });
      }

      // Setup second SRP with multiple accounts
      const srp2Keyring: KeyringObject = {
        ...MOCK_HD_KEYRING_2,
        metadata: { ...MOCK_HD_KEYRING_2.metadata, id: 'srp2-id' },
      };

      const srp2Accounts: Bip44Account<InternalAccount>[] = [];
      for (let i = 0; i < 3; i++) {
        srp2Accounts.push({
          ...MOCK_HD_ACCOUNT_2,
          id: `srp2-account-${i}`,
          address: `0x2${i}`,
          metadata: {
            ...MOCK_HD_ACCOUNT_2.metadata,
            name: '', // Empty to force default naming
          },
          options: {
            ...MOCK_HD_ACCOUNT_2.options,
            entropy: {
              type: 'mnemonic',
              id: 'srp2-id',
              derivationPath: `m/44'/60'/${i}'/0/0`,
              groupIndex: i,
            },
          },
        });
      }

      const { controller } = setup({
        accounts: [...srp1Accounts, ...srp2Accounts],
        keyrings: [srp1Keyring, srp2Keyring],
      });

      controller.init();

      const { state } = controller;

      // Verify first SRP has correct sequential naming
      const wallet1Id = toMultichainAccountWalletId('srp1-id');
      const wallet1 = state.accountTree.wallets[wallet1Id];

      expect(wallet1).toBeDefined();

      // Get groups in order by their groupIndex
      const wallet1Groups = [
        wallet1.groups[toMultichainAccountGroupId(wallet1Id, 0)],
        wallet1.groups[toMultichainAccountGroupId(wallet1Id, 1)],
        wallet1.groups[toMultichainAccountGroupId(wallet1Id, 2)],
        wallet1.groups[toMultichainAccountGroupId(wallet1Id, 3)],
        wallet1.groups[toMultichainAccountGroupId(wallet1Id, 4)],
      ];

      expect(wallet1Groups).toHaveLength(5);
      expect(wallet1Groups[0].metadata.name).toBe('Account 1');
      expect(wallet1Groups[1].metadata.name).toBe('Account 2');
      expect(wallet1Groups[2].metadata.name).toBe('Account 3');
      expect(wallet1Groups[3].metadata.name).toBe('Account 4');
      expect(wallet1Groups[4].metadata.name).toBe('Account 5');

      // Verify second SRP ALSO starts from Account 1 (independent numbering per wallet)
      const wallet2Id = toMultichainAccountWalletId('srp2-id');
      const wallet2 = state.accountTree.wallets[wallet2Id];

      expect(wallet2).toBeDefined();

      // Get groups in order by their groupIndex
      const wallet2Groups = [
        wallet2.groups[toMultichainAccountGroupId(wallet2Id, 0)],
        wallet2.groups[toMultichainAccountGroupId(wallet2Id, 1)],
        wallet2.groups[toMultichainAccountGroupId(wallet2Id, 2)],
      ];

      expect(wallet2Groups).toHaveLength(3);
      expect(wallet2Groups[0].metadata.name).toBe('Account 1');
      expect(wallet2Groups[1].metadata.name).toBe('Account 2');
      expect(wallet2Groups[2].metadata.name).toBe('Account 3');

      // Verify second SRP starts from Account 1 independently
      expect(wallet1Groups[0].metadata.name).toBe('Account 1');
      expect(wallet2Groups[0].metadata.name).toBe('Account 1');
    });

    it('handles account naming correctly after app restart', () => {
      // This test verifies that account names remain consistent after restart
      // and don't change from "Account 1" to "Account 2" etc.

      // Create two accounts in the same wallet but different groups
      const account1: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'account-1',
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: '', // Empty name to force default naming
        },
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            groupIndex: 0,
          },
        },
      };

      const account2: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'account-2',
        address: '0x456',
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: '', // Empty name to force default naming
        },
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            groupIndex: 1,
          },
        },
      };

      const { controller, messenger } = setup({
        accounts: [account1, account2],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      // First init - accounts get named
      controller.init();

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const group1Id = toMultichainAccountGroupId(walletId, 0);
      const group2Id = toMultichainAccountGroupId(walletId, 1);

      // Check initial names (both groups use entropy.groupIndex)
      const state1 = controller.state;
      const wallet1 = state1.accountTree.wallets[walletId];
      expect(wallet1.groups[group1Id].metadata.name).toBe('Account 1'); // groupIndex 0 → Account 1
      expect(wallet1.groups[group2Id].metadata.name).toBe('Account 2'); // groupIndex 1 → Account 2

      // Simulate app restart by re-initializing
      controller.reinit();

      // Names should remain the same (consistent entropy.groupIndex)
      const state2 = controller.state;
      const wallet2 = state2.accountTree.wallets[walletId];
      expect(wallet2.groups[group1Id].metadata.name).toBe('Account 1');
      expect(wallet2.groups[group2Id].metadata.name).toBe('Account 2');

      // Add a new account after restart
      const newAccount: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'new-account',
        address: '0xNEW',
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: '', // Empty to force default naming
        },
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            type: 'mnemonic',
            id: MOCK_HD_KEYRING_1.metadata.id,
            derivationPath: "m/44'/60'/2'/0/0",
            groupIndex: 2,
          },
        },
      };

      messenger.publish('AccountsController:accountAdded', newAccount);

      // New account should get Account 3, not duplicate an existing name
      const group3Id = toMultichainAccountGroupId(walletId, 2);
      const state3 = controller.state;
      const wallet3 = state3.accountTree.wallets[walletId];
      expect(wallet3.groups[group3Id].metadata.name).toBe('Account 3');

      // All names should be different
      const allNames = [
        wallet3.groups[group1Id].metadata.name,
        wallet3.groups[group2Id].metadata.name,
        wallet3.groups[group3Id].metadata.name,
      ];
      const uniqueNames = new Set(allNames);
      expect(uniqueNames.size).toBe(3); // All names should be unique
    });

    it('prevents alphabetical sorting duplicates for hardware wallet accounts', () => {
      // Create account 0xbbb -> Account 1
      // Create account 0xaaa -> Should get Account 2 (not duplicate Account 1 from alphabetical sorting)

      const hardwareAccount1: InternalAccount = {
        ...MOCK_HARDWARE_ACCOUNT_1,
        id: 'hardware-bbb',
        address: '0xbbb', // Will come AFTER 0xaaa in alphabetical order
        metadata: {
          ...MOCK_HARDWARE_ACCOUNT_1.metadata,
          name: '', // Force default naming
        },
      };

      const hardwareAccount2: InternalAccount = {
        ...MOCK_HARDWARE_ACCOUNT_1,
        id: 'hardware-aaa',
        address: '0xaaa', // Will come BEFORE 0xbbb in alphabetical order
        metadata: {
          ...MOCK_HARDWARE_ACCOUNT_1.metadata,
          name: '', // Force default naming
        },
      };

      // Create both accounts at once to test the naming logic
      const { controller } = setup({
        accounts: [hardwareAccount1, hardwareAccount2], // 0xbbb first, then 0xaaa
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const walletId = toAccountWalletId(
        AccountWalletType.Keyring,
        KeyringTypes.ledger,
      );

      const wallet = controller.state.accountTree.wallets[walletId];
      expect(wallet).toBeDefined();

      // Get both groups
      const group1Id = toAccountGroupId(walletId, hardwareAccount1.address);
      const group2Id = toAccountGroupId(walletId, hardwareAccount2.address);

      const group1 = wallet.groups[group1Id];
      const group2 = wallet.groups[group2Id];

      expect(group1).toBeDefined();
      expect(group2).toBeDefined();

      // The key test: both should have unique names despite alphabetical address ordering
      // With old alphabetical sorting: both would get "Account 1" (duplicate)
      // With new logic: should get sequential unique names (optimization starts at wallet.length-1)

      const allNames = [group1.metadata.name, group2.metadata.name];
      const uniqueNames = new Set(allNames);

      // Critical assertion: should have 2 unique names (no duplicates)
      expect(uniqueNames.size).toBe(2);

      // Due to optimization, names start at wallet.length, so we get "Account 3" and "Account 4"
      expect(allNames).toContain('Ledger Account 1');
      expect(allNames).toContain('Ledger Account 2');

      // Verify they're actually different
      expect(group1.metadata.name).not.toBe(group2.metadata.name);
    });

    it('handles naming conflicts when user renames entropy groups', () => {
      // This test covers the following conflict scenario:
      // 1. Create multichain account -> "Account 1"
      // 2. User renames it to "Account 2"
      // 3. Create 2nd multichain account -> Should be "Account 3" (not duplicate "Account 2")

      const account1: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'account-1',
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: '', // Empty to force default naming
        },
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            groupIndex: 0, // Would normally be "Account 1"
          },
        },
      };

      const account2: Bip44Account<InternalAccount> = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'account-2',
        address: '0x456',
        metadata: {
          ...MOCK_HD_ACCOUNT_1.metadata,
          name: '', // Empty to force default naming
        },
        options: {
          ...MOCK_HD_ACCOUNT_1.options,
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            groupIndex: 1, // Would normally be "Account 2"
          },
        },
      };

      const { controller } = setup({
        accounts: [account1, account2],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const group1Id = toMultichainAccountGroupId(walletId, 0);
      const group2Id = toMultichainAccountGroupId(walletId, 1);

      // Step 1: Verify initial names (conflict resolution already working)
      const state1 = controller.state;
      expect(
        state1.accountTree.wallets[walletId].groups[group1Id].metadata.name,
      ).toBe('Account 1');
      expect(
        state1.accountTree.wallets[walletId].groups[group2Id].metadata.name,
      ).toBe('Account 2');

      // Step 2: User renames first group to "Custom Name" (to avoid initial conflict)
      controller.setAccountGroupName(group1Id, 'Custom Name');

      // Step 3: Re-initialize (simulate app restart)
      controller.reinit();

      // Step 4: Verify the second group gets its proper name without conflict
      const state2 = controller.state;
      const wallet = state2.accountTree.wallets[walletId];

      // First group should keep user's custom name
      expect(wallet.groups[group1Id].metadata.name).toBe('Custom Name');

      // Second group should get its natural "Account 2" since no conflict
      expect(wallet.groups[group2Id].metadata.name).toBe('Account 2');

      // Verify no duplicates
      expect(wallet.groups[group1Id].metadata.name).not.toBe(
        wallet.groups[group2Id].metadata.name,
      );
    });

    it('validates starting point optimization logic for conflict resolution', () => {
      // Starting with wallet.length instead of 0 avoids unnecessary iterations
      // when checking for name conflicts

      // Test the optimization logic directly
      const mockWallet = {
        groups: {
          'group-1': { id: 'group-1', metadata: { name: 'My Account' } },
          'group-2': { id: 'group-2', metadata: { name: 'Account 3' } },
        },
      };

      // Simulate the optimization: start with Object.keys(wallet.groups).length
      const startingPoint = Object.keys(mockWallet.groups).length; // = 2
      expect(startingPoint).toBe(2);

      // This means we'd start checking "Account 3" instead of "Account 1"
      // Since "My Account" and "Account 3" exist, we'll increment to "Account 4"
      const mockRule = {
        getDefaultAccountGroupName: (index: number) => `Account ${index + 1}`,
      };

      const proposedName = mockRule.getDefaultAccountGroupName(startingPoint);
      expect(proposedName).toBe('Account 3');

      // Verify this name conflicts (since "Account 3" already exists)
      const nameExists = Object.values(mockWallet.groups).some(
        (g) => g.metadata.name === proposedName,
      );
      expect(nameExists).toBe(true); // Should conflict

      // The while loop would increment to find "Account 4" which would be unique
      const nextProposedName = mockRule.getDefaultAccountGroupName(
        startingPoint + 1,
      );
      expect(nextProposedName).toBe('Account 4');

      const nextNameExists = Object.values(mockWallet.groups).some(
        (g) => g.metadata.name === nextProposedName,
      );
      expect(nextNameExists).toBe(false); // Should be unique
    });

    it('thoroughly tests different naming patterns for wallet types', () => {
      // Test that the dynamic pattern detection works for different rule types
      // (Even though we don't have different patterns yet, this proves the logic works)

      const mockRule = {
        getDefaultAccountGroupName: (index: number) =>
          `Custom Pattern ${index + 1}`,
        getComputedAccountGroupName: () => '',
      };

      // Test the pattern detection logic would work
      const sampleName = mockRule.getDefaultAccountGroupName(0); // "Custom Pattern 1"
      const pattern = sampleName.replace('1', '\\d+'); // "Custom Pattern \d+"
      const regex = new RegExp(`^${pattern}$`, 'u');

      // Verify pattern matching works
      expect(regex.test('Custom Pattern 1')).toBe(true);
      expect(regex.test('Custom Pattern 2')).toBe(true);
      expect(regex.test('Custom Pattern 10')).toBe(true);
      expect(regex.test('Account 1')).toBe(false); // Different pattern
      expect(regex.test('Custom Pattern')).toBe(false); // Missing number

      // Test number extraction
      // Test pattern extraction logic with sample names
      // "Custom Pattern 1" -> 0, "Custom Pattern 5" -> 4, "Custom Pattern 10" -> 9
      const extractedNumbers = [0, 4, 9];

      expect(extractedNumbers).toStrictEqual([0, 4, 9]); // Proves extraction works
    });
  });

  describe('Computed names', () => {
    const mockHdAccount1: Bip44Account<InternalAccount> = {
      ...MOCK_HD_ACCOUNT_1,
      options: {
        ...MOCK_HD_ACCOUNT_1.options,
        entropy: {
          ...MOCK_HD_ACCOUNT_1.options.entropy,
          id: MOCK_HD_KEYRING_1.metadata.id,
          groupIndex: 0,
        },
      },
    };

    const mockHdAccount2: Bip44Account<InternalAccount> = {
      ...MOCK_HD_ACCOUNT_2,
      options: {
        ...MOCK_HD_ACCOUNT_2.options,
        entropy: {
          ...MOCK_HD_ACCOUNT_2.options.entropy,
          id: MOCK_HD_KEYRING_1.metadata.id,
          groupIndex: 1,
        },
      },
    };

    const mockSolAccount1: Bip44Account<InternalAccount> = {
      ...MOCK_HD_ACCOUNT_1,
      id: 'mock-sol-id-1',
      type: SolAccountType.DataAccount,
      options: {
        ...MOCK_HD_ACCOUNT_1.options,
        entropy: {
          ...MOCK_HD_ACCOUNT_1.options.entropy,
          id: MOCK_HD_KEYRING_1.metadata.id,
          groupIndex: 0,
        },
      },
      metadata: {
        ...MOCK_HD_ACCOUNT_1.metadata,
        snap: {
          enabled: true,
          id: MOCK_SNAP_1.id,
          name: MOCK_SNAP_1.name,
        },
      },
    };

    const expectedWalletId = toMultichainAccountWalletId(
      MOCK_HD_KEYRING_1.metadata.id,
    );

    const expectedGroupId1 = toMultichainAccountGroupId(
      expectedWalletId,
      mockHdAccount1.options.entropy.groupIndex,
    );

    const expectedGroupId2 = toMultichainAccountGroupId(
      expectedWalletId,
      mockHdAccount2.options.entropy.groupIndex,
    );

    it('uses computed name (from older accounts)', () => {
      const mockEvmAccountName1 = 'My super EVM account';

      const mockEvmAccount1 = {
        ...mockHdAccount1,
        metadata: {
          ...mockHdAccount1.metadata,
          // This name will be used to name the account group.
          name: mockEvmAccountName1,
        },
      };
      const mockAccount2 = {
        ...mockHdAccount2,
        metadata: {
          ...mockHdAccount2.metadata,
          // This "older" account has no name, thus, this will trigger the default
          // naming logic.
          name: '',
        },
      };

      const { controller } = setup({
        accounts: [mockSolAccount1, mockEvmAccount1, mockAccount2],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const wallet = controller.state.accountTree.wallets[expectedWalletId];
      const group1 = wallet?.groups[expectedGroupId1];
      const group2 = wallet?.groups[expectedGroupId2];

      // We used the `account.metadata.name` to compute this name.
      expect(group1?.metadata.name).toBe(mockEvmAccountName1);
      // We ysed the default naming logic for this one. (2, because it's the 2nd account).
      expect(group2?.metadata.name).toBe('Account 2');
    });

    it('ignores non-EVM existing account name', () => {
      const mockSolAccountName1 = 'Solana account';

      const mockEvmAccount1 = mockHdAccount1;
      expect(mockEvmAccount1.metadata.name).toBe('');

      const { controller } = setup({
        accounts: [mockSolAccount1, mockEvmAccount1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const wallet = controller.state.accountTree.wallets[expectedWalletId];
      const group1 = wallet?.groups[expectedGroupId1];

      // Solana account name are never used.
      expect(group1?.metadata.name).not.toBe(mockSolAccountName1);
      // Since EVM account name was empty, we default to normal account naming.
      expect(group1?.metadata.name).toBe('Account 1');
    });

    it('automatically resolve conflicting names if any', () => {
      const mockSameAccountName = 'Same account';

      const mockEvmAccount1 = {
        ...mockHdAccount1,
        metadata: {
          ...mockHdAccount1.metadata,
          name: mockSameAccountName,
        },
      };
      const mockEvmAccount2 = {
        ...mockHdAccount2,
        metadata: {
          ...mockHdAccount2.metadata,
          name: mockSameAccountName,
        },
      };

      // Having the same name should not really be an issue in normal scenarios, but
      // if a user had named some of his accounts with similar name than our new naming
      // scheme, then that could conflict somehow.
      expect(mockEvmAccount1.metadata.name).toBe(mockSameAccountName);
      expect(mockEvmAccount2.metadata.name).toBe(mockSameAccountName);

      const { controller } = setup({
        accounts: [mockEvmAccount1, mockEvmAccount2],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const wallet = controller.state.accountTree.wallets[expectedWalletId];
      const group1 = wallet?.groups[expectedGroupId1];
      const group2 = wallet?.groups[expectedGroupId2];

      // We used the `account.metadata.name` to compute this name.
      expect(group1?.metadata.name).toBe(mockSameAccountName);
      expect(group2?.metadata.name).toBe(`${mockSameAccountName} (2)`);
    });
  });

  describe('actions', () => {
    const walletId = toMultichainAccountWalletId(MOCK_HD_KEYRING_1.metadata.id);
    const groupId = toMultichainAccountGroupId(
      walletId,
      MOCK_HD_ACCOUNT_2.options.entropy.groupIndex,
    );

    it('gets a multichain account with AccountTreeController:getSelectedAccountGroup', () => {
      const spy = jest.spyOn(
        AccountTreeController.prototype,
        'getSelectedAccountGroup',
      );

      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      messenger.call('AccountTreeController:getSelectedAccountGroup');
      expect(spy).toHaveBeenCalled();
    });

    it('gets a multichain account with AccountTreeController:setSelectedAccountGroup', () => {
      const spy = jest.spyOn(
        AccountTreeController.prototype,
        'setSelectedAccountGroup',
      );

      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      messenger.call('AccountTreeController:setSelectedAccountGroup', groupId);
      expect(spy).toHaveBeenCalledWith(groupId);
    });

    it('gets a multichain account with AccountTreeController:getAccountsFromSelectedAccountGroup', () => {
      const spy = jest.spyOn(
        AccountTreeController.prototype,
        'getAccountsFromSelectedAccountGroup',
      );

      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      messenger.call(
        'AccountTreeController:getAccountsFromSelectedAccountGroup',
      );
      expect(spy).toHaveBeenCalled();
    });

    it('gets account context with AccountTreeController:getAccountContext', () => {
      const spy = jest.spyOn(
        AccountTreeController.prototype,
        'getAccountContext',
      );

      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      messenger.call(
        'AccountTreeController:getAccountContext',
        MOCK_HD_ACCOUNT_1.id,
      );
      expect(spy).toHaveBeenCalledWith(MOCK_HD_ACCOUNT_1.id);
    });

    it('gets a multichain account with AccountTreeController:setAccountWalletName', () => {
      const spy = jest.spyOn(
        AccountTreeController.prototype,
        'setAccountWalletName',
      );

      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const name = 'Test';

      messenger.call(
        'AccountTreeController:setAccountWalletName',
        walletId,
        name,
      );
      expect(spy).toHaveBeenCalledWith(walletId, name);
    });

    it('gets a multichain account with AccountTreeController:setAccountGroupName', () => {
      const spy = jest.spyOn(
        AccountTreeController.prototype,
        'setAccountGroupName',
      );

      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const name = 'Test';

      messenger.call(
        'AccountTreeController:setAccountGroupName',
        groupId,
        name,
      );
      expect(spy).toHaveBeenCalledWith(groupId, name);
    });

    it('gets a multichain account with AccountTreeController:setAccountGroupPinned', () => {
      const spy = jest.spyOn(
        AccountTreeController.prototype,
        'setAccountGroupPinned',
      );

      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const pinned = true;

      messenger.call(
        'AccountTreeController:setAccountGroupPinned',
        groupId,
        pinned,
      );
      expect(spy).toHaveBeenCalledWith(groupId, pinned);
    });

    it('gets a multichain account with AccountTreeController:setAccountGroupHidden', () => {
      const spy = jest.spyOn(
        AccountTreeController.prototype,
        'setAccountGroupHidden',
      );

      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const hidden = false;

      messenger.call(
        'AccountTreeController:setAccountGroupHidden',
        groupId,
        hidden,
      );
      expect(spy).toHaveBeenCalledWith(groupId, hidden);
    });
  });

  describe('Event Emissions', () => {
    it('does NOT emit accountTreeChange when tree is initialized', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      const accountTreeChangeListener = jest.fn();
      messenger.subscribe(
        'AccountTreeController:accountTreeChange',
        accountTreeChangeListener,
      );

      controller.init();

      expect(accountTreeChangeListener).not.toHaveBeenCalled();
    });

    it('emits accountTreeChange when account is added', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      const accountTreeChangeListener = jest.fn();
      messenger.subscribe(
        'AccountTreeController:accountTreeChange',
        accountTreeChangeListener,
      );

      controller.init();
      jest.clearAllMocks();

      messenger.publish('AccountsController:accountAdded', {
        ...MOCK_HD_ACCOUNT_2,
      });

      expect(accountTreeChangeListener).toHaveBeenCalledWith(
        controller.state.accountTree,
      );
      expect(accountTreeChangeListener).toHaveBeenCalledTimes(1);
    });

    it('emits accountTreeChange when account is removed', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      const accountTreeChangeListener = jest.fn();
      messenger.subscribe(
        'AccountTreeController:accountTreeChange',
        accountTreeChangeListener,
      );

      controller.init();
      jest.clearAllMocks();

      messenger.publish(
        'AccountsController:accountRemoved',
        MOCK_HD_ACCOUNT_2.id,
      );

      expect(accountTreeChangeListener).toHaveBeenCalledWith(
        controller.state.accountTree,
      );
      expect(accountTreeChangeListener).toHaveBeenCalledTimes(1);
    });

    it('emits selectedAccountGroupChange when account removal causes empty group and auto-selection', () => {
      // Set up with two accounts in different groups to ensure group change on removal
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_SNAP_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      const selectedAccountGroupChangeListener = jest.fn();
      messenger.subscribe(
        'AccountTreeController:selectedAccountGroupChange',
        selectedAccountGroupChangeListener,
      );

      controller.init();

      // Set selected group to be the group we're about to empty
      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const groupId = toMultichainAccountGroupId(walletId, 1);
      controller.setSelectedAccountGroup(groupId);

      jest.clearAllMocks();

      // Remove the only account in the selected group, which should trigger auto-selection
      messenger.publish(
        'AccountsController:accountRemoved',
        MOCK_SNAP_ACCOUNT_1.id,
      );

      const newSelectedGroup =
        controller.state.accountTree.selectedAccountGroup;

      expect(selectedAccountGroupChangeListener).toHaveBeenCalledWith(
        newSelectedGroup,
        groupId,
      );
      expect(selectedAccountGroupChangeListener).toHaveBeenCalledTimes(1);
    });

    it('emits selectedAccountGroupChange when tree is initialized', () => {
      const { controller, messenger, mocks } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      mocks.AccountsController.getSelectedMultichainAccount.mockImplementation(
        () => MOCK_HD_ACCOUNT_1,
      );

      const selectedAccountGroupChangeListener = jest.fn();
      messenger.subscribe(
        'AccountTreeController:selectedAccountGroupChange',
        selectedAccountGroupChangeListener,
      );

      controller.init();

      const defaultAccountGroupId = toMultichainAccountGroupId(
        toMultichainAccountWalletId(MOCK_HD_ACCOUNT_1.options.entropy.id),
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      expect(selectedAccountGroupChangeListener).toHaveBeenCalledWith(
        defaultAccountGroupId,
        '',
      );
    });

    it('emits selectedAccountGroupChange when tree is re-initialized and current selected group no longer exists', () => {
      const { controller, messenger, mocks } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      mocks.AccountsController.getSelectedMultichainAccount.mockImplementation(
        () => MOCK_HD_ACCOUNT_1,
      );

      controller.init();

      const defaultAccountGroupId = toMultichainAccountGroupId(
        toMultichainAccountWalletId(MOCK_HD_ACCOUNT_1.options.entropy.id),
        MOCK_HD_ACCOUNT_1.options.entropy.groupIndex,
      );

      expect(controller.state.accountTree.selectedAccountGroup).toStrictEqual(
        defaultAccountGroupId,
      );

      const selectedAccountGroupChangeListener = jest.fn();
      messenger.subscribe(
        'AccountTreeController:selectedAccountGroupChange',
        selectedAccountGroupChangeListener,
      );

      mocks.AccountsController.accounts = [MOCK_HD_ACCOUNT_2];
      mocks.KeyringController.keyrings = [MOCK_HD_KEYRING_2];
      mocks.AccountsController.getSelectedMultichainAccount.mockImplementation(
        () => MOCK_HD_ACCOUNT_2,
      );

      controller.reinit();

      const oldDefaultAccountGroupId = defaultAccountGroupId;
      const newDefaultAccountGroupId = toMultichainAccountGroupId(
        toMultichainAccountWalletId(MOCK_HD_ACCOUNT_2.options.entropy.id),
        MOCK_HD_ACCOUNT_2.options.entropy.groupIndex,
      );

      expect(controller.state.accountTree.selectedAccountGroup).toStrictEqual(
        newDefaultAccountGroupId,
      );
      expect(selectedAccountGroupChangeListener).toHaveBeenCalledWith(
        newDefaultAccountGroupId,
        oldDefaultAccountGroupId,
      );
    });

    it('emits selectedAccountGroupChange when setSelectedAccountGroup is called', () => {
      // Use different keyring types to ensure different groups
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_SNAP_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      const selectedAccountGroupChangeListener = jest.fn();
      messenger.subscribe(
        'AccountTreeController:selectedAccountGroupChange',
        selectedAccountGroupChangeListener,
      );

      controller.init();

      const initialSelectedGroup =
        controller.state.accountTree.selectedAccountGroup;
      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const targetGroupId = toMultichainAccountGroupId(walletId, 1);

      jest.clearAllMocks();

      controller.setSelectedAccountGroup(targetGroupId);

      expect(selectedAccountGroupChangeListener).toHaveBeenCalledWith(
        targetGroupId,
        initialSelectedGroup,
      );
      expect(selectedAccountGroupChangeListener).toHaveBeenCalledTimes(1);
    });

    it('emits selectedAccountGroupChange when selected account changes via AccountsController', () => {
      // Use different keyring types to ensure different groups
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1, MOCK_SNAP_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1, MOCK_HD_KEYRING_2],
      });

      const selectedAccountGroupChangeListener = jest.fn();
      messenger.subscribe(
        'AccountTreeController:selectedAccountGroupChange',
        selectedAccountGroupChangeListener,
      );

      controller.init();

      const initialSelectedGroup =
        controller.state.accountTree.selectedAccountGroup;

      jest.clearAllMocks();

      messenger.publish(
        'AccountsController:selectedAccountChange',
        MOCK_SNAP_ACCOUNT_1,
      );

      const newSelectedGroup =
        controller.state.accountTree.selectedAccountGroup;

      expect(selectedAccountGroupChangeListener).toHaveBeenCalledWith(
        newSelectedGroup,
        initialSelectedGroup,
      );
      expect(selectedAccountGroupChangeListener).toHaveBeenCalledTimes(1);
    });

    it('does NOT emit selectedAccountGroupChange when the same account group is already selected', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      const selectedAccountGroupChangeListener = jest.fn();
      messenger.subscribe(
        'AccountTreeController:selectedAccountGroupChange',
        selectedAccountGroupChangeListener,
      );

      controller.init();

      jest.clearAllMocks();

      // Try to trigger selectedAccountChange with same account
      messenger.publish(
        'AccountsController:selectedAccountChange',
        MOCK_HD_ACCOUNT_1,
      );

      expect(selectedAccountGroupChangeListener).not.toHaveBeenCalled();
    });

    it('does NOT emit selectedAccountGroupChange when setSelectedAccountGroup is called with same group', () => {
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      const selectedAccountGroupChangeListener = jest.fn();
      messenger.subscribe(
        'AccountTreeController:selectedAccountGroupChange',
        selectedAccountGroupChangeListener,
      );

      controller.init();

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const groupId = toMultichainAccountGroupId(walletId, 0);

      jest.clearAllMocks();

      controller.setSelectedAccountGroup(groupId);

      expect(selectedAccountGroupChangeListener).not.toHaveBeenCalled();
    });
  });

  describe('syncWithUserStorage', () => {
    beforeEach(() => {
      jest.clearAllMocks();
    });

    it('calls performFullSync on the syncing service', async () => {
      // Spy on the BackupAndSyncService constructor and methods
      const performFullSyncSpy = jest.spyOn(
        BackupAndSyncService.prototype,
        'performFullSync',
      );

      const { controller } = setup({
        accounts: [MOCK_HARDWARE_ACCOUNT_1], // Use hardware account to avoid entropy calls
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      await controller.syncWithUserStorage();

      expect(performFullSyncSpy).toHaveBeenCalledTimes(1);
    });

    it('handles sync errors gracefully', async () => {
      const syncError = new Error('Sync failed');
      const performFullSyncSpy = jest
        .spyOn(BackupAndSyncService.prototype, 'performFullSync')
        .mockRejectedValue(syncError);

      const { controller } = setup({
        accounts: [MOCK_HARDWARE_ACCOUNT_1], // Use hardware account to avoid entropy calls
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      await expect(controller.syncWithUserStorage()).rejects.toThrow(
        syncError.message,
      );
      expect(performFullSyncSpy).toHaveBeenCalledTimes(1);
    });
  });

  describe('syncWithUserStorageAtLeastOnce', () => {
    beforeEach(() => {
      jest.clearAllMocks();
    });

    it('calls performFullSyncAtLeastOnce on the syncing service', async () => {
      // Spy on the BackupAndSyncService constructor and methods
      const performFullSyncAtLeastOnceSpy = jest.spyOn(
        BackupAndSyncService.prototype,
        'performFullSyncAtLeastOnce',
      );

      const { controller } = setup({
        accounts: [MOCK_HARDWARE_ACCOUNT_1], // Use hardware account to avoid entropy calls
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      await controller.syncWithUserStorageAtLeastOnce();

      expect(performFullSyncAtLeastOnceSpy).toHaveBeenCalledTimes(1);
    });

    it('handles sync errors gracefully', async () => {
      const syncError = new Error('Sync failed');
      const performFullSyncAtLeastOnceSpy = jest
        .spyOn(BackupAndSyncService.prototype, 'performFullSyncAtLeastOnce')
        .mockRejectedValue(syncError);

      const { controller } = setup({
        accounts: [MOCK_HARDWARE_ACCOUNT_1], // Use hardware account to avoid entropy calls
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      await expect(controller.syncWithUserStorageAtLeastOnce()).rejects.toThrow(
        syncError.message,
      );
      expect(performFullSyncAtLeastOnceSpy).toHaveBeenCalledTimes(1);
    });
  });

  describe('UserStorageController:stateChange subscription', () => {
    beforeEach(() => {
      jest.clearAllMocks();
    });

    it('calls BackupAndSyncService.handleUserStorageStateChange', () => {
      const handleUserStorageStateChangeSpy = jest.spyOn(
        BackupAndSyncService.prototype,
        'handleUserStorageStateChange',
      );
      const { controller, messenger } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      messenger.publish(
        'UserStorageController:stateChange',
        {
          isBackupAndSyncEnabled: false,
          isAccountSyncingEnabled: true,
          isBackupAndSyncUpdateLoading: false,
          isContactSyncingEnabled: false,
          isContactSyncingInProgress: false,
        },
        [],
      );

      expect(handleUserStorageStateChangeSpy).toHaveBeenCalled();
      expect(handleUserStorageStateChangeSpy).toHaveBeenCalledTimes(1);
    });
  });

  describe('clearPersistedMetadataAndSyncingState', () => {
    it('clears all persisted metadata and syncing state', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      // Set some metadata first
      controller.setAccountGroupName(
        'entropy:mock-keyring-id-1/0',
        'Test Group',
      );
      controller.setAccountWalletName(
        'entropy:mock-keyring-id-1',
        'Test Wallet',
      );

      // Verify metadata exists
      expect(controller.state.accountGroupsMetadata).not.toStrictEqual({});
      expect(controller.state.accountWalletsMetadata).not.toStrictEqual({});

      // Clear the metadata
      controller.clearState();

      // Verify everything is cleared
      expect(controller.state).toStrictEqual(
        getDefaultAccountTreeControllerState(),
      );
    });
  });

  describe('backup and sync config initialization', () => {
    it('initializes backup and sync config with provided analytics callback', async () => {
      const mockAnalyticsCallback = jest.fn();

      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
        config: {
          backupAndSync: {
            isAccountSyncingEnabled: true,
            isBackupAndSyncEnabled: true,
            onBackupAndSyncEvent: mockAnalyticsCallback,
          },
        },
      });

      controller.init();

      // Verify config is initialized - controller should be defined and working
      expect(controller).toBeDefined();
      expect(controller.state).toBeDefined();

      // Test that the analytics callback can be accessed through the backup and sync service
      // We'll trigger a sync to test the callback (this should cover the callback invocation)
      await controller.syncWithUserStorage();
      expect(mockAnalyticsCallback).toHaveBeenCalled();
    });

    it('initializes backup and sync config with default values when no config provided', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      // Verify controller works without config (tests default config initialization)
      expect(controller).toBeDefined();
      expect(controller.state).toBeDefined();
    });
  });

  describe('metadata', () => {
    it('includes expected state in debug snapshots', () => {
      const { controller } = setup();

      expect(
        deriveStateFromMetadata(
          controller.state,
          controller.metadata,
          'includeInDebugSnapshot',
        ),
      ).toMatchInlineSnapshot(`{}`);
    });

    it('includes expected state in state logs', () => {
      const { controller } = setup();

      expect(
        deriveStateFromMetadata(
          controller.state,
          controller.metadata,
          'includeInStateLogs',
        ),
      ).toMatchInlineSnapshot(`
        {
          "accountGroupsMetadata": {},
          "accountTree": {
            "selectedAccountGroup": "",
            "wallets": {},
          },
          "accountWalletsMetadata": {},
          "hasAccountTreeSyncingSyncedAtLeastOnce": false,
        }
      `);
    });

    it('persists expected state', () => {
      const { controller } = setup();

      expect(
        deriveStateFromMetadata(
          controller.state,
          controller.metadata,
          'persist',
        ),
      ).toMatchInlineSnapshot(`
        {
          "accountGroupsMetadata": {},
          "accountWalletsMetadata": {},
          "hasAccountTreeSyncingSyncedAtLeastOnce": false,
        }
      `);
    });

    it('exposes expected state to UI', () => {
      const { controller } = setup();

      expect(
        deriveStateFromMetadata(
          controller.state,
          controller.metadata,
          'usedInUi',
        ),
      ).toMatchInlineSnapshot(`
        {
          "accountGroupsMetadata": {},
          "accountTree": {
            "selectedAccountGroup": "",
            "wallets": {},
          },
          "accountWalletsMetadata": {},
          "hasAccountTreeSyncingSyncedAtLeastOnce": false,
          "isAccountTreeSyncingInProgress": false,
        }
      `);
    });

    it('handles automatic conflict resolution with suffix when autoHandleConflict is true', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const groupId = toMultichainAccountGroupId(walletId, 0);

      // Should have "Account 1"
      expect(
        controller.state.accountTree.wallets[walletId].groups[groupId].metadata
          .name,
      ).toBe('Account 1');

      // Rename to "Test Name"
      controller.setAccountGroupName(groupId, 'Test Name');
      expect(
        controller.state.accountTree.wallets[walletId].groups[groupId].metadata
          .name,
      ).toBe('Test Name');

      // Try to rename to "Test Name" again with autoHandleConflict = true
      // Since it's the same account, it should stay "Test Name" (no conflict with itself)
      controller.setAccountGroupName(groupId, 'Test Name', true);
      expect(
        controller.state.accountTree.wallets[walletId].groups[groupId].metadata
          .name,
      ).toBe('Test Name');

      // Create a second wallet to test conflict resolution
      const { controller: controller2 } = setup({
        accounts: [MOCK_HD_ACCOUNT_2],
        keyrings: [MOCK_HD_KEYRING_2],
      });

      controller2.init();

      const wallet2Id = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_2.metadata.id,
      );
      const group2Id = toMultichainAccountGroupId(wallet2Id, 0);

      // Try to rename second wallet's account to "Test Name" with autoHandleConflict = true
      // Since it's a different wallet, it should be allowed (no cross-wallet conflicts)
      controller2.setAccountGroupName(group2Id, 'Test Name', true);
      expect(
        controller2.state.accountTree.wallets[wallet2Id].groups[group2Id]
          .metadata.name,
      ).toBe('Test Name');
    });

    it('validates autoHandleConflict parameter implementation', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const groupId = toMultichainAccountGroupId(walletId, 0);

      // Test that the parameter exists and method signature is correct
      expect(typeof controller.setAccountGroupName).toBe('function');

      // Test autoHandleConflict = false (default behavior)
      controller.setAccountGroupName(groupId, 'Test Name', false);
      expect(
        controller.state.accountTree.wallets[walletId].groups[groupId].metadata
          .name,
      ).toBe('Test Name');

      // Test autoHandleConflict = true (B&S integration ready)
      controller.setAccountGroupName(groupId, 'Different Name', true);
      expect(
        controller.state.accountTree.wallets[walletId].groups[groupId].metadata
          .name,
      ).toBe('Different Name');

      // The suffix logic is implemented but will be thoroughly tested during B&S integration
      // when real conflict scenarios will be available in the test environment
    });

    it('tests autoHandleConflict functionality', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const groupId = toMultichainAccountGroupId(walletId, 0);

      // Test autoHandleConflict = false (default behavior)
      controller.setAccountGroupName(groupId, 'Test Name', false);
      expect(
        controller.state.accountTree.wallets[walletId].groups[groupId].metadata
          .name,
      ).toBe('Test Name');

      // Test autoHandleConflict = true (B&S integration ready)
      controller.setAccountGroupName(groupId, 'Different Name', true);
      expect(
        controller.state.accountTree.wallets[walletId].groups[groupId].metadata
          .name,
      ).toBe('Different Name');

      // Test the suffix resolution logic directly using proper update method
      (
        controller as unknown as {
          update: (fn: (state: AccountTreeControllerState) => void) => void;
        }
      ).update((state) => {
        // Add conflicting groups to test suffix logic
        const wallet = state.accountTree.wallets[walletId];
        (wallet.groups as Record<string, unknown>)['conflict-1'] = {
          id: 'conflict-1',
          type: AccountGroupType.MultichainAccount,
          accounts: ['test-account-1'],
          metadata: {
            name: 'Suffix Test',
            entropy: { groupIndex: 1 },
            pinned: false,
            hidden: false,
          },
        };
        (wallet.groups as Record<string, unknown>)['conflict-2'] = {
          id: 'conflict-2',
          type: AccountGroupType.MultichainAccount,
          accounts: ['test-account-2'],
          metadata: {
            name: 'Suffix Test (2)',
            entropy: { groupIndex: 2 },
            pinned: false,
            hidden: false,
          },
        };
      });

      // Test suffix resolution directly using the public method
      const wallet = controller.state.accountTree.wallets[walletId];
      const resolvedName = controller.resolveNameConflict(
        wallet,
        groupId,
        'Suffix Test',
      );
      expect(resolvedName).toBe('Suffix Test (3)');

      // Test with no conflicts: should return "Unique Name (2)"
      const uniqueName = controller.resolveNameConflict(
        wallet,
        groupId,
        'Unique Name',
      );
      expect(uniqueName).toBe('Unique Name (2)');
    });

    it('throws error when group ID not found in tree', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      // Try to set name for a non-existent group ID
      expect(() => {
        controller.setAccountGroupName(
          'entropy:non-existent/group-id' as AccountGroupId,
          'Test Name',
        );
      }).toThrow(
        'Account group with ID "entropy:non-existent/group-id" not found in tree',
      );
    });

    it('handles autoHandleConflict with real conflict scenario', () => {
      const { controller } = setup({
        accounts: [MOCK_HD_ACCOUNT_1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      const walletId = toMultichainAccountWalletId(
        MOCK_HD_KEYRING_1.metadata.id,
      );
      const groupId = toMultichainAccountGroupId(walletId, 0);

      // Set initial name
      controller.setAccountGroupName(groupId, 'Test Name');

      // Create another group with conflicting name
      (
        controller as unknown as {
          update: (fn: (state: AccountTreeControllerState) => void) => void;
        }
      ).update((state) => {
        const wallet = state.accountTree.wallets[walletId];
        (wallet.groups as Record<string, unknown>)['conflict-group'] = {
          id: 'conflict-group',
          type: AccountGroupType.MultichainAccount,
          accounts: ['test-account'],
          metadata: {
            name: 'Conflict Name',
            entropy: { groupIndex: 1 },
            pinned: false,
            hidden: false,
          },
        };
      });

      // Try to rename first group to conflicting name with autoHandleConflict = true
      controller.setAccountGroupName(groupId, 'Conflict Name', true);

      // Should have been renamed to "Conflict Name (2)"
      expect(
        controller.state.accountTree.wallets[walletId].groups[groupId].metadata
          .name,
      ).toBe('Conflict Name (2)');
    });
  });

  describe('naming', () => {
    const mockAccount1 = {
      ...MOCK_HARDWARE_ACCOUNT_1,
      id: 'mock-id-1',
      address: '0x123',
    };
    const mockAccount2 = {
      ...MOCK_HARDWARE_ACCOUNT_1,
      id: 'mock-id-2',
      address: '0x456',
    };
    const mockAccount3 = {
      ...MOCK_HARDWARE_ACCOUNT_1,
      id: 'mock-id-3',
      address: '0x789',
    };
    const mockAccount4 = {
      ...MOCK_HARDWARE_ACCOUNT_1,
      id: 'mock-id-4',
      address: '0xabc',
    };

    const mockWalletId = toAccountWalletId(
      AccountWalletType.Keyring,
      KeyringTypes.ledger,
    );

    const getAccountGroupFromAccount = (
      controller: AccountTreeController,
      mockAccount: InternalAccount,
    ) => {
      const groupId = toAccountGroupId(mockWalletId, mockAccount.address);
      return controller.state.accountTree.wallets[mockWalletId].groups[groupId];
    };

    it('names all accounts properly even if they are not ordered naturally', () => {
      const mockHdAccount1 = MOCK_HD_ACCOUNT_1;
      const mockHdAccount2 = {
        ...MOCK_HD_ACCOUNT_1,
        id: 'mock-id-2',
        address: '0x456',
        options: {
          entropy: {
            ...MOCK_HD_ACCOUNT_1.options.entropy,
            groupIndex: 1,
          },
        },
      };

      const { controller, mocks } = setup({
        // We start with 1 account (index 0).
        accounts: [mockHdAccount1],
        keyrings: [MOCK_HD_KEYRING_1],
      });

      controller.init();

      // Then, we insert a second account (index 1), but we re-order it so it appears
      // before the first account (index 0).
      mocks.AccountsController.accounts = [mockHdAccount2, mockHdAccount1];

      // Re-init the controller should still give proper naming.
      controller.reinit();

      [mockHdAccount1, mockHdAccount2].forEach((mockAccount, index) => {
        const walletId = toMultichainAccountWalletId(
          mockAccount.options.entropy.id,
        );
        const groupId = toMultichainAccountGroupId(
          walletId,
          mockAccount.options.entropy.groupIndex,
        );

        const mockGroup =
          controller.state.accountTree.wallets[walletId].groups[groupId];
        expect(mockGroup).toBeDefined();
        expect(mockGroup.metadata.name).toBe(`Account ${index + 1}`);
      });
    });

    it('names non-HD keyrings accounts properly', () => {
      const { controller, messenger } = setup();

      controller.init();

      // Add all 3 accounts.
      [mockAccount1, mockAccount2, mockAccount3].forEach(
        (mockAccount, index) => {
          messenger.publish('AccountsController:accountAdded', mockAccount);

          const mockGroup = getAccountGroupFromAccount(controller, mockAccount);
          expect(mockGroup).toBeDefined();
          expect(mockGroup.metadata.name).toBe(`Ledger Account ${index + 1}`);
        },
      );

      // Remove account 2, should still create account 4 afterward.
      messenger.publish('AccountsController:accountRemoved', mockAccount2.id);

      expect(
        getAccountGroupFromAccount(controller, mockAccount4),
      ).toBeUndefined();
      messenger.publish('AccountsController:accountAdded', mockAccount4);

      const mockGroup4 = getAccountGroupFromAccount(controller, mockAccount4);
      expect(mockGroup4).toBeDefined();
      expect(mockGroup4.metadata.name).toBe('Ledger Account 4');

      // Now, removing account 3 and 4, should defaults to an index of "2" (since only
      // account 1 remains), thus, re-inserting account 2, should be named "* Account 2".
      messenger.publish('AccountsController:accountRemoved', mockAccount4.id);
      messenger.publish('AccountsController:accountRemoved', mockAccount3.id);

      expect(
        getAccountGroupFromAccount(controller, mockAccount2),
      ).toBeUndefined();
      messenger.publish('AccountsController:accountAdded', mockAccount2);

      const mockGroup2 = getAccountGroupFromAccount(controller, mockAccount2);
      expect(mockGroup2).toBeDefined();
      expect(mockGroup2.metadata.name).toBe('Ledger Account 2');
    });

    it('ignores bad account group name pattern and fallback to natural indexing', () => {
      const { controller, messenger } = setup({
        accounts: [mockAccount1],
      });

      controller.init();

      const mockGroup1 = getAccountGroupFromAccount(controller, mockAccount1);
      expect(mockGroup1).toBeDefined();

      const mockIndex = 90;
      controller.setAccountGroupName(
        mockGroup1.id,
        `Account${mockIndex}`, // No space, so this should fallback to natural indexing
      );

      // The first account has a non-matching pattern, thus we should fallback to the next
      // natural index.
      messenger.publish('AccountsController:accountAdded', mockAccount2);
      const mockGroup2 = getAccountGroupFromAccount(controller, mockAccount2);
      expect(mockGroup2).toBeDefined();
      expect(mockGroup2.metadata.name).toBe(`Ledger Account 2`); // Natural indexing.
    });

    it.each([
      ['Account', 'account'],
      ['Account', 'aCCount'],
      ['Account', 'accOunT'],
      [' ', '  '],
      [' ', '\t'],
      [' ', ' \t'],
      [' ', '\t '],
    ])(
      'ignores case (case-insensitive) and spaces when extracting highest index: "$0" -> "$1"',
      (toReplace, replaced) => {
        const { controller, messenger } = setup({
          accounts: [mockAccount1],
        });

        controller.init();

        const mockGroup1 = getAccountGroupFromAccount(controller, mockAccount1);
        expect(mockGroup1).toBeDefined();

        const mockIndex = 90;
        controller.setAccountGroupName(
          mockGroup1.id,
          mockGroup1.metadata.name
            .replace(toReplace, replaced)
            .replace('1', `${mockIndex}`), // Use index different than 1.
        );

        // Even if the account is not strictly named "Ledger Account 90", we should be able
        // to compute the next index from there.
        messenger.publish('AccountsController:accountAdded', mockAccount2);
        const mockGroup2 = getAccountGroupFromAccount(controller, mockAccount2);
        expect(mockGroup2).toBeDefined();
        expect(mockGroup2.metadata.name).toBe(
          `Ledger Account ${mockIndex + 1}`,
        );
      },
    );

    it.each([' ', '  ', '\t', ' \t'])(
      'extract name indexes and ignore multiple spaces: "%s"',
      (space) => {
        const { controller, messenger } = setup({
          accounts: [mockAccount1],
        });

        controller.init();

        const mockGroup1 = getAccountGroupFromAccount(controller, mockAccount1);
        expect(mockGroup1).toBeDefined();

        const mockIndex = 90;
        controller.setAccountGroupName(
          mockGroup1.id,
          mockGroup1.metadata.name
            .replace(' ', space)
            .replace('1', `${mockIndex}`), // Use index different than 1.
        );

        // Even if the account is not strictly named "Ledger Account 90", we should be able
        // to compute the next index from there.
        messenger.publish('AccountsController:accountAdded', mockAccount2);
        const mockGroup2 = getAccountGroupFromAccount(controller, mockAccount2);
        expect(mockGroup2).toBeDefined();
        expect(mockGroup2.metadata.name).toBe(
          `Ledger Account ${mockIndex + 1}`,
        );
      },
    );

    it('uses natural indexing for pre-existing accounts', () => {
      const { controller } = setup({
        accounts: [mockAccount1, mockAccount2, mockAccount3],
      });

      controller.init();

      // After initializing the controller, all accounts should be named appropriately.
      [mockAccount1, mockAccount2, mockAccount3].forEach(
        (mockAccount, index) => {
          const mockGroup = getAccountGroupFromAccount(controller, mockAccount);
          expect(mockGroup).toBeDefined();
          expect(mockGroup.metadata.name).toBe(`Ledger Account ${index + 1}`);
        },
      );
    });

    it('fallbacks to natural indexing if group names are not using our default name pattern', () => {
      const { controller, messenger } = setup();

      controller.init();

      [mockAccount1, mockAccount2, mockAccount3].forEach((mockAccount) =>
        messenger.publish('AccountsController:accountAdded', mockAccount),
      );

      const mockGroup1 = getAccountGroupFromAccount(controller, mockAccount1);
      const mockGroup2 = getAccountGroupFromAccount(controller, mockAccount2);
      const mockGroup3 = getAccountGroupFromAccount(controller, mockAccount3);
      expect(mockGroup1).toBeDefined();
      expect(mockGroup2).toBeDefined();
      expect(mockGroup3).toBeDefined();

      // Rename all accounts to something different than "* Account <index>".
      controller.setAccountGroupName(mockGroup1.id, 'Account A');
      controller.setAccountGroupName(mockGroup2.id, 'The next account');
      controller.setAccountGroupName(mockGroup3.id, 'Best account so far');

      // Adding a new account should not reset back to "Account 1", but it should
      // use the next natural index, here, "Account 4".
      messenger.publish('AccountsController:accountAdded', mockAccount4);
      const mockGroup4 = getAccountGroupFromAccount(controller, mockAccount4);
      expect(mockGroup4).toBeDefined();
      expect(mockGroup4.metadata.name).toBe('Ledger Account 4');
    });
  });

  describe('migrating account order callbacks', () => {
    const mockAccount1 = {
      ...MOCK_HD_ACCOUNT_1,
      id: 'test-account-1' as AccountId,
      address: '0x123',
    };

    describe('basic functionality', () => {
      it('initializes without callbacks and use default metadata values', () => {
        const { controller } = setup({
          accounts: [mockAccount1],
          config: {
            backupAndSync: {
              isAccountSyncingEnabled: true,
              isBackupAndSyncEnabled: true,
              onBackupAndSyncEvent: jest.fn(),
            },
            // No accountOrderCallbacks provided
          },
        });

        controller.init();

        const wallets = Object.values(controller.state.accountTree.wallets);
        expect(wallets).toHaveLength(1);

        const groups = Object.values(wallets[0].groups);
        expect(groups).toHaveLength(1);
        expect(groups[0].accounts).toContain(mockAccount1.id);
        expect(groups[0].metadata.pinned).toBe(false);
        expect(groups[0].metadata.hidden).toBe(false);

        // Verify that metadata was persisted with default values
        const groupId = groups[0].id;
        expect(controller.state.accountGroupsMetadata[groupId]).toStrictEqual({
          name: {
            value: expect.any(String),
            lastUpdatedAt: expect.any(Number),
          },
          pinned: {
            value: false,
            lastUpdatedAt: 0,
          },
          hidden: {
            value: false,
            lastUpdatedAt: 0,
          },
        });
      });

      it('handles only pinned callback provided', () => {
        const mockCallbacks = {
          isPinnedAccount: jest.fn().mockReturnValue(true),
        };

        const { controller } = setup({
          accounts: [mockAccount1],
          config: {
            backupAndSync: {
              isAccountSyncingEnabled: true,
              isBackupAndSyncEnabled: true,
              onBackupAndSyncEvent: jest.fn(),
            },
            accountOrderCallbacks: mockCallbacks,
          },
        });

        controller.init();

        const wallets = Object.values(controller.state.accountTree.wallets);
        expect(wallets).toHaveLength(1);

        const groups = Object.values(wallets[0].groups);
        expect(groups).toHaveLength(1);
        expect(groups[0].accounts).toContain(mockAccount1.id);
        expect(groups[0].metadata.pinned).toBe(true);
        expect(groups[0].metadata.hidden).toBe(false);
        expect(mockCallbacks.isPinnedAccount).toHaveBeenCalledWith(
          mockAccount1.id,
        );

        // Verify that metadata was persisted correctly
        const groupId = groups[0].id;
        expect(controller.state.accountGroupsMetadata[groupId]).toStrictEqual({
          name: {
            value: expect.any(String),
            lastUpdatedAt: expect.any(Number),
          },
          pinned: {
            value: true,
            lastUpdatedAt: 0,
          },
          hidden: {
            value: false,
            lastUpdatedAt: 0,
          },
        });
      });

      it('handles only hidden callback provided', () => {
        const mockCallbacks = {
          isHiddenAccount: jest.fn().mockReturnValue(true),
        };

        const { controller } = setup({
          accounts: [mockAccount1],
          config: {
            backupAndSync: {
              isAccountSyncingEnabled: true,
              isBackupAndSyncEnabled: true,
              onBackupAndSyncEvent: jest.fn(),
            },
            accountOrderCallbacks: mockCallbacks,
          },
        });

        controller.init();

        const wallets = Object.values(controller.state.accountTree.wallets);
        expect(wallets).toHaveLength(1);

        const groups = Object.values(wallets[0].groups);
        expect(groups).toHaveLength(1);
        expect(groups[0].accounts).toContain(mockAccount1.id);
        expect(groups[0].metadata.pinned).toBe(false);
        expect(groups[0].metadata.hidden).toBe(true);
        expect(mockCallbacks.isHiddenAccount).toHaveBeenCalledWith(
          mockAccount1.id,
        );

        // Verify that metadata was persisted correctly
        const groupId = groups[0].id;
        expect(controller.state.accountGroupsMetadata[groupId]).toStrictEqual({
          name: {
            value: expect.any(String),
            lastUpdatedAt: expect.any(Number),
          },
          pinned: {
            value: false,
            lastUpdatedAt: 0,
          },
          hidden: {
            value: true,
            lastUpdatedAt: 0,
          },
        });
      });

      it('prefers persisted metadata over callbacks', () => {
        const mockIsHiddenAccount = jest.fn().mockReturnValue(true);
        const mockIsPinnedAccount = jest.fn().mockReturnValue(true);

        const walletId = toMultichainAccountWalletId(
          mockAccount1.options.entropy.id,
        );
        const groupId = toMultichainAccountGroupId(
          walletId,
          mockAccount1.options.entropy.groupIndex,
        );

        const { controller } = setup({
          accounts: [mockAccount1],
          keyrings: [MOCK_HD_KEYRING_1],
          state: {
            accountGroupsMetadata: {
              [groupId]: {
                pinned: {
                  value: false,
                  lastUpdatedAt: Date.now(),
                },
                hidden: {
                  value: false,
                  lastUpdatedAt: Date.now(),
                },
              },
            },
          },
          config: {
            backupAndSync: {
              isAccountSyncingEnabled: true,
              isBackupAndSyncEnabled: true,
              onBackupAndSyncEvent: jest.fn(),
            },
            accountOrderCallbacks: {
              isHiddenAccount: mockIsHiddenAccount,
              isPinnedAccount: mockIsPinnedAccount,
            },
          },
        });

        controller.init();

        // Verify callbacks were NOT called because persisted metadata takes precedence
        expect(mockIsHiddenAccount).not.toHaveBeenCalled();
        expect(mockIsPinnedAccount).not.toHaveBeenCalled();

        const wallets = Object.values(controller.state.accountTree.wallets);
        const groups = Object.values(wallets[0].groups);
        expect(groups[0].accounts).toContain(mockAccount1.id);
        expect(groups[0].metadata.pinned).toBe(false); // Persisted value used
        expect(groups[0].metadata.hidden).toBe(false); // Persisted value used
      });

      it('uses persisted metadata when no callbacks are provided', () => {
        const walletId = toMultichainAccountWalletId(
          mockAccount1.options.entropy.id,
        );
        const groupId = toMultichainAccountGroupId(
          walletId,
          mockAccount1.options.entropy.groupIndex,
        );

        const { controller } = setup({
          accounts: [mockAccount1],
          keyrings: [MOCK_HD_KEYRING_1],
          state: {
            accountGroupsMetadata: {
              [groupId]: {
                pinned: {
                  value: true, // Persisted as pinned
                  lastUpdatedAt: Date.now(),
                },
                hidden: {
                  value: true, // Persisted as hidden
                  lastUpdatedAt: Date.now(),
                },
              },
            },
          },
          config: {
            backupAndSync: {
              isAccountSyncingEnabled: true,
              isBackupAndSyncEnabled: true,
              onBackupAndSyncEvent: jest.fn(),
            },
            // No accountOrderCallbacks provided
          },
        });

        controller.init();

        const wallets = Object.values(controller.state.accountTree.wallets);
        const groups = Object.values(wallets[0].groups);
        expect(groups[0].accounts).toContain(mockAccount1.id);
        expect(groups[0].metadata.pinned).toBe(true);
        expect(groups[0].metadata.hidden).toBe(true);
      });
    });
  });
});