chore: Add Solana Devnet feature flag (#19662)

<!--
Please submit this PR as a draft initially.
Do not mark it as "Ready for review" until the template has been
completely filled out, and PR status checks have passed at least once.
-->

## **Description**

We are adding the Solana testnet feature flag, in order to open the
support for enabling the Devnet network for Solana.

## **Changelog**

<!--
If this PR is not End-User-Facing and should not show up in the
CHANGELOG, you can choose to either:
1. Write `CHANGELOG entry: null`
2. Label with `no-changelog`

If this PR is End-User-Facing, please write a short User-Facing
description in the past tense like:
`CHANGELOG entry: Added a new tab for users to see their NFTs`
`CHANGELOG entry: Fixed a bug that was causing some NFTs to flicker`

(This helps the Release Engineer do their job more quickly and
accurately)
-->

CHANGELOG entry: null

## **Related issues**

Fixes:

## **Manual testing steps**

```gherkin
Feature: my feature name

  Scenario: user [verb for user action]
    Given [describe expected initial app state]

    When user [verb for user action]
    Then [describe expected outcome]
```

## **Screenshots/Recordings**

<!-- If applicable, add screenshots and/or recordings to visualize the
before and after of your change. -->

### **Before**

<!-- [screenshots/recordings] -->

### **After**

<!-- [screenshots/recordings] -->

## **Pre-merge author checklist**

- [ ] I’ve followed [MetaMask Contributor
Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask Mobile
Coding
Standards](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/CODING_GUIDELINES.md).
- [ ] I've completed the PR template to the best of my ability
- [ ] I’ve included tests if applicable
- [ ] I’ve documented my code using [JSDoc](https://jsdoc.app/) format
if applicable
- [ ] I’ve applied the right labels on the PR (see [labeling
guidelines](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/LABELING_GUIDELINES.md)).
Not required for external contributors.

## **Pre-merge reviewer checklist**

- [ ] I've manually tested the PR (e.g. pull and build branch, run the
app, test code being changed).
- [ ] I confirm that this PR addresses all acceptance criteria described
in the ticket it closes and includes the necessary testing evidence such
as recordings and or screenshots.

Author: zone-live

app/selectors/featureFlagController/solanaTestnet/index.test.ts

@@ -0,0 +1,114 @@
+import { selectIsSolanaTestnetEnabled } from '.';
+import mockedEngine from '../../../core/__mocks__/MockedEngine';
+import { mockedEmptyFlagsState, mockedUndefinedFlagsState } from '../mocks';
+
+jest.mock('../../../core/Engine', () => ({
+  init: () => mockedEngine.init(),
+}));
+
+const originalEnv = process.env;
+beforeEach(() => {
+  jest.resetModules();
+  process.env = { ...originalEnv };
+});
+
+afterEach(() => {
+  process.env = originalEnv;
+  jest.clearAllMocks();
+});
+
+const mockedStateWithSolanaTestnetsEnabled = {
+  engine: {
+    backgroundState: {
+      RemoteFeatureFlagController: {
+        remoteFeatureFlags: {
+          solanaTestnetsEnabled: true,
+        },
+        cacheTimestamp: 0,
+      },
+    },
+  },
+};
+
+const mockedStateWithSolanaTestnetsDisabled = {
+  engine: {
+    backgroundState: {
+      RemoteFeatureFlagController: {
+        remoteFeatureFlags: {
+          solanaTestnetsEnabled: false,
+        },
+        cacheTimestamp: 0,
+      },
+    },
+  },
+};
+
+const mockedStateWithoutSolanaTestnetsFlag = {
+  engine: {
+    backgroundState: {
+      RemoteFeatureFlagController: {
+        remoteFeatureFlags: {
+          someOtherFlag: true,
+        },
+        cacheTimestamp: 0,
+      },
+    },
+  },
+};
+
+describe('Solana Testnet Feature Flag Selector', () => {
+  it('returns true when solanaTestnetsEnabled feature flag is enabled', () => {
+    const result = selectIsSolanaTestnetEnabled(
+      mockedStateWithSolanaTestnetsEnabled,
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it('returns false when solanaTestnetsEnabled feature flag is explicitly disabled', () => {
+    const result = selectIsSolanaTestnetEnabled(
+      mockedStateWithSolanaTestnetsDisabled,
+    );
+
+    expect(result).toBe(false);
+  });
+
+  it('returns undefined when solanaTestnetsEnabled feature flag property is missing', () => {
+    const result = selectIsSolanaTestnetEnabled(
+      mockedStateWithoutSolanaTestnetsFlag,
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it('returns undefined when feature flag state is empty', () => {
+    const result = selectIsSolanaTestnetEnabled(mockedEmptyFlagsState);
+
+    expect(result).toBeUndefined();
+  });
+
+  it('returns undefined when RemoteFeatureFlagController state is undefined', () => {
+    const result = selectIsSolanaTestnetEnabled(mockedUndefinedFlagsState);
+
+    expect(result).toBeUndefined();
+  });
+
+  it('handles null values correctly', () => {
+    const stateWithNullFlag = {
+      engine: {
+        backgroundState: {
+          RemoteFeatureFlagController: {
+            remoteFeatureFlags: {
+              solanaTestnetsEnabled: null,
+            },
+            cacheTimestamp: 0,
+          },
+        },
+      },
+    };
+
+    const result = selectIsSolanaTestnetEnabled(stateWithNullFlag);
+
+    expect(result).toBeNull();
+  });
+});

app/selectors/featureFlagController/solanaTestnet/index.ts

@@ -0,0 +1,7 @@
+import { createSelector } from 'reselect';
+import { selectRemoteFeatureFlags } from '..';
+
+export const selectIsSolanaTestnetEnabled = createSelector(
+  selectRemoteFeatureFlags,
+  (remoteFeatureFlags) => remoteFeatureFlags.solanaTestnetsEnabled,
+);

app/selectors/multichain/multichain.test.ts

@@ -149,6 +149,7 @@ function getNonEvmState(
   account?: InternalAccount,
   mockBtcRate?: string,
   showFiatOnTestnets: boolean = true,
+  isSolanaTestnetEnabled: boolean = false,
 ): RootState {
   const {
     MOCK_ACCOUNT_BIP122_P2WPKH: mockBtcAccount,
@@ -180,6 +181,11 @@ function getNonEvmState(
             isUnlocked: true,
           },
         },
+        RemoteFeatureFlagController: {
+          remoteFeatureFlags: {
+            solanaTestnetsEnabled: isSolanaTestnetEnabled,
+          },
+        },
         AccountsController: {
           internalAccounts: {
             selectedAccount: selectedAccount.id,
@@ -673,6 +679,109 @@ describe('MultichainNonEvm Selectors', () => {
         transactions: [],
       });
     });
+
+    it('returns mainnet transactions normally', () => {
+      const state = getNonEvmState(MOCK_SOLANA_ACCOUNT);
+
+      const mockTransactionData = {
+        transactions: [
+          {
+            id: 'sol-tx-id',
+            timestamp: 1733736433,
+            chain: SolScope.Mainnet,
+            status: 'confirmed' as const,
+            type: 'send' as const,
+            account: MOCK_SOLANA_ACCOUNT.id,
+            from: [],
+            to: [],
+            fees: [],
+            events: [],
+          },
+        ],
+        next: null,
+        lastUpdated: Date.now(),
+      };
+
+      state.engine.backgroundState.MultichainTransactionsController.nonEvmTransactions =
+        {
+          [MOCK_SOLANA_ACCOUNT.id]: {
+            [SolScope.Mainnet]: mockTransactionData,
+          },
+        };
+
+      expect(selectNonEvmTransactions(state)).toEqual(mockTransactionData);
+    });
+
+    it('blocks devnet transactions when feature flag is disabled', () => {
+      const state = getNonEvmState(MOCK_SOLANA_ACCOUNT, undefined, true, false);
+      state.engine.backgroundState.MultichainNetworkController.selectedMultichainNetworkChainId =
+        SolScope.Devnet;
+
+      state.engine.backgroundState.MultichainTransactionsController.nonEvmTransactions =
+        {
+          [MOCK_SOLANA_ACCOUNT.id]: {
+            [SolScope.Devnet]: {
+              transactions: [
+                {
+                  id: 'devnet-tx',
+                  timestamp: 1733736433,
+                  chain: SolScope.Devnet,
+                  status: 'confirmed' as const,
+                  type: 'send' as const,
+                  account: MOCK_SOLANA_ACCOUNT.id,
+                  from: [],
+                  to: [],
+                  fees: [],
+                  events: [],
+                },
+              ],
+              next: null,
+              lastUpdated: Date.now(),
+            },
+          },
+        };
+
+      // Returns empty state when devnet is selected but feature flag is disabled
+      expect(selectNonEvmTransactions(state)).toEqual({
+        lastUpdated: 0,
+        next: null,
+        transactions: [],
+      });
+    });
+
+    it('allows devnet transactions when feature flag is enabled', () => {
+      const state = getNonEvmState(MOCK_SOLANA_ACCOUNT, undefined, true, true);
+      state.engine.backgroundState.MultichainNetworkController.selectedMultichainNetworkChainId =
+        SolScope.Devnet;
+
+      const mockDevnetData = {
+        transactions: [
+          {
+            id: 'devnet-tx',
+            timestamp: 1733736433,
+            chain: SolScope.Devnet,
+            status: 'confirmed' as const,
+            type: 'send' as const,
+            account: MOCK_SOLANA_ACCOUNT.id,
+            from: [],
+            to: [],
+            fees: [],
+            events: [],
+          },
+        ],
+        next: null,
+        lastUpdated: Date.now(),
+      };
+
+      state.engine.backgroundState.MultichainTransactionsController.nonEvmTransactions =
+        {
+          [MOCK_SOLANA_ACCOUNT.id]: {
+            [SolScope.Devnet]: mockDevnetData,
+          },
+        };
+
+      expect(selectNonEvmTransactions(state)).toEqual(mockDevnetData);
+    });
   });
 
   describe('selectMultichainHistoricalPrices', () => {

app/selectors/multichain/multichain.ts

@@ -12,11 +12,12 @@ import {
   selectSelectedInternalAccount,
 } from '../accountsController';
 import { createDeepEqualSelector } from '../util';
-import { Balance } from '@metamask/keyring-api';
+import { Balance, SolScope } from '@metamask/keyring-api';
 import { selectConversionRate } from '../currencyRateController';
 import { isMainNet } from '../../util/networks';
 import { selectAccountBalanceByChainId } from '../accountTrackerController';
 import { selectShowFiatInTestnets } from '../settings';
+import { selectIsSolanaTestnetEnabled } from '../featureFlagController/solanaTestnet';
 import {
   selectIsEvmNetworkSelected,
   selectSelectedNonEvmNetworkChainId,
@@ -403,7 +404,13 @@ export const selectNonEvmTransactions = createDeepEqualSelector(
   selectMultichainTransactions,
   selectSelectedInternalAccount,
   selectSelectedNonEvmNetworkChainId,
-  (nonEvmTransactions, selectedAccount, selectedNonEvmNetworkChainId) => {
+  selectIsSolanaTestnetEnabled,
+  (
+    nonEvmTransactions,
+    selectedAccount,
+    selectedNonEvmNetworkChainId,
+    isSolanaTestnetEnabled,
+  ) => {
     if (!selectedAccount) {
       return DEFAULT_TRANSACTION_STATE_ENTRY;
     }
@@ -413,6 +420,15 @@ export const selectNonEvmTransactions = createDeepEqualSelector(
       return DEFAULT_TRANSACTION_STATE_ENTRY;
     }
 
+    // If trying to access devnet transactions but feature flag is disabled, return the default transaction state entry
+    if (
+      selectedNonEvmNetworkChainId === SolScope.Devnet &&
+      !isSolanaTestnetEnabled
+    ) {
+      return DEFAULT_TRANSACTION_STATE_ENTRY;
+    }
+
+    // For all other cases, return transactions for the selected chain
     return (
       accountTransactions[selectedNonEvmNetworkChainId] ??
       DEFAULT_TRANSACTION_STATE_ENTRY

app/selectors/multichainNetworkController/index.ts

@@ -7,11 +7,12 @@ import {
   type MultichainNetworkConfiguration,
 } from '@metamask/multichain-network-controller';
 import { toHex } from '@metamask/controller-utils';
-import { CaipChainId } from '@metamask/utils';
+import { CaipChainId, Json } from '@metamask/utils';
 import { BtcScope, SolScope, EthScope } from '@metamask/keyring-api';
 import { RootState } from '../../reducers';
 import imageIcons from '../../images/image-icons';
 import { createDeepEqualSelector } from '../util';
+import { selectIsSolanaTestnetEnabled } from '../featureFlagController/solanaTestnet';
 
 export const selectMultichainNetworkControllerState = (state: RootState) =>
   state.engine.backgroundState?.MultichainNetworkController;
@@ -36,8 +37,12 @@ export const selectSelectedNonEvmNetworkChainId = createDeepEqualSelector(
  * @returns An object where the keys are chain IDs and the values are network configurations.
  */
 export const selectNonEvmNetworkConfigurationsByChainId = createSelector(
-  selectMultichainNetworkControllerState,
-  (multichainNetworkControllerState: MultichainNetworkControllerState) => {
+  [selectMultichainNetworkControllerState, selectIsSolanaTestnetEnabled],
+  (
+    multichainNetworkControllerState: MultichainNetworkControllerState,
+    isSolanaTestnetEnabled: Json,
+  ) => {
+    const isSolanaTestnetEnabledBoolean = Boolean(isSolanaTestnetEnabled);
     const extendedNonEvmData: Record<
       CaipChainId,
       {
@@ -54,6 +59,13 @@ export const selectNonEvmNetworkConfigurationsByChainId = createSelector(
         ticker: MULTICHAIN_NETWORK_TICKER[SolScope.Mainnet],
         isTestnet: false,
       },
+      [SolScope.Devnet]: {
+        decimals: MULTICHAIN_NETWORK_DECIMAL_PLACES[SolScope.Devnet],
+        imageSource: imageIcons.SOLANA,
+        ticker: MULTICHAIN_NETWORK_TICKER[SolScope.Devnet],
+        isTestnet: true,
+        name: 'Solana Devnet',
+      },
       [BtcScope.Mainnet]: {
         decimals: MULTICHAIN_NETWORK_DECIMAL_PLACES[BtcScope.Mainnet],
         imageSource: imageIcons.BTC,
@@ -98,6 +110,7 @@ export const selectNonEvmNetworkConfigurationsByChainId = createSelector(
       BtcScope.Signet,
       ///: END:ONLY_INCLUDE_IF
       SolScope.Mainnet,
+      ...(isSolanaTestnetEnabledBoolean ? [SolScope.Devnet] : []),
     ];
 
     const nonEvmNetworks: Record<CaipChainId, MultichainNetworkConfiguration> =