diff --git a/app/components/UI/Bridge/hooks/useShouldRenderMaxOption/index.ts b/app/components/UI/Bridge/hooks/useShouldRenderMaxOption/index.ts
index cab9c1ef187c..fe774135b87b 100644
--- a/app/components/UI/Bridge/hooks/useShouldRenderMaxOption/index.ts
+++ b/app/components/UI/Bridge/hooks/useShouldRenderMaxOption/index.ts
@@ -1,7 +1,7 @@
+import { useMemo } from 'react';
 import { useSelector } from 'react-redux';
 import { selectShouldUseSmartTransaction } from '../../../../../selectors/smartTransactionsController';
 import { RootState } from '../../../../../reducers';
-import { selectIsGaslessSwapEnabled } from '../../../../../core/redux/slices/bridge';
 import { BridgeToken } from '../../types';
 import { useTokenAddress } from '../useTokenAddress';
 import {
@@ -10,14 +10,23 @@ import {
   isNonEvmChainId,
 } from '@metamask/bridge-controller';
 import { BigNumber } from 'bignumber.js';
+import { useIsSendBundleSupported } from '../useIsSendBundleSupported';
 
 export const useShouldRenderMaxOption = (
   token?: BridgeToken,
   displayBalance?: string,
   isQuoteSponsored = false,
 ) => {
-  const isGaslessSwapEnabled = useSelector((state: RootState) =>
-    token?.chainId ? selectIsGaslessSwapEnabled(state, token.chainId) : false,
+  const evmChainId = useMemo(() => {
+    if (!token?.chainId || isNonEvmChainId(token.chainId)) {
+      return undefined;
+    }
+    return formatChainIdToHex(token.chainId);
+  }, [token?.chainId]);
+  const isSendBundleSupported = useIsSendBundleSupported(evmChainId);
+  const isGaslessSwapEnabled = useMemo(
+    () => Boolean(isSendBundleSupported),
+    [isSendBundleSupported],
   );
   const stxEnabled = useSelector((state: RootState) =>
     token?.chainId && !isNonEvmChainId(token.chainId)
diff --git a/app/components/UI/Bridge/hooks/useShouldRenderMaxOption/useShouldRenderMaxOption.test.ts b/app/components/UI/Bridge/hooks/useShouldRenderMaxOption/useShouldRenderMaxOption.test.ts
index 68d0c3cd7474..04fd28b2ad42 100644
--- a/app/components/UI/Bridge/hooks/useShouldRenderMaxOption/useShouldRenderMaxOption.test.ts
+++ b/app/components/UI/Bridge/hooks/useShouldRenderMaxOption/useShouldRenderMaxOption.test.ts
@@ -1,12 +1,16 @@
 import { renderHook } from '@testing-library/react-hooks';
-import { useShouldRenderMaxOption } from '.';
-import { BridgeToken } from '../../types';
 import { CHAIN_IDS } from '@metamask/transaction-controller';
+import {
+  formatChainIdToHex,
+  isNativeAddress,
+  isNonEvmChainId,
+} from '@metamask/bridge-controller';
 import { useSelector } from 'react-redux';
+import { useShouldRenderMaxOption } from '.';
+import { BridgeToken } from '../../types';
 import { useTokenAddress } from '../useTokenAddress';
-import { isNativeAddress } from '@metamask/bridge-controller';
+import { useIsSendBundleSupported } from '../useIsSendBundleSupported';
 
-// Mock dependencies
 jest.mock('react-redux', () => ({
   useSelector: jest.fn(),
 }));
@@ -15,580 +19,189 @@ jest.mock('../useTokenAddress', () => ({
   useTokenAddress: jest.fn(),
 }));
 
-jest.mock('@metamask/bridge-controller', () => ({
-  isNativeAddress: jest.fn(),
+jest.mock('../useIsSendBundleSupported', () => ({
+  useIsSendBundleSupported: jest.fn(),
 }));
 
-jest.mock('../../../../../core/redux/slices/bridge', () => ({
-  selectIsGaslessSwapEnabled: jest.fn(),
-}));
-
-jest.mock('../../../../../selectors/smartTransactionsController', () => ({
-  selectShouldUseSmartTransaction: jest.fn(),
-}));
+jest.mock('@metamask/bridge-controller', () => {
+  const actual = jest.requireActual('@metamask/bridge-controller');
+  return {
+    ...actual,
+    formatChainIdToHex: jest.fn(),
+    isNativeAddress: jest.fn(),
+    isNonEvmChainId: jest.fn(),
+  };
+});
 
 const mockUseSelector = useSelector as jest.MockedFunction<typeof useSelector>;
 const mockUseTokenAddress = useTokenAddress as jest.MockedFunction<
   typeof useTokenAddress
 >;
+const mockUseIsSendBundleSupported =
+  useIsSendBundleSupported as jest.MockedFunction<
+    typeof useIsSendBundleSupported
+  >;
+const mockFormatChainIdToHex = formatChainIdToHex as jest.MockedFunction<
+  typeof formatChainIdToHex
+>;
 const mockIsNativeAddress = isNativeAddress as jest.MockedFunction<
   typeof isNativeAddress
 >;
+const mockIsNonEvmChainId = isNonEvmChainId as jest.MockedFunction<
+  typeof isNonEvmChainId
+>;
 
-/**
- * IMPORTANT: useSelector call order in the hook:
- * 1. First call: isGaslessSwapEnabled (line 12 in hook)
- * 2. Second call: stxEnabled (line 15 in hook)
- */
-describe('useShouldRenderMaxOption', () => {
-  const mockToken: BridgeToken = {
-    address: '0x1234567890123456789012345678901234567890',
-    symbol: 'TEST',
-    decimals: 18,
-    chainId: CHAIN_IDS.MAINNET,
-  };
+const mockToken: BridgeToken = {
+  address: '0x1234567890123456789012345678901234567890',
+  symbol: 'TEST',
+  decimals: 18,
+  chainId: CHAIN_IDS.MAINNET,
+};
 
-  const nativeToken: BridgeToken = {
-    address: '0x0000000000000000000000000000000000000000',
-    symbol: 'ETH',
-    decimals: 18,
-    chainId: CHAIN_IDS.MAINNET,
-  };
+const nativeToken: BridgeToken = {
+  address: '0x0000000000000000000000000000000000000000',
+  symbol: 'ETH',
+  decimals: 18,
+  chainId: CHAIN_IDS.MAINNET,
+};
 
+const setSelectorValues = ({ stxEnabled = true }: { stxEnabled?: boolean }) => {
+  mockUseSelector.mockImplementation(() => stxEnabled);
+};
+
+describe('useShouldRenderMaxOption', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+
+    setSelectorValues({ stxEnabled: true });
     mockUseTokenAddress.mockReturnValue(mockToken.address);
+    mockUseIsSendBundleSupported.mockReturnValue(false);
+    mockFormatChainIdToHex.mockImplementation(
+      (chainId) => chainId as `0x${string}`,
+    );
     mockIsNativeAddress.mockReturnValue(false);
-    // Default: isGaslessSwapEnabled = false, stxEnabled = true
-    let callCount = 0;
-    mockUseSelector.mockImplementation(() => {
-      callCount++;
-      // First call: isGaslessSwapEnabled = false
-      // Second call: stxEnabled = true
-      return callCount === 2;
-    });
+    mockIsNonEvmChainId.mockReturnValue(false);
   });
 
-  describe('Zero balance scenarios', () => {
-    it('returns false when displayBalance is undefined', () => {
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, undefined, false),
-      );
-
-      expect(result.current).toBe(false);
-    });
-
-    it('returns false when displayBalance is "0"', () => {
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '0', false),
-      );
-
-      expect(result.current).toBe(false);
-    });
-
-    it('returns false when displayBalance is "0.0"', () => {
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '0.0', false),
-      );
+  it('returns false when token is undefined', () => {
+    const { result } = renderHook(() =>
+      useShouldRenderMaxOption(undefined, '10'),
+    );
 
-      expect(result.current).toBe(false);
-    });
-
-    it('returns false when displayBalance is empty string', () => {
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '', false),
-      );
-
-      expect(result.current).toBe(false);
-    });
+    expect(result.current).toBe(false);
   });
 
-  describe('Non-native token scenarios', () => {
-    beforeEach(() => {
-      mockIsNativeAddress.mockReturnValue(false);
-      mockUseTokenAddress.mockReturnValue(mockToken.address);
-    });
-
-    it('returns true for non-native token with balance regardless of gasless', () => {
-      mockUseSelector.mockImplementation(() => false); // Both selectors false
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '100.5', false),
-      );
-
-      expect(result.current).toBe(true);
-    });
-
-    it('returns true for non-native token with balance regardless of stxEnabled', () => {
-      mockUseSelector.mockImplementation(() => false); // stxEnabled = false
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '50', false),
-      );
+  it('returns false when display balance is zero', () => {
+    const { result } = renderHook(() =>
+      useShouldRenderMaxOption(mockToken, '0'),
+    );
 
-      expect(result.current).toBe(true);
-    });
-
-    it('returns true for non-native token with balance regardless of isQuoteSponsored', () => {
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '25.75', true),
-      );
-
-      expect(result.current).toBe(true);
-    });
-
-    it('returns true for non-native token with very small balance', () => {
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '0.000001', false),
-      );
-
-      expect(result.current).toBe(true);
-    });
-
-    it('returns false for non-native token with zero balance', () => {
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '0', false),
-      );
-
-      expect(result.current).toBe(false);
-    });
+    expect(result.current).toBe(false);
   });
 
-  describe('Native token scenarios', () => {
-    beforeEach(() => {
-      mockIsNativeAddress.mockReturnValue(true);
-      mockUseTokenAddress.mockReturnValue(nativeToken.address);
-    });
-
-    it('returns false when native token has zero balance', () => {
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(nativeToken, '0', false),
-      );
-
-      expect(result.current).toBe(false);
-    });
-
-    it('returns false when native token has zero balance even with all conditions favorable', () => {
-      mockIsNativeAddress.mockReturnValue(true);
-      mockUseTokenAddress.mockReturnValue(nativeToken.address);
-      mockUseSelector.mockReturnValue(true); // stxEnabled=true, gasless=true
+  it('returns true for non-native token with positive balance', () => {
+    mockIsNativeAddress.mockReturnValue(false);
 
-      const { result } = renderHook(
-        () => useShouldRenderMaxOption(nativeToken, '0', true), // sponsored=true
-      );
+    const { result } = renderHook(() =>
+      useShouldRenderMaxOption(mockToken, '10'),
+    );
 
-      // Zero balance always returns false
-      expect(result.current).toBe(false);
-    });
+    expect(result.current).toBe(true);
   });
 
-  describe('Edge cases', () => {
-    it('returns false when token is undefined', () => {
-      mockUseTokenAddress.mockReturnValue(undefined);
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(undefined, '100', false),
-      );
-
-      expect(result.current).toBe(false);
-    });
-
-    it('returns false when token is undefined but has balance', () => {
-      mockUseTokenAddress.mockReturnValue(undefined);
-      mockIsNativeAddress.mockReturnValue(false);
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(undefined, '500', false),
-      );
+  it('returns true for native token when stx and sendBundle are enabled', () => {
+    setSelectorValues({ stxEnabled: true });
+    mockUseTokenAddress.mockReturnValue(nativeToken.address);
+    mockIsNativeAddress.mockReturnValue(true);
+    mockUseIsSendBundleSupported.mockReturnValue(true);
 
-      expect(result.current).toBe(false);
-    });
+    const { result } = renderHook(() =>
+      useShouldRenderMaxOption(nativeToken, '1.25'),
+    );
 
-    it('handles large balance values correctly for non-native tokens', () => {
-      mockIsNativeAddress.mockReturnValue(false);
-      mockUseTokenAddress.mockReturnValue(mockToken.address);
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '1000000.123456789', false),
-      );
-
-      expect(result.current).toBe(true);
-    });
-
-    it('handles very small but non-zero balance for non-native tokens', () => {
-      mockIsNativeAddress.mockReturnValue(false);
-      mockUseTokenAddress.mockReturnValue(mockToken.address);
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '0.000000001', false),
-      );
-
-      expect(result.current).toBe(true);
-    });
-
-    it('correctly identifies native token without chainId in token object', () => {
-      const tokenWithoutChainId = {
-        address: '0x0000000000000000000000000000000000000000',
-        symbol: 'ETH',
-        decimals: 18,
-      } as BridgeToken;
+    expect(result.current).toBe(true);
+  });
 
-      mockIsNativeAddress.mockReturnValue(true);
-      mockUseTokenAddress.mockReturnValue(tokenWithoutChainId.address);
-      mockUseSelector.mockReturnValue(false); // stxEnabled = false, isGaslessSwapEnabled = false
+  it('returns false for native token when sendBundle is disabled', () => {
+    setSelectorValues({ stxEnabled: true });
+    mockUseTokenAddress.mockReturnValue(nativeToken.address);
+    mockIsNativeAddress.mockReturnValue(true);
+    mockUseIsSendBundleSupported.mockReturnValue(false);
 
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(tokenWithoutChainId, '100', false),
-      );
+    const { result } = renderHook(() =>
+      useShouldRenderMaxOption(nativeToken, '1.25'),
+    );
 
-      // Should return false (native + no gasless + no sponsored + no stx)
-      expect(result.current).toBe(false);
-    });
+    expect(result.current).toBe(false);
   });
 
-  describe('Hook parameter validation', () => {
-    it('uses useTokenAddress hook to get token address', () => {
-      const customToken = {
-        ...mockToken,
-        address: '0xabcdef1234567890abcdef1234567890abcdef12',
-      };
-      mockUseTokenAddress.mockReturnValue(customToken.address);
+  it('returns false for native token when stx is disabled even if sendBundle is enabled', () => {
+    setSelectorValues({ stxEnabled: false });
+    mockUseTokenAddress.mockReturnValue(nativeToken.address);
+    mockIsNativeAddress.mockReturnValue(true);
+    mockUseIsSendBundleSupported.mockReturnValue(true);
 
-      renderHook(() => useShouldRenderMaxOption(customToken, '100', false));
+    const { result } = renderHook(() =>
+      useShouldRenderMaxOption(nativeToken, '1.25'),
+    );
 
-      expect(mockUseTokenAddress).toHaveBeenCalledWith(customToken);
-    });
+    expect(result.current).toBe(false);
+  });
 
-    it('checks if token address is native using isNativeAddress', () => {
-      const tokenAddress = '0x1234567890123456789012345678901234567890';
-      mockUseTokenAddress.mockReturnValue(tokenAddress);
-      mockIsNativeAddress.mockReturnValue(false);
+  it('returns true for sponsored native quote when stx is enabled', () => {
+    setSelectorValues({ stxEnabled: true });
+    mockUseTokenAddress.mockReturnValue(nativeToken.address);
+    mockIsNativeAddress.mockReturnValue(true);
+    mockUseIsSendBundleSupported.mockReturnValue(false);
 
-      renderHook(() => useShouldRenderMaxOption(mockToken, '100', false));
+    const { result } = renderHook(() =>
+      useShouldRenderMaxOption(nativeToken, '1.25', true),
+    );
 
-      expect(mockIsNativeAddress).toHaveBeenCalledWith(tokenAddress);
-    });
+    expect(result.current).toBe(true);
+  });
 
-    it('calls selectIsGaslessSwapEnabled with correct chainId', () => {
-      const tokenWithChainId = {
-        ...mockToken,
-        chainId: '0xa' as `0x${string}`, // Optimism
-      };
-      mockUseSelector.mockReturnValue(true);
+  it('returns false for sponsored native quote when stx is disabled', () => {
+    setSelectorValues({ stxEnabled: false });
+    mockUseTokenAddress.mockReturnValue(nativeToken.address);
+    mockIsNativeAddress.mockReturnValue(true);
 
-      renderHook(() =>
-        useShouldRenderMaxOption(tokenWithChainId, '100', false),
-      );
+    const { result } = renderHook(() =>
+      useShouldRenderMaxOption(nativeToken, '1.25', true),
+    );
 
-      // Verify useSelector was called (it uses selectIsGaslessSwapEnabled)
-      expect(mockUseSelector).toHaveBeenCalled();
-    });
+    expect(result.current).toBe(false);
   });
 
-  describe('Default parameter values', () => {
-    it('uses false as default for isQuoteSponsored when not provided', () => {
-      mockIsNativeAddress.mockReturnValue(true);
-      mockUseTokenAddress.mockReturnValue(nativeToken.address);
-      let callCount = 0;
-      mockUseSelector.mockImplementation(() => {
-        callCount++;
-        // First call: isGaslessSwapEnabled = false
-        // Second call: stxEnabled = true
-        return callCount === 2;
-      });
-
-      // Call without isQuoteSponsored parameter
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(nativeToken, '100'),
-      );
-
-      // Should return false (native + stx=true + gasless=false + sponsored=false)
-      expect(result.current).toBe(false);
-    });
-  });
+  it('passes formatted EVM chain id to sendBundle hook', () => {
+    const chainId = '0xa' as `0x${string}`;
+    const formattedChainId = '0xa' as `0x${string}`;
+    const token = { ...nativeToken, chainId };
+    mockUseTokenAddress.mockReturnValue(token.address);
+    mockIsNativeAddress.mockReturnValue(true);
+    mockFormatChainIdToHex.mockReturnValue(formattedChainId);
 
-  describe('Integration scenarios', () => {
-    it('returns correct value for typical non-native ERC20 token', () => {
-      const usdcToken: BridgeToken = {
-        address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-        symbol: 'USDC',
-        decimals: 6,
-        chainId: CHAIN_IDS.MAINNET,
-      };
-
-      mockIsNativeAddress.mockReturnValue(false);
-      mockUseTokenAddress.mockReturnValue(usdcToken.address);
-      mockUseSelector.mockReturnValue(false); // Everything disabled
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(usdcToken, '1000', false),
-      );
-
-      // Non-native tokens always show max (even with everything disabled)
-      expect(result.current).toBe(true);
-    });
-
-    it('returns correct value for native ETH with gasless swap enabled', () => {
-      mockIsNativeAddress.mockReturnValue(true);
-      mockUseTokenAddress.mockReturnValue(nativeToken.address);
-      mockUseSelector.mockReturnValue(true); // stxEnabled=true, gasless=true
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(nativeToken, '5.5', false),
-      );
-
-      expect(result.current).toBe(true);
-    });
-
-    it('returns correct value for native ETH with sponsored quote', () => {
-      mockIsNativeAddress.mockReturnValue(true);
-      mockUseTokenAddress.mockReturnValue(nativeToken.address);
-      let callCount = 0;
-      mockUseSelector.mockImplementation(() => {
-        callCount++;
-        // First call: isGaslessSwapEnabled = false
-        // Second call: stxEnabled = true
-        return callCount === 2;
-      });
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(nativeToken, '2.25', true),
-      );
-
-      expect(result.current).toBe(true);
-    });
-
-    it('returns correct value for native ETH without gasless or sponsored but stx enabled', () => {
-      mockIsNativeAddress.mockReturnValue(true);
-      mockUseTokenAddress.mockReturnValue(nativeToken.address);
-      let callCount = 0;
-      mockUseSelector.mockImplementation(() => {
-        callCount++;
-        // First call: isGaslessSwapEnabled = false
-        // Second call: stxEnabled = true
-        return callCount === 2;
-      });
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(nativeToken, '10', false),
-      );
-
-      // Should be false (native + stx=true + gasless=false + sponsored=false)
-      expect(result.current).toBe(false);
-    });
-  });
+    renderHook(() => useShouldRenderMaxOption(token, '1.25'));
 
-  describe('Boundary conditions', () => {
-    it('handles balance exactly equal to zero', () => {
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '0.00000', false),
-      );
-
-      expect(result.current).toBe(false);
-    });
-
-    it('handles extremely small but non-zero balance', () => {
-      mockIsNativeAddress.mockReturnValue(false);
-      mockUseTokenAddress.mockReturnValue(mockToken.address);
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(mockToken, '0.00000001', false),
-      );
-
-      expect(result.current).toBe(true);
-    });
-
-    it('handles extremely large balance', () => {
-      mockIsNativeAddress.mockReturnValue(false);
-      mockUseTokenAddress.mockReturnValue(mockToken.address);
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(
-          mockToken,
-          '999999999999999999999999999.999999',
-          false,
-        ),
-      );
-
-      expect(result.current).toBe(true);
-    });
-
-    it('handles balance with many decimal places', () => {
-      mockIsNativeAddress.mockReturnValue(false);
-      mockUseTokenAddress.mockReturnValue(mockToken.address);
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(
-          mockToken,
-          '123.456789012345678901234567',
-          false,
-        ),
-      );
-
-      expect(result.current).toBe(true);
-    });
+    expect(mockUseIsSendBundleSupported).toHaveBeenCalledWith(formattedChainId);
   });
 
-  describe('Truth table - Native token with all combinations', () => {
-    beforeEach(() => {
-      mockIsNativeAddress.mockReturnValue(true);
-      mockUseTokenAddress.mockReturnValue(nativeToken.address);
-    });
-
-    const truthTable = [
-      { stxEnabled: true, gasless: true, sponsored: false, expected: true },
-      { stxEnabled: true, gasless: false, sponsored: true, expected: true },
-      { stxEnabled: true, gasless: true, sponsored: true, expected: true },
-      { stxEnabled: true, gasless: false, sponsored: false, expected: false },
-      { stxEnabled: false, gasless: true, sponsored: false, expected: false },
-      { stxEnabled: false, gasless: false, sponsored: true, expected: false },
-      { stxEnabled: false, gasless: true, sponsored: true, expected: false },
-      { stxEnabled: false, gasless: false, sponsored: false, expected: false },
-    ];
-
-    truthTable.forEach(({ stxEnabled, gasless, sponsored, expected }) => {
-      it(`stxEnabled=${stxEnabled}, gasless=${gasless}, sponsored=${sponsored} → returns ${expected}`, () => {
-        let callCount = 0;
-        mockUseSelector.mockImplementation(() => {
-          callCount++;
-          // First call: isGaslessSwapEnabled (line 12 in hook)
-          // Second call: stxEnabled (line 15 in hook)
-          if (callCount === 1) {
-            return gasless;
-          }
-          return stxEnabled;
-        });
-
-        const { result } = renderHook(() =>
-          useShouldRenderMaxOption(nativeToken, '100', sponsored),
-        );
-
-        expect(result.current).toBe(expected);
-      });
-    });
-  });
-
-  describe('Non-EVM native token scenarios', () => {
+  it('passes undefined chain id to sendBundle hook for non-EVM token', () => {
     const solanaToken: BridgeToken = {
-      address: '0x0000000000000000000000000000000000000000',
-      symbol: 'SOL',
-      decimals: 9,
-      chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp', // Solana mainnet CAIP-2
+      ...nativeToken,
+      chainId:
+        'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp' as `${string}:${string}`,
     };
+    mockUseTokenAddress.mockReturnValue(solanaToken.address);
+    mockIsNativeAddress.mockReturnValue(true);
+    mockIsNonEvmChainId.mockReturnValue(true);
+    setSelectorValues({ stxEnabled: false });
 
-    const bitcoinToken: BridgeToken = {
-      address: '0x0000000000000000000000000000000000000000',
-      symbol: 'BTC',
-      decimals: 8,
-      chainId: 'bip122:000000000019d6689c085ae165831e93', // Bitcoin mainnet CAIP-2
-    };
+    const { result } = renderHook(() =>
+      useShouldRenderMaxOption(solanaToken, '3'),
+    );
 
-    beforeEach(() => {
-      mockIsNativeAddress.mockReturnValue(true);
-    });
-
-    it('returns false for Solana native token even with gasless enabled', () => {
-      mockUseTokenAddress.mockReturnValue(solanaToken.address);
-      let callCount = 0;
-      mockUseSelector.mockImplementation(() => {
-        callCount++;
-        // First call: isGaslessSwapEnabled = true
-        // Second call: stxEnabled = false (non-EVM chain)
-        if (callCount === 1) {
-          return true; // gasless enabled
-        }
-        return false; // stxEnabled is false for non-EVM
-      });
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(solanaToken, '100', false),
-      );
-
-      // Should return false because stxEnabled is false for non-EVM chains
-      expect(result.current).toBe(false);
-    });
-
-    it('returns false for Solana native token even with sponsored quote', () => {
-      mockUseTokenAddress.mockReturnValue(solanaToken.address);
-      mockUseSelector.mockImplementation(
-        () =>
-          // First call: isGaslessSwapEnabled = false
-          // Second call: stxEnabled = false (non-EVM chain)
-          false,
-      );
-
-      const { result } = renderHook(
-        () => useShouldRenderMaxOption(solanaToken, '50', true), // sponsored = true
-      );
-
-      // Should return false because stxEnabled is false for non-EVM chains
-      expect(result.current).toBe(false);
-    });
-
-    it('returns false for Solana native token with both gasless and sponsored enabled', () => {
-      mockUseTokenAddress.mockReturnValue(solanaToken.address);
-      let callCount = 0;
-      mockUseSelector.mockImplementation(() => {
-        callCount++;
-        // First call: isGaslessSwapEnabled = true
-        // Second call: stxEnabled = false (non-EVM chain)
-        if (callCount === 1) {
-          return true; // gasless enabled
-        }
-        return false; // stxEnabled is false for non-EVM
-      });
-
-      const { result } = renderHook(
-        () => useShouldRenderMaxOption(solanaToken, '25.5', true), // sponsored = true
-      );
-
-      // Should return false because stxEnabled is false for non-EVM chains
-      expect(result.current).toBe(false);
-    });
-
-    it('returns false for Bitcoin native token with gasless enabled', () => {
-      mockUseTokenAddress.mockReturnValue(bitcoinToken.address);
-      let callCount = 0;
-      mockUseSelector.mockImplementation(() => {
-        callCount++;
-        // First call: isGaslessSwapEnabled = true
-        // Second call: stxEnabled = false (non-EVM chain)
-        if (callCount === 1) {
-          return true; // gasless enabled
-        }
-        return false; // stxEnabled is false for non-EVM
-      });
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(bitcoinToken, '1.5', false),
-      );
-
-      // Should return false because stxEnabled is false for non-EVM chains
-      expect(result.current).toBe(false);
-    });
-
-    it('returns false for Bitcoin native token without any flags enabled', () => {
-      mockUseTokenAddress.mockReturnValue(bitcoinToken.address);
-      mockUseSelector.mockReturnValue(false); // All flags disabled
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(bitcoinToken, '0.5', false),
-      );
-
-      // Should return false because stxEnabled is false for non-EVM chains
-      expect(result.current).toBe(false);
-    });
-
-    it('returns false for non-EVM native token with zero balance', () => {
-      mockUseTokenAddress.mockReturnValue(solanaToken.address);
-      mockUseSelector.mockReturnValue(false);
-
-      const { result } = renderHook(() =>
-        useShouldRenderMaxOption(solanaToken, '0', false),
-      );
-
-      // Should return false due to zero balance (checked before non-EVM logic)
-      expect(result.current).toBe(false);
-    });
+    expect(mockUseIsSendBundleSupported).toHaveBeenCalledWith(undefined);
+    expect(result.current).toBe(false);
   });
 });
diff --git a/app/components/UI/Earn/hooks/useMusdCtaVisibility.test.ts b/app/components/UI/Earn/hooks/useMusdCtaVisibility.test.ts
index 68c0e577231a..445ae7ec8891 100644
--- a/app/components/UI/Earn/hooks/useMusdCtaVisibility.test.ts
+++ b/app/components/UI/Earn/hooks/useMusdCtaVisibility.test.ts
@@ -11,6 +11,8 @@ import { useMusdConversionEligibility } from './useMusdConversionEligibility';
 import { useCurrentNetworkInfo } from '../../../hooks/useCurrentNetworkInfo';
 import { useNetworksByCustomNamespace } from '../../../hooks/useNetworksByNamespace/useNetworksByNamespace';
 import { useRampTokens, RampsToken } from '../../Ramp/hooks/useRampTokens';
+import useRampsTokens from '../../Ramp/hooks/useRampsTokens';
+import useRampsUnifiedV2Enabled from '../../Ramp/hooks/useRampsUnifiedV2Enabled';
 import { MUSD_TOKEN_ASSET_ID_BY_CHAIN } from '../constants/musd';
 import { createMockToken } from '../../Stake/testUtils';
 import {
@@ -31,6 +33,8 @@ jest.mock('./useMusdConversionEligibility');
 jest.mock('../../../hooks/useCurrentNetworkInfo');
 jest.mock('../../../hooks/useNetworksByNamespace/useNetworksByNamespace');
 jest.mock('../../Ramp/hooks/useRampTokens');
+jest.mock('../../Ramp/hooks/useRampsTokens');
+jest.mock('../../Ramp/hooks/useRampsUnifiedV2Enabled');
 jest.mock('react-redux', () => ({
   ...jest.requireActual('react-redux'),
   useSelector: jest.fn(),
@@ -61,6 +65,13 @@ const mockUseNetworksByCustomNamespace =
 const mockUseRampTokens = useRampTokens as jest.MockedFunction<
   typeof useRampTokens
 >;
+const mockUseRampsTokens = useRampsTokens as jest.MockedFunction<
+  typeof useRampsTokens
+>;
+const mockUseRampsUnifiedV2Enabled =
+  useRampsUnifiedV2Enabled as jest.MockedFunction<
+    typeof useRampsUnifiedV2Enabled
+  >;
 const mockUseMusdConversionTokens =
   useMusdConversionTokens as jest.MockedFunction<
     typeof useMusdConversionTokens
@@ -195,6 +206,14 @@ describe('useMusdCtaVisibility', () => {
     mockUseNetworksByCustomNamespace.mockReturnValue(
       defaultNetworksByNamespace,
     );
+    mockUseRampsUnifiedV2Enabled.mockReturnValue(false);
+    mockUseRampsTokens.mockReturnValue({
+      tokens: null,
+      selectedToken: null,
+      setSelectedToken: jest.fn(),
+      isLoading: false,
+      error: null,
+    });
     mockUseRampTokens.mockReturnValue(defaultRampTokens);
     mockUseMusdConversionTokens.mockReturnValue({
       tokens: [],
diff --git a/app/components/UI/Earn/hooks/useMusdRampAvailability.test.ts b/app/components/UI/Earn/hooks/useMusdRampAvailability.test.ts
index 27641a1dfe20..a0ad78b53c6d 100644
--- a/app/components/UI/Earn/hooks/useMusdRampAvailability.test.ts
+++ b/app/components/UI/Earn/hooks/useMusdRampAvailability.test.ts
@@ -2,233 +2,174 @@ import { renderHook } from '@testing-library/react-hooks';
 import { CHAIN_IDS } from '@metamask/transaction-controller';
 import { Hex } from '@metamask/utils';
 import { useMusdRampAvailability } from './useMusdRampAvailability';
-import { useRampTokens, RampsToken } from '../../Ramp/hooks/useRampTokens';
-import { MUSD_TOKEN_ASSET_ID_BY_CHAIN } from '../constants/musd';
-
-jest.mock('../../Ramp/hooks/useRampTokens');
+import {
+  MUSD_BUYABLE_CHAIN_IDS,
+  MUSD_TOKEN,
+  MUSD_TOKEN_ADDRESS_BY_CHAIN,
+} from '../constants/musd';
+import {
+  getTokenBuyabilityKey,
+  useTokensBuyability,
+} from '../../Ramp/hooks/useTokenBuyability';
+import { TokenI } from '../../Tokens/types';
+
+jest.mock('../../Ramp/hooks/useTokenBuyability', () => {
+  const actual = jest.requireActual('../../Ramp/hooks/useTokenBuyability');
+  return {
+    ...actual,
+    useTokensBuyability: jest.fn(),
+  };
+});
 
-const mockUseRampTokens = useRampTokens as jest.MockedFunction<
-  typeof useRampTokens
+const mockUseTokensBuyability = useTokensBuyability as jest.MockedFunction<
+  typeof useTokensBuyability
 >;
 
 describe('useMusdRampAvailability', () => {
-  const createMusdRampToken = (
-    chainId: Hex,
-    tokenSupported = true,
-  ): RampsToken => {
-    const assetId = MUSD_TOKEN_ASSET_ID_BY_CHAIN[chainId].toLowerCase();
-    const caipChainId = assetId.split('/')[0] as `${string}:${string}`;
-    return {
-      assetId: assetId as `${string}:${string}/${string}:${string}`,
-      symbol: 'MUSD',
-      chainId: caipChainId,
-      tokenSupported,
-      name: 'MetaMask USD',
-      decimals: 6,
-      iconUrl: 'https://example.com/musd.png',
-    };
-  };
+  const getMusdToken = (chainId: Hex): TokenI => ({
+    address: MUSD_TOKEN_ADDRESS_BY_CHAIN[chainId],
+    chainId,
+    symbol: MUSD_TOKEN.symbol,
+    name: MUSD_TOKEN.name,
+    decimals: MUSD_TOKEN.decimals,
+    image: '',
+    logo: undefined,
+    balance: '0',
+    isETH: false,
+    isNative: false,
+  });
 
-  const defaultRampTokens = {
-    topTokens: null,
-    allTokens: [
-      createMusdRampToken(CHAIN_IDS.MAINNET as Hex),
-      createMusdRampToken(CHAIN_IDS.LINEA_MAINNET as Hex),
-    ],
-    isLoading: false,
-    error: null,
+  const MAINNET_MUSD_KEY = getTokenBuyabilityKey(
+    getMusdToken(CHAIN_IDS.MAINNET as Hex),
+  );
+  const LINEA_MUSD_KEY = getTokenBuyabilityKey(
+    getMusdToken(CHAIN_IDS.LINEA_MAINNET as Hex),
+  );
+
+  const setBuyability = (
+    buyabilityByTokenKey: Record<string, boolean> = {},
+  ) => {
+    mockUseTokensBuyability.mockReturnValue({
+      buyabilityByTokenKey,
+      isLoading: false,
+    });
   };
 
   beforeEach(() => {
     jest.clearAllMocks();
-    mockUseRampTokens.mockReturnValue(defaultRampTokens);
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
+    setBuyability({
+      [MAINNET_MUSD_KEY]: true,
+      [LINEA_MUSD_KEY]: true,
+    });
   });
 
-  describe('hook structure', () => {
-    it('returns object with all required properties', () => {
-      const { result } = renderHook(() => useMusdRampAvailability());
-
-      expect(result.current).toHaveProperty('isMusdBuyableOnChain');
-      expect(result.current).toHaveProperty('isMusdBuyableOnAnyChain');
-      expect(result.current).toHaveProperty('getIsMusdBuyable');
-    });
+  it('returns false for all mUSD buyable chains when no tokens are buyable', () => {
+    setBuyability({});
 
-    it('returns getIsMusdBuyable as a function', () => {
-      const { result } = renderHook(() => useMusdRampAvailability());
+    const { result } = renderHook(() => useMusdRampAvailability());
 
-      expect(typeof result.current.getIsMusdBuyable).toBe('function');
+    MUSD_BUYABLE_CHAIN_IDS.forEach((chainId) => {
+      expect(result.current.isMusdBuyableOnChain[chainId]).toBe(false);
     });
+    expect(result.current.isMusdBuyableOnAnyChain).toBe(false);
   });
 
-  describe('isMusdBuyableOnChain', () => {
-    it('returns empty object when allTokens is null', () => {
-      mockUseRampTokens.mockReturnValue({
-        ...defaultRampTokens,
-        allTokens: null,
-      });
+  it('marks remaining chains as not buyable when buyability results are missing', () => {
+    setBuyability({ [MAINNET_MUSD_KEY]: true });
 
-      const { result } = renderHook(() => useMusdRampAvailability());
+    const { result } = renderHook(() => useMusdRampAvailability());
 
-      expect(result.current.isMusdBuyableOnChain).toEqual({});
-    });
+    expect(result.current.isMusdBuyableOnChain[CHAIN_IDS.MAINNET]).toBe(true);
+    expect(result.current.isMusdBuyableOnChain[CHAIN_IDS.LINEA_MAINNET]).toBe(
+      false,
+    );
+  });
 
-    it('returns buyability status for each chain', () => {
-      mockUseRampTokens.mockReturnValue({
-        ...defaultRampTokens,
-        allTokens: [
-          createMusdRampToken(CHAIN_IDS.MAINNET as Hex, true),
-          createMusdRampToken(CHAIN_IDS.LINEA_MAINNET as Hex, false),
-        ],
-      });
-
-      const { result } = renderHook(() => useMusdRampAvailability());
-
-      expect(result.current.isMusdBuyableOnChain[CHAIN_IDS.MAINNET]).toBe(true);
-      expect(result.current.isMusdBuyableOnChain[CHAIN_IDS.LINEA_MAINNET]).toBe(
-        false,
-      );
+  it('returns true when at least one chain has buyable mUSD', () => {
+    setBuyability({
+      [MAINNET_MUSD_KEY]: false,
+      [LINEA_MUSD_KEY]: true,
     });
 
-    it('returns false for chain when token not supported', () => {
-      mockUseRampTokens.mockReturnValue({
-        ...defaultRampTokens,
-        allTokens: [
-          createMusdRampToken(CHAIN_IDS.MAINNET as Hex, false),
-          createMusdRampToken(CHAIN_IDS.LINEA_MAINNET as Hex, false),
-        ],
-      });
-
-      const { result } = renderHook(() => useMusdRampAvailability());
-
-      expect(result.current.isMusdBuyableOnChain[CHAIN_IDS.MAINNET]).toBe(
-        false,
-      );
-      expect(result.current.isMusdBuyableOnChain[CHAIN_IDS.LINEA_MAINNET]).toBe(
-        false,
-      );
-    });
-  });
+    const { result } = renderHook(() => useMusdRampAvailability());
 
-  describe('isMusdBuyableOnAnyChain', () => {
-    it('returns true when at least one chain has buyable mUSD', () => {
-      mockUseRampTokens.mockReturnValue({
-        ...defaultRampTokens,
-        allTokens: [
-          createMusdRampToken(CHAIN_IDS.MAINNET as Hex, false),
-          createMusdRampToken(CHAIN_IDS.LINEA_MAINNET as Hex, true),
-        ],
-      });
-
-      const { result } = renderHook(() => useMusdRampAvailability());
+    expect(result.current.isMusdBuyableOnAnyChain).toBe(true);
+  });
 
-      expect(result.current.isMusdBuyableOnAnyChain).toBe(true);
+  it('returns chain-specific buyability when a single chain is selected', () => {
+    setBuyability({
+      [MAINNET_MUSD_KEY]: true,
+      [LINEA_MUSD_KEY]: false,
     });
 
-    it('returns false when no chains have buyable mUSD', () => {
-      mockUseRampTokens.mockReturnValue({
-        ...defaultRampTokens,
-        allTokens: [
-          createMusdRampToken(CHAIN_IDS.MAINNET as Hex, false),
-          createMusdRampToken(CHAIN_IDS.LINEA_MAINNET as Hex, false),
-        ],
-      });
+    const { result } = renderHook(() => useMusdRampAvailability());
 
-      const { result } = renderHook(() => useMusdRampAvailability());
+    const isMusdBuyable = result.current.getIsMusdBuyable(
+      CHAIN_IDS.MAINNET as Hex,
+      false,
+    );
+
+    expect(isMusdBuyable).toBe(true);
+  });
 
-      expect(result.current.isMusdBuyableOnAnyChain).toBe(false);
+  it('returns false when selected chain is not buyable', () => {
+    setBuyability({
+      [MAINNET_MUSD_KEY]: true,
+      [LINEA_MUSD_KEY]: false,
     });
 
-    it('returns false when allTokens is empty', () => {
-      mockUseRampTokens.mockReturnValue({
-        ...defaultRampTokens,
-        allTokens: [],
-      });
+    const { result } = renderHook(() => useMusdRampAvailability());
 
-      const { result } = renderHook(() => useMusdRampAvailability());
+    const isMusdBuyable = result.current.getIsMusdBuyable(
+      CHAIN_IDS.LINEA_MAINNET as Hex,
+      false,
+    );
 
-      expect(result.current.isMusdBuyableOnAnyChain).toBe(false);
-    });
+    expect(isMusdBuyable).toBe(false);
   });
 
-  describe('getIsMusdBuyable', () => {
-    it('returns isMusdBuyableOnAnyChain when popular networks filter is active', () => {
-      mockUseRampTokens.mockReturnValue({
-        ...defaultRampTokens,
-        allTokens: [
-          createMusdRampToken(CHAIN_IDS.MAINNET as Hex, false),
-          createMusdRampToken(CHAIN_IDS.LINEA_MAINNET as Hex, true),
-        ],
-      });
+  it('returns false when no chain is selected and popular networks filter is inactive', () => {
+    setBuyability({
+      [MAINNET_MUSD_KEY]: true,
+      [LINEA_MUSD_KEY]: true,
+    });
 
-      const { result } = renderHook(() => useMusdRampAvailability());
-      const isMusdBuyable = result.current.getIsMusdBuyable(null, true);
+    const { result } = renderHook(() => useMusdRampAvailability());
 
-      expect(isMusdBuyable).toBe(true);
-    });
+    const isMusdBuyable = result.current.getIsMusdBuyable(null, false);
 
-    it('returns chain-specific buyability when single chain selected', () => {
-      mockUseRampTokens.mockReturnValue({
-        ...defaultRampTokens,
-        allTokens: [
-          createMusdRampToken(CHAIN_IDS.MAINNET as Hex, true),
-          createMusdRampToken(CHAIN_IDS.LINEA_MAINNET as Hex, false),
-        ],
-      });
-
-      const { result } = renderHook(() => useMusdRampAvailability());
-      const isMusdBuyable = result.current.getIsMusdBuyable(
-        CHAIN_IDS.MAINNET as Hex,
-        false,
-      );
-
-      expect(isMusdBuyable).toBe(true);
-    });
+    expect(isMusdBuyable).toBe(false);
+  });
 
-    it('returns false when selected chain not buyable', () => {
-      mockUseRampTokens.mockReturnValue({
-        ...defaultRampTokens,
-        allTokens: [
-          createMusdRampToken(CHAIN_IDS.MAINNET as Hex, true),
-          createMusdRampToken(CHAIN_IDS.LINEA_MAINNET as Hex, false),
-        ],
-      });
-
-      const { result } = renderHook(() => useMusdRampAvailability());
-      const isMusdBuyable = result.current.getIsMusdBuyable(
-        CHAIN_IDS.LINEA_MAINNET as Hex,
-        false,
-      );
-
-      expect(isMusdBuyable).toBe(false);
+  it('returns false for an unknown chain ID', () => {
+    setBuyability({
+      [MAINNET_MUSD_KEY]: true,
+      [LINEA_MUSD_KEY]: true,
     });
 
-    it('returns false when no chain selected and popular networks filter is inactive', () => {
-      const { result } = renderHook(() => useMusdRampAvailability());
-      const isMusdBuyable = result.current.getIsMusdBuyable(null, false);
+    const { result } = renderHook(() => useMusdRampAvailability());
 
-      expect(isMusdBuyable).toBe(false);
-    });
+    const isMusdBuyable = result.current.getIsMusdBuyable(
+      '0x999' as Hex,
+      false,
+    );
 
-    it('returns false for unknown chain ID', () => {
-      const { result } = renderHook(() => useMusdRampAvailability());
-      const isMusdBuyable = result.current.getIsMusdBuyable(
-        '0x999' as Hex,
-        false,
-      );
+    expect(isMusdBuyable).toBe(false);
+  });
 
-      expect(isMusdBuyable).toBe(false);
+  it('uses aggregate buyability when popular networks filter is active even with selected chain', () => {
+    setBuyability({
+      [MAINNET_MUSD_KEY]: false,
+      [LINEA_MUSD_KEY]: true,
     });
-  });
 
-  describe('integration with useRampTokens', () => {
-    it('calls useRampTokens hook', () => {
-      renderHook(() => useMusdRampAvailability());
+    const { result } = renderHook(() => useMusdRampAvailability());
 
-      expect(mockUseRampTokens).toHaveBeenCalled();
-    });
+    const isMusdBuyable = result.current.getIsMusdBuyable(
+      CHAIN_IDS.MAINNET as Hex,
+      true,
+    );
+
+    expect(isMusdBuyable).toBe(true);
   });
 });
diff --git a/app/components/UI/Earn/hooks/useMusdRampAvailability.ts b/app/components/UI/Earn/hooks/useMusdRampAvailability.ts
index 2eeb16eebe8b..93bca09ad050 100644
--- a/app/components/UI/Earn/hooks/useMusdRampAvailability.ts
+++ b/app/components/UI/Earn/hooks/useMusdRampAvailability.ts
@@ -1,11 +1,15 @@
 import { useCallback, useMemo } from 'react';
 import { Hex } from '@metamask/utils';
 import {
+  MUSD_TOKEN,
+  MUSD_TOKEN_ADDRESS_BY_CHAIN,
   MUSD_BUYABLE_CHAIN_IDS,
-  MUSD_TOKEN_ASSET_ID_BY_CHAIN,
 } from '../constants/musd';
-import { useRampTokens } from '../../Ramp/hooks/useRampTokens';
-import { toLowerCaseEquals } from '../../../../util/general';
+import { TokenI } from '../../Tokens/types';
+import {
+  getTokenBuyabilityKey,
+  useTokensBuyability,
+} from '../../Ramp/hooks/useTokenBuyability';
 
 export interface MusdRampAvailability {
   isMusdBuyableOnChain: Record<Hex, boolean>;
@@ -26,34 +30,56 @@ export interface MusdRampAvailability {
  * @returns {MusdRampAvailability} Ramp availability state and helpers
  */
 export const useMusdRampAvailability = (): MusdRampAvailability => {
-  const { allTokens } = useRampTokens();
+  const musdTokensByChain = useMemo(
+    () =>
+      MUSD_BUYABLE_CHAIN_IDS.map((chainId) => {
+        const address = MUSD_TOKEN_ADDRESS_BY_CHAIN[chainId];
+        if (!address) {
+          return null;
+        }
+
+        const token: TokenI = {
+          address,
+          chainId,
+          symbol: MUSD_TOKEN.symbol,
+          name: MUSD_TOKEN.name,
+          decimals: MUSD_TOKEN.decimals,
+          image: '',
+          logo: undefined,
+          balance: '0',
+          isETH: false,
+          isNative: false,
+        };
+        return token;
+      }),
+    [],
+  );
+
+  const musdTokens = useMemo(
+    () => musdTokensByChain.filter((token): token is TokenI => token !== null),
+    [musdTokensByChain],
+  );
+
+  const { buyabilityByTokenKey } = useTokensBuyability(musdTokens);
 
   // Check if mUSD is buyable on a specific chain based on ramp availability
   const isMusdBuyableOnChain = useMemo(() => {
-    if (!allTokens) {
-      return {};
-    }
-
     const buyableByChain: Record<Hex, boolean> = {};
-
     MUSD_BUYABLE_CHAIN_IDS.forEach((chainId) => {
-      const musdAssetId = MUSD_TOKEN_ASSET_ID_BY_CHAIN[chainId];
-      if (!musdAssetId) {
-        buyableByChain[chainId] = false;
-        return;
-      }
-
-      const musdToken = allTokens.find(
-        (token) =>
-          toLowerCaseEquals(token.assetId, musdAssetId) &&
-          token.tokenSupported === true,
-      );
+      buyableByChain[chainId] = false;
+    });
 
-      buyableByChain[chainId] = Boolean(musdToken);
+    musdTokens.forEach((token) => {
+      if (token.chainId) {
+        const tokenKey = getTokenBuyabilityKey(token);
+        buyableByChain[token.chainId as Hex] = Boolean(
+          buyabilityByTokenKey[tokenKey],
+        );
+      }
     });
 
     return buyableByChain;
-  }, [allTokens]);
+  }, [buyabilityByTokenKey, musdTokens]);
 
   // Check if mUSD is buyable on any chain (for "all networks" view)
   const isMusdBuyableOnAnyChain = useMemo(
diff --git a/app/components/UI/Perps/__mocks__/serviceMocks.ts b/app/components/UI/Perps/__mocks__/serviceMocks.ts
index 1117c9af2134..093f484227e6 100644
--- a/app/components/UI/Perps/__mocks__/serviceMocks.ts
+++ b/app/components/UI/Perps/__mocks__/serviceMocks.ts
@@ -11,6 +11,23 @@ import {
   type PerpsPlatformDependencies,
 } from '@metamask/perps-controller';
 
+/**
+ * Create a mock EVM account (KeyringAccount)
+ */
+export const createMockEvmAccount = () => ({
+  id: '00000000-0000-0000-0000-000000000000',
+  address: '0x1234567890abcdef1234567890abcdef12345678' as `0x${string}`,
+  type: 'eip155:eoa' as const,
+  options: {},
+  scopes: ['eip155:1'],
+  methods: ['eth_signTransaction', 'eth_sign'],
+  metadata: {
+    name: 'Test Account',
+    importTime: Date.now(),
+    keyring: { type: 'HD Key Tree' },
+  },
+});
+
 /**
  * Create a mock PerpsPlatformDependencies instance.
  * Returns a type-safe mock with jest.Mock functions for all methods.
@@ -53,11 +70,6 @@ export const createMockInfrastructure =
         clearAllChannels: jest.fn(),
       },
 
-      // === Rewards (no standard messenger action in core) ===
-      rewards: {
-        getFeeDiscount: jest.fn().mockResolvedValue(0),
-      },
-
       // === Feature Flags (platform-specific version gating) ===
       featureFlags: {
         validateVersionGated: jest.fn().mockReturnValue(undefined),
@@ -76,6 +88,11 @@ export const createMockInfrastructure =
         invalidate: jest.fn(),
         invalidateAll: jest.fn(),
       },
+
+      // === Rewards (DI — no RewardsController in Core yet) ===
+      rewards: {
+        getPerpsDiscountForAccount: jest.fn().mockResolvedValue(0),
+      },
     }) as unknown as jest.Mocked<PerpsPlatformDependencies>;
 
 /**
@@ -161,23 +178,6 @@ export const createMockServiceContext = (
   ...overrides,
 });
 
-/**
- * Create a mock EVM account (KeyringAccount)
- */
-export const createMockEvmAccount = () => ({
-  id: '00000000-0000-0000-0000-000000000000',
-  address: '0x1234567890abcdef1234567890abcdef12345678' as `0x${string}`,
-  type: 'eip155:eoa' as const,
-  options: {},
-  scopes: ['eip155:1'],
-  methods: ['eth_signTransaction', 'eth_sign'],
-  metadata: {
-    name: 'Test Account',
-    importTime: Date.now(),
-    keyring: { type: 'HD Key Tree' },
-  },
-});
-
 /**
  * Create a mock PerpsControllerMessenger for testing inter-controller communication.
  * The messenger.call() method should be configured in each test to return appropriate values.
diff --git a/app/components/UI/Perps/adapters/mobileInfrastructure.test.ts b/app/components/UI/Perps/adapters/mobileInfrastructure.test.ts
index baad6cc4f596..eb70ccec4720 100644
--- a/app/components/UI/Perps/adapters/mobileInfrastructure.test.ts
+++ b/app/components/UI/Perps/adapters/mobileInfrastructure.test.ts
@@ -3,6 +3,7 @@ import { AnalyticsEventBuilder } from '../../../../util/analytics/AnalyticsEvent
 import { analytics } from '../../../../util/analytics/analytics';
 import type { PerpsAnalyticsEvent } from '@metamask/perps-controller';
 import { createMobileInfrastructure } from './mobileInfrastructure';
+import Engine from '../../../../core/Engine';
 
 jest.mock('../../../../util/analytics/analytics', () => ({
   analytics: {
@@ -55,7 +56,7 @@ jest.mock('../providers/PerpsStreamManager', () => ({
 jest.mock('../../../../core/Engine', () => ({
   context: {
     RewardsController: {
-      getPerpsDiscountForAccount: jest.fn(),
+      getPerpsDiscountForAccount: jest.fn().mockResolvedValue(5),
     },
   },
 }));
@@ -159,4 +160,20 @@ describe('createMobileInfrastructure', () => {
       });
     });
   });
+
+  describe('rewards', () => {
+    it('delegates getPerpsDiscountForAccount to RewardsController', async () => {
+      const infra = createMobileInfrastructure();
+      const caipAccountId =
+        'eip155:42161:0x1234' as `${string}:${string}:${string}`;
+
+      const result =
+        await infra.rewards.getPerpsDiscountForAccount(caipAccountId);
+
+      expect(
+        Engine.context.RewardsController.getPerpsDiscountForAccount,
+      ).toHaveBeenCalledWith(caipAccountId);
+      expect(result).toBe(5);
+    });
+  });
 });
diff --git a/app/components/UI/Perps/adapters/mobileInfrastructure.ts b/app/components/UI/Perps/adapters/mobileInfrastructure.ts
index 91e873d26126..2e51bee9e55c 100644
--- a/app/components/UI/Perps/adapters/mobileInfrastructure.ts
+++ b/app/components/UI/Perps/adapters/mobileInfrastructure.ts
@@ -216,14 +216,6 @@ export function createMobileInfrastructure(): PerpsPlatformDependencies {
     // === Platform Services ===
     streamManager: createStreamManagerAdapter(),
 
-    // === Rewards ===
-    rewards: {
-      getFeeDiscount: (caipAccountId: `${string}:${string}:${string}`) =>
-        Engine.context.RewardsController.getPerpsDiscountForAccount(
-          caipAccountId,
-        ),
-    },
-
     // === Feature Flags ===
     featureFlags: {
       validateVersionGated(flag: VersionGatedFeatureFlag): boolean | undefined {
@@ -236,6 +228,17 @@ export function createMobileInfrastructure(): PerpsPlatformDependencies {
 
     // === Cache Invalidation ===
     cacheInvalidator: createCacheInvalidatorAdapter(),
+
+    // === Rewards (DI — no RewardsController in Core yet) ===
+    rewards: {
+      getPerpsDiscountForAccount(
+        caipAccountId: `${string}:${string}:${string}`,
+      ) {
+        return Engine.context.RewardsController.getPerpsDiscountForAccount(
+          caipAccountId,
+        );
+      },
+    },
   };
 }
 
diff --git a/app/components/UI/Perps/utils/accountUtils.test.ts b/app/components/UI/Perps/utils/accountUtils.test.ts
index 060db48acc8d..f3bf3b73c6ea 100644
--- a/app/components/UI/Perps/utils/accountUtils.test.ts
+++ b/app/components/UI/Perps/utils/accountUtils.test.ts
@@ -8,7 +8,6 @@ import {
   getEvmAccountFromAccountGroup,
   getSelectedEvmAccount,
   calculateWeightedReturnOnEquity,
-  PerpsControllerMessenger,
 } from '@metamask/perps-controller';
 
 describe('accountUtils', () => {
@@ -242,7 +241,7 @@ describe('accountUtils', () => {
   });
 
   describe('getSelectedEvmAccount', () => {
-    it('returns EVM account when messenger returns accounts with EVM', () => {
+    it('returns EVM account when accounts array contains EVM account', () => {
       const mockAccounts = [
         {
           address: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdef',
@@ -259,27 +258,14 @@ describe('accountUtils', () => {
         },
       ] as unknown as InternalAccount[];
 
-      const mockMessenger = {
-        call: jest.fn().mockReturnValue(mockAccounts) as jest.MockedFunction<
-          (
-            action: 'AccountTreeController:getAccountsFromSelectedAccountGroup',
-          ) => InternalAccount[]
-        >,
-      };
-
-      const result = getSelectedEvmAccount(
-        mockMessenger as unknown as PerpsControllerMessenger,
-      );
-
-      expect(mockMessenger.call).toHaveBeenCalledWith(
-        'AccountTreeController:getAccountsFromSelectedAccountGroup',
-      );
+      const result = getSelectedEvmAccount(mockAccounts);
+
       expect(result).toEqual({
         address: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdef',
       });
     });
 
-    it('returns undefined when no EVM account in selected group', () => {
+    it('returns undefined when no EVM account in accounts array', () => {
       const mockAccounts = [
         {
           address: '0x1234567890123456789012345678901234567890',
@@ -296,33 +282,13 @@ describe('accountUtils', () => {
         },
       ] as unknown as InternalAccount[];
 
-      const mockMessenger = {
-        call: jest.fn().mockReturnValue(mockAccounts) as jest.MockedFunction<
-          (
-            action: 'AccountTreeController:getAccountsFromSelectedAccountGroup',
-          ) => InternalAccount[]
-        >,
-      };
-
-      const result = getSelectedEvmAccount(
-        mockMessenger as unknown as PerpsControllerMessenger,
-      );
+      const result = getSelectedEvmAccount(mockAccounts);
 
       expect(result).toBeUndefined();
     });
 
-    it('returns undefined when messenger returns empty accounts', () => {
-      const mockMessenger = {
-        call: jest.fn().mockReturnValue([]) as jest.MockedFunction<
-          (
-            action: 'AccountTreeController:getAccountsFromSelectedAccountGroup',
-          ) => InternalAccount[]
-        >,
-      };
-
-      const result = getSelectedEvmAccount(
-        mockMessenger as unknown as PerpsControllerMessenger,
-      );
+    it('returns undefined when accounts array is empty', () => {
+      const result = getSelectedEvmAccount([]);
 
       expect(result).toBeUndefined();
     });
diff --git a/app/components/UI/Perps/utils/rewardsUtils.test.ts b/app/components/UI/Perps/utils/rewardsUtils.test.ts
index 0697848fca3e..d490a5b46b60 100644
--- a/app/components/UI/Perps/utils/rewardsUtils.test.ts
+++ b/app/components/UI/Perps/utils/rewardsUtils.test.ts
@@ -8,11 +8,9 @@ import {
   handleRewardsError,
 } from '@metamask/perps-controller';
 import { toCaipAccountId, parseCaipChainId } from '@metamask/utils';
-import { formatChainIdToCaip } from '@metamask/bridge-controller';
 import { toChecksumHexAddress } from '@metamask/controller-utils';
 
 jest.mock('@metamask/utils');
-jest.mock('@metamask/bridge-controller');
 jest.mock('@metamask/controller-utils');
 
 const mockToCaipAccountId = toCaipAccountId as jest.MockedFunction<
@@ -21,9 +19,6 @@ const mockToCaipAccountId = toCaipAccountId as jest.MockedFunction<
 const mockParseCaipChainId = parseCaipChainId as jest.MockedFunction<
   typeof parseCaipChainId
 >;
-const mockFormatChainIdToCaip = formatChainIdToCaip as jest.MockedFunction<
-  typeof formatChainIdToCaip
->;
 const mockToChecksumHexAddress = toChecksumHexAddress as jest.MockedFunction<
   typeof toChecksumHexAddress
 >;
@@ -41,7 +36,6 @@ describe('rewardsUtils', () => {
       'eip155:42161:0x1234567890123456789012345678901234567890';
 
     beforeEach(() => {
-      mockFormatChainIdToCaip.mockReturnValue(mockCaipChainId);
       mockParseCaipChainId.mockReturnValue({
         namespace: 'eip155',
         reference: '42161',
@@ -57,7 +51,6 @@ describe('rewardsUtils', () => {
 
       // Assert
       expect(result).toBe(mockCaipAccountId);
-      expect(mockFormatChainIdToCaip).toHaveBeenCalledWith(mockChainId);
       expect(mockParseCaipChainId).toHaveBeenCalledWith(mockCaipChainId);
       expect(mockToCaipAccountId).toHaveBeenCalledWith(
         'eip155',
@@ -66,13 +59,7 @@ describe('rewardsUtils', () => {
       );
     });
 
-    it('returns null when formatChainIdToCaip throws', () => {
-      // Arrange
-      const error = new Error('Invalid chain ID format');
-      mockFormatChainIdToCaip.mockImplementation(() => {
-        throw error;
-      });
-
+    it('returns null when chain ID is invalid (NaN)', () => {
       // Act
       const result = formatAccountToCaipAccountId(mockAddress, 'invalid');
 
@@ -127,10 +114,8 @@ describe('rewardsUtils', () => {
       const checksummedAddress = '0x316BDE155acd07609872a56Bc32CcfB0B13201fA';
       const mixedCaseAddress = '0x316BdE155AcD07609872a56bC32CcFb0b13201Fa';
       const chainId = '1';
-      const caipChainId = 'eip155:1';
 
       beforeEach(() => {
-        mockFormatChainIdToCaip.mockReturnValue(caipChainId);
         mockParseCaipChainId.mockReturnValue({
           namespace: 'eip155',
           reference: '1',
@@ -238,9 +223,8 @@ describe('rewardsUtils', () => {
       const chainId = '1';
 
       beforeEach(() => {
-        mockFormatChainIdToCaip.mockReturnValue(
-          'bip122:000000000019d6689c085ae165831e93',
-        );
+        // parseCaipChainId receives 'eip155:1' from inlined formatChainIdToCaip,
+        // but we mock it to return a non-eip155 namespace to test the branch
         mockParseCaipChainId.mockReturnValue({
           namespace: 'bip122',
           reference: '000000000019d6689c085ae165831e93',
diff --git a/app/components/UI/Predict/constants/eventNames.ts b/app/components/UI/Predict/constants/eventNames.ts
index de26b01602cc..937ad44eea31 100644
--- a/app/components/UI/Predict/constants/eventNames.ts
+++ b/app/components/UI/Predict/constants/eventNames.ts
@@ -22,6 +22,7 @@ export const PredictEventProperties = {
   // Trade specific
   MARKET_TYPE: 'market_type',
   OUTCOME: 'outcome',
+  ORDER_TYPE: 'order_type',
 
   // Sensitive properties
   AMOUNT_USD: 'amount_usd',
diff --git a/app/components/UI/Predict/controllers/PredictController.test.ts b/app/components/UI/Predict/controllers/PredictController.test.ts
index 4996153bad32..630ce4b6ff79 100644
--- a/app/components/UI/Predict/controllers/PredictController.test.ts
+++ b/app/components/UI/Predict/controllers/PredictController.test.ts
@@ -5863,6 +5863,36 @@ describe('PredictController', () => {
       });
     });
 
+    it('includes orderType in analytics properties when provided', async () => {
+      await withController(async ({ controller }) => {
+        await controller.trackPredictOrderEvent({
+          status: 'submitted',
+          analyticsProperties: { marketId: 'test' },
+          orderType: 'FAK',
+        });
+
+        expect(analytics.trackEvent).toHaveBeenCalledWith(
+          expect.objectContaining({
+            properties: expect.objectContaining({
+              order_type: 'FAK',
+            }),
+          }),
+        );
+      });
+    });
+
+    it('omits orderType from analytics properties when not provided', async () => {
+      await withController(async ({ controller }) => {
+        await controller.trackPredictOrderEvent({
+          status: 'submitted',
+          analyticsProperties: { marketId: 'test' },
+        });
+
+        const eventArg = (analytics.trackEvent as jest.Mock).mock.calls[0][0];
+        expect(eventArg.properties).not.toHaveProperty('order_type');
+      });
+    });
+
     it('calls analytics.trackEvent for trackMarketDetailsOpened', () => {
       withController(({ controller }) => {
         controller.trackMarketDetailsOpened({
diff --git a/app/components/UI/Predict/controllers/PredictController.ts b/app/components/UI/Predict/controllers/PredictController.ts
index 58c75bef98f3..e11c74d78e11 100644
--- a/app/components/UI/Predict/controllers/PredictController.ts
+++ b/app/components/UI/Predict/controllers/PredictController.ts
@@ -79,6 +79,7 @@ import {
   PredictClaim,
   PredictClaimStatus,
   PredictMarket,
+  PredictOrderType,
   PredictPosition,
   PredictPositionStatus,
   PredictPriceHistoryPoint,
@@ -1046,6 +1047,7 @@ export class PredictController extends BaseController<
     failureReason,
     sharePrice,
     pnl,
+    orderType,
   }: {
     status: PredictTradeStatusValue;
     amountUsd?: number;
@@ -1054,6 +1056,7 @@ export class PredictController extends BaseController<
     failureReason?: string;
     sharePrice?: number;
     pnl?: number;
+    orderType?: PredictOrderType;
   }): Promise<void> {
     if (!analyticsProperties) {
       return;
@@ -1107,6 +1110,9 @@ export class PredictController extends BaseController<
       ...(analyticsProperties.gameClock && {
         [PredictEventProperties.GAME_CLOCK]: analyticsProperties.gameClock,
       }),
+      ...(orderType && {
+        [PredictEventProperties.ORDER_TYPE]: orderType,
+      }),
     };
 
     // Build sensitive properties
@@ -1436,6 +1442,7 @@ export class PredictController extends BaseController<
         amountUsd,
         analyticsProperties,
         sharePrice,
+        orderType: preview.orderType,
       });
 
       // Invalidate query cache (to avoid nonce issues)
@@ -1496,6 +1503,7 @@ export class PredictController extends BaseController<
         analyticsProperties,
         completionDuration,
         sharePrice: realSharePrice,
+        orderType: preview.orderType,
       });
 
       traceData = { success: true, side: preview.side };
@@ -1515,6 +1523,7 @@ export class PredictController extends BaseController<
         sharePrice,
         completionDuration,
         failureReason: errorMessage,
+        orderType: preview.orderType,
       });
 
       // Update error state for Sentry integration
diff --git a/app/components/UI/Predict/providers/polymarket/PolymarketProvider.test.ts b/app/components/UI/Predict/providers/polymarket/PolymarketProvider.test.ts
index c7074280b61d..9edb8fa2c44d 100644
--- a/app/components/UI/Predict/providers/polymarket/PolymarketProvider.test.ts
+++ b/app/components/UI/Predict/providers/polymarket/PolymarketProvider.test.ts
@@ -1363,21 +1363,52 @@ describe('PolymarketProvider', () => {
   });
 
   describe('previewOrder', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    const createPreviewSigner = () => ({
+      address: '0x1234567890123456789012345678901234567890',
+      signTypedMessage: jest.fn(),
+      signPersonalMessage: jest.fn(),
+    });
+
+    const createPreviewOrderParams = () => ({
+      marketId: 'market-123',
+      outcomeId: 'outcome-456',
+      outcomeTokenId: 'token-789',
+      side: Side.BUY,
+      size: 100,
+      signer: createPreviewSigner(),
+    });
+
+    const createPermit2PreviewProvider = (fakOrdersEnabled: boolean) =>
+      createProvider({
+        feeCollection: {
+          ...DEFAULT_FEE_COLLECTION_FLAG,
+          permit2Enabled: true,
+          executors: ['0xexecutor1'],
+        },
+        fakOrdersEnabled,
+      });
+
+    const mockPreviewOrderWithFees = () => {
+      mockPreviewOrder.mockResolvedValue({
+        fees: {
+          totalFee: 1,
+          metamaskFee: 0.5,
+          providerFee: 0.5,
+          totalFeePercentage: 1,
+          collector: DEFAULT_FEE_COLLECTION_FLAG.collector,
+        },
+      });
+    };
+
     it('calls previewOrder utility function with correct parameters', async () => {
       const provider = createProvider();
-      const mockSigner = {
-        address: '0x1234567890123456789012345678901234567890',
-        signTypedMessage: jest.fn(),
-        signPersonalMessage: jest.fn(),
-      };
       const mockParams = {
-        marketId: 'market-123',
-        outcomeId: 'outcome-456',
-        outcomeTokenId: 'token-789',
-        side: Side.BUY,
+        ...createPreviewOrderParams(),
         amount: 100,
-        size: 100,
-        signer: mockSigner,
       };
 
       await provider.previewOrder(mockParams);
@@ -1387,6 +1418,62 @@ describe('PolymarketProvider', () => {
         feeCollection: DEFAULT_FEE_COLLECTION_FLAG,
       });
     });
+    it('returns FOK orderType by default', async () => {
+      const provider = createProvider();
+      const result = await provider.previewOrder(createPreviewOrderParams());
+
+      expect(result.orderType).toBe('FOK');
+    });
+
+    it.each([
+      {
+        permit2Ready: true,
+        fakOrdersEnabled: true,
+        expectedOrderType: 'FAK',
+      },
+      {
+        permit2Ready: false,
+        fakOrdersEnabled: true,
+        expectedOrderType: 'FOK',
+      },
+      {
+        permit2Ready: true,
+        fakOrdersEnabled: false,
+        expectedOrderType: 'FOK',
+      },
+    ] as const)(
+      'returns $expectedOrderType orderType when permit2Ready=$permit2Ready and fakOrdersEnabled=$fakOrdersEnabled',
+      async ({ permit2Ready, fakOrdersEnabled, expectedOrderType }) => {
+        mockPreviewOrderWithFees();
+        mockHasPermit2Allowance.mockResolvedValue(permit2Ready);
+        const provider = createPermit2PreviewProvider(fakOrdersEnabled);
+
+        const result = await provider.previewOrder(createPreviewOrderParams());
+
+        expect(result.orderType).toBe(expectedOrderType);
+      },
+    );
+
+    it('returns FOK orderType when permit2 allowance check throws', async () => {
+      mockPreviewOrderWithFees();
+      mockHasPermit2Allowance.mockRejectedValue(new Error('RPC timeout'));
+      const provider = createPermit2PreviewProvider(true);
+
+      const result = await provider.previewOrder(createPreviewOrderParams());
+
+      expect(result.orderType).toBe('FOK');
+    });
+
+    it('returns FAK orderType when fees are absent and FAK flags are enabled', async () => {
+      mockPreviewOrder.mockResolvedValue({});
+      mockHasPermit2Allowance.mockResolvedValue(true);
+      const provider = createPermit2PreviewProvider(true);
+
+      const result = await provider.previewOrder(createPreviewOrderParams());
+
+      expect(result.orderType).toBe('FAK');
+      expect(mockHasPermit2Allowance).not.toHaveBeenCalled();
+    });
   });
 
   describe('API key caching', () => {
@@ -1867,6 +1954,57 @@ describe('PolymarketProvider', () => {
       );
     });
   });
+  describe('placeOrder FAK order type for sell orders', () => {
+    it('submits FAK order type for sell order without fees when FAK is enabled', async () => {
+      jest.clearAllMocks();
+      const { provider, mockSigner } = setupPlaceOrderTest({
+        feeCollection: {
+          ...DEFAULT_FEE_COLLECTION_FLAG,
+          permit2Enabled: true,
+          executors: ['0xexecutor1'],
+        },
+        fakOrdersEnabled: true,
+      });
+      const preview = createMockOrderPreview({
+        side: Side.SELL,
+        fees: undefined,
+      });
+
+      await provider.placeOrder({ preview, signer: mockSigner });
+
+      expect(mockSubmitClobOrder).toHaveBeenCalledWith(
+        expect.objectContaining({
+          clobOrder: expect.objectContaining({ orderType: 'FAK' }),
+        }),
+      );
+      expect(mockHasPermit2Allowance).not.toHaveBeenCalled();
+    });
+
+    it('submits FOK order type for sell order without fees when FAK is disabled', async () => {
+      jest.clearAllMocks();
+      const { provider, mockSigner } = setupPlaceOrderTest({
+        feeCollection: {
+          ...DEFAULT_FEE_COLLECTION_FLAG,
+          permit2Enabled: true,
+          executors: ['0xexecutor1'],
+        },
+        fakOrdersEnabled: false,
+      });
+      const preview = createMockOrderPreview({
+        side: Side.SELL,
+        fees: undefined,
+      });
+
+      await provider.placeOrder({ preview, signer: mockSigner });
+
+      expect(mockSubmitClobOrder).toHaveBeenCalledWith(
+        expect.objectContaining({
+          clobOrder: expect.objectContaining({ orderType: 'FOK' }),
+        }),
+      );
+    });
+  });
+
   describe('placeOrder edge cases', () => {
     it('places order without fee authorization when totalFee is zero', async () => {
       // Clear mock to ensure clean state for this test
diff --git a/app/components/UI/Predict/providers/polymarket/PolymarketProvider.ts b/app/components/UI/Predict/providers/polymarket/PolymarketProvider.ts
index 3cfb5b8a38dd..3a88fbb1a8fc 100644
--- a/app/components/UI/Predict/providers/polymarket/PolymarketProvider.ts
+++ b/app/components/UI/Predict/providers/polymarket/PolymarketProvider.ts
@@ -187,6 +187,48 @@ export class PolymarketProvider implements PredictProvider {
     };
   }
 
+  #hasPermit2Config(params: {
+    permit2Enabled?: boolean;
+    executors?: string[];
+  }): boolean {
+    return (
+      params.permit2Enabled === true &&
+      Array.isArray(params.executors) &&
+      params.executors.length > 0
+    );
+  }
+
+  #shouldUseFakOrderType({
+    permit2Enabled,
+    executors,
+    fakOrdersEnabled,
+  }: {
+    permit2Enabled?: boolean;
+    executors?: string[];
+    fakOrdersEnabled: boolean;
+  }): boolean {
+    return (
+      this.#hasPermit2Config({ permit2Enabled, executors }) &&
+      fakOrdersEnabled === true
+    );
+  }
+
+  async #isPermit2AllowanceReady(ownerAddress: string): Promise<boolean> {
+    const safeAddress =
+      this.#accountStateByAddress.get(ownerAddress)?.address ??
+      computeProxyAddress(ownerAddress);
+
+    try {
+      return await hasPermit2Allowance({ address: safeAddress });
+    } catch (error) {
+      DevLogger.log('PolymarketProvider: Permit2 allowance check failed', {
+        error,
+        ownerAddress,
+      });
+      return false;
+    }
+  }
+
   public async getMarketDetails({
     marketId,
   }: {
@@ -977,19 +1019,49 @@ export class PolymarketProvider implements PredictProvider {
       signer: Signer;
     },
   ): Promise<OrderPreview> {
-    const { feeCollection } = this.#getFeatureFlags();
+    const { feeCollection, fakOrdersEnabled } = this.#getFeatureFlags();
     const basePreview = await previewOrder({ ...params, feeCollection });
 
+    // Determine intended order type from feature flags.
+    // FAK is used when Permit2 config is active and FAK orders are enabled.
+    // The Permit2 allowance check is only needed when fees must be collected.
+    let orderType = OrderType.FOK;
+
+    const couldUseFak = this.#shouldUseFakOrderType({
+      permit2Enabled: feeCollection.permit2Enabled,
+      executors: feeCollection.executors,
+      fakOrdersEnabled,
+    });
+
+    if (couldUseFak) {
+      const hasFees =
+        basePreview.fees !== undefined && basePreview.fees.totalFee > 0;
+      if (hasFees) {
+        // TODO: remove this once placeOrder guarantees Permit2 allowance
+        // is set automatically before order submission.
+        const permit2Ready = await this.#isPermit2AllowanceReady(
+          params.signer.address,
+        );
+        if (permit2Ready) {
+          orderType = OrderType.FAK;
+        }
+      } else {
+        // No fees to collect via Permit2 — FAK can be used directly.
+        orderType = OrderType.FAK;
+      }
+    }
+
     if (params.signer) {
       if (this.isRateLimited(params.signer.address)) {
         return {
           ...basePreview,
+          orderType,
           rateLimited: true,
         };
       }
     }
 
-    return basePreview;
+    return { ...basePreview, orderType };
   }
 
   public async placeOrder(
@@ -1145,18 +1217,19 @@ export class PolymarketProvider implements PredictProvider {
 
       // Determine fees, permit2, and order type BEFORE building clobOrder
       // so the HMAC signature covers the correct orderType.
-      const { fakOrdersEnabled } = this.#getFeatureFlags();
-      const shouldUsePermit2 =
-        fees?.permit2Enabled === true &&
-        Array.isArray(fees.executors) &&
-        fees.executors.length > 0;
+      const { feeCollection, fakOrdersEnabled } = this.#getFeatureFlags();
+      const shouldUsePermit2 = this.#hasPermit2Config({
+        permit2Enabled: fees?.permit2Enabled,
+        executors: fees?.executors,
+      });
 
       let feeAuthorization:
         | SafeFeeAuthorization
         | Permit2FeeAuthorization
         | undefined;
       let executor: string | undefined;
-      let shouldUseFakOrderType = false;
+      let orderType: OrderType = OrderType.FOK;
+      let permit2FeeReady = false;
 
       if (fees !== undefined && fees.totalFee > 0) {
         const safeAddress = computeProxyAddress(signer.address);
@@ -1164,21 +1237,23 @@ export class PolymarketProvider implements PredictProvider {
           parseUnits(fees.totalFee.toString(), 6).toString(),
         );
 
-        if (shouldUsePermit2 && fees.executors) {
-          const permit2Ready = await hasPermit2Allowance({
-            address: safeAddress,
-          });
+        if (shouldUsePermit2) {
+          const executors = fees.executors ?? [];
+          const permit2Ready = await this.#isPermit2AllowanceReady(
+            signer.address,
+          );
 
           if (permit2Ready) {
-            executor =
-              fees.executors[Math.floor(Math.random() * fees.executors.length)];
+            permit2FeeReady = true;
+            const randomIndex = new Uint32Array(1);
+            global.crypto.getRandomValues(randomIndex);
+            executor = executors[randomIndex[0] % executors.length];
             feeAuthorization = await createPermit2FeeAuthorization({
               safeAddress,
               signer,
               amount: feeAmountInUsdc,
               spender: executor,
             });
-            shouldUseFakOrderType = fakOrdersEnabled === true;
           } else {
             feeAuthorization = await createSafeFeeAuthorization({
               safeAddress,
@@ -1197,10 +1272,26 @@ export class PolymarketProvider implements PredictProvider {
         }
       }
 
+      // Determine order type independently of fee authorization.
+      // FAK depends on feature flags only; the Permit2 allowance check
+      // is only needed when fees must be collected via Permit2.
+      if (
+        this.#shouldUseFakOrderType({
+          permit2Enabled: feeCollection.permit2Enabled,
+          executors: feeCollection.executors,
+          fakOrdersEnabled,
+        })
+      ) {
+        const hasFees = fees !== undefined && fees.totalFee > 0;
+        if (!hasFees || permit2FeeReady) {
+          orderType = OrderType.FAK;
+        }
+      }
+
       const clobOrder = {
         order: { ...signedOrder, side, salt: parseInt(signedOrder.salt) },
         owner: signerApiKey.apiKey,
-        orderType: shouldUseFakOrderType ? OrderType.FAK : OrderType.FOK,
+        orderType,
       };
 
       const body = JSON.stringify(clobOrder);
diff --git a/app/components/UI/Predict/types/index.ts b/app/components/UI/Predict/types/index.ts
index 672c524a22dd..51464d2ee186 100644
--- a/app/components/UI/Predict/types/index.ts
+++ b/app/components/UI/Predict/types/index.ts
@@ -7,6 +7,8 @@ export enum Side {
   SELL = 'SELL',
 }
 
+export type PredictOrderType = 'FOK' | 'FAK';
+
 export enum PredictPriceHistoryInterval {
   ONE_HOUR = '1h',
   SIX_HOUR = '6h',
@@ -470,6 +472,7 @@ export interface OrderPreview {
   // For sell orders, we can store the position ID
   // so we can perform optimistic updates
   positionId?: string;
+  orderType?: PredictOrderType;
 }
 
 export type OrderResult = Result<{
diff --git a/app/components/UI/Ramp/Aggregator/Views/OrdersList/OrdersList.testIds.ts b/app/components/UI/Ramp/Aggregator/Views/OrdersList/OrdersList.testIds.ts
new file mode 100644
index 000000000000..86b14cac06ea
--- /dev/null
+++ b/app/components/UI/Ramp/Aggregator/Views/OrdersList/OrdersList.testIds.ts
@@ -0,0 +1,14 @@
+export type RampsOrderTypeSlug = 'buy' | 'sell' | 'deposit';
+
+export const getOrderRowTestId = (type: RampsOrderTypeSlug, index: number) =>
+  `orders-list-row-${type}-${index}`;
+
+export const getOrderRowCryptoAmountTestId = (
+  type: RampsOrderTypeSlug,
+  index: number,
+) => `orders-list-crypto-amount-${type}-${index}`;
+
+export const getOrderRowFiatAmountTestId = (
+  type: RampsOrderTypeSlug,
+  index: number,
+) => `orders-list-fiat-amount-${type}-${index}`;
diff --git a/app/components/UI/Ramp/Aggregator/Views/OrdersList/OrdersList.tsx b/app/components/UI/Ramp/Aggregator/Views/OrdersList/OrdersList.tsx
index a4034f8d2a33..69d549095ba4 100644
--- a/app/components/UI/Ramp/Aggregator/Views/OrdersList/OrdersList.tsx
+++ b/app/components/UI/Ramp/Aggregator/Views/OrdersList/OrdersList.tsx
@@ -41,6 +41,12 @@ import ListItemColumn, {
   WidthType,
 } from '../../../../../../component-library/components/List/ListItemColumn';
 import ListItemColumnEnd from '../../components/ListItemColumnEnd';
+import {
+  getOrderRowTestId,
+  getOrderRowCryptoAmountTestId,
+  getOrderRowFiatAmountTestId,
+  type RampsOrderTypeSlug,
+} from './OrdersList.testIds';
 
 type filterType = 'ALL' | 'PURCHASE' | 'SELL';
 
@@ -92,12 +98,25 @@ function getStatusColorAndText(
   return [statusColor, statusText];
 }
 
-function DisplayOrderListItem({ item }: { item: DisplayOrder }) {
+function getOrderTypeSlug(orderType: string): RampsOrderTypeSlug {
+  if (orderType === 'DEPOSIT') return 'deposit';
+  if (orderType === 'SELL') return 'sell';
+  return 'buy';
+}
+
+function DisplayOrderListItem({
+  item,
+  index,
+}: {
+  item: DisplayOrder;
+  index: number;
+}) {
   const isBuy = item.orderType === 'BUY' || item.orderType === 'DEPOSIT';
   const [statusColor, statusText] = getStatusColorAndText(
     item.status,
     item.orderType,
   );
+  const typeSlug = getOrderTypeSlug(item.orderType);
 
   const title = item.providerName
     ? `${item.providerName}: ${strings(
@@ -128,10 +147,17 @@ function DisplayOrderListItem({ item }: { item: DisplayOrder }) {
       </ListItemColumn>
 
       <ListItemColumnEnd>
-        <Text variant={TextVariant.BodyMD}>
+        <Text
+          testID={getOrderRowCryptoAmountTestId(typeSlug, index)}
+          variant={TextVariant.BodyMD}
+        >
           {item.cryptoAmount} {item.cryptoCurrencySymbol}
         </Text>
-        <Text variant={TextVariant.BodySM} color={TextColor.Alternative}>
+        <Text
+          testID={getOrderRowFiatAmountTestId(typeSlug, index)}
+          variant={TextVariant.BodySM}
+          color={TextColor.Alternative}
+        >
           {item.fiatAmount == null
             ? '...'
             : addCurrencySymbol(
@@ -256,8 +282,15 @@ function OrdersList() {
     ],
   );
 
-  const renderItem = ({ item }: { item: DisplayOrder }) => (
+  const renderItem = ({
+    item,
+    index,
+  }: {
+    item: DisplayOrder;
+    index: number;
+  }) => (
     <TouchableHighlight
+      testID={getOrderRowTestId(getOrderTypeSlug(item.orderType), index + 1)}
       accessibilityRole="button"
       accessible
       style={styles.row}
@@ -265,7 +298,7 @@ function OrdersList() {
       underlayColor={colors.background.alternative}
       activeOpacity={1}
     >
-      <DisplayOrderListItem item={item} />
+      <DisplayOrderListItem item={item} index={index + 1} />
     </TouchableHighlight>
   );
 
diff --git a/app/components/UI/Ramp/Aggregator/Views/OrdersList/__snapshots__/OrdersList.test.tsx.snap b/app/components/UI/Ramp/Aggregator/Views/OrdersList/__snapshots__/OrdersList.test.tsx.snap
index cb8638a72fc3..5091ad05fb18 100644
--- a/app/components/UI/Ramp/Aggregator/Views/OrdersList/__snapshots__/OrdersList.test.tsx.snap
+++ b/app/components/UI/Ramp/Aggregator/Views/OrdersList/__snapshots__/OrdersList.test.tsx.snap
@@ -476,6 +476,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-1"
         underlayColor="#f3f3f4"
       >
         <View
@@ -583,6 +584,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-1"
               >
                 0.01231324
                  
@@ -599,6 +601,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-1"
               >
                 $34.23 
               </Text>
@@ -623,6 +626,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-2"
         underlayColor="#f3f3f4"
       >
         <View
@@ -730,6 +734,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-2"
               >
                 0.01231324
                  
@@ -746,6 +751,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-2"
               >
                 $34.23 
               </Text>
@@ -770,6 +776,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-3"
         underlayColor="#f3f3f4"
       >
         <View
@@ -877,6 +884,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-3"
               >
                 0.5
                  
@@ -893,6 +901,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-3"
               >
                 $1000 
               </Text>
@@ -917,6 +926,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-deposit-4"
         underlayColor="#f3f3f4"
       >
         <View
@@ -1024,6 +1034,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-deposit-4"
               >
                 100
                  
@@ -1040,6 +1051,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-deposit-4"
               >
                 $100 
               </Text>
@@ -1064,6 +1076,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-deposit-5"
         underlayColor="#f3f3f4"
       >
         <View
@@ -1171,6 +1184,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-deposit-5"
               >
                 20
                  
@@ -1187,6 +1201,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-deposit-5"
               >
                 $20 
               </Text>
@@ -1211,6 +1226,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-6"
         underlayColor="#f3f3f4"
       >
         <View
@@ -1318,6 +1334,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-6"
               >
                 0
                  
@@ -1334,6 +1351,7 @@ exports[`OrdersList renders buy only correctly when pressing buy filter 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-6"
               >
                 ...
               </Text>
@@ -1836,6 +1854,7 @@ exports[`OrdersList renders correctly 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-1"
         underlayColor="#f3f3f4"
       >
         <View
@@ -1943,6 +1962,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-1"
               >
                 0.01231324
                  
@@ -1959,6 +1979,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-1"
               >
                 $34.23 
               </Text>
@@ -1983,6 +2004,7 @@ exports[`OrdersList renders correctly 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-sell-2"
         underlayColor="#f3f3f4"
       >
         <View
@@ -2090,6 +2112,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-sell-2"
               >
                 0.01231324
                  
@@ -2106,6 +2129,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-sell-2"
               >
                 $34.23 
               </Text>
@@ -2130,6 +2154,7 @@ exports[`OrdersList renders correctly 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-3"
         underlayColor="#f3f3f4"
       >
         <View
@@ -2237,6 +2262,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-3"
               >
                 0.01231324
                  
@@ -2253,6 +2279,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-3"
               >
                 $34.23 
               </Text>
@@ -2277,6 +2304,7 @@ exports[`OrdersList renders correctly 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-4"
         underlayColor="#f3f3f4"
       >
         <View
@@ -2384,6 +2412,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-4"
               >
                 0.5
                  
@@ -2400,6 +2429,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-4"
               >
                 $1000 
               </Text>
@@ -2424,6 +2454,7 @@ exports[`OrdersList renders correctly 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-deposit-5"
         underlayColor="#f3f3f4"
       >
         <View
@@ -2531,6 +2562,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-deposit-5"
               >
                 100
                  
@@ -2547,6 +2579,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-deposit-5"
               >
                 $100 
               </Text>
@@ -2571,6 +2604,7 @@ exports[`OrdersList renders correctly 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-deposit-6"
         underlayColor="#f3f3f4"
       >
         <View
@@ -2678,6 +2712,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-deposit-6"
               >
                 20
                  
@@ -2694,6 +2729,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-deposit-6"
               >
                 $20 
               </Text>
@@ -2718,6 +2754,7 @@ exports[`OrdersList renders correctly 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-7"
         underlayColor="#f3f3f4"
       >
         <View
@@ -2825,6 +2862,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-7"
               >
                 0
                  
@@ -2841,6 +2879,7 @@ exports[`OrdersList renders correctly 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-7"
               >
                 ...
               </Text>
@@ -4117,6 +4156,7 @@ exports[`OrdersList renders sell only correctly when pressing sell filter 1`] =
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-sell-1"
         underlayColor="#f3f3f4"
       >
         <View
@@ -4224,6 +4264,7 @@ exports[`OrdersList renders sell only correctly when pressing sell filter 1`] =
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-sell-1"
               >
                 0.01231324
                  
@@ -4240,6 +4281,7 @@ exports[`OrdersList renders sell only correctly when pressing sell filter 1`] =
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-sell-1"
               >
                 $34.23 
               </Text>
@@ -4658,6 +4700,7 @@ exports[`OrdersList resets filter to all after other filter was set 1`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-sell-1"
         underlayColor="#f3f3f4"
       >
         <View
@@ -4765,6 +4808,7 @@ exports[`OrdersList resets filter to all after other filter was set 1`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-sell-1"
               >
                 0.01231324
                  
@@ -4781,6 +4825,7 @@ exports[`OrdersList resets filter to all after other filter was set 1`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-sell-1"
               >
                 $34.23 
               </Text>
@@ -5283,6 +5328,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-1"
         underlayColor="#f3f3f4"
       >
         <View
@@ -5390,6 +5436,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-1"
               >
                 0.01231324
                  
@@ -5406,6 +5453,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-1"
               >
                 $34.23 
               </Text>
@@ -5430,6 +5478,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-sell-2"
         underlayColor="#f3f3f4"
       >
         <View
@@ -5537,6 +5586,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-sell-2"
               >
                 0.01231324
                  
@@ -5553,6 +5603,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-sell-2"
               >
                 $34.23 
               </Text>
@@ -5577,6 +5628,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-3"
         underlayColor="#f3f3f4"
       >
         <View
@@ -5684,6 +5736,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-3"
               >
                 0.01231324
                  
@@ -5700,6 +5753,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-3"
               >
                 $34.23 
               </Text>
@@ -5724,6 +5778,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-4"
         underlayColor="#f3f3f4"
       >
         <View
@@ -5831,6 +5886,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-4"
               >
                 0.5
                  
@@ -5847,6 +5903,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-4"
               >
                 $1000 
               </Text>
@@ -5871,6 +5928,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-deposit-5"
         underlayColor="#f3f3f4"
       >
         <View
@@ -5978,6 +6036,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-deposit-5"
               >
                 100
                  
@@ -5994,6 +6053,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-deposit-5"
               >
                 $100 
               </Text>
@@ -6018,6 +6078,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-deposit-6"
         underlayColor="#f3f3f4"
       >
         <View
@@ -6125,6 +6186,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-deposit-6"
               >
                 20
                  
@@ -6141,6 +6203,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-deposit-6"
               >
                 $20 
               </Text>
@@ -6165,6 +6228,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
             "borderColor": "#b4b4b566",
           }
         }
+        testID="orders-list-row-buy-7"
         underlayColor="#f3f3f4"
       >
         <View
@@ -6272,6 +6336,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 24,
                   }
                 }
+                testID="orders-list-crypto-amount-buy-7"
               >
                 0
                  
@@ -6288,6 +6353,7 @@ exports[`OrdersList resets filter to all after other filter was set 2`] = `
                     "lineHeight": 22,
                   }
                 }
+                testID="orders-list-fiat-amount-buy-7"
               >
                 ...
               </Text>
diff --git a/app/components/UI/Ramp/Aggregator/components/PaymentMethodSelectorModal/PaymentMethodSelectorModal.test.tsx b/app/components/UI/Ramp/Aggregator/components/PaymentMethodSelectorModal/PaymentMethodSelectorModal.test.tsx
index ba8f2a2a7086..41b55bb8b616 100644
--- a/app/components/UI/Ramp/Aggregator/components/PaymentMethodSelectorModal/PaymentMethodSelectorModal.test.tsx
+++ b/app/components/UI/Ramp/Aggregator/components/PaymentMethodSelectorModal/PaymentMethodSelectorModal.test.tsx
@@ -110,7 +110,34 @@ describe('PaymentMethodSelectorModal', () => {
     expect(toJSON()).toMatchSnapshot();
   });
 
-  it('tracks RAMPS_PAYMENT_METHOD_SELECTED event when payment method is selected', () => {
+  it('tracks OFFRAMP_PAYMENT_METHOD_SELECTED event when payment method is selected in sell flow', () => {
+    mockUseParams.mockReturnValue({
+      ...defaultParams,
+      location: 'Amount to Sell Screen' as const,
+    });
+    mockUseRampSDKValues = {
+      ...mockUseRampSDKInitialValues,
+      rampType: RampType.SELL,
+      isBuy: false,
+    };
+
+    const { getByText } = render(PaymentMethodSelectorModal);
+
+    const paymentMethodElement = getByText('Bank Transfer');
+    fireEvent.press(paymentMethodElement);
+
+    expect(mockTrackEvent).toHaveBeenCalledWith(
+      'OFFRAMP_PAYMENT_METHOD_SELECTED',
+      {
+        payment_method_id: 'payment-method-2',
+        available_payment_method_ids: ['payment-method-1', 'payment-method-2'],
+        region: 'US',
+        location: 'Amount to Sell Screen',
+      },
+    );
+  });
+
+  it('tracks ONRAMP_PAYMENT_METHOD_SELECTED event when payment method is selected in buy flow', () => {
     const { getByText } = render(PaymentMethodSelectorModal);
 
     const paymentMethodElement = getByText('Bank Transfer');
@@ -126,7 +153,7 @@ describe('PaymentMethodSelectorModal', () => {
       },
     );
   });
-  it('does not track RAMPS_PAYMENT_METHOD_SELECTED event when the same payment method is selected', () => {
+  it('does not track ONRAMP_PAYMENT_METHOD_SELECTED event when the same payment method is selected', () => {
     const { getByText } = render(PaymentMethodSelectorModal);
 
     const paymentMethodElement = getByText('Credit Card');
diff --git a/app/components/UI/Ramp/Views/NativeFlow/EnterEmail.testIds.ts b/app/components/UI/Ramp/Views/NativeFlow/EnterEmail.testIds.ts
new file mode 100644
index 000000000000..3be1da5e5547
--- /dev/null
+++ b/app/components/UI/Ramp/Views/NativeFlow/EnterEmail.testIds.ts
@@ -0,0 +1,4 @@
+export const EnterEmailSelectorsIDs = {
+  EMAIL_INPUT: 'ramps-enter-email-input',
+  SEND_EMAIL_BUTTON: 'ramps-enter-email-send-button',
+};
diff --git a/app/components/UI/Ramp/Views/NativeFlow/EnterEmail.tsx b/app/components/UI/Ramp/Views/NativeFlow/EnterEmail.tsx
index da96ff54c4a4..50fe451ed5f8 100644
--- a/app/components/UI/Ramp/Views/NativeFlow/EnterEmail.tsx
+++ b/app/components/UI/Ramp/Views/NativeFlow/EnterEmail.tsx
@@ -29,6 +29,7 @@ import { useAnalytics } from '../../../../hooks/useAnalytics/useAnalytics';
 import { MetaMetricsEvents } from '../../../../../core/Analytics';
 import { useTransakController } from '../../hooks/useTransakController';
 import { parseUserFacingError } from '../../utils/parseUserFacingError';
+import { EnterEmailSelectorsIDs } from './EnterEmail.testIds';
 
 export interface V2EnterEmailParams {
   amount?: string;
@@ -149,6 +150,7 @@ const V2EnterEmail = () => {
             </Text>
 
             <TextField
+              testID={EnterEmailSelectorsIDs.EMAIL_INPUT}
               autoComplete="email"
               keyboardType="email-address"
               placeholder={strings('deposit.enter_email.input_placeholder')}
@@ -176,6 +178,7 @@ const V2EnterEmail = () => {
       <ScreenLayout.Footer>
         <ScreenLayout.Content style={styles.footerContent}>
           <Button
+            testID={EnterEmailSelectorsIDs.SEND_EMAIL_BUTTON}
             size={ButtonSize.Lg}
             onPress={handleSubmit}
             label={strings('deposit.enter_email.submit_button')}
diff --git a/app/components/UI/Ramp/Views/NativeFlow/OtpCode.testIds.ts b/app/components/UI/Ramp/Views/NativeFlow/OtpCode.testIds.ts
new file mode 100644
index 000000000000..426e920ccd52
--- /dev/null
+++ b/app/components/UI/Ramp/Views/NativeFlow/OtpCode.testIds.ts
@@ -0,0 +1,6 @@
+export const OtpCodeSelectorsIDs = {
+  OTP_CODE_SCREEN: 'otp-code-screen',
+  OTP_CODE_INPUT: 'otp-code-input',
+  PASTE_BUTTON: 'otp-code-paste-button',
+  SUBMIT_BUTTON: 'otp-code-submit-button',
+};
diff --git a/app/components/UI/Ramp/Views/NativeFlow/OtpCode.tsx b/app/components/UI/Ramp/Views/NativeFlow/OtpCode.tsx
index 508fafbb502f..51691a249188 100644
--- a/app/components/UI/Ramp/Views/NativeFlow/OtpCode.tsx
+++ b/app/components/UI/Ramp/Views/NativeFlow/OtpCode.tsx
@@ -40,6 +40,7 @@ import { useTransakController } from '../../hooks/useTransakController';
 import { useTransakRouting } from '../../hooks/useTransakRouting';
 import { useRampsController } from '../../hooks/useRampsController';
 import { parseUserFacingError } from '../../utils/parseUserFacingError';
+import { OtpCodeSelectorsIDs } from './OtpCode.testIds';
 
 export interface V2OtpCodeParams {
   email: string;
@@ -324,7 +325,7 @@ const V2OtpCode = () => {
   });
 
   return (
-    <ScreenLayout>
+    <ScreenLayout testID={OtpCodeSelectorsIDs.OTP_CODE_SCREEN}>
       <ScreenLayout.Body>
         <ScreenLayout.Content grow>
           <DepositProgressBar steps={4} currentStep={1} />
@@ -340,14 +341,14 @@ const V2OtpCode = () => {
               variant={TextVariant.BodyMD}
               color={TextColor.Primary}
               onPress={handlePaste}
-              testID="otp-code-paste-button"
+              testID={OtpCodeSelectorsIDs.PASTE_BUTTON}
             >
               {strings('deposit.otp_code.paste')}
             </Text>
           </Box>
 
           <CodeField
-            testID="otp-code-input"
+            testID={OtpCodeSelectorsIDs.OTP_CODE_INPUT}
             ref={inputRef as React.RefObject<TextInput>}
             {...props}
             value={value}
@@ -416,7 +417,7 @@ const V2OtpCode = () => {
             width={ButtonWidthTypes.Full}
             loading={isLoading}
             isDisabled={isLoading || value.length !== CELL_COUNT}
-            testID="otp-code-submit-button"
+            testID={OtpCodeSelectorsIDs.SUBMIT_BUTTON}
           />
           <PoweredByTransak name="powered-by-transak-logo" />
         </ScreenLayout.Content>
diff --git a/app/components/UI/Ramp/Views/NativeFlow/VerifyIdentity.testIds.ts b/app/components/UI/Ramp/Views/NativeFlow/VerifyIdentity.testIds.ts
new file mode 100644
index 000000000000..df76b6095984
--- /dev/null
+++ b/app/components/UI/Ramp/Views/NativeFlow/VerifyIdentity.testIds.ts
@@ -0,0 +1,5 @@
+export const VerifyIdentitySelectorsIDs = {
+  CONTINUE_BUTTON: 'ramps-verify-identity-continue-button',
+  PRIVACY_POLICY_LINK_1: 'privacy-policy-link-1',
+  PRIVACY_POLICY_LINK_2: 'privacy-policy-link-2',
+};
diff --git a/app/components/UI/Ramp/Views/NativeFlow/VerifyIdentity.tsx b/app/components/UI/Ramp/Views/NativeFlow/VerifyIdentity.tsx
index 93d14c2d3b9f..e757bcc66954 100644
--- a/app/components/UI/Ramp/Views/NativeFlow/VerifyIdentity.tsx
+++ b/app/components/UI/Ramp/Views/NativeFlow/VerifyIdentity.tsx
@@ -32,6 +32,7 @@ import {
   useParams,
 } from '../../../../../util/navigation/navUtils';
 import { createV2EnterEmailNavDetails } from './EnterEmail';
+import { VerifyIdentitySelectorsIDs } from './VerifyIdentity.testIds';
 
 export interface V2VerifyIdentityParams {
   amount?: string;
@@ -195,7 +196,7 @@ const V2VerifyIdentity = () => {
               <Text
                 style={styles.linkText}
                 onPress={handlePrivacyPolicyLink}
-                testID="privacy-policy-link-1"
+                testID={VerifyIdentitySelectorsIDs.PRIVACY_POLICY_LINK_1}
               >
                 {strings(
                   'deposit.verify_identity.description_3_privacy_policy',
@@ -228,13 +229,14 @@ const V2VerifyIdentity = () => {
               color={TextColor.Muted}
               style={styles.linkText}
               onPress={handlePrivacyPolicyLink}
-              testID="privacy-policy-link-2"
+              testID={VerifyIdentitySelectorsIDs.PRIVACY_POLICY_LINK_2}
             >
               {strings('deposit.verify_identity.agreement_text_privacy_policy')}
             </Text>
             {strings('deposit.verify_identity.agreement_text_part2')}
           </Text>
           <Button
+            testID={VerifyIdentitySelectorsIDs.CONTINUE_BUTTON}
             size={ButtonSize.Lg}
             onPress={handleSubmit}
             label={strings('deposit.verify_identity.button')}
diff --git a/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/EnterEmail.test.tsx.snap b/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/EnterEmail.test.tsx.snap
index be3433e7a531..7bb026de8c0b 100644
--- a/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/EnterEmail.test.tsx.snap
+++ b/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/EnterEmail.test.tsx.snap
@@ -173,6 +173,7 @@ exports[`V2EnterEmail matches snapshot 1`] = `
                     "opacity": 1,
                   }
                 }
+                testID="ramps-enter-email-input"
                 value=""
               />
             </View>
@@ -217,6 +218,7 @@ exports[`V2EnterEmail matches snapshot 1`] = `
               "paddingHorizontal": 16,
             }
           }
+          testID="ramps-enter-email-send-button"
         >
           <Text
             accessibilityRole="text"
diff --git a/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/OtpCode.test.tsx.snap b/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/OtpCode.test.tsx.snap
index 5b114f5e2cee..08c1a79a39b8 100644
--- a/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/OtpCode.test.tsx.snap
+++ b/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/OtpCode.test.tsx.snap
@@ -26,6 +26,7 @@ exports[`V2OtpCode matches snapshot 1`] = `
         undefined,
       ]
     }
+    testID="otp-code-screen"
   >
     <View
       style={
diff --git a/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/VerifyIdentity.test.tsx.snap b/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/VerifyIdentity.test.tsx.snap
index 5080f4827052..9b4e9039c1ad 100644
--- a/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/VerifyIdentity.test.tsx.snap
+++ b/app/components/UI/Ramp/Views/NativeFlow/__snapshots__/VerifyIdentity.test.tsx.snap
@@ -255,6 +255,7 @@ exports[`V2VerifyIdentity matches snapshot 1`] = `
               "paddingHorizontal": 16,
             }
           }
+          testID="ramps-verify-identity-continue-button"
         >
           <Text
             accessibilityRole="text"
diff --git a/app/components/UI/Ramp/Views/OrderDetails/OrderContent.tsx b/app/components/UI/Ramp/Views/OrderDetails/OrderContent.tsx
index ebf516dc1cba..d5c059b42130 100644
--- a/app/components/UI/Ramp/Views/OrderDetails/OrderContent.tsx
+++ b/app/components/UI/Ramp/Views/OrderDetails/OrderContent.tsx
@@ -37,6 +37,7 @@ import Button, {
 import { hasDepositOrderField } from '../../Deposit/utils';
 import BankDetailRow from '../../Deposit/components/BankDetailRow/BankDetailRow';
 import Routes from '../../../../../constants/navigation/Routes';
+import { RampsOrderDetailsSelectorsIDs } from './OrderDetails.testIds';
 
 const localStyles = StyleSheet.create({
   badgeWrapperCenter: {
@@ -309,6 +310,7 @@ const OrderContent: React.FC<OrderContentProps> = ({
         </BadgeWrapper>
 
         <Text
+          testID={RampsOrderDetailsSelectorsIDs.TOKEN_AMOUNT}
           variant={TextVariant.DisplayLg}
           fontWeight={FontWeight.Bold}
           twClassName="mt-6 text-center"
@@ -571,6 +573,7 @@ const OrderContent: React.FC<OrderContentProps> = ({
 
         {showCloseButton && (
           <Button
+            testID={RampsOrderDetailsSelectorsIDs.CLOSE_BUTTON}
             variant={ButtonVariants.Primary}
             size={ButtonSize.Lg}
             width={ButtonWidthTypes.Full}
diff --git a/app/components/UI/Ramp/Views/OrderDetails/OrderDetails.testIds.ts b/app/components/UI/Ramp/Views/OrderDetails/OrderDetails.testIds.ts
new file mode 100644
index 000000000000..ba1694235525
--- /dev/null
+++ b/app/components/UI/Ramp/Views/OrderDetails/OrderDetails.testIds.ts
@@ -0,0 +1,6 @@
+export const RampsOrderDetailsSelectorsIDs = {
+  CONTAINER: 'ramps-order-details-container',
+  CLOSE_BUTTON: 'ramps-order-details-close-button',
+  TOKEN_AMOUNT: 'ramps-order-details-token-amount',
+  BACK_BUTTON: 'ramps-order-details-back-navbar-button',
+};
diff --git a/app/components/UI/Ramp/Views/OrderDetails/OrderDetails.tsx b/app/components/UI/Ramp/Views/OrderDetails/OrderDetails.tsx
index a10f8ccd18ce..9340eaa0e063 100644
--- a/app/components/UI/Ramp/Views/OrderDetails/OrderDetails.tsx
+++ b/app/components/UI/Ramp/Views/OrderDetails/OrderDetails.tsx
@@ -31,6 +31,7 @@ import OrderContent from './OrderContent';
 import { useRampsOrders } from '../../hooks/useRampsOrders';
 import { useAnalytics } from '../../../../hooks/useAnalytics/useAnalytics';
 import { MetaMetricsEvents } from '../../../../../core/Analytics';
+import { RampsOrderDetailsSelectorsIDs } from './OrderDetails.testIds';
 
 interface RampsOrderDetailsParams {
   orderId: string;
@@ -196,7 +197,7 @@ const OrderDetails = () => {
   }
 
   return (
-    <ScreenLayout>
+    <ScreenLayout testID={RampsOrderDetailsSelectorsIDs.CONTAINER}>
       <ScrollView
         refreshControl={
           <RefreshControl
diff --git a/app/components/UI/Ramp/Views/OrderDetails/__snapshots__/OrderContent.test.tsx.snap b/app/components/UI/Ramp/Views/OrderDetails/__snapshots__/OrderContent.test.tsx.snap
index 91abdd763f3b..0477586bb135 100644
--- a/app/components/UI/Ramp/Views/OrderDetails/__snapshots__/OrderContent.test.tsx.snap
+++ b/app/components/UI/Ramp/Views/OrderDetails/__snapshots__/OrderContent.test.tsx.snap
@@ -166,6 +166,7 @@ exports[`OrderContent renders completed state correctly 1`] = `
           undefined,
         ]
       }
+      testID="ramps-order-details-token-amount"
     >
       0.05
        
@@ -759,6 +760,7 @@ exports[`OrderContent renders loading state when order has no amount 1`] = `
           undefined,
         ]
       }
+      testID="ramps-order-details-token-amount"
     >
       0.05
        
diff --git a/app/components/UI/Ramp/hooks/useRampTokens.test.ts b/app/components/UI/Ramp/hooks/useRampTokens.test.ts
index 17f3f346f186..f0f0b0a6bca7 100644
--- a/app/components/UI/Ramp/hooks/useRampTokens.test.ts
+++ b/app/components/UI/Ramp/hooks/useRampTokens.test.ts
@@ -182,6 +182,29 @@ describe('useRampTokens', () => {
     });
   });
 
+  describe('fetchOnMount option', () => {
+    it('skips fetching tokens when fetchOnMount is false', () => {
+      const mockResponse = createMockResponse(
+        [createMockToken({ symbol: 'ETH' })],
+        [createMockToken({ symbol: 'ETH' })],
+      );
+      mockHandleFetch.mockResolvedValueOnce(mockResponse);
+
+      const { result } = renderHookWithProvider(
+        () => useRampTokens({ fetchOnMount: false }),
+        {
+          state: createMockState(UnifiedRampRoutingType.AGGREGATOR, 'us-ca'),
+        },
+      );
+
+      expect(result.current.topTokens).toBeNull();
+      expect(result.current.allTokens).toBeNull();
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+      expect(mockHandleFetch).not.toHaveBeenCalled();
+    });
+  });
+
   describe('environment-based URL selection', () => {
     it('uses production URL for production environment', async () => {
       process.env.METAMASK_ENVIRONMENT = 'production';
diff --git a/app/components/UI/Ramp/hooks/useRampTokens.ts b/app/components/UI/Ramp/hooks/useRampTokens.ts
index 7249f8218985..2c11858411ab 100644
--- a/app/components/UI/Ramp/hooks/useRampTokens.ts
+++ b/app/components/UI/Ramp/hooks/useRampTokens.ts
@@ -48,12 +48,18 @@ export interface UseRampTokensResult {
   error: Error | null;
 }
 
+interface UseRampTokensOptions {
+  fetchOnMount: boolean;
+}
+
 /**
  * Hook to fetch available tokens for ramp flows based on user region and routing decision.
  *
  * @returns An object containing top tokens, all tokens, loading state, and error state
  */
-export function useRampTokens(): UseRampTokensResult {
+export function useRampTokens(
+  { fetchOnMount }: UseRampTokensOptions = { fetchOnMount: true },
+): UseRampTokensResult {
   const [rawTopTokens, setRawTopTokens] = useState<RampsToken[] | null>(null);
   const [rawAllTokens, setRawAllTokens] = useState<RampsToken[] | null>(null);
   const [isLoading, setIsLoading] = useState(false);
@@ -126,8 +132,10 @@ export function useRampTokens(): UseRampTokensResult {
   }, [detectedGeolocation, rampRoutingDecision]);
 
   useEffect(() => {
-    fetchTokens();
-  }, [fetchTokens]);
+    if (fetchOnMount) {
+      fetchTokens();
+    }
+  }, [fetchTokens, fetchOnMount]);
 
   // Filter tokens to only include those for networks the user has added
   const topTokens = useMemo(() => {
diff --git a/app/components/UI/Ramp/hooks/useTokenBuyability.test.ts b/app/components/UI/Ramp/hooks/useTokenBuyability.test.ts
index 83e22bf563de..c0a8bfd706f9 100644
--- a/app/components/UI/Ramp/hooks/useTokenBuyability.test.ts
+++ b/app/components/UI/Ramp/hooks/useTokenBuyability.test.ts
@@ -1,5 +1,6 @@
 import { renderHook } from '@testing-library/react-native';
-import { useTokenBuyability } from './useTokenBuyability';
+// eslint-disable-next-line import/no-namespace
+import * as tokenBuyabilityModule from './useTokenBuyability';
 import {
   useRampTokens,
   UseRampTokensResult,
@@ -8,6 +9,7 @@ import {
 import { useRampsTokens } from './useRampsTokens';
 import useRampsUnifiedV2Enabled from './useRampsUnifiedV2Enabled';
 import { TokenI } from '../../Tokens/types';
+import parseRampIntent from '../utils/parseRampIntent';
 
 jest.mock('./useRampTokens', () => ({
   useRampTokens: jest.fn(),
@@ -18,33 +20,40 @@ jest.mock('./useRampsTokens', () => ({
 }));
 
 jest.mock('./useRampsUnifiedV2Enabled', () => jest.fn());
+jest.mock('../utils/parseRampIntent', () => jest.fn());
 
 const mockUseRampTokens = jest.mocked(useRampTokens);
 const mockUseRampsTokens = jest.mocked(useRampsTokens);
 const mockUseRampsUnifiedV2Enabled = jest.mocked(useRampsUnifiedV2Enabled);
+const mockParseRampIntent = jest.mocked(parseRampIntent);
 
 describe('useTokenBuyability', () => {
-  const getMockToken = (overrides: Partial<TokenI> = {}): TokenI =>
-    ({
-      address: '0x6b175474e89094c44da98b954eedeac495271d0f',
-      symbol: 'DAI',
-      name: 'Dai Stablecoin',
-      decimals: 18,
-      chainId: '0x1',
-      ...overrides,
-    }) as TokenI;
-
-  const getMockRampToken = (overrides: Record<string, unknown> = {}) =>
-    ({
-      name: 'Mock Token',
-      symbol: 'MOCK',
-      decimals: 18,
-      iconUrl: 'https://example.com/icon.png',
-      assetId: '',
-      chainId: '',
-      tokenSupported: false,
-      ...overrides,
-    }) as unknown as RampsToken;
+  const getMockToken = (overrides: Partial<TokenI> = {}): TokenI => ({
+    address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+    symbol: 'DAI',
+    name: 'Dai Stablecoin',
+    decimals: 18,
+    chainId: '0x1',
+    image: '',
+    logo: undefined,
+    balance: '0',
+    isETH: false,
+    isNative: false,
+    ...overrides,
+  });
+
+  const getMockRampToken = (
+    overrides: Partial<RampsToken> = {},
+  ): RampsToken => ({
+    name: 'Mock Token',
+    symbol: 'MOCK',
+    decimals: 18,
+    iconUrl: 'https://example.com/icon.png',
+    assetId: 'eip155:1/erc20:0x0000000000000000000000000000000000000000',
+    chainId: 'eip155:1',
+    tokenSupported: false,
+    ...overrides,
+  });
 
   const setupV1Mocks = (): void => {
     mockUseRampsUnifiedV2Enabled.mockReturnValue(false);
@@ -67,9 +76,180 @@ describe('useTokenBuyability', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    mockParseRampIntent.mockReturnValue({
+      assetId: 'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f',
+    });
     setupV1Mocks();
   });
 
+  describe('useTokensBuyability', () => {
+    it('maps buyability for multiple tokens by token key', () => {
+      const firstToken = getMockToken({
+        address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+      });
+      const secondToken = getMockToken({
+        address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+      });
+
+      mockUseRampTokens.mockReturnValue({
+        allTokens: [
+          getMockRampToken({
+            assetId:
+              'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f',
+            tokenSupported: true,
+          }),
+          getMockRampToken({
+            assetId:
+              'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+            tokenSupported: false,
+          }),
+        ],
+        isLoading: false,
+      } as UseRampTokensResult);
+
+      mockParseRampIntent.mockImplementation(({ address }) => ({
+        assetId: `eip155:1/erc20:${address?.toLowerCase()}`,
+      }));
+
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokensBuyability([firstToken, secondToken]),
+      );
+
+      expect(result.current.buyabilityByTokenKey).toEqual({
+        [tokenBuyabilityModule.getTokenBuyabilityKey(firstToken)]: true,
+        [tokenBuyabilityModule.getTokenBuyabilityKey(secondToken)]: false,
+      });
+    });
+
+    it('returns loading from controller tokens when v2 is enabled', () => {
+      setupV2Mocks();
+      mockUseRampsTokens.mockReturnValue({
+        tokens: null,
+        selectedToken: null,
+        setSelectedToken: jest.fn(),
+        isLoading: true,
+        error: null,
+      });
+
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokensBuyability([getMockToken()]),
+      );
+
+      expect(result.current.isLoading).toBe(true);
+      expect(mockUseRampTokens).toHaveBeenCalledWith({ fetchOnMount: false });
+    });
+
+    it('returns loading from legacy tokens when v2 is disabled', () => {
+      setupV1Mocks();
+      mockUseRampTokens.mockReturnValue({
+        allTokens: null,
+        isLoading: true,
+      } as UseRampTokensResult);
+
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokensBuyability([getMockToken()]),
+      );
+
+      expect(result.current.isLoading).toBe(true);
+      expect(mockUseRampTokens).toHaveBeenCalledWith({ fetchOnMount: true });
+    });
+
+    it('does not call parseRampIntent when token address is already a CAIP asset type', () => {
+      const caipToken = getMockToken({
+        address: 'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f',
+        chainId: 'eip155:1',
+      });
+      mockUseRampTokens.mockReturnValue({
+        allTokens: [
+          getMockRampToken({
+            assetId:
+              'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f',
+            tokenSupported: true,
+          }),
+        ],
+        isLoading: false,
+      } as UseRampTokensResult);
+
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokensBuyability([caipToken]),
+      );
+
+      expect(result.current.buyabilityByTokenKey).toEqual({
+        [tokenBuyabilityModule.getTokenBuyabilityKey(caipToken)]: true,
+      });
+      expect(mockParseRampIntent).not.toHaveBeenCalled();
+    });
+
+    it('returns false when mockParseRampIntent parsing throws', () => {
+      mockParseRampIntent.mockImplementation(() => {
+        throw new Error('parse failed');
+      });
+      mockUseRampTokens.mockReturnValue({
+        allTokens: [
+          getMockRampToken({
+            assetId:
+              'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f',
+            tokenSupported: true,
+          }),
+        ],
+        isLoading: false,
+      } as UseRampTokensResult);
+
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokensBuyability([getMockToken()]),
+      );
+
+      expect(result.current.buyabilityByTokenKey).toEqual({
+        [tokenBuyabilityModule.getTokenBuyabilityKey(getMockToken())]: false,
+      });
+    });
+
+    it('returns false for native token when chainId differs', () => {
+      const nativeToken = getMockToken({ isNative: true, chainId: '0x1' });
+      mockUseRampTokens.mockReturnValue({
+        allTokens: [
+          getMockRampToken({
+            assetId: 'eip155:10/slip44:60',
+            chainId: 'eip155:10',
+            tokenSupported: true,
+          }),
+        ],
+        isLoading: false,
+      } as UseRampTokensResult);
+
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokensBuyability([nativeToken]),
+      );
+
+      expect(result.current.buyabilityByTokenKey).toEqual({
+        [tokenBuyabilityModule.getTokenBuyabilityKey(nativeToken)]: false,
+      });
+    });
+
+    it('returns false for native token when assetId is not slip44', () => {
+      const nativeToken = getMockToken({ isNative: true, chainId: '0x1' });
+      mockUseRampTokens.mockReturnValue({
+        allTokens: [
+          getMockRampToken({
+            assetId:
+              'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f',
+            chainId: 'eip155:1',
+            tokenSupported: true,
+          }),
+        ],
+        isLoading: false,
+      } as UseRampTokensResult);
+
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokensBuyability([nativeToken]),
+      );
+
+      expect(result.current.buyabilityByTokenKey).toEqual({
+        [tokenBuyabilityModule.getTokenBuyabilityKey(nativeToken)]: false,
+      });
+    });
+  });
+
   describe('when V2 is disabled (legacy flow)', () => {
     const testCases = [
       {
@@ -87,11 +267,12 @@ describe('useTokenBuyability', () => {
       {
         testName: 'token is in the list but not supported',
         hookReturn: [
-          {
-            address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+          getMockRampToken({
+            assetId:
+              'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f',
             chainId: 'eip155:1',
             tokenSupported: false,
-          },
+          }),
         ],
         token: getMockToken(),
         expectedBuyable: false,
@@ -131,20 +312,37 @@ describe('useTokenBuyability', () => {
           isLoading: false,
         } as UseRampTokensResult);
 
-        const { result } = renderHook(() => useTokenBuyability(token));
+        const { result } = renderHook(() =>
+          tokenBuyabilityModule.useTokenBuyability(token),
+        );
 
         expect(result.current.isBuyable).toBe(expectedBuyable);
         expect(result.current.isLoading).toBe(false);
       },
     );
 
+    it('ignores ramp entries without assetId', () => {
+      mockUseRampTokens.mockReturnValue({
+        allTokens: [getMockRampToken({ assetId: '' })],
+        isLoading: false,
+      } as UseRampTokensResult);
+
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokenBuyability(getMockToken()),
+      );
+
+      expect(result.current.isBuyable).toBe(false);
+    });
+
     it('returns isLoading: true when ramp tokens are loading', () => {
       mockUseRampTokens.mockReturnValue({
         allTokens: null,
         isLoading: true,
       } as UseRampTokensResult);
 
-      const { result } = renderHook(() => useTokenBuyability(getMockToken()));
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokenBuyability(getMockToken()),
+      );
 
       expect(result.current.isBuyable).toBe(false);
       expect(result.current.isLoading).toBe(true);
@@ -165,7 +363,9 @@ describe('useTokenBuyability', () => {
         error: null,
       });
 
-      const { result } = renderHook(() => useTokenBuyability(getMockToken()));
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokenBuyability(getMockToken()),
+      );
 
       expect(result.current.isBuyable).toBe(false);
     });
@@ -190,7 +390,9 @@ describe('useTokenBuyability', () => {
         error: null,
       });
 
-      const { result } = renderHook(() => useTokenBuyability(getMockToken()));
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokenBuyability(getMockToken()),
+      );
 
       expect(result.current.isBuyable).toBe(true);
     });
@@ -213,7 +415,9 @@ describe('useTokenBuyability', () => {
         error: null,
       });
 
-      const { result } = renderHook(() => useTokenBuyability(getMockToken()));
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokenBuyability(getMockToken()),
+      );
 
       expect(result.current.isBuyable).toBe(false);
     });
@@ -227,7 +431,9 @@ describe('useTokenBuyability', () => {
         error: null,
       });
 
-      const { result } = renderHook(() => useTokenBuyability(getMockToken()));
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokenBuyability(getMockToken()),
+      );
 
       expect(result.current.isBuyable).toBe(false);
       expect(result.current.isLoading).toBe(true);
@@ -257,7 +463,9 @@ describe('useTokenBuyability', () => {
         error: null,
       });
 
-      const { result } = renderHook(() => useTokenBuyability(getMockToken()));
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokenBuyability(getMockToken()),
+      );
 
       // V2 enabled: uses only V2 controller tokens, no legacy fallback
       expect(result.current.isBuyable).toBe(false);
@@ -294,10 +502,42 @@ describe('useTokenBuyability', () => {
         error: null,
       });
 
-      const { result } = renderHook(() => useTokenBuyability(getMockToken()));
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokenBuyability(getMockToken()),
+      );
 
       // V2 controller has tokens but NOT this one: not buyable (ignores legacy)
       expect(result.current.isBuyable).toBe(false);
     });
   });
+
+  describe('single token wrapper contract', () => {
+    it('returns the same result as batch buyability for one token', () => {
+      const token = getMockToken();
+      setupV1Mocks();
+      mockUseRampTokens.mockReturnValue({
+        allTokens: [
+          getMockRampToken({
+            assetId:
+              'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f',
+            tokenSupported: true,
+          }),
+        ],
+        isLoading: false,
+      } as UseRampTokensResult);
+
+      const { result } = renderHook(() =>
+        tokenBuyabilityModule.useTokenBuyability(token),
+      );
+      const { result: batchResult } = renderHook(() =>
+        tokenBuyabilityModule.useTokensBuyability([token]),
+      );
+
+      const tokenKey = tokenBuyabilityModule.getTokenBuyabilityKey(token);
+      expect(result.current.isBuyable).toBe(
+        batchResult.current.buyabilityByTokenKey[tokenKey] ?? false,
+      );
+      expect(result.current.isLoading).toBe(batchResult.current.isLoading);
+    });
+  });
 });
diff --git a/app/components/UI/Ramp/hooks/useTokenBuyability.ts b/app/components/UI/Ramp/hooks/useTokenBuyability.ts
index c59630abdcbe..aa9c48c33915 100644
--- a/app/components/UI/Ramp/hooks/useTokenBuyability.ts
+++ b/app/components/UI/Ramp/hooks/useTokenBuyability.ts
@@ -1,5 +1,10 @@
 import { useMemo } from 'react';
-import { Hex, isCaipChainId, isCaipAssetType } from '@metamask/utils';
+import {
+  Hex,
+  isCaipChainId,
+  isCaipAssetType,
+  isHexString,
+} from '@metamask/utils';
 import { TokenI } from '../../Tokens/types';
 import { useRampTokens } from './useRampTokens';
 import { useRampsTokens } from './useRampsTokens';
@@ -13,6 +18,17 @@ export interface UseTokenBuyabilityResult {
   isLoading: boolean;
 }
 
+interface UseTokensBuyabilityResult {
+  buyabilityByTokenKey: Record<string, boolean>;
+  isLoading: boolean;
+}
+
+interface BuyabilityTokenSource {
+  assetId?: string;
+  chainId?: string;
+  tokenSupported?: boolean;
+}
+
 /**
  * Builds the CAIP-19 assetId for a token, matching the format used by
  * useTokenActions.onBuy when navigating to the ramp flow.
@@ -31,44 +47,105 @@ function buildRampAssetId(token: TokenI): string | undefined {
   }
 }
 
+function getTokenCaipChainId(token: TokenI): string {
+  if (!token.chainId) {
+    return 'unknown-chain';
+  }
+
+  if (isCaipChainId(token.chainId)) {
+    return token.chainId;
+  }
+
+  if (isHexString(token.chainId)) {
+    return toEvmCaipChainId(token.chainId as Hex);
+  }
+
+  return token.chainId;
+}
+
+export function getTokenBuyabilityKey(token: TokenI): string {
+  const caipChainId = getTokenCaipChainId(token);
+  return `${caipChainId}:${token.address.toLowerCase()}`;
+}
+
+function getIsTokenBuyable(
+  token: TokenI,
+  rampsTokens: BuyabilityTokenSource[] | null,
+): boolean {
+  if (!rampsTokens) {
+    return false;
+  }
+
+  const chainId = getTokenCaipChainId(token);
+  const assetId = buildRampAssetId(token);
+  const isNative = token.isNative ?? false;
+
+  const match = rampsTokens.find((rampToken) => {
+    if (!rampToken.assetId) {
+      return false;
+    }
+
+    if (isNative) {
+      return (
+        rampToken.chainId === chainId && rampToken.assetId.includes('/slip44:')
+      );
+    }
+
+    return assetId
+      ? rampToken.assetId.toLowerCase() === assetId.toLowerCase()
+      : false;
+  });
+
+  return match?.tokenSupported ?? false;
+}
+
 /**
- * Hook that determines if a token can be bought via ramp services.
+ * Hook that determines if tokens can be bought via ramp services.
  * When unified V2 is enabled, checks against the RampsController's token list.
  * When V2 is disabled, uses the legacy token cache API.
  */
-export const useTokenBuyability = (token: TokenI): UseTokenBuyabilityResult => {
+export const useTokensBuyability = (
+  tokens: TokenI[],
+): UseTokensBuyabilityResult => {
   const isV2Enabled = useRampsUnifiedV2Enabled();
   const { allTokens: legacyAllTokens, isLoading: legacyLoading } =
-    useRampTokens();
+    useRampTokens({
+      fetchOnMount: !isV2Enabled,
+    });
   const { tokens: controllerTokens, isLoading: controllerLoading } =
     useRampsTokens();
 
   const isLoading = isV2Enabled ? controllerLoading : legacyLoading;
 
-  const isBuyable = useMemo(() => {
-    const tokens = isV2Enabled ? controllerTokens?.allTokens : legacyAllTokens;
-    if (!tokens) return false;
-
-    const chainId = isCaipChainId(token.chainId)
-      ? token.chainId
-      : toEvmCaipChainId(token.chainId as Hex);
-    const assetId = buildRampAssetId(token);
-    const isNative = token.isNative ?? false;
-
-    const match = tokens.find((tok) => {
-      if (!tok.assetId) return false;
-      if (isNative) {
-        return tok.chainId === chainId && tok.assetId.includes('/slip44:');
-      }
-      return assetId
-        ? tok.assetId.toLowerCase() === assetId.toLowerCase()
-        : false;
-    });
+  const rampsTokens = isV2Enabled
+    ? controllerTokens?.allTokens
+    : legacyAllTokens;
+  const buyabilityByTokenKey = useMemo(
+    () =>
+      tokens.reduce<Record<string, boolean>>((accumulator, token) => {
+        const tokenKey = getTokenBuyabilityKey(token);
+        accumulator[tokenKey] = getIsTokenBuyable(token, rampsTokens ?? null);
+        return accumulator;
+      }, {}),
+    [tokens, rampsTokens],
+  );
+
+  return { buyabilityByTokenKey, isLoading };
+};
+
+/**
+ * Hook that determines if a token can be bought via ramp services.
+ * Wrapper around useTokensBuyability for backwards compatibility.
+ */
+export const useTokenBuyability = (token: TokenI): UseTokenBuyabilityResult => {
+  const memoizedTokens = useMemo(() => [token], [token]);
+
+  const { buyabilityByTokenKey, isLoading } =
+    useTokensBuyability(memoizedTokens);
 
-    return match?.tokenSupported ?? false;
-  }, [isV2Enabled, controllerTokens, legacyAllTokens, token]);
+  const tokenKey = getTokenBuyabilityKey(token);
 
-  return { isBuyable, isLoading };
+  return { isBuyable: buyabilityByTokenKey[tokenKey] ?? false, isLoading };
 };
 
 export default useTokenBuyability;
diff --git a/app/components/Views/ActivityView/ActivitiesView.testIds.ts b/app/components/Views/ActivityView/ActivitiesView.testIds.ts
index 68e8f9fabad4..b9b623cac23a 100644
--- a/app/components/Views/ActivityView/ActivitiesView.testIds.ts
+++ b/app/components/Views/ActivityView/ActivitiesView.testIds.ts
@@ -7,6 +7,7 @@ function getSentUnitMessage(unit: string) {
 export const ActivitiesViewSelectorsIDs = {
   CONTAINER: 'transactions-container',
   TABS_CONTAINER: 'activity-view-tabs',
+  TRANSFER_TAB: 'activity-view-tabs-bar-tab-1',
 };
 
 export const ActivitiesViewSelectorsText = {
diff --git a/app/controllers/perps/PerpsController.test.ts b/app/controllers/perps/PerpsController.test.ts
index 3875eefac187..49879d9df4dd 100644
--- a/app/controllers/perps/PerpsController.test.ts
+++ b/app/controllers/perps/PerpsController.test.ts
@@ -516,8 +516,8 @@ describe('PerpsController', () => {
     });
 
     it('reads current RemoteFeatureFlagController state during construction', () => {
-      // Given: A mock messenger that tracks calls
-      const mockCall = jest.fn().mockImplementation((action: string) => {
+      // Given: A messenger that returns remote feature flags state
+      const testMockCall = jest.fn().mockImplementation((action: string) => {
         if (action === 'RemoteFeatureFlagController:getState') {
           return {
             remoteFeatureFlags: {
@@ -529,24 +529,25 @@ describe('PerpsController', () => {
         }
         return undefined;
       });
+      const testMessenger = createMockMessenger({ call: testMockCall });
 
       // When: Controller is constructed
       const testController = new TestablePerpsController({
-        messenger: createMockMessenger({ call: mockCall }),
+        messenger: testMessenger,
         state: getDefaultPerpsControllerState(),
         infrastructure: createMockInfrastructure(),
       });
 
-      // Then: Should have called to get RemoteFeatureFlagController state
+      // Then: Should have called to get RemoteFeatureFlagController state via messenger
       expect(testController).toBeDefined();
-      expect(mockCall).toHaveBeenCalledWith(
+      expect(testMockCall).toHaveBeenCalledWith(
         'RemoteFeatureFlagController:getState',
       );
     });
 
     it('applies remote blocked regions when available during construction', () => {
-      // Given: Remote feature flags with blocked regions
-      const mockCall = jest.fn().mockImplementation((action: string) => {
+      // Given: Messenger that returns remote feature flags with blocked regions
+      const testMockCall = jest.fn().mockImplementation((action: string) => {
         if (action === 'RemoteFeatureFlagController:getState') {
           return {
             remoteFeatureFlags: {
@@ -561,7 +562,7 @@ describe('PerpsController', () => {
 
       // When: Controller is constructed
       const testController = new TestablePerpsController({
-        messenger: createMockMessenger({ call: mockCall }),
+        messenger: createMockMessenger({ call: testMockCall }),
         state: getDefaultPerpsControllerState(),
         infrastructure: createMockInfrastructure(),
         clientConfig: {
@@ -604,8 +605,8 @@ describe('PerpsController', () => {
     });
 
     it('never downgrade from remote to fallback regions', () => {
-      // Given: Remote feature flags with blocked regions
-      const mockCall = jest.fn().mockImplementation((action: string) => {
+      // Given: Messenger that returns remote feature flags with blocked regions
+      const testMockCall = jest.fn().mockImplementation((action: string) => {
         if (action === 'RemoteFeatureFlagController:getState') {
           return {
             remoteFeatureFlags: {
@@ -620,7 +621,7 @@ describe('PerpsController', () => {
 
       // When: Controller is constructed with both remote and fallback
       const testController = new TestablePerpsController({
-        messenger: createMockMessenger({ call: mockCall }),
+        messenger: createMockMessenger({ call: testMockCall }),
         state: getDefaultPerpsControllerState(),
         infrastructure: createMockInfrastructure(),
         clientConfig: {
@@ -643,16 +644,16 @@ describe('PerpsController', () => {
     });
 
     it('continues initialization when RemoteFeatureFlagController state call throws error', () => {
-      const mockCall = jest.fn().mockImplementation((action: string) => {
+      const testInfrastructure = createMockInfrastructure();
+      const testMockCall = jest.fn().mockImplementation((action: string) => {
         if (action === 'RemoteFeatureFlagController:getState') {
           throw new Error('RemoteFeatureFlagController not ready');
         }
         return undefined;
       });
-      const testInfrastructure = createMockInfrastructure();
 
       const testController = new TestablePerpsController({
-        messenger: createMockMessenger({ call: mockCall }),
+        messenger: createMockMessenger({ call: testMockCall }),
         state: getDefaultPerpsControllerState(),
         infrastructure: testInfrastructure,
         clientConfig: {
@@ -2388,9 +2389,9 @@ describe('PerpsController', () => {
     const mockTransactionMeta = { id: 'tx-meta-123' };
     const mockTxHash = '0xhash123';
 
-    // Local messenger mock for depositWithConfirmation tests
-    let depositMessengerMock: jest.Mock;
+    let depositInfrastructure: jest.Mocked<PerpsPlatformDependencies>;
     let depositController: TestablePerpsController;
+    let depositMockCall: jest.Mock;
 
     beforeEach(() => {
       // Mock DepositService
@@ -2402,38 +2403,42 @@ describe('PerpsController', () => {
           currentDepositId: mockDepositId,
         });
 
-      // Create a messenger mock that handles network and transaction actions
-      depositMessengerMock = jest.fn().mockImplementation((action: string) => {
-        if (action === 'RemoteFeatureFlagController:getState') {
-          return {
-            remoteFeatureFlags: {
-              perpsPerpTradingGeoBlockedCountriesV2: {
-                blockedRegions: [],
+      // Create infrastructure mock (controllers no longer on infra)
+      depositInfrastructure = createMockInfrastructure();
+
+      // Create messenger mock that handles network + transaction + account controller calls
+      depositMockCall = jest
+        .fn()
+        .mockImplementation((action: string, ..._args: unknown[]) => {
+          if (action === 'RemoteFeatureFlagController:getState') {
+            return {
+              remoteFeatureFlags: {
+                perpsPerpTradingGeoBlockedCountriesV2: { blockedRegions: [] },
               },
-            },
-          };
-        }
-        if (action === 'NetworkController:findNetworkClientIdByChainId') {
-          return mockNetworkClientId;
-        }
-        if (action === 'TransactionController:addTransaction') {
-          return Promise.resolve({
-            result: Promise.resolve(mockTxHash),
-            transactionMeta: mockTransactionMeta,
-          });
-        }
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [
-            {
-              address: mockTransaction.from,
-              type: 'eip155:eoa',
-            },
-          ];
-        }
-        return undefined;
-      });
+            };
+          }
+          if (
+            action ===
+            'AccountTreeController:getAccountsFromSelectedAccountGroup'
+          ) {
+            return [
+              {
+                address: '0x1234567890123456789012345678901234567890',
+                type: 'eip155:eoa',
+              },
+            ];
+          }
+          if (action === 'NetworkController:findNetworkClientIdByChainId') {
+            return mockNetworkClientId;
+          }
+          if (action === 'TransactionController:addTransaction') {
+            return Promise.resolve({
+              result: Promise.resolve(mockTxHash),
+              transactionMeta: mockTransactionMeta,
+            });
+          }
+          return undefined;
+        });
 
       Engine.context.TransactionController.estimateGasFee = jest
         .fn()
@@ -2463,11 +2468,11 @@ describe('PerpsController', () => {
         },
       };
 
-      // Create a controller with the custom messenger for this test suite
+      // Create a controller with the custom infrastructure for this test suite
       depositController = new TestablePerpsController({
-        messenger: createMockMessenger({ call: depositMessengerMock }),
+        messenger: createMockMessenger({ call: depositMockCall }),
         state: getDefaultPerpsControllerState(),
-        infrastructure: createMockInfrastructure(),
+        infrastructure: depositInfrastructure,
       });
     });
 
@@ -2515,7 +2520,7 @@ describe('PerpsController', () => {
 
       await depositController.depositWithConfirmation({ amount: '100' });
 
-      expect(depositMessengerMock).toHaveBeenCalledWith(
+      expect(depositMockCall).toHaveBeenCalledWith(
         'NetworkController:findNetworkClientIdByChainId',
         mockAssetChainId,
       );
@@ -2529,7 +2534,7 @@ describe('PerpsController', () => {
 
       await depositController.depositWithConfirmation({ amount: '100' });
 
-      expect(depositMessengerMock).toHaveBeenCalledWith(
+      expect(depositMockCall).toHaveBeenCalledWith(
         'TransactionController:addTransaction',
         mockTransaction,
         {
@@ -2579,17 +2584,28 @@ describe('PerpsController', () => {
         new Map([['hyperliquid', mockProvider]]),
       );
       const mockError = new Error('Network client not found');
-      depositMessengerMock.mockImplementation((action: string) => {
-        if (action === 'NetworkController:findNetworkClientIdByChainId') {
-          throw mockError;
-        }
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [{ address: mockTransaction.from, type: 'eip155:eoa' }];
-        }
-        return undefined;
-      });
+      depositMockCall.mockImplementation(
+        (action: string, ..._args: unknown[]) => {
+          if (
+            action ===
+            'AccountTreeController:getAccountsFromSelectedAccountGroup'
+          ) {
+            return [
+              {
+                address: '0x1234567890123456789012345678901234567890',
+                type: 'eip155:eoa',
+              },
+            ];
+          }
+          if (action === 'NetworkController:findNetworkClientIdByChainId') {
+            throw mockError;
+          }
+          if (action === 'RemoteFeatureFlagController:getState') {
+            return { remoteFeatureFlags: {} };
+          }
+          return undefined;
+        },
+      );
 
       await expect(
         depositController.depositWithConfirmation({ amount: '100' }),
@@ -2601,17 +2617,28 @@ describe('PerpsController', () => {
       depositController.testSetProviders(
         new Map([['hyperliquid', mockProvider]]),
       );
-      depositMessengerMock.mockImplementation((action: string) => {
-        if (action === 'NetworkController:findNetworkClientIdByChainId') {
+      depositMockCall.mockImplementation(
+        (action: string, ..._args: unknown[]) => {
+          if (
+            action ===
+            'AccountTreeController:getAccountsFromSelectedAccountGroup'
+          ) {
+            return [
+              {
+                address: '0x1234567890123456789012345678901234567890',
+                type: 'eip155:eoa',
+              },
+            ];
+          }
+          if (action === 'NetworkController:findNetworkClientIdByChainId') {
+            return undefined;
+          }
+          if (action === 'RemoteFeatureFlagController:getState') {
+            return { remoteFeatureFlags: {} };
+          }
           return undefined;
-        }
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [{ address: mockTransaction.from, type: 'eip155:eoa' }];
-        }
-        return undefined;
-      });
+        },
+      );
 
       await expect(
         depositController.depositWithConfirmation({ amount: '100' }),
@@ -2632,20 +2659,31 @@ describe('PerpsController', () => {
         new Map([['hyperliquid', mockProvider]]),
       );
       const mockError = new Error('Transaction failed');
-      depositMessengerMock.mockImplementation((action: string) => {
-        if (action === 'NetworkController:findNetworkClientIdByChainId') {
-          return mockNetworkClientId;
-        }
-        if (action === 'TransactionController:addTransaction') {
-          return Promise.reject(mockError);
-        }
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [{ address: mockTransaction.from, type: 'eip155:eoa' }];
-        }
-        return undefined;
-      });
+      depositMockCall.mockImplementation(
+        (action: string, ..._args: unknown[]) => {
+          if (
+            action ===
+            'AccountTreeController:getAccountsFromSelectedAccountGroup'
+          ) {
+            return [
+              {
+                address: '0x1234567890123456789012345678901234567890',
+                type: 'eip155:eoa',
+              },
+            ];
+          }
+          if (action === 'TransactionController:addTransaction') {
+            return Promise.reject(mockError);
+          }
+          if (action === 'NetworkController:findNetworkClientIdByChainId') {
+            return mockNetworkClientId;
+          }
+          if (action === 'RemoteFeatureFlagController:getState') {
+            return { remoteFeatureFlags: {} };
+          }
+          return undefined;
+        },
+      );
 
       await expect(
         depositController.depositWithConfirmation({ amount: '100' }),
@@ -2661,20 +2699,31 @@ describe('PerpsController', () => {
         state.lastDepositTransactionId = 'old-tx-id';
       });
       const mockError = new Error('Network error');
-      depositMessengerMock.mockImplementation((action: string) => {
-        if (action === 'NetworkController:findNetworkClientIdByChainId') {
-          return mockNetworkClientId;
-        }
-        if (action === 'TransactionController:addTransaction') {
-          return Promise.reject(mockError);
-        }
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [{ address: mockTransaction.from, type: 'eip155:eoa' }];
-        }
-        return undefined;
-      });
+      depositMockCall.mockImplementation(
+        (action: string, ..._args: unknown[]) => {
+          if (
+            action ===
+            'AccountTreeController:getAccountsFromSelectedAccountGroup'
+          ) {
+            return [
+              {
+                address: '0x1234567890123456789012345678901234567890',
+                type: 'eip155:eoa',
+              },
+            ];
+          }
+          if (action === 'TransactionController:addTransaction') {
+            return Promise.reject(mockError);
+          }
+          if (action === 'NetworkController:findNetworkClientIdByChainId') {
+            return mockNetworkClientId;
+          }
+          if (action === 'RemoteFeatureFlagController:getState') {
+            return { remoteFeatureFlags: {} };
+          }
+          return undefined;
+        },
+      );
 
       await expect(
         depositController.depositWithConfirmation({ amount: '100' }),
@@ -2692,20 +2741,31 @@ describe('PerpsController', () => {
         state.lastDepositTransactionId = 'old-tx-id';
       });
       const mockError = new Error('User denied transaction signature');
-      depositMessengerMock.mockImplementation((action: string) => {
-        if (action === 'NetworkController:findNetworkClientIdByChainId') {
-          return mockNetworkClientId;
-        }
-        if (action === 'TransactionController:addTransaction') {
-          return Promise.reject(mockError);
-        }
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [{ address: mockTransaction.from, type: 'eip155:eoa' }];
-        }
-        return undefined;
-      });
+      depositMockCall.mockImplementation(
+        (action: string, ..._args: unknown[]) => {
+          if (
+            action ===
+            'AccountTreeController:getAccountsFromSelectedAccountGroup'
+          ) {
+            return [
+              {
+                address: '0x1234567890123456789012345678901234567890',
+                type: 'eip155:eoa',
+              },
+            ];
+          }
+          if (action === 'TransactionController:addTransaction') {
+            return Promise.reject(mockError);
+          }
+          if (action === 'NetworkController:findNetworkClientIdByChainId') {
+            return mockNetworkClientId;
+          }
+          if (action === 'RemoteFeatureFlagController:getState') {
+            return { remoteFeatureFlags: {} };
+          }
+          return undefined;
+        },
+      );
 
       await expect(
         depositController.depositWithConfirmation({ amount: '100' }),
@@ -2864,8 +2924,8 @@ describe('PerpsController', () => {
         placeOrder: true,
       });
 
-      // placeOrder uses messenger-based submitTransaction with perpsDepositAndOrder type
-      expect(depositMessengerMock).toHaveBeenCalledWith(
+      // placeOrder uses messenger-based addTransaction with perpsDepositAndOrder type
+      expect(depositMockCall).toHaveBeenCalledWith(
         'TransactionController:addTransaction',
         mockTransaction,
         {
@@ -2876,7 +2936,7 @@ describe('PerpsController', () => {
         },
       );
       // Should NOT also call with perpsDeposit type
-      expect(depositMessengerMock).not.toHaveBeenCalledWith(
+      expect(depositMockCall).not.toHaveBeenCalledWith(
         'TransactionController:addTransaction',
         expect.anything(),
         expect.objectContaining({ type: 'perpsDeposit' }),
@@ -2939,23 +2999,34 @@ describe('PerpsController', () => {
 
       // Mock messenger to succeed initially, but result promise rejects
       const mockError = new Error('Network error occurred');
-      depositMessengerMock.mockImplementation((action: string) => {
-        if (action === 'NetworkController:findNetworkClientIdByChainId') {
-          return mockNetworkClientId;
-        }
-        if (action === 'TransactionController:addTransaction') {
-          return Promise.resolve({
-            result: Promise.reject(mockError),
-            transactionMeta: mockTransactionMeta,
-          });
-        }
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [{ address: mockTransaction.from, type: 'eip155:eoa' }];
-        }
-        return undefined;
-      });
+      depositMockCall.mockImplementation(
+        (action: string, ..._args: unknown[]) => {
+          if (
+            action ===
+            'AccountTreeController:getAccountsFromSelectedAccountGroup'
+          ) {
+            return [
+              {
+                address: '0x1234567890123456789012345678901234567890',
+                type: 'eip155:eoa',
+              },
+            ];
+          }
+          if (action === 'TransactionController:addTransaction') {
+            return Promise.resolve({
+              result: Promise.reject(mockError),
+              transactionMeta: mockTransactionMeta,
+            });
+          }
+          if (action === 'NetworkController:findNetworkClientIdByChainId') {
+            return mockNetworkClientId;
+          }
+          if (action === 'RemoteFeatureFlagController:getState') {
+            return { remoteFeatureFlags: {} };
+          }
+          return undefined;
+        },
+      );
 
       const { result } = await depositController.depositWithConfirmation({
         amount: '100',
@@ -3005,24 +3076,34 @@ describe('PerpsController', () => {
         jest.clearAllMocks();
         const mockError = new Error(message);
         // Mock messenger to succeed initially, but result promise rejects with user cancellation
-        depositMessengerMock.mockImplementation((action: string) => {
-          if (action === 'NetworkController:findNetworkClientIdByChainId') {
-            return mockNetworkClientId;
-          }
-          if (action === 'TransactionController:addTransaction') {
-            return Promise.resolve({
-              result: Promise.reject(mockError),
-              transactionMeta: mockTransactionMeta,
-            });
-          }
-          if (
-            action ===
-            'AccountTreeController:getAccountsFromSelectedAccountGroup'
-          ) {
-            return [{ address: mockTransaction.from, type: 'eip155:eoa' }];
-          }
-          return undefined;
-        });
+        depositMockCall.mockImplementation(
+          (action: string, ..._args: unknown[]) => {
+            if (
+              action ===
+              'AccountTreeController:getAccountsFromSelectedAccountGroup'
+            ) {
+              return [
+                {
+                  address: '0x1234567890123456789012345678901234567890',
+                  type: 'eip155:eoa',
+                },
+              ];
+            }
+            if (action === 'TransactionController:addTransaction') {
+              return Promise.resolve({
+                result: Promise.reject(mockError),
+                transactionMeta: mockTransactionMeta,
+              });
+            }
+            if (action === 'NetworkController:findNetworkClientIdByChainId') {
+              return mockNetworkClientId;
+            }
+            if (action === 'RemoteFeatureFlagController:getState') {
+              return { remoteFeatureFlags: {} };
+            }
+            return undefined;
+          },
+        );
 
         const { result } = await depositController.depositWithConfirmation({
           amount: '100',
@@ -4313,8 +4394,13 @@ describe('PerpsController', () => {
     });
 
     it('switches to myx provider successfully', async () => {
-      // Enable MYX feature flag via remote flags + version gating
-      const mockCall = jest.fn().mockImplementation((action: string) => {
+      // Create controller with MYX-enabled mocks
+      const myxInfrastructure = createMockInfrastructure();
+      (
+        myxInfrastructure.featureFlags.validateVersionGated as jest.Mock
+      ).mockReturnValue(true);
+      // Enable MYX feature flag via messenger
+      const myxMockCall = jest.fn().mockImplementation((action: string) => {
         if (action === 'RemoteFeatureFlagController:getState') {
           return {
             remoteFeatureFlags: {
@@ -4329,14 +4415,8 @@ describe('PerpsController', () => {
         return undefined;
       });
 
-      // Create controller with MYX-enabled mocks
-      const myxInfrastructure = createMockInfrastructure();
-      (
-        myxInfrastructure.featureFlags.validateVersionGated as jest.Mock
-      ).mockReturnValue(true);
-
       const myxController = new TestablePerpsController({
-        messenger: createMockMessenger({ call: mockCall }),
+        messenger: createMockMessenger({ call: myxMockCall }),
         state: getDefaultPerpsControllerState(),
         infrastructure: myxInfrastructure,
       });
diff --git a/app/controllers/perps/PerpsController.ts b/app/controllers/perps/PerpsController.ts
index 108a1fa8ce0e..13160e64ba0f 100644
--- a/app/controllers/perps/PerpsController.ts
+++ b/app/controllers/perps/PerpsController.ts
@@ -1,7 +1,3 @@
-import type {
-  AccountTreeControllerGetAccountsFromSelectedAccountGroupAction,
-  AccountTreeControllerSelectedAccountGroupChangeEvent,
-} from '@metamask/account-tree-controller';
 import {
   BaseController,
   ControllerGetStateAction,
@@ -10,29 +6,7 @@ import {
 } from '@metamask/base-controller';
 import type { StateChangeListener } from '@metamask/base-controller';
 import { ORIGIN_METAMASK } from '@metamask/controller-utils';
-import type {
-  KeyringControllerGetStateAction,
-  KeyringControllerSignTypedMessageAction,
-} from '@metamask/keyring-controller';
 import type { Messenger } from '@metamask/messenger';
-import type {
-  NetworkControllerGetStateAction,
-  NetworkControllerGetNetworkClientByIdAction,
-  NetworkControllerFindNetworkClientIdByChainIdAction,
-} from '@metamask/network-controller';
-import type { AuthenticationController } from '@metamask/profile-sync-controller';
-import type {
-  RemoteFeatureFlagControllerState,
-  RemoteFeatureFlagControllerStateChangeEvent,
-  RemoteFeatureFlagControllerGetStateAction,
-} from '@metamask/remote-feature-flag-controller';
-import {
-  TransactionControllerAddTransactionAction,
-  TransactionControllerTransactionConfirmedEvent,
-  TransactionControllerTransactionFailedEvent,
-  TransactionControllerTransactionSubmittedEvent,
-  TransactionType,
-} from '@metamask/transaction-controller';
 import type { Json } from '@metamask/utils';
 import { v4 as uuidv4 } from 'uuid';
 
@@ -129,7 +103,14 @@ import type {
   PerpsActiveProviderMode,
   PerpsProviderType,
   PerpsSelectedPaymentToken,
+  PerpsRemoteFeatureFlagState,
+  PerpsTransactionParams,
+  PerpsAddTransactionOptions,
 } from './types';
+import type {
+  PerpsControllerAllowedActions,
+  PerpsControllerAllowedEvents,
+} from './types/messenger';
 import type { CandleData } from './types/perps-types';
 import {
   LastTransactionResult,
@@ -745,36 +726,14 @@ export type PerpsControllerActions =
     };
 
 /**
- * External actions the PerpsController can call via messenger
- */
-export type AllowedActions =
-  | NetworkControllerGetStateAction
-  | AuthenticationController.AuthenticationControllerGetBearerToken
-  | RemoteFeatureFlagControllerGetStateAction
-  | AccountTreeControllerGetAccountsFromSelectedAccountGroupAction
-  | KeyringControllerGetStateAction
-  | KeyringControllerSignTypedMessageAction
-  | NetworkControllerGetNetworkClientByIdAction
-  | NetworkControllerFindNetworkClientIdByChainIdAction
-  | TransactionControllerAddTransactionAction;
-
-/**
- * External events the PerpsController can subscribe to
- */
-export type AllowedEvents =
-  | TransactionControllerTransactionSubmittedEvent
-  | TransactionControllerTransactionConfirmedEvent
-  | TransactionControllerTransactionFailedEvent
-  | RemoteFeatureFlagControllerStateChangeEvent
-  | AccountTreeControllerSelectedAccountGroupChangeEvent;
-
-/**
- * PerpsController messenger constraints
+ * PerpsController messenger constraints.
+ * Includes both PerpsController's own actions/events and
+ * allowed actions/events from external controllers.
  */
 export type PerpsControllerMessenger = Messenger<
   'PerpsController',
-  PerpsControllerActions | AllowedActions,
-  PerpsControllerEvents | AllowedEvents
+  PerpsControllerActions | PerpsControllerAllowedActions,
+  PerpsControllerEvents | PerpsControllerAllowedEvents
 >;
 
 /**
@@ -786,7 +745,8 @@ export type PerpsControllerOptions = {
   clientConfig?: PerpsControllerConfig;
   /**
    * Platform-specific dependencies (required)
-   * Provides logging, metrics, tracing, stream management, and account utilities.
+   * Provides logging, metrics, tracing, stream management, and rewards.
+   * Cross-controller communication uses the messenger pattern.
    * Must be provided by the platform (mobile/extension) at instantiation time.
    */
   infrastructure: PerpsPlatformDependencies;
@@ -970,8 +930,8 @@ export class PerpsController extends BaseController<
       infrastructure,
     };
 
-    // Instantiate services with platform dependencies and messenger
-    // Services that need inter-controller communication receive the messenger
+    // Instantiate services with platform dependencies
+    // Services that need cross-controller access receive the messenger
     this.#tradingService = new TradingService(infrastructure);
     this.#marketDataService = new MarketDataService(infrastructure);
     this.#accountService = new AccountService(infrastructure, messenger);
@@ -1026,11 +986,12 @@ export class PerpsController extends BaseController<
       );
     }
 
-    const featureFlagHandler =
-      this.refreshEligibilityOnFeatureFlagChange.bind(this);
+    // Subscribe for the full controller lifetime — intentionally not stored;
+    // geo-blocking and HIP-3 flag propagation must remain active across
+    // disconnect → reconnect cycles and must never be torn down.
     this.messenger.subscribe(
       'RemoteFeatureFlagController:stateChange',
-      featureFlagHandler,
+      this.refreshEligibilityOnFeatureFlagChange.bind(this),
     );
 
     this.providers = new Map();
@@ -1183,27 +1144,20 @@ export class PerpsController extends BaseController<
    * @returns The transaction result containing a hash promise and transaction metadata.
    */
   async #submitTransaction(
-    txParams: {
-      from: string;
-      to?: string;
-      value?: string;
-      data?: string;
-      gas?: string;
-    },
-    options: {
-      networkClientId: string;
-      origin?: string;
-      type?: TransactionType;
-      skipInitialGasEstimate?: boolean;
-    },
+    txParams: PerpsTransactionParams,
+    options: PerpsAddTransactionOptions,
   ): Promise<{
     result: Promise<string>;
     transactionMeta: { id: string; hash?: string };
   }> {
+    // Cast needed: PerpsController uses loose string types for txParams/options
+    // while TransactionController uses strict branded types (TransactionParams, AddTransactionOptions)
     return this.messenger.call(
       'TransactionController:addTransaction',
-      txParams,
-      options,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      txParams as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      options as any,
     );
   }
 
@@ -1256,7 +1210,7 @@ export class PerpsController extends BaseController<
    * @param remoteFeatureFlagControllerState - State from RemoteFeatureFlagController.
    */
   protected refreshEligibilityOnFeatureFlagChange(
-    remoteFeatureFlagControllerState: RemoteFeatureFlagControllerState,
+    remoteFeatureFlagControllerState: PerpsRemoteFeatureFlagState,
   ): void {
     this.#featureFlagConfigurationService.refreshEligibility({
       remoteFeatureFlagControllerState,
@@ -1948,7 +1902,11 @@ export class PerpsController extends BaseController<
       currentDepositId = depositId;
 
       // Get current account address via messenger (outside of update() for proper typing)
-      const evmAccount = getSelectedEvmAccount(this.messenger);
+      const evmAccount = getSelectedEvmAccount(
+        this.messenger.call(
+          'AccountTreeController:getAccountsFromSelectedAccountGroup',
+        ),
+      );
       const accountAddress = evmAccount?.address ?? 'unknown';
 
       this.update((state) => {
@@ -1990,10 +1948,10 @@ export class PerpsController extends BaseController<
       };
 
       if (placeOrder) {
-        // Use messenger-based addTransaction to create transaction without navigating to confirmation screen
+        // Use addTransaction to create transaction without navigating to confirmation screen
         const addResult = await this.#submitTransaction(transaction, {
           ...defaultTransactionOptions,
-          type: TransactionType.perpsDepositAndOrder,
+          type: 'perpsDepositAndOrder',
         });
         transactionMeta = addResult.transactionMeta;
         // Return transaction ID immediately (fire-and-forget for caller)
@@ -2005,7 +1963,7 @@ export class PerpsController extends BaseController<
         // The promise will resolve when transaction completes or reject if cancelled/failed
         const submitResult = await this.#submitTransaction(transaction, {
           ...defaultTransactionOptions,
-          type: TransactionType.perpsDeposit,
+          type: 'perpsDeposit',
         });
         result = submitResult.result;
         transactionMeta = submitResult.transactionMeta;
@@ -2664,7 +2622,11 @@ export class PerpsController extends BaseController<
 
     // Watch for account changes via AccountTreeController
     const accountChangeHandler = (): void => {
-      const evmAccount = getSelectedEvmAccount(this.messenger);
+      const evmAccount = getSelectedEvmAccount(
+        this.messenger.call(
+          'AccountTreeController:getAccountsFromSelectedAccountGroup',
+        ),
+      );
       const currentAddress = evmAccount?.address ?? null;
 
       // If there's cached data from a different account (or no EVM account now), clear it
@@ -2816,7 +2778,11 @@ export class PerpsController extends BaseController<
     }
 
     // Get current user address
-    const evmAccount = getSelectedEvmAccount(this.messenger);
+    const evmAccount = getSelectedEvmAccount(
+      this.messenger.call(
+        'AccountTreeController:getAccountsFromSelectedAccountGroup',
+      ),
+    );
     if (!evmAccount?.address) {
       return;
     }
@@ -4328,9 +4294,7 @@ export class PerpsController extends BaseController<
       slPrice: params.slPrice,
       tpPrice: params.tpPrice,
       isTestnet: this.state.isTestnet,
-      context: this.#createServiceContext('reportOrderToDataLake', {
-        messenger: this.messenger,
-      }),
+      context: this.#createServiceContext('reportOrderToDataLake', {}),
       retryCount: params.retryCount,
       _traceId: params._traceId,
     });
diff --git a/app/controllers/perps/providers/HyperLiquidProvider.test.ts b/app/controllers/perps/providers/HyperLiquidProvider.test.ts
index 2a059bf46c83..6e1dd76373cc 100644
--- a/app/controllers/perps/providers/HyperLiquidProvider.test.ts
+++ b/app/controllers/perps/providers/HyperLiquidProvider.test.ts
@@ -300,6 +300,7 @@ const createMockExchangeClient = (overrides: Record<string, unknown> = {}) => ({
 // Create shared mock platform dependencies for provider tests
 const mockPlatformDependencies: PerpsPlatformDependencies =
   createMockInfrastructure();
+
 const mockMessenger = createMockMessenger();
 
 /**
diff --git a/app/controllers/perps/providers/HyperLiquidProvider.ts b/app/controllers/perps/providers/HyperLiquidProvider.ts
index 8ef0489c819c..1885529a67ad 100644
--- a/app/controllers/perps/providers/HyperLiquidProvider.ts
+++ b/app/controllers/perps/providers/HyperLiquidProvider.ts
@@ -27,7 +27,6 @@ import {
   WITHDRAWAL_CONSTANTS,
 } from '../constants/perpsConfig';
 import { PERPS_TRANSACTIONS_HISTORY_CONSTANTS } from '../constants/transactionsHistoryConfig';
-import type { PerpsControllerMessenger } from '../PerpsController';
 import { PERPS_ERROR_CODES } from '../perpsErrorCodes';
 import {
   HyperLiquidClientService,
@@ -106,6 +105,7 @@ import type {
   FrontendOrder,
   SpotMetaResponse,
 } from '../types/hyperliquid-types';
+import type { PerpsControllerMessengerBase } from '../types/messenger';
 import type { ExtendedAssetMeta, ExtendedPerpDex } from '../types/perps-types';
 import { aggregateAccountStates } from '../utils/accountUtils';
 import { ensureError } from '../utils/errorUtils';
@@ -333,6 +333,8 @@ export class HyperLiquidProvider implements PerpsProvider {
   // Promise-based lock to prevent race conditions in concurrent initialization
   #initializationPromise: Promise<void> | null = null;
 
+  readonly #messenger: PerpsControllerMessengerBase;
+
   constructor(options: {
     isTestnet?: boolean;
     hip3Enabled?: boolean;
@@ -340,10 +342,11 @@ export class HyperLiquidProvider implements PerpsProvider {
     blocklistMarkets?: string[];
     useDexAbstraction?: boolean;
     platformDependencies: PerpsPlatformDependencies;
-    messenger: PerpsControllerMessenger;
+    messenger: PerpsControllerMessengerBase;
     initialAssetMapping?: [string, number][];
   }) {
     this.#deps = options.platformDependencies;
+    this.#messenger = options.messenger;
     const isTestnet = options.isTestnet ?? false;
 
     // Dev-friendly defaults: Enable all markets by default for easier testing (discovery mode)
@@ -354,14 +357,16 @@ export class HyperLiquidProvider implements PerpsProvider {
     // Attempt native balance abstraction, fallback to programmatic transfer if unsupported
     this.#useDexAbstraction = options.useDexAbstraction ?? true;
 
-    // Initialize services with injected platform dependencies and messenger
+    // Initialize services with injected platform dependencies
     this.#clientService = new HyperLiquidClientService(this.#deps, {
       isTestnet,
     });
     this.#walletService = new HyperLiquidWalletService(
       this.#deps,
-      options.messenger,
-      { isTestnet },
+      this.#messenger,
+      {
+        isTestnet,
+      },
     );
     this.#subscriptionService = new HyperLiquidSubscriptionService(
       this.#clientService,
diff --git a/app/controllers/perps/services/AccountService.test.ts b/app/controllers/perps/services/AccountService.test.ts
index 128949908c89..934a202841b3 100644
--- a/app/controllers/perps/services/AccountService.test.ts
+++ b/app/controllers/perps/services/AccountService.test.ts
@@ -4,10 +4,7 @@ import {
   createMockInfrastructure,
   createMockMessenger,
 } from '../../../components/UI/Perps/__mocks__/serviceMocks';
-import type {
-  PerpsControllerState,
-  PerpsControllerMessenger,
-} from '../PerpsController';
+import type { PerpsControllerState } from '../PerpsController';
 import { PerpsAnalyticsEvent } from '../types';
 import type {
   PerpsProvider,
@@ -42,15 +39,15 @@ jest.mock('../perpsErrorCodes', () => ({
     WITHDRAW_FAILED: 'WITHDRAW_FAILED',
   },
 }));
-// Note: EVM account is now retrieved via dependency injection (deps.controllers.accounts.getSelectedEvmAccount)
-// The mock is set up via createMockInfrastructure() in serviceMocks.ts
+// Note: EVM account is now retrieved via messenger.call('AccountTreeController:getAccountsFromSelectedAccountGroup')
+// The mock is set up via createMockMessenger() in serviceMocks.ts
 
 describe('AccountService', () => {
   let mockProvider: jest.Mocked<PerpsProvider>;
   let mockContext: ServiceContext;
   let mockRefreshAccountState: jest.Mock;
   let mockDeps: PerpsPlatformDependencies;
-  let mockMessenger: jest.Mocked<PerpsControllerMessenger>;
+  let mockMessenger: ReturnType<typeof createMockMessenger>;
   let accountService: AccountService;
 
   const mockWithdrawParams: WithdrawParams = {
diff --git a/app/controllers/perps/services/AccountService.ts b/app/controllers/perps/services/AccountService.ts
index 56e1b31c9388..f6c121daa1e7 100644
--- a/app/controllers/perps/services/AccountService.ts
+++ b/app/controllers/perps/services/AccountService.ts
@@ -6,7 +6,6 @@ import {
 } from '../constants/eventNames';
 import { USDC_SYMBOL } from '../constants/hyperLiquidConfig';
 import { PERPS_CONSTANTS } from '../constants/perpsConfig';
-import type { PerpsControllerMessenger } from '../PerpsController';
 import { PERPS_ERROR_CODES } from '../perpsErrorCodes';
 import {
   PerpsAnalyticsEvent,
@@ -20,6 +19,7 @@ import type {
   PerpsPlatformDependencies,
 } from '../types';
 import type { ServiceContext } from './ServiceContext';
+import type { PerpsControllerMessengerBase } from '../types/messenger';
 import type { TransactionStatus } from '../types/transactionTypes';
 import { getSelectedEvmAccount } from '../utils/accountUtils';
 import { ensureError } from '../utils/errorUtils';
@@ -37,17 +37,17 @@ import { ensureError } from '../utils/errorUtils';
 export class AccountService {
   readonly #deps: PerpsPlatformDependencies;
 
-  readonly #messenger: PerpsControllerMessenger;
+  readonly #messenger: PerpsControllerMessengerBase;
 
   /**
    * Create a new AccountService instance
    *
    * @param deps - Platform dependencies for logging, metrics, etc.
-   * @param messenger - Messenger for inter-controller communication
+   * @param messenger - Controller messenger for cross-controller communication.
    */
   constructor(
     deps: PerpsPlatformDependencies,
-    messenger: PerpsControllerMessenger,
+    messenger: PerpsControllerMessengerBase,
   ) {
     this.#deps = deps;
     this.#messenger = messenger;
@@ -121,7 +121,11 @@ export class AccountService {
           const netAmount = Math.max(0, grossAmount - feeAmount);
 
           // Get current account address via messenger
-          const evmAccount = getSelectedEvmAccount(this.#messenger);
+          const evmAccount = getSelectedEvmAccount(
+            this.#messenger.call(
+              'AccountTreeController:getAccountsFromSelectedAccountGroup',
+            ),
+          );
           const accountAddress = evmAccount?.address ?? 'unknown';
 
           this.#deps.debugLogger.log(
diff --git a/app/controllers/perps/services/DataLakeService.test.ts b/app/controllers/perps/services/DataLakeService.test.ts
index 6ad5aff679b2..b45bc6e46aa8 100644
--- a/app/controllers/perps/services/DataLakeService.test.ts
+++ b/app/controllers/perps/services/DataLakeService.test.ts
@@ -4,7 +4,6 @@ import {
   createMockInfrastructure,
   createMockMessenger,
 } from '../../../components/UI/Perps/__mocks__/serviceMocks';
-import type { PerpsControllerMessenger } from '../PerpsController';
 import type { PerpsPlatformDependencies } from '../types';
 
 import { DataLakeService } from './DataLakeService';
@@ -21,12 +20,32 @@ global.setTimeout = jest.fn((fn: () => void) => {
 describe('DataLakeService', () => {
   let mockContext: ServiceContext;
   let mockDeps: jest.Mocked<PerpsPlatformDependencies>;
-  let mockMessenger: jest.Mocked<PerpsControllerMessenger>;
+  let mockMessenger: ReturnType<typeof createMockMessenger>;
   let dataLakeService: DataLakeService;
   const mockEvmAccount = createMockEvmAccount();
   const mockToken = 'mock-bearer-token';
 
+  /**
+   * Sets up the default messenger mock that returns a valid account and token.
+   * Called in beforeEach and after any mid-test jest.clearAllMocks().
+   */
+  function setupDefaultMessenger() {
+    (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
+      if (
+        action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
+      ) {
+        return [mockEvmAccount];
+      }
+      if (action === 'AuthenticationController:getBearerToken') {
+        return Promise.resolve(mockToken);
+      }
+      return undefined;
+    });
+  }
+
   beforeEach(() => {
+    jest.clearAllMocks();
+
     mockDeps = createMockInfrastructure();
     mockMessenger = createMockMessenger();
     dataLakeService = new DataLakeService(mockDeps, mockMessenger);
@@ -39,19 +58,7 @@ describe('DataLakeService', () => {
       },
     });
 
-    // Configure messenger to return expected values
-    (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
-      if (
-        action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-      ) {
-        return [mockEvmAccount];
-      }
-      if (action === 'AuthenticationController:getBearerToken') {
-        return Promise.resolve(mockToken);
-      }
-      return undefined;
-    });
-    jest.clearAllMocks();
+    setupDefaultMessenger();
   });
 
   afterEach(() => {
@@ -278,6 +285,8 @@ describe('DataLakeService', () => {
       expect(setTimeout).toHaveBeenCalledWith(expect.any(Function), 1000);
 
       jest.clearAllMocks();
+      setupDefaultMessenger();
+      (fetch as jest.Mock).mockRejectedValue(new Error('Network error'));
 
       await dataLakeService.reportOrder({
         action: 'open',
@@ -289,6 +298,8 @@ describe('DataLakeService', () => {
       expect(setTimeout).toHaveBeenCalledWith(expect.any(Function), 2000);
 
       jest.clearAllMocks();
+      setupDefaultMessenger();
+      (fetch as jest.Mock).mockRejectedValue(new Error('Network error'));
 
       await dataLakeService.reportOrder({
         action: 'open',
diff --git a/app/controllers/perps/services/DataLakeService.ts b/app/controllers/perps/services/DataLakeService.ts
index 0f217666a606..18c0162d1e1b 100644
--- a/app/controllers/perps/services/DataLakeService.ts
+++ b/app/controllers/perps/services/DataLakeService.ts
@@ -5,10 +5,10 @@ import {
   DATA_LAKE_API_CONFIG,
   PERPS_CONSTANTS,
 } from '../constants/perpsConfig';
-import type { PerpsControllerMessenger } from '../PerpsController';
 import { PerpsTraceNames, PerpsTraceOperations } from '../types';
 import type { PerpsPlatformDependencies } from '../types';
 import type { ServiceContext } from './ServiceContext';
+import type { PerpsControllerMessengerBase } from '../types/messenger';
 import { getSelectedEvmAccount } from '../utils/accountUtils';
 import { ensureError } from '../utils/errorUtils';
 
@@ -19,30 +19,29 @@ import { ensureError } from '../utils/errorUtils';
  * Implements exponential backoff retry logic and performance tracing.
  * Stateless service that operates purely on external API calls.
  *
- * Instance-based service with constructor injection of platform dependencies
- * and messenger for inter-controller communication.
+ * Instance-based service with constructor injection of platform dependencies.
  */
 export class DataLakeService {
   readonly #deps: PerpsPlatformDependencies;
 
-  readonly #messenger: PerpsControllerMessenger;
+  readonly #messenger: PerpsControllerMessengerBase;
 
   /**
    * Create a new DataLakeService instance
    *
    * @param deps - Platform dependencies for logging, metrics, etc.
-   * @param messenger - Messenger for inter-controller communication
+   * @param messenger - Controller messenger for cross-controller communication.
    */
   constructor(
     deps: PerpsPlatformDependencies,
-    messenger: PerpsControllerMessenger,
+    messenger: PerpsControllerMessengerBase,
   ) {
     this.#deps = deps;
     this.#messenger = messenger;
   }
 
   /**
-   * Get bearer token via messenger
+   * Get bearer token via DI authentication controller
    *
    * @returns The bearer token string for API authentication.
    */
@@ -132,7 +131,11 @@ export class DataLakeService {
 
     try {
       const token = await this.#getBearerToken();
-      const evmAccount = getSelectedEvmAccount(this.#messenger);
+      const evmAccount = getSelectedEvmAccount(
+        this.#messenger.call(
+          'AccountTreeController:getAccountsFromSelectedAccountGroup',
+        ),
+      );
 
       if (!evmAccount || !token) {
         this.#deps.debugLogger.log('DataLake API: Missing requirements', {
diff --git a/app/controllers/perps/services/DepositService.test.ts b/app/controllers/perps/services/DepositService.test.ts
index 547877920911..7b2dea0bdb10 100644
--- a/app/controllers/perps/services/DepositService.test.ts
+++ b/app/controllers/perps/services/DepositService.test.ts
@@ -7,7 +7,6 @@ import {
   createMockInfrastructure,
   createMockMessenger,
 } from '../../../components/UI/Perps/__mocks__/serviceMocks';
-import type { PerpsControllerMessenger } from '../PerpsController';
 import type { PerpsProvider, PerpsPlatformDependencies } from '../types';
 import { generateDepositId } from '../utils/idUtils';
 import { generateERC20TransferData } from '../utils/transferData';
@@ -37,7 +36,7 @@ jest.mock('@metamask/controller-utils', () => {
 describe('DepositService', () => {
   let mockProvider: jest.Mocked<PerpsProvider>;
   let mockDeps: jest.Mocked<PerpsPlatformDependencies>;
-  let mockMessenger: jest.Mocked<PerpsControllerMessenger>;
+  let mockMessenger: ReturnType<typeof createMockMessenger>;
   let service: DepositService;
   const mockEvmAccount = createMockEvmAccount();
   const mockDepositId = 'deposit-123';
@@ -164,7 +163,7 @@ describe('DepositService', () => {
       expect(result.transaction.data).toMatch(/^0xa9059cbb/);
     });
 
-    it('retrieves EVM account from selected account group via messenger', async () => {
+    it('retrieves EVM account from messenger via accountTree action', async () => {
       await service.prepareTransaction({
         provider: mockProvider,
       });
diff --git a/app/controllers/perps/services/DepositService.ts b/app/controllers/perps/services/DepositService.ts
index 496724e6db11..a4ffe31e5191 100644
--- a/app/controllers/perps/services/DepositService.ts
+++ b/app/controllers/perps/services/DepositService.ts
@@ -1,10 +1,13 @@
 import { toHex } from '@metamask/controller-utils';
-import type { TransactionParams } from '@metamask/transaction-controller';
 import { parseCaipAssetId } from '@metamask/utils';
 import type { Hex } from '@metamask/utils';
 
-import type { PerpsControllerMessenger } from '../PerpsController';
-import type { PerpsProvider, PerpsPlatformDependencies } from '../types';
+import type {
+  PerpsProvider,
+  PerpsPlatformDependencies,
+  PerpsTransactionParams,
+} from '../types';
+import type { PerpsControllerMessengerBase } from '../types/messenger';
 import { getSelectedEvmAccount } from '../utils/accountUtils';
 import { generateDepositId } from '../utils/idUtils';
 import { generateERC20TransferData } from '../utils/transferData';
@@ -25,17 +28,17 @@ const DEPOSIT_GAS_LIMIT = toHex(100000);
 export class DepositService {
   readonly #deps: PerpsPlatformDependencies;
 
-  readonly #messenger: PerpsControllerMessenger;
+  readonly #messenger: PerpsControllerMessengerBase;
 
   /**
    * Create a new DepositService instance
    *
    * @param deps - Platform dependencies for logging, metrics, etc.
-   * @param messenger - Messenger for inter-controller communication
+   * @param messenger - Controller messenger for cross-controller communication.
    */
   constructor(
     deps: PerpsPlatformDependencies,
-    messenger: PerpsControllerMessenger,
+    messenger: PerpsControllerMessengerBase,
   ) {
     this.#deps = deps;
     this.#messenger = messenger;
@@ -50,7 +53,7 @@ export class DepositService {
    * @returns Transaction data ready for TransactionController.addTransaction
    */
   async prepareTransaction(options: { provider: PerpsProvider }): Promise<{
-    transaction: TransactionParams;
+    transaction: PerpsTransactionParams;
     assetChainId: Hex;
     currentDepositId: string;
   }> {
@@ -73,7 +76,11 @@ export class DepositService {
     );
 
     // Get EVM account from selected account group via messenger
-    const evmAccount = getSelectedEvmAccount(this.#messenger);
+    const evmAccount = getSelectedEvmAccount(
+      this.#messenger.call(
+        'AccountTreeController:getAccountsFromSelectedAccountGroup',
+      ),
+    );
     if (!evmAccount) {
       throw new Error(
         'No EVM-compatible account found in selected account group',
@@ -87,7 +94,7 @@ export class DepositService {
     const tokenAddress = parsedAsset.assetReference as Hex;
 
     // Build transaction parameters for TransactionController
-    const transaction: TransactionParams = {
+    const transaction: PerpsTransactionParams = {
       from: accountAddress,
       to: tokenAddress,
       value: '0x0',
diff --git a/app/controllers/perps/services/FeatureFlagConfigurationService.ts b/app/controllers/perps/services/FeatureFlagConfigurationService.ts
index ba5f2adafd33..ee0295035499 100644
--- a/app/controllers/perps/services/FeatureFlagConfigurationService.ts
+++ b/app/controllers/perps/services/FeatureFlagConfigurationService.ts
@@ -1,9 +1,11 @@
-import type { RemoteFeatureFlagControllerState } from '@metamask/remote-feature-flag-controller';
 import { hasProperty } from '@metamask/utils';
 
 import { PERPS_CONSTANTS } from '../constants/perpsConfig';
 import { isVersionGatedFeatureFlag } from '../types';
-import type { PerpsPlatformDependencies } from '../types';
+import type {
+  PerpsPlatformDependencies,
+  PerpsRemoteFeatureFlagState,
+} from '../types';
 import type { ServiceContext } from './ServiceContext';
 import { ensureError } from '../utils/errorUtils';
 import { validateMarketPattern } from '../utils/marketUtils';
@@ -182,11 +184,11 @@ export class FeatureFlagConfigurationService {
    * Follows the "sticky remote" pattern: once remote config is loaded, never downgrade to fallback.
    *
    * @param options - Configuration object
-   * @param options.remoteFeatureFlagControllerState - State from RemoteFeatureFlagController
+   * @param options.remoteFeatureFlagControllerState - Remote feature flag state
    * @param options.context - ServiceContext providing state access callbacks
    */
   refreshHip3Config(options: {
-    remoteFeatureFlagControllerState: RemoteFeatureFlagControllerState;
+    remoteFeatureFlagControllerState: PerpsRemoteFeatureFlagState;
     context: ServiceContext;
   }): void {
     const { remoteFeatureFlagControllerState, context } = options;
@@ -320,11 +322,11 @@ export class FeatureFlagConfigurationService {
    * Note: Initial eligibility is set in the constructor if fallback regions are provided.
    *
    * @param options - Configuration object
-   * @param options.remoteFeatureFlagControllerState - State from RemoteFeatureFlagController
+   * @param options.remoteFeatureFlagControllerState - Remote feature flag state
    * @param options.context - ServiceContext providing callbacks
    */
   refreshEligibility(options: {
-    remoteFeatureFlagControllerState: RemoteFeatureFlagControllerState;
+    remoteFeatureFlagControllerState: PerpsRemoteFeatureFlagState;
     context: ServiceContext;
   }): void {
     const { remoteFeatureFlagControllerState, context } = options;
diff --git a/app/controllers/perps/services/HyperLiquidWalletService.test.ts b/app/controllers/perps/services/HyperLiquidWalletService.test.ts
index 42b75323eb0c..3c9363ace640 100644
--- a/app/controllers/perps/services/HyperLiquidWalletService.test.ts
+++ b/app/controllers/perps/services/HyperLiquidWalletService.test.ts
@@ -11,37 +11,7 @@ jest.mock('@metamask/keyring-api', () => ({
   ),
 }));
 
-// Mock keyring controller to avoid import issues
-jest.mock('@metamask/keyring-controller', () => ({
-  SignTypedDataVersion: {
-    V1: 'V1',
-    V2: 'V2',
-    V3: 'V3',
-    V4: 'V4',
-  },
-}));
-
 // Mock MetaMask utils
-// Mock using the MetaMask mobile testing patterns
-const MOCK_SELECTED_ACCOUNT = {
-  address: '0x1234567890123456789012345678901234567890',
-};
-
-const MOCK_STORE_STATE = {
-  engine: {
-    backgroundState: {
-      AccountsController: {
-        internalAccounts: {
-          selectedAccount: 'test-account-id',
-          accounts: {
-            'test-account-id': MOCK_SELECTED_ACCOUNT,
-          },
-        },
-      },
-    },
-  },
-};
-
 jest.mock('@metamask/utils', () => ({
   parseCaipAccountId: jest.fn((accountId: string) => {
     const parts = accountId.split(':');
@@ -56,51 +26,6 @@ jest.mock('@metamask/utils', () => ({
   ),
 }));
 
-jest.mock('../../../store', () => ({
-  store: {
-    getState: jest.fn(() => MOCK_STORE_STATE),
-  },
-}));
-
-// Mock selectors
-jest.mock('../../../selectors/accountsController', () => ({
-  selectSelectedInternalAccountAddress: jest.fn(
-    () => MOCK_SELECTED_ACCOUNT.address,
-  ),
-}));
-
-jest.mock('../../../selectors/multichainAccounts/accounts', () => ({
-  selectSelectedInternalAccountByScope: jest.fn(
-    () => () => MOCK_SELECTED_ACCOUNT,
-  ),
-}));
-
-// Mock Engine with proper hoisting
-jest.mock('../../../core/Engine', () => {
-  const mockKeyringController = {
-    signTypedMessage: jest.fn().mockResolvedValue('0xSignatureResult'),
-  };
-
-  const mockAccountTreeController = {
-    getAccountsFromSelectedAccountGroup: jest.fn().mockReturnValue([
-      {
-        address: '0x1234567890123456789012345678901234567890',
-        type: 'eip155:1',
-      },
-    ]),
-  };
-
-  return {
-    __esModule: true,
-    default: {
-      context: {
-        KeyringController: mockKeyringController,
-        AccountTreeController: mockAccountTreeController,
-      },
-    },
-  };
-});
-
 // Mock config
 jest.mock('../constants/hyperLiquidConfig', () => ({
   getChainId: jest.fn((isTestnet: boolean) => (isTestnet ? '421614' : '42161')),
@@ -117,17 +42,16 @@ import type { CaipAccountId } from '@metamask/utils';
 
 import {
   createMockInfrastructure,
-  createMockMessenger,
   createMockEvmAccount,
+  createMockMessenger,
 } from '../../../components/UI/Perps/__mocks__/serviceMocks';
-import type { PerpsControllerMessenger } from '../PerpsController';
 
 import { HyperLiquidWalletService } from './HyperLiquidWalletService';
 
 describe('HyperLiquidWalletService', () => {
   let service: HyperLiquidWalletService;
   let mockDeps: ReturnType<typeof createMockInfrastructure>;
-  let mockMessenger: jest.Mocked<PerpsControllerMessenger>;
+  let mockMessenger: ReturnType<typeof createMockMessenger>;
   const mockEvmAccount = createMockEvmAccount();
 
   beforeEach(() => {
@@ -272,7 +196,7 @@ describe('HyperLiquidWalletService', () => {
       });
 
       it('should throw error when no account selected', async () => {
-        // Mock messenger to return empty array (no account selected)
+        // Mock accountTree to return empty array (no account selected)
         (mockMessenger.call as jest.Mock).mockImplementation(
           (action: string) => {
             if (
@@ -281,6 +205,12 @@ describe('HyperLiquidWalletService', () => {
             ) {
               return [];
             }
+            if (action === 'KeyringController:getState') {
+              return { isUnlocked: true };
+            }
+            if (action === 'KeyringController:signTypedMessage') {
+              return Promise.resolve('0xSignatureResult');
+            }
             return undefined;
           },
         );
@@ -310,8 +240,11 @@ describe('HyperLiquidWalletService', () => {
           },
         );
 
+        // Need to recreate the adapter after changing the mock
+        const freshAdapter = service.createWalletAdapter();
+
         await expect(
-          walletAdapter.signTypedData(mockTypedDataParams),
+          freshAdapter.signTypedData(mockTypedDataParams),
         ).rejects.toThrow('Signing failed');
       });
     });
@@ -321,7 +254,6 @@ describe('HyperLiquidWalletService', () => {
     it('should get current account ID for mainnet', async () => {
       const accountId = await service.getCurrentAccountId();
 
-      // Uses address from mockMessenger's AccountTreeController:getAccountsFromSelectedAccountGroup
       expect(accountId).toBe(`eip155:42161:${mockEvmAccount.address}`);
     });
 
@@ -334,7 +266,6 @@ describe('HyperLiquidWalletService', () => {
     });
 
     it('should throw error when getting account ID with no selected account', async () => {
-      // Mock messenger to return empty array (no account selected)
       (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
         if (
           action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
@@ -359,7 +290,6 @@ describe('HyperLiquidWalletService', () => {
     });
 
     it('should throw error for invalid address format', () => {
-      // Mock isValidHexAddress at the module level
       const { isValidHexAddress } = jest.requireMock('@metamask/utils');
       isValidHexAddress.mockReturnValueOnce(false);
 
@@ -382,7 +312,6 @@ describe('HyperLiquidWalletService', () => {
     it('should get user address with default fallback', async () => {
       const address = await service.getUserAddressWithDefault();
 
-      // Uses address from mockMessenger's AccountTreeController:getAccountsFromSelectedAccountGroup
       expect(address).toBe(mockEvmAccount.address);
     });
   });
@@ -412,8 +341,7 @@ describe('HyperLiquidWalletService', () => {
   });
 
   describe('Error Handling', () => {
-    it('should handle store state errors gracefully', async () => {
-      // Mock messenger to throw an error
+    it('should handle accountTree errors gracefully', async () => {
       (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
         if (
           action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
@@ -429,7 +357,6 @@ describe('HyperLiquidWalletService', () => {
     });
 
     it('should handle malformed CAIP account IDs', () => {
-      // Mock parseCaipAccountId at the module level
       const { parseCaipAccountId } = jest.requireMock('@metamask/utils');
       parseCaipAccountId.mockImplementationOnce(() => {
         throw new Error('Invalid CAIP account ID');
@@ -474,7 +401,6 @@ describe('HyperLiquidWalletService', () => {
       await expect(walletAdapter.signTypedData(mockTypedData)).rejects.toThrow(
         'KEYRING_LOCKED',
       );
-      // signTypedMessage should NOT have been called
       expect(mockMessenger.call).not.toHaveBeenCalledWith(
         'KeyringController:signTypedMessage',
         expect.anything(),
@@ -497,7 +423,6 @@ describe('HyperLiquidWalletService', () => {
 
     it('should handle keyring controller initialization errors', async () => {
       const walletAdapter = service.createWalletAdapter();
-      // Override messenger.call for the signing call
       (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
         if (
           action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
diff --git a/app/controllers/perps/services/HyperLiquidWalletService.ts b/app/controllers/perps/services/HyperLiquidWalletService.ts
index fd60d4a236ce..d1ac687ce7a9 100644
--- a/app/controllers/perps/services/HyperLiquidWalletService.ts
+++ b/app/controllers/perps/services/HyperLiquidWalletService.ts
@@ -1,12 +1,13 @@
-import { SignTypedDataVersion } from '@metamask/keyring-controller';
-import type { TypedMessageParams } from '@metamask/keyring-controller';
 import { parseCaipAccountId, isValidHexAddress } from '@metamask/utils';
 import type { CaipAccountId, Hex } from '@metamask/utils';
 
 import { getChainId } from '../constants/hyperLiquidConfig';
-import type { PerpsControllerMessenger } from '../PerpsController';
 import { PERPS_ERROR_CODES } from '../perpsErrorCodes';
-import type { PerpsPlatformDependencies } from '../types';
+import type {
+  PerpsPlatformDependencies,
+  PerpsTypedMessageParams,
+} from '../types';
+import type { PerpsControllerMessengerBase } from '../types/messenger';
 import { getSelectedEvmAccount } from '../utils/accountUtils';
 
 /**
@@ -19,12 +20,11 @@ export class HyperLiquidWalletService {
   // Platform dependencies for observability
   readonly #deps: PerpsPlatformDependencies;
 
-  // Messenger for inter-controller communication
-  readonly #messenger: PerpsControllerMessenger;
+  readonly #messenger: PerpsControllerMessengerBase;
 
   constructor(
     deps: PerpsPlatformDependencies,
-    messenger: PerpsControllerMessenger,
+    messenger: PerpsControllerMessengerBase,
     options: { isTestnet?: boolean } = {},
   ) {
     this.#deps = deps;
@@ -42,19 +42,23 @@ export class HyperLiquidWalletService {
   }
 
   /**
-   * Sign typed data via messenger
+   * Sign typed data via DI keyring controller
    *
    * @param msgParams - The typed message parameters including data and sender address.
    * @returns The signature string.
    */
-  async #signTypedMessage(msgParams: TypedMessageParams): Promise<string> {
+  async #signTypedMessage(msgParams: PerpsTypedMessageParams): Promise<string> {
     if (!this.isKeyringUnlocked()) {
       throw new Error(PERPS_ERROR_CODES.KEYRING_LOCKED);
     }
+    // Cast needed: PerpsTypedMessageParams uses loose `data: unknown` type
+    // while KeyringController uses strict TypedMessageParams / SignTypedDataVersion
     return this.#messenger.call(
       'KeyringController:signTypedMessage',
-      msgParams,
-      SignTypedDataVersion.V4,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      msgParams as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      'V4' as any,
     );
   }
 
@@ -81,8 +85,12 @@ export class HyperLiquidWalletService {
     }) => Promise<Hex>;
     getChainId?: () => Promise<number>;
   } {
-    // Get current EVM account using messenger
-    const evmAccount = getSelectedEvmAccount(this.#messenger);
+    // Get current EVM account via DI accountTree
+    const evmAccount = getSelectedEvmAccount(
+      this.#messenger.call(
+        'AccountTreeController:getAccountsFromSelectedAccountGroup',
+      ),
+    );
 
     if (!evmAccount?.address) {
       throw new Error(PERPS_ERROR_CODES.NO_ACCOUNT_SELECTED);
@@ -107,7 +115,11 @@ export class HyperLiquidWalletService {
       }): Promise<Hex> => {
         // Get FRESH account on every sign to handle account switches
         // This prevents race conditions where wallet adapter was created with old account
-        const currentEvmAccount = getSelectedEvmAccount(this.#messenger);
+        const currentEvmAccount = getSelectedEvmAccount(
+          this.#messenger.call(
+            'AccountTreeController:getAccountsFromSelectedAccountGroup',
+          ),
+        );
 
         if (!currentEvmAccount?.address) {
           throw new Error(PERPS_ERROR_CODES.NO_ACCOUNT_SELECTED);
@@ -151,7 +163,11 @@ export class HyperLiquidWalletService {
    * @returns The CAIP account ID for the current EVM account.
    */
   public async getCurrentAccountId(): Promise<CaipAccountId> {
-    const evmAccount = getSelectedEvmAccount(this.#messenger);
+    const evmAccount = getSelectedEvmAccount(
+      this.#messenger.call(
+        'AccountTreeController:getAccountsFromSelectedAccountGroup',
+      ),
+    );
 
     if (!evmAccount?.address) {
       throw new Error(PERPS_ERROR_CODES.NO_ACCOUNT_SELECTED);
diff --git a/app/controllers/perps/services/RewardsIntegrationService.test.ts b/app/controllers/perps/services/RewardsIntegrationService.test.ts
index 4743bb20093f..c418c3c8c1e2 100644
--- a/app/controllers/perps/services/RewardsIntegrationService.test.ts
+++ b/app/controllers/perps/services/RewardsIntegrationService.test.ts
@@ -3,20 +3,48 @@ import {
   createMockInfrastructure,
   createMockMessenger,
 } from '../../../components/UI/Perps/__mocks__/serviceMocks';
-import type { PerpsControllerMessenger } from '../PerpsController';
 import type { PerpsPlatformDependencies } from '../types';
 
 import { RewardsIntegrationService } from './RewardsIntegrationService';
 
 describe('RewardsIntegrationService', () => {
-  let mockMessenger: jest.Mocked<PerpsControllerMessenger>;
   let mockDeps: jest.Mocked<PerpsPlatformDependencies>;
+  let mockMessenger: ReturnType<typeof createMockMessenger>;
   let service: RewardsIntegrationService;
   const mockEvmAccount = createMockEvmAccount();
 
+  /**
+   * Helper to set up mockMessenger.call with standard defaults,
+   * plus optional overrides for specific actions.
+   */
+  const setupMessengerDefaults = (overrides: Record<string, unknown> = {}) => {
+    (mockMessenger.call as jest.Mock).mockImplementation(
+      (action: string, ...args: unknown[]) => {
+        if (action in overrides) {
+          const val = overrides[action];
+          return typeof val === 'function'
+            ? (val as (...a: unknown[]) => unknown)(...args)
+            : val;
+        }
+        if (
+          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
+        ) {
+          return [mockEvmAccount];
+        }
+        if (action === 'NetworkController:getState') {
+          return { selectedNetworkClientId: 'mainnet' };
+        }
+        if (action === 'NetworkController:getNetworkClientById') {
+          return { configuration: { chainId: '0x1' } };
+        }
+        return undefined;
+      },
+    );
+  };
+
   beforeEach(() => {
-    mockMessenger = createMockMessenger();
     mockDeps = createMockInfrastructure();
+    mockMessenger = createMockMessenger();
     service = new RewardsIntegrationService(mockDeps, mockMessenger);
 
     jest.clearAllMocks();
@@ -30,29 +58,15 @@ describe('RewardsIntegrationService', () => {
     it('calculates fee discount successfully with valid discount', async () => {
       const mockDiscountBips = 6500; // 65%
 
-      // Configure messenger to return expected values
-      (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [mockEvmAccount];
-        }
-        if (action === 'NetworkController:getState') {
-          return { selectedNetworkClientId: 'mainnet' };
-        }
-        if (action === 'NetworkController:getNetworkClientById') {
-          return { configuration: { chainId: '0x1' } };
-        }
-        return undefined;
-      });
-      (mockDeps.rewards.getFeeDiscount as jest.Mock).mockResolvedValue(
-        mockDiscountBips,
-      );
+      setupMessengerDefaults();
+      (
+        mockDeps.rewards.getPerpsDiscountForAccount as jest.Mock
+      ).mockResolvedValue(mockDiscountBips);
 
       const result = await service.calculateUserFeeDiscount();
 
       expect(result).toBe(6500);
-      expect(mockDeps.rewards.getFeeDiscount).toHaveBeenCalledWith(
+      expect(mockDeps.rewards.getPerpsDiscountForAccount).toHaveBeenCalledWith(
         expect.stringMatching(/^eip155:1:0x/),
       );
       expect(mockDeps.debugLogger.log).toHaveBeenCalledWith(
@@ -64,22 +78,11 @@ describe('RewardsIntegrationService', () => {
       );
     });
 
-    it('returns undefined when no discount available', async () => {
-      (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [mockEvmAccount];
-        }
-        if (action === 'NetworkController:getState') {
-          return { selectedNetworkClientId: 'mainnet' };
-        }
-        if (action === 'NetworkController:getNetworkClientById') {
-          return { configuration: { chainId: '0x1' } };
-        }
-        return undefined;
-      });
-      (mockDeps.rewards.getFeeDiscount as jest.Mock).mockResolvedValue(0);
+    it('returns 0 when no discount available', async () => {
+      setupMessengerDefaults();
+      (
+        mockDeps.rewards.getPerpsDiscountForAccount as jest.Mock
+      ).mockResolvedValue(0);
 
       const result = await service.calculateUserFeeDiscount();
 
@@ -87,13 +90,8 @@ describe('RewardsIntegrationService', () => {
     });
 
     it('returns undefined when no EVM account found', async () => {
-      (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [];
-        }
-        return undefined;
+      setupMessengerDefaults({
+        'AccountTreeController:getAccountsFromSelectedAccountGroup': [],
       });
 
       const result = await service.calculateUserFeeDiscount();
@@ -102,51 +100,33 @@ describe('RewardsIntegrationService', () => {
       expect(mockDeps.debugLogger.log).toHaveBeenCalledWith(
         'RewardsIntegrationService: No EVM account found for fee discount',
       );
-      expect(mockDeps.rewards.getFeeDiscount).not.toHaveBeenCalled();
+      expect(
+        mockDeps.rewards.getPerpsDiscountForAccount,
+      ).not.toHaveBeenCalled();
     });
 
     it('returns undefined when chain ID not found', async () => {
-      (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [mockEvmAccount];
-        }
-        if (action === 'NetworkController:getState') {
-          return { selectedNetworkClientId: 'mainnet' };
-        }
-        if (action === 'NetworkController:getNetworkClientById') {
+      setupMessengerDefaults({
+        'NetworkController:getNetworkClientById': () => {
           throw new Error('Network client not found');
-        }
-        return undefined;
+        },
       });
 
       const result = await service.calculateUserFeeDiscount();
 
       expect(result).toBeUndefined();
-      expect(mockDeps.rewards.getFeeDiscount).not.toHaveBeenCalled();
+      expect(
+        mockDeps.rewards.getPerpsDiscountForAccount,
+      ).not.toHaveBeenCalled();
     });
 
     it('returns undefined when getFeeDiscount throws error', async () => {
       const mockError = new Error('Rewards API error');
 
-      (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [mockEvmAccount];
-        }
-        if (action === 'NetworkController:getState') {
-          return { selectedNetworkClientId: 'mainnet' };
-        }
-        if (action === 'NetworkController:getNetworkClientById') {
-          return { configuration: { chainId: '0x1' } };
-        }
-        return undefined;
-      });
-      (mockDeps.rewards.getFeeDiscount as jest.Mock).mockRejectedValue(
-        mockError,
-      );
+      setupMessengerDefaults();
+      (
+        mockDeps.rewards.getPerpsDiscountForAccount as jest.Mock
+      ).mockRejectedValue(mockError);
 
       const result = await service.calculateUserFeeDiscount();
 
@@ -164,16 +144,10 @@ describe('RewardsIntegrationService', () => {
     it('returns undefined when NetworkController throws error', async () => {
       const mockError = new Error('Network error');
 
-      (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
-        if (
-          action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
-        ) {
-          return [mockEvmAccount];
-        }
-        if (action === 'NetworkController:getState') {
+      setupMessengerDefaults({
+        'NetworkController:getState': () => {
           throw mockError;
-        }
-        return undefined;
+        },
       });
 
       const result = await service.calculateUserFeeDiscount();
@@ -190,7 +164,6 @@ describe('RewardsIntegrationService', () => {
       ];
 
       for (const chain of chains) {
-        // Reset only specific mocks, keeping mockDeps intact
         jest.clearAllMocks();
         mockDeps = createMockInfrastructure();
         mockMessenger = createMockMessenger();
@@ -213,7 +186,9 @@ describe('RewardsIntegrationService', () => {
             return undefined;
           },
         );
-        (mockDeps.rewards.getFeeDiscount as jest.Mock).mockResolvedValue(5000);
+        (
+          mockDeps.rewards.getPerpsDiscountForAccount as jest.Mock
+        ).mockResolvedValue(5000);
 
         const result = await service.calculateUserFeeDiscount();
 
@@ -233,26 +208,10 @@ describe('RewardsIntegrationService', () => {
       for (const testCase of testCases) {
         jest.clearAllMocks();
 
-        (mockMessenger.call as jest.Mock).mockImplementation(
-          (action: string) => {
-            if (
-              action ===
-              'AccountTreeController:getAccountsFromSelectedAccountGroup'
-            ) {
-              return [mockEvmAccount];
-            }
-            if (action === 'NetworkController:getState') {
-              return { selectedNetworkClientId: 'mainnet' };
-            }
-            if (action === 'NetworkController:getNetworkClientById') {
-              return { configuration: { chainId: '0x1' } };
-            }
-            return undefined;
-          },
-        );
-        (mockDeps.rewards.getFeeDiscount as jest.Mock).mockResolvedValue(
-          testCase.bips,
-        );
+        setupMessengerDefaults();
+        (
+          mockDeps.rewards.getPerpsDiscountForAccount as jest.Mock
+        ).mockResolvedValue(testCase.bips);
 
         await service.calculateUserFeeDiscount();
 
@@ -273,7 +232,7 @@ describe('RewardsIntegrationService', () => {
       const mockMessenger2 = createMockMessenger();
       const service2 = new RewardsIntegrationService(mockDeps2, mockMessenger2);
 
-      // First service - mock messenger to return empty array (no EVM account)
+      // First service - no EVM account
       (mockMessenger.call as jest.Mock).mockImplementation((action: string) => {
         if (
           action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
@@ -284,7 +243,7 @@ describe('RewardsIntegrationService', () => {
       });
       await service.calculateUserFeeDiscount();
 
-      // Second service - uses same mock pattern
+      // Second service - no EVM account
       (mockMessenger2.call as jest.Mock).mockImplementation(
         (action: string) => {
           if (
diff --git a/app/controllers/perps/services/RewardsIntegrationService.ts b/app/controllers/perps/services/RewardsIntegrationService.ts
index 3754abed5a1d..ffd8eadbab28 100644
--- a/app/controllers/perps/services/RewardsIntegrationService.ts
+++ b/app/controllers/perps/services/RewardsIntegrationService.ts
@@ -1,6 +1,6 @@
 import { PERPS_CONSTANTS } from '../constants/perpsConfig';
-import type { PerpsControllerMessenger } from '../PerpsController';
 import type { PerpsPlatformDependencies } from '../types';
+import type { PerpsControllerMessengerBase } from '../types/messenger';
 import { getSelectedEvmAccount } from '../utils/accountUtils';
 import { ensureError } from '../utils/errorUtils';
 import { formatAccountToCaipAccountId } from '../utils/rewardsUtils';
@@ -11,30 +11,29 @@ import { formatAccountToCaipAccountId } from '../utils/rewardsUtils';
  * Handles rewards-related operations and fee discount calculations.
  * Stateless service that coordinates with RewardsController and NetworkController.
  *
- * Instance-based service with constructor injection of platform dependencies
- * and messenger for inter-controller communication.
+ * Instance-based service with constructor injection of platform dependencies.
  */
 export class RewardsIntegrationService {
   readonly #deps: PerpsPlatformDependencies;
 
-  readonly #messenger: PerpsControllerMessenger;
+  readonly #messenger: PerpsControllerMessengerBase;
 
   /**
    * Create a new RewardsIntegrationService instance
    *
    * @param deps - Platform dependencies for logging, metrics, etc.
-   * @param messenger - Messenger for inter-controller communication
+   * @param messenger - Controller messenger for cross-controller communication.
    */
   constructor(
     deps: PerpsPlatformDependencies,
-    messenger: PerpsControllerMessenger,
+    messenger: PerpsControllerMessengerBase,
   ) {
     this.#deps = deps;
     this.#messenger = messenger;
   }
 
   /**
-   * Get chain ID for a network client via messenger
+   * Get chain ID for a network client via DI network controller
    *
    * @param networkClientId - The network client identifier to look up.
    * @returns The chain ID string, or undefined if the network client is not found.
@@ -60,7 +59,11 @@ export class RewardsIntegrationService {
    */
   async calculateUserFeeDiscount(): Promise<number | undefined> {
     try {
-      const evmAccount = getSelectedEvmAccount(this.#messenger);
+      const evmAccount = getSelectedEvmAccount(
+        this.#messenger.call(
+          'AccountTreeController:getAccountsFromSelectedAccountGroup',
+        ),
+      );
 
       if (!evmAccount) {
         this.#deps.debugLogger.log(
@@ -69,7 +72,7 @@ export class RewardsIntegrationService {
         return undefined;
       }
 
-      // Get the chain ID using messenger
+      // Get the chain ID via DI network controller
       const networkState = this.#messenger.call('NetworkController:getState');
       const { selectedNetworkClientId } = networkState;
       const chainId = this.#getChainIdForNetwork(selectedNetworkClientId);
@@ -115,9 +118,9 @@ export class RewardsIntegrationService {
         return undefined;
       }
 
-      // Use rewards from deps (stays as DI - no messenger action in core)
+      // Use rewards via DI (no RewardsController in Core yet)
       const discountBips =
-        await this.#deps.rewards.getFeeDiscount(caipAccountId);
+        await this.#deps.rewards.getPerpsDiscountForAccount(caipAccountId);
 
       this.#deps.debugLogger.log(
         'RewardsIntegrationService: Fee discount calculated',
diff --git a/app/controllers/perps/services/ServiceContext.ts b/app/controllers/perps/services/ServiceContext.ts
index 1a0aa13ec2a2..a14cd024b93d 100644
--- a/app/controllers/perps/services/ServiceContext.ts
+++ b/app/controllers/perps/services/ServiceContext.ts
@@ -1,7 +1,4 @@
-import type {
-  PerpsControllerState,
-  PerpsControllerMessenger,
-} from '../PerpsController';
+import type { PerpsControllerState } from '../PerpsController';
 import type { Order, Position } from '../types';
 
 /**
@@ -56,13 +53,6 @@ export type ServiceContext = {
     getState: () => PerpsControllerState;
   };
 
-  /**
-   * Messenger for controller communication (optional)
-   * Required by: DataLakeService (getBearerToken)
-   * Note: TradingService now receives this via setControllerDependencies()
-   */
-  messenger?: PerpsControllerMessenger;
-
   /**
    * Query functions for dependent data
    * Required by: Operations that need to fetch related data
diff --git a/app/controllers/perps/types/index.ts b/app/controllers/perps/types/index.ts
index ca9c541810f5..930a5439e778 100644
--- a/app/controllers/perps/types/index.ts
+++ b/app/controllers/perps/types/index.ts
@@ -1377,21 +1377,56 @@ export type PerpsTracer = {
 };
 
 // ============================================================================
-// Rewards Interface
+// Minimal local types for cross-controller DI (no external controller imports)
 // ============================================================================
 
 /**
- * Rewards controller operations required by Perps.
- * Provides fee discount capabilities for MetaMask rewards program.
+ * Minimal typed-message params passed to keyring for EIP-712 signing.
+ * Structurally matches KeyringController's TypedMessageParams.
  */
-export type PerpsRewardsOperations = {
-  /**
-   * Get fee discount for an account.
-   * Returns discount in basis points (e.g., 6500 = 65% discount)
-   */
-  getFeeDiscount(
-    caipAccountId: `${string}:${string}:${string}`,
-  ): Promise<number>;
+export type PerpsTypedMessageParams = {
+  from: string;
+  data: unknown;
+};
+
+/**
+ * Minimal transaction params passed to TransactionController.addTransaction.
+ * Only the fields PerpsController actually sets.
+ */
+export type PerpsTransactionParams = {
+  from: string;
+  to?: string;
+  value?: string;
+  data?: string;
+  gas?: string;
+};
+
+/**
+ * Options passed to TransactionController.addTransaction.
+ */
+export type PerpsAddTransactionOptions = {
+  networkClientId: string;
+  origin?: string;
+  type?: string;
+  skipInitialGasEstimate?: boolean;
+};
+
+/**
+ * Minimal account shape read from AccountTreeController.
+ * Only the fields PerpsController and its services actually use.
+ */
+export type PerpsInternalAccount = {
+  address: string;
+  type: string;
+  id: string;
+};
+
+/**
+ * Minimal remote feature flag state shape.
+ * Only the remoteFeatureFlags record is needed by PerpsController.
+ */
+export type PerpsRemoteFeatureFlagState = {
+  remoteFeatureFlags: Record<string, unknown>;
 };
 
 /**
@@ -1400,10 +1435,11 @@ export type PerpsRewardsOperations = {
  * Architecture:
  * - Observability: logger, debugLogger, metrics, performance, tracer
  * - Platform: streamManager (mobile/extension specific)
- * - Rewards: fee discount operations
  * - Cache: cache invalidation for standalone queries
+ * - Rewards: delegated rewards interaction (DI — no RewardsController in Core yet)
  *
- * Controller access uses messenger pattern (messenger.call()).
+ * Cross-controller communication uses the messenger pattern (messenger.call).
+ * Only rewards remains as DI because RewardsController is not yet in Core.
  */
 export type PerpsPlatformDependencies = {
   // === Observability (stateless utilities) ===
@@ -1416,9 +1452,6 @@ export type PerpsPlatformDependencies = {
   // === Platform Services (mobile/extension specific) ===
   streamManager: PerpsStreamManager;
 
-  // === Rewards (no standard messenger action in core) ===
-  rewards: PerpsRewardsOperations;
-
   // === Feature Flags (platform-specific version gating) ===
   featureFlags: {
     /**
@@ -1437,6 +1470,17 @@ export type PerpsPlatformDependencies = {
 
   // === Cache Invalidation (for standalone query caches) ===
   cacheInvalidator: PerpsCacheInvalidator;
+
+  // === Rewards (DI — no RewardsController in Core yet) ===
+  rewards: {
+    /**
+     * Get fee discount for an account from the RewardsController.
+     * Returns discount in basis points (e.g., 6500 = 65% discount)
+     */
+    getPerpsDiscountForAccount(
+      caipAccountId: `${string}:${string}:${string}`,
+    ): Promise<number>;
+  };
 };
 
 /**
diff --git a/app/controllers/perps/types/messenger.ts b/app/controllers/perps/types/messenger.ts
new file mode 100644
index 000000000000..182d030ca4c0
--- /dev/null
+++ b/app/controllers/perps/types/messenger.ts
@@ -0,0 +1,57 @@
+import type {
+  AccountTreeControllerGetAccountsFromSelectedAccountGroupAction,
+  AccountTreeControllerSelectedAccountGroupChangeEvent,
+} from '@metamask/account-tree-controller';
+import type {
+  KeyringControllerGetStateAction,
+  KeyringControllerSignTypedMessageAction,
+} from '@metamask/keyring-controller';
+import type { Messenger } from '@metamask/messenger';
+import type {
+  NetworkControllerGetStateAction,
+  NetworkControllerGetNetworkClientByIdAction,
+  NetworkControllerFindNetworkClientIdByChainIdAction,
+} from '@metamask/network-controller';
+import type { AuthenticationController } from '@metamask/profile-sync-controller';
+import type {
+  RemoteFeatureFlagControllerGetStateAction,
+  RemoteFeatureFlagControllerStateChangeEvent,
+} from '@metamask/remote-feature-flag-controller';
+import type { TransactionControllerAddTransactionAction } from '@metamask/transaction-controller';
+
+/**
+ * Actions from other controllers that PerpsController is allowed to call.
+ */
+export type PerpsControllerAllowedActions =
+  | NetworkControllerGetStateAction
+  | NetworkControllerGetNetworkClientByIdAction
+  | NetworkControllerFindNetworkClientIdByChainIdAction
+  | KeyringControllerGetStateAction
+  | KeyringControllerSignTypedMessageAction
+  | TransactionControllerAddTransactionAction
+  | RemoteFeatureFlagControllerGetStateAction
+  | AccountTreeControllerGetAccountsFromSelectedAccountGroupAction
+  | AuthenticationController.AuthenticationControllerGetBearerToken;
+
+/**
+ * Events from other controllers that PerpsController is allowed to subscribe to.
+ */
+export type PerpsControllerAllowedEvents =
+  | RemoteFeatureFlagControllerStateChangeEvent
+  | AccountTreeControllerSelectedAccountGroupChangeEvent;
+
+/**
+ * The messenger type used by PerpsController and its services.
+ * Defined here (rather than in PerpsController.ts) to avoid circular imports
+ * between the controller and service files.
+ *
+ * The first two type parameters (Actions, Events) are filled in by
+ * PerpsController.ts when it unions in its own actions/events.
+ * Services use this base type directly since they only need the allowed
+ * external actions/events.
+ */
+export type PerpsControllerMessengerBase = Messenger<
+  'PerpsController',
+  PerpsControllerAllowedActions,
+  PerpsControllerAllowedEvents
+>;
diff --git a/app/controllers/perps/utils/accountUtils.ts b/app/controllers/perps/utils/accountUtils.ts
index 2c9f2cd66659..377cdde6f1d8 100644
--- a/app/controllers/perps/utils/accountUtils.ts
+++ b/app/controllers/perps/utils/accountUtils.ts
@@ -2,16 +2,20 @@
  * Account utilities for Perps components
  * Handles account selection and EVM account filtering
  */
-import { isEvmAccountType } from '@metamask/keyring-api';
 import type { InternalAccount } from '@metamask/keyring-internal-api';
 
 import { PERPS_CONSTANTS } from '../constants/perpsConfig';
-import { PerpsControllerMessenger } from '../PerpsController';
-import type { AccountState } from '../types';
+import type { AccountState, PerpsInternalAccount } from '../types';
+
+const EVM_ACCOUNT_TYPES = new Set(['eip155:eoa', 'eip155:erc4337']);
+
+function isEvmAccountType(type: string): boolean {
+  return EVM_ACCOUNT_TYPES.has(type);
+}
 
 export function findEvmAccount(
-  accounts: InternalAccount[],
-): InternalAccount | null {
+  accounts: (InternalAccount | PerpsInternalAccount)[],
+): { address: string; type: string } | null {
   const evmAccount = accounts.find(
     (account) =>
       account && isEvmAccountType(account.type as InternalAccount['type']),
@@ -20,19 +24,16 @@ export function findEvmAccount(
 }
 
 export function getEvmAccountFromAccountGroup(
-  accounts: InternalAccount[],
+  accounts: (InternalAccount | PerpsInternalAccount)[],
 ): { address: string } | undefined {
   const evmAccount = findEvmAccount(accounts);
   return evmAccount ? { address: evmAccount.address } : undefined;
 }
 
 export function getSelectedEvmAccount(
-  messenger: PerpsControllerMessenger,
+  accounts: (InternalAccount | PerpsInternalAccount)[],
 ): { address: string } | undefined {
-  const accounts = messenger.call(
-    'AccountTreeController:getAccountsFromSelectedAccountGroup',
-  );
-  return getEvmAccountFromAccountGroup(accounts as InternalAccount[]);
+  return getEvmAccountFromAccountGroup(accounts);
 }
 
 export type ReturnOnEquityInput = {
diff --git a/app/controllers/perps/utils/rewardsUtils.test.ts b/app/controllers/perps/utils/rewardsUtils.test.ts
new file mode 100644
index 000000000000..202afe684f30
--- /dev/null
+++ b/app/controllers/perps/utils/rewardsUtils.test.ts
@@ -0,0 +1,102 @@
+import {
+  formatAccountToCaipAccountId,
+  isCaipAccountId,
+  handleRewardsError,
+} from './rewardsUtils';
+import type { PerpsLogger } from '../types';
+
+describe('rewardsUtils', () => {
+  describe('formatAccountToCaipAccountId', () => {
+    it('formats hex chain ID and address to CAIP-10', () => {
+      const result = formatAccountToCaipAccountId(
+        '0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B',
+        '0xa4b1',
+      );
+      expect(result).toMatch(/^eip155:42161:0x/);
+    });
+
+    it('formats decimal chain ID and address to CAIP-10', () => {
+      const result = formatAccountToCaipAccountId(
+        '0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B',
+        '42161',
+      );
+      expect(result).toMatch(/^eip155:42161:0x/);
+    });
+
+    it('returns null for invalid chain ID (NaN) and logs error', () => {
+      const mockLogger: PerpsLogger = {
+        error: jest.fn(),
+      };
+
+      const result = formatAccountToCaipAccountId(
+        '0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B',
+        'abc',
+        mockLogger,
+      );
+
+      expect(result).toBeNull();
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining('Invalid chain ID: abc'),
+        }),
+        expect.any(Object),
+      );
+    });
+
+    it('returns null for empty chain ID and logs error', () => {
+      const mockLogger: PerpsLogger = {
+        error: jest.fn(),
+      };
+
+      const result = formatAccountToCaipAccountId(
+        '0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B',
+        '',
+        mockLogger,
+      );
+
+      expect(result).toBeNull();
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('returns null without logger for invalid chain ID', () => {
+      const result = formatAccountToCaipAccountId(
+        '0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B',
+        'not-a-number',
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('isCaipAccountId', () => {
+    it('returns true for valid CAIP-10 account ID', () => {
+      expect(isCaipAccountId('eip155:1:0xABC')).toBe(true);
+    });
+
+    it('returns false for non-string value', () => {
+      expect(isCaipAccountId(123)).toBe(false);
+      expect(isCaipAccountId(null)).toBe(false);
+    });
+
+    it('returns false for non-eip155 namespace', () => {
+      expect(isCaipAccountId('solana:1:abc')).toBe(false);
+    });
+
+    it('returns false for string with fewer than 3 parts', () => {
+      expect(isCaipAccountId('eip155:1')).toBe(false);
+    });
+  });
+
+  describe('handleRewardsError', () => {
+    it('returns user-friendly error message', () => {
+      const result = handleRewardsError(new Error('test'));
+      expect(result).toBe('Rewards operation failed');
+    });
+
+    it('logs error when logger is provided', () => {
+      const mockLogger: PerpsLogger = { error: jest.fn() };
+      handleRewardsError(new Error('test'), mockLogger, { key: 'value' });
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+  });
+});
diff --git a/app/controllers/perps/utils/rewardsUtils.ts b/app/controllers/perps/utils/rewardsUtils.ts
index 487c706a9e1a..afb4f2c37aab 100644
--- a/app/controllers/perps/utils/rewardsUtils.ts
+++ b/app/controllers/perps/utils/rewardsUtils.ts
@@ -5,7 +5,6 @@
  * Portable: no mobile-specific imports.
  * Logger is injected as optional parameter for platform-agnostic error reporting.
  */
-import { formatChainIdToCaip } from '@metamask/bridge-controller';
 import { toChecksumHexAddress } from '@metamask/controller-utils';
 import {
   toCaipAccountId,
@@ -16,6 +15,23 @@ import {
 import type { PerpsLogger } from '../types';
 import { ensureError } from './errorUtils';
 
+/**
+ * Converts a numeric or hex chain ID to a CAIP-2 chain ID string.
+ * e.g. '0x1' → 'eip155:1', '42161' → 'eip155:42161'
+ *
+ * @param chainId - Numeric string or hex string chain ID.
+ * @returns CAIP-2 formatted chain ID.
+ */
+function formatChainIdToCaip(chainId: string): string {
+  const decimal = chainId.startsWith('0x')
+    ? parseInt(chainId, 16)
+    : parseInt(chainId, 10);
+  if (isNaN(decimal)) {
+    throw new Error(`Invalid chain ID: ${chainId}`);
+  }
+  return `eip155:${decimal}`;
+}
+
 /**
  * Formats an address to CAIP-10 account ID format
  *
@@ -35,7 +51,7 @@ export const formatAccountToCaipAccountId = (
   logger?: PerpsLogger,
 ): CaipAccountId | null => {
   try {
-    const caipChainId = formatChainIdToCaip(chainId);
+    const caipChainId = formatChainIdToCaip(chainId) as `${string}:${string}`;
     const { namespace, reference } = parseCaipChainId(caipChainId);
 
     // Normalize EVM addresses to checksummed format for consistent CAIP IDs
diff --git a/app/core/Engine/messengers/perps-controller-messenger/index.ts b/app/core/Engine/messengers/perps-controller-messenger/index.ts
index 1d86a21b68b1..6d63c356751d 100644
--- a/app/core/Engine/messengers/perps-controller-messenger/index.ts
+++ b/app/core/Engine/messengers/perps-controller-messenger/index.ts
@@ -9,6 +9,12 @@ import {
 /**
  * Get the PerpsControllerMessenger for the PerpsController.
  *
+ * PerpsController uses the messenger for all cross-controller communication:
+ * NetworkController, KeyringController, TransactionController,
+ * RemoteFeatureFlagController, AccountTreeController, AuthenticationController.
+ * The root messenger already registers actions for these controllers,
+ * so the child messenger can call them through the parent.
+ *
  * @param rootExtendedMessenger - The root extended messenger.
  * @returns The PerpsControllerMessenger.
  */
@@ -27,19 +33,16 @@ export function getPerpsControllerMessenger(
   rootExtendedMessenger.delegate({
     actions: [
       'NetworkController:getState',
-      'AuthenticationController:getBearerToken',
-      'RemoteFeatureFlagController:getState',
-      'AccountTreeController:getAccountsFromSelectedAccountGroup',
-      'KeyringController:getState',
-      'KeyringController:signTypedMessage',
       'NetworkController:getNetworkClientById',
       'NetworkController:findNetworkClientIdByChainId',
+      'KeyringController:getState',
+      'KeyringController:signTypedMessage',
       'TransactionController:addTransaction',
+      'RemoteFeatureFlagController:getState',
+      'AccountTreeController:getAccountsFromSelectedAccountGroup',
+      'AuthenticationController:getBearerToken',
     ],
     events: [
-      'TransactionController:transactionSubmitted',
-      'TransactionController:transactionConfirmed',
-      'TransactionController:transactionFailed',
       'RemoteFeatureFlagController:stateChange',
       'AccountTreeController:selectedAccountGroupChange',
     ],
diff --git a/scripts/perps/validate-core-sync.sh b/scripts/perps/validate-core-sync.sh
index a8aa87fd449d..659a29c918a1 100755
--- a/scripts/perps/validate-core-sync.sh
+++ b/scripts/perps/validate-core-sync.sh
@@ -30,7 +30,7 @@ PERPS_SRC="app/controllers/perps"
 PERPS_DEST="packages/perps-controller/src"
 WORKSPACE="@metamask/perps-controller"
 
-STEP_COUNT=7
+STEP_COUNT=9
 STEP_RESULTS=()
 STEP_TIMES=()
 STEP_LABELS=()
@@ -166,7 +166,7 @@ if [[ -z "$CORE_PATH" ]]; then
 fi
 
 if $SKIP_BUILD; then
-  STEP_COUNT=6
+  STEP_COUNT=8
 fi
 
 # ─── Step functions ─────────────────────────────────────────────────────────────
@@ -212,6 +212,52 @@ step_preflight() {
   return $errors
 }
 
+compute_source_checksum() {
+  local dir="$1"
+  find "$dir" -name '*.ts' -not -name '*.test.*' -print0 \
+    | sort -z \
+    | xargs -0 shasum -a 256 \
+    | shasum -a 256 \
+    | cut -d' ' -f1
+}
+
+step_conflict_check() {
+  local sync_state="$CORE_PATH/packages/perps-controller/.sync-state.json"
+  if [[ ! -f "$sync_state" ]]; then
+    echo "OK: No previous sync state — first sync"
+    return 0
+  fi
+
+  # Check git-level changes since last sync
+  local last_core_commit
+  last_core_commit=$(jq -r '.lastSyncedCoreCommit // empty' "$sync_state")
+  if [[ -n "$last_core_commit" ]]; then
+    local core_changes
+    core_changes=$(cd "$CORE_PATH" && git diff --name-only "$last_core_commit"..HEAD -- packages/perps-controller/src/ 2>/dev/null | wc -l | tr -d ' ')
+    if (( core_changes > 0 )); then
+      echo "WARN: Core has $core_changes committed file(s) changed in perps-controller/src/ since last sync ($last_core_commit)"
+      echo "WARN: Review these changes before syncing to avoid overwriting Core-only edits"
+    else
+      echo "OK: No committed Core changes since last sync"
+    fi
+  fi
+
+  # Check source fingerprint for uncommitted edits
+  local stored_checksum
+  stored_checksum=$(jq -r '.sourceChecksum // empty' "$sync_state")
+  if [[ -n "$stored_checksum" ]]; then
+    local current_checksum
+    current_checksum=$(compute_source_checksum "$CORE_PATH/$PERPS_DEST")
+    if [[ "$current_checksum" != "$stored_checksum" ]]; then
+      echo "WARN: Core source checksum mismatch — files were edited since last sync"
+      echo "WARN: stored:  $stored_checksum"
+      echo "WARN: current: $current_checksum"
+    else
+      echo "OK: Core source checksum matches last sync"
+    fi
+  fi
+}
+
 step_copy() {
   # Use --filter rules: excludes before includes, first match wins.
   # --delete-excluded ensures test files / mocks at destination are removed.
@@ -336,6 +382,27 @@ step_lint() {
   cd "$MOBILE_ROOT"
 }
 
+step_write_sync_state() {
+  local mobile_commit mobile_branch core_commit core_branch checksum
+  mobile_commit=$(cd "$MOBILE_ROOT" && git rev-parse HEAD)
+  mobile_branch=$(cd "$MOBILE_ROOT" && git branch --show-current)
+  core_commit=$(cd "$CORE_PATH" && git rev-parse HEAD)
+  core_branch=$(cd "$CORE_PATH" && git branch --show-current)
+  checksum=$(compute_source_checksum "$CORE_PATH/$PERPS_DEST")
+
+  cat > "$CORE_PATH/packages/perps-controller/.sync-state.json" <<EOF
+{
+  "lastSyncedMobileCommit": "$mobile_commit",
+  "lastSyncedMobileBranch": "$mobile_branch",
+  "lastSyncedCoreCommit": "$core_commit",
+  "lastSyncedCoreBranch": "$core_branch",
+  "lastSyncedDate": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "sourceChecksum": "$checksum"
+}
+EOF
+  echo "Sync state written (checksum: ${checksum:0:12}…)"
+}
+
 # ─── Main ───────────────────────────────────────────────────────────────────────
 
 main() {
@@ -352,6 +419,9 @@ main() {
   step=$((step + 1))
   run_step $step "Pre-flight checks" step_preflight
 
+  step=$((step + 1))
+  run_step $step "Conflict check" step_conflict_check
+
   step=$((step + 1))
   run_step $step "Copy source files" step_copy
 
@@ -372,6 +442,9 @@ main() {
   step=$((step + 1))
   run_step $step "Lint" step_lint
 
+  step=$((step + 1))
+  run_step $step "Write sync state" step_write_sync_state
+
   # ─── Summary ────────────────────────────────────────────────────────────────
 
   local total_elapsed
diff --git a/tests/api-mocking/mock-responses/ramps/onramp-persona-data.ts b/tests/api-mocking/mock-responses/ramps/onramp-persona-data.ts
new file mode 100644
index 000000000000..86826806ccf4
--- /dev/null
+++ b/tests/api-mocking/mock-responses/ramps/onramp-persona-data.ts
@@ -0,0 +1,14 @@
+export const ONRAMP_PERSONA = {
+  email: 'curtis@example.com',
+  firstName: 'Curt',
+  lastName: 'Angle',
+  mobileNumber: '+15555555555',
+  address: {
+    addressLine1: '123 Test St',
+    city: 'Test City',
+    state: 'CA',
+    postCode: '90210',
+    country: 'United States',
+    countryCode: 'US',
+  },
+};
diff --git a/tests/api-mocking/mock-responses/ramps/ramps-mocks.ts b/tests/api-mocking/mock-responses/ramps/ramps-mocks.ts
index 64e264ee2edd..5bf05ab6add3 100644
--- a/tests/api-mocking/mock-responses/ramps/ramps-mocks.ts
+++ b/tests/api-mocking/mock-responses/ramps/ramps-mocks.ts
@@ -12,7 +12,29 @@ import { RAMPS_TOP_TOKENS_RESPONSE } from './responses/ramps-tokens-response.ts'
 import { RAMPS_PROVIDERS_RESPONSE } from './responses/ramps-providers-response.ts';
 import { RAMPS_PAYMENTS_V2_RESPONSE } from './responses/ramps-payments-response.ts';
 import { createGeolocationResponse } from './responses/ramps-geolocation.ts';
-import { RAMPS_QUOTE_RESPONSE } from './responses/ramps-quotes-response.ts';
+import {
+  createRampsQuoteResponse,
+  ProviderType,
+} from './responses/ramps-quotes-response.ts';
+import {
+  TRANSAK_AUTH_LOGIN_RESPONSE,
+  TRANSAK_AUTH_VERIFY_RESPONSE,
+} from './transak/transak-auth-response.ts';
+import { TRANSAK_QUOTE_RESPONSE } from './transak/transak-quotes-response.ts';
+import {
+  TRANSAK_USER_DETAILS_RESPONSE,
+  TRANSAK_KYC_REQUIREMENT_RESPONSE,
+  TRANSAK_USER_LIMITS_RESPONSE,
+} from './transak/transak-user-response.ts';
+import { TRANSAK_CREATE_ORDER_RESPONSE } from './transak/transak-order-response.ts';
+import { TRANSAK_RAMPS_TRANSLATE_RESPONSE } from './transak/transak-ramps-translate-response.ts';
+import { TRANSAK_PAYMENTS_OVERRIDE_RESPONSE } from './transak/transak-payments-override-response.ts';
+import {
+  BUY_ORDER_WIDGET_URL_RESPONSE,
+  BUY_ORDER_CALLBACK_RESPONSE,
+} from './responses/ramps-buy-order-checkout-response.ts';
+import { createBuyOrderResponse } from './responses/ramps-buy-order-status-response.ts';
+import { createDepositOrderResponse } from './responses/ramps-deposit-order-status-response.ts';
 
 /** Registers an array of static GET mocks in parallel. */
 const registerGetMocks = (mockServer: Mockttp, mocks: MockApiEndpoint[]) =>
@@ -122,20 +144,26 @@ export const RAMPS_CATALOG_MOCKS = async (mockServer: Mockttp) => {
 /**
  * Quote mocks for V1 and V2 endpoints.
  * Returns a single transak-staging quote so the controller auto-selects it.
+ *
+ * @param providerType - 'native' for the Transak KYC flow, 'aggregator' for the widget/WebView flow.
  */
-export const RAMPS_QUOTE_MOCKS = async (mockServer: Mockttp) => {
+export const RAMPS_QUOTE_MOCKS = async (
+  mockServer: Mockttp,
+  providerType: ProviderType = 'aggregator',
+) => {
+  const quoteResponse = createRampsQuoteResponse(providerType);
   await registerGetMocks(mockServer, [
     {
       urlEndpoint:
         /^https:\/\/on-ramp\.uat-api\.cx\.metamask\.io\/providers\/all\/quote\?.*$/,
       responseCode: 200,
-      response: RAMPS_QUOTE_RESPONSE,
+      response: quoteResponse,
     },
     {
       urlEndpoint:
         /^https:\/\/on-ramp\.uat-api\.cx\.metamask\.io\/v2\/quotes\?.*$/,
       responseCode: 200,
-      response: RAMPS_QUOTE_RESPONSE,
+      response: quoteResponse,
     },
   ]);
 };
@@ -147,24 +175,17 @@ export const RAMPS_QUOTE_MOCKS = async (mockServer: Mockttp) => {
  */
 export const RAMPS_CHECKOUT_MOCKS = async (mockServer: Mockttp) => {
   await registerGetMocks(mockServer, [
-    // Buy widget URL — returns a staging callback URL so the WebView
-    // immediately triggers the "order complete" flow.
     {
       urlEndpoint:
         /^https:\/\/on-ramp\.uat-api\.cx\.metamask\.io\/v2\/providers\/[^/]+\/buy(\?.*)?$/,
       responseCode: 200,
-      response: {
-        url: 'https://on-ramp-content.uat-api.cx.metamask.io/regions/fake-callback?orderId=mock-order-123',
-        browser: 'APP_BROWSER',
-        orderId: null,
-      },
+      response: BUY_ORDER_WIDGET_URL_RESPONSE,
     },
-    // Callback — extracts order ID from provider callback URL
     {
       urlEndpoint:
         /^https:\/\/on-ramp\.uat-api\.cx\.metamask\.io\/v2\/providers\/[^/]+\/callback(\?.*)?$/,
       responseCode: 200,
-      response: { id: 'mock-order-123' },
+      response: BUY_ORDER_CALLBACK_RESPONSE,
     },
   ]);
 };
@@ -192,58 +213,17 @@ export const RAMPS_TOKEN_ICON_MOCKS = async (mockServer: Mockttp) => {
   ]);
 };
 
-/** Builds a full order response object for the given status. */
-const buildOrderResponse = (status: string) => ({
-  id: 'mock-order-123',
-  isOnlyLink: false,
-  success: status === 'COMPLETED',
-  cryptoAmount: '0.00355373',
-  fiatAmount: 15,
-  cryptoCurrency: {
-    symbol: 'ETH',
-    name: 'Ethereum',
-    decimals: 18,
-  },
-  fiatCurrency: {
-    symbol: 'USD',
-    name: 'US Dollar',
-    decimals: 2,
-    denomSymbol: '$',
-  },
-  provider: {
-    id: '/providers/transak-staging',
-    name: 'Transak (Staging)',
-  },
-  providerOrderId: 'mock-order-123',
-  providerOrderLink: '',
-  createdAt: Date.now(),
-  totalFeesFiat: 3.5,
-  txHash: status === 'COMPLETED' ? '0xmocktxhash123' : null,
-  walletAddress: '0x76cf1CdD1fcC252442b50D6e97207228aA4aefC3',
-  status,
-  network: {
-    name: 'Ethereum Mainnet',
-    chainId: '1',
-  },
-  canBeUpdated: false,
-  idHasExpired: false,
-  excludeFromPurchases: false,
-  timeDescriptionPending: 'Usually completes in a few minutes',
-  orderType: 'BUY',
-  exchangeRate: 4072.34,
-});
-
 /**
- * Stateful order-status mock.
- * Returns PENDING on the first call, then COMPLETED on every subsequent call.
- * This lets tests observe the pending -> completed transition during order polling.
+ * Buy order-status mock.
+ * Always returns COMPLETED so the order is stored as completed by
+ * getOrderFromCallback, matching how the native deposit flow works
+ * (refreshOrder is called before addOrder there, so the stored order
+ * is already completed when OrderDetails mounts).
  */
-export const RAMPS_ORDER_STATUS_MOCKS = async (mockServer: Mockttp) => {
+export const BUY_ORDER_STATUS_MOCKS = async (mockServer: Mockttp) => {
   const orderUrlPattern =
     /^https:\/\/on-ramp\.uat-api\.cx\.metamask\.io\/v2\/providers\/[^/]+\/orders\/[^/]+(\?.*)?$/;
 
-  let orderCallCount = 0;
-
   await mockServer
     .forGet('/proxy')
     .matching((request) => {
@@ -251,22 +231,203 @@ export const RAMPS_ORDER_STATUS_MOCKS = async (mockServer: Mockttp) => {
       return orderUrlPattern.test(url);
     })
     .asPriority(999)
-    .thenCallback((_) => {
-      orderCallCount++;
-      const status = orderCallCount <= 1 ? 'PENDING' : 'COMPLETED';
+    .thenCallback(() => ({
+      statusCode: 200,
+      json: createBuyOrderResponse('COMPLETED'),
+    }));
+};
+
+/**
+ * Stateful deposit order-status mock for the native Transak flow.
+ * Returns PENDING on the first call, then COMPLETED on every subsequent call.
+ */
+export const DEPOSIT_ORDER_STATUS_MOCKS = async (mockServer: Mockttp) => {
+  let depositOrderCallCount = 0;
+  await mockServer
+    .forGet('/proxy')
+    .matching((request) => {
+      const url = getDecodedProxiedURL(request.url);
+      // Matches both the legacy TransakService endpoint (/providers/...) and the
+      // v2 RampsService endpoint (/v2/providers/...) used by refreshOrder.
+      return url.includes('providers/transak-native-staging/orders/');
+    })
+    .asPriority(1000)
+    .thenCallback(() => {
+      depositOrderCallCount++;
+      const status = depositOrderCallCount <= 1 ? 'PENDING' : 'COMPLETED';
       return {
         statusCode: 200,
-        json: buildOrderResponse(status),
+        json: createDepositOrderResponse(status),
       };
     });
 };
 
 /**
- * Sets up all on-ramp API mocks for a given region.
- * This is the main entry point used by test files.
+ * Mocks all Transak API endpoints for the native KYC + bank-transfer flow.
+ * Covers: auth/login, auth/verify, lookup/quotes, user details, KYC requirement,
+ * user limits, create order, ramps translation, and ramps orders (with stateful polling).
  *
- * @param mockServer - The mock server instance
- * @param selectedRegion - The region selected in the test fixture
+ * Also overrides the payments mock to add isManualBankTransfer: true to debit-credit-card
+ * so the flow takes the bank transfer path (avoiding the unmockable WebView).
+ */
+export const TRANSAK_NATIVE_FLOW_MOCKS = async (mockServer: Mockttp) => {
+  // --- Transak API mocks (api-gateway-stg.transak.com) ---
+  // All responses wrapped in { data: ... } because TransakService unwraps .data
+
+  // POST auth/login — sendUserOtp(email)
+  await mockServer
+    .forPost('/proxy')
+    .matching((request) => {
+      const url = getDecodedProxiedURL(request.url);
+      return url.includes('api-gateway-stg.transak.com/api/v2/auth/login');
+    })
+    .asPriority(999)
+    .thenCallback(() => ({
+      statusCode: 200,
+      json: TRANSAK_AUTH_LOGIN_RESPONSE,
+    }));
+
+  // POST auth/verify — verifyUserOtp()
+  await mockServer
+    .forPost('/proxy')
+    .matching((request) => {
+      const url = getDecodedProxiedURL(request.url);
+      return url.includes('api-gateway-stg.transak.com/api/v2/auth/verify');
+    })
+    .asPriority(999)
+    .thenCallback(() => ({
+      statusCode: 200,
+      json: TRANSAK_AUTH_VERIFY_RESPONSE,
+    }));
+
+  // GET lookup/quotes — transakGetBuyQuote() internal Transak quote
+  await mockServer
+    .forGet('/proxy')
+    .matching((request) => {
+      const url = getDecodedProxiedURL(request.url);
+      return url.includes('api-gateway-stg.transak.com/api/v2/lookup/quotes');
+    })
+    .asPriority(999)
+    .thenCallback(() => ({
+      statusCode: 200,
+      json: TRANSAK_QUOTE_RESPONSE,
+    }));
+
+  // GET user/ — getUserDetails()
+  await mockServer
+    .forGet('/proxy')
+    .matching((request) => {
+      const url = getDecodedProxiedURL(request.url);
+      return url.includes('api-gateway-stg.transak.com/api/v2/user/');
+    })
+    .asPriority(999)
+    .thenCallback(() => ({
+      statusCode: 200,
+      json: TRANSAK_USER_DETAILS_RESPONSE,
+    }));
+
+  // GET kyc/requirement — getKycRequirement()
+  await mockServer
+    .forGet('/proxy')
+    .matching((request) => {
+      const url = getDecodedProxiedURL(request.url);
+      return url.includes('api-gateway-stg.transak.com/api/v2/kyc/requirement');
+    })
+    .asPriority(999)
+    .thenCallback(() => ({
+      statusCode: 200,
+      json: TRANSAK_KYC_REQUIREMENT_RESPONSE,
+    }));
+
+  // GET orders/user-limit — getUserLimits()
+  await mockServer
+    .forGet('/proxy')
+    .matching((request) => {
+      const url = getDecodedProxiedURL(request.url);
+      return url.includes(
+        'api-gateway-stg.transak.com/api/v2/orders/user-limit',
+      );
+    })
+    .asPriority(999)
+    .thenCallback(() => ({
+      statusCode: 200,
+      json: TRANSAK_USER_LIMITS_RESPONSE,
+    }));
+
+  // POST orders — createOrder()
+  await mockServer
+    .forPost('/proxy')
+    .matching((request) => {
+      const url = getDecodedProxiedURL(request.url);
+      return (
+        url.includes('api-gateway-stg.transak.com/api/v2/orders') &&
+        !url.includes('user-limit') &&
+        !url.includes('payment-confirmation') &&
+        !url.includes('active-orders')
+      );
+    })
+    .asPriority(999)
+    .thenCallback(() => ({
+      statusCode: 200,
+      json: TRANSAK_CREATE_ORDER_RESPONSE,
+    }));
+
+  // GET orders/{id} — TransakService.getOrder() payment-details enrichment
+  // Called after createOrder when an access token is present.
+  await mockServer
+    .forGet('/proxy')
+    .matching((request) => {
+      const url = getDecodedProxiedURL(request.url);
+      return (
+        url.includes('api-gateway-stg.transak.com/api/v2/orders/') &&
+        !url.includes('user-limit') &&
+        !url.includes('active-orders')
+      );
+    })
+    .asPriority(999)
+    .thenCallback(() => ({
+      statusCode: 200,
+      json: { data: { orderId: 'mock-transak-order-123' } },
+    }));
+
+  // GET translate — getTranslation() (on-ramp.uat-api.cx.metamask.io)
+  await mockServer
+    .forGet('/proxy')
+    .matching((request) => {
+      const url = getDecodedProxiedURL(request.url);
+      return url.includes(
+        'on-ramp.uat-api.cx.metamask.io/providers/transak-native-staging/native/translate',
+      );
+    })
+    .asPriority(999)
+    .thenCallback(() => ({
+      statusCode: 200,
+      json: TRANSAK_RAMPS_TRANSLATE_RESPONSE,
+    }));
+
+  await DEPOSIT_ORDER_STATUS_MOCKS(mockServer);
+
+  // Payments override — isManualBankTransfer: true for bank transfer path
+  await setupMockRequest(
+    mockServer,
+    {
+      requestMethod: 'GET',
+      url: /^https:\/\/on-ramp-cache\.uat-api\.cx\.metamask\.io\/v2\/regions\/[^/]+\/payments\?.*$/,
+      response: TRANSAK_PAYMENTS_OVERRIDE_RESPONSE,
+      responseCode: 200,
+    },
+    1000,
+  );
+};
+
+/**
+ * Sets up region eligibility and catalog mocks.
+ * Covers geolocation, deposit/aggregator eligibility, and all catalog data
+ * (networks, tokens, providers, payment methods, token icons).
+ *
+ * Use directly for tests that navigate the token-selection or off-ramp UI
+ * without proceeding to a quote or checkout step.
+ * Use setupDepositOnRampMocks or setupBuyOnRampMocks for full-flow tests.
  */
 export const setupRegionAwareOnRampMocks = async (
   mockServer: Mockttp,
@@ -274,8 +435,35 @@ export const setupRegionAwareOnRampMocks = async (
 ) => {
   await RAMPS_REGION_MOCKS(mockServer, selectedRegion);
   await RAMPS_CATALOG_MOCKS(mockServer);
+  await RAMPS_TOKEN_ICON_MOCKS(mockServer);
+};
+
+/**
+ * Sets up all mocks for the native Transak deposit flow (KYC/OTP + bank transfer).
+ * Builds on region/catalog mocks and adds native quotes, checkout, and all
+ * Transak-specific API endpoints.
+ */
+export const setupDepositOnRampMocks = async (
+  mockServer: Mockttp,
+  selectedRegion: RampsRegion,
+) => {
+  await setupRegionAwareOnRampMocks(mockServer, selectedRegion);
+  await RAMPS_QUOTE_MOCKS(mockServer, 'native');
+  await RAMPS_CHECKOUT_MOCKS(mockServer);
+  await TRANSAK_NATIVE_FLOW_MOCKS(mockServer);
+};
+
+/**
+ * Sets up all mocks for the aggregator WebView buy flow.
+ * Builds on region/catalog mocks and adds aggregator quotes, checkout,
+ * and buy order status polling.
+ */
+export const setupBuyOnRampMocks = async (
+  mockServer: Mockttp,
+  selectedRegion: RampsRegion,
+) => {
+  await setupRegionAwareOnRampMocks(mockServer, selectedRegion);
   await RAMPS_QUOTE_MOCKS(mockServer);
   await RAMPS_CHECKOUT_MOCKS(mockServer);
-  await RAMPS_TOKEN_ICON_MOCKS(mockServer);
-  await RAMPS_ORDER_STATUS_MOCKS(mockServer);
+  await BUY_ORDER_STATUS_MOCKS(mockServer);
 };
diff --git a/tests/api-mocking/mock-responses/ramps/responses/ramps-buy-order-checkout-response.ts b/tests/api-mocking/mock-responses/ramps/responses/ramps-buy-order-checkout-response.ts
new file mode 100644
index 000000000000..bc27e1fa2563
--- /dev/null
+++ b/tests/api-mocking/mock-responses/ramps/responses/ramps-buy-order-checkout-response.ts
@@ -0,0 +1,16 @@
+/**
+ * Mock response data for buy (aggregator) checkout flow.
+ * Endpoints: GET buy widget URL, GET callback.
+ * After a quote is selected, RampsController.syncWidgetUrl() fetches the widget URL,
+ * then getOrderFromCallback() extracts the order ID from the provider callback.
+ */
+
+export const BUY_ORDER_WIDGET_URL_RESPONSE = {
+  url: 'https://on-ramp-content.uat-api.cx.metamask.io/regions/fake-callback?orderId=mock-order-123',
+  browser: 'APP_BROWSER',
+  orderId: null,
+};
+
+export const BUY_ORDER_CALLBACK_RESPONSE = {
+  id: 'mock-order-123',
+};
diff --git a/tests/api-mocking/mock-responses/ramps/responses/ramps-buy-order-status-response.ts b/tests/api-mocking/mock-responses/ramps/responses/ramps-buy-order-status-response.ts
new file mode 100644
index 000000000000..8299a9cbb2bd
--- /dev/null
+++ b/tests/api-mocking/mock-responses/ramps/responses/ramps-buy-order-status-response.ts
@@ -0,0 +1,45 @@
+/**
+ * Mock response data for buy (aggregator) order status polling.
+ * Endpoint: GET on-ramp.uat-api.../v2/providers/.../orders/...
+ * Returns a full order object; status is typically PENDING then COMPLETED.
+ */
+
+export const createBuyOrderResponse = (status: string) => ({
+  id: 'mock-order-123',
+  isOnlyLink: false,
+  success: status === 'COMPLETED',
+  cryptoAmount: '0.00355',
+  fiatAmount: 15,
+  cryptoCurrency: {
+    symbol: 'ETH',
+    name: 'Ethereum',
+    decimals: 18,
+  },
+  fiatCurrency: {
+    symbol: 'USD',
+    name: 'US Dollar',
+    decimals: 2,
+    denomSymbol: '$',
+  },
+  provider: {
+    id: '/providers/transak-staging',
+    name: 'Transak (Staging)',
+  },
+  providerOrderId: 'mock-order-123',
+  providerOrderLink: '',
+  createdAt: Date.now(),
+  totalFeesFiat: 3.5,
+  txHash: status === 'COMPLETED' ? '0xmocktxhash123' : null,
+  walletAddress: '0x76cf1CdD1fcC252442b50D6e97207228aA4aefC3',
+  status,
+  network: {
+    name: 'Ethereum Mainnet',
+    chainId: '1',
+  },
+  canBeUpdated: false,
+  idHasExpired: false,
+  excludeFromPurchases: false,
+  timeDescriptionPending: 'Usually completes in a few minutes',
+  orderType: 'BUY',
+  exchangeRate: 4072.34,
+});
diff --git a/tests/api-mocking/mock-responses/ramps/responses/ramps-deposit-order-status-response.ts b/tests/api-mocking/mock-responses/ramps/responses/ramps-deposit-order-status-response.ts
new file mode 100644
index 000000000000..c1202c09af89
--- /dev/null
+++ b/tests/api-mocking/mock-responses/ramps/responses/ramps-deposit-order-status-response.ts
@@ -0,0 +1,42 @@
+/**
+ * Mock response data for deposit (Transak native) order status polling.
+ * Endpoint: GET on-ramp.uat-api.../providers/transak-native-staging/orders/...
+ * Used by ramps orders API mock (getOrder after createOrder) and processDepositOrder.
+ * Returns deposit-format order; status is typically PENDING then COMPLETED.
+ */
+
+export const createDepositOrderResponse = (status: string) => ({
+  provider: '/providers/transak-native-staging',
+  providerOrderId: 'mock-transak-order-123',
+  providerOrderLink: '',
+  createdAt: Date.now(),
+  fiatAmount: 100,
+  totalFeesFiat: 23.33,
+  cryptoAmount: '0.02455',
+  fiatCurrency: {
+    symbol: 'USD',
+    name: 'US Dollar',
+    decimals: 2,
+    denomSymbol: '$',
+  },
+  fiatAmountInUsd: 100,
+  cryptoCurrency: {
+    symbol: 'ETH',
+    name: 'Ethereum',
+  },
+  network: {
+    chainId: '1',
+    name: 'Ethereum Mainnet',
+  },
+  walletAddress: '0x76cf1CdD1fcC252442b50D6e97207228aA4aefC3',
+  status,
+  txHash: status === 'COMPLETED' ? '0xmocktxhash123' : null,
+  orderType: 'DEPOSIT',
+  isOnlyLink: false,
+  success: status === 'COMPLETED',
+  canBeUpdated: false,
+  idHasExpired: false,
+  excludeFromPurchases: false,
+  timeDescriptionPending: 'Usually completes in a few minutes',
+  exchangeRate: 4072.34,
+});
diff --git a/tests/api-mocking/mock-responses/ramps/responses/ramps-providers-response.ts b/tests/api-mocking/mock-responses/ramps/responses/ramps-providers-response.ts
index e2d51af76fa6..212ece62f7d7 100644
--- a/tests/api-mocking/mock-responses/ramps/responses/ramps-providers-response.ts
+++ b/tests/api-mocking/mock-responses/ramps/responses/ramps-providers-response.ts
@@ -1,4 +1,7 @@
-// Providers V2 response — staging providers: Transak (default) + Moonpay.
+// Providers V2 response — staging providers: Transak (native) + MoonPay (aggregator).
+// Transak uses the native SDK flow; MoonPay uses the WebView/widget aggregator flow.
+// Note: provider.type here is informational catalog metadata. Flow routing is NOT
+// driven by this field — it is determined at the quote level (quote.providerInfo.type).
 // determinePreferredProvider() auto-selects Transak (matches "transak" in id/name).
 export const RAMPS_PROVIDERS_RESPONSE = {
   providers: [
@@ -56,7 +59,7 @@ export const RAMPS_PROVIDERS_RESPONSE = {
         },
         recurringBuy: {},
       },
-      type: 'aggregator',
+      type: 'native',
       supportedCryptoCurrencies: {
         'eip155:1/slip44:60': true,
       },
diff --git a/tests/api-mocking/mock-responses/ramps/responses/ramps-quotes-response.ts b/tests/api-mocking/mock-responses/ramps/responses/ramps-quotes-response.ts
index 71deb3fb12e0..8e49bf50c801 100644
--- a/tests/api-mocking/mock-responses/ramps/responses/ramps-quotes-response.ts
+++ b/tests/api-mocking/mock-responses/ramps/responses/ramps-quotes-response.ts
@@ -6,7 +6,12 @@
 // controller auto-selects it (RampsController.mjs:952).
 // Returning multiple quotes breaks auto-selection and leaves the Continue
 // button disabled.
-export const RAMPS_QUOTE_RESPONSE = {
+
+export type ProviderType = 'native' | 'aggregator';
+
+export const createRampsQuoteResponse = (
+  providerType: ProviderType = 'native',
+) => ({
   success: [
     {
       provider: '/providers/transak-staging',
@@ -40,11 +45,11 @@ export const RAMPS_QUOTE_RESPONSE = {
           denomSymbol: '$',
         },
         fiatId: '/currencies/fiat/usd',
-        amountIn: 15,
-        amountOut: 0.00355373,
+        amountIn: providerType === 'native' ? 100 : 15,
+        amountOut: providerType === 'native' ? 0.02455598 : 0.00355373,
         exchangeRate: 4072.34318439678,
         networkFee: 0.02,
-        providerFee: 3.5,
+        providerFee: providerType === 'native' ? 23.33 : 3.5,
         extraFee: 0,
         receiver: '0x76cf1CdD1fcC252442b50D6e97207228aA4aefC3',
         paymentMethod: '/payments/debit-credit-card',
@@ -56,7 +61,7 @@ export const RAMPS_QUOTE_RESPONSE = {
       providerInfo: {
         id: '/providers/transak-staging',
         name: 'Transak (Staging)',
-        type: 'aggregator',
+        type: providerType,
         environmentType: 'STAGING',
         description:
           'Per Transak: "The fastest and securest way to buy 100+ cryptocurrencies on 75+ blockchains. Pay via Apple Pay, UPI, bank transfer or use your debit or credit card. Trusted by 2+ million global users. Transak empowers wallets, gaming, DeFi, NFTs, Exchanges, and DAOs across 125+ countries."',
@@ -132,4 +137,4 @@ export const RAMPS_QUOTE_RESPONSE = {
   ],
   error: [],
   customActions: [],
-};
+});
diff --git a/tests/api-mocking/mock-responses/ramps/transak/transak-auth-response.ts b/tests/api-mocking/mock-responses/ramps/transak/transak-auth-response.ts
new file mode 100644
index 000000000000..face3d8b9949
--- /dev/null
+++ b/tests/api-mocking/mock-responses/ramps/transak/transak-auth-response.ts
@@ -0,0 +1,24 @@
+/**
+ * Mock response data for Transak auth API endpoints.
+ * Endpoints: POST auth/login (sendUserOtp), POST auth/verify (verifyUserOtp).
+ * Transak API returns responses wrapped in { data: ... }.
+ */
+
+import { ONRAMP_PERSONA } from '../onramp-persona-data';
+
+export const TRANSAK_AUTH_LOGIN_RESPONSE = {
+  data: {
+    stateToken: 'mock-state-token',
+    isTncAccepted: true,
+    email: ONRAMP_PERSONA.email,
+    expiresIn: 20,
+  },
+};
+
+export const TRANSAK_AUTH_VERIFY_RESPONSE = {
+  data: {
+    accessToken: 'mock-access-token',
+    ttl: 3600,
+    created: new Date().toISOString(),
+  },
+};
diff --git a/tests/api-mocking/mock-responses/ramps/transak/transak-order-response.ts b/tests/api-mocking/mock-responses/ramps/transak/transak-order-response.ts
new file mode 100644
index 000000000000..462a37f5e2f8
--- /dev/null
+++ b/tests/api-mocking/mock-responses/ramps/transak/transak-order-response.ts
@@ -0,0 +1,11 @@
+/**
+ * Mock response data for Transak create order API.
+ * Endpoint: POST api-gateway-stg.transak.com/api/v2/orders
+ */
+
+export const TRANSAK_CREATE_ORDER_RESPONSE = {
+  data: {
+    orderId: 'mock-transak-order-123',
+    walletAddress: '0x76cf1CdD1fcC252442b50D6e97207228aA4aefC3',
+  },
+};
diff --git a/tests/api-mocking/mock-responses/ramps/transak/transak-payments-override-response.ts b/tests/api-mocking/mock-responses/ramps/transak/transak-payments-override-response.ts
new file mode 100644
index 000000000000..4c06f0f3ed13
--- /dev/null
+++ b/tests/api-mocking/mock-responses/ramps/transak/transak-payments-override-response.ts
@@ -0,0 +1,42 @@
+/**
+ * Payments override for Transak native flow (bank transfer path).
+ * Adds isManualBankTransfer: true to debit-credit-card so the flow
+ * avoids the unmockable WebView and uses the bank transfer path.
+ * Overrides: GET on-ramp-cache.../v2/regions/.../payments
+ */
+
+export const TRANSAK_PAYMENTS_OVERRIDE_RESPONSE = {
+  payments: [
+    {
+      id: '/payments/debit-credit-card',
+      paymentType: 'debit-credit-card',
+      name: 'Debit or Credit',
+      score: 100,
+      icons: [{ type: 'materialIcons', name: 'card' }],
+      logo: {
+        light: [
+          'assets/Visa-regular@3x.png',
+          'assets/Mastercard-regular@3x.png',
+        ],
+        dark: ['assets/Visa@3x.png', 'assets/Mastercard@3x.png'],
+      },
+      disclaimer:
+        "Credit card purchases may incur your bank's cash advance fees, subject to your bank's policies.",
+      delay: [5, 10],
+      pendingOrderDescription:
+        'Card purchases may take a few minutes to complete.',
+      amountTier: [1, 3],
+      isManualBankTransfer: true,
+      sellEnabled: true,
+      sell: { enabled: true },
+      recurringBuy: { enabled: true },
+      buy: { enabled: true },
+    },
+  ],
+  sorted: [
+    {
+      sortBy: '1',
+      ids: ['/payments/debit-credit-card'],
+    },
+  ],
+};
diff --git a/tests/api-mocking/mock-responses/ramps/transak/transak-quotes-response.ts b/tests/api-mocking/mock-responses/ramps/transak/transak-quotes-response.ts
new file mode 100644
index 000000000000..18a7375076e8
--- /dev/null
+++ b/tests/api-mocking/mock-responses/ramps/transak/transak-quotes-response.ts
@@ -0,0 +1,23 @@
+/**
+ * Mock response data for Transak lookup/quotes API.
+ * Endpoint: GET api-gateway-stg.transak.com/api/v2/lookup/quotes
+ * Used by transakGetBuyQuote() internal Transak quote.
+ */
+
+export const TRANSAK_QUOTE_RESPONSE = {
+  data: {
+    quoteId: 'mock-quote-id',
+    conversionPrice: 4072.34,
+    fiatCurrency: 'USD',
+    cryptoCurrency: 'ETH',
+    paymentMethod: 'credit_debit_card',
+    fiatAmount: 100,
+    cryptoAmount: 0.02455598,
+    isBuyOrSell: 'BUY',
+    network: 'ethereum',
+    totalFee: 23.33,
+    feeDecimal: 0.23,
+    feeBreakdown: [],
+    nonce: 1,
+  },
+};
diff --git a/tests/api-mocking/mock-responses/ramps/transak/transak-ramps-translate-response.ts b/tests/api-mocking/mock-responses/ramps/transak/transak-ramps-translate-response.ts
new file mode 100644
index 000000000000..66b43d20c9d7
--- /dev/null
+++ b/tests/api-mocking/mock-responses/ramps/transak/transak-ramps-translate-response.ts
@@ -0,0 +1,12 @@
+/**
+ * Mock response data for Ramps translate endpoint (Transak native flow).
+ * Endpoint: GET on-ramp.uat-api.cx.metamask.io/providers/transak-native-staging/native/translate
+ * Used by getBuyQuote, createOrder, getUserLimits. Response is NOT wrapped in { data: ... }.
+ */
+
+export const TRANSAK_RAMPS_TRANSLATE_RESPONSE = {
+  cryptoCurrency: 'ETH',
+  network: 'ethereum',
+  fiatCurrency: 'USD',
+  paymentMethod: 'credit_debit_card',
+};
diff --git a/tests/api-mocking/mock-responses/ramps/transak/transak-user-response.ts b/tests/api-mocking/mock-responses/ramps/transak/transak-user-response.ts
new file mode 100644
index 000000000000..8d3d87e299c8
--- /dev/null
+++ b/tests/api-mocking/mock-responses/ramps/transak/transak-user-response.ts
@@ -0,0 +1,41 @@
+/**
+ * Mock response data for Transak user/KYC/limits API endpoints.
+ * Endpoints: GET user/, GET kyc/requirement, GET orders/user-limit.
+ */
+
+import { ONRAMP_PERSONA } from '../onramp-persona-data';
+
+export const TRANSAK_USER_DETAILS_RESPONSE = {
+  data: {
+    id: 'mock-user-id',
+    firstName: ONRAMP_PERSONA.firstName,
+    lastName: ONRAMP_PERSONA.lastName,
+    email: ONRAMP_PERSONA.email,
+    mobileNumber: ONRAMP_PERSONA.mobileNumber,
+    status: 'active',
+    kyc: {
+      status: 'APPROVED',
+      type: 'SIMPLE',
+      highestApprovedKYCType: 'SIMPLE',
+    },
+    address: ONRAMP_PERSONA.address,
+    createdAt: new Date().toISOString(),
+  },
+};
+
+export const TRANSAK_KYC_REQUIREMENT_RESPONSE = {
+  data: {
+    status: 'APPROVED',
+    kycType: 'SIMPLE',
+    isAllowedToPlaceOrder: true,
+  },
+};
+
+export const TRANSAK_USER_LIMITS_RESPONSE = {
+  data: {
+    limits: { '1': 5000, '30': 25000, '365': 100000 },
+    spent: { '1': 0, '30': 0, '365': 0 },
+    remaining: { '1': 5000, '30': 25000, '365': 100000 },
+    exceeded: { '1': false, '30': false, '365': false },
+  },
+};
diff --git a/tests/framework/fixtures/FixtureBuilder.ts b/tests/framework/fixtures/FixtureBuilder.ts
index d2b2f07283b9..ae49b7286691 100644
--- a/tests/framework/fixtures/FixtureBuilder.ts
+++ b/tests/framework/fixtures/FixtureBuilder.ts
@@ -481,6 +481,9 @@ class FixtureBuilder {
     // with the sell/offramp flow which still uses the aggregator SDK
     this.fixture.state.fiatOrders.selectedRegionAgg = aggregatorCountry;
 
+    this.fixture.state.fiatOrders.detectedGeolocation =
+      selectedRegion.countryIsoCode;
+
     return this;
   }
 
diff --git a/tests/page-objects/Ramps/BuildQuoteView.ts b/tests/page-objects/Ramps/BuildQuoteView.ts
index 084ce3d583e4..1d25c3b8c691 100644
--- a/tests/page-objects/Ramps/BuildQuoteView.ts
+++ b/tests/page-objects/Ramps/BuildQuoteView.ts
@@ -1,5 +1,7 @@
 import Matchers from '../../framework/Matchers';
 import Gestures from '../../framework/Gestures';
+import Utilities from '../../framework/Utilities';
+
 import { BuildQuoteSelectors } from '../../../app/components/UI/Ramp/Aggregator/Views/BuildQuote/BuildQuote.testIds';
 import { AddressSelectorSelectors } from '../../../app/components/Views/AddressSelector/AddressSelector.testIds';
 
@@ -104,6 +106,15 @@ class BuildQuoteView {
     });
   }
 
+  async tapContinueButton(): Promise<void> {
+    await Utilities.waitForElementToBeEnabled(this.continueButton);
+
+    await Gestures.waitAndTap(this.continueButton, {
+      timeout: 2500,
+      elemDescription: 'Continue Button in Build Quote View',
+    });
+  }
+
   async tapSelectAddressDropdown(): Promise<void> {
     await Gestures.waitAndTap(this.accountPickerDropdown, {
       elemDescription: 'Account dropdown in address selector',
diff --git a/tests/page-objects/Ramps/KYCScreen.ts b/tests/page-objects/Ramps/KYCScreen.ts
new file mode 100644
index 000000000000..3ce9aa097436
--- /dev/null
+++ b/tests/page-objects/Ramps/KYCScreen.ts
@@ -0,0 +1,60 @@
+import { EnterEmailSelectorsIDs } from '../../../app/components/UI/Ramp/Views/NativeFlow/EnterEmail.testIds';
+import { OtpCodeSelectorsIDs } from '../../../app/components/UI/Ramp/Views/NativeFlow/OtpCode.testIds';
+import { VerifyIdentitySelectorsIDs } from '../../../app/components/UI/Ramp/Views/NativeFlow/VerifyIdentity.testIds';
+import Matchers from '../../framework/Matchers';
+import Gestures from '../../framework/Gestures';
+import { Utilities } from '../../framework';
+class KYCScreen {
+  get verifyIdentityContinueButton(): DetoxElement {
+    return Matchers.getElementByID(VerifyIdentitySelectorsIDs.CONTINUE_BUTTON);
+  }
+
+  get emailInput(): DetoxElement {
+    return Matchers.getElementByID(EnterEmailSelectorsIDs.EMAIL_INPUT);
+  }
+
+  get sendEmailButton(): DetoxElement {
+    return Matchers.getElementByID(EnterEmailSelectorsIDs.SEND_EMAIL_BUTTON);
+  }
+
+  get otpScreen(): DetoxElement {
+    return Matchers.getElementByID(OtpCodeSelectorsIDs.OTP_CODE_SCREEN);
+  }
+
+  get otpCodeInput(): DetoxElement {
+    return Matchers.getElementByID(OtpCodeSelectorsIDs.OTP_CODE_INPUT);
+  }
+
+  async enterOtpCode(code: string): Promise<void> {
+    await Gestures.typeText(this.otpCodeInput, code, {
+      checkVisibility: false,
+      elemDescription: 'OTP code input in Verify your identity View',
+    });
+  }
+  async tapVerifyIdentityContinueButton(): Promise<void> {
+    await Utilities.waitForElementToBeEnabled(
+      this.verifyIdentityContinueButton,
+    );
+
+    await Gestures.waitAndTap(this.verifyIdentityContinueButton, {
+      elemDescription: 'Verify Identity continue button',
+    });
+  }
+
+  async enterEmail(email: string): Promise<void> {
+    await Utilities.waitForElementToBeEnabled(this.emailInput);
+
+    await Gestures.typeText(this.emailInput, email, {
+      hideKeyboard: true,
+      elemDescription: 'Email input',
+    });
+  }
+
+  async tapSendEmail(): Promise<void> {
+    await Gestures.waitAndTap(this.sendEmailButton, {
+      elemDescription: 'Send email button',
+    });
+  }
+}
+
+export default new KYCScreen();
diff --git a/tests/page-objects/Ramps/OrderDetailsView.ts b/tests/page-objects/Ramps/OrderDetailsView.ts
new file mode 100644
index 000000000000..deec2a925b74
--- /dev/null
+++ b/tests/page-objects/Ramps/OrderDetailsView.ts
@@ -0,0 +1,37 @@
+import { RampsOrderDetailsSelectorsIDs } from '../../../app/components/UI/Ramp/Views/OrderDetails/OrderDetails.testIds';
+import Matchers from '../../framework/Matchers';
+import Gestures from '../../framework/Gestures';
+import Utilities from '../../framework/Utilities';
+
+class OrderDetailsView {
+  get container(): DetoxElement {
+    return Matchers.getElementByID(RampsOrderDetailsSelectorsIDs.CONTAINER);
+  }
+
+  get closeButton(): DetoxElement {
+    return Matchers.getElementByID(RampsOrderDetailsSelectorsIDs.CLOSE_BUTTON);
+  }
+
+  get tokenAmount(): DetoxElement {
+    return Matchers.getElementByID(RampsOrderDetailsSelectorsIDs.TOKEN_AMOUNT);
+  }
+  get backButton(): DetoxElement {
+    return Matchers.getElementByID(RampsOrderDetailsSelectorsIDs.BACK_BUTTON);
+  }
+
+  async tapCloseButton(): Promise<void> {
+    await Utilities.waitForElementToBeEnabled(this.closeButton);
+    await Gestures.waitAndTap(this.closeButton, {
+      timeout: 2500,
+      elemDescription: 'Ramps Order Details Close Button',
+    });
+  }
+
+  async tapBackButton(): Promise<void> {
+    await Gestures.waitAndTap(this.backButton, {
+      elemDescription: 'Ramps Order Details Back Button',
+    });
+  }
+}
+
+export default new OrderDetailsView();
diff --git a/tests/page-objects/Transactions/ActivitiesView.ts b/tests/page-objects/Transactions/ActivitiesView.ts
index 7ce77fd906f8..ce9de95907ff 100644
--- a/tests/page-objects/Transactions/ActivitiesView.ts
+++ b/tests/page-objects/Transactions/ActivitiesView.ts
@@ -2,6 +2,12 @@ import {
   ActivitiesViewSelectorsIDs,
   ActivitiesViewSelectorsText,
 } from '../../../app/components/Views/ActivityView/ActivitiesView.testIds';
+import {
+  getOrderRowFiatAmountTestId,
+  getOrderRowCryptoAmountTestId,
+  getOrderRowTestId,
+  type RampsOrderTypeSlug,
+} from '../../../app/components/UI/Ramp/Aggregator/Views/OrdersList/OrdersList.testIds';
 import Matchers from '../../framework/Matchers';
 import Gestures from '../../framework/Gestures';
 import Assertions from '../../framework/Assertions';
@@ -15,6 +21,9 @@ class ActivitiesView {
       ActivitiesViewSelectorsText.PREDICTIONS_TAB,
     );
   }
+  get transferTab(): DetoxElement {
+    return Matchers.getElementByID(ActivitiesViewSelectorsIDs.TRANSFER_TAB);
+  }
 
   get tabsBar(): DetoxElement {
     return Matchers.getElementByID(
@@ -137,6 +146,12 @@ class ActivitiesView {
     });
   }
 
+  async tapOnTransfersTab(): Promise<void> {
+    await Gestures.waitAndTap(this.transferTab, {
+      elemDescription: 'Transfer Tab in Activity View',
+    });
+  }
+
   async tapPredictPosition(positionName: string): Promise<void> {
     const el = Matchers.getElementByText(positionName);
     await Gestures.waitAndTap(el, {
@@ -144,6 +159,36 @@ class ActivitiesView {
     });
   }
 
+  rampsOrderCryptoAmount(
+    orderType: RampsOrderTypeSlug,
+    rowIndex: number,
+  ): DetoxElement {
+    return Matchers.getElementByID(
+      getOrderRowCryptoAmountTestId(orderType, rowIndex),
+    );
+  }
+
+  rampsOrderFiatAmount(
+    orderType: RampsOrderTypeSlug,
+    rowIndex: number,
+  ): DetoxElement {
+    return Matchers.getElementByID(
+      getOrderRowFiatAmountTestId(orderType, rowIndex),
+    );
+  }
+
+  async tapRampsOrder(
+    orderType: RampsOrderTypeSlug,
+    rowIndex: number,
+  ): Promise<void> {
+    const order = Matchers.getElementByID(
+      getOrderRowTestId(orderType, rowIndex),
+    );
+    await Gestures.waitAndTap(order, {
+      elemDescription: `Tapping Ramps Order: ${orderType} ${rowIndex}`,
+    });
+  }
+
   /**
    * Verifies that an activity item with the given title is visible and its row status matches.
    * Use after TabBarComponent.tapActivity(). Row 0 is the most recent transaction.
diff --git a/tests/smoke/ramps/offramp-cashout.failing.ts b/tests/smoke/ramps/offramp-cashout.failing.ts
deleted file mode 100644
index 8b076d837454..000000000000
--- a/tests/smoke/ramps/offramp-cashout.failing.ts
+++ /dev/null
@@ -1,116 +0,0 @@
-import { loginToApp } from '../../flows/wallet.flow';
-import FixtureBuilder from '../../framework/fixtures/FixtureBuilder';
-import { withFixtures } from '../../framework/fixtures/FixtureHelper';
-import { SmokeTrade } from '../../tags';
-import BuildQuoteView from '../../page-objects/Ramps/BuildQuoteView';
-import Assertions from '../../framework/Assertions';
-import WalletView from '../../page-objects/wallet/WalletView';
-import FundActionMenu from '../../page-objects/UI/FundActionMenu';
-import SelectPaymentMethodView from '../../page-objects/Ramps/SelectPaymentMethodView';
-import SellGetStartedView from '../../page-objects/Ramps/SellGetStartedView';
-import {
-  EventPayload,
-  findEvent,
-  getEventsPayloads,
-} from '../../helpers/analytics/helpers';
-import SoftAssert from '../../framework/SoftAssert';
-import { RampsRegions, RampsRegionsEnum } from '../../framework/Constants';
-import { Mockttp } from 'mockttp';
-import { setupRegionAwareOnRampMocks } from '../../api-mocking/mock-responses/ramps/ramps-mocks';
-
-const PaymentMethods = {
-  SEPA_BANK_TRANSFER: 'SEPA Bank Transfer',
-};
-const expectedEvents = {
-  OFFRAMP_PAYMENT_METHOD_SELECTED: 'Off-ramp Payment Method Selected',
-};
-
-/**
- * TODO:
- * Moving to quaratine since all tests are being skipped.
- * When this test is fixed we need to add a second shard to CI.
- */
-describe.skip(SmokeTrade('Off-Ramp Cashout destination'), () => {
-  const eventsToCheck: EventPayload[] = [];
-
-  beforeEach(async () => {
-    jest.setTimeout(150000);
-  });
-
-  it('should change cashout destination', async () => {
-    const selectedRegion = RampsRegions[RampsRegionsEnum.FRANCE];
-    await withFixtures(
-      {
-        fixture: new FixtureBuilder()
-          .withRampsSelectedRegion(selectedRegion)
-          .withRampsSelectedPaymentMethod()
-          .withMetaMetricsOptIn()
-          .build(),
-        restartDevice: true,
-        testSpecificMock: async (mockServer: Mockttp) => {
-          await setupRegionAwareOnRampMocks(mockServer, selectedRegion);
-        },
-        endTestfn: async ({ mockServer }) => {
-          const events = await getEventsPayloads(mockServer);
-          const offRampPaymentMethodSelected = findEvent(
-            events,
-            expectedEvents.OFFRAMP_PAYMENT_METHOD_SELECTED,
-          );
-          if (offRampPaymentMethodSelected) {
-            eventsToCheck.push(offRampPaymentMethodSelected);
-          }
-        },
-      },
-      async () => {
-        await loginToApp();
-        await WalletView.tapWalletBuyButton();
-        await FundActionMenu.tapSellButton();
-        await SellGetStartedView.tapGetStartedButton();
-        await Assertions.expectTextNotDisplayed('SEPA Bank Transfer');
-        await BuildQuoteView.tapPaymentMethodDropdown('Debit or Credit');
-        await SelectPaymentMethodView.tapPaymentMethodOption(
-          PaymentMethods.SEPA_BANK_TRANSFER,
-        );
-        await Assertions.expectTextDisplayed('SEPA Bank Transfer');
-      },
-    );
-  });
-
-  it('should validate segment/metametric events for a successful offramp flow (cashout)', async () => {
-    const softAssert = new SoftAssert();
-
-    const offRampPaymentMethodSelected = eventsToCheck.find(
-      (event) => event.event === expectedEvents.OFFRAMP_PAYMENT_METHOD_SELECTED,
-    );
-
-    // Define assertion calls as variables
-    const checkOffRampPaymentMethodDefined = softAssert.checkAndCollect(
-      async () => {
-        await Assertions.checkIfValueIsDefined(offRampPaymentMethodSelected);
-      },
-      'Off-ramp Payment Method Selected: Should be present',
-    );
-
-    // Only check properties if the event is defined
-    const checkOffRampPaymentMethodProperties = offRampPaymentMethodSelected
-      ? softAssert.checkAndCollect(async () => {
-          Assertions.checkIfObjectHasKeysAndValidValues(
-            offRampPaymentMethodSelected.properties,
-            {
-              payment_method_id: 'string',
-              available_payment_method_ids: 'array',
-              region: 'string',
-              location: 'string',
-            },
-          );
-        }, 'Off-ramp Payment Method Selected: Should have correct properties')
-      : Promise.resolve();
-
-    await Promise.all([
-      checkOffRampPaymentMethodDefined,
-      checkOffRampPaymentMethodProperties,
-    ]);
-
-    softAssert.throwIfErrors();
-  });
-});
diff --git a/tests/smoke/ramps/onramp-unified-buy.spec.ts b/tests/smoke/ramps/onramp-unified-buy.spec.ts
index 540ab21b2ba2..aa6f8be22a6d 100644
--- a/tests/smoke/ramps/onramp-unified-buy.spec.ts
+++ b/tests/smoke/ramps/onramp-unified-buy.spec.ts
@@ -7,13 +7,18 @@ import { CustomNetworks } from '../../resources/networks.e2e';
 import { SmokeRamps } from '../../tags';
 import Assertions from '../../framework/Assertions';
 import BuildQuoteView from '../../page-objects/Ramps/BuildQuoteView';
+import OrderDetailsView from '../../page-objects/Ramps/OrderDetailsView';
 import TokenSelectScreen from '../../page-objects/Ramps/TokenSelectScreen';
 
 import { RampsRegions, RampsRegionsEnum } from '../../framework/Constants';
 import { Mockttp } from 'mockttp';
-import { setupRegionAwareOnRampMocks } from '../../api-mocking/mock-responses/ramps/ramps-mocks';
+import {
+  setupDepositOnRampMocks,
+  setupBuyOnRampMocks,
+} from '../../api-mocking/mock-responses/ramps/ramps-mocks';
 import { remoteFeatureFlagRampsUnifiedEnabled } from '../../api-mocking/mock-responses/feature-flags-mocks';
 import { setupRemoteFeatureFlagsMock } from '../../api-mocking/helpers/remoteFeatureFlagsHelper';
+import { ONRAMP_PERSONA } from '../../api-mocking/mock-responses/ramps/onramp-persona-data';
 import {
   getEventsPayloads,
   EventPayload,
@@ -21,18 +26,50 @@ import {
 import SoftAssert from '../../framework/SoftAssert';
 
 import { UnifiedRampRoutingType } from '../../../app/reducers/fiatOrders/types';
-
+import TabBarComponent from '../../page-objects/wallet/TabBarComponent';
+import ActivitiesView from '../../page-objects/Transactions/ActivitiesView';
+import KYCScreen from '../../page-objects/Ramps/KYCScreen';
 const selectedRegion = RampsRegions[RampsRegionsEnum.UNITED_STATES];
 
-const unifiedBuyV2Mocks = async (mockServer: Mockttp) => {
+const newUserUnifiedBuyV2Mocks = async (mockServer: Mockttp) => {
+  await setupRemoteFeatureFlagsMock(mockServer, {
+    ...remoteFeatureFlagRampsUnifiedEnabled(true),
+    depositConfig: {
+      active: true,
+      providerApiKey: 'DUMMY_VALUE_FOR_TESTING',
+      entrypoints: { walletActions: true },
+      minimumVersion: '1.0.0',
+    },
+  });
+  await setupDepositOnRampMocks(mockServer, selectedRegion);
+};
+
+const returningUserUnifiedBuyV2Mocks = async (mockServer: Mockttp) => {
   await setupRemoteFeatureFlagsMock(
     mockServer,
     remoteFeatureFlagRampsUnifiedEnabled(true),
   );
-  await setupRegionAwareOnRampMocks(mockServer, selectedRegion);
+  await setupBuyOnRampMocks(mockServer, selectedRegion);
 };
 
-const tokenToBuy = 'ETH';
+// Deposit order mock (ramps-deposit-order-status-response) returns USD; UI shows $ + formatFiatValue
+const nativeDepositOrder = {
+  token: 'ETH',
+  tokenAmount: '0.02455',
+  totalFiat: '$100 USD',
+  feesFiat: '$23.33 USD',
+  quoteDisplayAmount: '100 USD',
+  provider: 'Transak (Staging)',
+};
+
+const aggregatorBuyOrder = {
+  token: 'ETH',
+  tokenAmount: '0.00355',
+  totalFiat: '$15 USD',
+  feesFiat: '$3.5 USD',
+  quoteDisplayAmount: '$15.00',
+  provider: 'Transak (Staging)',
+};
 
 const eventsToCheck: EventPayload[] = [];
 
@@ -45,9 +82,85 @@ const expectedEventNames = [
   expectedEvents.RampsButtonClicked,
   expectedEvents.RampsTokenSelected,
 ];
-
 describe(SmokeRamps('Onramp Unified Buy'), () => {
-  it('build quote', async () => {
+  beforeEach(async () => {
+    await device.clearKeychain();
+  });
+
+  it('New user native flow: Places ETH DEPOSIT order through Transak', async () => {
+    await withFixtures(
+      {
+        fixture: new FixtureBuilder()
+          .withNetworkController(CustomNetworks.Tenderly.Mainnet)
+          .withRampsSelectedRegion(selectedRegion)
+          .withMetaMetricsOptIn()
+          .build(),
+        restartDevice: true,
+        testSpecificMock: newUserUnifiedBuyV2Mocks,
+        endTestfn: async ({ mockServer }) => {
+          const events = await getEventsPayloads(
+            mockServer,
+            expectedEventNames,
+          );
+          eventsToCheck.push(...events);
+        },
+      },
+      async () => {
+        await loginToApp();
+        await WalletView.tapWalletBuyButton();
+        await FundActionMenu.tapUnifiedBuyButton();
+        await TokenSelectScreen.tapTokenByName(nativeDepositOrder.token);
+
+        await BuildQuoteView.tapContinueButton();
+
+        await KYCScreen.tapVerifyIdentityContinueButton();
+
+        await KYCScreen.enterEmail(ONRAMP_PERSONA.email);
+
+        await Assertions.expectElementToBeVisible(KYCScreen.otpScreen, {
+          description: 'OTP code screen is visible before entering code',
+        });
+
+        await KYCScreen.enterOtpCode('000000');
+
+        // Verify order details screen
+        await Assertions.expectElementToBeVisible(OrderDetailsView.container, {
+          elemDescription: 'ramps order confirmation screen',
+        });
+        await Assertions.expectElementToHaveText(
+          OrderDetailsView.tokenAmount,
+          `${nativeDepositOrder.tokenAmount} ${nativeDepositOrder.token}`,
+        );
+
+        for (const text of [
+          nativeDepositOrder.totalFiat,
+          nativeDepositOrder.feesFiat,
+        ]) {
+          await Assertions.expectTextDisplayed(text);
+        }
+
+        await OrderDetailsView.tapCloseButton();
+
+        // Verify order in transfers list
+        await TabBarComponent.tapActivity();
+        await ActivitiesView.tapOnTransfersTab();
+
+        await Assertions.expectTextDisplayed(
+          `${nativeDepositOrder.tokenAmount} ${nativeDepositOrder.token}`,
+        );
+        await ActivitiesView.tapRampsOrder('deposit', 1);
+
+        for (const text of [
+          `${nativeDepositOrder.tokenAmount} ${nativeDepositOrder.token}`,
+          nativeDepositOrder.totalFiat,
+        ]) {
+          await Assertions.expectTextDisplayed(text);
+        }
+      },
+    );
+  });
+
+  it('Returning User Aggregator Flow: Places ETH BUY order', async () => {
     await withFixtures(
       {
         fixture: new FixtureBuilder()
@@ -56,7 +169,7 @@ describe(SmokeRamps('Onramp Unified Buy'), () => {
           .withMetaMetricsOptIn()
           .build(),
         restartDevice: true,
-        testSpecificMock: unifiedBuyV2Mocks,
+        testSpecificMock: returningUserUnifiedBuyV2Mocks,
         endTestfn: async ({ mockServer }) => {
           const events = await getEventsPayloads(
             mockServer,
@@ -69,19 +182,45 @@ describe(SmokeRamps('Onramp Unified Buy'), () => {
         await loginToApp();
         await WalletView.tapWalletBuyButton();
         await FundActionMenu.tapUnifiedBuyButton();
-        /*
-        at the time of this code, the dev team is still working on hooking up the quotes logic
-        as of now, you cannot (both manually and via e2e) go past the continue button
-        there is an animated infinite spinner. And as a result detox is hanging here
-        the disable sync allows detox to proceed without hang
-        Once the code is completed, this should be removed and the test shall go past the continue button
-        */
-        await device.disableSynchronization();
-        await TokenSelectScreen.tapTokenByName(tokenToBuy);
+        await TokenSelectScreen.tapTokenByName(aggregatorBuyOrder.token);
         await BuildQuoteView.tapKeypadDeleteButton(1);
         await BuildQuoteView.enterAmount('15', 'unifiedBuy');
 
-        await Assertions.expectTextDisplayed('$15.00');
+        await BuildQuoteView.tapContinueButton();
+
+        // Verify order details screen
+        await Assertions.expectElementToBeVisible(OrderDetailsView.container, {
+          elemDescription: 'ramps order confirmation screen',
+        });
+        await Assertions.expectElementToHaveText(
+          OrderDetailsView.tokenAmount,
+          `${aggregatorBuyOrder.tokenAmount} ${aggregatorBuyOrder.token}`,
+        );
+
+        for (const text of [
+          aggregatorBuyOrder.totalFiat,
+          aggregatorBuyOrder.feesFiat,
+        ]) {
+          await Assertions.expectTextDisplayed(text);
+        }
+
+        await OrderDetailsView.tapCloseButton();
+
+        // Verify order in transfers list
+        await TabBarComponent.tapActivity();
+        await ActivitiesView.tapOnTransfersTab();
+
+        await Assertions.expectTextDisplayed(
+          `${aggregatorBuyOrder.tokenAmount} ${aggregatorBuyOrder.token}`,
+        );
+        await ActivitiesView.tapRampsOrder('buy', 1);
+
+        for (const text of [
+          `${aggregatorBuyOrder.tokenAmount} ${aggregatorBuyOrder.token}`,
+          aggregatorBuyOrder.totalFiat,
+        ]) {
+          await Assertions.expectTextDisplayed(text);
+        }
       },
     );
   });
@@ -206,16 +345,16 @@ describe(SmokeRamps('Onramp Unified Buy'), () => {
         await Assertions.checkIfObjectContains(
           rampsTokenSelected?.properties ?? {},
           {
-            token_symbol: tokenToBuy,
+            token_symbol: aggregatorBuyOrder.token,
             token_caip19: 'eip155:1/slip44:60',
             currency_destination: 'eip155:1/slip44:60',
-            currency_destination_symbol: tokenToBuy,
+            currency_destination_symbol: aggregatorBuyOrder.token,
             currency_destination_network:
               CustomNetworks.Tenderly.Mainnet.providerConfig.nickname,
             ramp_routing: UnifiedRampRoutingType.DEPOSIT,
           },
         ),
-      `Ramps Token Selected: token_symbol should be ${tokenToBuy}`,
+      `Ramps Token Selected: token_symbol should be ${aggregatorBuyOrder.token}`,
     );
 
     softAssert.throwIfErrors();