feat: enable STX by default with migration and notification

app/scripts/controllers/preferences-controller.ts

@@ -406,6 +406,12 @@ const controllerMetadata = {
   preferences: {
     persist: true,
     anonymous: true,
+    properties: {
+      smartTransactionsOptInStatus: {
+        persist: true,
+        anonymous: true,
+      },
+    },
   },
   ipfsGateway: {
     persist: true,
@@ -457,6 +463,10 @@ const controllerMetadata = {
   },
   isMultiAccountBalancesEnabled: { persist: true, anonymous: true },
   showIncomingTransactions: { persist: true, anonymous: true },
+  smartTransactionsOptInStatus: {
+    persist: true,
+    anonymous: true,
+  },
 };
 
 export class PreferencesController extends BaseController<
@@ -925,11 +935,14 @@ export class PreferencesController extends BaseController<
     preference: keyof Preferences,
     value: Preferences[typeof preference],
   ): Preferences {
+    console.log('Setting preference:', { preference, value });
     const currentPreferences = this.getPreferences();
+    console.log('Current preferences:', currentPreferences);
     const updatedPreferences = {
       ...currentPreferences,
       [preference]: value,
     };
+    console.log('Updated preferences:', updatedPreferences);
 
     this.update((state) => {
       state.preferences = updatedPreferences;

app/scripts/migrations/135.test.ts

@@ -0,0 +1,131 @@
+import { SmartTransaction } from '@metamask/smart-transactions-controller/dist/types';
+import { migrate, VersionedData } from './135';
+
+const prevVersion = 134;
+
+describe('migration #135', () => {
+  const mockSmartTransaction: SmartTransaction = {
+    uuid: 'test-uuid',
+  };
+
+  it('should update the version metadata', async () => {
+    const oldStorage: VersionedData = {
+      meta: { version: prevVersion },
+      data: {},
+    };
+
+    const newStorage = await migrate(oldStorage);
+    expect(newStorage.meta).toStrictEqual({ version: 135 });
+  });
+
+  it('should set stx opt-in to true when stx opt-in status is null', async () => {
+    const oldStorage: VersionedData = {
+      meta: { version: prevVersion },
+      data: {
+        PreferencesController: {
+          smartTransactionsOptInStatus: null,
+        },
+      },
+    };
+
+    const newStorage = await migrate(oldStorage);
+    expect(
+      newStorage.data.PreferencesController?.smartTransactionsOptInStatus,
+    ).toBe(true);
+  });
+
+  it('should set stx opt-in to true when stx opt-in status is undefined', async () => {
+    const oldStorage: VersionedData = {
+      meta: { version: prevVersion },
+      data: {
+        PreferencesController: {},
+      },
+    };
+
+    const newStorage = await migrate(oldStorage);
+    expect(
+      newStorage.data.PreferencesController?.smartTransactionsOptInStatus,
+    ).toBe(true);
+  });
+
+  it('should set stx opt-in to true when stx opt-in is false and no existing smart transactions', async () => {
+    const oldStorage: VersionedData = {
+      meta: { version: prevVersion },
+      data: {
+        PreferencesController: {
+          smartTransactionsOptInStatus: false,
+        },
+        SmartTransactionsController: {
+          smartTransactionsState: {
+            smartTransactions: {},
+          },
+        },
+      },
+    };
+
+    const newStorage = await migrate(oldStorage);
+    expect(
+      newStorage.data.PreferencesController?.smartTransactionsOptInStatus,
+    ).toBe(true);
+  });
+
+  it('should not change stx opt-in when stx opt-in is false but has existing smart transactions', async () => {
+    const oldStorage: VersionedData = {
+      meta: { version: prevVersion },
+      data: {
+        PreferencesController: {
+          smartTransactionsOptInStatus: false,
+        },
+        SmartTransactionsController: {
+          smartTransactionsState: {
+            smartTransactions: {
+              '0x1': [mockSmartTransaction],
+            },
+          },
+        },
+      },
+    };
+
+    const newStorage = await migrate(oldStorage);
+    expect(
+      newStorage.data.PreferencesController?.smartTransactionsOptInStatus,
+    ).toBe(false);
+  });
+
+  it('should not change stx opt-in when stx opt-in is already true', async () => {
+    const oldStorage: VersionedData = {
+      meta: { version: prevVersion },
+      data: {
+        PreferencesController: {
+          smartTransactionsOptInStatus: true,
+        },
+      },
+    };
+
+    const newStorage = await migrate(oldStorage);
+    expect(
+      newStorage.data.PreferencesController?.smartTransactionsOptInStatus,
+    ).toBe(true);
+  });
+
+  it('should capture exception if PreferencesController state is invalid', async () => {
+    const sentryCaptureExceptionMock = jest.fn();
+    global.sentry = {
+      captureException: sentryCaptureExceptionMock,
+    };
+
+    const oldStorage = {
+      meta: { version: prevVersion },
+      data: {
+        PreferencesController: 'invalid',
+      },
+    } as unknown as VersionedData;
+
+    const newStorage = await migrate(oldStorage);
+
+    expect(sentryCaptureExceptionMock).toHaveBeenCalledTimes(1);
+    expect(sentryCaptureExceptionMock).toHaveBeenCalledWith(
+      new Error('Invalid PreferencesController state: string'),
+    );
+  });
+});

app/scripts/migrations/135.ts

@@ -0,0 +1,101 @@
+import { hasProperty, isObject } from '@metamask/utils';
+import { cloneDeep } from 'lodash';
+import type { SmartTransaction } from '@metamask/smart-transactions-controller/dist/types';
+
+export type VersionedData = {
+  meta: {
+    version: number;
+  };
+  data: {
+    PreferencesController?: {
+      preferences?: {
+        smartTransactionsOptInStatus?: boolean | null;
+      };
+      smartTransactionsOptInStatus?: boolean | null;
+    };
+    SmartTransactionsController?: {
+      smartTransactionsState: {
+        smartTransactions: Record<string, SmartTransaction[]>;
+      };
+    };
+  };
+};
+
+export const version = 135;
+
+function transformState(state: VersionedData['data']) {
+  console.log('Migration 135 state:', JSON.stringify(state, null, 2));
+  console.log('Migration 135, Transform state input:', state);
+  if (
+    !hasProperty(state, 'PreferencesController') ||
+    !isObject(state.PreferencesController)
+  ) {
+    global.sentry?.captureException?.(
+      new Error(
+        `Invalid PreferencesController state: ${typeof state.PreferencesController}`,
+      ),
+    );
+    console.log('Migration 135 - Invalid PreferencesController');
+    return state;
+  }
+
+  const { PreferencesController } = state;
+  const currentOptInStatus =
+    PreferencesController?.smartTransactionsOptInStatus;
+    console.log('Migration 135 - Current STX Status:', currentOptInStatus);
+
+  if (currentOptInStatus === undefined || currentOptInStatus === null) {
+    console.log('Migration 135 - Setting null/undefined status to true');
+    PreferencesController.smartTransactionsOptInStatus = true;
+  } else if (
+    currentOptInStatus === false &&
+    !hasExistingSmartTransactions(state)
+  ) {
+    console.log('Migration 135 - Setting false status to true (no existing transactions)');
+    PreferencesController.smartTransactionsOptInStatus = true;
+  }
+  console.log('Migration 135 - Final State:', JSON.stringify(state, null, 2));
+  if (!state.PreferencesController.preferences) {
+    state.PreferencesController.preferences = {};
+  }
+
+  const { preferences } = state.PreferencesController;
+  preferences.smartTransactionsOptInStatus = true;
+
+  return state;
+}
+
+function hasExistingSmartTransactions(state: VersionedData['data']): boolean {
+  if (
+    !hasProperty(state, 'SmartTransactionsController') ||
+    !isObject(
+      state.SmartTransactionsController?.smartTransactionsState
+        ?.smartTransactions,
+    )
+  ) {
+    return false;
+  }
+
+  const { smartTransactions } =
+    state.SmartTransactionsController.smartTransactionsState;
+
+  return Object.values(smartTransactions).some(
+    (chainSmartTransactions: SmartTransaction[]) =>
+      chainSmartTransactions.length > 0,
+  );
+}
+
+export async function migrate(
+  originalVersionedData: VersionedData,
+): Promise<VersionedData> {
+  console.log('=== MIGRATION 135 START ===');
+  console.log('Original version:', originalVersionedData.meta.version);
+  console.log('Original data:', JSON.stringify(originalVersionedData.data, null, 2));
+  const versionedData = cloneDeep(originalVersionedData);
+  console.log('STX status before:', versionedData.data?.PreferencesController?.smartTransactionsOptInStatus);
+  versionedData.meta.version = version;
+  transformState(versionedData.data);
+  console.log('STX status after:', versionedData.data?.PreferencesController?.smartTransactionsOptInStatus);
+  console.log('=== MIGRATION 135 END ===');
+  return versionedData;
+}

app/scripts/migrations/index.js

@@ -155,6 +155,7 @@ const migrations = [
   require('./132'),
   require('./133'),
   require('./134'),
+  require('./135'),
 ];
 
 export default migrations;

shared/constants/alerts.ts

@@ -2,6 +2,7 @@ export enum AlertTypes {
   unconnectedAccount = 'unconnectedAccount',
   web3ShimUsage = 'web3ShimUsage',
   invalidCustomNetwork = 'invalidCustomNetwork',
+  stxMigration = 'stxMigration',
 }
 
 /**
@@ -10,6 +11,7 @@ export enum AlertTypes {
 export const TOGGLEABLE_ALERT_TYPES = [
   AlertTypes.unconnectedAccount,
   AlertTypes.web3ShimUsage,
+  AlertTypes.stxMigration,
 ];
 
 export enum Web3ShimUsageAlertStates {

ui/ducks/alerts/index.js

@@ -1,4 +1,5 @@
 export { default as unconnectedAccount } from './unconnected-account';
 export { default as invalidCustomNetwork } from './invalid-custom-network';
+export { default as stxMigration } from './stx-migration';
 
 export { ALERT_STATE } from './enums';

ui/ducks/alerts/stx-migration.js

@@ -0,0 +1,34 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { AlertTypes } from '../../../shared/constants/alerts';
+import { ALERT_STATE } from './enums';
+
+const name = AlertTypes.stxMigration;
+
+const initialState = {
+  state: ALERT_STATE.CLOSED,
+};
+
+const slice = createSlice({
+  name,
+  initialState,
+  reducers: {
+    showSTXMigrationAlert: (state) => {
+      state.state = ALERT_STATE.OPEN;
+    },
+    dismissSTXMigrationAlert: (state) => {
+      state.state = ALERT_STATE.CLOSED;
+    },
+  },
+});
+
+const { actions, reducer } = slice;
+
+// Selectors
+export const getSTXAlertState = (state) => state.metamask.alerts?.[name]?.state;
+export const stxAlertIsOpen = (state) =>
+  state.metamask.alerts?.[name]?.state === ALERT_STATE.OPEN;
+
+// Actions
+export const { showSTXMigrationAlert, dismissSTXMigrationAlert } = actions;
+
+export default reducer;

ui/helpers/constants/zendesk-url.js

@@ -49,6 +49,8 @@ const ZENDESK_URLS = {
     'https://support.metamask.io/networks-and-sidechains/managing-networks/verifying-custom-network-information/',
   NETWORK_DEPRECATED:
     'https://support.metamask.io/networks-and-sidechains/eth-on-testnets/',
+  SMART_TRANSACTIONS_LEARN_MORE:
+    'https://support.metamask.io/transactions-and-gas/transactions/smart-transactions/',
 };
 
 export default ZENDESK_URLS;

ui/pages/confirmations/components/stx-banner-alert/index.js

@@ -0,0 +1 @@
+export { default as STXBannerAlert } from './stx-banner-alert';