MetaMask
diff --git a/‎app/core/Engine/controllers/money-account-upgrade-controller-init.test.ts‎
Lines changed: 105 additions & 79 deletions b/‎app/core/Engine/controllers/money-account-upgrade-controller-init.test.ts‎
Lines changed: 105 additions & 79 deletions
diff --git a/‎app/core/Engine/controllers/money-account-upgrade-controller-init.ts‎
Lines changed: 64 additions & 28 deletions b/‎app/core/Engine/controllers/money-account-upgrade-controller-init.ts‎
Lines changed: 64 additions & 28 deletions
diff --git a/‎app/core/Engine/messengers/money-account-upgrade-controller-messenger.ts‎
Lines changed: 6 additions & 0 deletions b/‎app/core/Engine/messengers/money-account-upgrade-controller-messenger.ts‎
Lines changed: 6 additions & 0 deletions
@@ -1,4 +1,4 @@
-import { CHAIN_IDS } from '@metamask/transaction-controller';
+import type { Hex } from '@metamask/utils';
 import { MoneyAccountUpgradeController } from '@metamask/money-account-upgrade-controller';
 import { MOCK_ANY_NAMESPACE, MockAnyNamespace } from '@metamask/messenger';
 import { ExtendedMessenger } from '../../ExtendedMessenger';
@@ -7,7 +7,13 @@ import {
   getMoneyAccountUpgradeControllerInitMessenger,
   getMoneyAccountUpgradeControllerMessenger,
 } from '../messengers/money-account-upgrade-controller-messenger';
-import { getDeleGatorEnvironment } from '../../Delegation/environment';
+import Engine from '../../Engine';
+import ReduxService from '../../redux';
+import {
+  type MoneyAccountVaultConfig,
+  selectMoneyAccountVaultConfig,
+} from '../../../selectors/featureFlagController/moneyAccount';
+import { selectEvmNetworkConfigurationsByChainId } from '../../../selectors/networkController';
 import {
   __resetMoneyAccountUpgradeBootstrapForTesting,
   moneyAccountUpgradeControllerInit,
@@ -17,38 +23,42 @@ import Logger from '../../../util/Logger';
 
 jest.mock('@metamask/money-account-upgrade-controller');
 
-jest.mock('../../Delegation/environment', () => ({
-  getDeleGatorEnvironment: jest.fn(),
+jest.mock('../../redux');
+
+jest.mock('../../Engine', () => ({
+  __esModule: true,
+  default: {
+    context: {
+      NetworkController: {
+        addNetwork: jest.fn().mockResolvedValue(undefined),
+      },
+    },
+  },
+}));
+
+jest.mock('../../../selectors/featureFlagController/moneyAccount');
+
+jest.mock('../../../selectors/networkController', () => ({
+  selectEvmNetworkConfigurationsByChainId: jest.fn(),
 }));
 
 jest.mock('../../../util/Logger', () => ({
   error: jest.fn(),
 }));
 
-const MUSD_TOKEN_ADDRESS = '0x000000000000000000000000000000000000dead';
-const DELEGATOR_IMPL = '0x0000000000000000000000000000000000000001';
-const REDEEMER_ENFORCER = '0x0000000000000000000000000000000000000002';
-const VALUE_LTE_ENFORCER = '0x0000000000000000000000000000000000000003';
-
-const SERVICE_DETAILS = {
-  chains: {
-    [CHAIN_IDS.ARBITRUM]: {
-      protocol: {
-        vedaProtocol: {
-          supportedTokens: [{ tokenAddress: MUSD_TOKEN_ADDRESS }],
-        },
-      },
-    },
-  },
+const VAULT_CHAIN_ID = '0x8f' as Hex;
+const BORING_VAULT_ADDRESS =
+  '0x000000000000000000000000000000000000beef' as Hex;
+
+const VAULT_CONFIG: MoneyAccountVaultConfig = {
+  chainId: VAULT_CHAIN_ID,
+  boringVault: BORING_VAULT_ADDRESS,
+  tellerAddress: '0x0000000000000000000000000000000000000001',
+  accountantAddress: '0x0000000000000000000000000000000000000002',
+  lensAddress: '0x0000000000000000000000000000000000000003',
 };
 
-function getInitRequestMock({
-  isUnlocked,
-  serviceDetails = SERVICE_DETAILS,
-}: {
-  isUnlocked: boolean;
-  serviceDetails?: unknown;
-}) {
+function getInitRequestMock({ isUnlocked }: { isUnlocked: boolean }) {
   const baseMessenger = new ExtendedMessenger<MockAnyNamespace, never, never>({
     namespace: MOCK_ANY_NAMESPACE,
   });
@@ -59,21 +69,14 @@ function getInitRequestMock({
     jest.fn().mockReturnValue({ isUnlocked }),
   );
 
-  const getServiceDetails = jest.fn().mockResolvedValue(serviceDetails);
-  baseMessenger.registerActionHandler(
-    // @ts-expect-error: Action not allowed on the mock messenger namespace.
-    'ChompApiService:getServiceDetails',
-    getServiceDetails,
-  );
-
   const requestMock = {
     ...buildMessengerClientInitRequestMock(baseMessenger),
     controllerMessenger:
       getMoneyAccountUpgradeControllerMessenger(baseMessenger),
     initMessenger: getMoneyAccountUpgradeControllerInitMessenger(baseMessenger),
   };
 
-  return { requestMock, baseMessenger, getServiceDetails };
+  return { requestMock, baseMessenger };
 }
 
 const flushAsync = () => new Promise(process.nextTick);
@@ -92,15 +95,20 @@ describe('moneyAccountUpgradeControllerInit', () => {
       .mocked(MoneyAccountUpgradeController)
       .mockImplementation(() => mockedController);
 
-    jest.mocked(getDeleGatorEnvironment).mockReturnValue({
-      EIP7702StatelessDeleGatorImpl: DELEGATOR_IMPL,
-      caveatEnforcers: {
-        RedeemerEnforcer: REDEEMER_ENFORCER,
-        ValueLteEnforcer: VALUE_LTE_ENFORCER,
-      },
-    } as unknown as ReturnType<typeof getDeleGatorEnvironment>);
+    (ReduxService as unknown as { store: { getState: jest.Mock } }).store = {
+      getState: jest.fn().mockReturnValue({}),
+    };
+    jest.mocked(selectMoneyAccountVaultConfig).mockReturnValue(VAULT_CONFIG);
+    jest.mocked(selectEvmNetworkConfigurationsByChainId).mockReturnValue({
+      [VAULT_CHAIN_ID]: {
+        chainId: VAULT_CHAIN_ID,
+      } as never,
+    });
   });
 
+  const mockAddNetwork = Engine.context.NetworkController
+    .addNetwork as jest.Mock;
+
   it('returns a MoneyAccountUpgradeController instance', () => {
     const { requestMock } = getInitRequestMock({ isUnlocked: false });
 
@@ -126,23 +134,15 @@ describe('moneyAccountUpgradeControllerInit', () => {
     });
   });
 
-  it('initializes the controller with addresses from service details and the delegator environment when unlocked', async () => {
-    const { requestMock, getServiceDetails } = getInitRequestMock({
-      isUnlocked: true,
-    });
+  it('initializes the controller with the chainId and boring vault address from the vault config when unlocked', async () => {
+    const { requestMock } = getInitRequestMock({ isUnlocked: true });
 
     moneyAccountUpgradeControllerInit(requestMock);
     await flushAsync();
 
-    expect(getServiceDetails).toHaveBeenCalledWith([CHAIN_IDS.ARBITRUM]);
-    expect(getDeleGatorEnvironment).toHaveBeenCalledWith(
-      Number(CHAIN_IDS.ARBITRUM),
-    );
-    expect(mockedController.init).toHaveBeenCalledWith(CHAIN_IDS.ARBITRUM, {
-      musdTokenAddress: MUSD_TOKEN_ADDRESS,
-      delegatorImplAddress: DELEGATOR_IMPL,
-      redeemerEnforcer: REDEEMER_ENFORCER,
-      valueLteEnforcer: VALUE_LTE_ENFORCER,
+    expect(mockedController.init).toHaveBeenCalledWith({
+      chainId: VAULT_CHAIN_ID,
+      boringVaultAddress: BORING_VAULT_ADDRESS,
     });
   });
 
@@ -178,45 +178,71 @@ describe('moneyAccountUpgradeControllerInit', () => {
     expect(mockedController.init).toHaveBeenCalledTimes(1);
   });
 
-  it('logs an error when CHOMP service details are missing', async () => {
-    const { requestMock } = getInitRequestMock({
-      isUnlocked: true,
-      serviceDetails: null,
-    });
+  it('logs an error when the vault config is missing', async () => {
+    jest.mocked(selectMoneyAccountVaultConfig).mockReturnValue(undefined);
+    const { requestMock } = getInitRequestMock({ isUnlocked: true });
 
     moneyAccountUpgradeControllerInit(requestMock);
     await flushAsync();
 
     expect(mockedController.init).not.toHaveBeenCalled();
     expect(Logger.error).toHaveBeenCalledWith(
       expect.objectContaining({
-        message: `Missing CHOMP service details for chain ${CHAIN_IDS.ARBITRUM}`,
+        message: 'Missing Money Account vault config',
       }),
       'MoneyAccountUpgradeController bootstrap',
     );
   });
 
-  it('logs an error when the MUSD token address is missing from service details', async () => {
-    const { requestMock } = getInitRequestMock({
-      isUnlocked: true,
-      serviceDetails: {
-        chains: {
-          [CHAIN_IDS.ARBITRUM]: {
-            protocol: { vedaProtocol: { supportedTokens: [] } },
-          },
-        },
-      },
+  describe('chain configuration', () => {
+    it('does not add the chain if it is already configured', async () => {
+      const { requestMock } = getInitRequestMock({ isUnlocked: true });
+
+      moneyAccountUpgradeControllerInit(requestMock);
+      await flushAsync();
+
+      expect(mockAddNetwork).not.toHaveBeenCalled();
+      expect(mockedController.init).toHaveBeenCalled();
     });
 
-    moneyAccountUpgradeControllerInit(requestMock);
-    await flushAsync();
+    it('adds the chain from PopularList when it is not configured', async () => {
+      jest.mocked(selectEvmNetworkConfigurationsByChainId).mockReturnValue({});
 
-    expect(mockedController.init).not.toHaveBeenCalled();
-    expect(Logger.error).toHaveBeenCalledWith(
-      expect.objectContaining({
-        message: `Missing MUSD token address for chain ${CHAIN_IDS.ARBITRUM} in CHOMP service details`,
-      }),
-      'MoneyAccountUpgradeController bootstrap',
-    );
+      const { requestMock } = getInitRequestMock({ isUnlocked: true });
+
+      moneyAccountUpgradeControllerInit(requestMock);
+      await flushAsync();
+
+      expect(mockAddNetwork).toHaveBeenCalledWith(
+        expect.objectContaining({
+          chainId: VAULT_CHAIN_ID,
+          name: 'Monad',
+        }),
+      );
+      expect(mockedController.init).toHaveBeenCalled();
+    });
+
+    it('logs an error when the missing chain is not in PopularList', async () => {
+      const UNSUPPORTED_CHAIN_ID = '0xdeadbeef' as Hex;
+      jest.mocked(selectMoneyAccountVaultConfig).mockReturnValue({
+        ...VAULT_CONFIG,
+        chainId: UNSUPPORTED_CHAIN_ID,
+      });
+      jest.mocked(selectEvmNetworkConfigurationsByChainId).mockReturnValue({});
+
+      const { requestMock } = getInitRequestMock({ isUnlocked: true });
+
+      moneyAccountUpgradeControllerInit(requestMock);
+      await flushAsync();
+
+      expect(mockAddNetwork).not.toHaveBeenCalled();
+      expect(mockedController.init).not.toHaveBeenCalled();
+      expect(Logger.error).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining(UNSUPPORTED_CHAIN_ID),
+        }),
+        'MoneyAccountUpgradeController bootstrap',
+      );
+    });
   });
 });
@@ -2,16 +2,65 @@ import {
   MoneyAccountUpgradeController,
   type MoneyAccountUpgradeControllerMessenger,
 } from '@metamask/money-account-upgrade-controller';
-import { type Hex, hexToNumber } from '@metamask/utils';
-import { CHAIN_IDS } from '@metamask/transaction-controller';
+import type { Hex } from '@metamask/utils';
+import { RpcEndpointType } from '@metamask/network-controller';
+import { toHex } from '@metamask/controller-utils';
 import type { MessengerClientInitFunction } from '../types';
 import type { MoneyAccountUpgradeControllerInitMessenger } from '../messengers/money-account-upgrade-controller-messenger';
-import { getDeleGatorEnvironment } from '../../Delegation/environment';
+import Engine from '../../Engine';
+import ReduxService from '../../redux';
+import type { RootState } from '../../../reducers';
+import { selectMoneyAccountVaultConfig } from '../../../selectors/featureFlagController/moneyAccount';
+import { selectEvmNetworkConfigurationsByChainId } from '../../../selectors/networkController';
+import { PopularList } from '../../../util/networks/customNetworks';
 import Logger from '../../../util/Logger';
 
-// TODO: source this from a feature flag (parallel to ChompApiConfig.baseUrl)
-// so we can add/swap MUSD chains without a code deploy.
-const MUSD_CHAIN_ID: Hex = CHAIN_IDS.ARBITRUM;
+/**
+ * Ensures the given chain exists in the user's NetworkController configuration.
+ * If missing, adds it from `PopularList`. The upgrade flow's
+ * `eip-7702-authorization` step calls
+ * `NetworkController:findNetworkClientIdByChainId`, which throws if the chain
+ * hasn't been configured, and Monad is not enabled by default
+ * so we need to  make sure it's there before init runs.
+ */
+const ensureChainConfigured = async (chainId: Hex): Promise<void> => {
+  const networkConfigurations = selectEvmNetworkConfigurationsByChainId(
+    ReduxService.store.getState() as RootState,
+  );
+  if (networkConfigurations[chainId]) {
+    return;
+  }
+
+  const popularEntry = PopularList.find(
+    (network) => toHex(network.chainId as string) === chainId,
+  );
+  if (!popularEntry) {
+    throw new Error(
+      `Money Account upgrade chain ${chainId} is not in PopularList; cannot auto-add to NetworkController`,
+    );
+  }
+
+  await Engine.context.NetworkController.addNetwork({
+    chainId,
+    blockExplorerUrls: popularEntry.rpcPrefs?.blockExplorerUrl
+      ? [popularEntry.rpcPrefs.blockExplorerUrl]
+      : [],
+    defaultRpcEndpointIndex: 0,
+    defaultBlockExplorerUrlIndex: popularEntry.rpcPrefs?.blockExplorerUrl
+      ? 0
+      : undefined,
+    name: popularEntry.nickname,
+    nativeCurrency: popularEntry.ticker,
+    rpcEndpoints: [
+      {
+        url: popularEntry.rpcUrl,
+        failoverUrls: popularEntry.failoverRpcUrls,
+        name: popularEntry.nickname,
+        type: RpcEndpointType.Custom,
+      },
+    ],
+  });
+};
 
 let bootstrapPromise: Promise<void> | null = null;
 
@@ -61,33 +110,20 @@ export const moneyAccountUpgradeControllerInit: MessengerClientInitFunction<
   });
 
   const bootstrap = async () => {
-    const serviceDetails = await controllerMessenger.call(
-      'ChompApiService:getServiceDetails',
-      [MUSD_CHAIN_ID],
+    const vaultConfig = selectMoneyAccountVaultConfig(
+      ReduxService.store.getState() as RootState,
     );
-
-    if (!serviceDetails) {
-      throw new Error(
-        `Missing CHOMP service details for chain ${MUSD_CHAIN_ID}`,
-      );
+    if (!vaultConfig) {
+      throw new Error('Missing Money Account vault config');
     }
 
-    const chain = serviceDetails.chains[MUSD_CHAIN_ID];
-    const musdTokenAddress =
-      chain?.protocol.vedaProtocol?.supportedTokens[0]?.tokenAddress;
-    if (!musdTokenAddress) {
-      throw new Error(
-        `Missing MUSD token address for chain ${MUSD_CHAIN_ID} in CHOMP service details`,
-      );
-    }
+    const chainId = vaultConfig.chainId as Hex;
 
-    const environment = getDeleGatorEnvironment(hexToNumber(MUSD_CHAIN_ID));
+    await ensureChainConfigured(chainId);
 
-    await controller.init(MUSD_CHAIN_ID, {
-      musdTokenAddress,
-      delegatorImplAddress: environment.EIP7702StatelessDeleGatorImpl,
-      redeemerEnforcer: environment.caveatEnforcers.RedeemerEnforcer,
-      valueLteEnforcer: environment.caveatEnforcers.ValueLteEnforcer,
+    await controller.init({
+      chainId,
+      boringVaultAddress: vaultConfig.boringVault as Hex,
     });
   };
 
 
@@ -31,9 +31,15 @@ export function getMoneyAccountUpgradeControllerMessenger(
   });
   rootMessenger.delegate({
     actions: [
+      'AuthenticatedUserStorageService:createDelegation',
+      'AuthenticatedUserStorageService:listDelegations',
       'ChompApiService:associateAddress',
+      'ChompApiService:createIntents',
       'ChompApiService:createUpgrade',
+      'ChompApiService:getIntentsByAddress',
       'ChompApiService:getServiceDetails',
+      'ChompApiService:verifyDelegation',
+      'DelegationController:signDelegation',
       'KeyringController:signEip7702Authorization',
       'KeyringController:signPersonalMessage',
       'NetworkController:findNetworkClientIdByChainId',