diff --git a/app/scripts/metamask-controller.js b/app/scripts/metamask-controller.js
index fb878eb0f604..c25ce85a5f6e 100644
--- a/app/scripts/metamask-controller.js
+++ b/app/scripts/metamask-controller.js
@@ -48,6 +48,7 @@ import {
   BRIDGE_CONTROLLER_NAME,
   BridgeUserAction,
   BridgeBackgroundAction,
+  calcLatestSrcBalance,
 } from '@metamask/bridge-controller';
 
 import {
@@ -3179,6 +3180,19 @@ export default class MetamaskController extends EventEmitter {
         this.controllerMessenger,
         `${BRIDGE_CONTROLLER_NAME}:${BridgeBackgroundAction.FETCH_QUOTES}`,
       ),
+      getBalanceAmount: async (selectedAddress, tokenAddress, chainId) => {
+        const networkClientId =
+          await this.networkController.findNetworkClientIdByChainId(chainId);
+        const networkClient =
+          await this.networkController.getNetworkClientById(networkClientId);
+        const balance = await calcLatestSrcBalance(
+          networkClient.provider,
+          selectedAddress,
+          tokenAddress,
+          chainId,
+        );
+        return balance?.toString();
+      },
 
       // Bridge Tx submission
       [BridgeStatusAction.SUBMIT_TX]: this.controllerMessenger.call.bind(
diff --git a/shared/constants/bridge.ts b/shared/constants/bridge.ts
index f3dc6b0f832d..27b05f15718c 100644
--- a/shared/constants/bridge.ts
+++ b/shared/constants/bridge.ts
@@ -3,9 +3,14 @@ import {
   BRIDGE_DEV_API_BASE_URL,
   BRIDGE_PROD_API_BASE_URL,
   ChainId,
+  formatChainIdToCaip,
 } from '@metamask/bridge-controller';
 import { MultichainNetworks } from './multichain/networks';
-import { CHAIN_IDS, NETWORK_TO_NAME_MAP } from './network';
+import {
+  CHAIN_ID_TO_NETWORK_IMAGE_URL_MAP,
+  CHAIN_IDS,
+  NETWORK_TO_NAME_MAP,
+} from './network';
 
 const ALLOWED_MULTICHAIN_BRIDGE_CHAIN_IDS = [
   MultichainNetworks.SOLANA,
@@ -95,6 +100,18 @@ export const NETWORK_TO_SHORT_NETWORK_NAME_MAP: Record<
   ///: END:ONLY_INCLUDE_IF
 };
 
+export const BRIDGE_CHAIN_ID_TO_NETWORK_IMAGE_MAP: Record<
+  (typeof ALLOWED_BRIDGE_CHAIN_IDS_IN_CAIP)[number],
+  string
+> = ALLOWED_BRIDGE_CHAIN_IDS.reduce(
+  (acc, chainId) => {
+    acc[formatChainIdToCaip(chainId)] =
+      CHAIN_ID_TO_NETWORK_IMAGE_URL_MAP[chainId];
+    return acc;
+  },
+  {} as Record<(typeof ALLOWED_BRIDGE_CHAIN_IDS_IN_CAIP)[number], string>,
+);
+
 export const STATIC_METAMASK_BASE_URL = 'https://static.cx.metamask.io';
 
 export const BRIDGE_CHAINID_COMMON_TOKEN_PAIR: Partial<
diff --git a/shared/lib/asset-utils.ts b/shared/lib/asset-utils.ts
index bc2743ec6a1e..5cc9907bc039 100644
--- a/shared/lib/asset-utils.ts
+++ b/shared/lib/asset-utils.ts
@@ -24,10 +24,18 @@ import { TEN_SECONDS_IN_MILLISECONDS } from './transactions-controller-utils';
 const TOKEN_API_V3_BASE_URL = 'https://tokens.api.cx.metamask.io/v3';
 const STATIC_METAMASK_BASE_URL = 'https://static.cx.metamask.io';
 
+/**
+ * Converts an address and chainId to a CAIP asset type
+ *
+ * @param address - The address of the asset
+ * @param chainId - The chainId of the asset
+ * @returns The CAIP asset type
+ * @throws An error if the chainId is not supported by the Swap and Bridge APIs
+ */
 export const toAssetId = (
   address: Hex | CaipAssetType | string,
   chainId: CaipChainId,
-): CaipAssetType | undefined => {
+): CaipAssetType => {
   if (isCaipAssetType(address)) {
     return address;
   }
@@ -43,7 +51,7 @@ export const toAssetId = (
       `${chainId}/erc20:${address.toLowerCase()}`,
     );
   }
-  return undefined;
+  throw new Error(`Invalid address or chainId: ${address} ${chainId}`);
 };
 
 /**
diff --git a/test/data/bridge/mock-bridge-store.ts b/test/data/bridge/mock-bridge-store.ts
index 35902a7a0f8e..1c73f8bf851b 100644
--- a/test/data/bridge/mock-bridge-store.ts
+++ b/test/data/bridge/mock-bridge-store.ts
@@ -352,24 +352,8 @@ export const createBridgeMockStore = ({
             support: false,
             refreshRate: 5000,
             maxRefreshCount: 5,
-            ...featureFlagOverrides?.extensionConfig,
+            chainRanking: [{ chainId: formatChainIdToCaip(CHAIN_IDS.MAINNET) }],
             ...featureFlagOverrides?.bridgeConfig,
-            chains: {
-              [formatChainIdToCaip('0x1')]: {
-                isActiveSrc: true,
-                isActiveDest: false,
-              },
-              ...Object.fromEntries(
-                Object.entries(
-                  featureFlagOverrides?.extensionConfig?.chains ??
-                    featureFlagOverrides?.bridgeConfig?.chains ??
-                    {},
-                ).map(([chainId, config]) => [
-                  formatChainIdToCaip(chainId),
-                  config,
-                ]),
-              ),
-            },
           },
         },
       },
diff --git a/ui/ducks/bridge/actions.ts b/ui/ducks/bridge/actions.ts
index 167d4748d509..079503973c82 100644
--- a/ui/ducks/bridge/actions.ts
+++ b/ui/ducks/bridge/actions.ts
@@ -4,50 +4,46 @@ import {
   BridgeUserAction,
   formatChainIdToCaip,
   isNativeAddress,
-  getNativeAssetForChainId,
   type RequiredEventContextFromClient,
   UnifiedSwapBridgeEventName,
+  formatChainIdToHex,
 } from '@metamask/bridge-controller';
-import { type InternalAccount } from '@metamask/keyring-internal-api';
-import { type CaipChainId } from '@metamask/utils';
-import type {
-  AddNetworkFields,
-  NetworkConfiguration,
-} from '@metamask/network-controller';
+import { type Hex } from '@metamask/utils';
+import { zeroAddress } from 'ethereumjs-util';
 import { trace, TraceName } from '../../../shared/lib/trace';
-import {
-  forceUpdateMetamaskState,
-  setActiveNetworkWithError,
-} from '../../store/actions';
+import { forceUpdateMetamaskState } from '../../store/actions';
 import { submitRequestToBackground } from '../../store/background-connection';
-import type { MetaMaskReduxDispatch } from '../../store/store';
+import { getInternalAccountBySelectedAccountGroupAndCaip } from '../../selectors/multichain-accounts/account-tree';
+import type {
+  MetaMaskReduxDispatch,
+  MetaMaskReduxState,
+} from '../../store/store';
 import {
   bridgeSlice,
   setDestTokenExchangeRates,
   setDestTokenUsdExchangeRates,
   setSrcTokenExchangeRates,
   setTxAlerts,
-  setEVMSrcTokenBalance as setEVMSrcTokenBalance_,
-  setEVMSrcNativeBalance,
 } from './bridge';
-import type { TokenPayload } from './types';
-import { isNetworkAdded, isNonEvmChain } from './utils';
+import type { BridgeToken } from './types';
+import { isNonEvmChain } from './utils';
 
 const {
-  setToChainId,
   setFromToken,
   setToToken,
   setFromTokenInputValue,
+  setEVMSrcTokenBalance,
+  setEVMSrcNativeBalance,
   resetInputFields,
   setSortOrder,
   setSelectedQuote,
   setWasTxDeclined,
   setSlippage,
   restoreQuoteRequestFromState,
+  switchTokens,
 } = bridgeSlice.actions;
 
 export {
-  setToChainId,
   resetInputFields,
   setToToken,
   setFromToken,
@@ -60,17 +56,18 @@ export {
   setWasTxDeclined,
   setSlippage,
   setTxAlerts,
-  setEVMSrcNativeBalance,
   restoreQuoteRequestFromState,
+  switchTokens,
 };
 
 const callBridgeControllerMethod = (
-  bridgeAction: BridgeUserAction | BridgeBackgroundAction,
+  bridgeAction: BridgeUserAction | BridgeBackgroundAction | 'getBalanceAmount',
   ...args: unknown[]
 ) => {
   return async (dispatch: MetaMaskReduxDispatch) => {
-    await submitRequestToBackground(bridgeAction, args);
+    const result = await submitRequestToBackground(bridgeAction, args);
     await forceUpdateMetamaskState(dispatch);
+    return result;
   };
 };
 
@@ -119,96 +116,76 @@ export const updateQuoteRequestParams = (
   };
 };
 
-export const setEVMSrcTokenBalance = (
-  token: TokenPayload['payload'],
-  selectedAddress?: string,
+const getEVMBalance = async (
+  accountAddress: string,
+  chainId: Hex,
+  address?: string,
 ) => {
-  return async (dispatch: MetaMaskReduxDispatch) => {
-    if (token) {
-      trace({
-        name: TraceName.BridgeBalancesUpdated,
-        data: {
-          srcChainId: formatChainIdToCaip(token.chainId),
-          isNative: isNativeAddress(token.address),
-        },
-        startTime: Date.now(),
-      });
-      await dispatch(
-        setEVMSrcTokenBalance_({
-          selectedAddress,
-          tokenAddress: token.address,
-          chainId: token.chainId,
-        }),
-      );
-    }
-  };
+  return async (dispatch: MetaMaskReduxDispatch) =>
+    ((await dispatch(
+      await callBridgeControllerMethod(
+        'getBalanceAmount',
+        accountAddress,
+        address || zeroAddress(),
+        chainId,
+      ),
+    )) as string) || null;
 };
 
-export const setFromChain = ({
-  networkConfig,
-  selectedAccount,
-  token = null,
-}: {
-  networkConfig?:
-    | NetworkConfiguration
-    | AddNetworkFields
-    | (Omit<NetworkConfiguration, 'chainId'> & { chainId: CaipChainId });
-  selectedAccount: InternalAccount | null;
-  token?: TokenPayload['payload'];
-}) => {
-  return async (dispatch: MetaMaskReduxDispatch) => {
-    if (!networkConfig) {
-      return;
-    }
+/**
+ * This action reads the latest on chain balance for the selected token and its chain's native token
+ * It also traces the balance update.
+ *
+ * @param token - The token to fetch the balance for
+ */
+export const setLatestEVMBalances = (token: BridgeToken) => {
+  return async (
+    dispatch: MetaMaskReduxDispatch,
+    getState: () => MetaMaskReduxState,
+  ) => {
+    const { chainId, assetId, address } = token;
 
-    // Check for ALL non-EVM chains
-    const isNonEvm = isNonEvmChain(networkConfig.chainId);
-
-    // Set the src network
-    if (isNonEvm) {
-      dispatch(setActiveNetworkWithError(networkConfig.chainId));
-    } else {
-      const networkId = isNetworkAdded(networkConfig)
-        ? networkConfig.rpcEndpoints?.[networkConfig.defaultRpcEndpointIndex]
-            ?.networkClientId
-        : null;
-      if (networkId) {
-        dispatch(setActiveNetworkWithError(networkId));
-      }
+    if (isNonEvmChain(chainId)) {
+      return null;
     }
-
-    // Set the src token - if no token provided, set native token for non-EVM chains
-    if (token) {
-      dispatch(setFromToken(token));
-    } else if (isNonEvm) {
-      // Auto-select native token for non-EVM chains when switching
-      const nativeAsset = getNativeAssetForChainId(networkConfig.chainId);
-      if (nativeAsset) {
-        dispatch(
-          setFromToken({
-            ...nativeAsset,
-            chainId: networkConfig.chainId,
-          }),
-        );
-      }
+    const hexChainId = formatChainIdToHex(chainId);
+    const caipChainId = formatChainIdToCaip(hexChainId);
+    const account = getInternalAccountBySelectedAccountGroupAndCaip(
+      getState(),
+      caipChainId,
+    );
+    if (!account?.address) {
+      return null;
     }
 
-    // Fetch the native balance (EVM only)
-    if (selectedAccount && !isNonEvm) {
-      trace({
+    return await trace(
+      {
         name: TraceName.BridgeBalancesUpdated,
         data: {
-          srcChainId: formatChainIdToCaip(networkConfig.chainId),
-          isNative: true,
+          chainId,
+          isNative: isNativeAddress(address),
         },
         startTime: Date.now(),
-      });
-      await dispatch(
-        setEVMSrcNativeBalance({
-          selectedAddress: selectedAccount.address,
-          chainId: networkConfig.chainId,
-        }),
-      );
-    }
+      },
+      async () => {
+        dispatch(
+          setEVMSrcTokenBalance({
+            balance: await dispatch(
+              await getEVMBalance(account.address, hexChainId, address),
+            ),
+            assetId,
+          }),
+        );
+
+        dispatch(
+          setEVMSrcNativeBalance({
+            balance: await dispatch(
+              await getEVMBalance(account.address, hexChainId),
+            ),
+            chainId,
+          }),
+        );
+      },
+    );
   };
 };
diff --git a/ui/ducks/bridge/bridge.ts b/ui/ducks/bridge/bridge.ts
index 7d1d004856f8..ebc67744b916 100644
--- a/ui/ducks/bridge/bridge.ts
+++ b/ui/ducks/bridge/bridge.ts
@@ -1,25 +1,16 @@
 import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
 import {
   SortOrder,
-  formatChainIdToCaip,
   getNativeAssetForChainId,
-  calcLatestSrcBalance,
-  isNonEvmChainId,
-  isCrossChain,
-  formatChainIdToHex,
-  type GenericQuoteRequest,
   type QuoteResponse,
-  isBitcoinChainId,
 } from '@metamask/bridge-controller';
-import { zeroAddress } from 'ethereumjs-util';
+import { type CaipAssetType } from '@metamask/utils';
 import { fetchTxAlerts } from '../../../shared/modules/bridge-utils/security-alerts-api.util';
-import { endTrace, TraceName } from '../../../shared/lib/trace';
 import { SlippageValue } from '../../pages/bridge/utils/slippage-service';
 import { getTokenExchangeRate, toBridgeToken } from './utils';
-import type { BridgeState, ChainIdPayload, TokenPayload } from './types';
+import type { BridgeState, BridgeToken, TokenPayload } from './types';
 
 const initialState: BridgeState = {
-  toChainId: null,
   fromToken: null,
   toToken: null,
   fromTokenInputValue: null,
@@ -55,80 +46,38 @@ export const setTxAlerts = createAsyncThunk(
   fetchTxAlerts,
 );
 
-const getBalanceAmount = async ({
-  selectedAddress,
-  tokenAddress,
-  chainId,
-}: {
-  selectedAddress?: string;
-  tokenAddress: string;
-  chainId: GenericQuoteRequest['srcChainId'];
-}) => {
-  if (isNonEvmChainId(chainId) || !selectedAddress) {
-    return null;
-  }
-  return (
-    await calcLatestSrcBalance(
-      global.ethereumProvider,
-      selectedAddress,
-      tokenAddress,
-      formatChainIdToHex(chainId),
-    )
-  )?.toString();
-};
-
-export const setEVMSrcNativeBalance = createAsyncThunk(
-  'bridge/setEVMSrcNativeBalance',
-  async ({
-    selectedAddress,
-    chainId,
-  }: Omit<Parameters<typeof getBalanceAmount>[0], 'tokenAddress'>) =>
-    await getBalanceAmount({
-      selectedAddress,
-      tokenAddress: zeroAddress(),
-      chainId,
-    }),
-);
-
-export const setEVMSrcTokenBalance = createAsyncThunk(
-  'bridge/setEVMSrcTokenBalance',
-  getBalanceAmount,
-);
-
 const bridgeSlice = createSlice({
   name: 'bridge',
   initialState: { ...initialState },
   reducers: {
-    setToChainId: (state, { payload }: ChainIdPayload) => {
-      state.toChainId = payload ? formatChainIdToCaip(payload) : null;
-      state.toToken = null;
+    switchTokens: (
+      state,
+      {
+        payload: { fromToken, toToken },
+      }: { payload: { fromToken: BridgeToken; toToken: BridgeToken } },
+    ) => {
+      state.fromToken = toToken;
+      state.toToken = fromToken;
+      state.fromNativeBalance = null;
+      state.fromTokenBalance = null;
     },
     setFromToken: (state, { payload }: TokenPayload) => {
-      state.fromToken = toBridgeToken(payload);
+      state.fromToken = payload ? toBridgeToken(payload) : null;
+      state.fromTokenBalance = null;
+      state.fromNativeBalance = null;
       state.fromTokenBalance = null;
       // Unset toToken if it's the same as the fromToken
       if (
         state.fromToken?.assetId &&
         state.toToken?.assetId &&
-        // TODO: determine if this is necessary.
         state.fromToken.assetId?.toLowerCase() ===
           state.toToken.assetId?.toLowerCase()
       ) {
         state.toToken = null;
       }
-      // if new fromToken is BTC, and toToken is BTC, unset toChain and toToken
-      if (
-        state.fromToken?.chainId &&
-        isBitcoinChainId(state.fromToken.chainId) &&
-        state.toChainId &&
-        isBitcoinChainId(state.toChainId)
-      ) {
-        state.toChainId = null;
-        state.toToken = null;
-      }
     },
     setToToken: (state, { payload }: TokenPayload) => {
-      const toToken = toBridgeToken(payload);
+      const toToken = payload ? toBridgeToken(payload) : null;
       state.toToken = toToken
         ? {
             ...toToken,
@@ -137,16 +86,6 @@ const bridgeSlice = createSlice({
               getNativeAssetForChainId(toToken.chainId)?.address,
           }
         : toToken;
-      // Update toChainId if it's different from the toToken chainId
-      if (
-        toToken?.chainId &&
-        (state.toChainId
-          ? formatChainIdToCaip(toToken.chainId) !==
-            formatChainIdToCaip(state.toChainId)
-          : true)
-      ) {
-        state.toChainId = formatChainIdToCaip(toToken.chainId);
-      }
     },
     setFromTokenInputValue: (
       state,
@@ -163,7 +102,6 @@ const bridgeSlice = createSlice({
     ) => {
       state.fromToken = toBridgeToken(quote.srcAsset);
       state.toToken = toBridgeToken(quote.destAsset);
-      state.toChainId = formatChainIdToCaip(quote.destChainId);
     },
     setSortOrder: (state, action) => {
       state.sortOrder = action.payload;
@@ -177,6 +115,34 @@ const bridgeSlice = createSlice({
     setSlippage: (state, action) => {
       state.slippage = action.payload;
     },
+    setEVMSrcTokenBalance: (
+      state,
+      action: {
+        payload: {
+          assetId: CaipAssetType;
+          balance: BridgeState['fromTokenBalance'];
+        };
+      },
+    ) => {
+      const { assetId, balance } = action.payload;
+      if (!state.fromToken || assetId === state.fromToken.assetId) {
+        state.fromTokenBalance = balance;
+      }
+    },
+    setEVMSrcNativeBalance: (
+      state,
+      action: {
+        payload: {
+          chainId: BridgeToken['chainId'];
+          balance: BridgeState['fromNativeBalance'];
+        };
+      },
+    ) => {
+      const { chainId, balance } = action.payload;
+      if (!state.fromToken || chainId === state.fromToken.chainId) {
+        state.fromNativeBalance = balance;
+      }
+    },
   },
   extraReducers: (builder) => {
     builder.addCase(setDestTokenExchangeRates.pending, (state) => {
@@ -206,40 +172,6 @@ const bridgeSlice = createSlice({
     builder.addCase(setTxAlerts.rejected, (state) => {
       state.txAlert = null;
     });
-    builder.addCase(setEVMSrcTokenBalance.fulfilled, (state, action) => {
-      const isTokenInChain = !isCrossChain(
-        action.meta.arg.chainId,
-        state.fromToken?.chainId,
-      );
-      if (
-        isTokenInChain && state.fromToken?.address
-          ? action.meta.arg.tokenAddress === state.fromToken.address
-          : true
-      ) {
-        state.fromTokenBalance = action.payload?.toString() ?? null;
-      }
-      endTrace({
-        name: TraceName.BridgeBalancesUpdated,
-      });
-    });
-    builder.addCase(setEVMSrcTokenBalance.rejected, (state) => {
-      state.fromTokenBalance = null;
-      endTrace({
-        name: TraceName.BridgeBalancesUpdated,
-      });
-    });
-    builder.addCase(setEVMSrcNativeBalance.fulfilled, (state, action) => {
-      state.fromNativeBalance = action.payload?.toString() ?? null;
-      endTrace({
-        name: TraceName.BridgeBalancesUpdated,
-      });
-    });
-    builder.addCase(setEVMSrcNativeBalance.rejected, (state) => {
-      state.fromNativeBalance = null;
-      endTrace({
-        name: TraceName.BridgeBalancesUpdated,
-      });
-    });
   },
 });
 
diff --git a/ui/ducks/bridge/selectors.test.ts b/ui/ducks/bridge/selectors.test.ts
index 2f7892038b36..316c7063fb61 100644
--- a/ui/ducks/bridge/selectors.test.ts
+++ b/ui/ducks/bridge/selectors.test.ts
@@ -17,13 +17,11 @@ import mockErc20Erc20Quotes from '../../../test/data/bridge/mock-quotes-erc20-er
 import mockBridgeQuotesNativeErc20 from '../../../test/data/bridge/mock-quotes-native-erc20.json';
 import { MultichainNetworks } from '../../../shared/constants/multichain/networks';
 import {
-  getAllBridgeableNetworks,
   getBridgeQuotes,
   getFromAmount,
   getFromChain,
   getFromChains,
   getFromToken,
-  getIsBridgeTx,
   getIsSwap,
   getToChain,
   getToChains,
@@ -41,7 +39,7 @@ describe('Bridge selectors', () => {
     it('returns the fromChain from the state', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               [CHAIN_IDS.ARBITRUM]: { isActiveSrc: true, isActiveDest: false },
             },
@@ -110,7 +108,7 @@ describe('Bridge selectors', () => {
     it('returns the toChain from the state', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               '0xe708': { isActiveSrc: false, isActiveDest: true },
             },
@@ -141,7 +139,7 @@ describe('Bridge selectors', () => {
     it('returns the fromChain if toChainId is not set', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               '0x1': { isActiveSrc: true, isActiveDest: true },
               '0xe708': { isActiveSrc: false, isActiveDest: true },
@@ -171,76 +169,76 @@ describe('Bridge selectors', () => {
     });
   });
 
-  describe('getAllBridgeableNetworks', () => {
-    it('returns list of ALLOWED_BRIDGE_CHAIN_IDS networks', () => {
-      const state = createBridgeMockStore({
-        metamaskStateOverrides: {
-          ...mockNetworkState(...FEATURED_RPCS),
-        },
-      });
-      const result = getAllBridgeableNetworks(state as never);
-
-      expect(result).toHaveLength(12);
-      expect(result[0]).toStrictEqual(
-        expect.objectContaining({ chainId: FEATURED_RPCS[0].chainId }),
-      );
-      expect(result[1]).toStrictEqual(
-        expect.objectContaining({ chainId: FEATURED_RPCS[1].chainId }),
-      );
-      FEATURED_RPCS.forEach((rpcDefinition, idx) => {
-        expect(result[idx]).toStrictEqual(
-          expect.objectContaining({
-            ...rpcDefinition,
-            blockExplorerUrls: [
-              `https://localhost/blockExplorer/${rpcDefinition.chainId}`,
-            ],
-            name: expect.anything(),
-            rpcEndpoints: [
-              {
-                networkClientId: expect.anything(),
-                type: 'custom',
-                url: `https://localhost/rpc/${rpcDefinition.chainId}`,
-              },
-            ],
-          }),
-        );
-      });
-      result.forEach(({ chainId }) => {
-        expect(ALLOWED_BRIDGE_CHAIN_IDS).toContain(chainId);
-      });
-    });
-
-    it('returns network if included in ALLOWED_BRIDGE_CHAIN_IDS', () => {
-      const state = {
-        ...createBridgeMockStore(),
-        metamask: {
-          ...mockNetworkState(
-            { chainId: CHAIN_IDS.MAINNET },
-            { chainId: CHAIN_IDS.LINEA_MAINNET },
-            { chainId: CHAIN_IDS.MOONBEAM },
-          ),
-        },
-      };
-      const result = getAllBridgeableNetworks(state as never);
-
-      expect(result).toHaveLength(4);
-      expect(result[0]).toStrictEqual(
-        expect.objectContaining({ chainId: CHAIN_IDS.MAINNET }),
-      );
-      expect(result[1]).toStrictEqual(
-        expect.objectContaining({ chainId: CHAIN_IDS.LINEA_MAINNET }),
-      );
-      expect(
-        result.find(({ chainId }) => chainId === CHAIN_IDS.MOONBEAM),
-      ).toStrictEqual(undefined);
-    });
-  });
+  // describe('getAllBridgeableNetworks', () => {
+  //   it('returns list of ALLOWED_BRIDGE_CHAIN_IDS networks', () => {
+  //     const state = createBridgeMockStore({
+  //       metamaskStateOverrides: {
+  //         ...mockNetworkState(...FEATURED_RPCS),
+  //       },
+  //     });
+  //     const result = getFromChains(state as never);
+
+  //     expect(result).toHaveLength(12);
+  //     expect(result[0]).toStrictEqual(
+  //       expect.objectContaining({ chainId: FEATURED_RPCS[0].chainId }),
+  //     );
+  //     expect(result[1]).toStrictEqual(
+  //       expect.objectContaining({ chainId: FEATURED_RPCS[1].chainId }),
+  //     );
+  //     FEATURED_RPCS.forEach((rpcDefinition, idx) => {
+  //       expect(result[idx]).toStrictEqual(
+  //         expect.objectContaining({
+  //           ...rpcDefinition,
+  //           blockExplorerUrls: [
+  //             `https://localhost/blockExplorer/${rpcDefinition.chainId}`,
+  //           ],
+  //           name: expect.anything(),
+  //           rpcEndpoints: [
+  //             {
+  //               networkClientId: expect.anything(),
+  //               type: 'custom',
+  //               url: `https://localhost/rpc/${rpcDefinition.chainId}`,
+  //             },
+  //           ],
+  //         }),
+  //       );
+  //     });
+  //     result.forEach(({ chainId }) => {
+  //       expect(ALLOWED_BRIDGE_CHAIN_IDS).toContain(chainId);
+  //     });
+  //   });
+
+  //   it('returns network if included in ALLOWED_BRIDGE_CHAIN_IDS', () => {
+  //     const state = {
+  //       ...createBridgeMockStore(),
+  //       metamask: {
+  //         ...mockNetworkState(
+  //           { chainId: CHAIN_IDS.MAINNET },
+  //           { chainId: CHAIN_IDS.LINEA_MAINNET },
+  //           { chainId: CHAIN_IDS.MOONBEAM },
+  //         ),
+  //       },
+  //     };
+  //     const result = getAllBridgeableNetworks(state as never);
+
+  //     expect(result).toHaveLength(4);
+  //     expect(result[0]).toStrictEqual(
+  //       expect.objectContaining({ chainId: CHAIN_IDS.MAINNET }),
+  //     );
+  //     expect(result[1]).toStrictEqual(
+  //       expect.objectContaining({ chainId: CHAIN_IDS.LINEA_MAINNET }),
+  //     );
+  //     expect(
+  //       result.find(({ chainId }) => chainId === CHAIN_IDS.MOONBEAM),
+  //     ).toStrictEqual(undefined);
+  //   });
+  // });
 
   describe('getFromChains', () => {
     it('excludes disabled chains from options', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               [CHAIN_IDS.MAINNET]: { isActiveSrc: true, isActiveDest: false },
               [CHAIN_IDS.LINEA_MAINNET]: {
@@ -270,7 +268,7 @@ describe('Bridge selectors', () => {
     it('returns empty list when bridgeFeatureFlags are not set', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               [CHAIN_IDS.MAINNET]: { isActiveSrc: false, isActiveDest: true },
             },
@@ -281,13 +279,86 @@ describe('Bridge selectors', () => {
 
       expect(result).toHaveLength(0);
     });
+
+    it('returns sorted fromChains list when chainRanking is set', () => {
+      const chainRanking = [
+        1,
+        56,
+        8453,
+        43114,
+        ChainId.SOLANA,
+        42161,
+        13421,
+        10,
+        59144,
+        137,
+        10,
+      ].map((c) => ({
+        chainId: formatChainIdToCaip(c),
+      }));
+      const state = createBridgeMockStore({
+        metamaskStateOverrides: {
+          ...mockNetworkState(
+            { chainId: CHAIN_IDS.MAINNET }, // eth
+            FEATURED_RPCS[0], // linea
+            FEATURED_RPCS[1], //arb
+            FEATURED_RPCS[3], //bsc
+            FEATURED_RPCS[4], // opt
+          ),
+          internalAccounts: {
+            selectedAccount: 'bf13d52c-d6e8-40ea-9726-07d7149a3ca5',
+          },
+          balances: {
+            'bf13d52c-d6e8-40ea-9726-07d7149a3ca5': {
+              [getNativeAssetForChainId(MultichainNetworks.SOLANA).assetId]: {
+                amount: '2',
+              },
+            },
+          },
+        },
+        featureFlagOverrides: {
+          bridgeConfig: {
+            chainRanking,
+          },
+        },
+      });
+      const result = getFromChains(state as never);
+      const resultsInCaip = result
+        .map((r) => formatChainIdToCaip(r.chainId))
+        .filter(Boolean);
+      // Check that there are no duplicates
+      expect(resultsInCaip.length).toBe(new Set(resultsInCaip).size);
+      expect(getAllBridgeableNetworks(state as never)).toHaveLength(7);
+      // Check that the results are in the correct order
+      expect(resultsInCaip).toStrictEqual([
+        'eip155:1',
+        'eip155:56',
+        'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        'eip155:42161',
+        'eip155:10',
+        'eip155:59144',
+      ]);
+      expect(result).toHaveLength(6);
+      expect(result.map((r) => r.chainId)).toMatchInlineSnapshot(`
+        [
+          "0x1",
+          "0x38",
+          "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+          "0xa4b1",
+          "0xa",
+          "0xe708",
+        ]
+      `);
+      expect(result).not.toContain(undefined);
+      expect(result).not.toContain(null);
+    });
   });
 
   describe('getToChains', () => {
     it('includes selected providerConfig and disabled chains from options', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               [CHAIN_IDS.ARBITRUM]: { isActiveSrc: false, isActiveDest: true },
               [CHAIN_IDS.LINEA_MAINNET]: {
@@ -330,13 +401,91 @@ describe('Bridge selectors', () => {
 
       expect(result).toHaveLength(0);
     });
+
+    it('returns sorted toChains list when chainRanking is set', () => {
+      const chainRanking = [
+        1,
+        56,
+        8453,
+        43114,
+        ChainId.SOLANA,
+        42161,
+        13421,
+        10,
+        59144,
+        137,
+        10,
+      ].map((c) => ({
+        chainId: formatChainIdToCaip(c),
+      }));
+      const state = createBridgeMockStore({
+        metamaskStateOverrides: {
+          ...mockNetworkState(
+            { chainId: CHAIN_IDS.MAINNET }, // eth
+            FEATURED_RPCS[0], // linea
+            FEATURED_RPCS[1], //arb
+            FEATURED_RPCS[3], //bsc
+            FEATURED_RPCS[4], // opt
+          ),
+          internalAccounts: {
+            selectedAccount: 'bf13d52c-d6e8-40ea-9726-07d7149a3ca5',
+          },
+          balances: {
+            'bf13d52c-d6e8-40ea-9726-07d7149a3ca5': {
+              [getNativeAssetForChainId(MultichainNetworks.SOLANA).assetId]: {
+                amount: '2',
+              },
+            },
+          },
+        },
+        featureFlagOverrides: {
+          bridgeConfig: {
+            chainRanking,
+          },
+        },
+      });
+      const result = getToChains(state as never);
+      const resultsInCaip = result
+        .map((r) => formatChainIdToCaip(r.chainId))
+        .filter(Boolean);
+      // Check that there are no duplicates
+      expect(resultsInCaip.length).toBe(new Set(resultsInCaip).size);
+      // Check that the results are in the correct order
+      expect(resultsInCaip).toStrictEqual([
+        'eip155:1',
+        'eip155:56',
+        'eip155:8453',
+        'eip155:43114',
+        'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        'eip155:42161',
+        'eip155:10',
+        'eip155:59144',
+        'eip155:137',
+      ]);
+      expect(result).toHaveLength(9);
+      expect(result.map((r) => r?.name)).toMatchInlineSnapshot(`
+        [
+          "Ethereum",
+          "BNB Chain",
+          "Base",
+          "Avalanche",
+          "Solana",
+          "Arbitrum",
+          "OP",
+          "Linea",
+          "Polygon",
+        ]
+      `);
+      expect(result).not.toContain(undefined);
+      expect(result).not.toContain(null);
+    });
   });
 
   describe('getIsBridgeTx', () => {
     it('returns false if toChainId is null', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             support: true,
             chains: {
               '0x1': { isActiveSrc: true, isActiveDest: true },
@@ -357,7 +506,7 @@ describe('Bridge selectors', () => {
     it('returns false if fromChain and toChainId have the same chainId', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             support: true,
             chains: {
               '0x1': { isActiveSrc: true, isActiveDest: true },
@@ -378,7 +527,7 @@ describe('Bridge selectors', () => {
     it('returns true if fromChain and toChainId have different chainIds', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             support: true,
             chains: {
               '0x1': { isActiveSrc: true, isActiveDest: false },
@@ -471,7 +620,7 @@ describe('Bridge selectors', () => {
           toToken: { address: '0x567', symbol: 'DEST' },
         },
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             support: true,
             chains: {
               '0x1': { isActiveSrc: true, isActiveDest: true },
@@ -491,7 +640,7 @@ describe('Bridge selectors', () => {
           toChainId: formatChainIdToCaip(1),
         },
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             support: true,
             chains: {
               '0x1': { isActiveSrc: true, isActiveDest: true },
@@ -518,7 +667,7 @@ describe('Bridge selectors', () => {
     it('returns null if fromToken is null', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             support: true,
             chains: {
               '0x1': { isActiveSrc: false, isActiveDest: true },
@@ -543,7 +692,7 @@ describe('Bridge selectors', () => {
           toToken: { address: '0x456', symbol: 'DEST' },
         },
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             support: true,
             chains: {
               '0x1': { isActiveSrc: false, isActiveDest: true },
@@ -568,7 +717,7 @@ describe('Bridge selectors', () => {
           toChainId: formatChainIdToCaip(CHAIN_IDS.MAINNET),
         },
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             support: true,
             chains: {
               [toEvmCaipChainId(CHAIN_IDS.MAINNET)]: {
@@ -630,7 +779,7 @@ describe('Bridge selectors', () => {
     it('returns quote list and fetch data, insufficientBal=false,quotesRefreshCount=5', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             maxRefreshCount: 5,
             chains: {
               '0xa': { isActiveSrc: true, isActiveDest: false },
@@ -714,7 +863,7 @@ describe('Bridge selectors', () => {
     it('returns quote list and fetch data, insufficientBal=false,quotesRefreshCount=2', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             maxRefreshCount: 5,
             chains: {
               '0xa': { isActiveSrc: true, isActiveDest: false },
@@ -813,7 +962,7 @@ describe('Bridge selectors', () => {
     it('returns quote list and fetch data, insufficientBal=true', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             maxRefreshCount: 5,
             chains: {
               '0xa': { isActiveSrc: true, isActiveDest: false },
@@ -1451,7 +1600,7 @@ describe('Bridge selectors', () => {
     it('should return isInsufficientGasForQuote=true when balance is less than required network fees in quote', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               '0x1': { isActiveSrc: true, isActiveDest: false },
             },
@@ -1521,7 +1670,7 @@ describe('Bridge selectors', () => {
     it('should return isEstimatedReturnLow=true return value is less than 65% of sent funds', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               '0x1': { isActiveSrc: true, isActiveDest: false },
               '0xa': { isActiveSrc: true, isActiveDest: false },
@@ -1595,7 +1744,7 @@ describe('Bridge selectors', () => {
     it('should return isEstimatedReturnLow=false when return value is more than 65% of sent funds', () => {
       const state = createBridgeMockStore({
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               '0x1': { isActiveSrc: true, isActiveDest: false },
               '0xa': { isActiveSrc: true, isActiveDest: false },
@@ -1922,7 +2071,7 @@ describe('Bridge selectors', () => {
           },
         },
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               'eip155:1': { isActiveSrc: true, isActiveDest: false },
             },
@@ -1957,7 +2106,7 @@ describe('Bridge selectors', () => {
           },
         },
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               'eip155:1': { isActiveSrc: true, isActiveDest: false },
             },
@@ -1992,10 +2141,11 @@ describe('Bridge selectors', () => {
             [getNativeAssetForChainId(MultichainNetworks.SOLANA)?.assetId]: {
               rate: 1.5,
             },
-            [`${formatChainIdToCaip(ChainId.SOLANA)}/token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`]:
-              {
-                rate: 2.0,
-              },
+            [`${formatChainIdToCaip(
+              ChainId.SOLANA,
+            )}/token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`]: {
+              rate: 2.0,
+            },
           },
           rates: {
             sol: {
@@ -2012,7 +2162,7 @@ describe('Bridge selectors', () => {
           },
         },
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               [MultichainNetworks.SOLANA]: {
                 isActiveSrc: true,
@@ -2065,7 +2215,7 @@ describe('Bridge selectors', () => {
           },
         },
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               [MultichainNetworks.SOLANA]: {
                 isActiveSrc: true,
@@ -2084,7 +2234,7 @@ describe('Bridge selectors', () => {
     });
   });
 
-  describe('getToTokenConversionRate', () => {
+  describe.only('getToTokenConversionRate', () => {
     beforeEach(() => {
       jest.clearAllMocks();
     });
@@ -2104,7 +2254,7 @@ describe('Bridge selectors', () => {
 
       const result = getToTokenConversionRate(state);
       expect(result).toStrictEqual({
-        valueInCurrency: null,
+        valueInCurrency: 1.0,
         usd: null,
       });
     });
@@ -2121,7 +2271,7 @@ describe('Bridge selectors', () => {
           toToken: { address: '0x123', decimals: 18 },
         },
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               [formatChainIdToCaip(CHAIN_IDS.OPTIMISM)]: {
                 isActiveSrc: false,
@@ -2163,7 +2313,7 @@ describe('Bridge selectors', () => {
           },
         },
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               [formatChainIdToCaip(CHAIN_IDS.OPTIMISM)]: {
                 isActiveSrc: true,
@@ -2204,7 +2354,7 @@ describe('Bridge selectors', () => {
           },
         },
         featureFlagOverrides: {
-          extensionConfig: {
+          bridgeConfig: {
             chains: {
               [formatChainIdToCaip(CHAIN_IDS.OPTIMISM)]: {
                 isActiveSrc: false,
@@ -2239,6 +2389,11 @@ describe('Bridge selectors', () => {
               },
             },
           },
+          enabledNetworkMap: {
+            solana: {
+              '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': true,
+            },
+          },
           marketData: {},
           currencyRates: {},
           ...mockNetworkState({ chainId: '0x1' }),
@@ -2264,16 +2419,12 @@ describe('Bridge selectors', () => {
           toToken: {
             address: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
             decimals: 6,
+            chainId: MultichainNetworks.SOLANA,
           },
         },
         featureFlagOverrides: {
-          extensionConfig: {
-            chains: {
-              'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': {
-                isActiveSrc: true,
-                isActiveDest: true,
-              },
-            },
+          bridgeConfig: {
+            chainRanking: [{ chainId: MultichainNetworks.SOLANA }],
           },
         },
       });
@@ -2297,6 +2448,11 @@ describe('Bridge selectors', () => {
               rate: 1.5,
             },
           },
+          // enabledNetworkMap: {
+          //   solana: {
+          //     '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': true,
+          //   },
+          // },
           rates: {
             sol: {
               usdConversionRate: 1.4,
@@ -2309,17 +2465,13 @@ describe('Bridge selectors', () => {
           toToken: {
             address: zeroAddress(),
             decimals: 18,
+            chainId: MultichainNetworks.SOLANA,
           },
-          toChainId: MultichainNetworks.SOLANA,
         },
+
         featureFlagOverrides: {
-          extensionConfig: {
-            chains: {
-              [MultichainNetworks.SOLANA]: {
-                isActiveSrc: true,
-                isActiveDest: true,
-              },
-            },
+          bridgeConfig: {
+            chainRanking: [{ chainId: MultichainNetworks.SOLANA }],
           },
         },
       });
diff --git a/ui/ducks/bridge/selectors.ts b/ui/ducks/bridge/selectors.ts
index b093db6641cd..0b4d520adf4e 100644
--- a/ui/ducks/bridge/selectors.ts
+++ b/ui/ducks/bridge/selectors.ts
@@ -64,7 +64,6 @@ import { FEATURED_RPCS } from '../../../shared/constants/network';
 import {
   getMultichainBalances,
   getMultichainCoinRates,
-  getMultichainProviderConfig,
 } from '../../selectors/multichain';
 import { getAssetsRates } from '../../selectors/assets';
 import {
@@ -72,7 +71,6 @@ import {
   HardwareKeyringType,
 } from '../../../shared/constants/hardware-wallets';
 import { toAssetId } from '../../../shared/lib/asset-utils';
-import { MULTICHAIN_NATIVE_CURRENCY_TO_CAIP19 } from '../../../shared/constants/multichain/assets';
 import { Numeric } from '../../../shared/modules/Numeric';
 import { getIsSmartTransaction } from '../../../shared/modules/selectors';
 import {
@@ -97,31 +95,6 @@ import {
 } from './utils';
 import type { BridgeState } from './types';
 
-/**
- * Helper function to determine the CAIP asset type for non-EVM native assets
- *
- * @param chainId - The chain ID
- * @param address - The asset address
- * @param assetId - The asset ID
- * @returns The appropriate CAIP asset type string
- */
-const getNonEvmNativeAssetType = (
-  chainId: Hex | string | number | CaipChainId,
-  address: string,
-  assetId?: string,
-): CaipAssetType | string => {
-  if (isSolanaChainId(chainId)) {
-    return isNativeAddress(address)
-      ? MULTICHAIN_NATIVE_CURRENCY_TO_CAIP19.SOL
-      : (assetId ?? address);
-  }
-  if (isBitcoinChainId(chainId)) {
-    // Bitcoin bridge only supports mainnet
-    return MULTICHAIN_NATIVE_CURRENCY_TO_CAIP19.BTC;
-  }
-  return assetId ?? address;
-};
-
 export type BridgeAppState = {
   metamask: BridgeAppStateFromController &
     GasFeeState &
@@ -167,14 +140,35 @@ const hasBitcoinAccounts = (state: BridgeAppState) => {
   });
 };
 
-// only includes networks user has added
-export const getAllBridgeableNetworks = createDeepEqualSelector(
-  getNetworkConfigurationsByChainId,
-  (networkConfigurationsByChainId) => {
-    return uniqBy(
+const getBridgeFeatureFlags = createDeepEqualSelector(
+  [(state) => getRemoteFeatureFlags(state).bridgeConfig],
+  (bridgeConfig) => {
+    const validatedFlags = selectBridgeFeatureFlags({
+      remoteFeatureFlags: { bridgeConfig },
+    });
+
+    return {
+      ...validatedFlags,
+      // TODO remove validation skip
+      // @ts-expect-error - chainRanking is not typed yet
+      chainRanking: bridgeConfig?.chainRanking,
+    };
+  },
+);
+
+// only includes networks user has added, ranked by the feature flagged chainRanking
+const getAllBridgeableNetworks = createDeepEqualSelector(
+  [(state) => getNetworkConfigurationsByChainId(state)],
+  (networkConfigurationsByHexChainId) => {
+    return Object.fromEntries([
+      ...ALLOWED_BRIDGE_CHAIN_IDS.map((chainId) => [
+        formatChainIdToCaip(chainId),
+        networkConfigurationsByHexChainId[
+          chainId as keyof typeof networkConfigurationsByHexChainId
+        ],
+      ]),
       [
-        ...Object.values(networkConfigurationsByChainId),
-        // TODO: get this from network controller, use placeholder values for now
+        MultichainNetworks.SOLANA,
         {
           ...MULTICHAIN_PROVIDER_CONFIGS[MultichainNetworks.SOLANA],
           blockExplorerUrls: [],
@@ -185,8 +179,10 @@ export const getAllBridgeableNetworks = createDeepEqualSelector(
           defaultRpcEndpointIndex: 0,
           chainId: MultichainNetworks.SOLANA,
         } as unknown as NetworkConfiguration,
-        ///: BEGIN:ONLY_INCLUDE_IF(bitcoin-swaps)
-        // TODO: get this from network controller, use placeholder values for now
+      ],
+      ///: BEGIN:ONLY_INCLUDE_IF(bitcoin-swaps)
+      [
+        MultichainNetworks.BITCOIN,
         {
           ...MULTICHAIN_PROVIDER_CONFIGS[MultichainNetworks.BITCOIN],
           blockExplorerUrls: [],
@@ -198,24 +194,9 @@ export const getAllBridgeableNetworks = createDeepEqualSelector(
           defaultRpcEndpointIndex: 0,
           chainId: MultichainNetworks.BITCOIN,
         } as unknown as NetworkConfiguration,
-        ///: END:ONLY_INCLUDE_IF
       ],
-      'chainId',
-    ).filter(({ chainId }) =>
-      ALLOWED_BRIDGE_CHAIN_IDS.includes(
-        chainId as (typeof ALLOWED_BRIDGE_CHAIN_IDS)[number],
-      ),
-    );
-  },
-);
-
-const getBridgeFeatureFlags = createDeepEqualSelector(
-  [(state) => getRemoteFeatureFlags(state).bridgeConfig],
-  (bridgeConfig) => {
-    const validatedFlags = selectBridgeFeatureFlags({
-      remoteFeatureFlags: { bridgeConfig },
-    });
-    return validatedFlags;
+      ///: END:ONLY_INCLUDE_IF
+    ]);
   },
 );
 
@@ -224,75 +205,98 @@ export const getPriceImpactThresholds = createDeepEqualSelector(
   (bridgeFeatureFlags) => bridgeFeatureFlags?.priceImpactThreshold,
 );
 
+const getChainRanking = (state: BridgeAppState) => {
+  const chainRanking = (
+    getBridgeFeatureFlags(state).chainRanking as {
+      chainId: CaipChainId;
+    }[]
+  ).map((c) => c.chainId);
+  return Array.from(new Set(chainRanking));
+};
+
 export const getFromChains = createDeepEqualSelector(
-  getAllBridgeableNetworks,
-  getBridgeFeatureFlags,
-  (state: BridgeAppState) => hasSolanaAccounts(state),
-  (state: BridgeAppState) => hasBitcoinAccounts(state),
+  [
+    getAllBridgeableNetworks,
+    (state: BridgeAppState) => hasSolanaAccounts(state),
+    (state: BridgeAppState) => hasBitcoinAccounts(state),
+    getChainRanking,
+  ],
   (
     allBridgeableNetworks,
-    bridgeFeatureFlags,
     hasSolanaAccount,
     hasBitcoinAccount,
+    chainRanking,
   ) => {
-    // First filter out Solana from source chains if no Solana account exists
-    let filteredNetworks = hasSolanaAccount
-      ? allBridgeableNetworks
-      : allBridgeableNetworks.filter(
-          ({ chainId }) => !isSolanaChainId(chainId),
-        );
-
-    // Then filter out Bitcoin from source chains if no Bitcoin account exists
-    filteredNetworks = hasBitcoinAccount
-      ? filteredNetworks
-      : filteredNetworks.filter(({ chainId }) => !isBitcoinChainId(chainId));
-
-    // Then apply the standard filter for active source chains
-    return filteredNetworks.filter(
-      ({ chainId }) =>
-        bridgeFeatureFlags.chains[formatChainIdToCaip(chainId)]?.isActiveSrc,
-    );
+    return chainRanking
+      .map((chainId: CaipChainId) => {
+        // build a list of enabled chains ranked by chainRanking
+        const matchedChain =
+          allBridgeableNetworks[formatChainIdToCaip(chainId)];
+        if (!matchedChain) {
+          return null;
+        }
+        // if no solana account, filter out solana
+        if (!hasSolanaAccount && isSolanaChainId(matchedChain.chainId)) {
+          return null;
+        }
+        // if no bitcoin account, filter out bitcoin
+        if (!hasBitcoinAccount && isBitcoinChainId(matchedChain.chainId)) {
+          return null;
+        }
+        return matchedChain;
+      })
+      .filter(Boolean) as NetworkConfiguration[];
   },
 );
-
-/**
- * This matches the network filter in the activity and asset lists
- */
-export const getLastSelectedChainId = createSelector(
-  [getAllEnabledNetworksForAllNamespaces],
-  (allEnabledNetworksForAllNamespaces) => {
-    return allEnabledNetworksForAllNamespaces[0];
+// TODO use all Bridgeable?
+// Returns the latest enabled network that matches a supported bridge network
+// Matches the network filter in the activity and asset lists
+const getNetworkFilterOrTopChain = createSelector(
+  [getAllEnabledNetworksForAllNamespaces, getFromChains],
+  (enabledEvmNetworks, fromChains) => {
+    // If there is no network filter, return first chain ranked by bridge feature flags
+    if (enabledEvmNetworks.length > 1) {
+      return fromChains[0];
+    }
+    // If there is no match for the filter (i.e testnets), return first chain ranked by bridge feature flags
+    const lastEnabledChainId = enabledEvmNetworks.find((chainId) =>
+      fromChains.some(({ chainId: fromChainId }) => fromChainId === chainId),
+    );
+    return (
+      fromChains.find(
+        ({ chainId: fromChainId }) => fromChainId === lastEnabledChainId,
+      ) ?? fromChains[0]
+    );
   },
 );
 
-// This returns undefined if the selected chain is not supported by swap/bridge (i.e, testnets)
-export const getFromChain = createDeepEqualSelector(
-  [getFromChains, getMultichainProviderConfig],
-  (fromChains, providerConfig) => {
-    // When the page loads the global network always matches the network filter
-    // Because useBridging checks whether the lastSelectedNetwork matches the provider config
-    // Then useBridgeQueryParams sets the global network to lastSelectedNetwork as needed
-    // TODO remove providerConfig references and just use getLastSelectedChainId
-    return fromChains.find(
-      ({ chainId }) => chainId === providerConfig?.chainId,
-    );
-  },
+export const getFromToken = createSelector(
+  [
+    (state) => getNetworkFilterOrTopChain(state).chainId,
+    (state: BridgeAppState) => state.bridge.fromToken,
+  ],
+  (lastEnabledChainId, fromToken) =>
+    fromToken ?? toBridgeToken(getNativeAssetForChainId(lastEnabledChainId)),
 );
 
-export const getToChains = createDeepEqualSelector(
-  getAllBridgeableNetworks,
-  getBridgeFeatureFlags,
-  (allBridgeableNetworks, bridgeFeatureFlags) => {
-    const availableChains = uniqBy(
-      [...allBridgeableNetworks, ...FEATURED_RPCS],
-      'chainId',
-    ).filter(
-      ({ chainId }) =>
-        bridgeFeatureFlags?.chains?.[formatChainIdToCaip(chainId)]
-          ?.isActiveDest,
-    );
+const getFromChainId = (state: BridgeAppState) => getFromToken(state).chainId;
+// For compatibility with old code
+export const getFromChain = (state: BridgeAppState) => ({
+  chainId: getFromChainId(state),
+});
 
-    return availableChains;
+export const getToChains = createDeepEqualSelector(
+  [getAllBridgeableNetworks, getChainRanking],
+  (allBridgeableNetworks, chainRanking) => {
+    const allChains = {
+      ...allBridgeableNetworks,
+      ...Object.fromEntries(
+        FEATURED_RPCS.map((rpc) => [formatChainIdToCaip(rpc.chainId), rpc]),
+      ),
+    };
+    return chainRanking
+      .map((chainId) => allChains[formatChainIdToCaip(chainId)])
+      .filter(Boolean) as NetworkConfiguration[];
   },
 );
 
@@ -313,9 +317,6 @@ const getDefaultTokenPair = createDeepEqualSelector(
     (state) => getBridgeFeatureFlags(state).bip44DefaultPairs,
   ],
   (fromChainId, bip44DefaultPairs): null | [CaipAssetType, CaipAssetType] => {
-    if (!fromChainId) {
-      return null;
-    }
     const { namespace } = parseCaipChainId(formatChainIdToCaip(fromChainId));
     const defaultTokenPair = bip44DefaultPairs?.[namespace]?.standard;
     if (defaultTokenPair) {
@@ -338,79 +339,33 @@ const getBIP44DefaultToChainId = createSelector(
   },
 );
 
-// If the user has selected a toChainId, return it as the destination chain
-// Otherwise, use the source chain as the destination chain (default to swap params)
-export const getToChain = createSelector(
+// If the user has selected a toToken, return it
+// Otherwise, return the default token for the fromChain.
+export const getToToken = createSelector(
   [
-    getFromChain,
-    getToChains,
-    (state: BridgeAppState) => state.bridge?.toChainId,
+    getFromToken,
+    (state: BridgeAppState) => state.bridge.toToken,
     getBIP44DefaultToChainId,
   ],
-  (fromChain, toChains, toChainId, defaultToChainId) => {
-    // If user has explicitly selected a destination, use it
-    if (toChainId) {
-      return toChains.find(
-        ({ chainId }) =>
-          chainId === toChainId || formatChainIdToCaip(chainId) === toChainId,
-      );
-    }
-
-    // Bitcoin can only bridge to EVM chains, not to Bitcoin
-    // So if source is Bitcoin, default to BIP44 default chain
-    if (fromChain && isBitcoinChainId(fromChain.chainId)) {
-      return toChains.find(({ chainId }) => {
-        return formatChainIdToCaip(chainId) === defaultToChainId;
-      });
-    }
-
-    // For all other chains, default to same chain (swap mode)
-    return fromChain;
-  },
-);
-
-export const getFromToken = createSelector(
-  [
-    (state: BridgeAppState) => state.bridge.fromToken,
-    (state) => getFromChain(state)?.chainId,
-  ],
-  (fromToken, fromChainId) => {
-    if (!fromChainId) {
-      return null;
-    }
-    if (fromToken?.address) {
-      return fromToken;
-    }
-    const { iconUrl, ...nativeAsset } = getNativeAssetForChainId(fromChainId);
-    const newToToken = toBridgeToken(nativeAsset);
-    return newToToken
-      ? {
-          ...newToToken,
-          chainId: formatChainIdToCaip(fromChainId),
-        }
-      : newToToken;
-  },
-);
-
-export const getToToken = createSelector(
-  [getFromToken, getToChain, (state) => state.bridge.toToken],
-  (fromToken, toChain, toToken) => {
-    if (!toChain || !fromToken) {
-      return null;
-    }
+  (fromToken, toToken, defaultToChainId) => {
     // If the user has selected a token, return it
     if (toToken) {
       return toToken;
     }
+    // Bitcoin only has 1 asset, so we can use the default asset from LD
+    if (isBitcoinChainId(fromToken.chainId) && defaultToChainId) {
+      return toBridgeToken(getNativeAssetForChainId(defaultToChainId));
+    }
     // Otherwise, determine the default token to use based on fromToken and toChain
-    const defaultToken = getDefaultToToken(
-      formatChainIdToCaip(toChain.chainId),
-      fromToken,
-    );
-    return defaultToken ? toBridgeToken(defaultToken) : null;
+    return toBridgeToken(getDefaultToToken(fromToken));
   },
 );
 
+const getToChainId = (state: BridgeAppState) => getToToken(state).chainId;
+export const getToChain = (state: BridgeAppState) => ({
+  chainId: getToChainId(state),
+});
+
 export const getFromAmount = (state: BridgeAppState): string | null =>
   state.bridge.fromTokenInputValue;
 
@@ -447,14 +402,14 @@ export const getFromAccount = createSelector(
 );
 
 export const getToAccounts = createSelector(
-  [getToChain, getWalletsWithAccounts, (state) => state],
-  (toChain, accountsByWallet, state) => {
-    if (!toChain) {
+  [getToChainId, getWalletsWithAccounts, (state) => state],
+  (toChainId, accountsByWallet, state) => {
+    if (!toChainId) {
       return [];
     }
     const internalAccounts = getInternalAccountsByScope(
       state,
-      formatChainIdToCaip(toChain.chainId),
+      formatChainIdToCaip(toChainId),
     );
 
     return internalAccounts.map((account) => ({
@@ -476,23 +431,21 @@ export const getToAccounts = createSelector(
 
 const _getFromNativeBalance = createSelector(
   [
-    getFromChain,
+    getFromChainId,
     (state: BridgeAppState) => state.bridge.fromNativeBalance,
     getMultichainBalances,
     (state) => getFromAccount(state)?.id,
   ],
-  (fromChain, fromNativeBalance, nonEvmBalancesByAccountId, id) => {
-    if (!fromChain || !id) {
+  (fromChainId, fromNativeBalance, nonEvmBalancesByAccountId, id) => {
+    if (!id) {
       return null;
     }
 
-    const { chainId } = fromChain;
-    const { decimals, address, assetId } = getNativeAssetForChainId(chainId);
+    const { decimals, assetId } = getNativeAssetForChainId(fromChainId);
 
     // Use the balance provided by the multichain balances controller for non-EVM chains
-    if (isNonEvmChain(chainId)) {
-      const caipAssetType = getNonEvmNativeAssetType(chainId, address, assetId);
-      return nonEvmBalancesByAccountId?.[id]?.[caipAssetType]?.amount ?? null;
+    if (isNonEvmChain(fromChainId)) {
+      return nonEvmBalancesByAccountId?.[id]?.[assetId]?.amount ?? null;
     }
 
     return fromNativeBalance
@@ -502,30 +455,24 @@ const _getFromNativeBalance = createSelector(
 );
 
 export const getFromTokenBalance = createSelector(
-  getFromToken,
-  getFromChain,
-  (state: BridgeAppState) => state.bridge.fromTokenBalance,
-  getMultichainBalances,
-  getFromAccount,
-  (
-    fromToken,
-    fromChain,
-    fromTokenBalance,
-    nonEvmBalancesByAccountId,
-    fromAccount,
-  ) => {
-    if (!fromToken || !fromChain || !fromAccount) {
+  [
+    getFromToken,
+    (state: BridgeAppState) => state.bridge.fromTokenBalance,
+    getMultichainBalances,
+    getFromAccount,
+  ],
+  (fromToken, fromTokenBalance, nonEvmBalancesByAccountId, fromAccount) => {
+    if (!fromAccount) {
       return null;
     }
     const { id } = fromAccount;
-    const { chainId, decimals, address, assetId } = fromToken;
+    const { chainId, decimals, assetId } = fromToken;
 
     // Use the balance provided by the multichain balances controller for non-EVM chains
     if (isNonEvmChain(chainId)) {
-      const caipAssetType = getNonEvmNativeAssetType(chainId, address, assetId);
       return (
-        nonEvmBalancesByAccountId?.[id]?.[caipAssetType]?.amount ??
-        fromToken.string ??
+        nonEvmBalancesByAccountId?.[id]?.[assetId]?.amount ??
+        fromToken.balance ??
         null
       );
     }
@@ -544,12 +491,9 @@ export const getQuoteRequest = (state: BridgeAppState) => {
 };
 
 export const getQuoteRefreshRate = createSelector(
-  getBridgeFeatureFlags,
-  getFromChain,
-  (extensionConfig, fromChain) =>
-    (fromChain &&
-      extensionConfig.chains[formatChainIdToCaip(fromChain.chainId)]
-        ?.refreshRate) ??
+  [getBridgeFeatureFlags, getFromChainId],
+  (extensionConfig, fromChainId) =>
+    extensionConfig.chains[formatChainIdToCaip(fromChainId)]?.refreshRate ??
     extensionConfig.refreshRate,
 );
 export const getBridgeSortOrder = (state: BridgeAppState) =>
@@ -557,7 +501,6 @@ export const getBridgeSortOrder = (state: BridgeAppState) =>
 
 export const getFromTokenConversionRate = createSelector(
   [
-    getFromChain,
     (state: BridgeAppState) => state.metamask.marketData, // rates for non-native evm tokens
     getAssetsRates, // non-evm conversion rates multichain equivalent of getMarketData
     getFromToken,
@@ -566,7 +509,6 @@ export const getFromTokenConversionRate = createSelector(
     (state: BridgeAppState) => state.bridge.fromTokenExchangeRate,
   ],
   (
-    fromChain,
     marketData,
     conversionRates,
     fromToken,
@@ -574,96 +516,84 @@ export const getFromTokenConversionRate = createSelector(
     currencyRates,
     fromTokenExchangeRate,
   ) => {
-    if (fromChain?.chainId && fromToken) {
-      const nativeAssetId = getNativeAssetForChainId(
-        fromChain.chainId,
-      )?.assetId;
-      const tokenAssetId = toAssetId(
-        fromToken.address,
-        formatChainIdToCaip(fromChain.chainId),
-      );
-      const nativeToCurrencyRate = isNonEvmChain(fromChain.chainId)
-        ? Number(
-            rates?.[fromChain.nativeCurrency?.toLowerCase()]?.conversionRate ??
-              conversionRates?.[nativeAssetId as CaipAssetType]?.rate ??
-              null,
-          )
-        : (currencyRates[fromChain.nativeCurrency]?.conversionRate ?? null);
-      const nativeToUsdRate = isNonEvmChain(fromChain.chainId)
-        ? Number(
-            rates?.[fromChain.nativeCurrency?.toLowerCase()]
-              ?.usdConversionRate ??
-              conversionRates?.[nativeAssetId as CaipAssetType]?.rate ??
-              null,
-          )
-        : (currencyRates[fromChain.nativeCurrency]?.usdConversionRate ?? null);
-
-      if (isNativeAddress(fromToken.address)) {
-        return {
-          valueInCurrency: nativeToCurrencyRate,
-          usd: nativeToUsdRate,
-        };
-      }
-      if (isSolanaChainId(fromChain.chainId) && nativeAssetId && tokenAssetId) {
-        // For SOLANA tokens, we use the conversion rates provided by the multichain rates controller
-        const tokenToNativeAssetRate = tokenPriceInNativeAsset(
-          Number(
-            conversionRates?.[tokenAssetId]?.rate ??
-              fromTokenExchangeRate ??
-              null,
-          ),
-          Number(
+    const fromChainId = fromToken.chainId;
+    const nativeAssetId = getNativeAssetForChainId(fromChainId)?.assetId;
+    const tokenAssetId = toAssetId(
+      fromToken.address,
+      formatChainIdToCaip(fromChainId),
+    );
+    const nativeAssetSymbol = getNativeAssetForChainId(fromChainId)?.symbol;
+    const nativeToCurrencyRate = isNonEvmChain(fromChainId)
+      ? Number(
+          rates?.[nativeAssetSymbol.toLowerCase()]?.conversionRate ??
             conversionRates?.[nativeAssetId as CaipAssetType]?.rate ??
-              rates?.sol?.conversionRate ??
-              null,
-          ),
-        );
-        return exchangeRatesFromNativeAndCurrencyRates(
-          tokenToNativeAssetRate,
-          Number(nativeToCurrencyRate),
-          Number(nativeToUsdRate),
-        );
-      }
+            null,
+        )
+      : (currencyRates[nativeAssetSymbol]?.conversionRate ?? null);
+    const nativeToUsdRate = isNonEvmChain(fromChainId)
+      ? Number(
+          rates?.[nativeAssetSymbol?.toLowerCase()]?.usdConversionRate ??
+            conversionRates?.[nativeAssetId as CaipAssetType]?.rate ??
+            null,
+        )
+      : (currencyRates[nativeAssetSymbol]?.usdConversionRate ?? null);
 
-      if (
-        isBitcoinChainId(fromChain.chainId) &&
-        nativeAssetId &&
-        tokenAssetId
-      ) {
-        // For Bitcoin tokens, we use the conversion rates provided by the multichain rates controller
-        const nativeAssetRate = Number(
-          conversionRates?.[nativeAssetId as CaipAssetType]?.rate ?? null,
-        );
-        const tokenToNativeAssetRate = tokenPriceInNativeAsset(
-          Number(
-            conversionRates?.[tokenAssetId]?.rate ??
-              fromTokenExchangeRate ??
-              null,
-          ),
-          nativeAssetRate,
-        );
-        return exchangeRatesFromNativeAndCurrencyRates(
-          tokenToNativeAssetRate,
-          Number(nativeToCurrencyRate),
-          Number(nativeToUsdRate),
-        );
-      }
-      // For EVM tokens, we use the market data to get the exchange rate
-      const tokenToNativeAssetRate =
-        exchangeRateFromMarketData(
-          fromChain.chainId,
-          fromToken.address,
-          marketData,
-        ) ??
-        tokenPriceInNativeAsset(fromTokenExchangeRate, nativeToCurrencyRate);
+    if (isNativeAddress(fromToken.address)) {
+      return {
+        valueInCurrency: nativeToCurrencyRate,
+        usd: nativeToUsdRate,
+      };
+    }
+    if (isSolanaChainId(fromChainId) && nativeAssetId && tokenAssetId) {
+      // For SOLANA tokens, we use the conversion rates provided by the multichain rates controller
+      const tokenToNativeAssetRate = tokenPriceInNativeAsset(
+        Number(
+          conversionRates?.[tokenAssetId]?.rate ??
+            fromTokenExchangeRate ??
+            null,
+        ),
+        Number(
+          conversionRates?.[nativeAssetId as CaipAssetType]?.rate ??
+            rates?.sol?.conversionRate ??
+            null,
+        ),
+      );
+      return exchangeRatesFromNativeAndCurrencyRates(
+        tokenToNativeAssetRate,
+        Number(nativeToCurrencyRate),
+        Number(nativeToUsdRate),
+      );
+    }
 
+    if (isBitcoinChainId(fromChainId) && nativeAssetId && tokenAssetId) {
+      // For Bitcoin tokens, we use the conversion rates provided by the multichain rates controller
+      const nativeAssetRate = Number(
+        conversionRates?.[nativeAssetId as CaipAssetType]?.rate ?? null,
+      );
+      const tokenToNativeAssetRate = tokenPriceInNativeAsset(
+        Number(
+          conversionRates?.[tokenAssetId]?.rate ??
+            fromTokenExchangeRate ??
+            null,
+        ),
+        nativeAssetRate,
+      );
       return exchangeRatesFromNativeAndCurrencyRates(
         tokenToNativeAssetRate,
-        nativeToCurrencyRate,
-        nativeToUsdRate,
+        Number(nativeToCurrencyRate),
+        Number(nativeToUsdRate),
       );
     }
-    return exchangeRatesFromNativeAndCurrencyRates();
+    // For EVM tokens, we use the market data to get the exchange rate
+    const tokenToNativeAssetRate =
+      exchangeRateFromMarketData(fromChainId, fromToken.address, marketData) ??
+      tokenPriceInNativeAsset(fromTokenExchangeRate, nativeToCurrencyRate);
+
+    return exchangeRatesFromNativeAndCurrencyRates(
+      tokenToNativeAssetRate,
+      nativeToCurrencyRate,
+      nativeToUsdRate,
+    );
   },
 );
 
@@ -671,106 +601,90 @@ export const getFromTokenConversionRate = createSelector(
 // The cached exchange rate won't be available so the rate from the bridge state is used
 export const getToTokenConversionRate = createDeepEqualSelector(
   [
-    getToChain,
     (state: BridgeAppState) => state.metamask.marketData, // rates for non-native evm tokens
     getAssetsRates, // non-evm conversion rates, multichain equivalent of getMarketData
     getToToken,
-    getNetworkConfigurationsByChainId,
     (state) => ({
       state,
       toTokenExchangeRate: state.bridge.toTokenExchangeRate,
       toTokenUsdExchangeRate: state.bridge.toTokenUsdExchangeRate,
     }),
     getMultichainCoinRates, // multichain native rates
+    getAllBridgeableNetworks,
   ],
   (
-    toChain,
     marketData,
     conversionRates,
     toToken,
-    allNetworksByChainId,
     { state, toTokenExchangeRate, toTokenUsdExchangeRate },
     rates,
+    enabledNetworMap,
   ) => {
+    const { chainId } = toToken;
+    const isToChainEnabled = enabledNetworMap[formatChainIdToCaip(chainId)];
     // When the toChain is not imported, the exchange rate to native asset is not available
     // The rate in the bridge state is used instead
-    if (
-      toChain?.chainId &&
-      !allNetworksByChainId[toChain.chainId] &&
-      toTokenExchangeRate
-    ) {
+    if (!isToChainEnabled && toTokenExchangeRate) {
       return {
         valueInCurrency: toTokenExchangeRate,
         usd: toTokenUsdExchangeRate,
       };
     }
-    if (toChain?.chainId && toToken) {
-      const nativeAssetId = getNativeAssetForChainId(toChain.chainId)?.assetId;
-      const tokenAssetId = toAssetId(
-        toToken.address,
-        formatChainIdToCaip(toChain.chainId),
-      );
-
-      if (isSolanaChainId(toChain.chainId) && nativeAssetId && tokenAssetId) {
-        // For SOLANA tokens, we use the conversion rates provided by the multichain rates controller
-        const tokenToNativeAssetRate = tokenPriceInNativeAsset(
-          Number(conversionRates?.[tokenAssetId]?.rate ?? null),
-          Number(
-            conversionRates?.[nativeAssetId as CaipAssetType]?.rate ?? null,
-          ),
-        );
-        return exchangeRatesFromNativeAndCurrencyRates(
-          tokenToNativeAssetRate,
-          rates?.[toChain.nativeCurrency?.toLowerCase()]?.conversionRate ??
-            null,
-          rates?.[toChain.nativeCurrency?.toLowerCase()]?.usdConversionRate ??
-            null,
-        );
-      }
-
-      if (isBitcoinChainId(toChain.chainId) && nativeAssetId && tokenAssetId) {
-        // For Bitcoin tokens, we use the conversion rates provided by the multichain rates controller
-        const nativeAssetRate = Number(
-          conversionRates?.[nativeAssetId as CaipAssetType]?.rate ?? null,
-        );
-        const tokenToNativeAssetRate = tokenPriceInNativeAsset(
-          Number(conversionRates?.[tokenAssetId]?.rate ?? null),
-          nativeAssetRate,
-        );
-        return exchangeRatesFromNativeAndCurrencyRates(
-          tokenToNativeAssetRate,
-          rates?.[toChain.nativeCurrency?.toLowerCase()]?.conversionRate ??
-            null,
-          rates?.[toChain.nativeCurrency?.toLowerCase()]?.usdConversionRate ??
-            null,
-        );
-      }
-
-      const { chainId } = toChain;
+    const { assetId: nativeAssetId, symbol } =
+      getNativeAssetForChainId(chainId);
+    const tokenAssetId = toAssetId(
+      toToken.address,
+      formatChainIdToCaip(chainId),
+    );
+    const nativeSymbol = symbol?.toLowerCase();
 
-      const nativeToCurrencyRate = selectConversionRateByChainId(
-        state,
-        chainId,
+    if (isSolanaChainId(chainId) && nativeAssetId && tokenAssetId) {
+      // For SOLANA tokens, we use the conversion rates provided by the multichain rates controller
+      const tokenToNativeAssetRate = tokenPriceInNativeAsset(
+        Number(conversionRates?.[tokenAssetId]?.rate ?? null),
+        Number(conversionRates?.[nativeAssetId as CaipAssetType]?.rate ?? null),
       );
-      const nativeToUsdRate = getUSDConversionRateByChainId(chainId)(state);
-
-      if (isNativeAddress(toToken.address)) {
-        return {
-          valueInCurrency: nativeToCurrencyRate,
-          usd: nativeToUsdRate,
-        };
-      }
+      return exchangeRatesFromNativeAndCurrencyRates(
+        tokenToNativeAssetRate,
+        rates?.[nativeSymbol]?.conversionRate ?? null,
+        rates?.[nativeSymbol]?.usdConversionRate ?? null,
+      );
+    }
 
-      const tokenToNativeAssetRate =
-        exchangeRateFromMarketData(chainId, toToken.address, marketData) ??
-        tokenPriceInNativeAsset(toTokenExchangeRate, nativeToCurrencyRate);
+    if (isBitcoinChainId(chainId) && nativeAssetId && tokenAssetId) {
+      // For Bitcoin tokens, we use the conversion rates provided by the multichain rates controller
+      const nativeAssetRate = Number(
+        conversionRates?.[nativeAssetId as CaipAssetType]?.rate ?? null,
+      );
+      const tokenToNativeAssetRate = tokenPriceInNativeAsset(
+        Number(conversionRates?.[tokenAssetId]?.rate ?? null),
+        nativeAssetRate,
+      );
       return exchangeRatesFromNativeAndCurrencyRates(
         tokenToNativeAssetRate,
-        nativeToCurrencyRate,
-        nativeToUsdRate,
+        rates?.[nativeSymbol]?.conversionRate ?? null,
+        rates?.[nativeSymbol]?.usdConversionRate ?? null,
       );
     }
-    return exchangeRatesFromNativeAndCurrencyRates();
+
+    const nativeToCurrencyRate = selectConversionRateByChainId(state, chainId);
+    const nativeToUsdRate = getUSDConversionRateByChainId(chainId)(state);
+
+    if (isNativeAddress(toToken.address)) {
+      return {
+        valueInCurrency: nativeToCurrencyRate,
+        usd: nativeToUsdRate,
+      };
+    }
+
+    const tokenToNativeAssetRate =
+      exchangeRateFromMarketData(chainId, toToken.address, marketData) ??
+      tokenPriceInNativeAsset(toTokenExchangeRate, nativeToCurrencyRate);
+    return exchangeRatesFromNativeAndCurrencyRates(
+      tokenToNativeAssetRate,
+      nativeToCurrencyRate,
+      nativeToUsdRate,
+    );
   },
 );
 
@@ -792,17 +706,8 @@ export const getBridgeQuotes = createSelector(
     }),
 );
 
-export const getIsBridgeTx = createDeepEqualSelector(
-  getFromChain,
-  getToChain,
-  (fromChain, toChain) =>
-    toChain && fromChain?.chainId
-      ? fromChain.chainId !== toChain.chainId
-      : false,
-);
-
 export const getIsSwap = createDeepEqualSelector(
-  getQuoteRequest,
+  [getQuoteRequest],
   ({ srcChainId, destChainId }) =>
     Boolean(
       srcChainId &&
@@ -812,29 +717,28 @@ export const getIsSwap = createDeepEqualSelector(
 );
 
 const _getValidatedSrcAmount = createSelector(
-  getFromToken,
-  (state: BridgeAppState) => state.metamask.quoteRequest.srcTokenAmount,
-  (fromToken, srcTokenAmount) =>
-    srcTokenAmount && fromToken?.decimals
-      ? calcTokenAmount(srcTokenAmount, Number(fromToken.decimals)).toString()
+  [
+    (state) => getFromToken(state).decimals,
+    (state: BridgeAppState) => state.metamask.quoteRequest.srcTokenAmount,
+  ],
+  (decimals, srcTokenAmount) =>
+    srcTokenAmount && decimals
+      ? calcTokenAmount(srcTokenAmount, Number(decimals)).toString()
       : null,
 );
 
 export const getFromAmountInCurrency = createSelector(
-  getFromToken,
-  getFromChain,
-  _getValidatedSrcAmount,
-  getFromTokenConversionRate,
+  [getFromToken, _getValidatedSrcAmount, getFromTokenConversionRate],
   (
     fromToken,
-    fromChain,
     validatedSrcAmount,
     {
       valueInCurrency: fromTokenToCurrencyExchangeRate,
       usd: fromTokenToUsdExchangeRate,
     },
   ) => {
-    if (fromToken?.symbol && fromChain?.chainId && validatedSrcAmount) {
+    const fromChainId = fromToken.chainId;
+    if (fromToken.symbol && fromChainId && validatedSrcAmount) {
       if (fromTokenToCurrencyExchangeRate) {
         return {
           valueInCurrency: new BigNumber(validatedSrcAmount).mul(
@@ -982,16 +886,15 @@ export const needsBitcoinAccountForDestination = createDeepEqualSelector(
 );
 
 export const getIsToOrFromNonEvm = createSelector(
-  getFromChain,
-  getToChain,
-  (fromChain, toChain) => {
-    if (!fromChain?.chainId || !toChain?.chainId) {
+  [getFromChainId, getToChainId],
+  (fromChainId, toChainId) => {
+    if (!fromChainId || !toChainId) {
       return false;
     }
 
     // Parse the CAIP chain IDs to get their namespaces
-    const fromCaipChainId = formatChainIdToCaip(fromChain.chainId);
-    const toCaipChainId = formatChainIdToCaip(toChain.chainId);
+    const fromCaipChainId = formatChainIdToCaip(fromChainId);
+    const toCaipChainId = formatChainIdToCaip(toChainId);
 
     const { namespace: fromNamespace } = parseCaipChainId(fromCaipChainId);
     const { namespace: toNamespace } = parseCaipChainId(toCaipChainId);
@@ -1003,15 +906,14 @@ export const getIsToOrFromNonEvm = createSelector(
 );
 
 export const getIsSolanaSwap = createSelector(
-  getFromChain,
-  getToChain,
-  (fromChain, toChain) => {
-    if (!fromChain?.chainId || !toChain?.chainId) {
+  [getFromChainId, getToChainId],
+  (fromChainId, toChainId) => {
+    if (!fromChainId || !toChainId) {
       return false;
     }
 
-    const fromChainIsSolana = isSolanaChainId(fromChain.chainId);
-    const toChainIsSolana = isSolanaChainId(toChain.chainId);
+    const fromChainIsSolana = isSolanaChainId(fromChainId);
+    const toChainIsSolana = isSolanaChainId(toChainId);
 
     // Return true if BOTH chains are Solana (Solana-to-Solana swap)
     return fromChainIsSolana && toChainIsSolana;
diff --git a/ui/ducks/bridge/types.ts b/ui/ducks/bridge/types.ts
index cec78727bf4c..30b8a0394134 100644
--- a/ui/ducks/bridge/types.ts
+++ b/ui/ducks/bridge/types.ts
@@ -11,14 +11,12 @@ import { type TxAlert } from '../../../shared/types/security-alerts-api';
 
 export type BridgeToken = {
   address: string;
-  assetId?: CaipAssetType;
+  assetId: CaipAssetType;
   symbol: string;
   image: string;
   decimals: number;
-  chainId: number | Hex | ChainId | CaipChainId;
-  balance: string; // raw balance
-  // TODO deprecate this field and use balance instead
-  string: string | undefined; // normalized balance as a stringified number
+  chainId: Hex | CaipChainId;
+  balance: string; // normalized balance as a stringified number
   tokenFiatAmount?: number | null;
   occurrences?: number;
   aggregators?: string[];
@@ -26,12 +24,6 @@ export type BridgeToken = {
 };
 
 export type BridgeState = {
-  /*
-   * This stores the user's selected destination chain, and will be null if the user has not selected a destination chain
-   * This should not be accessed directly in components/hooks, use the getToChain selector instead
-   * The getToChain selector uses the source chain as the destination chain by default if toChainId is null
-   */
-  toChainId: CaipChainId | null;
   fromToken: BridgeToken | null;
   toToken: BridgeToken | null;
   fromTokenInputValue: string | null;
@@ -47,13 +39,12 @@ export type BridgeState = {
   txAlert: TxAlert | null;
 };
 
-export type ChainIdPayload = { payload: ChainId | Hex | CaipChainId | null };
 export type TokenPayload = {
   payload: {
     address: GenericQuoteRequest['srcTokenAddress'];
     symbol: string;
     decimals: number;
-    chainId: Exclude<ChainIdPayload['payload'], null>;
+    chainId: ChainId | Hex | CaipChainId;
     balance?: string;
     string?: string;
     image?: string;
diff --git a/ui/ducks/bridge/utils.ts b/ui/ducks/bridge/utils.ts
index 534e83702ab4..b3c59f47dacf 100644
--- a/ui/ducks/bridge/utils.ts
+++ b/ui/ducks/bridge/utils.ts
@@ -6,10 +6,6 @@ import {
 } from '@metamask/utils';
 import { BigNumber } from 'bignumber.js';
 import type { ContractMarketData } from '@metamask/assets-controllers';
-import {
-  AddNetworkFields,
-  NetworkConfiguration,
-} from '@metamask/network-controller';
 import {
   ChainId,
   type TxData,
@@ -235,16 +231,6 @@ export const exchangeRatesFromNativeAndCurrencyRates = (
   };
 };
 
-export const isNetworkAdded = (
-  v:
-    | NetworkConfiguration
-    | AddNetworkFields
-    | (Omit<NetworkConfiguration, 'chainId'> & { chainId: CaipChainId })
-    | undefined,
-): v is NetworkConfiguration =>
-  v !== undefined &&
-  'networkClientId' in v.rpcEndpoints[v.defaultRpcEndpointIndex];
-
 const getTokenImage = (payload: TokenPayload['payload']) => {
   if (!payload) {
     return '';
@@ -273,21 +259,20 @@ const getTokenImage = (payload: TokenPayload['payload']) => {
 };
 
 export const toBridgeToken = (
-  payload: TokenPayload['payload'],
-): BridgeToken | null => {
-  if (!payload) {
-    return null;
-  }
+  payload: NonNullable<TokenPayload['payload']>,
+): BridgeToken => {
   const caipChainId = formatChainIdToCaip(payload.chainId);
   return {
     ...payload,
     balance: payload.balance ?? '0',
-    string: payload.string ?? '0',
-    chainId: payload.chainId,
+    chainId: isNonEvmChainId(payload.chainId)
+      ? caipChainId
+      : formatChainIdToHex(payload.chainId),
     image: getTokenImage(payload),
     assetId: payload.assetId ?? toAssetId(payload.address, caipChainId),
   };
 };
+
 const createBridgeTokenPayload = (
   tokenData: {
     address: string;
@@ -297,7 +282,7 @@ const createBridgeTokenPayload = (
     assetId?: string;
   },
   chainId: ChainId | Hex | CaipChainId,
-): TokenPayload['payload'] | null => {
+) => {
   const { assetId, ...rest } = tokenData;
   return toBridgeToken({
     ...rest,
@@ -306,9 +291,9 @@ const createBridgeTokenPayload = (
 };
 
 export const getDefaultToToken = (
-  targetChainId: CaipChainId,
   fromToken: Pick<NonNullable<TokenPayload['payload']>, 'address' | 'chainId'>,
 ) => {
+  const targetChainId = formatChainIdToCaip(fromToken.chainId);
   const commonPair = BRIDGE_CHAINID_COMMON_TOKEN_PAIR[targetChainId];
 
   if (commonPair) {
@@ -344,5 +329,5 @@ export const getDefaultToToken = (
     return createBridgeTokenPayload(nativeAsset, targetChainId);
   }
 
-  return null;
+  throw new Error(`No default token found for chainId: ${targetChainId}`);
 };
diff --git a/ui/hooks/bridge/useBridgeExchangeRates.ts b/ui/hooks/bridge/useBridgeExchangeRates.ts
index 95ff724d7541..df910a6c6c9f 100644
--- a/ui/hooks/bridge/useBridgeExchangeRates.ts
+++ b/ui/hooks/bridge/useBridgeExchangeRates.ts
@@ -4,7 +4,6 @@ import {
   getBridgeQuotes,
   getFromToken,
   getQuoteRequest,
-  getToChain,
   getToToken,
 } from '../../ducks/bridge/selectors';
 import { getMarketData, getParticipateInMetaMetrics } from '../../selectors';
@@ -15,15 +14,12 @@ import {
   setSrcTokenExchangeRates,
 } from '../../ducks/bridge/bridge';
 import { exchangeRateFromMarketData } from '../../ducks/bridge/utils';
-import { useMultichainSelector } from '../useMultichainSelector';
-import { getMultichainCurrentChainId } from '../../selectors/multichain';
 
 export const useBridgeExchangeRates = () => {
   const { srcTokenAddress, destTokenAddress } = useSelector(getQuoteRequest);
   const { activeQuote } = useSelector(getBridgeQuotes);
-  const fromChainId = useMultichainSelector(getMultichainCurrentChainId);
-  const toChain = useSelector(getToChain);
-  const toChainId = toChain?.chainId;
+  const fromChainId = useSelector(getFromToken).chainId;
+  const toChainId = useSelector(getToToken).chainId;
 
   const isMetaMetricsEnabled = useSelector(getParticipateInMetaMetrics);
 
diff --git a/ui/hooks/bridge/useBridgeQueryParams.ts b/ui/hooks/bridge/useBridgeQueryParams.ts
index dde7bda93b01..68c526661ffe 100644
--- a/ui/hooks/bridge/useBridgeQueryParams.ts
+++ b/ui/hooks/bridge/useBridgeQueryParams.ts
@@ -2,18 +2,14 @@ import { useEffect, useMemo, useCallback, useState, useRef } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import { useNavigate, useLocation } from 'react-router-dom-v5-compat';
 import {
-  CaipAssetType,
+  type CaipAssetType,
   CaipAssetTypeStruct,
   parseCaipAssetType,
 } from '@metamask/utils';
 import {
-  formatChainIdToCaip,
   getNativeAssetForChainId,
-  isCrossChain,
   isNativeAddress,
 } from '@metamask/bridge-controller';
-import { type InternalAccount } from '@metamask/keyring-internal-api';
-import { type NetworkConfiguration } from '@metamask/network-controller';
 import {
   type AssetMetadata,
   fetchAssetMetadataForAssetIds,
@@ -21,19 +17,12 @@ import {
 import { BridgeQueryParams } from '../../../shared/lib/deep-links/routes/swap';
 import { calcTokenAmount } from '../../../shared/lib/transactions-controller-utils';
 import {
-  setEVMSrcTokenBalance,
-  setEVMSrcNativeBalance,
-  setFromChain,
+  setLatestEVMBalances,
   setFromToken,
   setFromTokenInputValue,
   setToToken,
 } from '../../ducks/bridge/actions';
-import {
-  getFromAccount,
-  getFromChain,
-  getFromChains,
-  getFromToken,
-} from '../../ducks/bridge/selectors';
+import { getFromChains, getFromToken } from '../../ducks/bridge/selectors';
 
 const parseAsset = (assetId: string | null) => {
   if (!assetId) {
@@ -81,9 +70,7 @@ const fetchAssetMetadata = async (
 export const useBridgeQueryParams = () => {
   const dispatch = useDispatch();
   const fromChains = useSelector(getFromChains);
-  const fromChain = useSelector(getFromChain);
   const fromToken = useSelector(getFromToken);
-  const selectedAccount = useSelector(getFromAccount);
 
   const abortController = useRef<AbortController>(new AbortController());
 
@@ -168,53 +155,22 @@ export const useBridgeQueryParams = () => {
   }, [searchParams]);
 
   // Set fromChain and fromToken
-  const setFromChainAndToken = useCallback(
-    (
-      fromTokenMetadata,
-      fromAsset,
-      networks: NetworkConfiguration[],
-      account: InternalAccount | null,
-      network?: NetworkConfiguration,
-    ) => {
-      const { chainId: assetChainId } = fromAsset;
-
-      if (fromTokenMetadata) {
-        const { chainId, assetReference } = parseCaipAssetType(
-          fromTokenMetadata.assetId,
-        );
-        const nativeAsset = getNativeAssetForChainId(chainId);
-        // TODO remove this after v36.0.0 bridge-controller bump
-        const isNativeReference = nativeAsset?.assetId.includes(assetReference);
-        const token = {
-          ...fromTokenMetadata,
-          chainId,
-          address:
-            isNativeReference || isNativeAddress(assetReference)
-              ? (nativeAsset?.address ?? '')
-              : assetReference,
-        };
-        // If asset's chain is the same as fromChain, only set the fromToken
-        if (network && assetChainId === formatChainIdToCaip(network.chainId)) {
-          dispatch(setFromToken(token));
-        } else {
-          // Find the chain matching the srcAsset's chainId
-          const targetChain = networks.find(
-            (chain) => formatChainIdToCaip(chain.chainId) === assetChainId,
-          );
-          if (targetChain) {
-            dispatch(
-              setFromChain({
-                networkConfig: targetChain,
-                selectedAccount: account,
-                token,
-              }),
-            );
-          }
-        }
-      }
-    },
-    [],
-  );
+  const setFromTokenWithMetadata = useCallback((fromTokenMetadata) => {
+    if (fromTokenMetadata) {
+      const { chainId, assetReference } = parseCaipAssetType(
+        fromTokenMetadata.assetId,
+      );
+      const nativeAsset = getNativeAssetForChainId(chainId);
+      const token = {
+        ...fromTokenMetadata,
+        chainId,
+        address: isNativeAddress(assetReference)
+          ? (nativeAsset?.address ?? '')
+          : assetReference,
+      };
+      dispatch(setFromToken(token));
+    }
+  }, []);
 
   const setToChainAndToken = useCallback(
     async (toTokenMetadata: AssetMetadata) => {
@@ -247,20 +203,8 @@ export const useBridgeQueryParams = () => {
       ];
 
     // Process from chain/token first
-    setFromChainAndToken(
-      fromTokenMetadata,
-      parsedFromAssetId,
-      fromChains,
-      selectedAccount,
-      fromChain,
-    );
-  }, [
-    assetMetadataByAssetId,
-    parsedFromAssetId,
-    fromChains,
-    fromChain,
-    selectedAccount,
-  ]);
+    setFromTokenWithMetadata(fromTokenMetadata);
+  }, [assetMetadataByAssetId, parsedFromAssetId]);
 
   // Set toChainId and toToken
   useEffect(() => {
@@ -307,18 +251,9 @@ export const useBridgeQueryParams = () => {
       // Wait for url params to be applied
       !parsedFromAssetId &&
       !searchParams.get(BridgeQueryParams.FROM) &&
-      fromToken &&
-      // Wait for network to be changed if needed
-      !isCrossChain(fromToken.chainId, fromChain?.chainId) &&
-      selectedAccount
+      fromToken
     ) {
-      dispatch(setEVMSrcTokenBalance(fromToken, selectedAccount.address));
-      dispatch(
-        setEVMSrcNativeBalance({
-          selectedAddress: selectedAccount.address,
-          chainId: fromToken.chainId,
-        }),
-      );
+      dispatch(setLatestEVMBalances(fromToken));
     }
-  }, [parsedFromAssetId, selectedAccount, fromToken, fromChain, searchParams]);
+  }, [parsedFromAssetId, fromToken, searchParams]);
 };
diff --git a/ui/hooks/bridge/useBridging.ts b/ui/hooks/bridge/useBridging.ts
index 5f2ad074bb67..5c042dadc86f 100644
--- a/ui/hooks/bridge/useBridging.ts
+++ b/ui/hooks/bridge/useBridging.ts
@@ -32,12 +32,9 @@ import { BridgeQueryParams } from '../../../shared/lib/deep-links/routes/swap';
 import { trace, TraceName } from '../../../shared/lib/trace';
 import { toAssetId } from '../../../shared/lib/asset-utils';
 import { ALL_ALLOWED_BRIDGE_CHAIN_IDS } from '../../../shared/constants/bridge';
-import {
-  getFromChains,
-  getLastSelectedChainId,
-} from '../../ducks/bridge/selectors';
-import { getMultichainProviderConfig } from '../../selectors/multichain';
+import { getFromChains } from '../../ducks/bridge/selectors';
 import { CHAIN_IDS } from '../../../shared/constants/network';
+import { getFromChain } from '../../ducks/bridge/selectors';
 
 const useBridging = () => {
   const navigate = useNavigate();
@@ -48,8 +45,6 @@ const useBridging = () => {
   const isMetaMetricsEnabled = useSelector(getParticipateInMetaMetrics);
   const isMarketingEnabled = useSelector(getDataCollectionForMarketing);
 
-  const lastSelectedChainId = useSelector(getLastSelectedChainId);
-  const providerConfig = useSelector(getMultichainProviderConfig);
   const fromChains = useSelector(getFromChains);
 
   const isChainIdEnabledForBridging = useCallback(
@@ -61,6 +56,7 @@ const useBridging = () => {
       ),
     [fromChains],
   );
+  const fromChain = useSelector(getFromChain);
 
   const openBridgeExperience = useCallback(
     (
@@ -83,10 +79,10 @@ const useBridging = () => {
        *
        * default fromChain: srctoken.chainId > lastSelectedId > MAINNET
        */
-      const targetChainId = isChainIdEnabledForBridging(lastSelectedChainId)
-        ? lastSelectedChainId
+      const targetChainId = isChainIdEnabledForBridging(fromChain.chainId)
+        ? fromChain.chainId
         : CHAIN_IDS.MAINNET;
-      if (!srcAssetIdToUse && targetChainId !== providerConfig?.chainId) {
+      if (!srcAssetIdToUse) {
         srcAssetIdToUse = getNativeAssetForChainId(targetChainId)?.assetId;
       }
 
@@ -105,7 +101,7 @@ const useBridging = () => {
           text: 'Swap',
           // TODO: Fix in https://github.com/MetaMask/metamask-extension/issues/31860
           // eslint-disable-next-line @typescript-eslint/naming-convention
-          chain_id: srcToken?.chainId ?? lastSelectedChainId,
+          chain_id: srcToken?.chainId ?? fromChain?.chainId,
         },
       });
       dispatch(
@@ -139,9 +135,8 @@ const useBridging = () => {
       trackEvent,
       isMetaMetricsEnabled,
       isMarketingEnabled,
-      lastSelectedChainId,
-      providerConfig?.chainId,
       isChainIdEnabledForBridging,
+      fromChain?.chainId,
     ],
   );
 
diff --git a/ui/hooks/bridge/useIsTxSubmittable.ts b/ui/hooks/bridge/useIsTxSubmittable.ts
index 35986dfce132..dd10e018cd24 100644
--- a/ui/hooks/bridge/useIsTxSubmittable.ts
+++ b/ui/hooks/bridge/useIsTxSubmittable.ts
@@ -6,13 +6,10 @@ import {
   getValidationErrors,
   getToToken,
 } from '../../ducks/bridge/selectors';
-import { getMultichainCurrentChainId } from '../../selectors/multichain';
-import { useMultichainSelector } from '../useMultichainSelector';
 
 export const useIsTxSubmittable = () => {
   const fromToken = useSelector(getFromToken);
   const toToken = useSelector(getToToken);
-  const fromChainId = useMultichainSelector(getMultichainCurrentChainId);
   const fromAmount = useSelector(getFromAmount);
   const { activeQuote } = useSelector(getBridgeQuotes);
 
@@ -26,7 +23,6 @@ export const useIsTxSubmittable = () => {
   return Boolean(
     fromToken &&
       toToken &&
-      fromChainId &&
       fromAmount &&
       activeQuote &&
       !isInsufficientBalance &&
diff --git a/ui/hooks/bridge/useSmartSlippage.ts b/ui/hooks/bridge/useSmartSlippage.ts
index 96c84834f8c9..476e66546d60 100644
--- a/ui/hooks/bridge/useSmartSlippage.ts
+++ b/ui/hooks/bridge/useSmartSlippage.ts
@@ -9,11 +9,8 @@ import { setSlippage } from '../../ducks/bridge/actions';
 import type { BridgeToken } from '../../ducks/bridge/types';
 
 type UseSmartSlippageParams = {
-  fromChain: { chainId: string } | null | undefined;
-  toChain: { chainId: string } | null | undefined;
-  fromToken: BridgeToken | null;
-  toToken: BridgeToken | null;
-  isSwap: boolean;
+  fromToken: BridgeToken;
+  toToken: BridgeToken;
 };
 
 // This hook doesn't return anything as it only dispatches slippage updates
@@ -28,55 +25,41 @@ type UseSmartSlippageParams = {
  * - Supports Solana AUTO mode (undefined)
  *
  * @param options0
- * @param options0.fromChain
- * @param options0.toChain
  * @param options0.fromToken
  * @param options0.toToken
- * @param options0.isSwap
  */
 export function useSmartSlippage({
-  fromChain,
-  toChain,
   fromToken,
   toToken,
-  isSwap,
 }: UseSmartSlippageParams): void {
   const dispatch = useDispatch();
 
   // Calculate the appropriate slippage for current context
-  const calculateCurrentSlippage = useCallback(() => {
-    const context: SlippageContext = {
-      fromChain,
-      toChain,
-      fromToken,
-      toToken,
-      isSwap,
-    };
+  const calculateCurrentSlippage = useCallback(
+    (fromTokenInput: BridgeToken, toTokenInput: BridgeToken) => {
+      const context: SlippageContext = {
+        fromToken: fromTokenInput,
+        toToken: toTokenInput,
+      };
 
-    const slippage = calculateSlippage(context);
+      const slippage = calculateSlippage(context);
 
-    // Log the reason in development
-    if (process.env.NODE_ENV === 'development') {
-      const reason = getSlippageReason(context);
-      console.log(
-        `[useSmartSlippage] Slippage calculated: ${slippage ?? 'AUTO'}% - ${reason}`,
-      );
-    }
+      // Log the reason in development
+      if (process.env.NODE_ENV === 'development') {
+        const reason = getSlippageReason(context);
+        console.log(
+          `[useSmartSlippage] Slippage calculated: ${slippage ?? 'AUTO'}% - ${reason}`,
+        );
+      }
 
-    return slippage;
-  }, [fromChain, toChain, fromToken, toToken, isSwap]);
+      return slippage;
+    },
+    [],
+  );
 
   // Update slippage when context changes
   useEffect(() => {
-    const newSlippage = calculateCurrentSlippage();
+    const newSlippage = calculateCurrentSlippage(fromToken, toToken);
     dispatch(setSlippage(newSlippage));
-  }, [
-    fromChain,
-    toChain,
-    fromToken,
-    toToken,
-    isSwap,
-    calculateCurrentSlippage,
-    dispatch,
-  ]);
+  }, [fromToken, toToken, calculateCurrentSlippage, dispatch]);
 }
diff --git a/ui/hooks/bridge/useTokenAlerts.ts b/ui/hooks/bridge/useTokenAlerts.ts
index 703972ab1ce2..4a420bbabc0a 100644
--- a/ui/hooks/bridge/useTokenAlerts.ts
+++ b/ui/hooks/bridge/useTokenAlerts.ts
@@ -3,12 +3,7 @@ import {
   formatAddressToCaipReference,
   isNativeAddress,
 } from '@metamask/bridge-controller';
-import {
-  getFromToken,
-  getFromChain,
-  getToToken,
-  getToChain,
-} from '../../ducks/bridge/selectors';
+import { getToToken } from '../../ducks/bridge/selectors';
 import {
   convertChainIdToBlockAidChainName,
   fetchTokenAlert,
@@ -18,22 +13,13 @@ import { AllowedBridgeChainIds } from '../../../shared/constants/bridge';
 import { useAsyncResult } from '../useAsync';
 
 export const useTokenAlerts = () => {
-  const fromToken = useSelector(getFromToken);
-  const fromChain = useSelector(getFromChain);
   const toToken = useSelector(getToToken);
-  const toChain = useSelector(getToChain);
 
   const { value: tokenAlert } =
     useAsyncResult<TokenAlertWithLabelIds | null>(async () => {
-      if (
-        fromToken &&
-        fromChain &&
-        toToken &&
-        toChain &&
-        !isNativeAddress(toToken.address)
-      ) {
+      if (!isNativeAddress(toToken.address)) {
         const chainName = convertChainIdToBlockAidChainName(
-          toChain?.chainId as AllowedBridgeChainIds,
+          toToken.chainId as AllowedBridgeChainIds,
         );
         if (chainName) {
           return await fetchTokenAlert(
@@ -43,7 +29,7 @@ export const useTokenAlerts = () => {
         }
       }
       return null;
-    }, [toToken?.address, toChain?.chainId]);
+    }, [toToken.address, toToken.chainId]);
 
   return { tokenAlert };
 };
diff --git a/ui/pages/bridge/hooks/useGasIncluded7702.ts b/ui/pages/bridge/hooks/useGasIncluded7702.ts
index b45b52dffccd..ff39ae95ea0b 100644
--- a/ui/pages/bridge/hooks/useGasIncluded7702.ts
+++ b/ui/pages/bridge/hooks/useGasIncluded7702.ts
@@ -9,10 +9,7 @@ import { getIsSmartTransaction } from '../../../../shared/modules/selectors';
 import { isRelaySupported } from '../../../store/actions';
 import { isAtomicBatchSupported } from '../../../store/controller-actions/transaction-controller';
 import { getUseSmartAccount } from '../../confirmations/selectors/preferences';
-
-type Chain = {
-  chainId: string;
-};
+import type { BridgeToken } from '../../../ducks/bridge/types';
 
 type Account = {
   address: string;
@@ -21,7 +18,7 @@ type Account = {
 type UseGasIncluded7702Params = {
   isSwap: boolean;
   selectedAccount: Account | null | undefined;
-  fromChain: Chain | null | undefined;
+  fromChainId: BridgeToken['chainId'];
   isSendBundleSupportedForChain: boolean;
 };
 
@@ -31,20 +28,20 @@ type UseGasIncluded7702Params = {
  * @param params - Configuration object
  * @param params.isSwap - Whether this is a swap transaction
  * @param params.selectedAccount - The selected account
- * @param params.fromChain - The source chain
+ * @param params.fromChainId - The source chain id
  * @param params.isSendBundleSupportedForChain - Whether send bundle is supported for the chain
  * @returns Whether gasless 7702 is supported
  */
 export function useGasIncluded7702({
   isSwap,
   selectedAccount,
-  fromChain,
+  fromChainId,
   isSendBundleSupportedForChain,
 }: UseGasIncluded7702Params): boolean {
   const [isGasIncluded7702Supported, setIsGasIncluded7702Supported] =
     useState(false);
   const isSmartTransaction = useSelector((state) =>
-    getIsSmartTransaction(state as never, fromChain?.chainId),
+    getIsSmartTransaction(state as never, fromChainId),
   );
 
   const smartAccountOptedIn = useSelector(getUseSmartAccount);
@@ -58,7 +55,7 @@ export function useGasIncluded7702({
         !smartAccountOptedIn ||
         !isSwap ||
         !selectedAccount?.address ||
-        !fromChain?.chainId
+        !fromChainId
       ) {
         if (!isCancelled) {
           setIsGasIncluded7702Supported(false);
@@ -66,13 +63,13 @@ export function useGasIncluded7702({
         return;
       }
 
-      if (isNonEvmChainId(fromChain.chainId)) {
+      if (isNonEvmChainId(fromChainId)) {
         setIsGasIncluded7702Supported(false);
         return;
       }
 
       try {
-        const chainIdInHex = formatChainIdToHex(fromChain.chainId);
+        const chainIdInHex = formatChainIdToHex(fromChainId);
         const atomicBatchResult = await isAtomicBatchSupported({
           address: selectedAccount.address as Hex,
           chainIds: [chainIdInHex],
@@ -84,7 +81,7 @@ export function useGasIncluded7702({
 
         const atomicBatchChainSupport = atomicBatchResult?.find(
           (result) =>
-            result.chainId.toLowerCase() === fromChain.chainId.toLowerCase(),
+            result.chainId.toLowerCase() === fromChainId.toLowerCase(),
         );
 
         const relaySupportsChain = await isRelaySupported(chainIdInHex);
@@ -111,7 +108,7 @@ export function useGasIncluded7702({
     };
   }, [
     smartAccountOptedIn,
-    fromChain?.chainId,
+    fromChainId,
     isSendBundleSupportedForChain,
     isSmartTransaction,
     isSwap,
diff --git a/ui/pages/bridge/hooks/useIsSendBundleSupported.ts b/ui/pages/bridge/hooks/useIsSendBundleSupported.ts
index 5618be91bbea..7e68ee3a1753 100644
--- a/ui/pages/bridge/hooks/useIsSendBundleSupported.ts
+++ b/ui/pages/bridge/hooks/useIsSendBundleSupported.ts
@@ -1,20 +1,19 @@
 import { useEffect, useState } from 'react';
-import { formatChainIdToHex } from '@metamask/bridge-controller';
+import {
+  formatChainIdToHex,
+  isNonEvmChainId,
+} from '@metamask/bridge-controller';
 import { isSendBundleSupported } from '../../../store/actions';
-import { isNonEvmChain } from '../../../ducks/bridge/utils';
-
-type Chain = {
-  chainId: string;
-};
+import type { BridgeToken } from '../../../ducks/bridge/types';
 
 /**
  * Custom hook to check if send bundle is supported for a chain
  *
- * @param fromChain - The source chain to check support for
+ * @param fromChainId - The source chain id to check support for
  * @returns Whether send bundle is supported for the chain
  */
 export function useIsSendBundleSupported(
-  fromChain: Chain | null | undefined,
+  fromChainId: BridgeToken['chainId'],
 ): boolean {
   const [isSendBundleSupportedForChain, setIsSendBundleSupportedForChain] =
     useState(false);
@@ -23,21 +22,21 @@ export function useIsSendBundleSupported(
     let isCancelled = false;
 
     const checkSendBundleSupport = async () => {
-      if (!fromChain?.chainId) {
+      if (!fromChainId) {
         if (!isCancelled) {
           setIsSendBundleSupportedForChain(false);
         }
         return;
       }
 
-      if (isNonEvmChain(fromChain.chainId)) {
+      if (isNonEvmChainId(fromChainId)) {
         setIsSendBundleSupportedForChain(false);
         return;
       }
 
       try {
         const isSupported = await isSendBundleSupported(
-          formatChainIdToHex(fromChain.chainId),
+          formatChainIdToHex(fromChainId),
         );
 
         if (!isCancelled) {
@@ -56,7 +55,7 @@ export function useIsSendBundleSupported(
     return () => {
       isCancelled = true;
     };
-  }, [fromChain?.chainId]);
+  }, [fromChainId]);
 
   return isSendBundleSupportedForChain;
 }
diff --git a/ui/pages/bridge/index.tsx b/ui/pages/bridge/index.tsx
index b7544a44328c..6fc69d936704 100644
--- a/ui/pages/bridge/index.tsx
+++ b/ui/pages/bridge/index.tsx
@@ -1,10 +1,11 @@
 import React, { useContext, useEffect, useState } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import { Route, Routes } from 'react-router-dom-v5-compat';
+import { type Hex } from '@metamask/utils';
 import {
   UnifiedSwapBridgeEventName,
-  // TODO: update this with all non-EVM chains when bitcoin added.
-  isSolanaChainId,
+  formatChainIdToHex,
+  isNonEvmChainId,
 } from '@metamask/bridge-controller';
 import { I18nContext } from '../../contexts/i18n';
 import { clearSwapsState } from '../../ducks/swaps/swaps';
@@ -21,7 +22,6 @@ import {
   ButtonIconSize,
   IconName,
 } from '../../components/component-library';
-import { getSelectedNetworkClientId } from '../../../shared/modules/selectors/networks';
 import useBridging from '../../hooks/bridge/useBridging';
 import {
   Content,
@@ -42,6 +42,7 @@ import { TextVariant } from '../../helpers/constants/design-system';
 import { useTxAlerts } from '../../hooks/bridge/useTxAlerts';
 import { getFromChain, getBridgeQuotes } from '../../ducks/bridge/selectors';
 import { useSafeNavigation } from '../../hooks/useSafeNavigation';
+import { getNetworkConfigurationIdByChainId } from '../../selectors';
 import PrepareBridgePage from './prepare/prepare-bridge-page';
 import AwaitingSignaturesCancelButton from './awaiting-signatures/awaiting-signatures-cancel-button';
 import AwaitingSignatures from './awaiting-signatures/awaiting-signatures';
@@ -69,8 +70,6 @@ const CrossChainSwap = ({ location }: CrossChainSwapProps) => {
     'isFromTransactionShield',
   );
 
-  const selectedNetworkClientId = useSelector(getSelectedNetworkClientId);
-
   const resetControllerAndInputStates = async () => {
     await dispatch(resetBridgeState());
   };
@@ -79,10 +78,13 @@ const CrossChainSwap = ({ location }: CrossChainSwapProps) => {
 
   // Get chain information to determine if we need gas estimates
   const fromChain = useSelector(getFromChain);
-  // Only fetch gas estimates if the source chain is EVM (not Solana)
-  const shouldFetchGasEstimates =
-    // TODO: update this with all non-EVM chains when bitcoin added.
-    fromChain?.chainId && !isSolanaChainId(fromChain.chainId);
+  const isEvmChain = !isNonEvmChainId(fromChain.chainId);
+  const networkClientIdsByHexChainId: Record<Hex, string> = useSelector(
+    getNetworkConfigurationIdByChainId,
+  );
+  const selectedNetworkClientId = isEvmChain
+    ? networkClientIdsByHexChainId[formatChainIdToHex(fromChain.chainId)]
+    : undefined;
 
   useEffect(() => {
     dispatch(
@@ -106,7 +108,7 @@ const CrossChainSwap = ({ location }: CrossChainSwapProps) => {
   }, []);
 
   // Needed for refreshing gas estimates (only for EVM chains)
-  useGasFeeEstimates(selectedNetworkClientId, shouldFetchGasEstimates);
+  useGasFeeEstimates(selectedNetworkClientId, isEvmChain);
   // Needed for fetching exchange rates for tokens that have not been imported
   useBridgeExchangeRates();
   // Emits events related to quote-fetching
diff --git a/ui/pages/bridge/prepare/bridge-input-group.tsx b/ui/pages/bridge/prepare/bridge-input-group.tsx
index b7872ab302a2..763a69edb3c1 100644
--- a/ui/pages/bridge/prepare/bridge-input-group.tsx
+++ b/ui/pages/bridge/prepare/bridge-input-group.tsx
@@ -2,7 +2,9 @@ import React, { useEffect, useRef } from 'react';
 import { useSelector } from 'react-redux';
 import {
   formatChainIdToCaip,
+  formatChainIdToHex,
   isNativeAddress,
+  isNonEvmChainId,
 } from '@metamask/bridge-controller';
 import { getAccountLink } from '@metamask/etherscan-link';
 import {
@@ -10,8 +12,6 @@ import {
   TextField,
   TextFieldType,
   ButtonLink,
-  Button,
-  ButtonSize,
 } from '../../../components/component-library';
 import { AssetPicker } from '../../../components/multichain/asset-picker-amount/asset-picker';
 import { TabName } from '../../../components/multichain/asset-picker-amount/asset-picker-modal/asset-picker-modal-tabs';
@@ -36,13 +36,9 @@ import { shortenString } from '../../../helpers/utils/util';
 import { useCopyToClipboard } from '../../../hooks/useCopyToClipboard';
 import { MINUTE } from '../../../../shared/constants/time';
 import { getIntlLocale } from '../../../ducks/locale/locale';
-import {
-  MULTICHAIN_NETWORK_BLOCK_EXPLORER_FORMAT_URLS_MAP,
-  MultichainNetworks,
-} from '../../../../shared/constants/multichain/networks';
+import { MULTICHAIN_NETWORK_BLOCK_EXPLORER_FORMAT_URLS_MAP } from '../../../../shared/constants/multichain/networks';
 import { formatBlockExplorerAddressUrl } from '../../../../shared/lib/multichain/networks';
 import type { BridgeToken } from '../../../ducks/bridge/types';
-import { getMultichainCurrentChainId } from '../../../selectors/multichain';
 import { BridgeAssetPickerButton } from './components/bridge-asset-picker-button';
 
 const sanitizeAmountInput = (textToSanitize: string) => {
@@ -75,7 +71,7 @@ export const BridgeInputGroup = ({
 }: {
   amountInFiat?: string;
   onAmountChange?: (value: string) => void;
-  token: BridgeToken | null;
+  token: BridgeToken;
   buttonProps: { testId: string };
   amountFieldProps: Pick<
     React.ComponentProps<typeof TextField>,
@@ -102,9 +98,7 @@ export const BridgeInputGroup = ({
   const currency = useSelector(getCurrentCurrency);
   const locale = useSelector(getIntlLocale);
 
-  const currentChainId = useSelector(getMultichainCurrentChainId);
-  const selectedChainId = networkProps?.network?.chainId ?? currentChainId;
-
+  const selectedChainId = token?.chainId;
   const [, handleCopy] = useCopyToClipboard(MINUTE);
 
   const inputRef = useRef<HTMLInputElement | null>(null);
@@ -132,10 +126,9 @@ export const BridgeInputGroup = ({
   const handleAddressClick = () => {
     if (token && selectedChainId) {
       const caipChainId = formatChainIdToCaip(selectedChainId);
-      const isSolana = caipChainId === MultichainNetworks.SOLANA;
 
       let blockExplorerUrl = '';
-      if (isSolana) {
+      if (isNonEvmChainId(selectedChainId)) {
         const blockExplorerUrls =
           MULTICHAIN_NETWORK_BLOCK_EXPLORER_FORMAT_URLS_MAP[caipChainId];
         if (blockExplorerUrls) {
@@ -152,7 +145,7 @@ export const BridgeInputGroup = ({
         if (explorerUrl) {
           blockExplorerUrl = getAccountLink(
             token.address,
-            selectedChainId,
+            formatChainIdToHex(selectedChainId),
             {
               blockExplorerUrl: explorerUrl,
             },
@@ -242,29 +235,14 @@ export const BridgeInputGroup = ({
           isMultiselectEnabled={isMultiselectEnabled}
           isDestinationToken={isDestinationToken}
         >
-          {(onClickHandler, networkImageSrc) =>
-            isAmountReadOnly && !token ? (
-              <Button
-                data-testid={buttonProps.testId}
-                onClick={onClickHandler}
-                size={ButtonSize.Lg}
-                paddingLeft={6}
-                paddingRight={6}
-                fontWeight={FontWeight.Normal}
-                style={{ whiteSpace: 'nowrap' }}
-              >
-                {t('swapSwapTo')}
-              </Button>
-            ) : (
-              <BridgeAssetPickerButton
-                onClick={onClickHandler}
-                networkImageSrc={networkImageSrc}
-                asset={(token as never) ?? undefined}
-                networkProps={networkProps}
-                data-testid={buttonProps.testId}
-              />
-            )
-          }
+          {(onClickHandler) => (
+            <BridgeAssetPickerButton
+              onClick={onClickHandler}
+              asset={token}
+              networkProps={networkProps}
+              data-testid={buttonProps.testId}
+            />
+          )}
         </AssetPicker>
       </Row>
 
diff --git a/ui/pages/bridge/prepare/components/bridge-asset-picker-button.tsx b/ui/pages/bridge/prepare/components/bridge-asset-picker-button.tsx
index 587b7fd149cb..c746fda5f3dc 100644
--- a/ui/pages/bridge/prepare/components/bridge-asset-picker-button.tsx
+++ b/ui/pages/bridge/prepare/components/bridge-asset-picker-button.tsx
@@ -1,4 +1,5 @@
 import React from 'react';
+import { formatChainIdToCaip } from '@metamask/bridge-controller';
 import {
   SelectButtonProps,
   SelectButtonSize,
@@ -24,16 +25,17 @@ import {
 import { useI18nContext } from '../../../../hooks/useI18nContext';
 import { AssetPicker } from '../../../../components/multichain/asset-picker-amount/asset-picker';
 import { getNftImage } from '../../../../helpers/utils/nfts';
+import { type BridgeToken } from '../../../../ducks/bridge/types';
+import { BRIDGE_CHAIN_ID_TO_NETWORK_IMAGE_MAP } from '../../../../../shared/constants/bridge';
 
 export const BridgeAssetPickerButton = ({
   asset,
   networkProps,
-  networkImageSrc,
   ...props
 }: {
-  networkImageSrc?: string;
+  asset: BridgeToken;
 } & SelectButtonProps<'div'> &
-  Pick<React.ComponentProps<typeof AssetPicker>, 'asset' | 'networkProps'>) => {
+  Pick<React.ComponentProps<typeof AssetPicker>, 'networkProps'>) => {
   const t = useI18nContext();
 
   return (
@@ -72,7 +74,11 @@ export const BridgeAssetPickerButton = ({
               asset ? (
                 <AvatarNetwork
                   name={networkProps?.network?.name ?? ''}
-                  src={networkImageSrc}
+                  src={
+                    BRIDGE_CHAIN_ID_TO_NETWORK_IMAGE_MAP[
+                      formatChainIdToCaip(asset.chainId)
+                    ]
+                  }
                   size={AvatarNetworkSize.Xs}
                 />
               ) : undefined
diff --git a/ui/pages/bridge/prepare/components/destination-account-list-item.tsx b/ui/pages/bridge/prepare/components/destination-account-list-item.tsx
index 01bbb0197d88..04330b42c20a 100644
--- a/ui/pages/bridge/prepare/components/destination-account-list-item.tsx
+++ b/ui/pages/bridge/prepare/components/destination-account-list-item.tsx
@@ -35,6 +35,7 @@ import {
 } from '../../../../selectors';
 // eslint-disable-next-line import/no-restricted-paths
 import { normalizeSafeAddress } from '../../../../../app/scripts/lib/multichain/address';
+import { NETWORK_TO_SHORT_NETWORK_NAME_MAP } from '../../../../../shared/constants/bridge';
 import { useGetFormattedTokensPerChain } from '../../../../hooks/useGetFormattedTokensPerChain';
 import { useAccountTotalCrossChainFiatBalance } from '../../../../hooks/useAccountTotalCrossChainFiatBalance';
 import UserPreferencedCurrencyDisplay from '../../../../components/app/user-preferenced-currency-display/user-preferenced-currency-display.component';
@@ -184,7 +185,11 @@ const DestinationAccountListItem: React.FC<DestinationAccountListItemProps> = ({
                   : (toChain?.chainId ?? '')
               ]
             }
-            name={toChain?.name ?? ''}
+            name={
+              NETWORK_TO_SHORT_NETWORK_NAME_MAP[
+                toChain.chainId as keyof typeof NETWORK_TO_SHORT_NETWORK_NAME_MAP
+              ]
+            }
             size={AvatarNetworkSize.Xs}
           />
         </Column>
diff --git a/ui/pages/bridge/prepare/prepare-bridge-page.tsx b/ui/pages/bridge/prepare/prepare-bridge-page.tsx
index eaafc9afe075..6b7279f43393 100644
--- a/ui/pages/bridge/prepare/prepare-bridge-page.tsx
+++ b/ui/pages/bridge/prepare/prepare-bridge-page.tsx
@@ -21,18 +21,19 @@ import {
   UnifiedSwapBridgeEventName,
   type BridgeController,
   isCrossChain,
+  isNonEvmChainId,
+  formatChainIdToHex,
 } from '@metamask/bridge-controller';
-import { Hex, parseCaipChainId } from '@metamask/utils';
+import { CaipChainId, Hex, parseCaipChainId } from '@metamask/utils';
 import {
   setFromToken,
   setFromTokenInputValue,
   setSelectedQuote,
-  setToChainId,
   setToToken,
   updateQuoteRequestParams,
   resetBridgeState,
   trackUnifiedSwapBridgeEvent,
-  setFromChain,
+  switchTokens,
 } from '../../../ducks/bridge/actions';
 import {
   getBridgeQuotes,
@@ -85,7 +86,6 @@ import {
   formatTokenAmount,
   isQuoteExpiredOrInvalid as isQuoteExpiredOrInvalidUtil,
 } from '../utils/quote';
-import { isNetworkAdded } from '../../../ducks/bridge/utils';
 import MascotBackgroundAnimation from '../../swaps/mascot-background-animation/mascot-background-animation';
 import { Column } from '../layout';
 import useRamps from '../../../hooks/ramps/useRamps/useRamps';
@@ -97,11 +97,6 @@ import {
 import { isHardwareKeyring } from '../../../helpers/utils/hardware';
 import { SECOND } from '../../../../shared/constants/time';
 import { getIntlLocale } from '../../../ducks/locale/locale';
-import { useMultichainSelector } from '../../../hooks/useMultichainSelector';
-import {
-  getMultichainNativeCurrency,
-  getMultichainProviderConfig,
-} from '../../../selectors/multichain';
 import { setEnabledAllPopularNetworks } from '../../../store/actions';
 import { MultichainBridgeQuoteCard } from '../quotes/multichain-bridge-quote-card';
 import { TokenFeatureType } from '../../../../shared/types/security-alerts-api';
@@ -136,17 +131,22 @@ export const useEnableMissingNetwork = () => {
   const dispatch = useDispatch();
 
   const enableMissingNetwork = useCallback(
-    (chainId: Hex) => {
+    (chainId: Hex | CaipChainId) => {
+      if (isNonEvmChainId(chainId)) {
+        return;
+      }
       const enabledNetworkKeys = Object.keys(enabledNetworksByNamespace ?? {});
 
       const caipChainId = formatChainIdToCaip(chainId);
       const { namespace } = parseCaipChainId(caipChainId);
+      const hexChainId = formatChainIdToHex(chainId);
 
       if (namespace) {
-        const isPopularNetwork = FEATURED_NETWORK_CHAIN_IDS.includes(chainId);
+        const isPopularNetwork =
+          FEATURED_NETWORK_CHAIN_IDS.includes(hexChainId);
 
         if (isPopularNetwork) {
-          const isNetworkEnabled = enabledNetworkKeys.includes(chainId);
+          const isNetworkEnabled = enabledNetworkKeys.includes(hexChainId);
           if (!isNetworkEnabled) {
             // Bridging between popular networks indicates we want the 'select all' enabled
             // This way users can see their full bridging tx activity
@@ -175,7 +175,9 @@ const PrepareBridgePage = ({
 
   const isSwap = useSelector(getIsSwap);
 
-  const isSendBundleSupportedForChain = useIsSendBundleSupported(fromChain);
+  const isSendBundleSupportedForChain = useIsSendBundleSupported(
+    fromChain.chainId,
+  );
   const gasIncluded = useSelector((state) =>
     getIsGasIncluded(state, isSendBundleSupportedForChain),
   );
@@ -199,14 +201,13 @@ const PrepareBridgePage = ({
       return false;
     }
     return Object.keys(fromTokens).length === 0;
-  }, [fromTokens, fromChain]);
+  }, [fromTokens, fromChain.chainId]);
 
   const fromAmount = useSelector(getFromAmount);
   const fromAmountInCurrency = useSelector(getFromAmountInCurrency);
 
   const smartTransactionsEnabled = useSelector(getIsStxEnabled);
 
-  const providerConfig = useMultichainSelector(getMultichainProviderConfig);
   const slippage = useSelector(getSlippage);
 
   const quoteRequest = useSelector(getQuoteRequest);
@@ -228,8 +229,8 @@ const PrepareBridgePage = ({
   const isQuoteExpiredOrInvalid = isQuoteExpiredOrInvalidUtil({
     activeQuote: unvalidatedQuote,
     toToken,
-    toChain,
-    fromChain,
+    toChainId: toChain?.chainId,
+    fromChainId: fromChain?.chainId,
     isQuoteExpired,
     insufficientBal: quoteRequest.insufficientBal,
   });
@@ -242,7 +243,7 @@ const PrepareBridgePage = ({
     isSwap,
     isSendBundleSupportedForChain,
     selectedAccount,
-    fromChain,
+    fromChainId: fromChain.chainId,
   });
 
   const shouldShowMaxButton =
@@ -256,7 +257,9 @@ const PrepareBridgePage = ({
   const isTxSubmittable = useIsTxSubmittable();
   const locale = useSelector(getIntlLocale);
 
-  const ticker = useMultichainSelector(getMultichainNativeCurrency);
+  const ticker = fromChain
+    ? getNativeAssetForChainId(fromChain.chainId)?.symbol
+    : undefined;
   const {
     isEstimatedReturnLow,
     isNoQuotesAvailable,
@@ -388,14 +391,8 @@ const PrepareBridgePage = ({
                     // Length of decimal part cannot exceed token.decimals
                     .split('.')[0]
                 : undefined,
-            srcChainId: fromChain?.chainId,
-            destChainId: toChain?.chainId,
-            // This override allows quotes to be returned when the rpcUrl is a forked network
-            // Otherwise quotes get filtered out by the bridge-api when the wallet's real
-            // balance is less than the tenderly balance
-            insufficientBal: providerConfig?.rpcUrl?.includes('localhost')
-              ? true
-              : undefined,
+            srcChainId: fromToken?.chainId,
+            destChainId: toToken?.chainId,
             slippage,
             walletAddress: selectedAccount.address,
             destWalletAddress: selectedDestinationAccount?.address,
@@ -405,15 +402,14 @@ const PrepareBridgePage = ({
         : undefined,
     [
       fromToken?.address,
+      fromToken?.chainId,
       fromToken?.decimals,
       toToken?.address,
+      toToken?.chainId,
       fromAmount,
-      fromChain?.chainId,
-      toChain?.chainId,
       slippage,
       selectedAccount?.address,
       selectedDestinationAccount?.address,
-      providerConfig?.rpcUrl,
       gasIncluded,
       gasIncluded7702,
     ],
@@ -459,11 +455,8 @@ const PrepareBridgePage = ({
 
   // Use smart slippage defaults
   useSmartSlippage({
-    fromChain,
-    toChain,
     fromToken,
     toToken,
-    isSwap,
   });
 
   // Trace swap/bridge view loaded
@@ -538,18 +531,12 @@ const PrepareBridgePage = ({
             }
           }}
           networkProps={{
-            network: fromChain,
+            network: fromChains.find(
+              (chain) => chain.chainId === fromChain.chainId,
+            ),
             networks: fromChains,
             onNetworkChange: (networkConfig) => {
-              if (isNetworkAdded(networkConfig)) {
-                enableMissingNetwork(networkConfig.chainId);
-              }
-              dispatch(
-                setFromChain({
-                  networkConfig,
-                  selectedAccount,
-                }),
-              );
+              enableMissingNetwork(networkConfig.chainId);
             },
             header: t('yourNetworks'),
           }}
@@ -630,7 +617,10 @@ const PrepareBridgePage = ({
               disabled={
                 isSwitchingTemporarilyDisabled ||
                 !isValidQuoteRequest(quoteRequest, false) ||
-                (toChain && !isNetworkAdded(toChain))
+                // If no fromChains match the toChain, it means the toChain is not an enabled network
+                fromChains.every((chain) =>
+                  isCrossChain(chain.chainId, toChain.chainId),
+                )
               }
               onClick={() => {
                 dispatch(setSelectedQuote(null));
@@ -677,22 +667,8 @@ const PrepareBridgePage = ({
                       },
                     ),
                   );
-
                 setRotateSwitchTokens(!rotateSwitchTokens);
-
-                if (isSwap) {
-                  dispatch(setFromToken(toToken));
-                } else {
-                  // Handle account switching for Solana
-                  dispatch(
-                    setFromChain({
-                      networkConfig: toChain,
-                      token: toToken,
-                      selectedAccount,
-                    }),
-                  );
-                }
-                dispatch(setToToken(fromToken));
+                dispatch(switchTokens({ fromToken, toToken }));
               }}
             />
           </Box>
@@ -716,13 +692,15 @@ const PrepareBridgePage = ({
               dispatch(setToToken(bridgeToken));
             }}
             networkProps={{
-              network: toChain,
+              network: toChains.find(
+                (chain) => chain.chainId === toChain.chainId,
+              ),
               networks: toChains,
               onNetworkChange: (networkConfig) => {
-                if (isNetworkAdded(networkConfig)) {
-                  enableMissingNetwork(networkConfig.chainId);
-                }
-                dispatch(setToChainId(networkConfig.chainId));
+                enableMissingNetwork(networkConfig.chainId);
+                dispatch(
+                  setToToken(getNativeAssetForChainId(networkConfig.chainId)),
+                );
               },
               header: t('yourNetworks'),
               shouldDisableNetwork: ({ chainId }) =>
diff --git a/ui/pages/bridge/quotes/bridge-quotes-modal.tsx b/ui/pages/bridge/quotes/bridge-quotes-modal.tsx
index 4e4f429f64a1..8939955e7229 100644
--- a/ui/pages/bridge/quotes/bridge-quotes-modal.tsx
+++ b/ui/pages/bridge/quotes/bridge-quotes-modal.tsx
@@ -47,8 +47,6 @@ import {
 import { Column, Row } from '../layout';
 import { getCurrentCurrency } from '../../../ducks/metamask/metamask';
 import { getIntlLocale } from '../../../ducks/locale/locale';
-import { getMultichainNativeCurrency } from '../../../selectors/multichain';
-import { useMultichainSelector } from '../../../hooks/useMultichainSelector';
 
 export const BridgeQuotesModal = ({
   onClose,
@@ -68,7 +66,7 @@ export const BridgeQuotesModal = ({
     useSelector(getBridgeQuotes);
   const sortOrder = useSelector(getBridgeSortOrder);
   const currency = useSelector(getCurrentCurrency);
-  const nativeCurrency = useMultichainSelector(getMultichainNativeCurrency);
+  const nativeCurrency = getNativeAssetForChainId(fromToken.chainId)?.symbol;
   const locale = useSelector(getIntlLocale);
 
   return (
diff --git a/ui/pages/bridge/utils/quote.ts b/ui/pages/bridge/utils/quote.ts
index 119ad42704cf..4c247720132c 100644
--- a/ui/pages/bridge/utils/quote.ts
+++ b/ui/pages/bridge/utils/quote.ts
@@ -5,10 +5,6 @@ import {
   isNativeAddress,
   isNonEvmChainId,
 } from '@metamask/bridge-controller';
-import type {
-  NetworkConfiguration,
-  AddNetworkFields,
-} from '@metamask/network-controller';
 import { formatCurrency } from '../../../helpers/utils/confirm-tx.util';
 import { DEFAULT_PRECISION } from '../../../hooks/useCurrencyDisplay';
 import { formatAmount } from '../../confirmations/components/simulation-details/formatAmount';
@@ -109,15 +105,15 @@ export const formatProviderLabel = (args?: {
 export const isQuoteExpiredOrInvalid = ({
   activeQuote,
   toToken,
-  toChain,
-  fromChain,
+  toChainId,
+  fromChainId,
   isQuoteExpired,
   insufficientBal,
 }: {
   activeQuote: QuoteResponse | null;
   toToken: BridgeToken | null;
-  toChain?: NetworkConfiguration | AddNetworkFields;
-  fromChain?: NetworkConfiguration;
+  toChainId: BridgeToken['chainId'];
+  fromChainId: BridgeToken['chainId'];
   isQuoteExpired: boolean;
   insufficientBal?: boolean;
 }): boolean => {
@@ -126,7 +122,7 @@ export const isQuoteExpiredOrInvalid = ({
     isQuoteExpired &&
     (!insufficientBal ||
       // `insufficientBal` is always true for non-EVM chains (Solana, Bitcoin)
-      (fromChain && isNonEvmChainId(fromChain.chainId)))
+      isNonEvmChainId(fromChainId))
   ) {
     return true;
   }
@@ -140,8 +136,8 @@ export const isQuoteExpiredOrInvalid = ({
     const quoteDestChainIdCaip = activeQuote.quote?.destChainId
       ? formatChainIdToCaip(activeQuote.quote.destChainId)
       : '';
-    const selectedDestChainIdCaip = toChain?.chainId
-      ? formatChainIdToCaip(toChain.chainId)
+    const selectedDestChainIdCaip = toChainId
+      ? formatChainIdToCaip(toChainId)
       : '';
 
     return !(
diff --git a/ui/pages/bridge/utils/slippage-service.ts b/ui/pages/bridge/utils/slippage-service.ts
index 220282672a85..36c7fc3c4b6e 100644
--- a/ui/pages/bridge/utils/slippage-service.ts
+++ b/ui/pages/bridge/utils/slippage-service.ts
@@ -1,4 +1,4 @@
-import { isSolanaChainId } from '@metamask/bridge-controller';
+import { isCrossChain, isSolanaChainId } from '@metamask/bridge-controller';
 import type { BridgeToken } from '../../../ducks/bridge/types';
 import { STABLECOINS_BY_CHAIN_ID } from './stablecoins';
 
@@ -15,11 +15,8 @@ export enum SlippageValue {
  * Context for calculating slippage
  */
 export type SlippageContext = {
-  fromChain: { chainId: string } | null | undefined;
-  toChain: { chainId: string } | null | undefined;
-  fromToken: BridgeToken | null;
-  toToken: BridgeToken | null;
-  isSwap: boolean;
+  fromToken: BridgeToken;
+  toToken: BridgeToken;
 };
 
 /**
@@ -80,25 +77,25 @@ function isStablecoinPair(
 export function calculateSlippage(
   context: SlippageContext,
 ): number | undefined {
-  const { fromChain, toChain, fromToken, toToken, isSwap } = context;
+  const { fromToken, toToken } = context;
 
   // If no source chain, we can't determine the type
-  if (!fromChain?.chainId || !toChain?.chainId) {
+  if (!fromToken.chainId || !toToken.chainId) {
     return SlippageValue.BridgeDefault;
   }
 
   // 1. Cross-chain (bridge) → 2%
-  if (!isSwap || fromChain.chainId !== toChain.chainId) {
+  if (isCrossChain(fromToken.chainId, toToken.chainId)) {
     return SlippageValue.BridgeDefault;
   }
 
   // 2. Solana swap → undefined (AUTO mode)
-  if (isSolanaChainId(fromChain.chainId)) {
+  if (isSolanaChainId(fromToken.chainId)) {
     return undefined;
   }
 
   // 3. EVM swap → check for stablecoin pair
-  if (isStablecoinPair(fromChain.chainId, fromToken, toToken)) {
+  if (isStablecoinPair(fromToken.chainId, fromToken, toToken)) {
     return SlippageValue.EvmStablecoin; // 0.5%
   }
 
@@ -113,21 +110,21 @@ export function calculateSlippage(
  * @param context
  */
 export function getSlippageReason(context: SlippageContext): string {
-  const { fromChain, toChain, fromToken, toToken, isSwap } = context;
+  const { fromToken, toToken } = context;
 
-  if (!fromChain?.chainId || !toChain?.chainId) {
+  if (!fromToken.chainId || !toToken.chainId) {
     return 'Incomplete chain setup - using bridge default';
   }
 
-  if (!isSwap || fromChain.chainId !== toChain.chainId) {
+  if (isCrossChain(fromToken.chainId, toToken.chainId)) {
     return 'Cross-chain transaction';
   }
 
-  if (isSolanaChainId(fromChain.chainId)) {
+  if (isSolanaChainId(fromToken.chainId)) {
     return 'Solana swap (AUTO mode)';
   }
 
-  if (isStablecoinPair(fromChain.chainId, fromToken, toToken)) {
+  if (isStablecoinPair(fromToken.chainId, fromToken, toToken)) {
     return 'EVM stablecoin pair';
   }
 
diff --git a/ui/selectors/selectors.js b/ui/selectors/selectors.js
index 0ec339bed93d..e710eef53565 100644
--- a/ui/selectors/selectors.js
+++ b/ui/selectors/selectors.js
@@ -4107,7 +4107,7 @@ export function getShowUpdateModal(state) {
  * @returns {string | null} The previous version string, or null if not available.
  */
 export function getLastUpdatedFromVersion(state) {
-  return state.metamask.lastUpdatedFromVersion;
+  return '13.9.0'; //state.metamask.lastUpdatedFromVersion;
 }
 
 /**