diff --git a/.github/workflows/run-performance-e2e.yml b/.github/workflows/run-performance-e2e.yml
index 25510b23154..e95664724cd 100644
--- a/.github/workflows/run-performance-e2e.yml
+++ b/.github/workflows/run-performance-e2e.yml
@@ -8,6 +8,14 @@ on:
         description: 'Optional description for this test run'
         required: false
         type: string
+      browserstack_app_url_android:
+        description: 'BrowserStack Android App URL (bs://...)'
+        required: false
+        type: string
+      browserstack_app_url_ios:
+        description: 'BrowserStack iOS App URL (bs://...)'
+        required: false
+        type: string
 permissions:
   contents: read
   id-token: write
@@ -66,6 +74,8 @@ jobs:
     name: Trigger QA Builds and Extract BrowserStack URLs
     runs-on: ubuntu-latest
     needs: read-device-matrix
+    # Only run if BrowserStack URLs are not provided
+    if: ${{ !inputs.browserstack_app_url_android || !inputs.browserstack_app_url_ios }}
     env:
       BITRISE_APP_ID: ${{ secrets.BITRISE_APP_ID }}
       BITRISE_BUILD_TRIGGER_TOKEN: ${{ secrets.BITRISE_BUILD_TRIGGER_TOKEN }}
@@ -334,8 +344,10 @@ jobs:
   android-tests:
     name: Android Tests
     runs-on: ubuntu-latest
-    timeout-minutes: 45
-    needs: [trigger-qa-builds-and-upload, read-device-matrix]
+    timeout-minutes: 60
+    needs: [read-device-matrix, trigger-qa-builds-and-upload]
+    # Always run after device matrix is ready, regardless of trigger job status
+    if: always() && !failure() && !cancelled()
     strategy:
       fail-fast: false
       matrix:
@@ -389,12 +401,35 @@ jobs:
       - name: Set Android Test Environment
         run: |
           echo "Setting test environment for device: ${{ matrix.device.name }}"
+          
+          # Use BrowserStack URL from trigger job if it ran, otherwise from input
+          ANDROID_APP_URL="${{ needs.trigger-qa-builds-and-upload.outputs.browserstack-android-url }}"
+          if [ -z "$ANDROID_APP_URL" ]; then
+            ANDROID_APP_URL="${{ inputs.browserstack_app_url_android }}"
+            echo "ℹ️ Using Android URL from input (trigger job was skipped)"
+          else
+            echo "ℹ️ Using Android URL from trigger job"
+          fi
+          
+          # Validate that we have a BrowserStack URL
+          if [ -z "$ANDROID_APP_URL" ]; then
+            echo "❌ Error: No Android BrowserStack URL available"
+            echo "Either provide browserstack_app_url_android as input or ensure trigger-qa-builds-and-upload job runs successfully"
+            exit 1
+          fi
+          
+          # Use app version from trigger job if available, otherwise default
+          APP_VERSION="${{ needs.trigger-qa-builds-and-upload.outputs.android-version }}"
+          if [ -z "$APP_VERSION" ]; then
+            APP_VERSION="Manual-Input"
+          fi
+          
           {
             echo "BROWSERSTACK_DEVICE=${{ matrix.device.name }}"
             echo "BROWSERSTACK_OS_VERSION=${{ matrix.device.os_version }}"
-            echo "BROWSERSTACK_ANDROID_APP_URL=${{ needs.trigger-qa-builds-and-upload.outputs.browserstack-android-url }}"
+            echo "BROWSERSTACK_ANDROID_APP_URL=$ANDROID_APP_URL"
             echo "TEST_PLATFORM=android"
-            echo "QA_APP_VERSION=${{ needs.trigger-qa-builds-and-upload.outputs.android-version }}"
+            echo "QA_APP_VERSION=$APP_VERSION"
             echo "BROWSERSTACK_BUILD_NAME=Android-Performance-${{ github.ref_name }}-Branch"
           } >> "$GITHUB_ENV"
       
@@ -407,8 +442,8 @@ jobs:
           echo "OS Version: ${{ matrix.device.os_version }}"
           echo "Category: ${{ matrix.device.category }}"
           echo "Branch: ${{ github.ref_name }}"
-          echo "QA App Version: ${{ needs.trigger-qa-builds-and-upload.outputs.android-version }}"
-          echo "BrowserStack Android App URL: ${{ needs.trigger-qa-builds-and-upload.outputs.browserstack-android-url }}"
+          echo "QA App Version: $QA_APP_VERSION"
+          echo "BrowserStack Android App URL: $BROWSERSTACK_ANDROID_APP_URL"
           
           yarn run-appwright:android-bs
       
@@ -426,8 +461,10 @@ jobs:
   ios-tests:
     name: iOS Tests
     runs-on: ubuntu-latest
-    timeout-minutes: 45
-    needs: [trigger-qa-builds-and-upload, read-device-matrix]
+    timeout-minutes: 60
+    needs: [read-device-matrix, trigger-qa-builds-and-upload]
+    # Always run after device matrix is ready, regardless of trigger job status
+    if: always() && !failure() && !cancelled()
     strategy:
       fail-fast: false
       matrix:
@@ -481,11 +518,34 @@ jobs:
       - name: Set iOS Test Environment
         run: |
           echo "Setting test environment for device: ${{ matrix.device.name }}"
+          
+          # Use BrowserStack URL from trigger job if it ran, otherwise from input
+          IOS_APP_URL="${{ needs.trigger-qa-builds-and-upload.outputs.browserstack-ios-url }}"
+          if [ -z "$IOS_APP_URL" ]; then
+            IOS_APP_URL="${{ inputs.browserstack_app_url_ios }}"
+            echo "ℹ️ Using iOS URL from input (trigger job was skipped)"
+          else
+            echo "ℹ️ Using iOS URL from trigger job"
+          fi
+          
+          # Validate that we have a BrowserStack URL
+          if [ -z "$IOS_APP_URL" ]; then
+            echo "❌ Error: No iOS BrowserStack URL available"
+            echo "Either provide browserstack_app_url_ios as input or ensure trigger-qa-builds-and-upload job runs successfully"
+            exit 1
+          fi
+          
+          # Use app version from trigger job if available, otherwise default
+          APP_VERSION="${{ needs.trigger-qa-builds-and-upload.outputs.ios-version }}"
+          if [ -z "$APP_VERSION" ]; then
+            APP_VERSION="Manual-Input"
+          fi
+          
           {
             echo "BROWSERSTACK_DEVICE=${{ matrix.device.name }}"
             echo "BROWSERSTACK_OS_VERSION=${{ matrix.device.os_version }}"
-            echo "BROWSERSTACK_IOS_APP_URL=${{ needs.trigger-qa-builds-and-upload.outputs.browserstack-ios-url }}"
-            echo "QA_APP_VERSION=${{ needs.trigger-qa-builds-and-upload.outputs.ios-version }}"
+            echo "BROWSERSTACK_IOS_APP_URL=$IOS_APP_URL"
+            echo "QA_APP_VERSION=$APP_VERSION"
             echo "BROWSERSTACK_BUILD_NAME=iOS-Performance-${{ github.ref_name }}-Branch"
           } >> "$GITHUB_ENV"
       
@@ -498,8 +558,8 @@ jobs:
           echo "OS Version: ${{ matrix.device.os_version }}"
           echo "Category: ${{ matrix.device.category }}"
           echo "Branch: ${{ github.ref_name }}"
-          echo "QA App Version: ${{ needs.trigger-qa-builds-and-upload.outputs.ios-version }}"
-          echo "BrowserStack iOS App URL: ${{ needs.trigger-qa-builds-and-upload.outputs.browserstack-ios-url }}"
+          echo "QA App Version: $QA_APP_VERSION"
+          echo "BrowserStack iOS App URL: $BROWSERSTACK_IOS_APP_URL"
           if [ "${{ matrix.device.os_version }}" == "13" ] || [ "${{ matrix.device.os_version }}" == "11" ]; then
             echo "Warning: iOS ${{ matrix.device.os_version }} may not be supported by MetaMask app"
           fi
@@ -521,14 +581,330 @@ jobs:
   gather-results:
     name: Gather Test Results
     runs-on: ubuntu-latest
-    needs: [trigger-qa-builds-and-upload, android-tests, ios-tests]
-    if: always()
+    needs: [android-tests, ios-tests]
+    if: always()  # Always run, even if previous jobs failed
     
     steps:
       - name: Download All Test Results
         uses: actions/download-artifact@v4
         with:
           path: appwright/test-reports/
+        continue-on-error: true  # Continue even if some artifacts are missing due to failed tests
+      
+      - name: Aggregate Performance Reports
+        run: |
+          echo "🔍 Searching for JSON performance reports..."
+          echo "📊 Job status context:"
+          echo "  Android tests: ${{ needs.android-tests.result }}"
+          echo "  iOS tests: ${{ needs.ios-tests.result }}"
+          
+          # Set environment variables for job results
+          export ANDROID_JOB_STATUS="${{ needs.android-tests.result }}"
+          export IOS_JOB_STATUS="${{ needs.ios-tests.result }}"
+          
+          # Create output directory
+          mkdir -p appwright/aggregated-reports
+          
+          # Create aggregated report structure
+          cat > aggregate_reports.js << 'EOF'
+          const fs = require('fs');
+          const path = require('path');
+          
+          function findJsonFiles(dir, jsonFiles = []) {
+            if (!fs.existsSync(dir)) return jsonFiles;
+            
+            const files = fs.readdirSync(dir);
+            for (const file of files) {
+              const fullPath = path.join(dir, file);
+              if (fs.statSync(fullPath).isDirectory()) {
+                findJsonFiles(fullPath, jsonFiles);
+              } else if (file.endsWith('.json') && file.includes('performance-metrics')) {
+                jsonFiles.push(fullPath);
+              }
+            }
+            return jsonFiles;
+          }
+          
+          function aggregateReports() {
+            try {
+              console.log('🔍 Looking for performance JSON reports...');
+            
+            const jsonFiles = findJsonFiles('appwright/test-reports');
+            console.log(`📊 Found ${jsonFiles.length} JSON report files:`);
+            
+            if (jsonFiles.length === 0) {
+              console.log('❌ No performance JSON files found - creating empty report structure');
+              
+              // Create empty report structure when no files are found (in requested format)
+              const emptyReport = {
+                Android: {},
+                iOS: {}
+              };
+              
+              const outputPath = 'appwright/aggregated-reports/aggregated-performance-report.json';
+              fs.writeFileSync(outputPath, JSON.stringify(emptyReport, null, 2));
+              
+              // Create empty summary
+              const emptySummary = {
+                totalTests: 0,
+                platforms: { android: 0, ios: 0 },
+                testsByPlatform: { android: 0, ios: 0 },
+                devices: [],
+                platformDevices: { Android: [], iOS: [] },
+                generatedAt: new Date().toISOString(),
+                branch: process.env.GITHUB_REF_NAME || 'unknown',
+                commit: process.env.GITHUB_SHA || 'unknown',
+                warning: 'No test results found'
+              };
+              
+              fs.writeFileSync('appwright/aggregated-reports/summary.json', JSON.stringify(emptySummary, null, 2));
+              
+              console.log('✅ Empty report structure created successfully');
+              console.log(`📄 Empty report saved to: ${outputPath}`);
+              console.log('📋 Empty summary saved to: appwright/aggregated-reports/summary.json');
+              return;
+            }
+            
+            // Create the new grouped structure
+            const groupedResults = {
+              Android: {},
+              iOS: {}
+            };
+            
+            const metadata = {
+              generatedAt: new Date().toISOString(),
+              totalReports: jsonFiles.length,
+              platforms: {
+                android: 0,
+                ios: 0
+              },
+              jobResults: {
+                android: process.env.ANDROID_JOB_STATUS || 'unknown',
+                ios: process.env.IOS_JOB_STATUS || 'unknown'
+              },
+              branch: process.env.GITHUB_REF_NAME || 'unknown',
+              commit: process.env.GITHUB_SHA || 'unknown',
+              workflowRun: process.env.GITHUB_RUN_ID || 'unknown'
+            };
+            
+            jsonFiles.forEach(filePath => {
+              try {
+                const content = fs.readFileSync(filePath, 'utf8');
+                const reportData = JSON.parse(content);
+                
+                // Extract platform and device info from path or content
+                const pathParts = filePath.split('/');
+                let platform = 'unknown';
+                let platformKey = 'Unknown';
+                let deviceInfo = 'unknown';
+                let deviceKey = 'Unknown Device';
+                
+                // Try to determine platform from path
+                if (filePath.includes('android-test-results')) {
+                  platform = 'android';
+                  platformKey = 'Android';
+                  metadata.platforms.android++;
+                } else if (filePath.includes('ios-test-results')) {
+                  platform = 'ios';
+                  platformKey = 'iOS';
+                  metadata.platforms.ios++;
+                }
+                
+                // Extract device info from path (e.g., android-test-results-Samsung Galaxy S21-11)
+                const deviceMatch = pathParts.find(part => part.includes('-test-results-'));
+                if (deviceMatch) {
+                  const parts = deviceMatch.split('-');
+                  if (parts.length >= 4) {
+                    deviceInfo = parts.slice(3).join('-');
+                    // Create device key in format "DeviceName+OSVersion"
+                    const deviceParts = deviceInfo.split('-');
+                    if (deviceParts.length >= 2) {
+                      const osVersion = deviceParts[deviceParts.length - 1];
+                      const deviceName = deviceParts.slice(0, -1).join(' ');
+                      deviceKey = `${deviceName}+${osVersion}`;
+                    } else {
+                      deviceKey = deviceInfo;
+                    }
+                  }
+                } else {
+                  // Fallback: try to extract from full path or use device info from report data
+                  if (Array.isArray(reportData) && reportData.length > 0 && reportData[0].device) {
+                    const device = reportData[0].device;
+                    deviceKey = `${device.name}+${device.osVersion}`;
+                  } else if (reportData.device) {
+                    const device = reportData.device;
+                    deviceKey = `${device.name}+${device.osVersion}`;
+                  }
+                }
+                
+                // Initialize platform and device arrays if they don't exist
+                if (!groupedResults[platformKey]) {
+                  groupedResults[platformKey] = {};
+                }
+                if (!groupedResults[platformKey][deviceKey]) {
+                  groupedResults[platformKey][deviceKey] = [];
+                }
+                
+                // Process the report data (array of test results)
+                const processTestReport = (testReport) => {
+                  const cleanedReport = {
+                    testName: testReport.testName,
+                    steps: testReport.steps || [],
+                    totalTime: testReport.total,
+                    videoURL: testReport.videoURL || null
+                  };
+                  
+                  // Add failure info if test failed (optional - include if you want failure info in final output)
+                  if (testReport.testFailed) {
+                    cleanedReport.testFailed = true;
+                    cleanedReport.failureReason = testReport.failureReason;
+                  }
+                  
+                  groupedResults[platformKey][deviceKey].push(cleanedReport);
+                };
+                
+                if (Array.isArray(reportData)) {
+                  reportData.forEach(processTestReport);
+                } else {
+                  // Single test report
+                  processTestReport(reportData);
+                }
+              } catch (error) {
+                console.error(`❌ Error processing ${filePath}: ${error.message}`);
+                return;
+              }
+            });
+            
+            // Create final report in the exact format requested (just Android and iOS at root level)
+            const finalReport = {
+              Android: groupedResults.Android || {},
+              iOS: groupedResults.iOS || {}
+            };
+            
+            // Write the aggregated report in the requested format
+            const outputPath = 'appwright/aggregated-reports/aggregated-performance-report.json';
+            fs.writeFileSync(outputPath, JSON.stringify(finalReport, null, 2));
+            
+            // Also create a pretty-formatted version for easier viewing
+            const prettyOutputPath = 'appwright/aggregated-reports/performance-results.json';
+            fs.writeFileSync(prettyOutputPath, JSON.stringify(finalReport, null, 4));
+            
+            // Count total tests across all platforms and devices
+            let totalTests = 0;
+            const devices = [];
+            
+            Object.keys(groupedResults).forEach(platform => {
+              Object.keys(groupedResults[platform]).forEach(device => {
+                devices.push(`${platform}-${device}`);
+                totalTests += groupedResults[platform][device].length;
+              });
+            });
+            
+            console.log(`✅ Aggregated report saved: ${totalTests} tests across ${devices.length} device configurations`);
+            console.log(`📊 Platform summary:`);
+            console.log(`   Android: ${metadata.platforms.android} reports (job: ${metadata.jobResults.android})`);
+            console.log(`   iOS: ${metadata.platforms.ios} reports (job: ${metadata.jobResults.ios})`);
+            
+            // Show which platforms had data
+            const androidHasData = Object.keys(groupedResults.Android).length > 0;
+            const iosHasData = Object.keys(groupedResults.iOS).length > 0;
+            
+            if (!androidHasData && metadata.jobResults.android === 'failure') {
+              console.log(`⚠️ Android tests failed - no Android performance data available`);
+            }
+            if (!iosHasData && metadata.jobResults.ios === 'failure') {
+              console.log(`⚠️ iOS tests failed - no iOS performance data available`);
+            }
+            if (androidHasData || iosHasData) {
+              console.log(`✅ Successfully aggregated data from available platforms`);
+            }
+            
+            // Create summary file with metadata
+            const summary = {
+              totalTests,
+              platforms: metadata.platforms,
+              testsByPlatform: {
+                android: 0,
+                ios: 0
+              },
+              devices: [],
+              platformDevices: {
+                Android: Object.keys(groupedResults.Android || {}),
+                iOS: Object.keys(groupedResults.iOS || {})
+              },
+              metadata,
+              generatedAt: metadata.generatedAt,
+              branch: metadata.branch,
+              commit: metadata.commit
+            };
+            
+            // Count tests by platform and collect device info
+            Object.keys(groupedResults).forEach(platform => {
+              Object.keys(groupedResults[platform]).forEach(device => {
+                const testsCount = groupedResults[platform][device].length;
+                if (platform === 'Android') {
+                  summary.testsByPlatform.android += testsCount;
+                } else if (platform === 'iOS') {
+                  summary.testsByPlatform.ios += testsCount;
+                }
+                summary.devices.push({ platform, device, testCount: testsCount });
+              });
+            });
+            
+            fs.writeFileSync('appwright/aggregated-reports/summary.json', JSON.stringify(summary, null, 2));
+            console.log('📋 Summary report saved to: appwright/aggregated-reports/summary.json');
+            
+            } catch (error) {
+              console.error('❌ Error during aggregation:', error.message);
+              console.log('🔄 Creating fallback empty report due to aggregation error...');
+              
+              // Create fallback empty report structure (in requested format)
+              const fallbackReport = {
+                Android: {},
+                iOS: {}
+              };
+              
+              try {
+                fs.writeFileSync('appwright/aggregated-reports/aggregated-performance-report.json', JSON.stringify(fallbackReport, null, 2));
+                fs.writeFileSync('appwright/aggregated-reports/summary.json', JSON.stringify({
+                  totalTests: 0,
+                  platforms: { android: 0, ios: 0 },
+                  error: error.message,
+                  generatedAt: new Date().toISOString()
+                }, null, 2));
+                console.log('✅ Fallback reports created successfully');
+              } catch (writeError) {
+                console.error('❌ Failed to create fallback reports:', writeError.message);
+              }
+            }
+          }
+          
+          aggregateReports();
+          EOF
+          
+          # Run the aggregation script (ensure it doesn't fail the step)
+          echo ""
+          echo "🔄 Running aggregation script..."
+          node aggregate_reports.js || {
+            echo "⚠️ Aggregation script had issues, but continuing to ensure reports are available"
+            echo "This is normal when some test jobs failed - we'll aggregate whatever data is available"
+          }
+          
+          # Ensure output directory exists even if script failed
+          mkdir -p appwright/aggregated-reports
+          
+          # List generated files and show structure
+          echo "📁 Generated files:"
+          ls -la appwright/aggregated-reports/ || echo "📁 No aggregated reports directory found"
+          
+          # Show a sample of the aggregated report structure if it exists
+          if [ -f "appwright/aggregated-reports/aggregated-performance-report.json" ]; then
+            echo ""
+            echo "📋 Sample of aggregated report structure:"
+            echo "========================================="
+            head -50 appwright/aggregated-reports/aggregated-performance-report.json || echo "Could not display file contents"
+            echo "========================================="
+          fi
       
       - name: Upload Combined Reports
         if: always()
@@ -538,31 +914,36 @@ jobs:
           path: |
             appwright/test-reports/appwright-report/
             appwright/reporters/reports
+            appwright/aggregated-reports/
           if-no-files-found: ignore
           retention-days: 14
     
-      - name: Check Test Results
+      - name: Check Test Results  
         id: test-results
         run: |
-          if [ "${{ needs.android-tests.result }}" == "failure" ] || [ "${{ needs.ios-tests.result }}" == "failure" ]; then
-            echo "Some tests failed. Check the individual job results above."
-            echo "Note: iOS 13 and iOS 11 failures are expected due to MetaMask app compatibility."
-            echo "overall_status=failure" >> "$GITHUB_OUTPUT"
-            exit 1
+          ANDROID_STATUS="${{ needs.android-tests.result }}"
+          IOS_STATUS="${{ needs.ios-tests.result }}"
+          
+          echo "📊 Test Results Summary:"
+          echo "  Android tests: $ANDROID_STATUS"
+          echo "  iOS tests: $IOS_STATUS"
+          
+          # Check if we have any performance data available
+          if [ -f "appwright/aggregated-reports/aggregated-performance-report.json" ]; then
+            echo "✅ Performance data aggregated successfully from available test results"
+            
+            if [ "$ANDROID_STATUS" == "failure" ] || [ "$IOS_STATUS" == "failure" ]; then
+              echo "⚠️ Some tests failed, but performance data was collected from successful tests"
+              echo "Note: This is expected behavior - we collect data from passing tests even when others fail"
+              echo "overall_status=partial_success" >> "$GITHUB_OUTPUT"
+            else
+              echo "🎉 All test jobs completed successfully with full performance data!"
+              echo "overall_status=success" >> "$GITHUB_OUTPUT"
+            fi
           else
-            echo "All test jobs completed successfully!"
-            echo "overall_status=success" >> "$GITHUB_OUTPUT"
+            echo "❌ No performance data could be aggregated - all tests may have failed"
+            echo "overall_status=failure" >> "$GITHUB_OUTPUT"
           fi
-      
-      - name: Display QA Build Info
-        run: |
-          echo "=== QA Build Information ==="
-          echo "Android Version: ${{ needs.trigger-qa-builds-and-upload.outputs.android-version }}"
-          echo "iOS Version: ${{ needs.trigger-qa-builds-and-upload.outputs.ios-version }}"
-          echo ""
-          echo "=== BrowserStack App URLs ==="
-          echo "Android App URL: ${{ needs.trigger-qa-builds-and-upload.outputs.browserstack-android-url }}"
-          echo "iOS App URL: ${{ needs.trigger-qa-builds-and-upload.outputs.browserstack-ios-url }}"
     
     outputs:
       overall_status: ${{ steps.test-results.outputs.overall_status }}
@@ -594,16 +975,27 @@ jobs:
           echo "- android-tests: $ANDROID_RESULT"
           echo "- ios-tests: $IOS_RESULT"
           
+          # Get gather-results status
+          GATHER_RESULT="${{ needs.gather-results.outputs.overall_status }}"
+          echo "- gather-results: $GATHER_RESULT"
+          
           # Determine overall status
           if [ "$TRIGGER_RESULT" = "failure" ]; then
             OVERALL_STATUS="❌ FAILED"
             echo "Overall Status: FAILED (QA builds failed)"
-          elif [ "$ANDROID_RESULT" = "failure" ] || [ "$IOS_RESULT" = "failure" ]; then
+          elif [ "$GATHER_RESULT" = "failure" ]; then
             OVERALL_STATUS="❌ FAILED"
-            echo "Overall Status: FAILED (tests failed)"
+            echo "Overall Status: FAILED (No performance data collected - all tests failed)"
+          elif [ "$GATHER_RESULT" = "partial_success" ] || [ "$ANDROID_RESULT" = "failure" ] || [ "$IOS_RESULT" = "failure" ]; then
+            OVERALL_STATUS="⚠️ PARTIAL SUCCESS"
+            echo "Overall Status: PARTIAL SUCCESS (Some tests failed, but performance data was collected)"
           else
             OVERALL_STATUS="✅ PASSED"
-            echo "Overall Status: PASSED (all tests passed)"
+            if [ "$TRIGGER_RESULT" = "skipped" ]; then
+              echo "Overall Status: PASSED (All tests passed with performance data - used provided BrowserStack URLs)"
+            else
+              echo "Overall Status: PASSED (All tests passed with performance data)"
+            fi
           fi
           
           # Set outputs
diff --git a/app/component-library/components-temp/MultichainAccounts/MultichainAccountSelectorList/MultichainAccountSelectorList.tsx b/app/component-library/components-temp/MultichainAccounts/MultichainAccountSelectorList/MultichainAccountSelectorList.tsx
index 48b8baa56ef..08d077d9a44 100644
--- a/app/component-library/components-temp/MultichainAccounts/MultichainAccountSelectorList/MultichainAccountSelectorList.tsx
+++ b/app/component-library/components-temp/MultichainAccounts/MultichainAccountSelectorList/MultichainAccountSelectorList.tsx
@@ -151,6 +151,20 @@ const MultichainAccountSelectorList = ({
     return items;
   }, [filteredWalletSections]);
 
+  // Reset scroll to top when search text changes
+  useEffect(() => {
+    if (listRefToUse.current) {
+      // Use requestAnimationFrame to ensure the list has finished re-rendering
+      const animationFrameId = requestAnimationFrame(() => {
+        listRefToUse.current?.scrollToOffset({ offset: 0, animated: false });
+      });
+
+      return () => {
+        cancelAnimationFrame(animationFrameId);
+      };
+    }
+  }, [debouncedSearchText, listRefToUse]);
+
   // Listen for account creation and scroll to new account
   useEffect(() => {
     if (lastCreatedAccountId && listRefToUse.current) {
diff --git a/app/component-library/components/Skeleton/Skeleton.tsx b/app/component-library/components/Skeleton/Skeleton.tsx
index d15565b67a4..7aa7b3c8f55 100644
--- a/app/component-library/components/Skeleton/Skeleton.tsx
+++ b/app/component-library/components/Skeleton/Skeleton.tsx
@@ -30,10 +30,6 @@ const Skeleton: React.FC<SkeletonProps> = ({
   });
 
   const startAnimation = () => {
-    // On E2E, we don't want to animate the skeleton otherwise recurring timers will be ON.
-    if (isE2E) {
-      return;
-    }
     Animated.sequence([
       Animated.timing(opacityAnim, {
         toValue: 0.1,
@@ -56,7 +52,7 @@ const Skeleton: React.FC<SkeletonProps> = ({
 
   useEffect(() => {
     // Only start animation if no children are present or if children should be hidden
-    if (!children || hideChildren) {
+    if (!isE2E && (!children || hideChildren)) {
       startAnimation();
     }
 
diff --git a/app/components/UI/AddCustomCollectible/__snapshots__/index.test.tsx.snap b/app/components/UI/AddCustomCollectible/__snapshots__/index.test.tsx.snap
index d7aa66d46ed..58c9cfdb76b 100644
--- a/app/components/UI/AddCustomCollectible/__snapshots__/index.test.tsx.snap
+++ b/app/components/UI/AddCustomCollectible/__snapshots__/index.test.tsx.snap
@@ -27,6 +27,11 @@ exports[`AddCustomCollectible should render correctly 1`] = `
     }
   }
 >
-  <AddCustomCollectible />
+  <AddCustomCollectible
+    networkClientId=""
+    networkId=""
+    selectedNetwork=""
+    setOpenNetworkSelector={[MockFunction]}
+  />
 </ContextProvider>
 `;
diff --git a/app/components/UI/AddCustomCollectible/index.test.tsx b/app/components/UI/AddCustomCollectible/index.test.tsx
index 9290c24ada9..6ff1760f26e 100644
--- a/app/components/UI/AddCustomCollectible/index.test.tsx
+++ b/app/components/UI/AddCustomCollectible/index.test.tsx
@@ -5,10 +5,11 @@ import configureMockStore from 'redux-mock-store';
 import { Provider } from 'react-redux';
 import initialRootState from '../../../util/test/initial-root-state';
 import renderWithProvider from '../../../util/test/renderWithProvider';
-import { act, fireEvent } from '@testing-library/react-native';
+import { act, fireEvent, waitFor } from '@testing-library/react-native';
 import Engine from '../../../core/Engine';
 // eslint-disable-next-line import/no-namespace
 import * as utilsTransactions from '../../../util/transactions';
+import { Alert } from 'react-native';
 
 jest.mock('../../../core/Engine', () => ({
   context: {
@@ -33,20 +34,47 @@ jest.mock('react-redux', () => ({
   useSelector: jest.fn().mockImplementation(() => ''),
 }));
 
+jest.mock('react-native', () => {
+  const RN = jest.requireActual('react-native');
+  return {
+    ...RN,
+    Alert: {
+      alert: jest.fn(),
+    },
+  };
+});
+
+jest.mock('../../../../locales/i18n', () => ({
+  strings: jest.fn((key) => key),
+}));
+
 describe('AddCustomCollectible', () => {
   it('should render correctly', () => {
     const wrapper = shallow(
       <Provider store={store}>
-        <AddCustomCollectible />
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={''}
+          selectedNetwork={''}
+          networkClientId={''}
+        />
       </Provider>,
     );
     expect(wrapper).toMatchSnapshot();
   });
 
   it('handles address input changes', () => {
-    const { getByTestId } = renderWithProvider(<AddCustomCollectible />, {
-      state: initialRootState,
-    });
+    const { getByTestId } = renderWithProvider(
+      <AddCustomCollectible
+        setOpenNetworkSelector={jest.fn()}
+        networkId={''}
+        selectedNetwork={''}
+        networkClientId={''}
+      />,
+      {
+        state: initialRootState,
+      },
+    );
 
     const textfield = getByTestId('input-collectible-address');
     fireEvent.changeText(textfield, '0xtestAddress');
@@ -54,9 +82,17 @@ describe('AddCustomCollectible', () => {
   });
 
   it('handles tokenId input changes', () => {
-    const { getByTestId } = renderWithProvider(<AddCustomCollectible />, {
-      state: initialRootState,
-    });
+    const { getByTestId } = renderWithProvider(
+      <AddCustomCollectible
+        setOpenNetworkSelector={jest.fn()}
+        networkId={''}
+        selectedNetwork={''}
+        networkClientId={''}
+      />,
+      {
+        state: initialRootState,
+      },
+    );
 
     const textfield = getByTestId('input-collectible-identifier');
     fireEvent.changeText(textfield, '55');
@@ -79,6 +115,10 @@ describe('AddCustomCollectible', () => {
     const { getByTestId } = renderWithProvider(
       <AddCustomCollectible
         navigation={{ navigate: jest.fn(), goBack: jest.fn() }}
+        setOpenNetworkSelector={jest.fn()}
+        networkId={''}
+        selectedNetwork={''}
+        networkClientId={''}
       />,
       { state: initialRootState },
     );
@@ -100,4 +140,600 @@ describe('AddCustomCollectible', () => {
 
     expect(spyOnAddNft).toHaveBeenCalledTimes(1);
   });
+
+  describe('Validation Functions', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('shows warning when address is empty and input loses focus', async () => {
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+      fireEvent(addressInput, 'onBlur');
+
+      await waitFor(() => {
+        const warningText = getByTestId('collectible-address-warning');
+        expect(warningText.props.children).toBe(
+          'collectible.address_cant_be_empty',
+        );
+      });
+    });
+
+    it('shows warning when address is invalid and input loses focus', async () => {
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+      fireEvent.changeText(addressInput, 'invalid-address');
+      fireEvent(addressInput, 'onBlur');
+
+      await waitFor(() => {
+        const warningText = getByTestId('collectible-address-warning');
+        expect(warningText.props.children).toBe(
+          'collectible.address_must_be_valid',
+        );
+      });
+    });
+
+    it('shows warning when address is not a smart contract and input loses focus', async () => {
+      jest
+        .spyOn(utilsTransactions, 'isSmartContractAddress')
+        .mockResolvedValue(false);
+
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+      fireEvent.changeText(
+        addressInput,
+        '0x1a92f7381b9f03921564a437210bb9396471050c',
+      );
+      fireEvent(addressInput, 'onBlur');
+
+      await waitFor(() => {
+        const warningText = getByTestId('collectible-address-warning');
+        expect(warningText.props.children).toBe(
+          'collectible.address_must_be_smart_contract',
+        );
+      });
+    });
+
+    it('clears address warning when valid smart contract address is entered', async () => {
+      jest
+        .spyOn(utilsTransactions, 'isSmartContractAddress')
+        .mockResolvedValue(true);
+
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+      fireEvent.changeText(
+        addressInput,
+        '0x1a92f7381b9f03921564a437210bb9396471050c',
+      );
+      fireEvent(addressInput, 'onBlur');
+
+      await waitFor(() => {
+        const warningText = getByTestId('collectible-address-warning');
+        expect(warningText.props.children).toBe('');
+      });
+    });
+
+    it('shows warning when token ID is empty and input loses focus', () => {
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const tokenIdInput = getByTestId('input-collectible-identifier');
+      fireEvent(tokenIdInput, 'onBlur');
+
+      const warningText = getByTestId('collectible-identifier-warning');
+      expect(warningText.props.children).toBe(
+        'collectible.token_id_cant_be_empty',
+      );
+    });
+
+    it('clears token ID warning when value is entered', () => {
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const tokenIdInput = getByTestId('input-collectible-identifier');
+      fireEvent.changeText(tokenIdInput, '123');
+      fireEvent(tokenIdInput, 'onBlur');
+
+      const warningText = getByTestId('collectible-identifier-warning');
+      expect(warningText.props.children).toBe('');
+    });
+  });
+
+  describe('Ownership Validation', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+      jest
+        .spyOn(utilsTransactions, 'isSmartContractAddress')
+        .mockResolvedValue(true);
+    });
+
+    it('shows alert when user is not the owner of NFT', async () => {
+      jest
+        .spyOn(Engine.context.NftController, 'isNftOwner')
+        .mockResolvedValue(false);
+      const alertSpy = jest.spyOn(Alert, 'alert');
+
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          navigation={{ navigate: jest.fn(), goBack: jest.fn() }}
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+      fireEvent.changeText(
+        addressInput,
+        '0x1a92f7381b9f03921564a437210bb9396471050c',
+      );
+
+      const tokenIdInput = getByTestId('input-collectible-identifier');
+      fireEvent.changeText(tokenIdInput, '55');
+
+      const button = getByTestId('add-collectible-button');
+
+      await act(async () => {
+        fireEvent.press(button);
+      });
+
+      expect(alertSpy).toHaveBeenCalledWith(
+        'collectible.not_owner_error_title',
+        'collectible.not_owner_error',
+      );
+    });
+
+    it('shows alert when ownership verification fails', async () => {
+      jest
+        .spyOn(Engine.context.NftController, 'isNftOwner')
+        .mockRejectedValue(new Error('Network error'));
+      const alertSpy = jest.spyOn(Alert, 'alert');
+
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          navigation={{ navigate: jest.fn(), goBack: jest.fn() }}
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+      fireEvent.changeText(
+        addressInput,
+        '0x1a92f7381b9f03921564a437210bb9396471050c',
+      );
+
+      const tokenIdInput = getByTestId('input-collectible-identifier');
+      fireEvent.changeText(tokenIdInput, '55');
+
+      const button = getByTestId('add-collectible-button');
+
+      await act(async () => {
+        fireEvent.press(button);
+      });
+
+      expect(alertSpy).toHaveBeenCalledWith(
+        'collectible.ownership_verification_error_title',
+        'collectible.ownership_verification_error',
+      );
+    });
+  });
+
+  describe('State Management', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('manages loading state during NFT addition', async () => {
+      jest
+        .spyOn(Engine.context.NftController, 'isNftOwner')
+        .mockResolvedValue(true);
+      jest
+        .spyOn(Engine.context.NftController, 'addNft')
+        .mockImplementation(
+          () => new Promise((resolve) => setTimeout(resolve, 100)),
+        );
+      jest
+        .spyOn(utilsTransactions, 'isSmartContractAddress')
+        .mockResolvedValue(true);
+
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          navigation={{ navigate: jest.fn(), goBack: jest.fn() }}
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+      fireEvent.changeText(
+        addressInput,
+        '0x1a92f7381b9f03921564a437210bb9396471050c',
+      );
+
+      const tokenIdInput = getByTestId('input-collectible-identifier');
+      fireEvent.changeText(tokenIdInput, '55');
+
+      const button = getByTestId('add-collectible-button');
+
+      act(() => {
+        fireEvent.press(button);
+      });
+
+      // Button should be disabled during loading
+      expect(button.props.disabled).toBeTruthy();
+    });
+
+    it('sets address from collectibleContract prop on mount', () => {
+      const collectibleContract = {
+        address: '0x1a92f7381b9f03921564a437210bb9396471050c',
+      };
+
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          collectibleContract={collectibleContract}
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+      expect(addressInput.props.value).toBe(collectibleContract.address);
+    });
+
+    it('confirms button is disabled when required fields are missing', () => {
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const button = getByTestId('add-collectible-button');
+      expect(button.props.disabled).toBeTruthy();
+    });
+
+    it('enables confirm button when all required fields are filled', () => {
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+      fireEvent.changeText(
+        addressInput,
+        '0x1a92f7381b9f03921564a437210bb9396471050c',
+      );
+
+      const tokenIdInput = getByTestId('input-collectible-identifier');
+      fireEvent.changeText(tokenIdInput, '55');
+
+      const button = getByTestId('add-collectible-button');
+      expect(button.props.disabled).toBeFalsy();
+    });
+
+    it('disables confirm button when network is not selected', () => {
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={null}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+      fireEvent.changeText(
+        addressInput,
+        '0x1a92f7381b9f03921564a437210bb9396471050c',
+      );
+
+      const tokenIdInput = getByTestId('input-collectible-identifier');
+      fireEvent.changeText(tokenIdInput, '55');
+
+      const button = getByTestId('add-collectible-button');
+      expect(button.props.disabled).toBeTruthy();
+    });
+  });
+
+  describe('Navigation Interactions', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('calls navigation.goBack when cancel is pressed', () => {
+      const mockGoBack = jest.fn();
+      const navigation = { navigate: jest.fn(), goBack: mockGoBack };
+
+      const { getByText } = renderWithProvider(
+        <AddCustomCollectible
+          navigation={navigation}
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const cancelButton = getByText(
+        'add_asset.collectibles.cancel_add_collectible',
+      );
+      fireEvent.press(cancelButton);
+
+      expect(mockGoBack).toHaveBeenCalledTimes(1);
+    });
+
+    it('calls navigation.goBack after successful NFT addition', async () => {
+      const mockGoBack = jest.fn();
+      const navigation = { navigate: jest.fn(), goBack: mockGoBack };
+
+      jest
+        .spyOn(Engine.context.NftController, 'isNftOwner')
+        .mockResolvedValue(true);
+      jest
+        .spyOn(Engine.context.NftController, 'addNft')
+        .mockResolvedValue(undefined);
+      jest
+        .spyOn(utilsTransactions, 'isSmartContractAddress')
+        .mockResolvedValue(true);
+
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          navigation={navigation}
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+      fireEvent.changeText(
+        addressInput,
+        '0x1a92f7381b9f03921564a437210bb9396471050c',
+      );
+
+      const tokenIdInput = getByTestId('input-collectible-identifier');
+      fireEvent.changeText(tokenIdInput, '55');
+
+      const button = getByTestId('add-collectible-button');
+
+      await act(async () => {
+        fireEvent.press(button);
+      });
+
+      expect(mockGoBack).toHaveBeenCalledTimes(1);
+    });
+
+    it('opens network selector when network selector button is pressed', () => {
+      const mockSetOpenNetworkSelector = jest.fn();
+
+      const { getAllByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={mockSetOpenNetworkSelector}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const networkButtons = getAllByTestId('select-network-button');
+      const networkButton = networkButtons[1]; // Get the TouchableOpacity button
+      fireEvent.press(networkButton);
+
+      expect(mockSetOpenNetworkSelector).toHaveBeenCalledWith(true);
+    });
+  });
+
+  describe('Input Interactions', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('focuses token ID input when address input is submitted', () => {
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const addressInput = getByTestId('input-collectible-address');
+
+      fireEvent(addressInput, 'onSubmitEditing');
+
+      // Since we can't easily test focus in React Native Testing Library,
+      // we verify the onSubmitEditing handler exists
+      expect(addressInput.props.onSubmitEditing).toBeDefined();
+    });
+
+    it('calls addNft when token ID input is submitted', () => {
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const tokenIdInput = getByTestId('input-collectible-identifier');
+
+      // Verify the onSubmitEditing handler exists for token ID input
+      expect(tokenIdInput.props.onSubmitEditing).toBeDefined();
+      expect(tokenIdInput.props.returnKeyType).toBe('done');
+    });
+  });
+
+  describe('Props Variations', () => {
+    it('renders without navigation prop', () => {
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      expect(getByTestId('import-nft-screen')).toBeTruthy();
+    });
+
+    it('renders with empty selectedNetwork', () => {
+      const { getByText } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={''}
+          selectedNetwork={''}
+          networkClientId={''}
+        />,
+        { state: initialRootState },
+      );
+
+      expect(getByText('networks.select_network')).toBeTruthy();
+    });
+
+    it('renders network avatar when selectedNetwork is provided', () => {
+      const { getAllByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const networkButtons = getAllByTestId('select-network-button');
+      expect(networkButtons.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Analytics and Error Handling', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('handles analytics parameter generation error gracefully', () => {
+      // Mock console.error to prevent error output during test
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+
+      // This tests the getAnalyticsParams function when it encounters an error
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'invalid-chain-id'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      expect(getByTestId('import-nft-screen')).toBeTruthy();
+
+      consoleSpy.mockRestore();
+    });
+
+    it('stops loading and returns early when validation fails', async () => {
+      const mockAddNft = jest.spyOn(Engine.context.NftController, 'addNft');
+
+      const { getByTestId } = renderWithProvider(
+        <AddCustomCollectible
+          navigation={{ navigate: jest.fn(), goBack: jest.fn() }}
+          setOpenNetworkSelector={jest.fn()}
+          networkId={'0x1'}
+          selectedNetwork={'Ethereum Mainnet'}
+          networkClientId={'mainnet'}
+        />,
+        { state: initialRootState },
+      );
+
+      const button = getByTestId('add-collectible-button');
+
+      await act(async () => {
+        fireEvent.press(button);
+      });
+
+      // Should not call addNft when validation fails
+      expect(mockAddNft).not.toHaveBeenCalled();
+    });
+  });
 });
diff --git a/app/components/UI/AddCustomCollectible/index.tsx b/app/components/UI/AddCustomCollectible/index.tsx
index 6fbb661921b..1312b0db090 100644
--- a/app/components/UI/AddCustomCollectible/index.tsx
+++ b/app/components/UI/AddCustomCollectible/index.tsx
@@ -1,6 +1,13 @@
 import React, { useState, useEffect, useCallback } from 'react';
 import { useSelector } from 'react-redux';
-import { Alert, Text, TextInput, View, StyleSheet } from 'react-native';
+import {
+  Alert,
+  Text,
+  TextInput,
+  View,
+  StyleSheet,
+  TouchableOpacity,
+} from 'react-native';
 import { fontStyles } from '../../../styles/common';
 import Engine from '../../../core/Engine';
 import { strings } from '../../../../locales/i18n';
@@ -17,10 +24,23 @@ import {
   selectSelectedNetworkClientId,
 } from '../../../selectors/networkController';
 import { selectSelectedInternalAccountFormattedAddress } from '../../../selectors/accountsController';
-import { getDecimalChainId } from '../../../util/networks';
+import {
+  getDecimalChainId,
+  getNetworkImageSource,
+} from '../../../util/networks';
 import { useMetrics } from '../../../components/hooks/useMetrics';
 import Logger from '../../../util/Logger';
 import { TraceName, endTrace, trace } from '../../../util/trace';
+import {
+  IconColor,
+  IconName,
+} from '../../../component-library/components/Icons/Icon';
+import { ImportTokenViewSelectorsIDs } from '../../../../e2e/selectors/wallet/ImportTokenView.selectors';
+import ButtonIcon from '../../../component-library/components/Buttons/ButtonIcon';
+import Avatar, {
+  AvatarSize,
+  AvatarVariant,
+} from '../../../component-library/components/Avatars/Avatar';
 
 // TODO: Replace "any" with type
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -57,6 +77,29 @@ const createStyles = (colors: any) =>
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       ...(fontStyles.normal as any),
     },
+    networkSelectorContainer: {
+      flexDirection: 'row',
+      alignItems: 'center',
+      justifyContent: 'space-between',
+      padding: 16,
+      borderWidth: 1,
+      borderColor: colors.border.default,
+      borderRadius: 8,
+      marginBottom: 16,
+    },
+    networkSelectorText: {
+      ...fontStyles.normal,
+      color: colors.text.default,
+      fontSize: 16,
+    },
+    overlappingAvatarsContainer: {
+      flexDirection: 'row',
+      alignItems: 'center',
+      justifyContent: 'space-between',
+    },
+    buttonIcon: {
+      marginLeft: 16,
+    },
   });
 
 interface AddCustomCollectibleProps {
@@ -66,11 +109,19 @@ interface AddCustomCollectibleProps {
   collectibleContract?: {
     address: string;
   };
+  setOpenNetworkSelector: (open: boolean) => void;
+  networkId: string;
+  selectedNetwork: string | null;
+  networkClientId: string | null;
 }
 
 const AddCustomCollectible = ({
   navigation,
   collectibleContract,
+  setOpenNetworkSelector,
+  networkId,
+  selectedNetwork,
+  networkClientId,
 }: AddCustomCollectibleProps) => {
   const [mounted, setMounted] = useState<boolean>(true);
   const [address, setAddress] = useState<string>('');
@@ -122,13 +173,14 @@ const AddCustomCollectible = ({
   const validateCustomCollectibleAddress = async (): Promise<boolean> => {
     let validated = true;
     const isValidEthAddress = isValidAddress(address);
+    const clientId = networkClientId || selectedNetworkClientId;
     if (address.length === 0) {
       setWarningAddress(strings('collectible.address_cant_be_empty'));
       validated = false;
     } else if (!isValidEthAddress) {
       setWarningAddress(strings('collectible.address_must_be_valid'));
       validated = false;
-    } else if (!(await isSmartContractAddress(address, chainId))) {
+    } else if (!(await isSmartContractAddress(address, chainId, clientId))) {
       setWarningAddress(strings('collectible.address_must_be_smart_contract'));
       validated = false;
     } else {
@@ -168,6 +220,7 @@ const AddCustomCollectible = ({
         selectedAddress,
         address,
         tokenId,
+        networkClientId,
       );
 
       if (!isOwner)
@@ -204,7 +257,7 @@ const AddCustomCollectible = ({
 
     trace({ name: TraceName.ImportNfts });
 
-    await NftController.addNft(address, tokenId, selectedNetworkClientId);
+    await NftController.addNft(address, tokenId, networkClientId);
 
     endTrace({ name: TraceName.ImportNfts });
 
@@ -244,12 +297,46 @@ const AddCustomCollectible = ({
         confirmText={strings('add_asset.collectibles.add_collectible')}
         onCancelPress={cancelAddCollectible}
         onConfirmPress={addNft}
-        confirmDisabled={!address || !tokenId}
+        confirmDisabled={!address || !tokenId || !selectedNetwork}
         loading={loading}
         confirmTestID={'add-collectible-button'}
       >
         <View>
           <View style={styles.rowWrapper}>
+            <TouchableOpacity
+              style={styles.networkSelectorContainer}
+              onPress={() => setOpenNetworkSelector(true)}
+              onLongPress={() => setOpenNetworkSelector(true)}
+            >
+              <Text style={styles.networkSelectorText}>
+                {selectedNetwork || strings('networks.select_network')}
+              </Text>
+
+              <View style={styles.overlappingAvatarsContainer}>
+                {selectedNetwork ? (
+                  <Avatar
+                    variant={AvatarVariant.Network}
+                    size={AvatarSize.Sm}
+                    name={selectedNetwork}
+                    imageSource={getNetworkImageSource({
+                      networkType: 'evm',
+                      chainId: networkId,
+                    })}
+                    testID={ImportTokenViewSelectorsIDs.SELECT_NETWORK_BUTTON}
+                  />
+                ) : null}
+
+                <ButtonIcon
+                  iconName={IconName.ArrowDown}
+                  iconColor={IconColor.Default}
+                  testID={ImportTokenViewSelectorsIDs.SELECT_NETWORK_BUTTON}
+                  onPress={() => setOpenNetworkSelector(true)}
+                  accessibilityRole="button"
+                  style={styles.buttonIcon}
+                />
+              </View>
+            </TouchableOpacity>
+
             <Text style={styles.rowTitleText}>
               {strings('collectible.collectible_address')}
             </Text>
diff --git a/app/components/UI/Bridge/components/BridgeSourceNetworkSelector/BridgeSourceNetworkSelector.test.tsx b/app/components/UI/Bridge/components/BridgeSourceNetworkSelector/BridgeSourceNetworkSelector.test.tsx
index 368dab629d8..2a67ec8be02 100644
--- a/app/components/UI/Bridge/components/BridgeSourceNetworkSelector/BridgeSourceNetworkSelector.test.tsx
+++ b/app/components/UI/Bridge/components/BridgeSourceNetworkSelector/BridgeSourceNetworkSelector.test.tsx
@@ -1,3 +1,4 @@
+import React from 'react';
 import { initialState } from '../../_mocks_/initialState';
 import { fireEvent, waitFor } from '@testing-library/react-native';
 import { renderScreen } from '../../../../../util/test/renderWithProvider';
@@ -6,6 +7,8 @@ import Routes from '../../../../../constants/navigation/Routes';
 import { Hex } from '@metamask/utils';
 import { setSelectedSourceChainIds } from '../../../../../core/redux/slices/bridge';
 import { BridgeSourceNetworkSelectorSelectorsIDs } from '../../../../../../e2e/selectors/Bridge/BridgeSourceNetworkSelector.selectors';
+import { cloneDeep } from 'lodash';
+import { MultichainNetwork } from '@metamask/multichain-transactions-controller';
 
 const mockNavigate = jest.fn();
 const mockGoBack = jest.fn();
@@ -228,4 +231,54 @@ describe('BridgeSourceNetworkSelector', () => {
     expect(networkItems[0].props.testID).toBe(`chain-${mockChainId}`);
     expect(networkItems[1].props.testID).toBe(`chain-${optimismChainId}`);
   });
+
+  it('renders non-EVM networks', async () => {
+    const state = cloneDeep(initialState);
+
+    state.engine.backgroundState.RemoteFeatureFlagController.remoteFeatureFlags.bridgeConfigV2.chains[
+      MultichainNetwork.Solana
+    ] = {
+      isActiveSrc: true,
+      isActiveDest: true,
+      isUnifiedUIEnabled: true,
+    };
+
+    const { getByText } = renderScreen(
+      BridgeSourceNetworkSelector,
+      {
+        name: Routes.BRIDGE.MODALS.SOURCE_NETWORK_SELECTOR,
+      },
+      { state },
+    );
+
+    await waitFor(() => {
+      expect(getByText('Solana')).toBeTruthy();
+      expect(getByText('$30012.75599')).toBeTruthy();
+    });
+  });
+
+  it('does not render non-EVM networks if isEvmOnly set', async () => {
+    const state = cloneDeep(initialState);
+
+    state.engine.backgroundState.RemoteFeatureFlagController.remoteFeatureFlags.bridgeConfigV2.chains[
+      MultichainNetwork.Solana
+    ] = {
+      isActiveSrc: true,
+      isActiveDest: true,
+      isUnifiedUIEnabled: true,
+    };
+
+    const { queryByText } = renderScreen(
+      () => <BridgeSourceNetworkSelector isEvmOnly />,
+      {
+        name: Routes.BRIDGE.MODALS.SOURCE_NETWORK_SELECTOR,
+      },
+      { state },
+    );
+
+    await waitFor(() => {
+      expect(queryByText('Solana')).toBeNull();
+      expect(queryByText('$30012.75599')).toBeNull();
+    });
+  });
 });
diff --git a/app/components/UI/Bridge/components/BridgeSourceNetworkSelector/index.tsx b/app/components/UI/Bridge/components/BridgeSourceNetworkSelector/index.tsx
index 19740107803..6ade797e427 100644
--- a/app/components/UI/Bridge/components/BridgeSourceNetworkSelector/index.tsx
+++ b/app/components/UI/Bridge/components/BridgeSourceNetworkSelector/index.tsx
@@ -31,6 +31,7 @@ import { useNetworkInfo } from '../../../../../selectors/selectedNetworkControll
 import { useSwitchNetworks } from '../../../../Views/NetworkSelector/useSwitchNetworks';
 import { CaipChainId, Hex } from '@metamask/utils';
 import { selectEvmNetworkConfigurationsByChainId } from '../../../../../selectors/networkController';
+import { isSolanaChainId } from '@metamask/bridge-controller';
 
 const createStyles = () =>
   StyleSheet.create({
@@ -52,23 +53,38 @@ const createStyles = () =>
   });
 
 export interface BridgeSourceNetworkSelectorProps {
+  isEvmOnly?: boolean;
   onApply?: (selectedChainIds: Hex[]) => void;
 }
 
 export const BridgeSourceNetworkSelector: React.FC<
   BridgeSourceNetworkSelectorProps
-> = ({ onApply }) => {
+> = ({ isEvmOnly, onApply }) => {
   const { styles } = useStyles(createStyles, {});
   const navigation = useNavigation();
   const dispatch = useDispatch();
   const enabledSourceChains = useSelector(selectEnabledSourceChains);
-  const enabledSourceChainIds = useMemo(
-    () => enabledSourceChains.map((chain) => chain.chainId),
-    [enabledSourceChains],
-  );
   const selectedSourceChainIds = useSelector(selectSelectedSourceChainIds);
   const currentCurrency = useSelector(selectCurrentCurrency);
-  const { sortedSourceNetworks } = useSortedSourceNetworks();
+  const { sortedSourceNetworks: sortedSourceNetworksRaw } =
+    useSortedSourceNetworks();
+
+  const enabledSourceChainIds = useMemo(
+    () =>
+      enabledSourceChains
+        .filter((chain) => (isEvmOnly ? !isSolanaChainId(chain.chainId) : true))
+        .map((chain) => chain.chainId),
+    [enabledSourceChains, isEvmOnly],
+  );
+
+  const sortedSourceNetworks = useMemo(
+    () =>
+      sortedSourceNetworksRaw.filter((chain) =>
+        enabledSourceChainIds.includes(chain.chainId),
+      ),
+    [enabledSourceChainIds, sortedSourceNetworksRaw],
+  );
+
   const evmNetworkConfigurations = useSelector(
     selectEvmNetworkConfigurationsByChainId,
   );
@@ -95,29 +111,35 @@ export const BridgeSourceNetworkSelector: React.FC<
   });
 
   const handleApply = useCallback(async () => {
+    const newSelectedSourceChainids = candidateSourceChainIds.filter((id) =>
+      enabledSourceChainIds.includes(id as CaipChainId),
+    );
+
     if (onApply) {
-      onApply(candidateSourceChainIds as Hex[]);
+      onApply(newSelectedSourceChainids as Hex[]);
       return;
     }
 
     // Update the Redux state with the candidate selections
     dispatch(
       setSelectedSourceChainIds(
-        candidateSourceChainIds as (Hex | CaipChainId)[],
+        newSelectedSourceChainids as (Hex | CaipChainId)[],
       ),
     );
 
     // If there's only 1 network selected, set the source token to native token of that chain and switch chains
-    if (candidateSourceChainIds.length === 1) {
+    if (newSelectedSourceChainids.length === 1) {
       const evmNetworkConfiguration =
-        evmNetworkConfigurations[candidateSourceChainIds[0] as Hex];
+        evmNetworkConfigurations[newSelectedSourceChainids[0] as Hex];
       if (evmNetworkConfiguration) {
         await onSetRpcTarget(evmNetworkConfiguration);
       }
 
       ///: BEGIN:ONLY_INCLUDE_IF(keyring-snaps)
       if (!evmNetworkConfiguration) {
-        await onNonEvmNetworkChange(candidateSourceChainIds[0] as CaipChainId);
+        await onNonEvmNetworkChange(
+          newSelectedSourceChainids[0] as CaipChainId,
+        );
       }
       ///: END:ONLY_INCLUDE_IF
 
@@ -131,6 +153,7 @@ export const BridgeSourceNetworkSelector: React.FC<
     navigation,
     dispatch,
     candidateSourceChainIds,
+    enabledSourceChainIds,
     evmNetworkConfigurations,
     onSetRpcTarget,
     ///: BEGIN:ONLY_INCLUDE_IF(keyring-snaps)
diff --git a/app/components/UI/Bridge/components/DestinationAccountSelector.tsx/DestinationAccountSelector.test.tsx b/app/components/UI/Bridge/components/DestinationAccountSelector.tsx/DestinationAccountSelector.test.tsx
index 951749bee1f..d964df0bedf 100644
--- a/app/components/UI/Bridge/components/DestinationAccountSelector.tsx/DestinationAccountSelector.test.tsx
+++ b/app/components/UI/Bridge/components/DestinationAccountSelector.tsx/DestinationAccountSelector.test.tsx
@@ -155,25 +155,32 @@ jest.mock('../../../../../selectors/bridge', () => ({
 // Mock the account tree controller selectors
 jest.mock(
   '../../../../../selectors/multichainAccounts/accountTreeController',
-  () => ({
-    selectAccountGroups: (state: MockState) =>
-      state.engine?.backgroundState?.AccountTreeController?.accountTree
-        ?.accountGroups
-        ? Object.values(
-            state.engine.backgroundState.AccountTreeController.accountTree
-              .accountGroups,
-          )
-        : [],
-    selectSelectedAccountGroup: (state: MockState) => {
-      const selectedId =
-        state.engine?.backgroundState?.AccountTreeController?.accountTree
-          ?.selectedAccountGroupId;
-      const accountGroups =
+  () => {
+    const actual = jest.requireActual(
+      '../../../../../selectors/multichainAccounts/accountTreeController',
+    );
+
+    return {
+      ...actual,
+      selectAccountGroups: (state: MockState) =>
         state.engine?.backgroundState?.AccountTreeController?.accountTree
-          ?.accountGroups;
-      return selectedId && accountGroups ? accountGroups[selectedId] : null;
-    },
-  }),
+          ?.accountGroups
+          ? Object.values(
+              state.engine.backgroundState.AccountTreeController.accountTree
+                .accountGroups,
+            )
+          : [],
+      selectSelectedAccountGroup: (state: MockState) => {
+        const selectedId =
+          state.engine?.backgroundState?.AccountTreeController?.accountTree
+            ?.selectedAccountGroupId;
+        const accountGroups =
+          state.engine?.backgroundState?.AccountTreeController?.accountTree
+            ?.accountGroups;
+        return selectedId && accountGroups ? accountGroups[selectedId] : null;
+      },
+    };
+  },
 );
 
 // Mock the feature flag selector
diff --git a/app/components/UI/Card/Views/CardHome/CardHome.test.tsx b/app/components/UI/Card/Views/CardHome/CardHome.test.tsx
index 6ace793c5e4..fadfe848fa8 100644
--- a/app/components/UI/Card/Views/CardHome/CardHome.test.tsx
+++ b/app/components/UI/Card/Views/CardHome/CardHome.test.tsx
@@ -19,7 +19,6 @@ import {
 } from '../../../../../selectors/featureFlagController/deposit';
 import { selectChainId } from '../../../../../selectors/networkController';
 import { selectCardholderAccounts } from '../../../../../core/redux/slices/card';
-import { selectSelectedInternalAccount } from '../../../../../selectors/accountsController';
 const mockNavigate = jest.fn();
 const mockGoBack = jest.fn();
 const mockSetNavigationOptions = jest.fn();
@@ -52,6 +51,10 @@ const mockPriorityToken = {
 
 const mockCurrentAddress = '0x789';
 
+const mockSelectedInternalAccount = {
+  address: mockCurrentAddress,
+};
+
 // Mock hooks
 const mockFetchPriorityToken = jest.fn().mockResolvedValue(mockPriorityToken);
 const mockNavigateToCardPage = jest.fn();
@@ -355,27 +358,8 @@ describe('CardHome Component', () => {
       if (selector === selectCardholderAccounts) {
         return [mockCurrentAddress];
       }
-      if (selector === selectSelectedInternalAccount) {
-        return {
-          address: mockCurrentAddress,
-          id: 'account-id',
-          type: 'eip155:eoa',
-          options: {},
-          metadata: {
-            name: 'Test Account',
-            importTime: Date.now(),
-            keyring: { type: 'HD Key Tree' },
-          },
-          scopes: [],
-          methods: [],
-        };
-      }
-      if (
-        selector
-          .toString()
-          .includes('selectSelectedInternalAccountFormattedAddress')
-      ) {
-        return mockCurrentAddress;
+      if (selector.toString().includes('selectSelectedInternalAccount')) {
+        return mockSelectedInternalAccount;
       }
       if (selector.toString().includes('selectChainId')) {
         return '0xe708'; // Linea chain ID - fallback for string matching
@@ -422,27 +406,8 @@ describe('CardHome Component', () => {
       if (selector === selectCardholderAccounts) {
         return [mockCurrentAddress];
       }
-      if (selector === selectSelectedInternalAccount) {
-        return {
-          address: mockCurrentAddress,
-          id: 'account-id',
-          type: 'eip155:eoa',
-          options: {},
-          metadata: {
-            name: 'Test Account',
-            importTime: Date.now(),
-            keyring: { type: 'HD Key Tree' },
-          },
-          scopes: [],
-          methods: [],
-        };
-      }
-      if (
-        selector
-          .toString()
-          .includes('selectSelectedInternalAccountFormattedAddress')
-      ) {
-        return mockCurrentAddress;
+      if (selector.toString().includes('selectSelectedInternalAccount')) {
+        return mockSelectedInternalAccount;
       }
       if (selector.toString().includes('selectChainId')) {
         return '0xe708'; // Linea chain ID - fallback
@@ -547,7 +512,6 @@ describe('CardHome Component', () => {
       expect(mockTrackEvent).toHaveBeenCalled();
       expect(mockOpenSwaps).toHaveBeenCalledWith({
         chainId: '0xe708',
-        cardholderAddress: mockCurrentAddress,
       });
     });
   });
@@ -719,156 +683,6 @@ describe('CardHome Component', () => {
     expect(navigationOptions.headerTitle).toBeDefined();
   });
 
-  it('switches to Linea network on focus if not already on Linea', async () => {
-    // Override the mock to allow network switching for this test
-    mockFindNetworkClientIdByChainId.mockReturnValue('linea-network-id');
-
-    // Mock being on a different chain initially
-    mockUseSelector.mockImplementation((selector) => {
-      if (selector === selectChainId) {
-        return '0x1'; // Ethereum mainnet
-      }
-      if (selector === selectPrivacyMode) {
-        return false;
-      }
-      if (selector === selectDepositActiveFlag) {
-        return true;
-      }
-      if (selector === selectDepositMinimumVersionFlag) {
-        return '0.9.0';
-      }
-      if (selector === selectCardholderAccounts) {
-        return [mockCurrentAddress];
-      }
-      if (selector === selectSelectedInternalAccount) {
-        return {
-          address: mockCurrentAddress,
-          id: 'account-id',
-          type: 'eip155:eoa',
-          options: {},
-          metadata: {
-            name: 'Test Account',
-            importTime: Date.now(),
-            keyring: { type: 'HD Key Tree' },
-          },
-          scopes: [],
-          methods: [],
-        };
-      }
-      if (selector.toString().includes('selectChainId')) {
-        return '0x1'; // Ethereum mainnet - fallback
-      }
-      if (selector.toString().includes('selectPrivacyMode')) {
-        return false;
-      }
-      if (selector.toString().includes('selectCardholderAccounts')) {
-        return [mockCurrentAddress];
-      }
-      if (selector.toString().includes('selectEvmTokens')) {
-        return [mockPriorityToken];
-      }
-      if (selector.toString().includes('selectEvmTokenFiatBalances')) {
-        return ['1000.00'];
-      }
-      return [];
-    });
-
-    // Mock useFocusEffect to call the callbacks when they're registered
-    const focusCallbacks: (() => void)[] = [];
-    jest.mocked(useFocusEffect).mockImplementation((callback: () => void) => {
-      focusCallbacks.push(callback);
-    });
-
-    render();
-
-    // Execute all focus effect callbacks (network change first, then account change)
-    await waitFor(async () => {
-      for (const callback of focusCallbacks) {
-        callback();
-      }
-    });
-
-    await waitFor(() => {
-      expect(mockFindNetworkClientIdByChainId).toHaveBeenCalledWith('0xe708');
-      expect(mockSetActiveNetwork).toHaveBeenCalledWith('linea-network-id');
-    });
-  });
-
-  it('handles network switching errors gracefully', async () => {
-    // Override the mock to allow network switching for this test
-    mockFindNetworkClientIdByChainId.mockReturnValue('linea-network-id');
-    mockSetActiveNetwork.mockRejectedValueOnce(new Error('Network error'));
-
-    // Mock being on a different chain initially
-    mockUseSelector.mockImplementation((selector) => {
-      if (selector === selectChainId) {
-        return '0x1'; // Ethereum mainnet
-      }
-      if (selector === selectPrivacyMode) {
-        return false;
-      }
-      if (selector === selectDepositActiveFlag) {
-        return true;
-      }
-      if (selector === selectDepositMinimumVersionFlag) {
-        return '0.9.0';
-      }
-      if (selector === selectCardholderAccounts) {
-        return [mockCurrentAddress];
-      }
-      if (selector === selectSelectedInternalAccount) {
-        return {
-          address: mockCurrentAddress,
-          id: 'account-id',
-          type: 'eip155:eoa',
-          options: {},
-          metadata: {
-            name: 'Test Account',
-            importTime: Date.now(),
-            keyring: { type: 'HD Key Tree' },
-          },
-          scopes: [],
-          methods: [],
-        };
-      }
-      if (selector.toString().includes('selectChainId')) {
-        return '0x1'; // Ethereum mainnet - fallback
-      }
-      if (selector.toString().includes('selectPrivacyMode')) {
-        return false;
-      }
-      if (selector.toString().includes('selectCardholderAccounts')) {
-        return [mockCurrentAddress];
-      }
-      if (selector.toString().includes('selectEvmTokens')) {
-        return [mockPriorityToken];
-      }
-      if (selector.toString().includes('selectEvmTokenFiatBalances')) {
-        return ['1000.00'];
-      }
-      return [];
-    });
-
-    // Mock useFocusEffect to call the callbacks when they're registered
-    const focusCallbacks: (() => void)[] = [];
-    jest.mocked(useFocusEffect).mockImplementation((callback: () => void) => {
-      focusCallbacks.push(callback);
-    });
-
-    render();
-
-    // Execute all focus effect callbacks (network change first, then account change)
-    await waitFor(async () => {
-      for (const callback of focusCallbacks) {
-        callback();
-      }
-    });
-
-    await waitFor(() => {
-      expect(mockSetActiveNetwork).toHaveBeenCalled();
-    });
-  });
-
   it('dispatches bridge tokens when opening swaps with non-USDC token', async () => {
     // Reset useFocusEffect to default mock for this test
     jest.mocked(useFocusEffect).mockImplementation(jest.fn());
@@ -902,7 +716,6 @@ describe('CardHome Component', () => {
       expect(mockTrackEvent).toHaveBeenCalled();
       expect(mockOpenSwaps).toHaveBeenCalledWith({
         chainId: '0xe708',
-        cardholderAddress: mockCurrentAddress,
       });
     });
   });
diff --git a/app/components/UI/Card/Views/CardHome/CardHome.tsx b/app/components/UI/Card/Views/CardHome/CardHome.tsx
index 2e8ef0bb026..d34a49381e6 100644
--- a/app/components/UI/Card/Views/CardHome/CardHome.tsx
+++ b/app/components/UI/Card/Views/CardHome/CardHome.tsx
@@ -12,7 +12,6 @@ import Text, {
 import {
   NavigationProp,
   ParamListBase,
-  useFocusEffect,
   useNavigation,
 } from '@react-navigation/native';
 import ButtonIcon, {
@@ -39,9 +38,6 @@ import { AllowanceState } from '../../types';
 import CardAssetItem from '../../components/CardAssetItem';
 import ManageCardListItem from '../../components/ManageCardListItem';
 import CardImage from '../../components/CardImage';
-import { LINEA_CHAIN_ID } from '@metamask/swaps-controller/dist/constants';
-import { selectCardholderAccounts } from '../../../../../core/redux/slices/card';
-import Logger from '../../../../../util/Logger';
 import { selectChainId } from '../../../../../selectors/networkController';
 import { CardHomeSelectors } from '../../../../../../e2e/selectors/Card/CardHome.selectors';
 import {
@@ -54,8 +50,6 @@ import AddFundsBottomSheet from '../../components/AddFundsBottomSheet';
 import { useOpenSwaps } from '../../hooks/useOpenSwaps';
 import { MetaMetricsEvents, useMetrics } from '../../../../hooks/useMetrics';
 import { SUPPORTED_BOTTOMSHEET_TOKENS_SYMBOLS } from '../../constants';
-import { selectSelectedInternalAccount } from '../../../../../selectors/accountsController';
-import { useIsCardholder } from '../../hooks/useIsCardholder';
 import {
   Skeleton,
   SkeletonProps,
@@ -80,10 +74,7 @@ const SkeletonLoading = (props: SkeletonProps) => {
  * @returns JSX element representing the card home screen
  */
 const CardHome = () => {
-  const { PreferencesController, NetworkController, AccountsController } =
-    Engine.context;
-  const [error, setError] = useState<boolean>(false);
-  const [isLoadingNetworkChange, setIsLoadingNetworkChange] = useState(true);
+  const { PreferencesController } = Engine.context;
   const [openAddFundsBottomSheet, setOpenAddFundsBottomSheet] = useState(false);
   const [retries, setRetries] = useState(0);
   const sheetRef = useRef<BottomSheetRef>(null);
@@ -96,68 +87,13 @@ const CardHome = () => {
 
   const privacyMode = useSelector(selectPrivacyMode);
   const selectedChainId = useSelector(selectChainId);
-  const cardholderAddresses = useSelector(selectCardholderAccounts);
-  const selectedAccount = useSelector(selectSelectedInternalAccount);
-  const isCardholder = useIsCardholder();
-
-  // Handle network and account changes
-  useFocusEffect(
-    useCallback(() => {
-      const handleNetworkAndAccountChanges = async () => {
-        // Handle network change first
-        if (selectedChainId !== LINEA_CHAIN_ID) {
-          const networkClientId =
-            NetworkController.findNetworkClientIdByChainId(LINEA_CHAIN_ID);
-
-          try {
-            if (networkClientId) {
-              await NetworkController.setActiveNetwork(networkClientId);
-            }
-          } catch (err) {
-            const mappedError =
-              err instanceof Error ? err : new Error(String(err));
-            Logger.error(mappedError, 'CardHome::Error setting active network');
-            setError(true);
-            setIsLoadingNetworkChange(false);
-            return;
-          }
-        }
-
-        setIsLoadingNetworkChange(false);
-
-        // Handle account change after network is correct
-        if (!isCardholder) {
-          const account = AccountsController.getAccountByAddress(
-            cardholderAddresses?.[0],
-          );
-
-          if (!account) {
-            setError(true);
-          } else {
-            AccountsController.setSelectedAccount(account.id);
-          }
-        }
-      };
-
-      handleNetworkAndAccountChanges();
-    }, [
-      NetworkController,
-      AccountsController,
-      selectedChainId,
-      cardholderAddresses,
-      isCardholder,
-    ]),
-  );
 
   const {
     priorityToken,
     fetchPriorityToken,
     isLoading: isLoadingPriorityToken,
-    error: errorPriorityToken,
-  } = useGetPriorityCardToken(
-    selectedAccount?.address,
-    selectedChainId === LINEA_CHAIN_ID,
-  );
+    error,
+  } = useGetPriorityCardToken();
   const { balanceFiat, mainBalance } = useAssetBalance(priorityToken);
   const { navigateToCardPage } = useNavigateToCardPage(navigation);
   const { openSwaps } = useOpenSwaps({
@@ -176,11 +112,6 @@ const CardHome = () => {
     [priorityToken],
   );
 
-  const hasError = useMemo(
-    () => error || errorPriorityToken,
-    [error, errorPriorityToken],
-  );
-
   const balanceAmount = useMemo(() => {
     if (!balanceFiat || balanceFiat === TOKEN_RATE_UNDEFINED) {
       return mainBalance;
@@ -196,7 +127,6 @@ const CardHome = () => {
         setOpenAddFundsBottomSheet={setOpenAddFundsBottomSheet}
         priorityToken={priorityToken ?? undefined}
         chainId={selectedChainId}
-        cardholderAddresses={cardholderAddresses}
         navigate={navigation.navigate}
       />
     ),
@@ -204,7 +134,6 @@ const CardHome = () => {
       sheetRef,
       setOpenAddFundsBottomSheet,
       priorityToken,
-      cardholderAddresses,
       selectedChainId,
       navigation,
     ],
@@ -223,7 +152,6 @@ const CardHome = () => {
     } else if (priorityToken) {
       openSwaps({
         chainId: selectedChainId,
-        cardholderAddress: cardholderAddresses?.[0],
       });
     }
   }, [
@@ -232,18 +160,9 @@ const CardHome = () => {
     priorityToken,
     openSwaps,
     selectedChainId,
-    cardholderAddresses,
   ]);
 
-  const isLoading = useMemo(
-    () =>
-      isLoadingPriorityToken ||
-      isLoadingNetworkChange ||
-      (!priorityToken && !hasError),
-    [isLoadingPriorityToken, isLoadingNetworkChange, priorityToken, hasError],
-  );
-
-  if (hasError) {
+  if (error) {
     return (
       <View style={styles.errorContainer}>
         <Icon
@@ -298,7 +217,7 @@ const CardHome = () => {
             length={SensitiveTextLength.Long}
             variant={TextVariant.HeadingLG}
           >
-            {isLoading ||
+            {isLoadingPriorityToken ||
             balanceAmount === TOKEN_BALANCE_LOADING ||
             balanceAmount === TOKEN_BALANCE_LOADING_UPPERCASE ? (
               <SkeletonLoading
@@ -364,7 +283,7 @@ const CardHome = () => {
             styles.defaultHorizontalPadding,
           ]}
         >
-          {isLoading || !priorityToken ? (
+          {isLoadingPriorityToken || !priorityToken ? (
             <SkeletonLoading
               height={50}
               width={'100%'}
@@ -382,7 +301,7 @@ const CardHome = () => {
             styles.defaultHorizontalPadding,
           ]}
         >
-          {isLoading ? (
+          {isLoadingPriorityToken ? (
             <SkeletonLoading
               height={28}
               width={'100%'}
@@ -396,7 +315,7 @@ const CardHome = () => {
               size={ButtonSize.Sm}
               onPress={addFundsAction}
               width={ButtonWidthTypes.Full}
-              loading={isLoading}
+              loading={isLoadingPriorityToken}
               testID={CardHomeSelectors.ADD_FUNDS_BUTTON}
             />
           )}
diff --git a/app/components/UI/Card/components/AddFundsBottomSheet/AddFundsBottomSheet.test.tsx b/app/components/UI/Card/components/AddFundsBottomSheet/AddFundsBottomSheet.test.tsx
index d134d3769e8..bccdd51fd24 100644
--- a/app/components/UI/Card/components/AddFundsBottomSheet/AddFundsBottomSheet.test.tsx
+++ b/app/components/UI/Card/components/AddFundsBottomSheet/AddFundsBottomSheet.test.tsx
@@ -108,7 +108,6 @@ describe('AddFundsBottomSheet', () => {
     sheetRef: mockSheetRef,
     priorityToken: mockPriorityToken,
     chainId: '0xe708',
-    cardholderAddresses: ['0xcardholder'],
     navigate: mockNavigate,
   };
 
@@ -221,7 +220,6 @@ describe('AddFundsBottomSheet', () => {
 
     expect(mockOpenSwaps).toHaveBeenCalledWith({
       chainId: '0xe708',
-      cardholderAddress: '0xcardholder',
       beforeNavigate: expect.any(Function),
     });
   });
diff --git a/app/components/UI/Card/components/AddFundsBottomSheet/AddFundsBottomSheet.tsx b/app/components/UI/Card/components/AddFundsBottomSheet/AddFundsBottomSheet.tsx
index e7c4184c42d..6c7a793785c 100644
--- a/app/components/UI/Card/components/AddFundsBottomSheet/AddFundsBottomSheet.tsx
+++ b/app/components/UI/Card/components/AddFundsBottomSheet/AddFundsBottomSheet.tsx
@@ -36,7 +36,6 @@ export interface AddFundsBottomSheetProps {
   sheetRef: React.RefObject<BottomSheetRef>;
   priorityToken?: CardTokenAllowance;
   chainId: string;
-  cardholderAddresses?: string[];
   navigate: (route: string) => void;
 }
 
@@ -45,7 +44,6 @@ const AddFundsBottomSheet: React.FC<AddFundsBottomSheetProps> = ({
   sheetRef,
   priorityToken,
   chainId,
-  cardholderAddresses,
   navigate,
 }) => {
   const { isDepositEnabled } = useDepositEnabled();
@@ -67,16 +65,9 @@ const AddFundsBottomSheet: React.FC<AddFundsBottomSheetProps> = ({
     if (!priorityToken) return;
     openSwaps({
       chainId,
-      cardholderAddress: cardholderAddresses?.[0],
       beforeNavigate: (nav) => closeBottomSheetAndNavigate(nav),
     });
-  }, [
-    priorityToken,
-    openSwaps,
-    chainId,
-    cardholderAddresses,
-    closeBottomSheetAndNavigate,
-  ]);
+  }, [priorityToken, openSwaps, chainId, closeBottomSheetAndNavigate]);
 
   const openDeposit = useCallback(() => {
     closeBottomSheetAndNavigate(() => {
diff --git a/app/components/UI/Card/hooks/useAssetBalance.test.ts b/app/components/UI/Card/hooks/useAssetBalance.test.ts
index 661fdcb3a6a..643ba10ac1d 100644
--- a/app/components/UI/Card/hooks/useAssetBalance.test.ts
+++ b/app/components/UI/Card/hooks/useAssetBalance.test.ts
@@ -44,6 +44,17 @@ jest.mock('../../../../selectors/tokenRatesController', () => ({
 jest.mock('../../../../selectors/tokenBalancesController', () => ({
   selectSingleTokenBalance: jest.fn(),
 }));
+jest.mock('../../Bridge/hooks/useTokensWithBalance', () => ({
+  useTokensWithBalance: jest.fn(() => []),
+}));
+jest.mock('../../../../selectors/networkController', () => ({
+  selectAllPopularNetworkConfigurations: jest.fn(() => ({
+    mainnet: { chainId: '0x1' },
+    polygon: { chainId: '0x89' },
+    optimism: { chainId: '0xa' },
+    arbitrum: { chainId: '0xa4b1' },
+  })),
+}));
 jest.mock('../../../../../locales/i18n', () => ({
   strings: jest.fn((key: string) => {
     const translations: { [key: string]: string } = {
@@ -117,6 +128,12 @@ describe('useAssetBalance', () => {
         showFiatOnTestnets: true,
         selectedAccount: { id: 'account1' },
         exchangeRates: { price: 2000 },
+        popularNetworks: {
+          mainnet: { chainId: '0x1' },
+          polygon: { chainId: '0x89' },
+          optimism: { chainId: '0xa' },
+          arbitrum: { chainId: '0xa4b1' },
+        },
         ...overrides,
       };
 
@@ -140,6 +157,8 @@ describe('useAssetBalance', () => {
         return overrides.tokenBalances;
       if (selector.toString().includes('selectCurrencyRateForChainId'))
         return overrides.conversionRate;
+      if (selector.toString().includes('selectAllPopularNetworkConfigurations'))
+        return defaults.popularNetworks;
 
       // This catches the dynamically created selectors from makeSelectAssetByAddressAndChainId
       // and makeSelectNonEvmAssetById
@@ -193,9 +212,20 @@ describe('useAssetBalance', () => {
           if (selector.toString().includes('selectSingleTokenPriceMarketData'))
             return { price: 2000 };
           if (selector.toString().includes('selectSingleTokenBalance'))
-            return {};
+            return undefined;
           if (selector.toString().includes('selectCurrencyRateForChainId'))
-            return 0;
+            return undefined;
+          if (
+            selector
+              .toString()
+              .includes('selectAllPopularNetworkConfigurations')
+          )
+            return {
+              mainnet: { chainId: '0x1' },
+              polygon: { chainId: '0x89' },
+              optimism: { chainId: '0xa' },
+              arbitrum: { chainId: '0xa4b1' },
+            };
 
           // For null/undefined token, the selector should return undefined
           if (typeof selector === 'function') {
@@ -243,6 +273,17 @@ describe('useAssetBalance', () => {
             return {};
           if (selector.toString().includes('selectCurrencyRateForChainId'))
             return 0;
+          if (
+            selector
+              .toString()
+              .includes('selectAllPopularNetworkConfigurations')
+          )
+            return {
+              mainnet: { chainId: '0x1' },
+              polygon: { chainId: '0x89' },
+              optimism: { chainId: '0xa' },
+              arbitrum: { chainId: '0xa4b1' },
+            };
 
           // When token is falsy, the evmAsset selector should return undefined
           if (typeof selector === 'function') {
@@ -344,6 +385,17 @@ describe('useAssetBalance', () => {
             return {};
           if (selector.toString().includes('selectCurrencyRateForChainId'))
             return 0;
+          if (
+            selector
+              .toString()
+              .includes('selectAllPopularNetworkConfigurations')
+          )
+            return {
+              mainnet: { chainId: '0x1' },
+              polygon: { chainId: '0x89' },
+              optimism: { chainId: '0xa' },
+              arbitrum: { chainId: '0xa4b1' },
+            };
 
           // Handle the dynamic selector that should return the error asset
           if (typeof selector === 'function') {
@@ -390,6 +442,17 @@ describe('useAssetBalance', () => {
             return {};
           if (selector.toString().includes('selectCurrencyRateForChainId'))
             return 0;
+          if (
+            selector
+              .toString()
+              .includes('selectAllPopularNetworkConfigurations')
+          )
+            return {
+              mainnet: { chainId: '0x1' },
+              polygon: { chainId: '0x89' },
+              optimism: { chainId: '0xa' },
+              arbitrum: { chainId: '0xa4b1' },
+            };
 
           // Return undefined for asset selector
           if (typeof selector === 'function') {
@@ -459,6 +522,17 @@ describe('useAssetBalance', () => {
             return {};
           if (selector.toString().includes('selectCurrencyRateForChainId'))
             return 0;
+          if (
+            selector
+              .toString()
+              .includes('selectAllPopularNetworkConfigurations')
+          )
+            return {
+              mainnet: { chainId: '0x1' },
+              polygon: { chainId: '0x89' },
+              optimism: { chainId: '0xa' },
+              arbitrum: { chainId: '0xa4b1' },
+            };
 
           // Return undefined for both asset selectors to trigger mapped asset creation
           if (typeof selector === 'function') {
@@ -604,6 +678,17 @@ describe('useAssetBalance', () => {
             return {};
           if (selector.toString().includes('selectCurrencyRateForChainId'))
             return 0;
+          if (
+            selector
+              .toString()
+              .includes('selectAllPopularNetworkConfigurations')
+          )
+            return {
+              mainnet: { chainId: '0x1' },
+              polygon: { chainId: '0x89' },
+              optimism: { chainId: '0xa' },
+              arbitrum: { chainId: '0xa4b1' },
+            };
 
           if (typeof selector === 'function') {
             return stakedAsset;
@@ -816,6 +901,17 @@ describe('useAssetBalance', () => {
             return {};
           if (selector.toString().includes('selectCurrencyRateForChainId'))
             return 0;
+          if (
+            selector
+              .toString()
+              .includes('selectAllPopularNetworkConfigurations')
+          )
+            return {
+              mainnet: { chainId: '0x1' },
+              polygon: { chainId: '0x89' },
+              optimism: { chainId: '0xa' },
+              arbitrum: { chainId: '0xa4b1' },
+            };
 
           // Return undefined for nonEvmAsset when selectedAccount is null
           if (typeof selector === 'function') {
diff --git a/app/components/UI/Card/hooks/useAssetBalance.tsx b/app/components/UI/Card/hooks/useAssetBalance.tsx
index 64a890b3801..d1d628039df 100644
--- a/app/components/UI/Card/hooks/useAssetBalance.tsx
+++ b/app/components/UI/Card/hooks/useAssetBalance.tsx
@@ -23,6 +23,8 @@ import { isTestNet } from '../../../../util/networks';
 import { TokenI } from '../../Tokens/types';
 import { CardTokenAllowance } from '../types';
 import { buildTokenIconUrl } from '../util/buildTokenIconUrl';
+import { useTokensWithBalance } from '../../Bridge/hooks/useTokensWithBalance';
+import { selectAllPopularNetworkConfigurations } from '../../../../selectors/networkController';
 
 // This hook retrieves the asset balance and related information for a given token and account.
 export const useAssetBalance = (
@@ -37,6 +39,13 @@ export const useAssetBalance = (
   const selectedInternalAccountAddress = useSelector(
     selectSelectedInternalAccountAddress,
   );
+  const popularNetworks = useSelector(selectAllPopularNetworkConfigurations);
+  const chainIds = Object.entries(popularNetworks || {})
+    .map((network) => network[1]?.chainId)
+    .filter(Boolean);
+  const tokensWithBalance = useTokensWithBalance({
+    chainIds,
+  });
 
   const selectEvmAsset = useMemo(
     () => makeSelectAssetByAddressAndChainId(),
@@ -53,11 +62,16 @@ export const useAssetBalance = (
       : undefined,
   );
 
-  let asset = token && isEvmNetworkSelected ? evmAsset : undefined;
+  let asset = evmAsset;
   let isMappedAsset = false;
 
   if (!asset && token) {
     const iconUrl = buildTokenIconUrl(token.chainId, token.address);
+    const filteredToken = tokensWithBalance.find(
+      (t) =>
+        t.address.toLowerCase() === token.address.toLowerCase() &&
+        t.chainId === token.chainId,
+    );
 
     asset = {
       ...token,
@@ -65,8 +79,8 @@ export const useAssetBalance = (
       logo: iconUrl,
       isETH: false,
       aggregators: [],
-      balance: '0',
-      balanceFiat: '0',
+      balance: filteredToken?.balance ?? '0',
+      balanceFiat: filteredToken?.balanceFiat ?? '0',
     } as TokenI;
     isMappedAsset = true;
   }
@@ -118,12 +132,28 @@ export const useAssetBalance = (
     }
 
     if (isMappedAsset) {
+      const zeroBalanceFiat = formatWithThreshold(
+        0,
+        oneHundredths,
+        I18n.locale,
+        { style: 'currency', currency: currentCurrency },
+      );
+      const zeroBalanceFormatted = `0 ${asset.symbol}`;
+
       return {
-        balanceFiat: formatWithThreshold(0, oneHundredths, I18n.locale, {
-          style: 'currency',
-          currency: currentCurrency,
-        }),
-        balanceValueFormatted: `0 ${asset.symbol}`,
+        balanceFiat:
+          asset.balanceFiat && asset.balanceFiat !== '0'
+            ? asset.balanceFiat
+            : zeroBalanceFiat,
+        balanceValueFormatted:
+          asset.balance && asset.balance !== '0'
+            ? formatWithThreshold(
+                parseFloat(asset.balance),
+                oneHundredThousandths,
+                I18n.locale,
+                { minimumFractionDigits: 0, maximumFractionDigits: 5 },
+              )
+            : zeroBalanceFormatted,
       };
     }
 
diff --git a/app/components/UI/Card/hooks/useCardholderCheck.ts b/app/components/UI/Card/hooks/useCardholderCheck.ts
index a2f802bd28b..b1ffb41b0fb 100644
--- a/app/components/UI/Card/hooks/useCardholderCheck.ts
+++ b/app/components/UI/Card/hooks/useCardholderCheck.ts
@@ -7,24 +7,31 @@ import {
   selectAppServicesReady,
   selectUserLoggedIn,
 } from '../../../../reducers/user';
-import { selectInternalAccountsWithCaipAccountId } from '../../../../selectors/accountsController';
+import { selectInternalAccountsByScope } from '../../../../selectors/accountsController';
 import Logger from '../../../../util/Logger';
 import { isEthAccount } from '../../../../core/Multichain/utils';
+import { RootState } from '../../../../reducers';
 
 /**
  * Hook that automatically checks for cardholder accounts when conditions are met
  */
 export const useCardholderCheck = () => {
+  const lineaScope = 'eip155:59144';
   const dispatch = useThunkDispatch();
   const userLoggedIn = useSelector(selectUserLoggedIn);
   const appServicesReady = useSelector(selectAppServicesReady);
   const cardFeatureFlag = useSelector(selectCardFeatureFlag);
-  const accounts = useSelector(selectInternalAccountsWithCaipAccountId);
+  const internalAccounts = useSelector((state: RootState) =>
+    selectInternalAccountsByScope(state, lineaScope),
+  );
 
   const checkCardholderAccounts = useCallback(() => {
-    const caipAccountIds = accounts
+    const caipAccountIds = internalAccounts
       ?.filter((account) => isEthAccount(account))
-      .map((account) => account.caipAccountId);
+      .map(
+        (account) =>
+          `eip155:0:${account.address}` as `${string}:${string}:${string}`,
+      );
 
     if (!caipAccountIds?.length) {
       return;
@@ -36,14 +43,14 @@ export const useCardholderCheck = () => {
         cardFeatureFlag,
       }),
     );
-  }, [cardFeatureFlag, dispatch, accounts]);
+  }, [cardFeatureFlag, dispatch, internalAccounts]);
 
   useEffect(() => {
     if (
       userLoggedIn &&
       appServicesReady &&
       cardFeatureFlag &&
-      accounts?.length
+      internalAccounts?.length
     ) {
       try {
         checkCardholderAccounts();
@@ -59,6 +66,6 @@ export const useCardholderCheck = () => {
     appServicesReady,
     cardFeatureFlag,
     checkCardholderAccounts,
-    accounts,
+    internalAccounts,
   ]);
 };
diff --git a/app/components/UI/Card/hooks/useGetPriorityCardToken.test.ts b/app/components/UI/Card/hooks/useGetPriorityCardToken.test.ts
index edb52fc37bb..4cc649dd25d 100644
--- a/app/components/UI/Card/hooks/useGetPriorityCardToken.test.ts
+++ b/app/components/UI/Card/hooks/useGetPriorityCardToken.test.ts
@@ -1,10 +1,12 @@
 import { renderHook, act } from '@testing-library/react-hooks';
+import { useSelector } from 'react-redux';
 import { useCardSDK } from '../sdk';
 import { CardToken, CardTokenAllowance, AllowanceState } from '../types';
 import { useGetPriorityCardToken } from './useGetPriorityCardToken';
 import Logger from '../../../../util/Logger';
 import { strings } from '../../../../../locales/i18n';
-import { LINEA_CHAIN_ID } from '@metamask/swaps-controller/dist/constants';
+
+const mockUseSelector = useSelector as jest.MockedFunction<typeof useSelector>;
 
 jest.mock('../sdk', () => ({
   useCardSDK: jest.fn(),
@@ -15,6 +17,25 @@ jest.mock('react-redux', () => ({
   useDispatch: jest.fn(),
 }));
 
+jest.mock('../../../../selectors/tokenBalancesController', () => ({
+  selectAllTokenBalances: jest.fn(),
+}));
+
+jest.mock('../../../../selectors/multichainAccounts/accounts', () => ({
+  selectSelectedInternalAccountByScope: jest.fn(),
+}));
+
+import { selectAllTokenBalances } from '../../../../selectors/tokenBalancesController';
+import { selectSelectedInternalAccountByScope } from '../../../../selectors/multichainAccounts/accounts';
+import { LINEA_CHAIN_ID } from '@metamask/swaps-controller/dist/constants';
+
+const mockSelectAllTokenBalances =
+  selectAllTokenBalances as jest.MockedFunction<typeof selectAllTokenBalances>;
+const mockSelectSelectedInternalAccountByScope =
+  selectSelectedInternalAccountByScope as jest.MockedFunction<
+    typeof selectSelectedInternalAccountByScope
+  >;
+
 jest.mock('../../../../util/Logger', () => ({
   error: jest.fn(),
 }));
@@ -71,47 +92,33 @@ describe('useGetPriorityCardToken', () => {
         symbol: 'TKN2',
         name: 'Token 2',
       },
-      {
-        address: '0xToken3',
-        decimals: 18,
-        symbol: 'TKN3',
-        name: 'Token 3',
-      },
-      {
-        address: '0xSupportedToken',
-        decimals: 18,
-        symbol: 'SUPP',
-        name: 'Supported Token',
-      },
     ],
   };
 
   const mockAddress = '0x1234567890123456789012345678901234567890';
 
-  // Create mock data that matches the SDK response format - simplified version
-  const createMockSDKTokenData = (address: string, allowanceAmount: string) => {
-    const numAmount = Number(allowanceAmount);
-    return {
-      address,
-      usAllowance: {
-        gt: (other: number) => numAmount > other,
-        toString: () => allowanceAmount,
-        isZero: () => allowanceAmount === '0',
-        lt: (other: number) => numAmount < other,
-      },
-      globalAllowance: {
-        gt: (other: number) => numAmount > other,
-        toString: () => allowanceAmount,
-        isZero: () => allowanceAmount === '0',
-        lt: (other: number) => numAmount < other,
-      },
-    };
-  };
+  const createMockSDKTokenData = (
+    address: string,
+    allowanceAmount: string,
+  ) => ({
+    address,
+    usAllowance: {
+      gt: (other: number) => Number(allowanceAmount) > other,
+      toString: () => allowanceAmount,
+      isZero: () => allowanceAmount === '0',
+      lt: (other: number) => Number(allowanceAmount) < other,
+    },
+    globalAllowance: {
+      gt: (other: number) => Number(allowanceAmount) > other,
+      toString: () => allowanceAmount,
+      isZero: () => allowanceAmount === '0',
+      lt: (other: number) => Number(allowanceAmount) < other,
+    },
+  });
 
   const mockSDKTokensData = [
-    createMockSDKTokenData('0xToken1', '1000000000000'), // > ARBITRARY_ALLOWANCE for Enabled state
-    createMockSDKTokenData('0xToken2', '500000000000'), // > ARBITRARY_ALLOWANCE for Enabled state
-    createMockSDKTokenData('0xToken3', '0'),
+    createMockSDKTokenData('0xToken1', '1000000000000'),
+    createMockSDKTokenData('0xToken2', '500000000000'),
   ];
 
   const mockCardToken: CardToken = {
@@ -134,62 +141,89 @@ describe('useGetPriorityCardToken', () => {
     mockPriorityToken = null;
     mockLastFetched = null;
 
-    // Create simplified stable references for Engine controllers
-    const tokensController = {
-      state: {
-        allTokens: {
-          [LINEA_CHAIN_ID]: {
-            [mockAddress.toLowerCase()]: [], // Empty by default for most tests
-          },
+    const mockTokenBalances = {
+      [mockAddress.toLowerCase()]: {
+        '0x1': {
+          '0xToken1': '1000000000000000000',
+          '0xToken2': '500000000000000000',
         },
       },
       addToken: jest.fn().mockResolvedValue(undefined),
     };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockSelectAllTokenBalances.mockReturnValue(mockTokenBalances as any);
 
-    const networkController = {
-      findNetworkClientIdByChainId: jest.fn().mockReturnValue('linea-mainnet'),
-    };
-
-    // Update the mocked Engine context with stable references
-    const mockEngine = jest.requireMock('../../../../core/Engine');
-    mockEngine.context.TokensController = tokensController;
-    mockEngine.context.NetworkController = networkController;
-
-    (useCardSDK as jest.Mock).mockReturnValue({ sdk: mockSDK });
-
-    // Simplified dispatch mock
-    mockDispatch.mockImplementation((action) => action);
-
-    // Simplified selector mock with basic return values
-    const { useSelector, useDispatch } = jest.requireMock('react-redux');
-
-    useSelector.mockImplementation((selector: (state: unknown) => unknown) => {
-      const selectorStr = selector.toString();
-      if (selectorStr.includes('selectAllTokenBalances')) {
+    const mockAccountSelector = (scope: string) => {
+      if (scope === 'eip155:0') {
         return {
-          [mockAddress.toLowerCase()]: {
-            [LINEA_CHAIN_ID]: {
-              '0xToken1': '1000000000000000000',
-              '0xToken2': '500000000000000000',
-              '0xToken3': '0',
-            },
-          },
+          address: mockAddress,
+          id: 'test-account-id',
+          type: 'eip155:eoa' as const,
+          options: {},
+          metadata: {},
+          methods: [],
+          scopes: [],
         };
       }
-      if (selectorStr.includes('selectCardPriorityTokenLastFetched')) {
-        return null;
+      return undefined;
+    };
+    mockSelectSelectedInternalAccountByScope.mockReturnValue(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      mockAccountSelector as any,
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockUseSelector.mockImplementation((selector: any) => {
+      if (selector === selectAllTokenBalances) {
+        return mockTokenBalances;
+      }
+      if (selector === selectSelectedInternalAccountByScope) {
+        return mockAccountSelector;
       }
-      if (selectorStr.includes('selectCardPriorityToken')) {
-        return null;
+      const selectorString = selector.toString();
+      if (
+        selectorString.includes('selectCardPriorityToken') &&
+        !selectorString.includes('LastFetched')
+      ) {
+        return mockPriorityToken;
+      }
+      if (selectorString.includes('selectCardPriorityTokenLastFetched')) {
+        return mockLastFetched;
+      }
+      // Fallback: try invoking the selector with a minimal state shape
+      try {
+        return selector({
+          card: {
+            cardholderAccounts: [],
+            isLoaded: true,
+            priorityTokensByAddress: {
+              [mockAddress.toLowerCase()]: mockPriorityToken,
+            },
+            lastFetchedByAddress: {
+              [mockAddress.toLowerCase()]: mockLastFetched,
+            },
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        } as unknown as any);
+      } catch (_e) {
+        // no-op
       }
       return null;
     });
 
+    (useCardSDK as jest.Mock).mockReturnValue({ sdk: mockSDK });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { useDispatch } = jest.requireMock('react-redux');
+
+    mockDispatch.mockImplementation(
+      (action: { type?: string; payload?: unknown }) => action,
+    );
+
     useDispatch.mockReturnValue(mockDispatch);
 
     (strings as jest.Mock).mockReturnValue('Error occurred');
 
-    // Mock trace utilities
     const { trace, endTrace } = jest.requireMock('../../../../util/trace');
     trace.mockImplementation(mockTrace);
     endTrace.mockImplementation(mockEndTrace);
@@ -198,16 +232,13 @@ describe('useGetPriorityCardToken', () => {
   it('should initialize with correct default state', async () => {
     (useCardSDK as jest.Mock).mockReturnValue({ sdk: null });
 
-    const { result } = renderHook(() =>
-      useGetPriorityCardToken(mockAddress, false),
-    );
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 0));
     });
 
     expect(result.current.isLoading).toBe(false);
-    expect(result.current.error).toBe(false);
     expect(result.current.priorityToken).toBe(null);
   });
 
@@ -215,9 +246,8 @@ describe('useGetPriorityCardToken', () => {
     mockFetchAllowances.mockResolvedValue(mockSDKTokensData);
     mockGetPriorityToken.mockResolvedValue(mockCardToken);
 
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
-    // Wait for the useEffect to complete
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 100));
     });
@@ -265,45 +295,12 @@ describe('useGetPriorityCardToken', () => {
     });
   });
 
-  it('should handle null response from API', async () => {
-    mockFetchAllowances.mockResolvedValue(mockSDKTokensData);
-    mockGetPriorityToken.mockResolvedValue(null);
-
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
-
-    // Wait for the hook to complete its async operations
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    });
-
-    // Verify that dispatch was called with the correct token (fallback to first valid allowance)
-    expect(mockDispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: expect.stringContaining('setCardPriorityToken'),
-        payload: expect.objectContaining({
-          address: '0x1234567890123456789012345678901234567890',
-          token: expect.objectContaining({
-            address: '0xToken1',
-            symbol: 'TKN1',
-            name: 'Token 1',
-            allowanceState: AllowanceState.Enabled,
-          }),
-        }),
-      }),
-    );
-
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.error).toBe(false);
-    expect(mockGetPriorityToken).toHaveBeenCalledTimes(1);
-  });
-
   it('should handle API errors gracefully', async () => {
     const mockError = new Error('Failed to fetch priority token');
     mockFetchAllowances.mockRejectedValueOnce(mockError);
 
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
-    // Wait for the hook to complete its async operations
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 100));
     });
@@ -321,9 +318,8 @@ describe('useGetPriorityCardToken', () => {
   it('should not fetch when SDK is not available', async () => {
     (useCardSDK as jest.Mock).mockReturnValue({ sdk: null });
 
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
-    // Wait for useEffect to complete
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 0));
     });
@@ -334,20 +330,34 @@ describe('useGetPriorityCardToken', () => {
     expect(mockGetPriorityToken).not.toHaveBeenCalled();
   });
 
-  it('should not fetch when address is not provided', async () => {
-    const { result } = renderHook(() =>
-      useGetPriorityCardToken(undefined, false),
-    );
+  it('should handle null response from API and fallback to first valid allowance', async () => {
+    mockFetchAllowances.mockResolvedValue(mockSDKTokensData);
+    mockGetPriorityToken.mockResolvedValue(null);
+
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
-    // Wait for useEffect to complete
     await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 0));
+      await new Promise((resolve) => setTimeout(resolve, 100));
     });
 
-    expect(result.current.priorityToken).toBeNull();
+    expect(mockDispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: expect.stringContaining('setCardPriorityToken'),
+        payload: expect.objectContaining({
+          address: mockAddress,
+          token: expect.objectContaining({
+            address: '0xToken1',
+            symbol: 'TKN1',
+            name: 'Token 1',
+            allowanceState: AllowanceState.Enabled,
+          }),
+        }),
+      }),
+    );
+
     expect(result.current.isLoading).toBe(false);
     expect(result.current.error).toBe(false);
-    expect(mockGetPriorityToken).not.toHaveBeenCalled();
+    expect(mockGetPriorityToken).toHaveBeenCalledTimes(1);
   });
 
   it('should use cached token when cache is valid', async () => {
@@ -363,114 +373,18 @@ describe('useGetPriorityCardToken', () => {
       chainId: LINEA_CHAIN_ID,
     } as CardTokenAllowance;
 
-    jest.resetAllMocks();
-
-    const testMockFetchAllowances = jest.fn();
-    const testMockGetPriorityToken = jest.fn();
-    const testMockDispatch = jest.fn();
-
-    const useReduxMocks = jest.requireMock('react-redux');
-    useReduxMocks.useDispatch.mockReturnValue(testMockDispatch);
-
-    // Mock useSelector to consistently return cached values
-    // We need to track which selector is being called and return appropriate values
-    let selectorCallCount = 0;
-    const expectedSelectorCalls = [
-      'selectAllTokenBalances', // First call for token balances
-      'selectCardPriorityToken', // Second call for cached priority token
-      'selectCardPriorityTokenLastFetched', // Third call for last fetched timestamp
-    ];
-
-    useReduxMocks.useSelector.mockImplementation(
-      (selector: (state: unknown) => unknown) => {
-        const selectorString = selector.toString();
-
-        if (selectorString.includes('selectAllTokenBalances')) {
-          return {
-            [mockAddress.toLowerCase()]: {
-              '0x1': {
-                '0xCachedToken': '1000000000000000000',
-              },
-            },
-          };
-        }
-
-        // For the address-based selectors, they will contain references to the state structure
-        // Let's be more explicit about what we return
-        if (selectorString.includes('priorityTokensByAddress')) {
-          return cachedToken;
-        }
-
-        if (selectorString.includes('lastFetchedByAddress')) {
-          return recentTimestamp;
-        }
-
-        // Fallback: if we can't identify the selector, assume it's asking for cached data
-        const currentCall =
-          expectedSelectorCalls[
-            selectorCallCount % expectedSelectorCalls.length
-          ];
-        selectorCallCount++;
-
-        switch (currentCall) {
-          case 'selectCardPriorityToken':
-            return cachedToken;
-          case 'selectCardPriorityTokenLastFetched':
-            return recentTimestamp;
-          default:
-            return null;
-        }
-      },
-    );
-
-    // Mock Engine with token that already exists
-    const mockEngine = jest.requireMock('../../../../core/Engine');
-    mockEngine.context.TokensController.state.allTokens = {
-      [LINEA_CHAIN_ID]: {
-        [mockAddress.toLowerCase()]: [
-          {
-            address: '0xCachedToken',
-            symbol: 'CACHED',
-            name: 'Cached Token',
-            decimals: 18,
-          },
-        ],
-      },
-    };
-
-    const sdkMocks = jest.requireMock('../sdk');
-    sdkMocks.useCardSDK.mockReturnValue({
-      sdk: {
-        getSupportedTokensAllowances: testMockFetchAllowances,
-        getPriorityToken: testMockGetPriorityToken,
-        supportedTokens: [
-          {
-            address: '0xCachedToken',
-            symbol: 'CACHED',
-            name: 'Cached Token',
-            decimals: 18,
-          },
-        ],
-      },
-    });
+    mockPriorityToken = cachedToken;
+    mockLastFetched = recentTimestamp;
 
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
-    // Give the hook time to stabilize
     await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve) => setTimeout(resolve, 50));
     });
 
-    // The key assertion: no API calls should have been made
-    expect(testMockFetchAllowances).not.toHaveBeenCalled();
-    expect(testMockGetPriorityToken).not.toHaveBeenCalled();
-
-    // No new dispatch calls should have been made since cache is valid
-    expect(testMockDispatch).not.toHaveBeenCalled();
+    expect(mockGetPriorityToken).not.toHaveBeenCalled();
 
-    // Hook should not be in loading or error state
     expect(result.current.isLoading).toBe(false);
-    expect(result.current.error).toBe(false);
     // And the cached token should be surfaced by the hook
     expect(result.current.priorityToken).toEqual(
       expect.objectContaining({
@@ -481,46 +395,21 @@ describe('useGetPriorityCardToken', () => {
   });
 
   it('should fetch new data when cache is stale', async () => {
-    // Set up a stale cached token (older than 5 minutes)
-    const staleTimestamp = new Date(Date.now() - 10 * 60 * 1000); // 10 minutes ago
-
-    // Override the selector to return stale cache
-    const { useSelector } = jest.requireMock('react-redux');
-    useSelector.mockImplementation((selector: (state: unknown) => unknown) => {
-      const selectorString = selector.toString();
-      if (selectorString.includes('selectAllTokenBalances')) {
-        return {
-          [mockAddress.toLowerCase()]: {
-            [LINEA_CHAIN_ID]: {
-              '0xToken1': '1000000000000000000',
-            },
-          },
-        };
-      }
-      if (selectorString.includes('selectCardPriorityToken')) {
-        return null; // No cached token
-      }
-      if (selectorString.includes('selectCardPriorityTokenLastFetched')) {
-        return staleTimestamp; // Stale timestamp
-      }
-      return null;
-    });
+    const staleTimestamp = new Date(Date.now() - 10 * 60 * 1000);
+    mockLastFetched = staleTimestamp;
 
     mockFetchAllowances.mockResolvedValue(mockSDKTokensData);
     mockGetPriorityToken.mockResolvedValue(mockCardToken);
 
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
-    // Wait for the fetch to complete
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 100));
     });
 
-    // Should have called the API since cache is stale
     expect(mockFetchAllowances).toHaveBeenCalledTimes(1);
     expect(mockGetPriorityToken).toHaveBeenCalledTimes(1);
 
-    // Should have dispatched new actions
     expect(mockDispatch).toHaveBeenCalledWith(
       expect.objectContaining({
         type: expect.stringContaining('setCardPriorityToken'),
@@ -531,125 +420,162 @@ describe('useGetPriorityCardToken', () => {
     expect(result.current.error).toBe(false);
   });
 
-  it('should handle multiple consecutive fetch calls', async () => {
-    // Test multiple fetch calls with valid address - each should make fresh API calls
-    const expectedSDKToken1 = createMockSDKTokenData('0xToken1', '1000000');
+  it('should not fetch when no address is available', async () => {
+    const noAddressSelector = () => undefined;
+    mockSelectSelectedInternalAccountByScope.mockReturnValue(noAddressSelector);
 
-    mockFetchAllowances.mockResolvedValueOnce([expectedSDKToken1]);
-    mockGetPriorityToken.mockResolvedValueOnce({
-      address: '0xToken1',
-      symbol: 'TKN1',
-      name: 'Token 1',
-      decimals: 18,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockUseSelector.mockImplementation((selector: any) => {
+      if (selector === selectAllTokenBalances) {
+        return {};
+      }
+      if (selector === selectSelectedInternalAccountByScope) {
+        return noAddressSelector;
+      }
+      return null;
+    });
+
+    const { result } = renderHook(() => useGetPriorityCardToken());
+
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    });
+
+    expect(mockFetchAllowances).not.toHaveBeenCalled();
+    expect(mockGetPriorityToken).not.toHaveBeenCalled();
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBe(false);
+    expect(result.current.priorityToken).toBeNull();
+  });
+
+  it('should handle manual fetchPriorityToken call', async () => {
+    mockFetchAllowances.mockResolvedValue(mockSDKTokensData);
+    mockGetPriorityToken.mockResolvedValue(mockCardToken);
+
+    const { result } = renderHook(() => useGetPriorityCardToken());
+
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    });
+
+    mockFetchAllowances.mockClear();
+    mockGetPriorityToken.mockClear();
+    mockDispatch.mockClear();
+
+    let manualResult: CardTokenAllowance | null | undefined;
+    await act(async () => {
+      manualResult = await result.current.fetchPriorityToken();
     });
 
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+    expect(manualResult).toEqual(
+      expect.objectContaining({
+        address: '0xToken1',
+        symbol: 'TKN1',
+        name: 'Token 1',
+        allowanceState: AllowanceState.Enabled,
+      }),
+    );
+    expect(mockFetchAllowances).toHaveBeenCalledTimes(1);
+    expect(mockGetPriorityToken).toHaveBeenCalledTimes(1);
+    expect(mockDispatch).toHaveBeenCalledTimes(2);
+  });
+
+  it('should return fallback token when no allowances are returned', async () => {
+    mockFetchAllowances.mockResolvedValue([]);
+
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
-    // Wait for automatic fetch from useEffect to complete
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 100));
     });
 
-    // Verify that setCardPriorityToken was called with the expected token
     expect(mockDispatch).toHaveBeenCalledWith(
       expect.objectContaining({
-        type: 'card/setCardPriorityToken',
+        type: expect.stringContaining('setCardPriorityToken'),
         payload: expect.objectContaining({
-          address: expect.any(String),
+          address: mockAddress,
           token: expect.objectContaining({
             address: '0xToken1',
             symbol: 'TKN1',
             name: 'Token 1',
+            allowanceState: AllowanceState.NotEnabled,
+            isStaked: false,
+            chainId: '0xe708',
           }),
         }),
       }),
     );
 
-    // Set up second fetch with different data
-    const expectedSDKToken2 = createMockSDKTokenData('0xToken2', '500000');
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBe(false);
+    expect(mockGetPriorityToken).not.toHaveBeenCalled();
+  });
 
-    mockFetchAllowances.mockResolvedValueOnce([expectedSDKToken2]);
-    mockGetPriorityToken.mockResolvedValueOnce({
-      address: '0xToken2',
-      symbol: 'TKN2',
-      name: 'Token 2',
-      decimals: 18,
+  it('should return null when no allowances and no supported tokens exist', async () => {
+    mockFetchAllowances.mockResolvedValue([]);
+    (useCardSDK as jest.Mock).mockReturnValue({
+      sdk: {
+        ...mockSDK,
+        supportedTokens: [],
+      },
     });
 
-    // Manual fetch should get fresh data
-    let priorityToken2: CardTokenAllowance | null | undefined;
+    const { result } = renderHook(() => useGetPriorityCardToken());
+
     await act(async () => {
-      priorityToken2 = await result.current.fetchPriorityToken();
+      await new Promise((resolve) => setTimeout(resolve, 100));
     });
-    expect(priorityToken2).toEqual(
+
+    expect(mockDispatch).toHaveBeenCalledWith(
       expect.objectContaining({
-        address: '0xToken2',
-        symbol: 'TKN2',
-        name: 'Token 2',
+        type: expect.stringContaining('setCardPriorityToken'),
+        payload: expect.objectContaining({
+          address: mockAddress,
+          token: null,
+        }),
       }),
     );
 
-    expect(mockGetPriorityToken).toHaveBeenCalledTimes(2); // Called for both fetches
     expect(result.current.isLoading).toBe(false);
     expect(result.current.error).toBe(false);
+    expect(mockGetPriorityToken).not.toHaveBeenCalled();
   });
 
-  it('should make fresh API calls on each fetchPriorityToken invocation', async () => {
-    // The fetchPriorityToken function doesn't cache - it always makes fresh API calls
-    mockFetchAllowances.mockResolvedValue(mockSDKTokensData);
-    mockGetPriorityToken.mockResolvedValue(mockCardToken);
+  it('should return first token when all allowances have zero balance', async () => {
+    const zeroAllowanceTokens = [
+      createMockSDKTokenData('0xToken1', '0'),
+      createMockSDKTokenData('0xToken2', '0'),
+    ];
 
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+    mockFetchAllowances.mockResolvedValue(zeroAllowanceTokens);
+
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
-    // Wait for the automatic fetch from useEffect
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 100));
     });
 
-    // Verify that setCardPriorityToken was called with the expected token
     expect(mockDispatch).toHaveBeenCalledWith(
       expect.objectContaining({
-        type: 'card/setCardPriorityToken',
+        type: expect.stringContaining('setCardPriorityToken'),
         payload: expect.objectContaining({
-          address: expect.any(String),
+          address: mockAddress,
           token: expect.objectContaining({
             address: '0xToken1',
             symbol: 'TKN1',
             name: 'Token 1',
-            allowanceState: AllowanceState.Enabled,
+            allowanceState: AllowanceState.NotEnabled,
           }),
         }),
       }),
     );
-    expect(mockFetchAllowances).toHaveBeenCalledTimes(1);
-
-    // Reset the call count to track subsequent calls
-    mockFetchAllowances.mockClear();
-    mockGetPriorityToken.mockClear();
-
-    // Manual fetch should make fresh API calls
-    let priorityToken2: CardTokenAllowance | null | undefined;
-    await act(async () => {
-      priorityToken2 = await result.current.fetchPriorityToken();
-    });
-
-    expect(priorityToken2).toEqual(
-      expect.objectContaining({
-        address: '0xToken1',
-        symbol: 'TKN1',
-        name: 'Token 1',
-        allowanceState: AllowanceState.Enabled,
-      }),
-    );
-    expect(mockFetchAllowances).toHaveBeenCalledTimes(1); // Fresh API call made
-    expect(mockGetPriorityToken).toHaveBeenCalledTimes(1); // Fresh API call made
 
-    // Verify that dispatch was called again after manual fetch
-    expect(mockDispatch).toHaveBeenCalledTimes(4); // 2 for auto-fetch (token + timestamp), 2 for manual fetch (token + timestamp)
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBe(false);
+    expect(mockGetPriorityToken).not.toHaveBeenCalled();
   });
 
   it('should fallback to token with positive balance when suggested token has zero balance', async () => {
-    // Create SDK format allowances where suggested token has zero balance
     const tokenWithZeroBalanceSDK = createMockSDKTokenData(
       '0xZeroBalance',
       '1000000000000',
@@ -670,25 +596,44 @@ describe('useGetPriorityCardToken', () => {
       decimals: 18,
     };
 
-    // Mock balances where suggested token has zero balance
-    const { useSelector } = jest.requireMock('react-redux');
-    useSelector.mockImplementation((selector: (state: unknown) => unknown) => {
-      // Mock different selectors based on what they're selecting
-      if (selector.toString().includes('selectAllTokenBalances')) {
-        return {
-          [mockAddress.toLowerCase()]: {
-            '0x1': {
-              '0xZeroBalance': '0', // Zero balance (exact case match with suggested token)
-              '0xToken2': '500000000000000000', // Positive balance (exact case match with allowance)
-            },
-          },
+    const customTokenBalances = {
+      [mockAddress.toLowerCase()]: {
+        '0x1': {
+          '0xZeroBalance': '0',
+          '0xToken2': '500000000000000000',
+        },
+      },
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockUseSelector.mockImplementation((selector: any) => {
+      if (selector === selectAllTokenBalances) {
+        return customTokenBalances;
+      }
+      if (selector === selectSelectedInternalAccountByScope) {
+        return (scope: string) => {
+          if (scope === 'eip155:0') {
+            return {
+              address: mockAddress,
+              id: 'test-account-id',
+              type: 'eip155:eoa' as const,
+              options: {},
+              metadata: {},
+              methods: [],
+            };
+          }
+          return undefined;
         };
       }
-      if (selector.toString().includes('selectCardPriorityToken')) {
-        return mockPriorityToken; // Use the shared mock state
+      const selectorString = selector.toString();
+      if (
+        selectorString.includes('selectCardPriorityToken') &&
+        !selectorString.includes('LastFetched')
+      ) {
+        return mockPriorityToken;
       }
-      if (selector.toString().includes('selectCardPriorityTokenLastFetched')) {
-        return mockLastFetched; // Use the shared mock state
+      if (selectorString.includes('selectCardPriorityTokenLastFetched')) {
+        return mockLastFetched;
       }
       return null;
     });
@@ -696,7 +641,7 @@ describe('useGetPriorityCardToken', () => {
     mockFetchAllowances.mockResolvedValue(allowancesWithZeroBalance);
     mockGetPriorityToken.mockResolvedValue(suggestedTokenWithZeroBalance);
 
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 100));
@@ -704,7 +649,7 @@ describe('useGetPriorityCardToken', () => {
 
     expect(mockDispatch).toHaveBeenCalledWith(
       expect.objectContaining({
-        type: 'card/setCardPriorityToken',
+        type: expect.stringContaining('setCardPriorityToken'),
         payload: expect.objectContaining({
           address: expect.any(String),
           token: expect.objectContaining({
@@ -721,7 +666,6 @@ describe('useGetPriorityCardToken', () => {
   });
 
   it('should return suggested token even with zero balance if no other token has positive balance', async () => {
-    // Create SDK format allowances where all tokens have zero balance
     const tokenWithZeroBalance1SDK = createMockSDKTokenData(
       '0xToken1',
       '1000000000000',
@@ -742,25 +686,44 @@ describe('useGetPriorityCardToken', () => {
       decimals: 18,
     };
 
-    // Mock balances where all tokens have zero balance
-    const { useSelector } = jest.requireMock('react-redux');
-    useSelector.mockImplementation((selector: (state: unknown) => unknown) => {
-      // Mock different selectors based on what they're selecting
-      if (selector.toString().includes('selectAllTokenBalances')) {
-        return {
-          [mockAddress.toLowerCase()]: {
-            '0x1': {
-              '0xToken1': '0',
-              '0xToken2': '0',
-            },
-          },
+    const zeroBalanceTokens = {
+      [mockAddress.toLowerCase()]: {
+        '0x1': {
+          '0xToken1': '0',
+          '0xToken2': '0',
+        },
+      },
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockUseSelector.mockImplementation((selector: any) => {
+      if (selector === selectAllTokenBalances) {
+        return zeroBalanceTokens;
+      }
+      if (selector === selectSelectedInternalAccountByScope) {
+        return (scope: string) => {
+          if (scope === 'eip155:0') {
+            return {
+              address: mockAddress,
+              id: 'test-account-id',
+              type: 'eip155:eoa' as const,
+              options: {},
+              metadata: {},
+              methods: [],
+            };
+          }
+          return undefined;
         };
       }
-      if (selector.toString().includes('selectCardPriorityToken')) {
-        return mockPriorityToken; // Use the shared mock state
+      const selectorString = selector.toString();
+      if (
+        selectorString.includes('selectCardPriorityToken') &&
+        !selectorString.includes('LastFetched')
+      ) {
+        return mockPriorityToken;
       }
-      if (selector.toString().includes('selectCardPriorityTokenLastFetched')) {
-        return mockLastFetched; // Use the shared mock state
+      if (selectorString.includes('selectCardPriorityTokenLastFetched')) {
+        return mockLastFetched;
       }
       return null;
     });
@@ -768,7 +731,7 @@ describe('useGetPriorityCardToken', () => {
     mockFetchAllowances.mockResolvedValue(allowancesWithZeroBalance);
     mockGetPriorityToken.mockResolvedValue(suggestedTokenWithZeroBalance);
 
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 100));
@@ -776,7 +739,7 @@ describe('useGetPriorityCardToken', () => {
 
     expect(mockDispatch).toHaveBeenCalledWith(
       expect.objectContaining({
-        type: 'card/setCardPriorityToken',
+        type: expect.stringContaining('setCardPriorityToken'),
         payload: expect.objectContaining({
           address: expect.any(String),
           token: expect.objectContaining({
@@ -792,18 +755,7 @@ describe('useGetPriorityCardToken', () => {
     expect(result.current.error).toBe(false);
   });
 
-  it('should maintain loading state correctly during fetch', async () => {
-    // Start with no address to avoid automatic fetching
-    const { result, rerender } = renderHook(
-      ({ address }: { address?: string }) => useGetPriorityCardToken(address),
-      {
-        initialProps: { address: undefined as string | undefined },
-      },
-    );
-
-    // Initially, loading should be false with no address
-    expect(result.current.isLoading).toBe(false);
-
+  it('should handle loading state correctly during fetch', async () => {
     let resolvePromise: (value: CardToken) => void;
     const mockPromise = new Promise<CardToken>((resolve) => {
       resolvePromise = resolve;
@@ -812,482 +764,76 @@ describe('useGetPriorityCardToken', () => {
     mockFetchAllowances.mockResolvedValue(mockSDKTokensData);
     mockGetPriorityToken.mockReturnValue(mockPromise);
 
-    // Now provide an address which will trigger useEffect and start loading
-    rerender({ address: mockAddress });
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
-    // Wait a tick for the useEffect to trigger and set loading to true
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 10));
     });
 
-    // Loading should now be true as the fetch is in progress
     expect(result.current.isLoading).toBe(true);
 
-    // Resolve the promise which should set loading back to false
     await act(async () => {
-      resolvePromise?.(mockCardToken);
-      await new Promise((resolve) => setTimeout(resolve, 10)); // Let the promise resolve
+      resolvePromise(mockCardToken);
+      await new Promise((resolve) => setTimeout(resolve, 10));
     });
 
     expect(result.current.isLoading).toBe(false);
   });
 
-  it('should refetch when SDK becomes available', async () => {
-    mockFetchAllowances.mockResolvedValue(mockSDKTokensData);
-    mockGetPriorityToken.mockResolvedValue(mockCardToken);
-
-    (useCardSDK as jest.Mock).mockReturnValue({ sdk: null });
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
-
-    // Wait for initial mount with no SDK
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 0));
-    });
-
-    expect(result.current.priorityToken).toBeNull();
-    expect(mockGetPriorityToken).not.toHaveBeenCalled();
-
-    // Enable SDK and create a new hook instance to trigger fetch
-    (useCardSDK as jest.Mock).mockReturnValue({ sdk: mockSDK });
-
-    renderHook(() => useGetPriorityCardToken(mockAddress));
-
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    });
-
-    expect(mockDispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'card/setCardPriorityToken',
-        payload: expect.objectContaining({
-          address: expect.any(String),
-          token: expect.objectContaining({
-            address: '0xToken1',
-            symbol: 'TKN1',
-            name: 'Token 1',
-            allowanceState: AllowanceState.Enabled,
-          }),
-        }),
-      }),
-    );
-    expect(mockGetPriorityToken).toHaveBeenCalledTimes(1);
-  });
+  it('should handle tokens with limited allowance', async () => {
+    const limitedAllowanceTokens = [
+      createMockSDKTokenData('0xToken1', '1000'),
+      createMockSDKTokenData('0xToken2', '2000'),
+    ];
 
-  it('should automatically fetch priority token on mount when address is provided', async () => {
-    mockFetchAllowances.mockResolvedValue(mockSDKTokensData);
+    mockFetchAllowances.mockResolvedValue(limitedAllowanceTokens);
     mockGetPriorityToken.mockResolvedValue(mockCardToken);
 
-    renderHook(() => useGetPriorityCardToken(mockAddress));
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
-    // Wait for the useEffect to trigger the fetch
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 100));
     });
 
     expect(mockDispatch).toHaveBeenCalledWith(
       expect.objectContaining({
-        type: 'card/setCardPriorityToken',
-        payload: expect.objectContaining({
-          address: expect.any(String),
-          token: expect.objectContaining({
-            address: '0xToken1',
-            symbol: 'TKN1',
-            name: 'Token 1',
-            allowanceState: AllowanceState.Enabled,
-          }),
-        }),
-      }),
-    );
-    expect(mockFetchAllowances).toHaveBeenCalledTimes(1);
-    expect(mockGetPriorityToken).toHaveBeenCalledTimes(1);
-  });
-
-  it('should handle concurrent fetch calls correctly', async () => {
-    let resolvePromise1: (value: CardToken) => void;
-    let resolvePromise2: (value: CardToken) => void;
-
-    const mockPromise1 = new Promise<CardToken>((resolve) => {
-      resolvePromise1 = resolve;
-    });
-    const mockPromise2 = new Promise<CardToken>((resolve) => {
-      resolvePromise2 = resolve;
-    });
-
-    const mockToken1 = {
-      address: '0xToken1',
-      symbol: 'TKN1',
-      name: 'Token 1',
-      decimals: 18,
-    };
-    const mockToken2 = {
-      address: '0xToken2',
-      symbol: 'TKN2',
-      name: 'Token 2',
-      decimals: 18,
-    };
-    const mockSDKAllowance1 = createMockSDKTokenData(
-      '0xToken1',
-      '1000000000000',
-    ); // Large allowance for enabled state
-    const mockSDKAllowance2 = createMockSDKTokenData(
-      '0xToken2',
-      '500000000000',
-    ); // Large allowance for enabled state
-
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
-
-    // Wait for the automatic fetch from useEffect to complete
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    });
-
-    mockFetchAllowances.mockResolvedValueOnce([mockSDKAllowance1]);
-    mockFetchAllowances.mockResolvedValueOnce([mockSDKAllowance2]);
-    mockGetPriorityToken.mockReturnValueOnce(mockPromise1);
-    mockGetPriorityToken.mockReturnValueOnce(mockPromise2);
-
-    let priorityToken1: CardTokenAllowance | null | undefined;
-    let priorityToken2: CardTokenAllowance | null | undefined;
-
-    // Test concurrent calls by calling both functions within act
-    let fetch1: Promise<CardTokenAllowance | null>;
-    let fetch2: Promise<CardTokenAllowance | null>;
-
-    await act(async () => {
-      fetch1 = result.current.fetchPriorityToken();
-      fetch2 = result.current.fetchPriorityToken();
-    });
-
-    // Resolve both promises in an act block
-    await act(async () => {
-      resolvePromise1?.(mockToken1);
-      resolvePromise2?.(mockToken2);
-    });
-
-    // Wait for both fetches to complete
-    await act(async () => {
-      priorityToken1 = await fetch1;
-      priorityToken2 = await fetch2;
-    });
-
-    expect(priorityToken1).toEqual(
-      expect.objectContaining({
-        address: '0xToken1',
-        symbol: 'TKN1',
-        name: 'Token 1',
-        allowanceState: AllowanceState.Enabled,
-      }),
-    );
-    expect(priorityToken2).toEqual(
-      expect.objectContaining({
-        address: '0xToken2',
-        symbol: 'TKN2',
-        name: 'Token 2',
-        allowanceState: AllowanceState.Enabled,
-      }),
-    );
-    expect(mockGetPriorityToken).toHaveBeenCalledTimes(2);
-    expect(result.current.isLoading).toBe(false);
-  });
-
-  it('should return fallback token when no allowances are returned', async () => {
-    // Mock empty allowances array
-    mockFetchAllowances.mockResolvedValue([]);
-
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
-
-    // Wait for the hook to complete its async operations
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    });
-
-    // Should dispatch the first supported token as fallback
-    expect(mockDispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'card/setCardPriorityToken',
-        payload: expect.objectContaining({
-          address: expect.any(String),
-          token: expect.objectContaining({
-            address: '0xToken1',
-            symbol: 'TKN1',
-            name: 'Token 1',
-            allowanceState: AllowanceState.NotEnabled,
-            isStaked: false,
-            chainId: LINEA_CHAIN_ID,
-          }),
-        }),
-      }),
-    );
-
-    expect(mockDispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'card/setCardPriorityTokenLastFetched',
-        payload: expect.objectContaining({
-          address: '0x1234567890123456789012345678901234567890',
-          lastFetched: expect.any(Date),
-        }),
-      }),
-    );
-
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.error).toBe(false);
-    expect(mockGetPriorityToken).not.toHaveBeenCalled();
-  });
-
-  it('should handle address change and refetch', async () => {
-    const address1 = '0x1111111111111111111111111111111111111111';
-    const address2 = '0x2222222222222222222222222222222222222222';
-    const mockSDKAllowance1 = createMockSDKTokenData(
-      '0xToken1',
-      '1000000000000',
-    ); // Large allowance for enabled state
-    const mockSDKAllowance2 = createMockSDKTokenData(
-      '0xToken2',
-      '500000000000',
-    ); // Large allowance for enabled state
-    const mockToken1 = {
-      address: '0xToken1',
-      symbol: 'TKN1',
-      name: 'Token 1',
-      decimals: 18,
-    };
-    const mockToken2 = {
-      address: '0xToken2',
-      symbol: 'TKN2',
-      name: 'Token 2',
-      decimals: 18,
-    };
-
-    // Set up proper token balances for both addresses
-    const { useSelector } = jest.requireMock('react-redux');
-    useSelector.mockImplementation((selector: (state: unknown) => unknown) => {
-      // Mock different selectors based on what they're selecting
-      if (selector.toString().includes('selectAllTokenBalances')) {
-        return {
-          [address1.toLowerCase()]: {
-            '0x1': {
-              '0xToken1': '1000000000000000000',
-            },
-          },
-          [address2.toLowerCase()]: {
-            '0x1': {
-              '0xToken2': '500000000000000000',
-            },
-          },
-        };
-      }
-      if (selector.toString().includes('selectCardPriorityToken')) {
-        return mockPriorityToken; // Use the shared mock state
-      }
-      if (selector.toString().includes('selectCardPriorityTokenLastFetched')) {
-        return mockLastFetched; // Use the shared mock state
-      }
-      return null;
-    });
-
-    // Use mockResolvedValue instead of mockResolvedValueOnce for multiple calls
-    mockFetchAllowances.mockResolvedValue([mockSDKAllowance1]);
-    mockGetPriorityToken.mockResolvedValue(mockToken1);
-
-    const { rerender } = renderHook(
-      ({ address }) => useGetPriorityCardToken(address),
-      {
-        initialProps: { address: address1 },
-      },
-    );
-
-    // Wait for the useEffect to trigger the fetch
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    });
-
-    expect(mockDispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'card/setCardPriorityToken',
+        type: expect.stringContaining('setCardPriorityToken'),
         payload: expect.objectContaining({
-          address: expect.any(String),
+          address: mockAddress,
           token: expect.objectContaining({
             address: '0xToken1',
             symbol: 'TKN1',
             name: 'Token 1',
-            allowanceState: AllowanceState.Enabled,
+            allowanceState: AllowanceState.Limited,
           }),
         }),
       }),
     );
-    expect(mockGetPriorityToken).toHaveBeenCalledWith(address1, ['0xToken1']);
-
-    // Reset mocks for second address
-    mockFetchAllowances.mockClear();
-    mockGetPriorityToken.mockClear();
-    mockFetchAllowances.mockResolvedValue([mockSDKAllowance2]);
-    mockGetPriorityToken.mockResolvedValue(mockToken2);
-
-    // Change address and verify refetch
-    rerender({ address: address2 });
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    });
-
-    expect(mockDispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'card/setCardPriorityToken',
-        payload: expect.objectContaining({
-          address: expect.any(String),
-          token: expect.objectContaining({
-            address: '0xToken2',
-            symbol: 'TKN2',
-            name: 'Token 2',
-            allowanceState: AllowanceState.Enabled,
-          }),
-        }),
-      }),
-    );
-    expect(mockGetPriorityToken).toHaveBeenLastCalledWith(address2, [
-      '0xToken2',
-    ]);
-    expect(mockGetPriorityToken).toHaveBeenCalledTimes(1); // Only once since we cleared
-  });
-
-  it('should return null when no allowances and no supported tokens exist', async () => {
-    // Mock empty allowances and no supported tokens
-    mockFetchAllowances.mockResolvedValue([]);
-
-    // Override SDK to have no supported tokens
-    (useCardSDK as jest.Mock).mockReturnValue({
-      sdk: {
-        ...mockSDK,
-        supportedTokens: [],
-      },
-    });
-
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
-
-    // Wait for the hook to complete its async operations
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    });
-
-    // Should dispatch null when no fallback tokens available
-    expect(mockDispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'card/setCardPriorityToken',
-        payload: expect.objectContaining({
-          address: '0x1234567890123456789012345678901234567890',
-          token: null,
-        }),
-      }),
-    );
-
-    expect(mockDispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'card/setCardPriorityTokenLastFetched',
-        payload: expect.objectContaining({
-          address: '0x1234567890123456789012345678901234567890',
-          lastFetched: expect.any(Date),
-        }),
-      }),
-    );
 
     expect(result.current.isLoading).toBe(false);
     expect(result.current.error).toBe(false);
-    expect(mockGetPriorityToken).not.toHaveBeenCalled();
-  });
-
-  it('should handle error when getSupportedTokensAllowances returns null', async () => {
-    // Mock null response from getSupportedTokensAllowances (which causes fetchAllowances to throw)
-    mockFetchAllowances.mockResolvedValue(null);
-
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
-
-    // Wait for the hook to complete its async operations
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    });
-
-    // This should trigger an error since fetchAllowances tries to map over null
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.error).toBe(true);
-    expect(result.current.priorityToken).toBeNull();
-    expect(mockGetPriorityToken).not.toHaveBeenCalled();
-    expect(Logger.error).toHaveBeenCalledWith(
-      expect.any(Error),
-      'useGetPriorityCardToken::error fetching priority token',
-    );
   });
 
-  it('should return first token when all allowances have zero balance', async () => {
-    // Create allowances where all have zero allowance amounts
-    const zeroAllowanceTokens = [
-      createMockSDKTokenData('0xToken1', '0'), // Zero allowance
-      createMockSDKTokenData('0xToken2', '0'), // Zero allowance
-      createMockSDKTokenData('0xToken3', '0'), // Zero allowance
+  it('should handle unsupported token filtering', async () => {
+    const unsupportedTokenAllowances = [
+      createMockSDKTokenData('0xUnsupportedToken', '1000000000000'),
     ];
 
-    mockFetchAllowances.mockResolvedValue(zeroAllowanceTokens);
+    mockFetchAllowances.mockResolvedValue(unsupportedTokenAllowances);
 
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+    const { result } = renderHook(() => useGetPriorityCardToken());
 
-    // Wait for the hook to complete its async operations
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 100));
     });
 
-    // Should dispatch the first token even though it has zero allowance
     expect(mockDispatch).toHaveBeenCalledWith(
       expect.objectContaining({
-        type: 'card/setCardPriorityToken',
+        type: expect.stringContaining('setCardPriorityToken'),
         payload: expect.objectContaining({
-          address: expect.any(String),
+          address: mockAddress,
           token: expect.objectContaining({
             address: '0xToken1',
-            symbol: 'TKN1',
-            name: 'Token 1',
-            allowanceState: AllowanceState.NotEnabled, // Zero allowance = NotEnabled
-          }),
-        }),
-      }),
-    );
-
-    expect(mockDispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'card/setCardPriorityTokenLastFetched',
-        payload: expect.objectContaining({
-          address: '0x1234567890123456789012345678901234567890',
-          lastFetched: expect.any(Date),
-        }),
-      }),
-    );
-
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.error).toBe(false);
-    expect(mockGetPriorityToken).not.toHaveBeenCalled(); // Should not call getPriorityToken if no valid allowances
-  });
-
-  it('should handle case when all tokens have zero allowance and no supported tokens', async () => {
-    // Create allowances where all have zero allowance amounts
-    const zeroAllowanceTokens = [
-      createMockSDKTokenData('0xUnknownToken', '0'), // Zero allowance, not in supported tokens
-    ];
-
-    mockFetchAllowances.mockResolvedValue(zeroAllowanceTokens);
-
-    const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
-
-    // Wait for the hook to complete its async operations
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    });
-
-    // Should dispatch null since the token is not in supported tokens (filtered out)
-    // and falls back to the fallback token logic
-    expect(mockDispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'card/setCardPriorityToken',
-        payload: expect.objectContaining({
-          address: expect.any(String),
-          token: expect.objectContaining({
-            address: '0xToken1', // First supported token as fallback
             allowanceState: AllowanceState.NotEnabled,
           }),
         }),
@@ -1374,8 +920,9 @@ describe('useGetPriorityCardToken', () => {
       mockDispatch.mockImplementation((action) => action);
 
       // Simplified selector implementation
-      const { useSelector, useDispatch } = jest.requireMock('react-redux');
-      useSelector.mockImplementation(
+      const { useSelector: useSelectorMock, useDispatch: useDispatchMock } =
+        jest.requireMock('react-redux');
+      useSelectorMock.mockImplementation(
         (selector: (state: unknown) => unknown) => {
           const selectorStr = selector.toString();
           // Detect by internal state keys to be resilient to createSelector wrappers
@@ -1409,7 +956,7 @@ describe('useGetPriorityCardToken', () => {
         },
       );
 
-      useDispatch.mockReturnValue(mockDispatch);
+      useDispatchMock.mockReturnValue(mockDispatch);
     });
 
     afterEach(() => {
@@ -1421,7 +968,7 @@ describe('useGetPriorityCardToken', () => {
     });
 
     it('should add token when it does not exist in TokensController', async () => {
-      const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+      const { result } = renderHook(() => useGetPriorityCardToken());
 
       // Wait for the addToken effect to run
       await act(async () => {
@@ -1449,7 +996,7 @@ describe('useGetPriorityCardToken', () => {
         },
       };
 
-      const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+      const { result } = renderHook(() => useGetPriorityCardToken());
 
       // Wait for the addToken effect to run
       await act(async () => {
@@ -1466,7 +1013,7 @@ describe('useGetPriorityCardToken', () => {
         new Error('Add token failed'),
       );
 
-      const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+      const { result } = renderHook(() => useGetPriorityCardToken());
 
       // Wait for the addToken effect to run
       await act(async () => {
@@ -1484,18 +1031,40 @@ describe('useGetPriorityCardToken', () => {
 
     it('should not add token when priorityToken is null', async () => {
       // Mock no priority token
-      const { useSelector } = jest.requireMock('react-redux');
-      useSelector.mockImplementation(
+      const { useSelector: useSelectorMock2 } = jest.requireMock('react-redux');
+      useSelectorMock2.mockImplementation(
         (selector: (state: unknown) => unknown) => {
-          const selectorString = selector.toString();
-          if (selectorString.includes('selectCardPriorityToken')) {
+          const selectorStr = selector.toString();
+          if (
+            selector === selectAllTokenBalances ||
+            selectorStr.includes('selectAllTokenBalances')
+          ) {
+            return STATIC_TOKEN_BALANCES;
+          }
+          if (
+            selector === selectSelectedInternalAccountByScope ||
+            selectorStr.includes('selectSelectedInternalAccountByScope')
+          ) {
+            return (scope: string) => {
+              if (scope === 'eip155:0') {
+                return {
+                  address: mockAddress,
+                };
+              }
+              return undefined;
+            };
+          }
+          if (selectorStr.includes('selectCardPriorityToken')) {
             return null; // No priority token
           }
+          if (selectorStr.includes('selectCardPriorityTokenLastFetched')) {
+            return new Date();
+          }
           return null;
         },
       );
 
-      const { result } = renderHook(() => useGetPriorityCardToken(mockAddress));
+      const { result } = renderHook(() => useGetPriorityCardToken());
 
       // Wait for effects to run
       await act(async () => {
diff --git a/app/components/UI/Card/hooks/useGetPriorityCardToken.tsx b/app/components/UI/Card/hooks/useGetPriorityCardToken.tsx
index 675d65d77cf..12e67c33172 100644
--- a/app/components/UI/Card/hooks/useGetPriorityCardToken.tsx
+++ b/app/components/UI/Card/hooks/useGetPriorityCardToken.tsx
@@ -16,6 +16,7 @@ import { LINEA_CHAIN_ID } from '@metamask/swaps-controller/dist/constants';
 import { selectAllTokenBalances } from '../../../../selectors/tokenBalancesController';
 import { CardSDK } from '../sdk/CardSDK';
 import { ARBITRARY_ALLOWANCE } from '../constants';
+import { selectSelectedInternalAccountByScope } from '../../../../selectors/multichainAccounts/accounts';
 import {
   selectCardPriorityToken,
   selectCardPriorityTokenLastFetched,
@@ -106,8 +107,6 @@ const fetchAllowances = async (
  * This hook implements a caching strategy where if the priority token was fetched less than 5 minutes ago,
  * it returns the cached value. Otherwise, it fetches a new priority token from the Card SDK.
  *
- * @param {string} [address] - Ethereum address of the user whose card token priority is to be fetched.
- * @param {boolean} [shouldFetch=true] - Whether the hook should attempt to fetch if cache is stale.
  * @returns {{
  * fetchPriorityToken: () => Promise<CardTokenAllowance | null>,
  * isLoading: boolean,
@@ -120,10 +119,7 @@ const fetchAllowances = async (
  * - error: any error encountered while fetching
  * - priorityToken: the cached or newly fetched priority token
  */
-export const useGetPriorityCardToken = (
-  selectedAddress?: string,
-  shouldFetch: boolean = true,
-) => {
+export const useGetPriorityCardToken = () => {
   const dispatch = useDispatch();
   const { TokensController, NetworkController } = Engine.context;
   const { sdk } = useCardSDK();
@@ -133,6 +129,9 @@ export const useGetPriorityCardToken = (
 
   // Extract controller state
   const allTokenBalances = useSelector(selectAllTokenBalances);
+  const selectedAddress = useSelector(selectSelectedInternalAccountByScope)(
+    'eip155:0',
+  )?.address;
   const priorityToken = useSelector(selectCardPriorityToken(selectedAddress));
   const lastFetched = useSelector(
     selectCardPriorityTokenLastFetched(selectedAddress),
@@ -343,7 +342,7 @@ export const useGetPriorityCardToken = (
     }, [sdk, selectedAddress, getBalancesForChain, dispatch]);
 
   useEffect(() => {
-    if (!selectedAddress || !shouldFetch) {
+    if (!selectedAddress) {
       return;
     }
 
@@ -356,7 +355,6 @@ export const useGetPriorityCardToken = (
     fetchPriorityToken();
   }, [
     selectedAddress,
-    shouldFetch,
     cacheIsValid,
     priorityToken,
     fetchPriorityToken,
diff --git a/app/components/UI/Card/hooks/useOpenSwaps.test.ts b/app/components/UI/Card/hooks/useOpenSwaps.test.ts
index f4e526b2dad..2a650789f5d 100644
--- a/app/components/UI/Card/hooks/useOpenSwaps.test.ts
+++ b/app/components/UI/Card/hooks/useOpenSwaps.test.ts
@@ -156,7 +156,6 @@ describe('useOpenSwaps', () => {
     act(() => {
       result.current.openSwaps({
         chainId: '0xe708',
-        cardholderAddress: '0xcard',
       });
     });
 
@@ -194,7 +193,6 @@ describe('useOpenSwaps', () => {
     act(() => {
       result.current.openSwaps({
         chainId: '0xe708',
-        cardholderAddress: '0xcard',
       });
     });
 
@@ -222,7 +220,6 @@ describe('useOpenSwaps', () => {
     act(() => {
       result.current.openSwaps({
         chainId: '0xe708',
-        cardholderAddress: '0xcard',
         beforeNavigate,
       });
     });
@@ -276,7 +273,6 @@ describe('useOpenSwaps', () => {
     act(() => {
       result.current.openSwaps({
         chainId: '0xe708',
-        cardholderAddress: '0xcard',
       });
     });
 
diff --git a/app/components/UI/Card/hooks/useOpenSwaps.ts b/app/components/UI/Card/hooks/useOpenSwaps.ts
index 7c5d7cbc1ab..2b0c6e48642 100644
--- a/app/components/UI/Card/hooks/useOpenSwaps.ts
+++ b/app/components/UI/Card/hooks/useOpenSwaps.ts
@@ -18,7 +18,6 @@ import { useTokensWithBalance } from '../../Bridge/hooks/useTokensWithBalance';
 
 export interface OpenSwapsParams {
   chainId: string;
-  cardholderAddress?: string;
   beforeNavigate?: (navigate: () => void) => void;
 }
 
diff --git a/app/components/UI/Card/sdk/CardSDK.test.ts b/app/components/UI/Card/sdk/CardSDK.test.ts
index 26824f7d59e..9cb63b574e1 100644
--- a/app/components/UI/Card/sdk/CardSDK.test.ts
+++ b/app/components/UI/Card/sdk/CardSDK.test.ts
@@ -112,7 +112,6 @@ describe('CardSDK', () => {
 
     cardSDK = new CardSDK({
       cardFeatureFlag: mockCardFeatureFlag,
-      rawChainId: '0xe708',
     });
   });
 
@@ -143,7 +142,6 @@ describe('CardSDK', () => {
 
       const disabledCardholderSDK = new CardSDK({
         cardFeatureFlag: disabledCardFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       expect(disabledCardholderSDK.isCardEnabled).toBe(false);
@@ -154,7 +152,6 @@ describe('CardSDK', () => {
 
       const noChainCardholderSDK = new CardSDK({
         cardFeatureFlag: emptyCardFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       expect(noChainCardholderSDK.isCardEnabled).toBe(false);
@@ -181,7 +178,6 @@ describe('CardSDK', () => {
 
       const disabledCardholderSDK = new CardSDK({
         cardFeatureFlag: disabledCardFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       expect(disabledCardholderSDK.supportedTokens).toEqual([]);
@@ -202,7 +198,6 @@ describe('CardSDK', () => {
 
       const noTokensCardSDK = new CardSDK({
         cardFeatureFlag: noTokensCardFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       expect(noTokensCardSDK.supportedTokens).toEqual([]);
@@ -226,7 +221,6 @@ describe('CardSDK', () => {
 
       const missingFoxConnectSDK = new CardSDK({
         cardFeatureFlag: missingFoxConnectFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       // This should throw an error when trying to access foxConnectAddresses
@@ -258,7 +252,6 @@ describe('CardSDK', () => {
 
       const missingBalanceScannerSDK = new CardSDK({
         cardFeatureFlag: missingBalanceScannerFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       // This should throw an error when trying to access balanceScannerAddress
@@ -304,7 +297,6 @@ describe('CardSDK', () => {
 
       const disabledCardholderSDK = new CardSDK({
         cardFeatureFlag: disabledCardFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       const result = await disabledCardholderSDK.isCardHolder([
@@ -469,7 +461,6 @@ describe('CardSDK', () => {
 
       const missingAccountsApiSDK = new CardSDK({
         cardFeatureFlag: missingAccountsApiFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       const result = await missingAccountsApiSDK.isCardHolder([
@@ -567,7 +558,6 @@ describe('CardSDK', () => {
 
       const disabledCardholderSDK = new CardSDK({
         cardFeatureFlag: disabledCardFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       await expect(
@@ -592,7 +582,6 @@ describe('CardSDK', () => {
 
       const emptyTokensCardSDK = new CardSDK({
         cardFeatureFlag: emptyTokensCardFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       const result = await emptyTokensCardSDK.getSupportedTokensAllowances(
@@ -645,7 +634,6 @@ describe('CardSDK', () => {
 
       const disabledCardholderSDK = new CardSDK({
         cardFeatureFlag: disabledCardFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       await expect(
@@ -780,7 +768,6 @@ describe('CardSDK', () => {
 
       const emptyCardholderSDK = new CardSDK({
         cardFeatureFlag: emptyCardFeatureFlag,
-        rawChainId: '0xe708',
       });
 
       mockProvider.getLogs.mockResolvedValue([]);
diff --git a/app/components/UI/Card/sdk/CardSDK.ts b/app/components/UI/Card/sdk/CardSDK.ts
index 72c82c5d0ee..17e8580616e 100644
--- a/app/components/UI/Card/sdk/CardSDK.ts
+++ b/app/components/UI/Card/sdk/CardSDK.ts
@@ -3,12 +3,12 @@ import {
   CardFeatureFlag,
   SupportedToken,
 } from '../../../../selectors/featureFlagController/card';
-import { SupportedCaipChainId } from '@metamask/multichain-network-controller';
 import { getDecimalChainId } from '../../../../util/networks';
 import { LINEA_DEFAULT_RPC_URL } from '../../../../constants/urls';
 import { BALANCE_SCANNER_ABI } from '../constants';
 import Logger from '../../../../util/Logger';
 import { CardToken } from '../types';
+import { LINEA_CHAIN_ID } from '@metamask/swaps-controller/dist/constants';
 
 // The CardSDK class provides methods to interact with the Card feature
 // and check if an address is a card holder, get supported tokens, and more.
@@ -21,15 +21,13 @@ export class CardSDK {
 
   constructor({
     cardFeatureFlag,
-    rawChainId,
     enableLogs = false,
   }: {
     cardFeatureFlag: CardFeatureFlag;
-    rawChainId: `0x${string}` | SupportedCaipChainId;
     enableLogs?: boolean;
   }) {
     this.cardFeatureFlag = cardFeatureFlag;
-    this.chainId = getDecimalChainId(rawChainId);
+    this.chainId = getDecimalChainId(LINEA_CHAIN_ID);
     this.enableLogs = enableLogs;
   }
 
diff --git a/app/components/UI/Card/sdk/index.test.tsx b/app/components/UI/Card/sdk/index.test.tsx
index 4dcf6efbdc8..392fef89866 100644
--- a/app/components/UI/Card/sdk/index.test.tsx
+++ b/app/components/UI/Card/sdk/index.test.tsx
@@ -15,6 +15,7 @@ import {
 } from '../../../../selectors/featureFlagController/card';
 import { selectChainId } from '../../../../selectors/networkController';
 import { useCardholderCheck } from '../hooks/useCardholderCheck';
+import { View } from 'react-native';
 
 jest.mock('./CardSDK', () => ({
   CardSDK: jest.fn().mockImplementation(() => ({
@@ -98,7 +99,7 @@ describe('CardSDK Context', () => {
     it('should render children without crashing', () => {
       setupMockUseSelector(mockCardFeatureFlag);
 
-      const TestComponent = () => <div>Test Child</div>;
+      const TestComponent = () => <View>Test Child</View>;
 
       render(
         <CardSDKProvider>
@@ -108,14 +109,13 @@ describe('CardSDK Context', () => {
 
       expect(MockedCardholderSDK).toHaveBeenCalledWith({
         cardFeatureFlag: mockCardFeatureFlag,
-        rawChainId: '0xe708',
       });
     });
 
     it('should not initialize SDK when card feature flag is missing', () => {
       setupMockUseSelector(null);
 
-      const TestComponent = () => <div>Test Child</div>;
+      const TestComponent = () => <View>Test Child</View>;
 
       render(
         <CardSDKProvider>
@@ -136,7 +136,7 @@ describe('CardSDK Context', () => {
       const TestComponent = () => {
         const context = useCardSDK();
         expect(context).toEqual(providedValue);
-        return <div>Test Child</div>;
+        return <View>Test Child</View>;
       };
 
       render(
@@ -223,7 +223,7 @@ describe('CardSDK Context', () => {
     it('should handle undefined card feature flag gracefully', () => {
       setupMockUseSelector(undefined);
 
-      const TestComponent = () => <div>Test Child</div>;
+      const TestComponent = () => <View>Test Child</View>;
 
       render(
         <CardSDKProvider>
@@ -237,7 +237,7 @@ describe('CardSDK Context', () => {
     it('should handle empty card feature flag gracefully', () => {
       setupMockUseSelector({});
 
-      const TestComponent = () => <div>Test Child</div>;
+      const TestComponent = () => <View>Test Child</View>;
 
       render(
         <CardSDKProvider>
@@ -247,7 +247,6 @@ describe('CardSDK Context', () => {
 
       expect(MockedCardholderSDK).toHaveBeenCalledWith({
         cardFeatureFlag: {},
-        rawChainId: '0xe708',
       });
     });
   });
diff --git a/app/components/UI/Card/sdk/index.tsx b/app/components/UI/Card/sdk/index.tsx
index f30d267561a..bd95e9e4bf4 100644
--- a/app/components/UI/Card/sdk/index.tsx
+++ b/app/components/UI/Card/sdk/index.tsx
@@ -10,7 +10,6 @@ import { useSelector } from 'react-redux';
 import { CardSDK } from './CardSDK';
 import { selectCardFeatureFlag } from '../../../../selectors/featureFlagController/card';
 import { useCardholderCheck } from '../hooks/useCardholderCheck';
-import { LINEA_CHAIN_ID } from '@metamask/swaps-controller/dist/constants';
 
 export interface ICardSDK {
   sdk: CardSDK | null;
@@ -36,7 +35,6 @@ export const CardSDKProvider = ({
     if (cardFeatureFlag) {
       const cardSDK = new CardSDK({
         cardFeatureFlag,
-        rawChainId: LINEA_CHAIN_ID,
       });
       setSdk(cardSDK);
     } else {
diff --git a/app/components/UI/Card/util/getCardholder.test.ts b/app/components/UI/Card/util/getCardholder.test.ts
index ebc9afae7f8..457c2ccacdb 100644
--- a/app/components/UI/Card/util/getCardholder.test.ts
+++ b/app/components/UI/Card/util/getCardholder.test.ts
@@ -2,11 +2,7 @@ import { getCardholder } from './getCardholder';
 import { CardSDK } from '../sdk/CardSDK';
 import Logger from '../../../../util/Logger';
 import { CardFeatureFlag } from '../../../../selectors/featureFlagController/card';
-import {
-  isValidHexAddress,
-  safeToChecksumAddress,
-} from '../../../../util/address';
-import { LINEA_CHAIN_ID } from '@metamask/swaps-controller/dist/constants';
+import { isValidHexAddress } from '../../../../util/address';
 
 // Mock dependencies
 jest.mock('../sdk/CardSDK');
@@ -21,8 +17,6 @@ const mockedLogger = Logger as jest.Mocked<typeof Logger>;
 const mockedIsValidHexAddress = isValidHexAddress as jest.MockedFunction<
   typeof isValidHexAddress
 >;
-const mockedSafeToChecksumAddress =
-  safeToChecksumAddress as jest.MockedFunction<typeof safeToChecksumAddress>;
 
 describe('getCardholder', () => {
   const mockCardFeatureFlag: CardFeatureFlag = {
@@ -69,9 +63,6 @@ describe('getCardholder', () => {
 
     // Mock address utilities
     mockedIsValidHexAddress.mockReturnValue(true);
-    mockedSafeToChecksumAddress.mockImplementation(
-      (address) => address as `0x${string}`,
-    );
   });
 
   describe('successful scenarios', () => {
@@ -94,7 +85,6 @@ describe('getCardholder', () => {
       ]);
       expect(MockedCardSDK).toHaveBeenCalledWith({
         cardFeatureFlag: mockCardFeatureFlag,
-        rawChainId: LINEA_CHAIN_ID,
       });
       expect(mockCardSDKInstance.isCardHolder).toHaveBeenCalledWith(
         mockFormattedAccounts,
@@ -288,7 +278,6 @@ describe('getCardholder', () => {
         '0x2222222222222222222222222222222222222222',
         '0x3333333333333333333333333333333333333333',
       ]);
-      expect(mockedSafeToChecksumAddress).toHaveBeenCalledTimes(3);
     });
 
     it('should handle invalid CAIP-10 format and log errors', async () => {
diff --git a/app/components/UI/Card/util/getCardholder.ts b/app/components/UI/Card/util/getCardholder.ts
index b283c0db119..7af2d58cf94 100644
--- a/app/components/UI/Card/util/getCardholder.ts
+++ b/app/components/UI/Card/util/getCardholder.ts
@@ -1,11 +1,7 @@
-import { LINEA_CHAIN_ID } from '@metamask/swaps-controller/dist/constants';
 import { CardFeatureFlag } from '../../../../selectors/featureFlagController/card';
 import { CardSDK } from '../sdk/CardSDK';
 import Logger from '../../../../util/Logger';
-import {
-  isValidHexAddress,
-  safeToChecksumAddress,
-} from '../../../../util/address';
+import { isValidHexAddress } from '../../../../util/address';
 import { isCaipAccountId, parseCaipAccountId } from '@metamask/utils';
 
 export const getCardholder = async ({
@@ -22,7 +18,6 @@ export const getCardholder = async ({
 
     const cardSDK = new CardSDK({
       cardFeatureFlag,
-      rawChainId: LINEA_CHAIN_ID,
     });
 
     const cardCaipAccountIds = await cardSDK.isCardHolder(caipAccountIds);
@@ -34,7 +29,7 @@ export const getCardholder = async ({
 
       if (!isValidHexAddress(address)) return null;
 
-      return safeToChecksumAddress(address);
+      return address.toLowerCase();
     });
 
     return cardholderAddresses.filter(Boolean) as string[];
diff --git a/app/components/UI/Perps/Views/PerpsBalanceModal/PerpsBalanceModal.tsx b/app/components/UI/Perps/Views/PerpsBalanceModal/PerpsBalanceModal.tsx
index f1f8f707319..a023d0ca6aa 100644
--- a/app/components/UI/Perps/Views/PerpsBalanceModal/PerpsBalanceModal.tsx
+++ b/app/components/UI/Perps/Views/PerpsBalanceModal/PerpsBalanceModal.tsx
@@ -20,6 +20,7 @@ import Routes from '../../../../../constants/navigation/Routes';
 import type { PerpsNavigationParamList } from '../../controllers/types';
 import { usePerpsTrading, usePerpsNetworkManagement } from '../../hooks';
 import createStyles from './PerpsBalanceModal.styles';
+import { PerpsTabViewSelectorsIDs } from '../../../../../../e2e/selectors/Perps/Perps.selectors';
 
 interface PerpsBalanceModalProps {}
 
@@ -89,6 +90,7 @@ const PerpsBalanceModal: React.FC<PerpsBalanceModalProps> = () => {
           onPress={handleAddFunds}
           style={styles.actionButton}
           startIconName={IconName.Add}
+          testID={PerpsTabViewSelectorsIDs.ADD_FUNDS_BUTTON}
         />
         <Button
           variant={ButtonVariants.Secondary}
diff --git a/app/components/UI/Perps/Views/PerpsMarketListView/PerpsMarketListView.test.tsx b/app/components/UI/Perps/Views/PerpsMarketListView/PerpsMarketListView.test.tsx
index f17ac3fc5bf..316952fcea5 100644
--- a/app/components/UI/Perps/Views/PerpsMarketListView/PerpsMarketListView.test.tsx
+++ b/app/components/UI/Perps/Views/PerpsMarketListView/PerpsMarketListView.test.tsx
@@ -9,6 +9,7 @@ import {
 import PerpsMarketListView from './PerpsMarketListView';
 import type { PerpsMarketData } from '../../controllers/types';
 import Routes from '../../../../../constants/navigation/Routes';
+import { PerpsMarketListViewSelectorsIDs } from '../../../../../../e2e/selectors/Perps/Perps.selectors';
 import renderWithProvider from '../../../../../util/test/renderWithProvider';
 
 // Mock dependencies
@@ -324,7 +325,9 @@ describe('PerpsMarketListView', () => {
 
       expect(screen.getByText('Perps')).toBeOnTheScreen();
       expect(
-        screen.getByTestId('perps-market-list-search-toggle-button'),
+        screen.getByTestId(
+          PerpsMarketListViewSelectorsIDs.SEARCH_TOGGLE_BUTTON,
+        ),
       ).toBeOnTheScreen();
       expect(screen.getByText('Volume')).toBeOnTheScreen();
       expect(screen.getByText('Price / 24h change')).toBeOnTheScreen();
@@ -343,7 +346,9 @@ describe('PerpsMarketListView', () => {
 
       // Should have search toggle button and market rows
       expect(
-        screen.getByTestId('perps-market-list-search-toggle-button'),
+        screen.getByTestId(
+          PerpsMarketListViewSelectorsIDs.SEARCH_TOGGLE_BUTTON,
+        ),
       ).toBeOnTheScreen();
       expect(screen.getByTestId('market-row-BTC')).toBeOnTheScreen();
       expect(screen.getByTestId('market-row-ETH')).toBeOnTheScreen();
@@ -362,7 +367,7 @@ describe('PerpsMarketListView', () => {
 
       // Click search toggle button
       const searchButton = screen.getByTestId(
-        'perps-market-list-search-toggle-button',
+        PerpsMarketListViewSelectorsIDs.SEARCH_TOGGLE_BUTTON,
       );
       act(() => {
         fireEvent.press(searchButton);
@@ -379,7 +384,7 @@ describe('PerpsMarketListView', () => {
 
       // First toggle search visibility
       const searchButton = screen.getByTestId(
-        'perps-market-list-search-toggle-button',
+        PerpsMarketListViewSelectorsIDs.SEARCH_TOGGLE_BUTTON,
       );
       act(() => {
         fireEvent.press(searchButton);
@@ -400,7 +405,7 @@ describe('PerpsMarketListView', () => {
 
       // First toggle search visibility
       const searchButton = screen.getByTestId(
-        'perps-market-list-search-toggle-button',
+        PerpsMarketListViewSelectorsIDs.SEARCH_TOGGLE_BUTTON,
       );
       act(() => {
         fireEvent.press(searchButton);
@@ -421,7 +426,7 @@ describe('PerpsMarketListView', () => {
 
       // First toggle search visibility
       const searchButton = screen.getByTestId(
-        'perps-market-list-search-toggle-button',
+        PerpsMarketListViewSelectorsIDs.SEARCH_TOGGLE_BUTTON,
       );
       act(() => {
         fireEvent.press(searchButton);
@@ -436,7 +441,7 @@ describe('PerpsMarketListView', () => {
 
       // Should show clear button when there's search text
       expect(
-        screen.getByTestId('perps-market-list-search-clear-button'),
+        screen.getByTestId(PerpsMarketListViewSelectorsIDs.SEARCH_CLEAR_BUTTON),
       ).toBeOnTheScreen();
 
       // Should only show the filtered market (BTC), not others
@@ -449,7 +454,7 @@ describe('PerpsMarketListView', () => {
 
       // First toggle search visibility
       const searchButton = screen.getByTestId(
-        'perps-market-list-search-toggle-button',
+        PerpsMarketListViewSelectorsIDs.SEARCH_TOGGLE_BUTTON,
       );
       act(() => {
         fireEvent.press(searchButton);
@@ -468,7 +473,7 @@ describe('PerpsMarketListView', () => {
 
       // Find and press clear button using testID
       const clearButton = screen.getByTestId(
-        'perps-market-list-search-clear-button',
+        PerpsMarketListViewSelectorsIDs.SEARCH_CLEAR_BUTTON,
       );
       act(() => {
         fireEvent.press(clearButton);
@@ -488,7 +493,7 @@ describe('PerpsMarketListView', () => {
 
       // First toggle search visibility
       const searchButton = screen.getByTestId(
-        'perps-market-list-search-toggle-button',
+        PerpsMarketListViewSelectorsIDs.SEARCH_TOGGLE_BUTTON,
       );
       act(() => {
         fireEvent.press(searchButton);
@@ -636,7 +641,7 @@ describe('PerpsMarketListView', () => {
 
       // Find the tutorial button
       const tutorialButton = screen.getByTestId(
-        'perps-market-list-tutorial-button',
+        PerpsMarketListViewSelectorsIDs.TUTORIAL_BUTTON,
       );
       act(() => {
         fireEvent.press(tutorialButton);
@@ -817,7 +822,7 @@ describe('PerpsMarketListView', () => {
 
       // First toggle search visibility
       const searchButton = screen.getByTestId(
-        'perps-market-list-search-toggle-button',
+        PerpsMarketListViewSelectorsIDs.SEARCH_TOGGLE_BUTTON,
       );
       act(() => {
         fireEvent.press(searchButton);
@@ -839,7 +844,7 @@ describe('PerpsMarketListView', () => {
 
       // First toggle search visibility
       const searchButton = screen.getByTestId(
-        'perps-market-list-search-toggle-button',
+        PerpsMarketListViewSelectorsIDs.SEARCH_TOGGLE_BUTTON,
       );
       act(() => {
         fireEvent.press(searchButton);
diff --git a/app/components/UI/Perps/Views/PerpsMarketListView/PerpsMarketListView.tsx b/app/components/UI/Perps/Views/PerpsMarketListView/PerpsMarketListView.tsx
index 934b55bbe31..5ab1e18700d 100644
--- a/app/components/UI/Perps/Views/PerpsMarketListView/PerpsMarketListView.tsx
+++ b/app/components/UI/Perps/Views/PerpsMarketListView/PerpsMarketListView.tsx
@@ -89,7 +89,10 @@ const PerpsMarketListHeader = () => {
   const { styles } = useStyles(styleSheet, {});
 
   return (
-    <View style={styles.listHeader}>
+    <View
+      style={styles.listHeader}
+      testID={PerpsMarketListViewSelectorsIDs.LIST_HEADER}
+    >
       <View style={styles.listHeaderLeft}>
         <Text variant={TextVariant.BodySMMedium} color={TextColor.Alternative}>
           {strings('perps.volume')}
@@ -424,6 +427,7 @@ const PerpsMarketListView = ({
               iconName={IconName.Arrow2Left}
               size={ButtonIconSizes.Md}
               onPress={handleBackPressed}
+              testID={PerpsMarketListViewSelectorsIDs.BACK_HEADER_BUTTON}
             />
           </View>
           <Text
diff --git a/app/components/UI/Perps/Views/PerpsOrderView/PerpsOrderView.tsx b/app/components/UI/Perps/Views/PerpsOrderView/PerpsOrderView.tsx
index c7a4652f41c..093e07e0593 100644
--- a/app/components/UI/Perps/Views/PerpsOrderView/PerpsOrderView.tsx
+++ b/app/components/UI/Perps/Views/PerpsOrderView/PerpsOrderView.tsx
@@ -14,8 +14,13 @@ import React, {
 } from 'react';
 import { ScrollView, TouchableOpacity, View } from 'react-native';
 import { SafeAreaView } from 'react-native-safe-area-context';
+import {
+  PerpsOrderViewSelectorsIDs,
+  PerpsGeneralSelectorsIDs,
+} from '../../../../../../e2e/selectors/Perps/Perps.selectors';
+
 import { notificationAsync, NotificationFeedbackType } from 'expo-haptics';
-import { PerpsOrderViewSelectorsIDs } from '../../../../../../e2e/selectors/Perps/Perps.selectors';
+
 import { strings } from '../../../../../../locales/i18n';
 import Button, {
   ButtonSize,
@@ -213,6 +218,7 @@ const PerpsOrderViewContentBase: React.FC = () => {
             label: strings('perps.order.error.dismiss'),
             variant: ButtonVariants.Secondary,
             onPress: () => toastRef?.current?.closeToast(),
+            testID: PerpsGeneralSelectorsIDs.ORDER_SUCCESS_TOAST_DISMISS_BUTTON,
           },
         });
 
@@ -855,7 +861,10 @@ const PerpsOrderViewContentBase: React.FC = () => {
 
           {/* Combined TP/SL row */}
           <View style={[styles.detailItem, styles.detailItemLast]}>
-            <TouchableOpacity onPress={() => setIsTPSLVisible(true)}>
+            <TouchableOpacity
+              onPress={() => setIsTPSLVisible(true)}
+              testID={PerpsOrderViewSelectorsIDs.STOP_LOSS_BUTTON}
+            >
               <ListItem>
                 <ListItemColumn widthType={WidthType.Fill}>
                   <View style={styles.detailLeft}>
@@ -968,7 +977,10 @@ const PerpsOrderViewContentBase: React.FC = () => {
       </ScrollView>
       {/* Keypad Section - Show when input is focused */}
       {isInputFocused && (
-        <View style={styles.bottomSection}>
+        <View
+          style={styles.bottomSection}
+          testID={PerpsOrderViewSelectorsIDs.KEYPAD}
+        >
           <View style={styles.percentageButtonsContainer}>
             <Button
               variant={ButtonVariants.Secondary}
diff --git a/app/components/UI/Perps/Views/PerpsPositionsView/PerpsPositionsView.test.tsx b/app/components/UI/Perps/Views/PerpsPositionsView/PerpsPositionsView.test.tsx
index 0b190b34a37..1390febff7a 100644
--- a/app/components/UI/Perps/Views/PerpsPositionsView/PerpsPositionsView.test.tsx
+++ b/app/components/UI/Perps/Views/PerpsPositionsView/PerpsPositionsView.test.tsx
@@ -4,6 +4,7 @@ import {
   screen,
   fireEvent,
   waitFor,
+  within,
 } from '@testing-library/react-native';
 import { useNavigation, useFocusEffect } from '@react-navigation/native';
 import PerpsPositionsView from './PerpsPositionsView';
@@ -228,10 +229,13 @@ describe('PerpsPositionsView', () => {
 
       // Assert
       await waitFor(() => {
-        expect(screen.getByText('Open Positions')).toBeOnTheScreen();
-        expect(screen.getByText('2 positions')).toBeOnTheScreen();
-        expect(screen.getByText(/1\.50[\s\S]*ETH/)).toBeOnTheScreen();
-        expect(screen.getByText(/0\.5000[\s\S]*BTC/)).toBeOnTheScreen();
+        const section = screen.getByTestId('perps-positions-section');
+        expect(within(section).getByText('Open Positions')).toBeOnTheScreen();
+        expect(within(section).getByText('2 positions')).toBeOnTheScreen();
+        expect(within(section).getByText(/1\.50[\s\S]*ETH/)).toBeOnTheScreen();
+        expect(
+          within(section).getByText(/0\.5000[\s\S]*BTC/),
+        ).toBeOnTheScreen();
       });
     });
 
@@ -340,7 +344,8 @@ describe('PerpsPositionsView', () => {
 
       // Assert
       await waitFor(() => {
-        expect(screen.getByText('Open Positions')).toBeOnTheScreen();
+        const section = screen.getByTestId('perps-positions-section');
+        expect(within(section).getByText('Open Positions')).toBeOnTheScreen();
       });
     });
 
@@ -350,7 +355,8 @@ describe('PerpsPositionsView', () => {
 
       // Assert
       await waitFor(() => {
-        expect(screen.getByText('Open Positions')).toBeOnTheScreen();
+        const section = screen.getByTestId('perps-positions-section');
+        expect(within(section).getByText('Open Positions')).toBeOnTheScreen();
       });
     });
   });
diff --git a/app/components/UI/Perps/Views/PerpsPositionsView/PerpsPositionsView.tsx b/app/components/UI/Perps/Views/PerpsPositionsView/PerpsPositionsView.tsx
index b9e5d887445..3944355d538 100644
--- a/app/components/UI/Perps/Views/PerpsPositionsView/PerpsPositionsView.tsx
+++ b/app/components/UI/Perps/Views/PerpsPositionsView/PerpsPositionsView.tsx
@@ -30,6 +30,7 @@ import { formatPnl, formatPrice } from '../../utils/formatUtils';
 import { calculateTotalPnL } from '../../utils/pnlCalculations';
 import { createStyles } from './PerpsPositionsView.styles';
 import { SafeAreaView } from 'react-native-safe-area-context';
+import { PerpsPositionsViewSelectorsIDs } from '../../../../../../e2e/selectors/Perps/Perps.selectors';
 
 const PerpsPositionsView: React.FC = () => {
   const { styles } = useStyles(createStyles, {});
@@ -114,7 +115,10 @@ const PerpsPositionsView: React.FC = () => {
     }
 
     return (
-      <View style={styles.positionsSection}>
+      <View
+        style={styles.positionsSection}
+        testID={PerpsPositionsViewSelectorsIDs.POSITIONS_SECTION}
+      >
         <View style={styles.sectionHeader}>
           <Text variant={TextVariant.HeadingSM} color={TextColor.Default}>
             {strings('perps.position.list.open_positions')}
@@ -123,12 +127,24 @@ const PerpsPositionsView: React.FC = () => {
             {positionCountText}
           </Text>
         </View>
-        {positions.map((position, index) => (
-          <PerpsPositionCard
-            key={`${position.coin}-${index}`}
-            position={position}
-          />
-        ))}
+        {positions.map((position, index) => {
+          const sizeValue = parseFloat(position.size);
+          const directionSegment = Number.isFinite(sizeValue)
+            ? sizeValue > 0
+              ? 'long'
+              : sizeValue < 0
+              ? 'short'
+              : 'unknown'
+            : 'unknown';
+          return (
+            <View
+              key={`${position.coin}-${index}`}
+              testID={`${PerpsPositionsViewSelectorsIDs.POSITION_ITEM}-${position.coin}-${position.leverage.value}x-${directionSegment}-${index}`}
+            >
+              <PerpsPositionCard position={position} />
+            </View>
+          );
+        })}
       </View>
     );
   };
@@ -197,7 +213,6 @@ const PerpsPositionsView: React.FC = () => {
             </Text>
           </View>
         </View>
-
         {renderContent()}
       </ScrollView>
 
diff --git a/app/components/UI/Perps/Views/PerpsTabView/PerpsTabView.test.tsx b/app/components/UI/Perps/Views/PerpsTabView/PerpsTabView.test.tsx
index e45b2e45db8..7bfed4bcde1 100644
--- a/app/components/UI/Perps/Views/PerpsTabView/PerpsTabView.test.tsx
+++ b/app/components/UI/Perps/Views/PerpsTabView/PerpsTabView.test.tsx
@@ -147,6 +147,10 @@ jest.mock('../../../../../../e2e/selectors/Perps/Perps.selectors', () => ({
   PerpsTabViewSelectorsIDs: {
     START_NEW_TRADE_CTA: 'perps-tab-view-start-new-trade-cta',
   },
+  PerpsPositionsViewSelectorsIDs: {
+    POSITIONS_SECTION_TITLE: 'perps-positions-section-title',
+    POSITION_ITEM: 'perps-positions-item',
+  },
 }));
 
 jest.mock('../../components/PerpsBottomSheetTooltip', () => ({
diff --git a/app/components/UI/Perps/Views/PerpsTabView/PerpsTabView.tsx b/app/components/UI/Perps/Views/PerpsTabView/PerpsTabView.tsx
index 56ada1c1702..a3062056237 100644
--- a/app/components/UI/Perps/Views/PerpsTabView/PerpsTabView.tsx
+++ b/app/components/UI/Perps/Views/PerpsTabView/PerpsTabView.tsx
@@ -40,8 +40,11 @@ import {
 import { usePerpsLiveOrders } from '../../hooks/stream';
 import { selectSelectedInternalAccountByScope } from '../../../../../selectors/multichainAccounts/accounts';
 import PerpsCard from '../../components/PerpsCard';
-import { PerpsTabViewSelectorsIDs } from '../../../../../../e2e/selectors/Perps/Perps.selectors';
 import styleSheet from './PerpsTabView.styles';
+import {
+  PerpsTabViewSelectorsIDs,
+  PerpsPositionsViewSelectorsIDs,
+} from '../../../../../../e2e/selectors/Perps/Perps.selectors';
 import PerpsBottomSheetTooltip from '../../components/PerpsBottomSheetTooltip';
 import { selectPerpsEligibility } from '../../selectors/perpsController';
 
@@ -220,14 +223,36 @@ const PerpsTabView: React.FC<PerpsTabViewProps> = () => {
     return (
       <>
         <View style={styles.sectionHeader}>
-          <Text variant={TextVariant.BodyMDMedium} style={styles.sectionTitle}>
+          <Text
+            variant={TextVariant.BodyMDMedium}
+            style={styles.sectionTitle}
+            testID={PerpsPositionsViewSelectorsIDs.POSITIONS_SECTION_TITLE}
+          >
             {strings('perps.position.title')}
           </Text>
         </View>
         <View>
-          {positions.map((position, index) => (
-            <PerpsCard key={`${position.coin}-${index}`} position={position} />
-          ))}
+          {positions.map((position, index) => {
+            const sizeValue = parseFloat(position.size);
+            const directionSegment = Number.isFinite(sizeValue)
+              ? sizeValue > 0
+                ? 'long'
+                : sizeValue < 0
+                ? 'short'
+                : 'unknown'
+              : 'unknown';
+            return (
+              <View
+                key={`${position.coin}-${index}`}
+                testID={`${PerpsPositionsViewSelectorsIDs.POSITION_ITEM}-${position.coin}-${position.leverage.value}x-${directionSegment}-${index}`}
+              >
+                <PerpsCard
+                  key={`${position.coin}-${index}`}
+                  position={position}
+                />
+              </View>
+            );
+          })}
           {renderStartTradeCTA()}
         </View>
       </>
diff --git a/app/components/UI/Perps/components/PerpsAmountDisplay/PerpsAmountDisplay.tsx b/app/components/UI/Perps/components/PerpsAmountDisplay/PerpsAmountDisplay.tsx
index 427c67dd2ce..649de1661c1 100644
--- a/app/components/UI/Perps/components/PerpsAmountDisplay/PerpsAmountDisplay.tsx
+++ b/app/components/UI/Perps/components/PerpsAmountDisplay/PerpsAmountDisplay.tsx
@@ -80,6 +80,7 @@ const PerpsAmountDisplay: React.FC<PerpsAmountDisplayProps> = ({
       )}
       <View style={styles.amountRow}>
         <RNText
+          testID={PerpsAmountDisplaySelectorsIDs.AMOUNT_LABEL}
           style={[
             showTokenAmount && tokenAmount && tokenSymbol
               ? styles.amountValueToken
@@ -110,6 +111,7 @@ const PerpsAmountDisplay: React.FC<PerpsAmountDisplayProps> = ({
           variant={TextVariant.BodyMD}
           color={TextColor.Alternative}
           style={styles.maxAmount}
+          testID={PerpsAmountDisplaySelectorsIDs.MAX_LABEL}
         >
           {formatPrice(maxAmount, { minimumDecimals: 2, maximumDecimals: 2 })}{' '}
           {strings('perps.order.max')}
diff --git a/app/components/UI/Perps/components/PerpsMarketRowItem/PerpsMarketRowItem.test.tsx b/app/components/UI/Perps/components/PerpsMarketRowItem/PerpsMarketRowItem.test.tsx
index 9c9f40f56c4..67cbaf4d25b 100644
--- a/app/components/UI/Perps/components/PerpsMarketRowItem/PerpsMarketRowItem.test.tsx
+++ b/app/components/UI/Perps/components/PerpsMarketRowItem/PerpsMarketRowItem.test.tsx
@@ -90,7 +90,7 @@ describe('PerpsMarketRowItem', () => {
       render(<PerpsMarketRowItem market={mockMarketData} />);
 
       const tokenLogo = screen.getByTestId(
-        getPerpsMarketRowItemSelector.rowItem('BTC'),
+        getPerpsMarketRowItemSelector.tokenLogo('BTC'),
       );
       expect(tokenLogo).toBeOnTheScreen();
       expect(tokenLogo.props['data-symbol']).toBe('BTC');
@@ -255,9 +255,15 @@ describe('PerpsMarketRowItem', () => {
       render(<PerpsMarketRowItem market={customMarket} />);
 
       const avatar = screen.getByTestId(
-        getPerpsMarketRowItemSelector.rowItem('ETH'),
+        getPerpsMarketRowItemSelector.tokenLogo('ETH'),
       );
       expect(avatar).toBeOnTheScreen();
+
+      // Also assert the row container keeps its own testID
+      const rowItem = screen.getByTestId(
+        getPerpsMarketRowItemSelector.rowItem('ETH'),
+      );
+      expect(rowItem).toBeOnTheScreen();
     });
   });
 
diff --git a/app/components/UI/Perps/components/PerpsMarketRowItem/PerpsMarketRowItem.tsx b/app/components/UI/Perps/components/PerpsMarketRowItem/PerpsMarketRowItem.tsx
index 200e50ae795..cda14a35cb3 100644
--- a/app/components/UI/Perps/components/PerpsMarketRowItem/PerpsMarketRowItem.tsx
+++ b/app/components/UI/Perps/components/PerpsMarketRowItem/PerpsMarketRowItem.tsx
@@ -95,14 +95,20 @@ const PerpsMarketRowItem = ({ market, onPress }: PerpsMarketRowItemProps) => {
   const isPositiveChange = !displayMarket.change24h.startsWith('-');
 
   return (
-    <TouchableOpacity style={styles.container} onPress={handlePress}>
+    <TouchableOpacity
+      style={styles.container}
+      onPress={handlePress}
+      testID={getPerpsMarketRowItemSelector.rowItem(market.symbol)}
+    >
       <View style={styles.leftSection}>
         <View style={styles.perpIcon}>
           <PerpsTokenLogo
             symbol={displayMarket.symbol}
             size={32}
             recyclingKey={displayMarket.symbol}
-            testID={getPerpsMarketRowItemSelector.rowItem(displayMarket.symbol)}
+            testID={getPerpsMarketRowItemSelector.tokenLogo(
+              displayMarket.symbol,
+            )}
           />
         </View>
 
diff --git a/app/components/UI/Perps/components/PerpsTPSLBottomSheet/PerpsTPSLBottomSheet.tsx b/app/components/UI/Perps/components/PerpsTPSLBottomSheet/PerpsTPSLBottomSheet.tsx
index 3472437ee41..a890691c37c 100644
--- a/app/components/UI/Perps/components/PerpsTPSLBottomSheet/PerpsTPSLBottomSheet.tsx
+++ b/app/components/UI/Perps/components/PerpsTPSLBottomSheet/PerpsTPSLBottomSheet.tsx
@@ -31,6 +31,10 @@ import type { Position } from '../../controllers/types';
 import { usePerpsPerformance } from '../../hooks';
 import { usePerpsLivePrices } from '../../hooks/stream';
 import { usePerpsEventTracking } from '../../hooks/usePerpsEventTracking';
+import {
+  getPerpsTPSLBottomSheetSelector,
+  PerpsTPSLBottomSheetSelectorsIDs,
+} from '../../../../../../e2e/selectors/Perps/Perps.selectors';
 import { usePerpsTPSLForm } from '../../hooks/usePerpsTPSLForm';
 import { usePerpsLiquidationPrice } from '../../hooks/usePerpsLiquidationPrice';
 import { createStyles } from './PerpsTPSLBottomSheet.styles';
@@ -248,6 +252,7 @@ const PerpsTPSLBottomSheet: React.FC<PerpsTPSLBottomSheetProps> = ({
       ref={bottomSheetRef}
       shouldNavigateBack={false}
       onClose={handleClose}
+      testID={PerpsTPSLBottomSheetSelectorsIDs.BOTTOM_SHEET}
     >
       <BottomSheetHeader onClose={handleClose}>
         <Text variant={TextVariant.HeadingMD}>
@@ -329,6 +334,9 @@ const PerpsTPSLBottomSheet: React.FC<PerpsTPSLBottomSheetProps> = ({
                     styles.percentageButtonActiveTP,
                 ]}
                 onPress={() => handleTakeProfitPercentageButton(percentage)}
+                testID={getPerpsTPSLBottomSheetSelector.takeProfitPercentageButton(
+                  percentage,
+                )}
               >
                 <Text
                   variant={TextVariant.BodySM}
@@ -430,6 +438,9 @@ const PerpsTPSLBottomSheet: React.FC<PerpsTPSLBottomSheetProps> = ({
                     styles.percentageButtonActiveSL,
                 ]}
                 onPress={() => handleStopLossPercentageButton(percentage)}
+                testID={getPerpsTPSLBottomSheetSelector.stopLossPercentageButton(
+                  percentage,
+                )}
               >
                 <Text
                   variant={TextVariant.BodySM}
diff --git a/app/components/UI/Perps/components/PerpsTabControlBar/PerpsTabControlBar.tsx b/app/components/UI/Perps/components/PerpsTabControlBar/PerpsTabControlBar.tsx
index 379ad31d621..982995aab8e 100644
--- a/app/components/UI/Perps/components/PerpsTabControlBar/PerpsTabControlBar.tsx
+++ b/app/components/UI/Perps/components/PerpsTabControlBar/PerpsTabControlBar.tsx
@@ -21,6 +21,7 @@ import {
   formatPnl,
   formatPercentage,
 } from '../../utils/formatUtils';
+import { PerpsTabViewSelectorsIDs } from '../../../../../../e2e/selectors/Perps/Perps.selectors';
 import { BigNumber } from 'bignumber.js';
 
 interface PerpsTabControlBarProps {
@@ -151,6 +152,7 @@ export const PerpsTabControlBar: React.FC<PerpsTabControlBarProps> = ({
         <TouchableOpacity
           style={balancePillContainerStyle}
           onPress={handlePress}
+          testID={PerpsTabViewSelectorsIDs.BALANCE_BUTTON}
         >
           <View style={styles.leftSection}>
             <Text
@@ -167,6 +169,7 @@ export const PerpsTabControlBar: React.FC<PerpsTabControlBarProps> = ({
                 style={styles.valueText}
                 variant={TextVariant.HeadingSM}
                 color={TextColor.Default}
+                testID={PerpsTabViewSelectorsIDs.BALANCE_VALUE}
               >
                 {formatPerpsFiat(availableBalance)}
               </Text>
diff --git a/app/components/UI/Perps/components/PerpsTutorialCarousel/PerpsTutorialCarousel.tsx b/app/components/UI/Perps/components/PerpsTutorialCarousel/PerpsTutorialCarousel.tsx
index 75363aea9b4..7ea5b018561 100644
--- a/app/components/UI/Perps/components/PerpsTutorialCarousel/PerpsTutorialCarousel.tsx
+++ b/app/components/UI/Perps/components/PerpsTutorialCarousel/PerpsTutorialCarousel.tsx
@@ -46,6 +46,7 @@ import { selectPerpsEligibility } from '../../selectors/perpsController';
 import { useSelector } from 'react-redux';
 // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires, import/no-commonjs, @typescript-eslint/no-unused-vars
 const PerpsOnboardingAnimation = require('../../animations/perps-onboarding-carousel-v4.riv');
+import { PerpsTutorialSelectorsIDs } from '../../../../../../e2e/selectors/Perps/Perps.selectors';
 
 export enum PERPS_RIVE_ARTBOARD_NAMES {
   INTRO = 'Intro_Perps_v03 2',
@@ -388,10 +389,15 @@ const PerpsTutorialCarousel: React.FC = () => {
             label={buttonLabel}
             onPress={handleContinue}
             size={ButtonSize.Lg}
+            testID={PerpsTutorialSelectorsIDs.CONTINUE_BUTTON}
             style={styles.continueButton}
           />
           <View style={styles.skipButton}>
-            <TouchableOpacity onPress={handleSkip} disabled={!isEligible}>
+            <TouchableOpacity
+              onPress={handleSkip}
+              disabled={!isEligible}
+              testID={PerpsTutorialSelectorsIDs.SKIP_BUTTON}
+            >
               <Text
                 variant={TextVariant.BodyMDMedium}
                 color={TextColor.Alternative}
diff --git a/app/components/UI/Perps/controllers/PerpsController.ts b/app/components/UI/Perps/controllers/PerpsController.ts
index 0d989aa1d79..af8373ab564 100644
--- a/app/components/UI/Perps/controllers/PerpsController.ts
+++ b/app/components/UI/Perps/controllers/PerpsController.ts
@@ -930,7 +930,7 @@ export class PerpsController extends BaseController<
     });
 
     try {
-      DevLogger.log('🚀 PerpsController: STARTING WITHDRAWAL', {
+      DevLogger.log('PerpsController: STARTING WITHDRAWAL', {
         params,
         timestamp: new Date().toISOString(),
         assetId: params.assetId,
@@ -947,7 +947,7 @@ export class PerpsController extends BaseController<
 
       // Get provider (all validation is handled at the provider level)
       const provider = this.getActiveProvider();
-      DevLogger.log('📡 PerpsController: DELEGATING TO PROVIDER', {
+      DevLogger.log('PerpsController: DELEGATING TO PROVIDER', {
         provider: this.state.activeProvider,
         providerReady: !!provider,
       });
@@ -955,7 +955,7 @@ export class PerpsController extends BaseController<
       // Execute withdrawal through provider
       const result = await provider.withdraw(params);
 
-      DevLogger.log('📊 PerpsController: WITHDRAWAL RESULT', {
+      DevLogger.log('PerpsController: WITHDRAWAL RESULT', {
         success: result.success,
         error: result.error,
         txHash: result.txHash,
@@ -975,7 +975,7 @@ export class PerpsController extends BaseController<
           };
         });
 
-        DevLogger.log('✅ PerpsController: WITHDRAWAL SUCCESSFUL', {
+        DevLogger.log('PerpsController: WITHDRAWAL SUCCESSFUL', {
           txHash: result.txHash,
           amount: params.amount,
           assetId: params.assetId,
@@ -1017,7 +1017,7 @@ export class PerpsController extends BaseController<
         };
       });
 
-      DevLogger.log('❌ PerpsController: WITHDRAWAL FAILED', {
+      DevLogger.log('PerpsController: WITHDRAWAL FAILED', {
         error: result.error,
         params,
       });
@@ -1037,7 +1037,7 @@ export class PerpsController extends BaseController<
           ? error.message
           : PERPS_ERROR_CODES.WITHDRAW_FAILED;
 
-      DevLogger.log('💥 PerpsController: WITHDRAWAL EXCEPTION', {
+      DevLogger.log('PerpsController: WITHDRAWAL EXCEPTION', {
         error: errorMessage,
         errorType:
           error instanceof Error ? error.constructor.name : typeof error,
diff --git a/app/components/UI/Perps/controllers/providers/HyperLiquidProvider.ts b/app/components/UI/Perps/controllers/providers/HyperLiquidProvider.ts
index d6a728bed9f..6270d0a68f4 100644
--- a/app/components/UI/Perps/controllers/providers/HyperLiquidProvider.ts
+++ b/app/components/UI/Perps/controllers/providers/HyperLiquidProvider.ts
@@ -1639,7 +1639,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
    */
   async withdraw(params: WithdrawParams): Promise<WithdrawResult> {
     try {
-      DevLogger.log('🚀 HyperLiquidProvider: STARTING WITHDRAWAL', {
+      DevLogger.log('HyperLiquidProvider: STARTING WITHDRAWAL', {
         params,
         timestamp: new Date().toISOString(),
         assetId: params.assetId,
@@ -1649,7 +1649,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
       });
 
       // Step 1: Validate withdrawal parameters
-      DevLogger.log('🔍 HyperLiquidProvider: VALIDATING PARAMETERS');
+      DevLogger.log('HyperLiquidProvider: VALIDATING PARAMETERS');
       const validation = validateWithdrawalParams(params);
       if (!validation.isValid) {
         DevLogger.log('❌ HyperLiquidProvider: PARAMETER VALIDATION FAILED', {
@@ -1659,12 +1659,12 @@ export class HyperLiquidProvider implements IPerpsProvider {
         });
         throw new Error(validation.error);
       }
-      DevLogger.log('✅ HyperLiquidProvider: PARAMETERS VALIDATED');
+      DevLogger.log('HyperLiquidProvider: PARAMETERS VALIDATED');
 
       // Step 2: Get supported withdrawal routes and validate asset
-      DevLogger.log('🔍 HyperLiquidProvider: CHECKING ASSET SUPPORT');
+      DevLogger.log('HyperLiquidProvider: CHECKING ASSET SUPPORT');
       const supportedRoutes = this.getWithdrawalRoutes();
-      DevLogger.log('📋 HyperLiquidProvider: SUPPORTED WITHDRAWAL ROUTES', {
+      DevLogger.log('HyperLiquidProvider: SUPPORTED WITHDRAWAL ROUTES', {
         routeCount: supportedRoutes.length,
         routes: supportedRoutes.map((route) => ({
           assetId: route.assetId,
@@ -1678,7 +1678,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
         const error = strings(
           'perps.errors.withdrawValidation.assetIdRequired',
         );
-        DevLogger.log('❌ HyperLiquidProvider: MISSING ASSET ID', {
+        DevLogger.log('HyperLiquidProvider: MISSING ASSET ID', {
           error,
           params,
         });
@@ -1697,36 +1697,36 @@ export class HyperLiquidProvider implements IPerpsProvider {
         });
         throw new Error(assetValidation.error);
       }
-      DevLogger.log('✅ HyperLiquidProvider: ASSET SUPPORTED', {
+      DevLogger.log('HyperLiquidProvider: ASSET SUPPORTED', {
         assetId: params.assetId,
       });
 
       // Step 3: Determine destination address
-      DevLogger.log('🔍 HyperLiquidProvider: DETERMINING DESTINATION ADDRESS');
+      DevLogger.log('HyperLiquidProvider: DETERMINING DESTINATION ADDRESS');
       let destination: Hex;
       if (params.destination) {
         destination = params.destination;
-        DevLogger.log('📍 HyperLiquidProvider: USING PROVIDED DESTINATION', {
+        DevLogger.log('HyperLiquidProvider: USING PROVIDED DESTINATION', {
           destination,
         });
       } else {
         destination = await this.walletService.getUserAddressWithDefault();
-        DevLogger.log('📍 HyperLiquidProvider: USING USER WALLET ADDRESS', {
+        DevLogger.log('HyperLiquidProvider: USING USER WALLET ADDRESS', {
           destination,
         });
       }
 
       // Step 4: Ensure client is ready
-      DevLogger.log('🔌 HyperLiquidProvider: ENSURING CLIENT READY');
+      DevLogger.log('HyperLiquidProvider: ENSURING CLIENT READY');
       await this.ensureReady();
       const exchangeClient = this.clientService.getExchangeClient();
-      DevLogger.log('✅ HyperLiquidProvider: CLIENT READY');
+      DevLogger.log('HyperLiquidProvider: CLIENT READY');
 
       // Step 5: Validate amount against account balance
-      DevLogger.log('🔍 HyperLiquidProvider: CHECKING ACCOUNT BALANCE');
+      DevLogger.log('HyperLiquidProvider: CHECKING ACCOUNT BALANCE');
       const accountState = await this.getAccountState();
       const availableBalance = parseFloat(accountState.availableBalance);
-      DevLogger.log('💰 HyperLiquidProvider: ACCOUNT BALANCE', {
+      DevLogger.log('HyperLiquidProvider: ACCOUNT BALANCE', {
         availableBalance,
         totalBalance: accountState.totalBalance,
         marginUsed: accountState.marginUsed,
@@ -1736,7 +1736,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
       // This check is already done in validateWithdrawalParams, but TypeScript needs explicit check
       if (!params.amount) {
         const error = strings('perps.errors.withdrawValidation.amountRequired');
-        DevLogger.log('❌ HyperLiquidProvider: MISSING AMOUNT', {
+        DevLogger.log('HyperLiquidProvider: MISSING AMOUNT', {
           error,
           params,
         });
@@ -1744,7 +1744,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
       }
 
       const withdrawAmount = parseFloat(params.amount);
-      DevLogger.log('🔢 HyperLiquidProvider: WITHDRAWAL AMOUNT', {
+      DevLogger.log('HyperLiquidProvider: WITHDRAWAL AMOUNT', {
         requestedAmount: withdrawAmount,
         availableBalance,
         sufficientBalance: withdrawAmount <= availableBalance,
@@ -1755,7 +1755,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
         availableBalance,
       );
       if (!balanceValidation.isValid) {
-        DevLogger.log('❌ HyperLiquidProvider: INSUFFICIENT BALANCE', {
+        DevLogger.log('HyperLiquidProvider: INSUFFICIENT BALANCE', {
           error: balanceValidation.error,
           requestedAmount: withdrawAmount,
           availableBalance,
@@ -1766,7 +1766,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
       DevLogger.log('✅ HyperLiquidProvider: BALANCE SUFFICIENT');
 
       // Step 6: Execute withdrawal via HyperLiquid SDK (API call)
-      DevLogger.log('📡 HyperLiquidProvider: CALLING WITHDRAW3 API', {
+      DevLogger.log('HyperLiquidProvider: CALLING WITHDRAW3 API', {
         destination,
         amount: params.amount,
         endpoint: 'withdraw3',
@@ -1778,7 +1778,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
         amount: params.amount,
       });
 
-      DevLogger.log('📊 HyperLiquidProvider: WITHDRAW3 API RESPONSE', {
+      DevLogger.log('HyperLiquidProvider: WITHDRAW3 API RESPONSE', {
         status: result.status,
         response: result,
         timestamp: new Date().toISOString(),
@@ -1786,7 +1786,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
 
       if (result.status === 'ok') {
         DevLogger.log(
-          '✅ HyperLiquidProvider: WITHDRAWAL SUBMITTED SUCCESSFULLY',
+          'HyperLiquidProvider: WITHDRAWAL SUBMITTED SUCCESSFULLY',
           {
             destination,
             amount: params.amount,
@@ -1808,7 +1808,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
       }
 
       const errorMessage = `Withdrawal failed: ${result.status}`;
-      DevLogger.log('❌ HyperLiquidProvider: WITHDRAWAL FAILED', {
+      DevLogger.log('HyperLiquidProvider: WITHDRAWAL FAILED', {
         error: errorMessage,
         status: result.status,
         response: result,
@@ -1821,7 +1821,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
     } catch (error) {
       const errorMessage =
         error instanceof Error ? error.message : 'Unknown error';
-      DevLogger.log('💥 HyperLiquidProvider: WITHDRAWAL EXCEPTION', {
+      DevLogger.log('HyperLiquidProvider: WITHDRAWAL EXCEPTION', {
         error: errorMessage,
         errorType:
           error instanceof Error ? error.constructor.name : typeof error,
@@ -2138,7 +2138,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
     let feeRate =
       orderType === 'market' || !isMaker ? FEE_RATES.taker : FEE_RATES.maker;
 
-    DevLogger.log('🔍 HyperLiquid Fee Calculation Started', {
+    DevLogger.log('HyperLiquid Fee Calculation Started', {
       orderType,
       isMaker,
       amount,
@@ -2151,7 +2151,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
     try {
       const userAddress = await this.walletService.getUserAddressWithDefault();
 
-      DevLogger.log('👤 User Address Retrieved', {
+      DevLogger.log('User Address Retrieved', {
         userAddress,
         network: this.clientService.isTestnetMode() ? 'testnet' : 'mainnet',
       });
@@ -2178,7 +2178,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
           });
         }
       } else {
-        DevLogger.log('🌐 Fetching Fresh Fee Rates from HyperLiquid API', {
+        DevLogger.log('Fetching Fresh Fee Rates from HyperLiquid API', {
           cacheHit: false,
           userAddress,
         });
@@ -2190,7 +2190,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
           user: userAddress as `0x${string}`,
         });
 
-        DevLogger.log('📡 HyperLiquid userFees API Response', {
+        DevLogger.log('HyperLiquid userFees API Response', {
           userCrossRate: userFees.userCrossRate,
           userAddRate: userFees.userAddRate,
           activeReferralDiscount: userFees.activeReferralDiscount,
@@ -2220,7 +2220,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
         const spotTakerRate = baseUserSpotTakerRate * (1 - totalDiscount);
         const spotMakerRate = baseUserSpotMakerRate * (1 - totalDiscount);
 
-        DevLogger.log('🔢 Fee Discount Calculation', {
+        DevLogger.log('Fee Discount Calculation', {
           discounts: {
             referral: `${(referralDiscount * 100).toFixed(1)}%`,
             staking: `${(stakingDiscount * 100).toFixed(1)}%`,
@@ -2249,7 +2249,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
           spotTakerRate < 0 ||
           spotMakerRate < 0
         ) {
-          DevLogger.log('❌ Fee Rate Validation Failed', {
+          DevLogger.log('Fee Rate Validation Failed', {
             validation: {
               perpsTakerValid: !isNaN(perpsTakerRate) && perpsTakerRate >= 0,
               perpsMakerValid: !isNaN(perpsMakerRate) && perpsMakerRate >= 0,
@@ -2282,7 +2282,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
             ? rates.perpsTakerRate
             : rates.perpsMakerRate;
 
-        DevLogger.log('✅ Fee Rates Validated and Cached', {
+        DevLogger.log('Fee Rates Validated and Cached', {
           selectedRate: feeRate,
           selectedRatePercentage: `${(feeRate * 100).toFixed(4)}%`,
           discountApplied: perpsTakerRate < FEE_RATES.taker,
@@ -2291,7 +2291,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
       }
     } catch (error) {
       // Silently fall back to base rates
-      DevLogger.log('⚠️ Fee API Call Failed - Falling Back to Base Rates', {
+      DevLogger.log('Fee API Call Failed - Falling Back to Base Rates', {
         error: error instanceof Error ? error.message : String(error),
         errorType:
           error instanceof Error ? error.constructor.name : typeof error,
@@ -2344,7 +2344,7 @@ export class HyperLiquidProvider implements IPerpsProvider {
       metamaskFeeAmount,
     };
 
-    DevLogger.log('💰 Final Fee Calculation Result', {
+    DevLogger.log('Final Fee Calculation Result', {
       orderType,
       amount,
       fees: {
@@ -2378,10 +2378,10 @@ export class HyperLiquidProvider implements IPerpsProvider {
   public clearFeeCache(userAddress?: string): void {
     if (userAddress) {
       this.userFeeCache.delete(userAddress);
-      DevLogger.log('🗑️ Cleared fee cache for user', { userAddress });
+      DevLogger.log('Cleared fee cache for user', { userAddress });
     } else {
       this.userFeeCache.clear();
-      DevLogger.log('🗑️ Cleared all fee cache');
+      DevLogger.log('Cleared all fee cache');
     }
   }
 
diff --git a/app/components/UI/Perps/hooks/usePerpsPerformance.ts b/app/components/UI/Perps/hooks/usePerpsPerformance.ts
index d09255f8fef..b45fe37ff4c 100644
--- a/app/components/UI/Perps/hooks/usePerpsPerformance.ts
+++ b/app/components/UI/Perps/hooks/usePerpsPerformance.ts
@@ -22,7 +22,7 @@ const validatePerformance = (
     const percentOver = ((duration - target) / target) * 100;
     const priority = PerpsMetricPriorities[name] || 'MEDIUM';
 
-    DevLogger.log('⚠️ Performance target exceeded', {
+    DevLogger.log('Performance target exceeded', {
       metric: name,
       duration: `${duration.toFixed(0)}ms`,
       target: `${target}ms`,
diff --git a/app/components/UI/Perps/providers/PerpsConnectionProvider.tsx b/app/components/UI/Perps/providers/PerpsConnectionProvider.tsx
index 3c25e2400c6..25c575f3c14 100644
--- a/app/components/UI/Perps/providers/PerpsConnectionProvider.tsx
+++ b/app/components/UI/Perps/providers/PerpsConnectionProvider.tsx
@@ -13,6 +13,7 @@ import PerpsLoadingSkeleton from '../components/PerpsLoadingSkeleton';
 import { usePerpsDepositStatus } from '../hooks/usePerpsDepositStatus';
 import { usePerpsWithdrawStatus } from '../hooks/usePerpsWithdrawStatus';
 import { usePerpsConnectionLifecycle } from '../hooks/usePerpsConnectionLifecycle';
+import { isE2E } from '../../../../util/test/utils';
 import PerpsConnectionErrorView from '../components/PerpsConnectionErrorView';
 
 interface PerpsConnectionContextValue {
@@ -58,6 +59,19 @@ export const PerpsConnectionProvider: React.FC<
 
   // Poll connection state to sync with singleton
   useEffect(() => {
+    // Skip polling in E2E mode to prevent timer interference
+    if (isE2E) {
+      // Set mock connected state for E2E
+      setConnectionState({
+        isConnected: true,
+        isConnecting: false,
+        isInitialized: true,
+        isDisconnecting: false,
+        error: null,
+      });
+      return;
+    }
+
     const updateState = () => {
       const state = PerpsConnectionManager.getConnectionState();
       setConnectionState((prevState) => {
diff --git a/app/components/UI/Perps/providers/PerpsStreamManager.tsx b/app/components/UI/Perps/providers/PerpsStreamManager.tsx
index b610821b517..72bcf567061 100644
--- a/app/components/UI/Perps/providers/PerpsStreamManager.tsx
+++ b/app/components/UI/Perps/providers/PerpsStreamManager.tsx
@@ -10,6 +10,7 @@ import type {
   PerpsMarketData,
 } from '../controllers/types';
 import { PERFORMANCE_CONFIG } from '../constants/perpsConfig';
+import { getE2EMockStreamManager } from '../utils/e2eBridgePerps';
 
 // Generic subscription parameters
 interface StreamSubscription<T> {
@@ -737,11 +738,26 @@ const PerpsStreamContext = createContext<PerpsStreamManager | null>(null);
 export const PerpsStreamProvider: React.FC<{
   children: React.ReactNode;
   testStreamManager?: PerpsStreamManager; // Only for testing
-}> = ({ children, testStreamManager }) => (
-  <PerpsStreamContext.Provider value={testStreamManager || streamManager}>
-    {children}
-  </PerpsStreamContext.Provider>
-);
+}> = ({ children, testStreamManager }) => {
+  // Check for E2E mock stream manager
+  const e2eMockStreamManager =
+    getE2EMockStreamManager() as PerpsStreamManager | null;
+
+  const selectedManager: PerpsStreamManager =
+    testStreamManager || e2eMockStreamManager || streamManager;
+
+  DevLogger.log('PerpsStreamProvider: Using stream manager:', {
+    isTestManager: !!testStreamManager,
+    isE2EMockManager: !!e2eMockStreamManager,
+    isRealManager: selectedManager === streamManager,
+  });
+
+  return (
+    <PerpsStreamContext.Provider value={selectedManager}>
+      {children}
+    </PerpsStreamContext.Provider>
+  );
+};
 
 export const usePerpsStream = () => {
   const context = useContext(PerpsStreamContext);
diff --git a/app/components/UI/Perps/services/HyperLiquidSubscriptionService.ts b/app/components/UI/Perps/services/HyperLiquidSubscriptionService.ts
index 0ce2d43dd88..8251cc1cbfd 100644
--- a/app/components/UI/Perps/services/HyperLiquidSubscriptionService.ts
+++ b/app/components/UI/Perps/services/HyperLiquidSubscriptionService.ts
@@ -198,7 +198,7 @@ export class HyperLiquidSubscriptionService {
             }
           });
 
-          DevLogger.log('🔍 Cached funding rates from initial market data:', {
+          DevLogger.log('Cached funding rates from initial market data:', {
             cachedCount: perpsMeta.universe.filter((_asset, index) => {
               const assetCtx = assetCtxs[1][index];
               return assetCtx && 'funding' in assetCtx;
diff --git a/app/components/UI/Perps/utils/e2eBridgePerps.ts b/app/components/UI/Perps/utils/e2eBridgePerps.ts
new file mode 100644
index 00000000000..b19b6c20a90
--- /dev/null
+++ b/app/components/UI/Perps/utils/e2eBridgePerps.ts
@@ -0,0 +1,121 @@
+/**
+ * E2E Bridge - Dynamic Mock Injection
+ *
+ * This bridge allows production code to conditionally use E2E mocks
+ * without direct dependencies on E2E files. The bridge automatically
+ * configures itself when the isE2E flag is detected.
+ */
+
+import DevLogger from '../../../../core/SDKConnect/utils/DevLogger';
+import { isE2E } from '../../../../util/test/utils';
+
+// Global bridge for E2E mock injection
+export interface E2EBridgePerpsStreaming {
+  mockStreamManager?: unknown;
+  applyControllerMocks?: (controller: unknown) => void;
+}
+
+// Global bridge instance
+let e2eBridgePerps: E2EBridgePerpsStreaming = {};
+
+/**
+ * Auto-configure E2E bridge when isE2E is true
+ */
+function autoConfigureE2EBridge(): void {
+  if (!isE2E || e2eBridgePerps.mockStreamManager) {
+    return; // Already configured or not in E2E mode
+  }
+
+  try {
+    // Dynamically import E2E modules to avoid build-time dependencies
+    // This will only work in E2E environment where these files exist
+
+    // Try to require the modules directly - if they don't exist, this will throw
+    /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires */
+    const {
+      PerpsE2EMockService,
+    } = require('../../../../../e2e/api-mocking/mock-responses/perps-e2e-mocks');
+    const {
+      applyE2EPerpsControllerMocks,
+      createE2EMockStreamManager,
+    } = require('../../../../../e2e/api-mocking/mock-config/perps-controller-mixin');
+    /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires */
+
+    // Initialize mock service
+    const mockService = PerpsE2EMockService.getInstance();
+    mockService.reset();
+
+    // Create mock stream manager
+    const mockStreamManager = createE2EMockStreamManager();
+
+    // Configure bridge
+    e2eBridgePerps = {
+      mockStreamManager,
+      applyControllerMocks: applyE2EPerpsControllerMocks,
+    };
+
+    DevLogger.log('E2E Bridge auto-configured successfully');
+    DevLogger.log('Mock state:', {
+      accountBalance: mockService.getMockAccountState().availableBalance,
+      positionsCount: mockService.getMockPositions().length,
+      marketsCount: mockService.getMockMarkets().length,
+    });
+    DevLogger.log(
+      'Mock markets:',
+      mockService
+        .getMockMarkets()
+        .map(
+          (m: { symbol: string; volume: string }) => `${m.symbol}: ${m.volume}`,
+        ),
+    );
+  } catch (error) {
+    // This is expected in production builds where E2E files don't exist
+    // or when running in environments that don't have the e2e directory
+    DevLogger.log(
+      'E2E files not found (expected in production) - skipping mock setup',
+    );
+  }
+}
+
+/**
+ * Set E2E bridge from external test setup (legacy support)
+ */
+export function setE2EBridge(bridge: E2EBridgePerpsStreaming): void {
+  if (isE2E) {
+    e2eBridgePerps = bridge;
+    DevLogger.log('E2E Bridge manually configured:', Object.keys(bridge));
+  }
+}
+
+/**
+ * Get mock stream manager if available
+ */
+export function getE2EMockStreamManager(): unknown {
+  if (isE2E) {
+    autoConfigureE2EBridge();
+    DevLogger.log(
+      'E2E Bridge: Returning mock stream manager:',
+      !!e2eBridgePerps.mockStreamManager,
+    );
+    return e2eBridgePerps.mockStreamManager;
+  }
+  return null;
+}
+
+/**
+ * Apply controller mocks if available
+ */
+export function applyE2EControllerMocks(controller: unknown): void {
+  if (isE2E) {
+    autoConfigureE2EBridge();
+    if (e2eBridgePerps.applyControllerMocks) {
+      e2eBridgePerps.applyControllerMocks(controller);
+    }
+  }
+}
+
+export default {
+  setE2EBridge,
+  getE2EMockStreamManager,
+  applyE2EControllerMocks,
+};
diff --git a/app/components/UI/Perps/utils/hyperLiquidValidation.ts b/app/components/UI/Perps/utils/hyperLiquidValidation.ts
index d67fbc4194b..a5175f7bc41 100644
--- a/app/components/UI/Perps/utils/hyperLiquidValidation.ts
+++ b/app/components/UI/Perps/utils/hyperLiquidValidation.ts
@@ -36,7 +36,7 @@ export function validateWithdrawalParams(params: {
   amount?: string;
   destination?: Hex;
 }): { isValid: boolean; error?: string } {
-  DevLogger.log('🔍 validateWithdrawalParams: Starting validation', {
+  DevLogger.log('validateWithdrawalParams: Starting validation', {
     params,
     hasAssetId: !!params.assetId,
     hasAmount: !!params.amount,
@@ -46,7 +46,7 @@ export function validateWithdrawalParams(params: {
   // Validate required parameters
   if (!params.assetId) {
     const error = strings('perps.errors.withdrawValidation.assetIdRequired');
-    DevLogger.log('❌ validateWithdrawalParams: Missing assetId', {
+    DevLogger.log('validateWithdrawalParams: Missing assetId', {
       error,
       params,
     });
@@ -59,7 +59,7 @@ export function validateWithdrawalParams(params: {
   // Validate amount
   if (!params.amount) {
     const error = strings('perps.errors.withdrawValidation.amountRequired');
-    DevLogger.log('❌ validateWithdrawalParams: Missing amount', {
+    DevLogger.log('validateWithdrawalParams: Missing amount', {
       error,
       params,
     });
@@ -72,7 +72,7 @@ export function validateWithdrawalParams(params: {
   const amount = parseFloat(params.amount);
   if (isNaN(amount) || amount <= 0) {
     const error = strings('perps.errors.withdrawValidation.amountPositive');
-    DevLogger.log('❌ validateWithdrawalParams: Invalid amount', {
+    DevLogger.log('validateWithdrawalParams: Invalid amount', {
       error,
       amount: params.amount,
       parsedAmount: amount,
@@ -92,7 +92,7 @@ export function validateWithdrawalParams(params: {
         address: params.destination,
       },
     );
-    DevLogger.log('❌ validateWithdrawalParams: Invalid destination address', {
+    DevLogger.log('validateWithdrawalParams: Invalid destination address', {
       error,
       destination: params.destination,
       isValidHex: isValidHexAddress(params.destination),
@@ -103,7 +103,7 @@ export function validateWithdrawalParams(params: {
     };
   }
 
-  DevLogger.log('✅ validateWithdrawalParams: All validations passed', {
+  DevLogger.log('validateWithdrawalParams: All validations passed', {
     assetId: params.assetId,
     amount: params.amount,
     destination: params.destination || 'will use user wallet',
@@ -120,7 +120,7 @@ export function validateDepositParams(params: {
   amount?: string;
   isTestnet?: boolean;
 }): { isValid: boolean; error?: string } {
-  DevLogger.log('🔍 validateDepositParams: Starting validation', {
+  DevLogger.log('validateDepositParams: Starting validation', {
     params,
     hasAssetId: !!params.assetId,
     hasAmount: !!params.amount,
@@ -130,7 +130,7 @@ export function validateDepositParams(params: {
   // Validate required parameters
   if (!params.assetId) {
     const error = strings('perps.errors.depositValidation.assetIdRequired');
-    DevLogger.log('❌ validateDepositParams: Missing assetId', {
+    DevLogger.log('validateDepositParams: Missing assetId', {
       error,
       params,
     });
@@ -143,7 +143,7 @@ export function validateDepositParams(params: {
   // Validate amount
   if (!params.amount) {
     const error = strings('perps.errors.depositValidation.amountRequired');
-    DevLogger.log('❌ validateDepositParams: Missing amount', {
+    DevLogger.log('validateDepositParams: Missing amount', {
       error,
       params,
     });
@@ -156,7 +156,7 @@ export function validateDepositParams(params: {
   const amount = parseFloat(params.amount);
   if (isNaN(amount) || amount <= 0) {
     const error = strings('perps.errors.depositValidation.amountPositive');
-    DevLogger.log('❌ validateDepositParams: Invalid amount', {
+    DevLogger.log('validateDepositParams: Invalid amount', {
       error,
       amount: params.amount,
       parsedAmount: amount,
@@ -173,7 +173,7 @@ export function validateDepositParams(params: {
     ? TRADING_DEFAULTS.amount.testnet
     : TRADING_DEFAULTS.amount.mainnet;
 
-  DevLogger.log('🔍 validateDepositParams: Checking minimum amount', {
+  DevLogger.log('validateDepositParams: Checking minimum amount', {
     amount,
     minimumAmount,
     isTestnet: params.isTestnet,
@@ -184,7 +184,7 @@ export function validateDepositParams(params: {
     const error = strings('perps.errors.minimumDeposit', {
       amount: minimumAmount,
     });
-    DevLogger.log('❌ validateDepositParams: Below minimum deposit', {
+    DevLogger.log('validateDepositParams: Below minimum deposit', {
       error,
       amount,
       minimumAmount,
@@ -196,7 +196,7 @@ export function validateDepositParams(params: {
     };
   }
 
-  DevLogger.log('✅ validateDepositParams: All validations passed', {
+  DevLogger.log('validateDepositParams: All validations passed', {
     assetId: params.assetId,
     amount: params.amount,
     parsedAmount: amount,
@@ -214,7 +214,7 @@ export function validateAssetSupport(
   assetId: CaipAssetId,
   supportedRoutes: { assetId: CaipAssetId }[],
 ): { isValid: boolean; error?: string } {
-  DevLogger.log('🔍 validateAssetSupport: Checking asset support', {
+  DevLogger.log('validateAssetSupport: Checking asset support', {
     assetId,
     supportedRoutesCount: supportedRoutes.length,
   });
@@ -248,7 +248,7 @@ export function validateAssetSupport(
         },
       );
 
-      DevLogger.log('❌ validateAssetSupport: Asset not supported', {
+      DevLogger.log('validateAssetSupport: Asset not supported', {
         error,
         assetId,
         supportedAssetIds,
@@ -272,7 +272,7 @@ export function validateAssetSupport(
     );
   }
 
-  DevLogger.log('✅ validateAssetSupport: Asset is supported', {
+  DevLogger.log('validateAssetSupport: Asset is supported', {
     assetId,
   });
 
@@ -286,7 +286,7 @@ export function validateBalance(
   withdrawAmount: number,
   availableBalance: number,
 ): { isValid: boolean; error?: string } {
-  DevLogger.log('🔍 validateBalance: Checking balance sufficiency', {
+  DevLogger.log('validateBalance: Checking balance sufficiency', {
     withdrawAmount,
     availableBalance,
     difference: availableBalance - withdrawAmount,
@@ -302,7 +302,7 @@ export function validateBalance(
       },
     );
 
-    DevLogger.log('❌ validateBalance: Insufficient balance', {
+    DevLogger.log('validateBalance: Insufficient balance', {
       error,
       withdrawAmount,
       availableBalance,
@@ -320,7 +320,7 @@ export function validateBalance(
   }
 
   const remainingBalance = availableBalance - withdrawAmount;
-  DevLogger.log('✅ validateBalance: Balance is sufficient', {
+  DevLogger.log('validateBalance: Balance is sufficient', {
     withdrawAmount,
     availableBalance,
     remainingBalance,
diff --git a/app/components/Views/AccountActions/AccountActions.test.tsx b/app/components/Views/AccountActions/AccountActions.test.tsx
index 895c71aa7de..3581e36ba50 100644
--- a/app/components/Views/AccountActions/AccountActions.test.tsx
+++ b/app/components/Views/AccountActions/AccountActions.test.tsx
@@ -51,32 +51,36 @@ jest.mock('../../../reducers/swaps', () => ({
   swapsControllerAndUserTokensMultichain: jest.fn(() => ({})),
 }));
 
-jest.mock('../../../selectors/networkController', () => ({
-  selectProviderConfig: jest.fn(() => ({
-    type: 'rpc',
-    rpcUrl: 'https://custom-rpc.com',
-    chainId: '0x1',
-    ticker: 'ETH',
-    nickname: 'Custom Network',
-  })),
-  selectNetworkConfigurations: jest.fn(() => ({
-    'custom-network-id': {
+jest.mock('../../../selectors/networkController', () => {
+  const actual = jest.requireActual('../../../selectors/networkController');
+  return {
+    ...actual,
+    selectProviderConfig: jest.fn(() => ({
+      type: 'rpc',
       rpcUrl: 'https://custom-rpc.com',
       chainId: '0x1',
       ticker: 'ETH',
-      blockExplorerUrl: 'https://custom-explorer.com',
-    },
-  })),
-  selectChainId: jest.fn(() => '0x1'),
-  selectEvmChainId: jest.fn(() => 1),
-  selectSelectedInternalAccountAddress: jest.fn(
-    () => '0xC4966c0D659D99699BFD7EB54D8fafEE40e4a756',
-  ),
-  selectSelectedNetworkClientId: jest.fn(() => 'mainnet'),
-  selectNetworkClientId: jest.fn(() => 'mainnet'),
-  selectEvmNetworkConfigurationsByChainId: jest.fn(() => ({})),
-  selectRpcUrl: jest.fn(() => 'https://mainnet.infura.io/v3/123'),
-}));
+      nickname: 'Custom Network',
+    })),
+    selectNetworkConfigurations: jest.fn(() => ({
+      'custom-network-id': {
+        rpcUrl: 'https://custom-rpc.com',
+        chainId: '0x1',
+        ticker: 'ETH',
+        blockExplorerUrl: 'https://custom-explorer.com',
+      },
+    })),
+    selectChainId: jest.fn(() => '0x1'),
+    selectEvmChainId: jest.fn(() => 1),
+    selectSelectedInternalAccountAddress: jest.fn(
+      () => '0xC4966c0D659D99699BFD7EB54D8fafEE40e4a756',
+    ),
+    selectSelectedNetworkClientId: jest.fn(() => 'mainnet'),
+    selectNetworkClientId: jest.fn(() => 'mainnet'),
+    selectEvmNetworkConfigurationsByChainId: jest.fn(() => ({})),
+    selectRpcUrl: jest.fn(() => 'https://mainnet.infura.io/v3/123'),
+  };
+});
 
 // Import the mocked selectors
 import {
diff --git a/app/components/Views/AccountBackupStep1B/index.js b/app/components/Views/AccountBackupStep1B/index.js
index 44d9daa8d9e..c236351e532 100644
--- a/app/components/Views/AccountBackupStep1B/index.js
+++ b/app/components/Views/AccountBackupStep1B/index.js
@@ -1,5 +1,5 @@
 import React, { useState, useEffect, useCallback } from 'react';
-import { connect } from 'react-redux';
+import { connect, useSelector } from 'react-redux';
 import {
   ScrollView,
   TouchableOpacity,
@@ -29,6 +29,7 @@ import { ManualBackUpStepsSelectorsIDs } from '../../../../e2e/selectors/Onboard
 import trackOnboarding from '../../../util/metrics/TrackOnboarding/trackOnboarding';
 import { MetricsEventBuilder } from '../../../core/Analytics/MetricsEventBuilder';
 import Routes from '../../../constants/navigation/Routes';
+import { selectSeedlessOnboardingLoginFlow } from '../../../selectors/seedlessOnboardingController';
 
 const explain_backup_seedphrase = require('../../../images/explain-backup-seedphrase.png'); // eslint-disable-line
 
@@ -207,6 +208,9 @@ const AccountBackupStep1B = (props) => {
   const [showWhySecureWalletModal, setWhySecureWalletModal] = useState(false);
   const { colors } = useTheme();
   const styles = createStyles(colors);
+  const isSeedlessOnboardingLoginFlow = useSelector(
+    selectSeedlessOnboardingLoginFlow,
+  );
 
   const headerLeft = useCallback(() => <View />, []);
   const track = (event, properties) => {
@@ -353,7 +357,9 @@ const AccountBackupStep1B = (props) => {
       </ScrollView>
       {Device.isAndroid() && <AndroidBackHandler customBackPress={dismiss} />}
       <ActionModal
-        modalVisible={showWhySecureWalletModal}
+        modalVisible={
+          showWhySecureWalletModal && !isSeedlessOnboardingLoginFlow
+        }
         actionContainerStyle={styles.modalNoBorder}
         displayConfirmButton={false}
         displayCancelButton={false}
diff --git a/app/components/Views/AccountBackupStep1B/index.test.tsx b/app/components/Views/AccountBackupStep1B/index.test.tsx
index 9f7d9520518..c71dd570f75 100644
--- a/app/components/Views/AccountBackupStep1B/index.test.tsx
+++ b/app/components/Views/AccountBackupStep1B/index.test.tsx
@@ -72,6 +72,17 @@ describe('AccountBackupStep1B', () => {
         }}
         route={{}}
       />,
+      {
+        state: {
+          engine: {
+            backgroundState: {
+              SeedlessOnboardingController: {
+                vault: 'encrypted-vault-data',
+              },
+            },
+          },
+        },
+      },
     );
 
     return {
diff --git a/app/components/Views/AddAsset/AddAsset.test.tsx b/app/components/Views/AddAsset/AddAsset.test.tsx
index 5b7977dd2c2..2903a6e2bdb 100644
--- a/app/components/Views/AddAsset/AddAsset.test.tsx
+++ b/app/components/Views/AddAsset/AddAsset.test.tsx
@@ -279,6 +279,350 @@ describe('AddAsset component', () => {
       });
     });
   });
+
+  describe('Navigation interactions', () => {
+    it('renders banner with action button for collectibles when displayNftMedia is false', () => {
+      mockUseParamsValues.assetType = 'collectible';
+
+      // Render with displayNftMedia false to show the action button
+      const { getAllByRole } = renderWithProvider(<AddAsset />, {
+        state: {
+          ...initialState,
+          engine: {
+            ...initialState.engine,
+            backgroundState: {
+              ...initialState.engine.backgroundState,
+              PreferencesController: {
+                ...initialState.engine.backgroundState.PreferencesController,
+                displayNftMedia: false,
+              },
+            },
+          },
+        },
+      });
+
+      // Verify that action buttons exist - this shows the banner with action button is rendered
+      const buttons = getAllByRole('button');
+      expect(buttons.length).toBeGreaterThan(0);
+    });
+
+    it('calls setOptions with correct navbar options for token view', () => {
+      mockUseParamsValues.assetType = 'token';
+      renderComponent(<AddAsset />);
+
+      // The component should call setOptions during useEffect
+      expect(mockSetOptions).toHaveBeenCalled();
+    });
+
+    it('calls setOptions with correct navbar options for collectible view', () => {
+      mockUseParamsValues.assetType = 'collectible';
+      renderComponent(<AddAsset />);
+
+      // The component should call setOptions during useEffect
+      expect(mockSetOptions).toHaveBeenCalled();
+    });
+  });
+
+  describe('State management', () => {
+    it('opens and closes network filter bottom sheet', () => {
+      mockUseParamsValues.assetType = 'token';
+      mockUseNetworksByNamespace.mockReturnValue({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        networks: [{ name: 'Ethereum' } as any],
+        selectedNetworks: [],
+        areAllNetworksSelected: false,
+        areAnyNetworksSelected: false,
+        networkCount: 1,
+        selectedCount: 0,
+      });
+
+      const { getByTestId, queryByText } = renderComponent(<AddAsset />);
+
+      // Initially, network filter should not be visible
+      expect(queryByText('Network Filter')).toBeNull();
+
+      // Click filter button to open network filter
+      const filterButton = getByTestId('filter-controls-button');
+      fireEvent.press(filterButton);
+
+      // Network filter should now be open
+      expect(getByTestId('select-network-button')).toBeDefined();
+    });
+
+    it('handles network selection', () => {
+      mockUseParamsValues.assetType = 'token';
+      const mockSelectNetworkFn = jest.fn();
+      mockUseNetworkSelection.mockReturnValue({
+        selectCustomNetwork: jest.fn(),
+        selectPopularNetwork: jest.fn(),
+        selectNetwork: mockSelectNetworkFn,
+        deselectAll: jest.fn(),
+        selectAllPopularNetworks: jest.fn(),
+        resetCustomNetworks: jest.fn(),
+        customNetworksToReset: [],
+      });
+
+      renderComponent(<AddAsset />);
+
+      // Test that network selection hooks are properly initialized
+      expect(mockUseNetworkSelection).toHaveBeenCalledWith({
+        networks: [],
+      });
+    });
+  });
+
+  describe('Conditional rendering based on selectors', () => {
+    it('renders banner with action button when displayNftMedia is false', () => {
+      mockUseParamsValues.assetType = 'collectible';
+
+      // Test with displayNftMedia false - should show enable CTA
+      const { getAllByRole } = renderWithProvider(<AddAsset />, {
+        state: {
+          ...initialState,
+          engine: {
+            ...initialState.engine,
+            backgroundState: {
+              ...initialState.engine.backgroundState,
+              PreferencesController: {
+                ...initialState.engine.backgroundState.PreferencesController,
+                displayNftMedia: false,
+              },
+            },
+          },
+        },
+      });
+
+      // Should show action button when displayNftMedia is false
+      const buttons = getAllByRole('button');
+      expect(buttons.length).toBeGreaterThan(0); // At least one button should exist
+    });
+
+    it('renders banner warning when displayNftMedia is true', () => {
+      mockUseParamsValues.assetType = 'collectible';
+
+      // Test with displayNftMedia true - should show warning without button
+      const { getByTestId } = renderWithProvider(<AddAsset />, {
+        state: {
+          ...initialState,
+          engine: {
+            ...initialState.engine,
+            backgroundState: {
+              ...initialState.engine.backgroundState,
+              PreferencesController: {
+                ...initialState.engine.backgroundState.PreferencesController,
+                displayNftMedia: true,
+              },
+            },
+          },
+        },
+      });
+
+      // Should show the warning test ID
+      expect(
+        getByTestId(AddAssetViewSelectorsIDs.WARNING_ENABLE_DISPLAY_MEDIA),
+      ).toBeDefined();
+    });
+
+    it('renders token detection section when supported', () => {
+      mockUseParamsValues.assetType = 'token';
+
+      // Mock token detection as supported by having the component render
+      const { getByTestId } = renderComponent(<AddAsset />);
+
+      // Should render the token screen
+      expect(getByTestId('add-token-screen')).toBeDefined();
+    });
+
+    it('shows correct network information', () => {
+      mockUseParamsValues.assetType = 'token';
+
+      const mockNetworkConfigs = {
+        '0x1': {
+          name: 'Ethereum Mainnet',
+          chainId: '0x1' as const,
+          rpcEndpoints: [
+            {
+              networkClientId: 'mainnet',
+            },
+          ],
+          defaultRpcEndpointIndex: 0,
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any;
+
+      renderWithProvider(<AddAsset />, {
+        state: {
+          ...initialState,
+          engine: {
+            ...initialState.engine,
+            backgroundState: {
+              ...initialState.engine.backgroundState,
+              NetworkController: {
+                ...initialState.engine.backgroundState.NetworkController,
+                networkConfigurationsByChainId: mockNetworkConfigs,
+              },
+            },
+          },
+        },
+      });
+
+      expect(useNetworksByNamespace).toHaveBeenCalledWith({
+        networkType: 'popular',
+      });
+    });
+  });
+
+  describe('Props passing to child components', () => {
+    it('passes correct props to SearchTokenAutocomplete', () => {
+      mockUseParamsValues.assetType = 'token';
+
+      const { getByTestId } = renderComponent(<AddAsset />);
+
+      // Verify that SearchTokenAutocomplete receives expected props
+      const searchTab = getByTestId('add-token-screen');
+      expect(searchTab).toBeDefined();
+    });
+
+    it('passes correct props to AddCustomToken', () => {
+      mockUseParamsValues.assetType = 'token';
+
+      const { getByTestId } = renderComponent(<AddAsset />);
+
+      // Verify that AddCustomToken receives expected props
+      const tokenTab = getByTestId('add-token-screen');
+      expect(tokenTab).toBeDefined();
+    });
+
+    it('passes correct props to AddCustomCollectible', () => {
+      mockUseParamsValues.assetType = 'collectible';
+
+      const { getByTestId } = renderComponent(<AddAsset />);
+
+      // Verify that AddCustomCollectible receives expected props
+      const collectibleScreen = getByTestId('add-collectible-screen');
+      expect(collectibleScreen).toBeDefined();
+    });
+  });
+
+  describe('Edge cases and error scenarios', () => {
+    it('handles missing collectibleContract param gracefully', () => {
+      mockUseParamsValues.assetType = 'collectible';
+      delete mockUseParamsValues.collectibleContract;
+
+      expect(() => renderComponent(<AddAsset />)).not.toThrow();
+    });
+
+    it('handles empty network configurations', () => {
+      mockUseParamsValues.assetType = 'token';
+
+      const { getByTestId } = renderWithProvider(<AddAsset />, {
+        state: {
+          ...initialState,
+          engine: {
+            ...initialState.engine,
+            backgroundState: {
+              ...initialState.engine.backgroundState,
+              NetworkController: {
+                ...initialState.engine.backgroundState.NetworkController,
+                networkConfigurationsByChainId: {},
+              },
+            },
+          },
+        },
+      });
+
+      expect(getByTestId('add-token-screen')).toBeDefined();
+    });
+
+    it('handles undefined selectedNetwork', () => {
+      mockUseParamsValues.assetType = 'token';
+
+      const { getByTestId } = renderComponent(<AddAsset />);
+
+      // Should render without crashing when selectedNetwork is null
+      expect(getByTestId('add-token-screen')).toBeDefined();
+    });
+  });
+
+  describe('Hook interactions', () => {
+    it('responds to different useNetworksByNamespace return values', () => {
+      mockUseParamsValues.assetType = 'token';
+
+      mockUseNetworksByNamespace.mockReturnValue({
+        networks: [
+          { name: 'Ethereum' },
+          { name: 'Polygon' },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ] as any,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        selectedNetworks: ['0x1'] as any,
+        areAllNetworksSelected: false,
+        areAnyNetworksSelected: true,
+        networkCount: 2,
+        selectedCount: 1,
+      });
+
+      renderComponent(<AddAsset />);
+
+      expect(mockUseNetworkSelection).toHaveBeenCalledWith({
+        networks: [{ name: 'Ethereum' }, { name: 'Polygon' }],
+      });
+    });
+
+    it('handles different provider config values', () => {
+      mockUseParamsValues.assetType = 'token';
+
+      // Test different provider configurations - just test that the component renders
+      const { getByTestId } = renderComponent(<AddAsset />);
+
+      expect(getByTestId('add-token-screen')).toBeDefined();
+    });
+  });
+
+  describe('Network filter functionality', () => {
+    it('calls selectNetwork when feature flag is enabled and filter option is selected', () => {
+      mockIsRemoveGlobalNetworkSelectorEnabled.mockReturnValue(true);
+      mockUseParamsValues.assetType = 'token';
+      const mockSelectNetworkFn = jest.fn();
+
+      mockUseNetworkSelection.mockReturnValue({
+        selectCustomNetwork: jest.fn(),
+        selectPopularNetwork: jest.fn(),
+        selectNetwork: mockSelectNetworkFn,
+        deselectAll: jest.fn(),
+        selectAllPopularNetworks: jest.fn(),
+        resetCustomNetworks: jest.fn(),
+        customNetworksToReset: [],
+      });
+
+      renderComponent(<AddAsset />);
+
+      // Verify that selectNetwork function is available
+      expect(mockSelectNetworkFn).toBeDefined();
+    });
+
+    it('does not call selectNetwork when feature flag is disabled', () => {
+      mockIsRemoveGlobalNetworkSelectorEnabled.mockReturnValue(false);
+      mockUseParamsValues.assetType = 'token';
+
+      const mockSelectNetworkFn = jest.fn();
+      mockUseNetworkSelection.mockReturnValue({
+        selectCustomNetwork: jest.fn(),
+        selectPopularNetwork: jest.fn(),
+        selectNetwork: mockSelectNetworkFn,
+        deselectAll: jest.fn(),
+        selectAllPopularNetworks: jest.fn(),
+        resetCustomNetworks: jest.fn(),
+        customNetworksToReset: [],
+      });
+
+      renderComponent(<AddAsset />);
+
+      // Function should be available but not called automatically
+      expect(mockSelectNetworkFn).toBeDefined();
+      expect(mockSelectNetworkFn).not.toHaveBeenCalled();
+    });
+  });
 });
 
 describe('AddAsset utils', () => {
diff --git a/app/components/Views/AddAsset/AddAsset.tsx b/app/components/Views/AddAsset/AddAsset.tsx
index f13c937468c..93fb172bcce 100644
--- a/app/components/Views/AddAsset/AddAsset.tsx
+++ b/app/components/Views/AddAsset/AddAsset.tsx
@@ -285,6 +285,21 @@ const AddAsset = () => {
         <AddCustomCollectible
           navigation={navigation}
           collectibleContract={collectibleContract}
+          setOpenNetworkSelector={setOpenNetworkSelector}
+          networkId={networkConfigurations?.[selectedNetwork as Hex]?.chainId}
+          selectedNetwork={
+            selectedNetwork
+              ? networkConfigurations?.[selectedNetwork as Hex]?.name
+              : null
+          }
+          networkClientId={
+            selectedNetwork
+              ? networkConfigurations?.[selectedNetwork]?.rpcEndpoints[
+                  networkConfigurations?.[selectedNetwork]
+                    ?.defaultRpcEndpointIndex
+                ]?.networkClientId
+              : null
+          }
         />
       )}
       {openNetworkFilter ? renderNetworkFilterSelector() : null}
diff --git a/app/components/Views/AddAsset/__snapshots__/AddAsset.test.tsx.snap b/app/components/Views/AddAsset/__snapshots__/AddAsset.test.tsx.snap
index cc73e1b1895..63b9cec1bf3 100644
--- a/app/components/Views/AddAsset/__snapshots__/AddAsset.test.tsx.snap
+++ b/app/components/Views/AddAsset/__snapshots__/AddAsset.test.tsx.snap
@@ -167,6 +167,80 @@ exports[`AddAsset component renders collectible view correctly 1`] = `
                 }
               }
             >
+              <TouchableOpacity
+                onLongPress={[Function]}
+                onPress={[Function]}
+                style={
+                  {
+                    "alignItems": "center",
+                    "borderColor": "#b7bbc8",
+                    "borderRadius": 8,
+                    "borderWidth": 1,
+                    "flexDirection": "row",
+                    "justifyContent": "space-between",
+                    "marginBottom": 16,
+                    "padding": 16,
+                  }
+                }
+              >
+                <Text
+                  style={
+                    {
+                      "color": "#121314",
+                      "fontFamily": "CentraNo1-Book",
+                      "fontSize": 16,
+                      "fontWeight": "400",
+                    }
+                  }
+                >
+                  Select a network
+                </Text>
+                <View
+                  style={
+                    {
+                      "alignItems": "center",
+                      "flexDirection": "row",
+                      "justifyContent": "space-between",
+                    }
+                  }
+                >
+                  <TouchableOpacity
+                    accessibilityRole="button"
+                    accessible={true}
+                    activeOpacity={1}
+                    disabled={false}
+                    onPress={[Function]}
+                    onPressIn={[Function]}
+                    onPressOut={[Function]}
+                    style={
+                      {
+                        "alignItems": "center",
+                        "borderRadius": 8,
+                        "height": 24,
+                        "justifyContent": "center",
+                        "marginLeft": 16,
+                        "opacity": 1,
+                        "width": 24,
+                      }
+                    }
+                    testID="select-network-button"
+                  >
+                    <SvgMock
+                      color="#121314"
+                      fill="currentColor"
+                      height={16}
+                      name="ArrowDown"
+                      style={
+                        {
+                          "height": 16,
+                          "width": 16,
+                        }
+                      }
+                      width={16}
+                    />
+                  </TouchableOpacity>
+                </View>
+              </TouchableOpacity>
               <Text
                 style={
                   {
diff --git a/app/components/Views/ProtectWalletMandatoryModal/ProtectWalletMandatoryModal.test.tsx b/app/components/Views/ProtectWalletMandatoryModal/ProtectWalletMandatoryModal.test.tsx
index 6d9aa09af09..64f2525829f 100644
--- a/app/components/Views/ProtectWalletMandatoryModal/ProtectWalletMandatoryModal.test.tsx
+++ b/app/components/Views/ProtectWalletMandatoryModal/ProtectWalletMandatoryModal.test.tsx
@@ -65,6 +65,9 @@ const initialState = {
   engine: {
     backgroundState: {
       ...backgroundState,
+      SeedlessOnboardingController: {
+        vault: undefined,
+      },
     },
   },
   user: {
@@ -108,4 +111,22 @@ describe('ProtectWalletMandatoryModal', () => {
     expect(mockNavigate).toHaveBeenCalledWith('SetPasswordFlow', undefined);
     expect(InteractionManager.runAfterInteractions).toHaveBeenCalled();
   });
+
+  it('does not render when in seedless onboarding login flow', () => {
+    const { queryByText } = renderWithProvider(
+      <ProtectWalletMandatoryModal />,
+      {
+        state: {
+          ...initialState,
+          engine: {
+            backgroundState: {
+              ...initialState.engine.backgroundState,
+              SeedlessOnboardingController: { vault: 'encrypted-vault-data' },
+            },
+          },
+        },
+      },
+    );
+    expect(queryByText('Protect wallet')).toBeNull();
+  });
 });
diff --git a/app/components/Views/ProtectWalletMandatoryModal/ProtectWalletMandatoryModal.tsx b/app/components/Views/ProtectWalletMandatoryModal/ProtectWalletMandatoryModal.tsx
index 4f641071240..82fa5ae5ed5 100644
--- a/app/components/Views/ProtectWalletMandatoryModal/ProtectWalletMandatoryModal.tsx
+++ b/app/components/Views/ProtectWalletMandatoryModal/ProtectWalletMandatoryModal.tsx
@@ -21,6 +21,7 @@ import { selectSelectedInternalAccountAddress } from '../../../selectors/account
 import { useNavigation } from '@react-navigation/native';
 import Routes from '../../../constants/navigation/Routes';
 import { findRouteNameFromNavigatorState } from '../../../util/general';
+import { selectSeedlessOnboardingLoginFlow } from '../../../selectors/seedlessOnboardingController';
 
 const ProtectWalletMandatoryModal = () => {
   const [showProtectWalletModal, setShowProtectWalletModal] = useState(false);
@@ -34,6 +35,9 @@ const ProtectWalletMandatoryModal = () => {
   const allTokens = useSelector(selectAllTokens);
   const nfts = useSelector(selectAllNfts);
   const selectedAddress = useSelector(selectSelectedInternalAccountAddress);
+  const isSeedlessOnboardingLoginFlow = useSelector(
+    selectSeedlessOnboardingLoginFlow,
+  );
 
   const { navigate, dangerouslyGetState } = useNavigation();
 
@@ -41,6 +45,11 @@ const ProtectWalletMandatoryModal = () => {
   const seedphraseBackedUp = useSelector(selectSeedphraseBackedUp);
   useEffect(() => {
     const route = findRouteNameFromNavigatorState(dangerouslyGetState().routes);
+    if (isSeedlessOnboardingLoginFlow) {
+      setShowProtectWalletModal(false);
+      return;
+    }
+
     if (!passwordSet || !seedphraseBackedUp) {
       if (
         [
@@ -91,6 +100,7 @@ const ProtectWalletMandatoryModal = () => {
     allTokens,
     nfts,
     selectedAddress,
+    isSeedlessOnboardingLoginFlow,
   ]);
 
   const onSecureWallet = () => {
diff --git a/app/components/Views/confirmations/components/edit-amount-keyboard/edit-amount-keyboard.test.tsx b/app/components/Views/confirmations/components/edit-amount-keyboard/edit-amount-keyboard.test.tsx
index edb76c121a2..6efe35d699f 100644
--- a/app/components/Views/confirmations/components/edit-amount-keyboard/edit-amount-keyboard.test.tsx
+++ b/app/components/Views/confirmations/components/edit-amount-keyboard/edit-amount-keyboard.test.tsx
@@ -129,4 +129,42 @@ describe('EditAmountKeyboard', () => {
 
     expect(getByText('Additional Row')).toBeDefined();
   });
+
+  it('calls onchange with "0 if enableEmptyValueString is false and back button is pressed to make value empty', () => {
+    const onChangeMock = jest.fn();
+
+    const { getByTestId } = render(
+      <EditAmountKeyboard
+        enableEmptyValueString
+        onChange={onChangeMock}
+        onDonePress={noop}
+        onPercentagePress={noop}
+        value={'0'}
+      />,
+    );
+
+    const backButton = getByTestId('keypad-delete-button');
+    fireEvent.press(backButton);
+
+    expect(onChangeMock).toHaveBeenCalledWith('');
+  });
+
+  it('calls onchange with empty string if enableEmptyValueString is true and back button is pressed to make value empty', () => {
+    const onChangeMock = jest.fn();
+
+    const { getByTestId } = render(
+      <EditAmountKeyboard
+        enableEmptyValueString
+        onChange={onChangeMock}
+        onDonePress={noop}
+        onPercentagePress={noop}
+        value={'0'}
+      />,
+    );
+
+    const backButton = getByTestId('keypad-delete-button');
+    fireEvent.press(backButton);
+
+    expect(onChangeMock).toHaveBeenCalledWith('');
+  });
 });
diff --git a/app/components/Views/confirmations/components/edit-amount-keyboard/edit-amount-keyboard.tsx b/app/components/Views/confirmations/components/edit-amount-keyboard/edit-amount-keyboard.tsx
index fa1f36f63e1..5fc622ab776 100644
--- a/app/components/Views/confirmations/components/edit-amount-keyboard/edit-amount-keyboard.tsx
+++ b/app/components/Views/confirmations/components/edit-amount-keyboard/edit-amount-keyboard.tsx
@@ -1,7 +1,10 @@
 import React, { ReactNode, useCallback } from 'react';
 import { View } from 'react-native';
 
-import KeypadComponent, { KeypadChangeData } from '../../../../Base/Keypad';
+import KeypadComponent, {
+  KeypadChangeData,
+  Keys,
+} from '../../../../Base/Keypad';
 import { useStyles } from '../../../../hooks/useStyles';
 import styleSheet from './edit-amount-keyboard.styles';
 import Button, {
@@ -26,6 +29,7 @@ export interface EditAmountKeyboardProps {
   hideDoneButton?: boolean;
   showAdditionalKeyboard?: boolean;
   additionalRow?: ReactNode;
+  enableEmptyValueString?: boolean;
 }
 
 export function EditAmountKeyboard({
@@ -37,14 +41,20 @@ export function EditAmountKeyboard({
   hideDoneButton = false,
   showAdditionalKeyboard = true,
   additionalRow,
+  enableEmptyValueString = false,
 }: Readonly<EditAmountKeyboardProps>) {
   const { styles } = useStyles(styleSheet, {});
 
   const handleChange = useCallback(
     (data: KeypadChangeData) => {
-      onChange(data.value);
+      const { pressedKey, value } = data;
+      if (pressedKey === Keys.Back && value === '0' && enableEmptyValueString) {
+        onChange('');
+        return;
+      }
+      onChange(value);
     },
-    [onChange],
+    [enableEmptyValueString, onChange],
   );
 
   return (
diff --git a/app/components/Views/confirmations/components/modals/pay-with-modal/pay-with-modal.test.tsx b/app/components/Views/confirmations/components/modals/pay-with-modal/pay-with-modal.test.tsx
index 67151ffdbf8..e569aeabf8d 100644
--- a/app/components/Views/confirmations/components/modals/pay-with-modal/pay-with-modal.test.tsx
+++ b/app/components/Views/confirmations/components/modals/pay-with-modal/pay-with-modal.test.tsx
@@ -3,7 +3,6 @@ import { fireEvent, waitFor } from '@testing-library/react-native';
 import { PayWithModal } from './pay-with-modal';
 import Routes from '../../../../../../constants/navigation/Routes';
 import { useTokens } from '../../../../../UI/Bridge/hooks/useTokens';
-import { Hex } from '@metamask/utils';
 import { BridgeToken } from '../../../../../UI/Bridge/types';
 import { NATIVE_TOKEN_ADDRESS } from '../../../constants/tokens';
 import { cloneDeep, merge } from 'lodash';
@@ -13,6 +12,8 @@ import { simpleSendTransactionControllerMock } from '../../../__mocks__/controll
 import { otherControllersMock } from '../../../__mocks__/controllers/other-controllers-mock';
 import { initialState } from '../../../../../UI/Bridge/_mocks_/initialState';
 import { useTransactionPayToken } from '../../../hooks/pay/useTransactionPayToken';
+import { BridgeSourceNetworksBar } from '../../../../../UI/Bridge/components/BridgeSourceNetworksBar';
+import { CHAIN_IDS } from '@metamask/transaction-controller';
 
 jest.useFakeTimers();
 
@@ -23,6 +24,7 @@ const mockSetPayToken = jest.fn();
 jest.mock('../../../../../UI/Bridge/hooks/useTokens');
 jest.mock('../../../hooks/pay/useTransactionRequiredTokens');
 jest.mock('../../../hooks/pay/useTransactionPayToken');
+jest.mock('../../../../../UI/Bridge/components/BridgeSourceNetworksBar');
 
 jest.mock(
   '../../../../../../core/redux/slices/bridge/utils/hasMinimumRequiredVersion',
@@ -39,8 +41,8 @@ jest.mock('@react-navigation/native', () => ({
   }),
 }));
 
-const CHAIN_ID_1_MOCK = '0x1' as Hex;
-const CHAIN_ID_2_MOCK = '0x456' as Hex;
+const CHAIN_ID_1_MOCK = CHAIN_IDS.MAINNET;
+const CHAIN_ID_2_MOCK = CHAIN_IDS.OPTIMISM;
 
 const TOKENS_MOCK: BridgeToken[] = [
   {
@@ -119,6 +121,7 @@ function render({ minimumFiatBalance }: { minimumFiatBalance?: number } = {}) {
 describe('PayWithModal', () => {
   const useTokensMock = jest.mocked(useTokens);
   const useTransactionPayTokenMock = jest.mocked(useTransactionPayToken);
+  const BridgeSourceNetworksBarMock = jest.mocked(BridgeSourceNetworksBar);
   const useTransactionRequiredTokensMock = jest.mocked(
     useTransactionRequiredTokens,
   );
@@ -259,6 +262,25 @@ describe('PayWithModal', () => {
     });
   });
 
+  it('displays supported networks in networks bar', async () => {
+    render();
+
+    expect(BridgeSourceNetworksBarMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        networksToShow: [
+          expect.objectContaining({ chainId: CHAIN_ID_1_MOCK }),
+          expect.objectContaining({ chainId: CHAIN_ID_2_MOCK }),
+        ],
+        enabledSourceChains: [
+          expect.objectContaining({ chainId: CHAIN_ID_1_MOCK }),
+          expect.objectContaining({ chainId: CHAIN_ID_2_MOCK }),
+        ],
+        selectedSourceChainIds: [CHAIN_ID_1_MOCK, CHAIN_ID_2_MOCK],
+      }),
+      expect.anything(),
+    );
+  });
+
   describe('on token select', () => {
     it('sets pay asset', async () => {
       const { getByText } = render();
@@ -286,6 +308,14 @@ describe('PayWithModal', () => {
 
   describe('on network select', () => {
     it('navigates to network selector', async () => {
+      const originalNetworkBar = jest.requireActual(
+        '../../../../../UI/Bridge/components/BridgeSourceNetworksBar',
+      ).BridgeSourceNetworksBar;
+
+      BridgeSourceNetworksBarMock.mockImplementation((props) =>
+        originalNetworkBar(props),
+      );
+
       const { getByText } = render();
 
       await waitFor(() => {
diff --git a/app/components/Views/confirmations/components/modals/pay-with-modal/pay-with-modal.tsx b/app/components/Views/confirmations/components/modals/pay-with-modal/pay-with-modal.tsx
index c13de96398f..a9db8831b29 100644
--- a/app/components/Views/confirmations/components/modals/pay-with-modal/pay-with-modal.tsx
+++ b/app/components/Views/confirmations/components/modals/pay-with-modal/pay-with-modal.tsx
@@ -24,18 +24,34 @@ import { strings } from '../../../../../../../locales/i18n';
 import { NATIVE_TOKEN_ADDRESS } from '../../../constants/tokens';
 import { useTransactionRequiredTokens } from '../../../hooks/pay/useTransactionRequiredTokens';
 import { useTransactionMetadataRequest } from '../../../hooks/transactions/useTransactionMetadataRequest';
+import { isSolanaChainId } from '@metamask/bridge-controller';
 
 export function PayWithModal() {
   const allNetworkConfigurations = useSelector(selectNetworkConfigurations);
   const enabledSourceChains = useSelector(selectEnabledSourceChains);
   const selectedSourceChainIds = useSelector(selectSelectedSourceChainIds);
-  const { sortedSourceNetworks } = useSortedSourceNetworks();
+  const { sortedSourceNetworks: sortedSourceNetworksRaw } =
+    useSortedSourceNetworks();
   const navigation = useNavigation();
   const { payToken, setPayToken } = useTransactionPayToken();
   const { minimumFiatBalance } = useParams<{ minimumFiatBalance?: number }>();
   const { chainId: transactionChainId } = useTransactionMetadataRequest() ?? {};
   const requiredTokens = useTransactionRequiredTokens();
 
+  const supportedSourceChains = useMemo(
+    () =>
+      enabledSourceChains.filter((chain) => !isSolanaChainId(chain.chainId)),
+    [enabledSourceChains],
+  );
+
+  const sortedSourceNetworks = useMemo(
+    () =>
+      sortedSourceNetworksRaw.filter((chain) =>
+        supportedSourceChains.some((c) => c.chainId === chain.chainId),
+      ),
+    [sortedSourceNetworksRaw, supportedSourceChains],
+  );
+
   const targetTokens = useMemo(
     () => requiredTokens.filter((t) => !t.skipIfBalance),
     [requiredTokens],
@@ -157,7 +173,7 @@ export function PayWithModal() {
           networksToShow={networksToShow}
           networkConfigurations={allNetworkConfigurations}
           selectedSourceChainIds={selectedSourceChainIds as Hex[]}
-          enabledSourceChains={enabledSourceChains}
+          enabledSourceChains={supportedSourceChains}
           onPress={handleNetworkPress}
         />
       }
diff --git a/app/components/Views/confirmations/components/modals/pay-with-network-modal/pay-with-network-modal.tsx b/app/components/Views/confirmations/components/modals/pay-with-network-modal/pay-with-network-modal.tsx
index 3996eca7cac..0242deec638 100644
--- a/app/components/Views/confirmations/components/modals/pay-with-network-modal/pay-with-network-modal.tsx
+++ b/app/components/Views/confirmations/components/modals/pay-with-network-modal/pay-with-network-modal.tsx
@@ -17,5 +17,5 @@ export function PayWithNetworkModal() {
     [dispatch, navigation],
   );
 
-  return <BridgeSourceNetworkSelector onApply={handleApply} />;
+  return <BridgeSourceNetworkSelector onApply={handleApply} isEvmOnly />;
 }
diff --git a/app/components/Views/confirmations/components/recipient-list/recipient-list.tsx b/app/components/Views/confirmations/components/recipient-list/recipient-list.tsx
index d28a9c7a706..6120a910517 100644
--- a/app/components/Views/confirmations/components/recipient-list/recipient-list.tsx
+++ b/app/components/Views/confirmations/components/recipient-list/recipient-list.tsx
@@ -19,6 +19,7 @@ interface RecipientListProps {
   emptyMessage?: string;
   onRecipientSelected: (recipient: RecipientType) => void;
   isContactList?: boolean;
+  disabled?: boolean;
 }
 
 export function RecipientList({
@@ -26,6 +27,7 @@ export function RecipientList({
   onRecipientSelected,
   emptyMessage,
   isContactList = false,
+  disabled = false,
 }: RecipientListProps) {
   const accountAvatarType = useAccountAvatarType();
   const { to } = useSendContext();
@@ -56,6 +58,7 @@ export function RecipientList({
           accountAvatarType={accountAvatarType}
           to={to}
           isBIP44={isBIP44}
+          disabled={disabled}
         />
       </Box>
     );
@@ -80,12 +83,14 @@ function FlatRecipientList({
   accountAvatarType,
   to,
   isBIP44,
+  disabled,
 }: {
   data: RecipientType[];
   onRecipientSelected: (recipient: RecipientType) => void;
   accountAvatarType: AvatarAccountType;
   to?: string;
   isBIP44?: boolean;
+  disabled?: boolean;
 }) {
   return (
     <Box twClassName="flex-1">
@@ -96,7 +101,7 @@ function FlatRecipientList({
           accountAvatarType={accountAvatarType}
           isSelected={to === recipient.address}
           isBIP44={isBIP44}
-          onPress={onRecipientSelected}
+          onPress={disabled ? undefined : onRecipientSelected}
         />
       ))}
     </Box>
diff --git a/app/components/Views/confirmations/components/rows/pay-with-row/pay-with-row.tsx b/app/components/Views/confirmations/components/rows/pay-with-row/pay-with-row.tsx
index 1f96d056678..fe686b0a746 100644
--- a/app/components/Views/confirmations/components/rows/pay-with-row/pay-with-row.tsx
+++ b/app/components/Views/confirmations/components/rows/pay-with-row/pay-with-row.tsx
@@ -33,7 +33,7 @@ export function PayWithRow() {
   const { styles } = useStyles(styleSheet, {});
   const navigation = useNavigation();
   const { payToken } = useTransactionPayToken();
-  const { totalFiat } = useTransactionRequiredFiat();
+  const { totalFiat } = useTransactionRequiredFiat({ log: true });
 
   useTransactionBridgeQuotes();
 
diff --git a/app/components/Views/confirmations/components/rows/total-row/total-row.tsx b/app/components/Views/confirmations/components/rows/total-row/total-row.tsx
index 6673072d8dc..1312a88d06d 100644
--- a/app/components/Views/confirmations/components/rows/total-row/total-row.tsx
+++ b/app/components/Views/confirmations/components/rows/total-row/total-row.tsx
@@ -1,4 +1,4 @@
-import React, { useEffect } from 'react';
+import React from 'react';
 import Text from '../../../../../../component-library/components/Texts/Text';
 import InfoRow from '../../UI/info-row';
 import { useTransactionTotalFiat } from '../../../hooks/pay/useTransactionTotalFiat';
@@ -12,23 +12,15 @@ import AnimatedSpinner, {
 } from '../../../../../UI/AnimatedSpinner';
 import { View } from 'react-native';
 import { TransactionType } from '@metamask/transaction-controller';
-import { createProjectLogger } from '@metamask/utils';
-
-const log = createProjectLogger('transaction-pay');
 
 export function TotalRow() {
   const { id: transactionId, type } = useTransactionMetadataOrThrow();
-  const totals = useTransactionTotalFiat();
-  const { totalFormatted } = totals;
+  const { totalFormatted } = useTransactionTotalFiat({ log: true });
 
   const isQuotesLoading = useSelector((state: RootState) =>
     selectIsTransactionBridgeQuotesLoadingById(state, transactionId),
   );
 
-  useEffect(() => {
-    log('Total fiat', totals);
-  }, [totals]);
-
   return (
     <View testID="total-row">
       <InfoRow
diff --git a/app/components/Views/confirmations/components/send/amount/amount-keyboard/amount-keyboard.tsx b/app/components/Views/confirmations/components/send/amount/amount-keyboard/amount-keyboard.tsx
index a0e5916e9f4..2ac1b0d9483 100644
--- a/app/components/Views/confirmations/components/send/amount/amount-keyboard/amount-keyboard.tsx
+++ b/app/components/Views/confirmations/components/send/amount/amount-keyboard/amount-keyboard.tsx
@@ -108,6 +108,7 @@ export const AmountKeyboard = ({
           />
         ) : undefined
       }
+      enableEmptyValueString
       hideDoneButton
       onChange={updateToNewAmount}
       onPercentagePress={updateToPercentageAmount}
diff --git a/app/components/Views/confirmations/components/send/amount/amount.styles.ts b/app/components/Views/confirmations/components/send/amount/amount.styles.ts
index 04377c743cc..7612442b593 100644
--- a/app/components/Views/confirmations/components/send/amount/amount.styles.ts
+++ b/app/components/Views/confirmations/components/send/amount/amount.styles.ts
@@ -7,25 +7,32 @@ import {
   JustifyContent,
 } from '../../../../../UI/Box/box.types';
 
-export const getFontSizeForInputLength = (contentLength: number) => {
-  if (contentLength < 10) {
+export const getFontSizeForInputLength = (
+  inputLength: number,
+  symbolLength: number,
+) => {
+  if (inputLength < 5 && symbolLength < 6) {
     return 60;
   }
-  if (contentLength < 12) {
+  if (inputLength < 6 && symbolLength < 7) {
     return 48;
   }
-  if (contentLength < 18) {
+  if (inputLength < 9 && symbolLength < 9) {
     return 32;
   }
-  if (contentLength < 24) {
+  if (inputLength < 12 && symbolLength < 12) {
     return 24;
   }
-  return 18;
+  if (inputLength < 16 && symbolLength < 16) {
+    return 18;
+  }
+  return 12;
 };
 
 export const styleSheet = (params: {
   theme: Theme;
   vars: {
+    fiatMode: boolean;
     inputError: boolean;
     inputLength: number;
     isNFT: boolean;
@@ -34,7 +41,7 @@ export const styleSheet = (params: {
 }) => {
   const {
     theme,
-    vars: { inputError, inputLength, isNFT, symbolLength },
+    vars: { fiatMode, inputError, inputLength, isNFT, symbolLength },
   } = params;
   return StyleSheet.create({
     balanceSection: {
@@ -62,28 +69,29 @@ export const styleSheet = (params: {
       color: inputError
         ? theme.colors.error.default
         : theme.colors.text.default,
-      fontSize: getFontSizeForInputLength(inputLength + symbolLength),
-      minWidth: '30%',
+      fontSize: getFontSizeForInputLength(inputLength, symbolLength),
       includeFontPadding: false,
       textAlignVertical: 'center',
       paddingTop: Platform.OS === 'ios' ? 0 : 2,
       // Dynamic height for large fonts:
       height: Math.max(
         50,
-        getFontSizeForInputLength(inputLength + symbolLength) + 10,
+        getFontSizeForInputLength(inputLength, symbolLength) + 10,
       ),
     },
     inputSection: {
       flexDirection: FlexDirection.Row,
-      justifyContent:
-        inputLength < 5 ? JustifyContent.center : JustifyContent.flexEnd,
+      justifyContent: JustifyContent.center,
       marginTop: isNFT ? 0 : 80,
       width: '100%',
     },
     inputWrapper: {
       alignItems: AlignItems.center,
       flexDirection: FlexDirection.Row,
-      justifyContent: JustifyContent.flexEnd,
+      justifyContent: fiatMode
+        ? JustifyContent.flexStart
+        : JustifyContent.flexEnd,
+      width: '50%',
     },
     nftImage: { alignSelf: 'center', height: 100, width: 100 },
     nftImageWrapper: {
@@ -91,13 +99,18 @@ export const styleSheet = (params: {
       marginTop: 32,
       width: '100%',
     },
+    tokenSymbolWrapper: {
+      justifyContent: fiatMode
+        ? JustifyContent.flexEnd
+        : JustifyContent.flexStart,
+      width: '50%',
+    },
     tokenSymbol: {
       alignItems: AlignItems.center,
-      alignSelf: 'flex-end',
-      fontSize: getFontSizeForInputLength(inputLength + symbolLength),
+      alignSelf: fiatMode ? AlignItems.flexEnd : AlignItems.flexStart,
+      fontSize: getFontSizeForInputLength(inputLength, symbolLength),
       lineHeight: 75,
       paddingLeft: 2,
-      textAlign: 'left',
     },
     topSection: {
       paddingHorizontal: 8,
diff --git a/app/components/Views/confirmations/components/send/amount/amount.test.tsx b/app/components/Views/confirmations/components/send/amount/amount.test.tsx
index feb09babfc1..72918e22ddc 100644
--- a/app/components/Views/confirmations/components/send/amount/amount.test.tsx
+++ b/app/components/Views/confirmations/components/send/amount/amount.test.tsx
@@ -71,6 +71,7 @@ jest.mock('@react-navigation/native', () => ({
 }));
 
 import { useAmountSelectionMetrics } from '../../../hooks/send/metrics/useAmountSelectionMetrics';
+import { getFontSizeForInputLength } from './amount.styles';
 const mockedUseAmountSelectionMetrics = jest.mocked(useAmountSelectionMetrics);
 
 const renderComponent = (mockState?: ProviderValues['state']) => {
@@ -146,7 +147,7 @@ describe('Amount', () => {
     act(() => {
       fireEvent.changeText(getByTestId('send_amount'), '1');
     });
-    expect(getByText('$ 3890.00')).toBeTruthy();
+    expect(getByText('$ 3890')).toBeTruthy();
   });
 
   it('display fiat conversion of amount entered for solana asset', () => {
@@ -160,7 +161,7 @@ describe('Amount', () => {
     act(() => {
       fireEvent.changeText(getByTestId('send_amount'), '1');
     });
-    expect(getByText('$ 175.00')).toBeTruthy();
+    expect(getByText('$ 175')).toBeTruthy();
   });
 
   it('if fiatmode is enabled display native conversion of amount entered', () => {
@@ -212,11 +213,11 @@ describe('Amount', () => {
     act(() => {
       fireEvent.press(getByTestId('fiat_toggle'));
     });
-    expect(mockSetAmountInputTypeToken).toHaveBeenCalled();
+    expect(mockSetAmountInputTypeFiat).toHaveBeenCalled();
     act(() => {
       fireEvent.press(getByTestId('fiat_toggle'));
     });
-    expect(mockSetAmountInputTypeFiat).toHaveBeenCalled();
+    expect(mockSetAmountInputTypeToken).toHaveBeenCalled();
   });
 
   it('fiatmode is not avaialble for NFT', () => {
@@ -526,3 +527,25 @@ describe('Amount', () => {
   //   expect(mockCaptureAmountSelected).toHaveBeenCalled();
   // });
 });
+
+describe('getFontSizeForInputLength', () => {
+  it('renders correct font size using input and symbol length', () => {
+    expect(getFontSizeForInputLength(1, 1)).toEqual(60);
+    expect(getFontSizeForInputLength(5, 1)).toEqual(48);
+    expect(getFontSizeForInputLength(1, 6)).toEqual(48);
+    expect(getFontSizeForInputLength(5, 6)).toEqual(48);
+    expect(getFontSizeForInputLength(6, 6)).toEqual(32);
+    expect(getFontSizeForInputLength(5, 7)).toEqual(32);
+    expect(getFontSizeForInputLength(6, 7)).toEqual(32);
+    expect(getFontSizeForInputLength(9, 7)).toEqual(24);
+    expect(getFontSizeForInputLength(6, 9)).toEqual(24);
+    expect(getFontSizeForInputLength(9, 9)).toEqual(24);
+    expect(getFontSizeForInputLength(12, 9)).toEqual(18);
+    expect(getFontSizeForInputLength(9, 12)).toEqual(18);
+    expect(getFontSizeForInputLength(12, 12)).toEqual(18);
+    expect(getFontSizeForInputLength(16, 12)).toEqual(12);
+    expect(getFontSizeForInputLength(12, 16)).toEqual(12);
+    expect(getFontSizeForInputLength(16, 16)).toEqual(12);
+    expect(getFontSizeForInputLength(18, 18)).toEqual(12);
+  });
+});
diff --git a/app/components/Views/confirmations/components/send/amount/amount.tsx b/app/components/Views/confirmations/components/send/amount/amount.tsx
index fa26227964f..69afd9be66a 100644
--- a/app/components/Views/confirmations/components/send/amount/amount.tsx
+++ b/app/components/Views/confirmations/components/send/amount/amount.tsx
@@ -39,9 +39,10 @@ export const Amount = () => {
   const [fiatMode, setFiatMode] = useState(primaryCurrency === 'Fiat');
   const {
     fiatCurrencySymbol,
+    getFiatValue,
     getFiatDisplayValue,
-    getNativeDisplayValue,
     getNativeValue,
+    getNativeDisplayValue,
   } = useCurrencyConversions();
   const isNFT = asset?.standard === TokenStandard.ERC1155;
   const assetSymbol = isNFT
@@ -49,6 +50,7 @@ export const Amount = () => {
     : (asset as AssetType)?.ticker ?? (asset as AssetType)?.symbol;
   const assetDisplaySymbol = assetSymbol ?? (isNFT ? 'NFT' : '');
   const { styles, theme } = useStyles(styleSheet, {
+    fiatMode,
     inputError: Boolean(amountError),
     inputLength: amount.length,
     isNFT,
@@ -87,21 +89,25 @@ export const Amount = () => {
   );
 
   const toggleFiatMode = useCallback(() => {
-    if (!fiatMode) {
-      setAmountInputTypeToken();
-    } else {
+    const newFiatMode = !fiatMode;
+    if (newFiatMode) {
       setAmountInputTypeFiat();
+    } else {
+      setAmountInputTypeToken();
+    }
+    setFiatMode(newFiatMode);
+    if (amount !== undefined) {
+      setAmount(newFiatMode ? getFiatValue(amount) : getNativeValue(amount));
     }
-    setFiatMode(!fiatMode);
-    setAmount('');
-    updateValue('');
   }, [
+    amount,
     fiatMode,
+    getFiatValue,
+    getNativeValue,
     setAmount,
     setAmountInputTypeFiat,
     setAmountInputTypeToken,
     setFiatMode,
-    updateValue,
   ]);
 
   const balanceUnit =
@@ -128,26 +134,42 @@ export const Amount = () => {
           </View>
         )}
         <View style={styles.inputSection}>
+          {fiatMode && (
+            <View style={styles.tokenSymbolWrapper}>
+              <Text
+                color={amountError ? TextColor.Error : TextColor.Alternative}
+                numberOfLines={1}
+                style={styles.tokenSymbol}
+                variant={TextVariant.DisplayLG}
+              >
+                {fiatCurrencySymbol}
+              </Text>
+            </View>
+          )}
           <View style={styles.inputWrapper}>
             <Input
               cursorColor={theme.colors.primary.default}
               onChangeText={updateToNewAmount}
               style={styles.input}
               testID="send_amount"
-              textAlign="right"
+              textAlign={fiatMode ? 'left' : 'right'}
               textVariant={TextVariant.DisplayLG}
               value={amount}
               showSoftInputOnFocus={false}
             />
           </View>
-          <Text
-            color={amountError ? TextColor.Error : TextColor.Alternative}
-            numberOfLines={1}
-            style={styles.tokenSymbol}
-            variant={TextVariant.DisplayLG}
-          >
-            {fiatMode ? fiatCurrencySymbol : assetDisplaySymbol}
-          </Text>
+          {!fiatMode && (
+            <View style={styles.tokenSymbolWrapper}>
+              <Text
+                color={amountError ? TextColor.Error : TextColor.Alternative}
+                numberOfLines={1}
+                style={styles.tokenSymbol}
+                variant={TextVariant.DisplayLG}
+              >
+                {assetDisplaySymbol}
+              </Text>
+            </View>
+          )}
         </View>
         {!isNFT && (
           <TagBase shape={TagShape.Pill} style={styles.currencyTag}>
diff --git a/app/components/Views/confirmations/components/send/recipient/recipient.test.tsx b/app/components/Views/confirmations/components/send/recipient/recipient.test.tsx
index 90825aa51f7..acd756a5132 100644
--- a/app/components/Views/confirmations/components/send/recipient/recipient.test.tsx
+++ b/app/components/Views/confirmations/components/send/recipient/recipient.test.tsx
@@ -13,6 +13,21 @@ import { useSendType } from '../../../hooks/send/useSendType';
 import { RecipientType } from '../../UI/recipient';
 import { Recipient } from './recipient';
 
+jest.mock('@react-navigation/native', () => {
+  const actual = jest.requireActual('@react-navigation/native');
+  const ReactActual = jest.requireActual('react');
+  return {
+    ...actual,
+    // Run focus effects as a normal effect during tests
+    useFocusEffect: (effect: () => void | (() => void)) => {
+      ReactActual.useEffect(() => {
+        const cleanup = effect();
+        return cleanup;
+      }, []);
+    },
+  };
+});
+
 const mockAccounts: RecipientType[] = [
   {
     accountName: 'Account 1',
diff --git a/app/components/Views/confirmations/components/send/recipient/recipient.tsx b/app/components/Views/confirmations/components/send/recipient/recipient.tsx
index a0e3e94ab6d..a2e0ace87be 100644
--- a/app/components/Views/confirmations/components/send/recipient/recipient.tsx
+++ b/app/components/Views/confirmations/components/send/recipient/recipient.tsx
@@ -27,6 +27,7 @@ import { RecipientList } from '../../recipient-list/recipient-list';
 import { RecipientInput } from '../../recipient-input';
 import { RecipientType } from '../../UI/recipient';
 import { styleSheet } from './recipient.styles';
+import { useFocusEffect } from '@react-navigation/native';
 
 export const Recipient = () => {
   const [isRecipientSelectedFromList, setIsRecipientSelectedFromList] =
@@ -48,11 +49,20 @@ export const Recipient = () => {
   // This hook needs to be called to update ERC721 NFTs in send flow
   // because that flow is triggered directly from the asset details page and user is redirected to the recipient page
   useRouteParams();
+  // This submission lifecycle state prevents adding multiple transactions
+  const [isSubmittingTransaction, setIsSubmittingTransaction] = useState(false);
+  // Reset the submitting state when the user returns to the recipient page
+  useFocusEffect(
+    useCallback(() => {
+      setIsSubmittingTransaction(false);
+    }, []),
+  );
 
   const handleReview = useCallback(async () => {
     if (toAddressError) {
       return;
     }
+    setIsSubmittingTransaction(true);
 
     let resolvedEnsAddress = to;
     if (isEvmSendType) {
@@ -78,6 +88,7 @@ export const Recipient = () => {
           | typeof RecipientInputMethod.SelectContact,
       ) =>
       (recipient: RecipientType) => {
+        setIsSubmittingTransaction(true);
         const selectedAddress = recipient.address;
         setIsRecipientSelectedFromList(true);
         updateTo(selectedAddress);
@@ -115,6 +126,7 @@ export const Recipient = () => {
               onRecipientSelected={onRecipientSelected(
                 RecipientInputMethod.SelectAccount,
               )}
+              disabled={isSubmittingTransaction}
             />
             {contacts.length > 0 && (
               <RecipientList
@@ -124,6 +136,7 @@ export const Recipient = () => {
                   RecipientInputMethod.SelectContact,
                 )}
                 emptyMessage={strings('send.no_contacts_found')}
+                disabled={isSubmittingTransaction}
               />
             )}
           </ScrollView>
@@ -151,7 +164,8 @@ export const Recipient = () => {
                 onPress={handleReview}
                 twClassName="w-full"
                 isDanger={Boolean(toAddressError)}
-                disabled={Boolean(toAddressError)}
+                disabled={Boolean(toAddressError) || isSubmittingTransaction}
+                isLoading={isSubmittingTransaction}
               >
                 {isReviewButtonDisabled
                   ? toAddressError
diff --git a/app/components/Views/confirmations/external/perps-temp/components/deposit/deposit.test.tsx b/app/components/Views/confirmations/external/perps-temp/components/deposit/deposit.test.tsx
index e0d5f4757bb..6796425bea3 100644
--- a/app/components/Views/confirmations/external/perps-temp/components/deposit/deposit.test.tsx
+++ b/app/components/Views/confirmations/external/perps-temp/components/deposit/deposit.test.tsx
@@ -23,6 +23,7 @@ jest.mock('../../hooks/usePerpsDepositView');
 jest.mock('../../../../hooks/useTokenAsset');
 jest.mock('../../../../hooks/useTokenAmount');
 jest.mock('../../../../hooks/ui/useClearConfirmationOnBackSwipe');
+jest.mock('../../../../hooks/pay/useTransactionBridgeQuotes');
 
 jest.mock('@react-navigation/native', () => ({
   ...jest.requireActual('@react-navigation/native'),
diff --git a/app/components/Views/confirmations/hooks/pay/useAutomaticTransactionPayToken.ts b/app/components/Views/confirmations/hooks/pay/useAutomaticTransactionPayToken.ts
index 49a12d386ba..7b1574900b0 100644
--- a/app/components/Views/confirmations/hooks/pay/useAutomaticTransactionPayToken.ts
+++ b/app/components/Views/confirmations/hooks/pay/useAutomaticTransactionPayToken.ts
@@ -34,7 +34,7 @@ export function useAutomaticTransactionPayToken({
   );
 
   const tokens = useTokensWithBalance({ chainIds });
-  const requiredTokens = useTransactionRequiredTokens();
+  const requiredTokens = useTransactionRequiredTokens({ log: true });
   const { chainId } = useTransactionMetadataRequest() ?? {};
   const { setPayToken } = useTransactionPayToken();
   const { totalFiat } = useTransactionRequiredFiat();
diff --git a/app/components/Views/confirmations/hooks/pay/useTransactionBridgeQuotes.test.ts b/app/components/Views/confirmations/hooks/pay/useTransactionBridgeQuotes.test.ts
index 12868b1d611..c9b79c41b3e 100644
--- a/app/components/Views/confirmations/hooks/pay/useTransactionBridgeQuotes.test.ts
+++ b/app/components/Views/confirmations/hooks/pay/useTransactionBridgeQuotes.test.ts
@@ -15,9 +15,10 @@ import {
   ATTEMPTS_MAX_DEFAULT,
   BUFFER_INITIAL_DEFAULT,
   BUFFER_STEP_DEFAULT,
-  SLIPPAGE_INITIAL_DEFAULT,
-  SLIPPAGE_SUBSEQUENT_DEFAULT,
+  BUFFER_SUBSEQUENT_DEFAULT,
+  SLIPPAGE_DEFAULT,
 } from '../../../../../selectors/featureFlagController/confirmations';
+import { initialState } from '../../../../UI/Bridge/_mocks_/initialState';
 
 jest.mock('./useTransactionPayToken');
 jest.mock('./useTransactionPayTokenAmounts');
@@ -25,6 +26,15 @@ jest.mock('../transactions/useTransactionMetadataRequest');
 jest.mock('../../utils/bridge');
 jest.mock('../../context/alert-system-context');
 
+jest.mock(
+  '../../../../../core/redux/slices/bridge/utils/hasMinimumRequiredVersion',
+  () => ({
+    hasMinimumRequiredVersion: jest.fn().mockReturnValue(true),
+  }),
+);
+
+jest.useFakeTimers();
+
 const TRANSACTION_ID_MOCK = '1234-5678';
 const CHAIN_ID_SOURCE_MOCK = '0x1';
 const CHAIN_ID_TARGET_MOCK = '0x2';
@@ -43,8 +53,9 @@ const QUOTE_MOCK = {
 } as TransactionBridgeQuote;
 
 function runHook() {
-  return renderHookWithProvider(useTransactionBridgeQuotes, { state: {} })
-    .result;
+  return renderHookWithProvider(useTransactionBridgeQuotes, {
+    state: initialState,
+  });
 }
 
 describe('useTransactionBridgeQuotes', () => {
@@ -115,9 +126,9 @@ describe('useTransactionBridgeQuotes', () => {
         attemptsMax: ATTEMPTS_MAX_DEFAULT,
         bufferInitial: BUFFER_INITIAL_DEFAULT,
         bufferStep: BUFFER_STEP_DEFAULT,
+        bufferSubsequent: BUFFER_SUBSEQUENT_DEFAULT,
         from: ACCOUNT_ADDRESS_MOCK,
-        slippageInitial: SLIPPAGE_INITIAL_DEFAULT,
-        slippageSubsequent: SLIPPAGE_SUBSEQUENT_DEFAULT,
+        slippage: SLIPPAGE_DEFAULT,
         sourceBalanceRaw: SOURCE_BALANCE_RAW_MOCK,
         sourceChainId: CHAIN_ID_SOURCE_MOCK,
         sourceTokenAddress: TOKEN_ADDRESS_SOURCE_MOCK,
@@ -130,9 +141,9 @@ describe('useTransactionBridgeQuotes', () => {
         attemptsMax: ATTEMPTS_MAX_DEFAULT,
         bufferInitial: BUFFER_INITIAL_DEFAULT,
         bufferStep: BUFFER_STEP_DEFAULT,
+        bufferSubsequent: BUFFER_SUBSEQUENT_DEFAULT,
         from: ACCOUNT_ADDRESS_MOCK,
-        slippageInitial: SLIPPAGE_INITIAL_DEFAULT,
-        slippageSubsequent: SLIPPAGE_SUBSEQUENT_DEFAULT,
+        slippage: SLIPPAGE_DEFAULT,
         sourceBalanceRaw: SOURCE_BALANCE_RAW_MOCK,
         sourceChainId: CHAIN_ID_SOURCE_MOCK,
         sourceTokenAddress: TOKEN_ADDRESS_SOURCE_MOCK,
@@ -145,7 +156,7 @@ describe('useTransactionBridgeQuotes', () => {
   });
 
   it('returns bridge quotes', async () => {
-    const result = runHook();
+    const { result } = runHook();
 
     await act(async () => {
       // Intentionally empty
@@ -177,7 +188,7 @@ describe('useTransactionBridgeQuotes', () => {
       payToken: undefined,
     } as unknown as ReturnType<typeof useTransactionPayToken>);
 
-    const result = runHook();
+    const { result } = runHook();
 
     await act(async () => {
       // Intentionally empty
@@ -196,7 +207,7 @@ describe('useTransactionBridgeQuotes', () => {
       ],
     } as unknown as ReturnType<typeof useAlerts>);
 
-    const result = runHook();
+    const { result } = runHook();
 
     await act(async () => {
       // Intentionally empty
@@ -217,7 +228,7 @@ describe('useTransactionBridgeQuotes', () => {
         ],
       } as unknown as ReturnType<typeof useAlerts>);
 
-      const result = runHook();
+      const { result } = runHook();
 
       await act(async () => {
         // Intentionally empty
@@ -226,4 +237,24 @@ describe('useTransactionBridgeQuotes', () => {
       expect(result.current.quotes).toStrictEqual([QUOTE_MOCK, QUOTE_MOCK]);
     },
   );
+
+  it('refreshes quotes', async () => {
+    runHook();
+
+    await act(async () => {
+      // Intentionally empty
+    });
+
+    await act(async () => {
+      await jest.advanceTimersByTimeAsync(29000);
+    });
+
+    expect(getBridgeQuotesMock).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      await jest.advanceTimersByTimeAsync(2000);
+    });
+
+    expect(getBridgeQuotesMock).toHaveBeenCalledTimes(2);
+  });
 });
diff --git a/app/components/Views/confirmations/hooks/pay/useTransactionBridgeQuotes.ts b/app/components/Views/confirmations/hooks/pay/useTransactionBridgeQuotes.ts
index ed5b13cce82..bc233a6ef2c 100644
--- a/app/components/Views/confirmations/hooks/pay/useTransactionBridgeQuotes.ts
+++ b/app/components/Views/confirmations/hooks/pay/useTransactionBridgeQuotes.ts
@@ -1,7 +1,7 @@
 import { useTransactionPayTokenAmounts } from './useTransactionPayTokenAmounts';
 import { useAsyncResult } from '../../../../hooks/useAsyncResult';
 import { BridgeQuoteRequest, getBridgeQuotes } from '../../utils/bridge';
-import { useEffect } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { useTransactionPayToken } from './useTransactionPayToken';
 import { useDispatch, useSelector } from 'react-redux';
 import {
@@ -14,6 +14,11 @@ import { useDeepMemo } from '../useDeepMemo';
 import { useAlerts } from '../../context/alert-system-context';
 import { AlertKeys } from '../../constants/alerts';
 import { selectMetaMaskPayFlags } from '../../../../../selectors/featureFlagController/confirmations';
+import {
+  getQuoteRefreshRate,
+  isQuoteExpired,
+} from '../../../../UI/Bridge/utils/quoteUtils';
+import { selectBridgeFeatureFlags } from '../../../../../core/redux/slices/bridge';
 
 const EXCLUDED_ALERTS = [
   AlertKeys.NoPayTokenQuotes,
@@ -26,14 +31,43 @@ export function useTransactionBridgeQuotes() {
   const dispatch = useDispatch();
   const transactionMeta = useTransactionMetadataOrThrow();
   const { alerts } = useAlerts();
+  const { payToken } = useTransactionPayToken() ?? {};
+  const { amounts: sourceAmounts } = useTransactionPayTokenAmounts({
+    log: true,
+  });
+  const bridgeFeatureFlags = useSelector(selectBridgeFeatureFlags);
+  const refreshRate = getQuoteRefreshRate(bridgeFeatureFlags);
+  const [lastFetched, setLastFetched] = useState(0);
+  const interval = useRef<NodeJS.Timer>();
+  const isExpired = useRef(false);
+  const [refreshIndex, setRefreshIndex] = useState(0);
 
-  const {
-    attemptsMax,
-    bufferInitial,
-    bufferStep,
-    slippageInitial,
-    slippageSubsequent,
-  } = useSelector(selectMetaMaskPayFlags);
+  useEffect(() => {
+    if (interval.current) {
+      clearInterval(interval.current as unknown as number);
+    }
+
+    interval.current = setInterval(() => {
+      if (
+        !isExpired.current &&
+        lastFetched &&
+        isQuoteExpired(false, refreshRate, lastFetched)
+      ) {
+        log('Quote expired', { refreshRate, lastFetched });
+        isExpired.current = true;
+        setRefreshIndex((index) => index + 1);
+      }
+    }, 1000);
+
+    return () => {
+      if (interval.current) {
+        clearInterval(interval.current as unknown as number);
+      }
+    };
+  }, [isExpired, lastFetched, refreshRate]);
+
+  const { attemptsMax, bufferInitial, bufferStep, bufferSubsequent, slippage } =
+    useSelector(selectMetaMaskPayFlags);
 
   const hasBlockingAlert = alerts.some(
     (a) => a.isBlocking && !EXCLUDED_ALERTS.includes(a.key as AlertKeys),
@@ -45,9 +79,6 @@ export function useTransactionBridgeQuotes() {
     txParams: { from },
   } = transactionMeta;
 
-  const { payToken } = useTransactionPayToken() ?? {};
-  const { amounts: sourceAmounts } = useTransactionPayTokenAmounts();
-
   const {
     address: sourceTokenAddress,
     balanceRaw,
@@ -77,9 +108,9 @@ export function useTransactionBridgeQuotes() {
         attemptsMax,
         bufferInitial,
         bufferStep,
+        bufferSubsequent,
         from: from as Hex,
-        slippageInitial,
-        slippageSubsequent,
+        slippage,
         sourceBalanceRaw,
         sourceChainId,
         sourceTokenAddress,
@@ -95,8 +126,7 @@ export function useTransactionBridgeQuotes() {
     bufferStep,
     from,
     hasBlockingAlert,
-    slippageInitial,
-    slippageSubsequent,
+    slippage,
     sourceAmounts,
     sourceBalanceRaw,
     sourceChainId,
@@ -110,7 +140,7 @@ export function useTransactionBridgeQuotes() {
     }
 
     return getBridgeQuotes(requests);
-  }, [requests]);
+  }, [requests, refreshIndex]);
 
   useEffect(() => {
     dispatch(
@@ -121,6 +151,11 @@ export function useTransactionBridgeQuotes() {
   useEffect(() => {
     dispatch(setTransactionBridgeQuotes({ transactionId, quotes }));
 
+    if (quotes?.length) {
+      isExpired.current = false;
+      setLastFetched(Date.now());
+    }
+
     log(
       'Bridge quotes',
       quotes?.map((quote) => ({
diff --git a/app/components/Views/confirmations/hooks/pay/useTransactionPayTokenAmounts.ts b/app/components/Views/confirmations/hooks/pay/useTransactionPayTokenAmounts.ts
index 53332cf3b5a..432c6ab2c31 100644
--- a/app/components/Views/confirmations/hooks/pay/useTransactionPayTokenAmounts.ts
+++ b/app/components/Views/confirmations/hooks/pay/useTransactionPayTokenAmounts.ts
@@ -5,19 +5,23 @@ import { useTokenFiatRates } from '../tokens/useTokenFiatRates';
 import { useTransactionRequiredFiat } from './useTransactionRequiredFiat';
 import { Hex, createProjectLogger } from '@metamask/utils';
 import { useDeepMemo } from '../useDeepMemo';
+import { noop } from 'lodash';
 
-const log = createProjectLogger('transaction-pay');
+const logger = createProjectLogger('transaction-pay');
 
 /**
  * Calculate the amount of the selected pay token, that is needed for each token required by the transaction.
  */
 export function useTransactionPayTokenAmounts({
   amountOverrides,
+  log: isLoggingEnabled,
 }: {
   amountOverrides?: Record<Hex, string>;
+  log?: boolean;
 } = {}) {
   const { payToken } = useTransactionPayToken();
   const { address, chainId, decimals } = payToken ?? {};
+  const log = isLoggingEnabled ? logger : noop;
 
   const fiatRequests = useMemo(() => {
     if (!address || !chainId) {
@@ -50,6 +54,7 @@ export function useTransactionPayTokenAmounts({
 
     return values
       .filter((value) => {
+        const { address: currentAddress } = value;
         const hasBalance = value.balanceFiat > value.amountFiat;
 
         const isSameTokenSelected =
@@ -57,7 +62,7 @@ export function useTransactionPayTokenAmounts({
 
         const hasOtherTokenWithoutBalance = values.some(
           (v) =>
-            v.address.toLowerCase() !== address.toLowerCase() &&
+            v.address.toLowerCase() !== currentAddress.toLowerCase() &&
             v.balanceFiat < v.amountFiat,
         );
 
@@ -121,7 +126,7 @@ export function useTransactionPayTokenAmounts({
       totalHuman,
       totalRaw,
     });
-  }, [amounts, totalHuman, totalRaw]);
+  }, [amounts, log, totalHuman, totalRaw]);
 
   return {
     amounts,
diff --git a/app/components/Views/confirmations/hooks/pay/useTransactionRequiredFiat.test.ts b/app/components/Views/confirmations/hooks/pay/useTransactionRequiredFiat.test.ts
index 3ab3c74c724..80bcbf187c6 100644
--- a/app/components/Views/confirmations/hooks/pay/useTransactionRequiredFiat.test.ts
+++ b/app/components/Views/confirmations/hooks/pay/useTransactionRequiredFiat.test.ts
@@ -85,16 +85,16 @@ describe('useTransactionRequiredFiat', () => {
         amountFiat: 15,
         amountRaw: '3000',
         balanceFiat: 100,
-        feeFiat: 0.375,
+        feeFiat: 0.75,
         skipIfBalance: true,
-        totalFiat: 15.375,
+        totalFiat: 15.75,
       },
     ]);
   });
 
   it('returns total fiat value', () => {
     const { totalFiat } = runHook();
-    expect(totalFiat).toBe(23.575);
+    expect(totalFiat).toBe(23.95);
   });
 
   it('supports amount overrides', () => {
@@ -119,9 +119,9 @@ describe('useTransactionRequiredFiat', () => {
         amountFiat: 15,
         amountRaw: '3000',
         balanceFiat: 100,
-        feeFiat: 0.375,
+        feeFiat: 0.75,
         skipIfBalance: true,
-        totalFiat: 15.375,
+        totalFiat: 15.75,
       },
     ]);
   });
diff --git a/app/components/Views/confirmations/hooks/pay/useTransactionRequiredFiat.ts b/app/components/Views/confirmations/hooks/pay/useTransactionRequiredFiat.ts
index 0388bbce4e1..115e6d0817a 100644
--- a/app/components/Views/confirmations/hooks/pay/useTransactionRequiredFiat.ts
+++ b/app/components/Views/confirmations/hooks/pay/useTransactionRequiredFiat.ts
@@ -25,8 +25,10 @@ export interface TransactionRequiredFiat {
  */
 export function useTransactionRequiredFiat({
   amountOverrides,
+  log: isLoggingEnabled,
 }: {
   amountOverrides?: Record<Hex, string>;
+  log?: boolean;
 } = {}): {
   values: TransactionRequiredFiat[];
   totalFiat: number;
@@ -34,7 +36,10 @@ export function useTransactionRequiredFiat({
   const transactionMeta = useTransactionMetadataOrThrow();
   const { chainId } = transactionMeta;
   const requiredTokens = useTransactionRequiredTokens();
-  const { bufferInitial } = useSelector(selectMetaMaskPayFlags);
+
+  const { bufferInitial, bufferSubsequent } = useSelector(
+    selectMetaMaskPayFlags,
+  );
 
   const fiatRequests = useMemo(
     () =>
@@ -61,7 +66,9 @@ export function useTransactionRequiredFiat({
           targetFiatRate,
         );
 
-        const feeFiat = amountFiat.multipliedBy(bufferInitial);
+        const feeFiat = amountFiat.multipliedBy(
+          index === 0 ? bufferInitial : bufferSubsequent,
+        );
 
         const balanceFiat = new BigNumber(target.balanceHuman).multipliedBy(
           targetFiatRate,
@@ -79,7 +86,13 @@ export function useTransactionRequiredFiat({
           skipIfBalance: target.skipIfBalance,
         };
       }),
-    [amountOverrides, bufferInitial, requiredTokens, tokenFiatRates],
+    [
+      amountOverrides,
+      bufferInitial,
+      bufferSubsequent,
+      requiredTokens,
+      tokenFiatRates,
+    ],
   );
 
   const totalFiat = values.reduce<number>(
@@ -88,10 +101,12 @@ export function useTransactionRequiredFiat({
   );
 
   useEffect(() => {
+    if (!isLoggingEnabled) return;
+
     log('Required fiat', values, {
       totalFiat,
     });
-  }, [values, totalFiat]);
+  }, [isLoggingEnabled, totalFiat, values]);
 
   return {
     values,
diff --git a/app/components/Views/confirmations/hooks/pay/useTransactionRequiredTokens.ts b/app/components/Views/confirmations/hooks/pay/useTransactionRequiredTokens.ts
index 369954fc4bb..2a868cc8bb5 100644
--- a/app/components/Views/confirmations/hooks/pay/useTransactionRequiredTokens.ts
+++ b/app/components/Views/confirmations/hooks/pay/useTransactionRequiredTokens.ts
@@ -28,7 +28,9 @@ export interface TransactionToken {
  * Determine what tokens are required by the transaction.
  * Necessary for MetaMask Pay to generate suitable bridge or swap transactions.
  */
-export function useTransactionRequiredTokens() {
+export function useTransactionRequiredTokens({
+  log: isLoggingEnabled,
+}: { log?: boolean } = {}): TransactionToken[] {
   const transactionMeta = useTransactionMetadataOrThrow();
   const { chainId } = transactionMeta;
 
@@ -41,8 +43,9 @@ export function useTransactionRequiredTokens() {
   );
 
   useEffect(() => {
+    if (!isLoggingEnabled) return;
     log('Required tokens', result);
-  }, [result]);
+  }, [isLoggingEnabled, result]);
 
   return result;
 }
diff --git a/app/components/Views/confirmations/hooks/pay/useTransactionTotalFiat.ts b/app/components/Views/confirmations/hooks/pay/useTransactionTotalFiat.ts
index 2937b92a630..ce25598e3af 100644
--- a/app/components/Views/confirmations/hooks/pay/useTransactionTotalFiat.ts
+++ b/app/components/Views/confirmations/hooks/pay/useTransactionTotalFiat.ts
@@ -11,12 +11,18 @@ import useFiatFormatter from '../../../../UI/SimulationDetails/FiatDisplay/useFi
 import { TransactionBridgeQuote } from '../../utils/bridge';
 import { useFeeCalculations } from '../gas/useFeeCalculations';
 import { useDeepMemo } from '../useDeepMemo';
+import { useEffect } from 'react';
+import { createProjectLogger } from '@metamask/utils';
+
+const log = createProjectLogger('transaction-pay');
 
 type TransactionBridgeQuoteExtended = TransactionBridgeQuote & {
   requiredFiat: number;
 };
 
-export function useTransactionTotalFiat() {
+export function useTransactionTotalFiat({
+  log: isLoggingEnabled,
+}: { log?: boolean } = {}) {
   const fiatFormatter = useFiatFormatter();
   const { values } = useTransactionRequiredFiat();
   const transactionMeta = useTransactionMetadataOrThrow();
@@ -50,7 +56,14 @@ export function useTransactionTotalFiat() {
     ...getTotal(quotes, values, estimatedFeeFiatPrecise, fiatFormatter),
   };
 
-  return useDeepMemo(() => result, [result]);
+  const stableResult = useDeepMemo(() => result, [result]);
+
+  useEffect(() => {
+    if (!isLoggingEnabled) return;
+    log('Transaction total fiat', stableResult);
+  }, [isLoggingEnabled, stableResult]);
+
+  return stableResult;
 }
 
 function getTotal(
@@ -60,11 +73,7 @@ function getTotal(
   format: (value: BigNumber) => string,
 ) {
   const balanceTotal = requiredFiat
-    .filter(
-      (token) =>
-        !token.skipIfBalance ||
-        new BigNumber(token.balanceFiat).isLessThan(token.amountFiat),
-    )
+    .filter((token) => !token.skipIfBalance)
     .reduce(
       (acc, token) => acc.plus(new BigNumber(token.amountFiat)),
       new BigNumber(0),
diff --git a/app/components/Views/confirmations/hooks/send/useCurrencyConversions.test.ts b/app/components/Views/confirmations/hooks/send/useCurrencyConversions.test.ts
index 92f97167b25..859e394e501 100644
--- a/app/components/Views/confirmations/hooks/send/useCurrencyConversions.test.ts
+++ b/app/components/Views/confirmations/hooks/send/useCurrencyConversions.test.ts
@@ -31,7 +31,7 @@ describe('getFiatValueFn', () => {
         amount: '10',
         decimals: 2,
       }),
-    ).toStrictEqual(38905.56);
+    ).toStrictEqual('38905.56');
   });
 
   it('return 0 if input is empty string', () => {
@@ -42,7 +42,7 @@ describe('getFiatValueFn', () => {
         amount: '',
         decimals: 2,
       }),
-    ).toStrictEqual(0);
+    ).toStrictEqual('0');
   });
 
   it('use conversionRate 1 if conversionRate is not passed', () => {
@@ -53,7 +53,7 @@ describe('getFiatValueFn', () => {
         amount: '10',
         decimals: 2,
       }),
-    ).toStrictEqual(38905.56);
+    ).toStrictEqual('38905.56');
   });
 });
 
diff --git a/app/components/Views/confirmations/hooks/send/useCurrencyConversions.ts b/app/components/Views/confirmations/hooks/send/useCurrencyConversions.ts
index d6be1c8ba3b..95ba29f51a2 100644
--- a/app/components/Views/confirmations/hooks/send/useCurrencyConversions.ts
+++ b/app/components/Views/confirmations/hooks/send/useCurrencyConversions.ts
@@ -4,11 +4,7 @@ import { useCallback, useMemo } from 'react';
 import { useSelector } from 'react-redux';
 
 import { RootState } from '../../../../../reducers';
-import {
-  balanceToFiatNumber,
-  getCurrencySymbol,
-  limitToMaximumDecimalPlaces,
-} from '../../../../../util/number';
+import { getCurrencySymbol, isDecimal } from '../../../../../util/number';
 import { selectContractExchangeRatesByChainId } from '../../../../../selectors/tokenRatesController';
 import {
   selectConversionRateByChainId,
@@ -17,6 +13,7 @@ import {
 import { selectMultichainAssetsRates } from '../../../../../selectors/multichain';
 import { AssetType } from '../../types/token';
 import { useSendContext } from '../../context/send-context';
+import { convertCurrency } from '../../utils/send';
 
 interface ConversionArgs {
   amount?: string;
@@ -32,8 +29,18 @@ export const getFiatValueFn = ({
   conversionRate,
   decimals,
   exchangeRate,
-}: ConversionArgs) =>
-  balanceToFiatNumber(amount ?? 0, conversionRate ?? 1, exchangeRate, decimals);
+}: ConversionArgs) => {
+  if (!amount || !isDecimal(amount)) {
+    return '0';
+  }
+
+  return convertCurrency(
+    amount ?? '0',
+    (conversionRate ?? 1) * (exchangeRate ?? 1),
+    decimals,
+    2,
+  ).toString();
+};
 
 export const getFiatDisplayValueFn = ({
   amount,
@@ -47,7 +54,7 @@ export const getFiatDisplayValueFn = ({
         exchangeRate,
         amount: amount ?? '0',
         decimals: 2,
-      }).toFixed(2)
+      })
     : '0.00';
   return `${getCurrencySymbol(currentCurrency)} ${amt}`;
 };
@@ -58,10 +65,16 @@ export const getNativeValueFn = ({
   decimals,
   exchangeRate,
 }: ConversionArgs) => {
-  let amt = amount ? parseFloat(amount) : 0;
-  amt = Number.isNaN(amt) ? 0 : amt;
-  const nativeValue = amt / ((conversionRate ?? 1) * exchangeRate);
-  return limitToMaximumDecimalPlaces(nativeValue, decimals ?? 0);
+  if (!amount || !isDecimal(amount)) {
+    return '0';
+  }
+
+  return convertCurrency(
+    amount ?? '0',
+    1 / ((conversionRate ?? 1) * (exchangeRate ?? 1)),
+    2,
+    decimals,
+  ).toString();
 };
 
 export const getNativeDisplayValueFn = ({
@@ -70,7 +83,7 @@ export const getNativeDisplayValueFn = ({
   conversionRate,
   exchangeRate,
 }: ConversionArgs) =>
-  `${asset?.symbol} ${getNativeValueFn({
+  `${asset?.ticker ?? asset?.symbol} ${getNativeValueFn({
     conversionRate,
     exchangeRate,
     amount: amount ?? '0',
@@ -138,9 +151,10 @@ export const useCurrencyConversions = () => {
       getFiatValueFn({
         conversionRate,
         exchangeRate,
+        decimals: (asset as AssetType)?.decimals,
         amount,
       }),
-    [conversionRate, exchangeRate],
+    [asset, conversionRate, exchangeRate],
   );
 
   const getNativeValue = useCallback(
@@ -149,8 +163,9 @@ export const useCurrencyConversions = () => {
         conversionRate,
         exchangeRate,
         amount,
+        decimals: (asset as AssetType)?.decimals,
       }),
-    [conversionRate, exchangeRate],
+    [asset, conversionRate, exchangeRate],
   );
 
   return {
diff --git a/app/components/Views/confirmations/utils/bridge.test.ts b/app/components/Views/confirmations/utils/bridge.test.ts
index ed86f6c0747..0b641c15749 100644
--- a/app/components/Views/confirmations/utils/bridge.test.ts
+++ b/app/components/Views/confirmations/utils/bridge.test.ts
@@ -10,10 +10,12 @@ import {
   BridgeQuoteRequest,
   TransactionBridgeQuote,
   getBridgeQuotes,
+  refreshQuote,
 } from './bridge';
 import { selectBridgeQuotes } from '../../../../core/redux/slices/bridge';
 import { selectShouldUseSmartTransaction } from '../../../../selectors/smartTransactionsController';
 import { GasFeeController } from '@metamask/gas-fee-controller';
+import { cloneDeep } from 'lodash';
 
 jest.mock('../../../../core/Engine');
 jest.mock('../../../../core/redux/slices/bridge');
@@ -25,9 +27,9 @@ const QUOTE_REQUEST_1_MOCK: BridgeQuoteRequest = {
   attemptsMax: 1,
   bufferInitial: 1,
   bufferStep: 1,
+  bufferSubsequent: 2,
   from: '0x123',
-  slippageInitial: 0.005,
-  slippageSubsequent: 0.02,
+  slippage: 0.005,
   sourceBalanceRaw: '10000000000000000000',
   sourceChainId: '0x1',
   sourceTokenAddress: '0xabc',
@@ -127,7 +129,10 @@ describe('Confirmations Bridge Utils', () => {
 
       const quotes = await quotesPromise;
 
-      expect(quotes).toStrictEqual([QUOTE_1_MOCK, QUOTE_2_MOCK]);
+      expect(quotes).toStrictEqual([
+        expect.objectContaining(QUOTE_1_MOCK),
+        expect.objectContaining(QUOTE_2_MOCK),
+      ]);
     });
 
     it('requests quotes', async () => {
@@ -141,10 +146,10 @@ describe('Confirmations Bridge Utils', () => {
           srcTokenAmount: QUOTE_REQUEST_1_MOCK.sourceTokenAmount,
           destChainId: QUOTE_REQUEST_1_MOCK.targetChainId,
           destTokenAddress: QUOTE_REQUEST_1_MOCK.targetTokenAddress,
-          slippage: QUOTE_REQUEST_1_MOCK.slippageInitial,
+          slippage: 0.5,
           insufficientBal: false,
         }),
-        expect.any(Object),
+        undefined,
         FeatureId.PERPS,
       );
 
@@ -156,10 +161,10 @@ describe('Confirmations Bridge Utils', () => {
           srcTokenAmount: QUOTE_REQUEST_2_MOCK.sourceTokenAmount,
           destChainId: QUOTE_REQUEST_2_MOCK.targetChainId,
           destTokenAddress: QUOTE_REQUEST_2_MOCK.targetTokenAddress,
-          slippage: QUOTE_REQUEST_2_MOCK.slippageSubsequent,
+          slippage: 0.5,
           insufficientBal: false,
         }),
-        expect.any(Object),
+        undefined,
         FeatureId.PERPS,
       );
     });
@@ -220,7 +225,7 @@ describe('Confirmations Bridge Utils', () => {
 
       const quotes = await getBridgeQuotes([QUOTE_REQUEST_1_MOCK]);
 
-      expect(quotes).toStrictEqual([QUOTES[2]]);
+      expect(quotes).toStrictEqual([expect.objectContaining(QUOTES[2])]);
     });
 
     it('ignores quote if token amount if less than minimum', async () => {
@@ -267,7 +272,7 @@ describe('Confirmations Bridge Utils', () => {
 
       const quotes = await getBridgeQuotes([QUOTE_REQUEST_1_MOCK]);
 
-      expect(quotes).toStrictEqual([QUOTES[1]]);
+      expect(quotes).toStrictEqual([expect.objectContaining(QUOTES[1])]);
     });
 
     it('returns undefined if all fastest quotes have token amount less than minimum', async () => {
@@ -346,21 +351,23 @@ describe('Confirmations Bridge Utils', () => {
         { ...QUOTE_REQUEST_1_MOCK, attemptsMax: 2 },
       ]);
 
-      expect(quotes).toStrictEqual([QUOTES_ATTEMPT_2[0]]);
+      expect(quotes).toStrictEqual([
+        expect.objectContaining(QUOTES_ATTEMPT_2[0]),
+      ]);
 
       expect(bridgeControllerMock.fetchQuotes).toHaveBeenCalledTimes(2);
       expect(bridgeControllerMock.fetchQuotes).toHaveBeenCalledWith(
         expect.objectContaining({
           srcTokenAmount: '1000000000000000000',
         }),
-        expect.any(Object),
+        undefined,
         expect.any(String),
       );
       expect(bridgeControllerMock.fetchQuotes).toHaveBeenCalledWith(
         expect.objectContaining({
           srcTokenAmount: '1500000000000000000',
         }),
-        expect.any(Object),
+        undefined,
         expect.any(String),
       );
     });
@@ -480,21 +487,23 @@ describe('Confirmations Bridge Utils', () => {
         },
       ]);
 
-      expect(quotes).toStrictEqual([QUOTES_ATTEMPT_2[0]]);
+      expect(quotes).toStrictEqual([
+        expect.objectContaining(QUOTES_ATTEMPT_2[0]),
+      ]);
 
       expect(bridgeControllerMock.fetchQuotes).toHaveBeenCalledTimes(2);
       expect(bridgeControllerMock.fetchQuotes).toHaveBeenCalledWith(
         expect.objectContaining({
           srcTokenAmount: '1000000000000000000',
         }),
-        expect.any(Object),
+        undefined,
         expect.any(String),
       );
       expect(bridgeControllerMock.fetchQuotes).toHaveBeenCalledWith(
         expect.objectContaining({
           srcTokenAmount: '1400000000000000000',
         }),
-        expect.any(Object),
+        undefined,
         expect.any(String),
       );
     });
@@ -544,7 +553,7 @@ describe('Confirmations Bridge Utils', () => {
         expect.objectContaining({
           srcTokenAmount: '1000000000000000000',
         }),
-        expect.any(Object),
+        undefined,
         expect.any(String),
       );
 
@@ -553,7 +562,7 @@ describe('Confirmations Bridge Utils', () => {
         expect.objectContaining({
           srcTokenAmount: '1000000000000000000',
         }),
-        expect.any(Object),
+        undefined,
         expect.any(String),
       );
     });
@@ -605,7 +614,10 @@ describe('Confirmations Bridge Utils', () => {
         },
       ]);
 
-      expect(quotes).toStrictEqual([QUOTES_ATTEMPT_2[0], QUOTES_ATTEMPT_3[0]]);
+      expect(quotes).toStrictEqual([
+        expect.objectContaining(QUOTES_ATTEMPT_2[0]),
+        expect.objectContaining(QUOTES_ATTEMPT_3[0]),
+      ]);
 
       expect(bridgeControllerMock.fetchQuotes).toHaveBeenCalledTimes(3);
 
@@ -615,7 +627,7 @@ describe('Confirmations Bridge Utils', () => {
           srcTokenAmount: '1000000000000000000',
           destTokenAddress: QUOTE_REQUEST_1_MOCK.targetTokenAddress,
         }),
-        expect.any(Object),
+        undefined,
         expect.any(String),
       );
 
@@ -625,7 +637,7 @@ describe('Confirmations Bridge Utils', () => {
           srcTokenAmount: '1000000000000000000',
           destTokenAddress: QUOTE_REQUEST_2_MOCK.targetTokenAddress,
         }),
-        expect.any(Object),
+        undefined,
         expect.any(String),
       );
 
@@ -635,9 +647,47 @@ describe('Confirmations Bridge Utils', () => {
           srcTokenAmount: '1400000000000000000',
           destTokenAddress: QUOTE_REQUEST_1_MOCK.targetTokenAddress,
         }),
-        expect.any(Object),
+        undefined,
         expect.any(String),
       );
     });
   });
+
+  describe('refreshQuote', () => {
+    it('returns new quote', async () => {
+      bridgeControllerMock.fetchQuotes.mockReset();
+      bridgeControllerMock.fetchQuotes.mockResolvedValue([QUOTE_2_MOCK]);
+
+      const result = await refreshQuote({
+        ...QUOTE_1_MOCK,
+        request: QUOTE_REQUEST_1_MOCK,
+      } as TransactionBridgeQuote);
+
+      expect(result).toStrictEqual(expect.objectContaining(QUOTE_2_MOCK));
+    });
+
+    it('requests new quote', async () => {
+      await refreshQuote({
+        ...QUOTE_1_MOCK,
+        request: QUOTE_REQUEST_1_MOCK,
+      } as TransactionBridgeQuote);
+
+      expect(bridgeControllerMock.fetchQuotes).toHaveBeenCalledTimes(1);
+    });
+
+    it('throws if new quote under minimum', async () => {
+      const quote = cloneDeep(QUOTE_1_MOCK);
+      quote.quote.minDestTokenAmount = '122';
+
+      bridgeControllerMock.fetchQuotes.mockReset();
+      bridgeControllerMock.fetchQuotes.mockResolvedValue([quote]);
+
+      await expect(
+        refreshQuote({
+          ...QUOTE_1_MOCK,
+          request: QUOTE_REQUEST_1_MOCK,
+        } as TransactionBridgeQuote),
+      ).rejects.toThrow('All quotes under minimum');
+    });
+  });
 });
diff --git a/app/components/Views/confirmations/utils/bridge.ts b/app/components/Views/confirmations/utils/bridge.ts
index 19ed6b253bf..83beb34f2a1 100644
--- a/app/components/Views/confirmations/utils/bridge.ts
+++ b/app/components/Views/confirmations/utils/bridge.ts
@@ -16,19 +16,18 @@ import { BigNumber } from 'bignumber.js';
 const ERROR_MESSAGE_NO_QUOTES = 'No quotes found';
 const ERROR_MESSAGE_ALL_QUOTES_UNDER_MINIMUM = 'All quotes under minimum';
 
-export type TransactionBridgeQuote = QuoteResponse & QuoteMetadata;
+export type TransactionBridgeQuote = QuoteResponse &
+  QuoteMetadata & { request: BridgeQuoteRequest };
 
 const log = createProjectLogger('confirmation-bridge-utils');
 
-let abort: AbortController;
-
 export interface BridgeQuoteRequest {
   attemptsMax: number;
   bufferInitial: number;
   bufferStep: number;
+  bufferSubsequent: number;
   from: Hex;
-  slippageInitial: number;
-  slippageSubsequent: number;
+  slippage: number;
   sourceBalanceRaw: string;
   sourceChainId: Hex;
   sourceTokenAddress: Hex;
@@ -43,9 +42,6 @@ export async function getBridgeQuotes(
 ): Promise<TransactionBridgeQuote[] | undefined> {
   log('Fetching bridge quotes', requests);
 
-  abort?.abort();
-  abort = new AbortController();
-
   if (!requests?.length) {
     return [];
   }
@@ -70,6 +66,17 @@ export async function getBridgeQuotes(
   }
 }
 
+export async function refreshQuote(
+  quote: TransactionBridgeQuote,
+): Promise<TransactionBridgeQuote> {
+  const gasFeeEstimates = await getGasFeeEstimates(quote.request.sourceChainId);
+  const newQuote = await getSingleBridgeQuote(quote.request, gasFeeEstimates);
+
+  log('Refreshed bridge quote', { old: quote, new: newQuote });
+
+  return newQuote;
+}
+
 async function getSufficientSingleBridgeQuote(
   request: BridgeQuoteRequest,
   gasFeeEstimates: GasFeeEstimates,
@@ -79,13 +86,15 @@ async function getSufficientSingleBridgeQuote(
     attemptsMax,
     bufferInitial,
     bufferStep,
+    bufferSubsequent,
     sourceBalanceRaw,
     sourceTokenAmount,
     targetTokenAddress,
   } = request;
 
   const sourceAmountValue = new BigNumber(sourceTokenAmount);
-  const originalSourceAmount = sourceAmountValue.div(1 + bufferInitial);
+  const buffer = index === 0 ? bufferInitial : bufferSubsequent;
+  const originalSourceAmount = sourceAmountValue.div(1 + buffer);
 
   let currentSourceAmount = sourceTokenAmount;
 
@@ -108,7 +117,6 @@ async function getSufficientSingleBridgeQuote(
       const result = await getSingleBridgeQuote(
         currentRequest,
         gasFeeEstimates,
-        index,
       );
 
       const dust = new BigNumber(result.quote.minDestTokenAmount)
@@ -143,7 +151,7 @@ async function getSufficientSingleBridgeQuote(
     }
 
     const newSourceAmount = originalSourceAmount.multipliedBy(
-      1 + bufferInitial + bufferStep * (i + 1),
+      1 + buffer + bufferStep * (i + 1),
     );
 
     currentSourceAmount = newSourceAmount.isLessThan(sourceBalanceRaw)
@@ -159,12 +167,10 @@ async function getSufficientSingleBridgeQuote(
 async function getSingleBridgeQuote(
   request: BridgeQuoteRequest,
   gasFeeEstimates: GasFeeEstimates,
-  index: number,
 ): Promise<TransactionBridgeQuote> {
   const {
     from,
-    slippageInitial,
-    slippageSubsequent,
+    slippage,
     sourceChainId,
     sourceTokenAddress,
     sourceTokenAmount,
@@ -181,7 +187,7 @@ async function getSingleBridgeQuote(
     gasIncluded: false,
     gasless7702: false,
     insufficientBal: false,
-    slippage: index === 0 ? slippageInitial : slippageSubsequent,
+    slippage: slippage * 100,
     srcChainId: sourceChainId,
     srcTokenAddress: toChecksumAddress(sourceTokenAddress),
     srcTokenAmount: sourceTokenAmount,
@@ -190,7 +196,7 @@ async function getSingleBridgeQuote(
 
   const quotes = await BridgeController.fetchQuotes(
     quoteRequest,
-    abort.signal,
+    undefined,
     FeatureId.PERPS,
   );
 
@@ -251,7 +257,7 @@ async function getGasFeeEstimates(chainId: Hex) {
 }
 
 function getBestQuote(
-  quotes: TransactionBridgeQuote[],
+  quotes: (QuoteResponse & QuoteMetadata)[],
   request: BridgeQuoteRequest,
 ): TransactionBridgeQuote {
   const fastestQuotes = orderBy(
@@ -270,11 +276,16 @@ function getBestQuote(
     throw new Error(ERROR_MESSAGE_ALL_QUOTES_UNDER_MINIMUM);
   }
 
-  return orderBy(
+  const match = orderBy(
     quotesOverMinimumTarget,
     (quote) => BigNumber(quote.cost?.valueInCurrency ?? 0).toNumber(),
     'asc',
   )[0];
+
+  return {
+    ...match,
+    request,
+  };
 }
 
 function getFinalRequests(
diff --git a/app/components/Views/confirmations/utils/send.test.ts b/app/components/Views/confirmations/utils/send.test.ts
index 9fbfa5a41b7..7d7c7ab5af5 100644
--- a/app/components/Views/confirmations/utils/send.test.ts
+++ b/app/components/Views/confirmations/utils/send.test.ts
@@ -9,6 +9,7 @@ import * as EngineNetworkUtils from '../../../../util/networks/engineNetworkUtil
 import { AssetType, TokenStandard } from '../types/token';
 import { InitSendLocation } from '../constants/send';
 import {
+  convertCurrency,
   formatToFixedDecimals,
   fromBNWithDecimals,
   fromHexWithDecimals,
@@ -283,3 +284,11 @@ describe('getLayer1GasFeeForSend', () => {
     expect(mockGetLayer1GasFee).toHaveBeenCalled();
   });
 });
+
+describe('convertCurrency', () => {
+  it('apply conversion rate to passed value', () => {
+    expect(convertCurrency('120.75', 0.5, 4, 2)).toEqual('60.37');
+    expect(convertCurrency('120.75', 0.25, 4, 4)).toEqual('30.1875');
+    expect(convertCurrency('0.01', 10, 4, 0)).toEqual('0');
+  });
+});
diff --git a/app/components/Views/confirmations/utils/send.ts b/app/components/Views/confirmations/utils/send.ts
index 7816819b195..c4a6f81639b 100644
--- a/app/components/Views/confirmations/utils/send.ts
+++ b/app/components/Views/confirmations/utils/send.ts
@@ -133,7 +133,11 @@ export const submitEvmTransaction = async ({
   });
 };
 
-export function formatToFixedDecimals(value: string, decimalsToShow = 5) {
+export function formatToFixedDecimals(
+  value: string,
+  decimalsToShow = 5,
+  formatSmallValue = true,
+) {
   if (value) {
     const decimals = decimalsToShow < 5 ? decimalsToShow : 5;
     const result = String(value).replace(/^-/, '').split('.');
@@ -150,7 +154,7 @@ export function formatToFixedDecimals(value: string, decimalsToShow = 5) {
       fracPart = fracPart.padEnd(decimals, '0');
     }
 
-    if (new BN(`${intPart}${fracPart}`).lt(new BN(1))) {
+    if (formatSmallValue && new BN(`${intPart}${fracPart}`).lt(new BN(1))) {
       return `< ${1 / Math.pow(10, decimals)}`;
     }
 
@@ -220,3 +224,32 @@ export const getLayer1GasFeeForSend = async ({
     chainId,
   })) as Hex | undefined;
 };
+
+export const convertCurrency = (
+  value: string,
+  conversionRate: number,
+  decimals?: number,
+  targetDecimals?: number,
+) => {
+  let sourceDecimalValue = parseInt(decimals?.toString() ?? '0', 10);
+  const targetDecimalValue = parseInt(targetDecimals?.toString() ?? '0', 10);
+
+  const conversionRateDecimals = (
+    conversionRate?.toString().replace(/^-/, '').split('.')[1] ?? ''
+  ).length;
+
+  const convertedValueBN = toBNWithDecimals(value, sourceDecimalValue);
+  const conversionRateBN = toBNWithDecimals(
+    conversionRate.toString(),
+    conversionRateDecimals,
+  );
+  sourceDecimalValue += conversionRateDecimals;
+
+  const convertedValue = convertedValueBN.mul(conversionRateBN);
+
+  return formatToFixedDecimals(
+    fromBNWithDecimals(convertedValue, sourceDecimalValue),
+    targetDecimalValue,
+    false,
+  );
+};
diff --git a/app/core/Engine/controllers/perps-controller/index.ts b/app/core/Engine/controllers/perps-controller/index.ts
index 002a0dd34a2..f2614916230 100644
--- a/app/core/Engine/controllers/perps-controller/index.ts
+++ b/app/core/Engine/controllers/perps-controller/index.ts
@@ -4,6 +4,7 @@ import {
   PerpsControllerMessenger,
   getDefaultPerpsControllerState,
 } from '../../../../components/UI/Perps/controllers';
+import { applyE2EControllerMocks } from '../../../../components/UI/Perps/utils/e2eBridgePerps';
 
 /**
  * Initialize the PerpsController.
@@ -28,5 +29,8 @@ export const perpsControllerInit: ControllerInitFunction<
     },
   });
 
+  // Apply E2E mocks if configured via bridge
+  applyE2EControllerMocks(controller);
+
   return { controller };
 };
diff --git a/app/core/SDKConnectV2/adapters/host-application-adapter.test.ts b/app/core/SDKConnectV2/adapters/host-application-adapter.test.ts
index c1d9d480443..f5db112b544 100644
--- a/app/core/SDKConnectV2/adapters/host-application-adapter.test.ts
+++ b/app/core/SDKConnectV2/adapters/host-application-adapter.test.ts
@@ -18,6 +18,7 @@ describe('HostApplicationAdapter', () => {
     ).resolves.not.toThrow();
     expect(() => adapter.showLoading()).not.toThrow();
     expect(() => adapter.hideLoading()).not.toThrow();
+    expect(() => adapter.showAlert()).not.toThrow();
     expect(adapter.showOTPModal()).resolves.not.toThrow();
     expect(() => adapter.syncConnectionList([])).not.toThrow();
   });
diff --git a/app/core/SDKConnectV2/adapters/host-application-adapter.ts b/app/core/SDKConnectV2/adapters/host-application-adapter.ts
index 046d6bbb0da..59f13870ff2 100644
--- a/app/core/SDKConnectV2/adapters/host-application-adapter.ts
+++ b/app/core/SDKConnectV2/adapters/host-application-adapter.ts
@@ -1,11 +1,11 @@
-import { Connection } from '../types/connection';
-import { DappMetadata } from '../types/dapp-metadata';
+import { Connection } from '../services/connection';
 import { IHostApplicationAdapter } from '../types/host-application-adapter';
+import { Metadata } from '../types/metadata';
 
 export class HostApplicationAdapter implements IHostApplicationAdapter {
   showConnectionApproval(
     _connectionId: string,
-    _dappMetadata: DappMetadata,
+    _dappMetadata: Metadata['dapp'],
   ): Promise<void> {
     console.warn(
       '[SDKConnectV2] HostApplicationAdapter.showConnectionApproval called but is not yet implemented.',
@@ -25,6 +25,12 @@ export class HostApplicationAdapter implements IHostApplicationAdapter {
     );
   }
 
+  showAlert(): void {
+    console.warn(
+      '[SDKConnectV2] HostApplicationAdapter.showAlert called but is not yet implemented.',
+    );
+  }
+
   showOTPModal(): Promise<void> {
     console.warn(
       '[SDKConnectV2] HostApplicationAdapter.showOTPModal called but is not yet implemented.',
diff --git a/app/core/SDKConnectV2/index.ts b/app/core/SDKConnectV2/index.ts
index 14552dafa48..8359eea1b71 100644
--- a/app/core/SDKConnectV2/index.ts
+++ b/app/core/SDKConnectV2/index.ts
@@ -1,9 +1,12 @@
 import { HostApplicationAdapter } from './adapters/host-application-adapter';
 import { ConnectionStore } from './store/connection-store';
 import { ConnectionRegistry } from './services/connection-registry';
+import { KeyManager } from './services/key-manager';
 
+const relayURL = 'wss://mm-sdk-relay.api.cx.metamask.io/connection/websocket';
+const keymanager = new KeyManager();
 const hostapp = new HostApplicationAdapter();
-const store = new ConnectionStore();
-const registry = new ConnectionRegistry(hostapp, store);
+const store = new ConnectionStore('sdk-connect-v2/connections');
+const registry = new ConnectionRegistry(relayURL, keymanager, hostapp, store);
 
 export default registry;
diff --git a/app/core/SDKConnectV2/services/connection-registry.test.ts b/app/core/SDKConnectV2/services/connection-registry.test.ts
index 49b9ff6e0ed..2da8eadc166 100644
--- a/app/core/SDKConnectV2/services/connection-registry.test.ts
+++ b/app/core/SDKConnectV2/services/connection-registry.test.ts
@@ -1,18 +1,207 @@
 import { ConnectionRegistry } from './connection-registry';
 import { HostApplicationAdapter } from '../adapters/host-application-adapter';
 import { ConnectionStore } from '../store/connection-store';
+import { KeyManager } from './key-manager';
+import { Connection } from './connection';
+import { ConnectionRequest } from '../types/connection-request';
+
+jest.mock('../adapters/host-application-adapter');
+jest.mock('../store/connection-store');
+jest.mock('./key-manager');
+jest.mock('./connection');
+
+// A valid, sample connection request payload for use in tests
+const mockConnectionRequest: ConnectionRequest = {
+  sessionRequest: {
+    id: 'test-conn-id',
+    dappPublicKey: 'dapp_pub_key',
+    walletPublicKey: 'wallet_pub_key',
+    channel: 'websocket-channel-id',
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } as any,
+  metadata: {
+    dapp: {
+      name: 'Test DApp',
+      url: 'https://test.dapp',
+    },
+    sdk: {
+      version: '2.0.0',
+      platform: 'JavaScript',
+    },
+  },
+};
+
+// A valid deeplink URL containing the encoded connection request
+const validDeeplink = `metamask://connect/mwp?p=${encodeURIComponent(
+  JSON.stringify(mockConnectionRequest),
+)}`;
 
 describe('ConnectionRegistry', () => {
   let registry: ConnectionRegistry;
+  let mockHostApp: jest.Mocked<HostApplicationAdapter>;
+  let mockStore: jest.Mocked<ConnectionStore>;
+  let mockKeyManager: jest.Mocked<KeyManager>;
+  let mockConnection: jest.Mocked<Connection>;
+
+  const RELAY_URL = 'wss://test-relay.example.com';
 
   beforeEach(() => {
-    const hostapp = new HostApplicationAdapter();
-    const store = new ConnectionStore();
-    registry = new ConnectionRegistry(hostapp, store);
+    jest.clearAllMocks();
+
+    mockHostApp =
+      new HostApplicationAdapter() as jest.Mocked<HostApplicationAdapter>;
+    mockStore = new ConnectionStore(
+      'test-prefix',
+    ) as jest.Mocked<ConnectionStore>;
+    mockKeyManager = new KeyManager() as jest.Mocked<KeyManager>;
+
+    mockConnection = {
+      id: mockConnectionRequest.sessionRequest.id,
+      metadata: mockConnectionRequest.metadata,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      client: {} as any,
+      connect: jest.fn().mockResolvedValue(undefined),
+      disconnect: jest.fn().mockResolvedValue(undefined),
+      resume: jest.fn().mockResolvedValue(undefined),
+    } as unknown as jest.Mocked<Connection>;
+
+    (Connection.create as jest.Mock).mockResolvedValue(mockConnection);
+
+    registry = new ConnectionRegistry(
+      RELAY_URL,
+      mockKeyManager,
+      mockHostApp,
+      mockStore,
+    );
   });
 
-  it('dummy tests for scaffolding, will be replaced with real tests', () => {
-    expect(registry).toBeDefined();
-    expect(() => registry.handleConnectDeeplink('test-deeplink')).not.toThrow();
+  describe('handleConnectDeeplink', () => {
+    it('should successfully handle the full connection happy path', async () => {
+      await registry.handleConnectDeeplink(validDeeplink);
+
+      // UI loading state is properly managed
+      expect(mockHostApp.showLoading).toHaveBeenCalledTimes(1);
+
+      // Connection is created and established with correct parameters
+      expect(Connection.create).toHaveBeenCalledWith(
+        mockConnectionRequest,
+        mockKeyManager,
+        RELAY_URL,
+      );
+      expect(mockConnection.connect).toHaveBeenCalledWith(
+        mockConnectionRequest.sessionRequest,
+      );
+
+      // Connection data is persisted to storage
+      expect(mockStore.save).toHaveBeenCalledWith({
+        id: mockConnection.id,
+        metadata: mockConnection.metadata,
+      });
+
+      // UI is synchronized with the new connection
+      expect(mockHostApp.syncConnectionList).toHaveBeenCalledWith([
+        mockConnection,
+      ]);
+      expect(mockHostApp.hideLoading).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle invalid URL gracefully', async () => {
+      const invalidDeeplink = 'invalid-url';
+      await registry.handleConnectDeeplink(invalidDeeplink);
+
+      // Error alert is shown
+      expect(mockHostApp.showAlert).toHaveBeenCalledWith(
+        'Connection Error',
+        'The connection request failed. Please try again.',
+      );
+
+      // Nothing else happens
+      expect(mockHostApp.showLoading).not.toHaveBeenCalled();
+      expect(Connection.create).not.toHaveBeenCalled();
+      expect(mockStore.save).not.toHaveBeenCalled();
+      expect(mockHostApp.syncConnectionList).not.toHaveBeenCalled();
+      expect(mockHostApp.hideLoading).toHaveBeenCalledTimes(1);
+    });
+
+    it('should call hideLoading and not save anything if the URL is invalid', async () => {
+      const invalidDeeplink = 'metamask://connect/mwp?p=not-json';
+
+      await registry.handleConnectDeeplink(invalidDeeplink);
+
+      // Error alert is shown
+      expect(mockHostApp.showAlert).toHaveBeenCalledWith(
+        'Connection Error',
+        'The connection request failed. Please try again.',
+      );
+
+      // Nothing else happens
+      expect(mockHostApp.showLoading).not.toHaveBeenCalled();
+      expect(Connection.create).not.toHaveBeenCalled();
+
+      // No data is persisted or UI updates made for invalid requests
+      expect(mockConnection.disconnect).not.toHaveBeenCalled();
+      expect(mockStore.save).not.toHaveBeenCalled();
+      expect(mockHostApp.syncConnectionList).not.toHaveBeenCalled();
+      expect(mockHostApp.hideLoading).toHaveBeenCalledTimes(1);
+    });
+
+    it('should attempt to disconnect and hide loading if the connect method fails', async () => {
+      const connectionError = new Error('Connection failed');
+      mockConnection.connect.mockRejectedValue(connectionError);
+
+      const disconnectSpy = jest.spyOn(registry, 'disconnect');
+
+      await registry.handleConnectDeeplink(validDeeplink);
+
+      // Connection creation is attempted but fails during handshake
+      expect(mockHostApp.showAlert).toHaveBeenCalledWith(
+        'Connection Error',
+        'The connection request failed. Please try again.',
+      );
+
+      // Nothing else happens
+      expect(mockHostApp.showLoading).toHaveBeenCalledTimes(1);
+      expect(Connection.create).toHaveBeenCalledTimes(1);
+      expect(mockConnection.connect).toHaveBeenCalledTimes(1);
+
+      // Failed connection is cleaned up properly
+      expect(disconnectSpy).toHaveBeenCalledWith(mockConnection.id);
+      expect(mockStore.delete).toHaveBeenCalledWith(mockConnection.id);
+      expect(mockHostApp.syncConnectionList).toHaveBeenCalledWith([]);
+
+      expect(mockHostApp.hideLoading).toHaveBeenCalledTimes(1);
+
+      disconnectSpy.mockRestore();
+    });
+  });
+
+  describe('disconnect', () => {
+    it('should handle a non-existent connection', async () => {
+      await registry.disconnect('non-existent-id');
+
+      // Gracefully handles cleanup for non-existent connections
+      expect(mockStore.delete).toHaveBeenCalledWith('non-existent-id');
+      expect(mockHostApp.syncConnectionList).toHaveBeenCalledWith([]);
+    });
+
+    it('should disconnect a session, delete it from the store, and update the UI', async () => {
+      // Given: an established connection
+      await registry.handleConnectDeeplink(validDeeplink);
+
+      jest.clearAllMocks();
+
+      // When: disconnecting the connection
+      await registry.disconnect(mockConnection.id);
+
+      // Then: connection is properly terminated
+      expect(mockConnection.disconnect).toHaveBeenCalledTimes(1);
+
+      // Connection data is removed from storage
+      expect(mockStore.delete).toHaveBeenCalledWith(mockConnection.id);
+
+      // UI reflects the disconnection
+      expect(mockHostApp.syncConnectionList).toHaveBeenCalledWith([]);
+      expect(mockHostApp.syncConnectionList).toHaveBeenCalledTimes(1);
+    });
   });
 });
diff --git a/app/core/SDKConnectV2/services/connection-registry.ts b/app/core/SDKConnectV2/services/connection-registry.ts
index f7719f806f7..6dace971b04 100644
--- a/app/core/SDKConnectV2/services/connection-registry.ts
+++ b/app/core/SDKConnectV2/services/connection-registry.ts
@@ -1,44 +1,121 @@
-import { IHostApplicationAdapter } from '../types/host-application-adapter';
+import { IKeyManager } from '@metamask/mobile-wallet-protocol-core';
+import {
+  ConnectionRequest,
+  isConnectionRequest,
+} from '../types/connection-request';
 import { IConnectionStore } from '../types/connection-store';
+import { IHostApplicationAdapter } from '../types/host-application-adapter';
+import { Connection } from './connection';
 
 /**
  * The ConnectionRegistry is the central service responsible for managing the
- * lifecycle of all SDKConnectV2 connections. It acts as the primary entry
- * point and orchestrator for creating, managing, and tearing down secure
- * dApp sessions.
+ * lifecycle of all SDKConnectV2 connections.
  */
 export class ConnectionRegistry {
+  private readonly RELAY_URL: string;
+  private readonly keymanager: IKeyManager;
   private readonly hostapp: IHostApplicationAdapter;
   private readonly store: IConnectionStore;
 
+  private connections = new Map<string, Connection>();
+
+  constructor(
+    relayURL: string,
+    keymanager: IKeyManager,
+    hostapp: IHostApplicationAdapter,
+    store: IConnectionStore,
+  ) {
+    this.RELAY_URL = relayURL;
+    this.keymanager = keymanager;
+    this.hostapp = hostapp;
+    this.store = store;
+  }
+
   /**
-   * The constructor for the ConnectionRegistry.
+   * The primary entry point for handling a new connection from a deeplink.
+   * @param url The full deeplink URL that triggered the connection.
    *
-   * @param hostapp - An adapter that provides a bridge to the
-   * host MetaMask Mobile application's UI and state management systems.
-   * @param store - An adapter for the persistence layer, used to
-   * save and retrieve connection data.
+   * Happy path:
+   * 1. Show loading indicator
+   * 2. Parse the connection request
+   * 3. Create a new connection and connect
+   * 4. Save the connection to the store
+   * 5. Sync the connection list to the host application
+   * 6. Hide loading indicator
    */
-  constructor(hostapp: IHostApplicationAdapter, store: IConnectionStore) {
-    this.hostapp = hostapp;
-    this.store = store;
+  public async handleConnectDeeplink(url: string): Promise<void> {
+    let conn: Connection | undefined;
+
+    try {
+      const connreq = this.parseConnectionRequest(url);
+      this.hostapp.showLoading();
+      conn = await Connection.create(connreq, this.keymanager, this.RELAY_URL);
+      await conn.connect(connreq.sessionRequest);
+      this.connections.set(conn.id, conn);
+      await this.store.save({ id: conn.id, metadata: connreq.metadata });
+      this.hostapp.syncConnectionList(Array.from(this.connections.values()));
+      console.warn(
+        `[SDKConnectV2] Connection with ${connreq.metadata.dapp.name} successfully established.`,
+      );
+    } catch (error) {
+      console.error('[SDKConnectV2] Connection handshake failed:', error);
+      if (conn) await this.disconnect(conn.id);
+      this.hostapp.showAlert(
+        'Connection Error',
+        'The connection request failed. Please try again.',
+      );
+    } finally {
+      this.hostapp.hideLoading();
+    }
   }
 
   /**
-   * The primary entry point for handling a new connection request from a
-   * v2 deeplink (e.g., from a QR code).
-   * @param url - The full deeplink URL that triggered the connection.
+   * Disconnects a session and cleans up all associated data.
+   * @param id The ID of the connection to terminate.
    */
-  public handleConnectDeeplink(url: string): void {
-    console.warn(
-      '[SDKConnectV2] ConnectionRegistry: handleConnectDeeplink successfully called with URL:',
-      url,
-    );
-
-    // In future, this method will be responsible for:
-    // 1. Parsing the URL to extract the ConnectionRequest.
-    // 2. Calling the hostapp to show the connection approval UI.
-    // 3. Initiating the cryptographic handshake upon user approval.
-    // 4. Saving the resulting connection to the store.
+  public async disconnect(id: string): Promise<void> {
+    await this.connections.get(id)?.disconnect();
+    await this.store.delete(id);
+    this.connections.delete(id);
+    this.hostapp.syncConnectionList(Array.from(this.connections.values()));
+  }
+
+  /**
+   * Parse the connection request from the deeplink URL.
+   * @param url The full deeplink URL that triggered the connection.
+   * @returns The parsed connection request.
+   *
+   * Format: metamask://connect/mwp?p=<encoded_connection_request>
+   */
+  private parseConnectionRequest(url: string): ConnectionRequest {
+    let parsed: URL;
+
+    try {
+      parsed = new URL(url);
+    } catch (error) {
+      throw new Error('[SDKConnectV2] Invalid URL format.');
+    }
+
+    const payload = parsed.searchParams.get('p');
+    if (!payload) {
+      throw new Error('[SDKConnectV2] No payload found in URL.');
+    }
+
+    if (payload.length > 1024 * 1024) {
+      throw new Error('[SDKConnectV2] Payload too large (max 1MB).');
+    }
+
+    let connreq: unknown;
+    try {
+      connreq = JSON.parse(payload);
+    } catch (error) {
+      throw new Error('[SDKConnectV2] Invalid JSON in payload.');
+    }
+
+    if (!isConnectionRequest(connreq)) {
+      throw new Error('[SDKConnectV2] Invalid connection request structure.');
+    }
+
+    return connreq;
   }
 }
diff --git a/app/core/SDKConnectV2/services/connection.test.ts b/app/core/SDKConnectV2/services/connection.test.ts
new file mode 100644
index 00000000000..52220390a39
--- /dev/null
+++ b/app/core/SDKConnectV2/services/connection.test.ts
@@ -0,0 +1,128 @@
+import { Connection } from './connection';
+import { ConnectionRequest } from '../types/connection-request';
+import { KeyManager } from './key-manager';
+import {
+  WalletClient,
+  SessionRequest,
+} from '@metamask/mobile-wallet-protocol-wallet-client';
+import {
+  WebSocketTransport,
+  SessionStore,
+} from '@metamask/mobile-wallet-protocol-core';
+import { KVStore } from '../store/kv-store';
+
+jest.mock('@metamask/mobile-wallet-protocol-wallet-client');
+jest.mock('@metamask/mobile-wallet-protocol-core', () => ({
+  ...jest.requireActual('@metamask/mobile-wallet-protocol-core'),
+  WebSocketTransport: {
+    create: jest.fn(),
+  },
+  SessionStore: jest.fn(),
+}));
+jest.mock('../store/kv-store');
+
+const MockedWalletClient = WalletClient as jest.MockedClass<
+  typeof WalletClient
+>;
+const MockedWebSocketTransport = WebSocketTransport as jest.Mocked<
+  typeof WebSocketTransport
+>;
+
+describe('Connection', () => {
+  let mockKeyManager: KeyManager;
+  let mockWalletClientInstance: jest.Mocked<WalletClient>;
+
+  const RELAY_URL = 'wss://test-relay.example.com';
+  const mockConnectionRequest: ConnectionRequest = {
+    sessionRequest: {
+      id: 'test-session-id',
+      dappPublicKey: 'dapp_pub_key',
+      walletPublicKey: 'wallet_pub_key',
+      channel: 'channel-id',
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any,
+    metadata: {
+      dapp: { name: 'Test DApp', url: 'https://test.dapp' },
+      sdk: { version: '1.0.0', platform: 'JavaScript' },
+    },
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockKeyManager = new KeyManager();
+    mockWalletClientInstance = new MockedWalletClient({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      transport: {} as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      sessionstore: {} as any,
+      keymanager: mockKeyManager,
+    }) as jest.Mocked<WalletClient>;
+
+    MockedWalletClient.mockImplementation(
+      () => mockWalletClientInstance as WalletClient,
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (MockedWebSocketTransport.create as jest.Mock).mockResolvedValue({} as any);
+  });
+
+  describe('create', () => {
+    it('should correctly initialize dependencies and create a Connection instance', async () => {
+      const connection = await Connection.create(
+        mockConnectionRequest,
+        mockKeyManager,
+        RELAY_URL,
+      );
+
+      expect(WebSocketTransport.create).toHaveBeenCalledWith({
+        url: RELAY_URL,
+        kvstore: expect.any(KVStore),
+      });
+      expect(SessionStore).toHaveBeenCalledWith(expect.any(KVStore));
+      expect(WalletClient).toHaveBeenCalledWith({
+        transport: expect.anything(),
+        sessionstore: expect.anything(),
+        keymanager: mockKeyManager,
+      });
+
+      expect(connection).toBeInstanceOf(Connection);
+      expect(connection.id).toBe(mockConnectionRequest.sessionRequest.id);
+      expect(connection.metadata).toBe(mockConnectionRequest.metadata);
+      expect(connection.client).toBe(mockWalletClientInstance);
+    });
+  });
+
+  describe('connect', () => {
+    it('should call connect on its WalletClient with the sessionRequest', async () => {
+      const connection = await Connection.create(
+        mockConnectionRequest,
+        mockKeyManager,
+        RELAY_URL,
+      );
+      const sessionRequest: SessionRequest =
+        mockConnectionRequest.sessionRequest;
+
+      await connection.connect(sessionRequest);
+
+      expect(mockWalletClientInstance.connect).toHaveBeenCalledTimes(1);
+      expect(mockWalletClientInstance.connect).toHaveBeenCalledWith({
+        sessionRequest,
+      });
+    });
+  });
+
+  describe('disconnect', () => {
+    it('should call disconnect on its WalletClient and remove the message listener', async () => {
+      const connection = await Connection.create(
+        mockConnectionRequest,
+        mockKeyManager,
+        RELAY_URL,
+      );
+
+      await connection.disconnect();
+
+      expect(mockWalletClientInstance.disconnect).toHaveBeenCalledTimes(1);
+    });
+  });
+});
diff --git a/app/core/SDKConnectV2/services/connection.ts b/app/core/SDKConnectV2/services/connection.ts
new file mode 100644
index 00000000000..133e8efdf73
--- /dev/null
+++ b/app/core/SDKConnectV2/services/connection.ts
@@ -0,0 +1,74 @@
+import {
+  SessionRequest,
+  WalletClient,
+} from '@metamask/mobile-wallet-protocol-wallet-client';
+import {
+  IKeyManager,
+  SessionStore,
+  WebSocketTransport,
+} from '@metamask/mobile-wallet-protocol-core';
+import { ConnectionRequest } from '../types/connection-request';
+import { KVStore } from '../store/kv-store';
+import { Metadata } from '../types/metadata';
+
+/**
+ * Connection is a live, runtime representation of a dApp connection.
+ */
+export class Connection {
+  public readonly id: string;
+  public readonly metadata: Metadata;
+  public readonly client: WalletClient;
+
+  private constructor(id: string, metadata: Metadata, client: WalletClient) {
+    this.id = id;
+    this.metadata = metadata;
+    this.client = client;
+
+    this.client.on('message', (payload) => {
+      console.warn(`[Connection:${this.id}] Received message:`, payload); // To be implemented in a future PR.
+    });
+  }
+
+  /**
+   * Creates a new connection.
+   * @param connreq - The connection request.
+   * @param keymanager - The key manager.
+   * @param relayURL - The relay URL.
+   * @returns The created connection.
+   */
+  public static async create(
+    connreq: ConnectionRequest,
+    keymanager: IKeyManager,
+    relayURL: string,
+  ): Promise<Connection> {
+    const id = connreq.sessionRequest.id;
+    const metadata = connreq.metadata;
+    const transport = await WebSocketTransport.create({
+      url: relayURL,
+      kvstore: new KVStore(`mwp/transport/${id}`),
+    });
+    const sessionstore = new SessionStore(
+      new KVStore(`mwp/session-store/${id}`),
+    );
+    const client = new WalletClient({ transport, sessionstore, keymanager });
+
+    return new Connection(id, metadata, client);
+  }
+
+  /**
+   * Connects the connection to the dApp.
+   * @param sessionRequest - The session request.
+   */
+  public async connect(sessionRequest: SessionRequest): Promise<void> {
+    await this.client.connect({ sessionRequest });
+    console.warn(`[Connection:${this.id}] Connected to dApp.`);
+  }
+
+  /**
+   * Disconnects the connection from the dApp.
+   */
+  public async disconnect(): Promise<void> {
+    await this.client.disconnect();
+    console.warn(`[Connection:${this.id}] Disconnected.`);
+  }
+}
diff --git a/app/core/SDKConnectV2/services/key-manager.test.ts b/app/core/SDKConnectV2/services/key-manager.test.ts
new file mode 100644
index 00000000000..ced1e9675e3
--- /dev/null
+++ b/app/core/SDKConnectV2/services/key-manager.test.ts
@@ -0,0 +1,42 @@
+import { KeyManager } from './key-manager';
+
+describe('KeyManager', () => {
+  let keyManager: KeyManager;
+
+  beforeEach(() => {
+    keyManager = new KeyManager();
+  });
+
+  it('should generate a valid key pair', () => {
+    const keyPair = keyManager.generateKeyPair();
+
+    expect(keyPair.privateKey).toBeInstanceOf(Uint8Array);
+    expect(keyPair.publicKey).toBeInstanceOf(Uint8Array);
+    expect(keyPair.privateKey.length).toBe(32);
+    expect(keyPair.publicKey.length).toBe(33); // Compressed public key
+  });
+
+  it('should encrypt and decrypt a message successfully', async () => {
+    const keyPair = keyManager.generateKeyPair();
+    const originalMessage = 'This is a secret message.';
+
+    // Test encrypt method
+    const encryptedMessage = await keyManager.encrypt(
+      originalMessage,
+      keyPair.publicKey,
+    );
+
+    // Verify encryption produces a base64 string
+    expect(encryptedMessage).toBeTruthy();
+    expect(typeof encryptedMessage).toBe('string');
+
+    // Test decrypt method
+    const decryptedMessage = await keyManager.decrypt(
+      encryptedMessage,
+      keyPair.privateKey,
+    );
+
+    // Verify the round-trip encryption/decryption
+    expect(decryptedMessage).toBe(originalMessage);
+  });
+});
diff --git a/app/core/SDKConnectV2/services/key-manager.ts b/app/core/SDKConnectV2/services/key-manager.ts
new file mode 100644
index 00000000000..db9a0650ba9
--- /dev/null
+++ b/app/core/SDKConnectV2/services/key-manager.ts
@@ -0,0 +1,32 @@
+import { IKeyManager, KeyPair } from '@metamask/mobile-wallet-protocol-core';
+import { PrivateKey, encrypt, decrypt } from 'eciesjs';
+
+export class KeyManager implements IKeyManager {
+  generateKeyPair(): KeyPair {
+    const privateKey = new PrivateKey();
+    return {
+      privateKey: Uint8Array.from(privateKey.secret),
+      publicKey: Uint8Array.from(privateKey.publicKey.compressed),
+    };
+  }
+
+  async encrypt(
+    plaintext: string,
+    theirPublicKey: Uint8Array,
+  ): Promise<string> {
+    const plaintextBuffer = Buffer.from(plaintext, 'utf8');
+    const theirPublicKeyBuffer = Buffer.from(theirPublicKey);
+    const encryptedBuffer = encrypt(theirPublicKeyBuffer, plaintextBuffer);
+    return encryptedBuffer.toString('base64');
+  }
+
+  async decrypt(
+    encryptedB64: string,
+    myPrivateKey: Uint8Array,
+  ): Promise<string> {
+    const encryptedBuffer = Buffer.from(encryptedB64, 'base64');
+    const myPrivateKeyBuffer = Buffer.from(myPrivateKey);
+    const decryptedBuffer = decrypt(myPrivateKeyBuffer, encryptedBuffer);
+    return decryptedBuffer.toString('utf8');
+  }
+}
diff --git a/app/core/SDKConnectV2/store/connection-store.test.ts b/app/core/SDKConnectV2/store/connection-store.test.ts
index 2764294e4d7..0f543eefa86 100644
--- a/app/core/SDKConnectV2/store/connection-store.test.ts
+++ b/app/core/SDKConnectV2/store/connection-store.test.ts
@@ -1,18 +1,145 @@
 import { ConnectionStore } from './connection-store';
-import { Connection } from '../types/connection';
+import { PersistedConnection } from '../types/persisted-connection';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import StorageWrapper from '../../../store/storage-wrapper';
+
+jest.mock('@react-native-async-storage/async-storage');
+jest.mock('../../../store/storage-wrapper', () => ({
+  __esModule: true,
+  default: {
+    getItem: jest.fn(),
+    setItem: jest.fn(),
+    removeItem: jest.fn(),
+  },
+}));
 
 describe('ConnectionStore', () => {
   let store: ConnectionStore;
 
   beforeEach(() => {
-    store = new ConnectionStore();
+    jest.clearAllMocks();
+    store = new ConnectionStore('test-prefix');
   });
 
-  it('dummy tests for scaffolding, will be replaced with real tests', () => {
+  it('should create an instance with a properly formatted prefix', () => {
     expect(store).toBeDefined();
-    expect(store.save({} as Connection)).resolves.not.toThrow();
-    expect(store.get('test-id')).resolves.toBeNull();
-    expect(store.list()).resolves.toEqual([]);
-    expect(store.delete('test-id')).resolves.not.toThrow();
+    const storeWithSlash = new ConnectionStore('prefix/');
+    expect(storeWithSlash).toBeDefined();
+  });
+
+  it('should save a connection', async () => {
+    const connection: PersistedConnection = {
+      id: 'test-id',
+      metadata: {
+        dapp: {
+          name: 'Test DApp',
+          url: 'https://example.com',
+          icon: 'https://example.com/icon.png',
+        },
+        sdk: {
+          version: '1.0.0',
+          platform: 'ios',
+        },
+      },
+    };
+
+    await store.save(connection);
+
+    expect(StorageWrapper.setItem).toHaveBeenCalledWith(
+      'test-prefix/test-id',
+      JSON.stringify(connection),
+    );
+  });
+
+  it('should get a connection by id', async () => {
+    const connection: PersistedConnection = {
+      id: 'test-id',
+      metadata: {
+        dapp: {
+          name: 'Test DApp',
+          url: 'https://example.com',
+          icon: 'https://example.com/icon.png',
+        },
+        sdk: {
+          version: '1.0.0',
+          platform: 'ios',
+        },
+      },
+    };
+
+    (StorageWrapper.getItem as jest.Mock).mockResolvedValueOnce(
+      JSON.stringify(connection),
+    );
+
+    const result = await store.get('test-id');
+
+    expect(StorageWrapper.getItem).toHaveBeenCalledWith('test-prefix/test-id');
+    expect(result).toEqual(connection);
+  });
+
+  it('should return null when connection not found', async () => {
+    (StorageWrapper.getItem as jest.Mock).mockResolvedValueOnce(null);
+    const result = await store.get('non-existent');
+
+    expect(StorageWrapper.getItem).toHaveBeenCalledWith(
+      'test-prefix/non-existent',
+    );
+    expect(result).toBeNull();
+  });
+
+  it('should list all connections', async () => {
+    const connections: PersistedConnection[] = [
+      {
+        id: 'id1',
+        metadata: {
+          dapp: { name: 'DApp 1', url: 'https://dapp1.com' },
+          sdk: { version: '1.0.0', platform: 'ios' },
+        },
+      },
+      {
+        id: 'id2',
+        metadata: {
+          dapp: { name: 'DApp 2', url: 'https://dapp2.com' },
+          sdk: { version: '1.0.0', platform: 'ios' },
+        },
+      },
+    ];
+
+    (AsyncStorage.getAllKeys as jest.Mock).mockResolvedValueOnce([
+      'test-prefix/id1',
+      'test-prefix/id2',
+      'other-prefix/id3',
+    ]);
+
+    (AsyncStorage.multiGet as jest.Mock).mockResolvedValueOnce([
+      ['test-prefix/id1', JSON.stringify(connections[0])],
+      ['test-prefix/id2', JSON.stringify(connections[1])],
+    ]);
+
+    const result = await store.list();
+
+    expect(AsyncStorage.getAllKeys).toHaveBeenCalled();
+    expect(AsyncStorage.multiGet).toHaveBeenCalledWith([
+      'test-prefix/id1',
+      'test-prefix/id2',
+    ]);
+    expect(result).toEqual(connections);
+  });
+
+  it('should return empty array when no connections exist', async () => {
+    (AsyncStorage.getAllKeys as jest.Mock).mockResolvedValueOnce([]);
+
+    const result = await store.list();
+
+    expect(result).toEqual([]);
+    expect(AsyncStorage.multiGet).not.toHaveBeenCalled();
+  });
+
+  it('should delete a connection', async () => {
+    await store.delete('test-id');
+
+    expect(StorageWrapper.removeItem).toHaveBeenCalledWith(
+      'test-prefix/test-id',
+    );
   });
 });
diff --git a/app/core/SDKConnectV2/store/connection-store.ts b/app/core/SDKConnectV2/store/connection-store.ts
index c4bbd2d3250..23c90462d5a 100644
--- a/app/core/SDKConnectV2/store/connection-store.ts
+++ b/app/core/SDKConnectV2/store/connection-store.ts
@@ -1,38 +1,56 @@
-import { Connection } from '../types/connection';
 import { IConnectionStore } from '../types/connection-store';
+import { PersistedConnection } from '../types/persisted-connection';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import StorageWrapper from '../../../store/storage-wrapper';
 
 /**
- * Placeholder implementation of the IConnectionStore.
- * For now, this class provides no-op implementations of the
- * required storage methods to satisfy the dependency requirements
- * of the ConnectionRegistry.
+ * An implementation of IConnectionStore to persist
+ * the metadata of established dApp connections.
+ * Uses StorageWrapper for better performance, with fallback to AsyncStorage
+ * for batch operations (getAllKeys, multiGet) that aren't available in StorageWrapper.
  */
 export class ConnectionStore implements IConnectionStore {
-  save(_connection: Connection): Promise<void> {
-    console.warn(
-      '[SDKConnectV2] ConnectionStore.save called but is not yet implemented.',
-    );
-    return Promise.resolve();
+  private readonly prefix: string;
+
+  constructor(prefix: string) {
+    this.prefix = prefix;
   }
 
-  get(_id: string): Promise<Connection | null> {
-    console.warn(
-      '[SDKConnectV2] ConnectionStore.get called but is not yet implemented.',
-    );
-    return Promise.resolve(null);
+  private getKey(id: string): string {
+    return `${this.prefix}/${id}`;
   }
 
-  list(): Promise<Connection[]> {
-    console.warn(
-      '[SDKConnectV2] ConnectionStore.list called but is not yet implemented.',
+  async save(connection: PersistedConnection): Promise<void> {
+    await StorageWrapper.setItem(
+      this.getKey(connection.id),
+      JSON.stringify(connection),
     );
-    return Promise.resolve([]);
   }
 
-  delete(_id: string): Promise<void> {
-    console.warn(
-      '[SDKConnectV2] ConnectionStore.delete called but is not yet implemented.',
-    );
-    return Promise.resolve();
+  async get(id: string): Promise<PersistedConnection | null> {
+    const json = await StorageWrapper.getItem(this.getKey(id));
+    return json ? (JSON.parse(json) as PersistedConnection) : null;
+  }
+
+  async list(): Promise<PersistedConnection[]> {
+    const keys = await AsyncStorage.getAllKeys();
+    const connectionKeys = keys.filter((key) => key.startsWith(this.prefix));
+
+    if (connectionKeys.length === 0) {
+      return [];
+    }
+
+    const items = await AsyncStorage.multiGet(connectionKeys);
+    return items.reduce((acc, item) => {
+      // item is a [key, value] tuple
+      if (item[1]) {
+        acc.push(JSON.parse(item[1]) as PersistedConnection);
+      }
+      return acc;
+    }, [] as PersistedConnection[]);
+  }
+
+  async delete(id: string): Promise<void> {
+    await StorageWrapper.removeItem(this.getKey(id));
   }
 }
diff --git a/app/core/SDKConnectV2/store/kv-store.test.ts b/app/core/SDKConnectV2/store/kv-store.test.ts
new file mode 100644
index 00000000000..71fc8d5b28f
--- /dev/null
+++ b/app/core/SDKConnectV2/store/kv-store.test.ts
@@ -0,0 +1,66 @@
+import { KVStore } from './kv-store';
+import StorageWrapper from '../../../store/storage-wrapper';
+
+jest.mock('../../../store/storage-wrapper', () => ({
+  __esModule: true,
+  default: {
+    getItem: jest.fn(),
+    setItem: jest.fn(),
+    removeItem: jest.fn(),
+  },
+}));
+
+describe('KVStore', () => {
+  let store: KVStore;
+  const TEST_PREFIX = 'test-kv-prefix/';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    store = new KVStore(TEST_PREFIX);
+  });
+
+  it('should correctly prefix the key when setting an item', async () => {
+    const key = 'my-key';
+    const value = 'my-value';
+    const expectedPrefixedKey = `${TEST_PREFIX}${key}`;
+
+    await store.set(key, value);
+
+    expect(StorageWrapper.setItem).toHaveBeenCalledTimes(1);
+    expect(StorageWrapper.setItem).toHaveBeenCalledWith(
+      expectedPrefixedKey,
+      value,
+    );
+  });
+
+  it('should correctly prefix the key when getting an item', async () => {
+    const key = 'my-key';
+    const expectedValue = 'retrieved-value';
+    const expectedPrefixedKey = `${TEST_PREFIX}${key}`;
+
+    (StorageWrapper.getItem as jest.Mock).mockResolvedValueOnce(expectedValue);
+
+    const result = await store.get(key);
+
+    expect(StorageWrapper.getItem).toHaveBeenCalledTimes(1);
+    expect(StorageWrapper.getItem).toHaveBeenCalledWith(expectedPrefixedKey);
+    expect(result).toBe(expectedValue);
+  });
+
+  it('should return null if the item does not exist', async () => {
+    const key = 'non-existent-key';
+    (StorageWrapper.getItem as jest.Mock).mockResolvedValueOnce(null);
+    const result = await store.get(key);
+    expect(result).toBeNull();
+  });
+
+  it('should correctly prefix the key when deleting an item', async () => {
+    const key = 'my-k	ey-to-delete';
+    const expectedPrefixedKey = `${TEST_PREFIX}${key}`;
+
+    await store.delete(key);
+
+    expect(StorageWrapper.removeItem).toHaveBeenCalledTimes(1);
+    expect(StorageWrapper.removeItem).toHaveBeenCalledWith(expectedPrefixedKey);
+  });
+});
diff --git a/app/core/SDKConnectV2/store/kv-store.ts b/app/core/SDKConnectV2/store/kv-store.ts
new file mode 100644
index 00000000000..84116943c7d
--- /dev/null
+++ b/app/core/SDKConnectV2/store/kv-store.ts
@@ -0,0 +1,30 @@
+import { IKVStore } from '@metamask/mobile-wallet-protocol-core';
+import StorageWrapper from '../../../store/storage-wrapper';
+
+/**
+ * An implementation of the IKVStore interface that uses StorageWrapper
+ * for persistent key-value storage.
+ */
+export class KVStore implements IKVStore {
+  private readonly prefix: string;
+
+  constructor(prefix: string) {
+    this.prefix = prefix;
+  }
+
+  private getKey(key: string): string {
+    return this.prefix + key;
+  }
+
+  async get(key: string): Promise<string | null> {
+    return StorageWrapper.getItem(this.getKey(key));
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    await StorageWrapper.setItem(this.getKey(key), value);
+  }
+
+  async delete(key: string): Promise<void> {
+    await StorageWrapper.removeItem(this.getKey(key));
+  }
+}
diff --git a/app/core/SDKConnectV2/types/connection-request.ts b/app/core/SDKConnectV2/types/connection-request.ts
index 01b330e6cda..48e4c7347ee 100644
--- a/app/core/SDKConnectV2/types/connection-request.ts
+++ b/app/core/SDKConnectV2/types/connection-request.ts
@@ -1,5 +1,5 @@
 import { SessionRequest } from '@metamask/mobile-wallet-protocol-core';
-import { DappMetadata } from './dapp-metadata';
+import { Metadata } from './metadata';
 
 /**
  * Represents an incoming connection request parsed from a QR code or deep link.
@@ -15,8 +15,81 @@ export interface ConnectionRequest {
   sessionRequest: SessionRequest;
 
   /**
-   * Metadata about the decentralized application (dApp) that is
-   * requesting the connection.
+   * Metadata about the dApp and SDK that is requesting the connection.
    */
-  dappMetadata: DappMetadata;
+  metadata: Metadata;
+}
+
+/**
+ * Type guard to validate if the given data conforms to the ConnectionRequest interface.
+ *
+ * @param {unknown} data - The data to be validated.
+ * @returns {boolean} True if the data conforms to the ConnectionRequest interface, false otherwise.
+ */
+export function isConnectionRequest(data: unknown): data is ConnectionRequest {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    return false;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const obj = data as any;
+
+  // Validate sessionRequest
+  if (!obj.sessionRequest || typeof obj.sessionRequest !== 'object') {
+    return false;
+  }
+
+  const sessionReq = obj.sessionRequest;
+  if (
+    !sessionReq.id ||
+    typeof sessionReq.id !== 'string' ||
+    !sessionReq.dappPublicKey ||
+    typeof sessionReq.dappPublicKey !== 'string' ||
+    !sessionReq.walletPublicKey ||
+    typeof sessionReq.walletPublicKey !== 'string' ||
+    !sessionReq.channel ||
+    typeof sessionReq.channel !== 'string'
+  ) {
+    return false;
+  }
+
+  // Validate metadata
+  if (!obj.metadata || typeof obj.metadata !== 'object') {
+    return false;
+  }
+
+  const metadata = obj.metadata;
+
+  // Validate dapp metadata
+  if (
+    !metadata.dapp ||
+    typeof metadata.dapp !== 'object' ||
+    !metadata.dapp.name ||
+    typeof metadata.dapp.name !== 'string' ||
+    !metadata.dapp.url ||
+    typeof metadata.dapp.url !== 'string'
+  ) {
+    return false;
+  }
+
+  // Validate SDK metadata
+  if (
+    !metadata.sdk ||
+    typeof metadata.sdk !== 'object' ||
+    !metadata.sdk.version ||
+    typeof metadata.sdk.version !== 'string' ||
+    !metadata.sdk.platform ||
+    typeof metadata.sdk.platform !== 'string'
+  ) {
+    return false;
+  }
+
+  // Validate URL format
+  try {
+    new URL(metadata.dapp.url);
+  } catch {
+    return false;
+  }
+
+  return true;
 }
diff --git a/app/core/SDKConnectV2/types/connection-store.ts b/app/core/SDKConnectV2/types/connection-store.ts
index 8a97db11335..cf5fb23da2a 100644
--- a/app/core/SDKConnectV2/types/connection-store.ts
+++ b/app/core/SDKConnectV2/types/connection-store.ts
@@ -1,4 +1,4 @@
-import { Connection } from './connection';
+import { PersistedConnection } from './persisted-connection';
 
 /**
  * Defines the contract for the persistence layer that will act as the
@@ -14,20 +14,20 @@ export interface IConnectionStore {
    * @param connection The connection object to save.
    * @returns A promise that resolves when the save operation is complete.
    */
-  save(connection: Connection): Promise<void>;
+  save(connection: PersistedConnection): Promise<void>;
 
   /**
    * Retrieves a single connection by its unique ID.
    * @param id The ID of the connection to retrieve.
    * @returns A promise that resolves with the Connection object, or null if not found.
    */
-  get(id: string): Promise<Connection | null>;
+  get(id: string): Promise<PersistedConnection | null>;
 
   /**
    * Retrieves a list of all persisted connections.
    * @returns A promise that resolves with an array of all Connection objects.
    */
-  list(): Promise<Connection[]>;
+  list(): Promise<PersistedConnection[]>;
 
   /**
    * Deletes a connection from storage by its unique ID.
diff --git a/app/core/SDKConnectV2/types/connection.ts b/app/core/SDKConnectV2/types/connection.ts
index 02752696d75..56029fbf66e 100644
--- a/app/core/SDKConnectV2/types/connection.ts
+++ b/app/core/SDKConnectV2/types/connection.ts
@@ -1,7 +1,7 @@
 import { Session } from '@metamask/mobile-wallet-protocol-core';
 import { WalletClient } from '@metamask/mobile-wallet-protocol-wallet-client';
 import { BackgroundBridge } from '../../BackgroundBridge/BackgroundBridge';
-import { DappMetadata } from './dapp-metadata';
+import { Metadata } from './metadata';
 
 /**
  * Represents a fully established, user-approved, and persisted connection.
@@ -28,7 +28,7 @@ export interface Connection {
    * Metadata about the connected dApp. This data is persisted alongside
    * the session.
    */
-  dappMetadata: DappMetadata;
+  dappMetadata: Metadata['dapp'];
 
   /**
    * The live, in-memory client instance for this connection, provided by the
diff --git a/app/core/SDKConnectV2/types/dapp-metadata.ts b/app/core/SDKConnectV2/types/dapp-metadata.ts
deleted file mode 100644
index 3875a32df43..00000000000
--- a/app/core/SDKConnectV2/types/dapp-metadata.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-/**
- * Metadata about the connected dApp.
- */
-export interface DappMetadata {
-  name: string;
-  url: string;
-  icon?: string;
-}
diff --git a/app/core/SDKConnectV2/types/host-application-adapter.ts b/app/core/SDKConnectV2/types/host-application-adapter.ts
index d00bf92b495..73666cdd6d2 100644
--- a/app/core/SDKConnectV2/types/host-application-adapter.ts
+++ b/app/core/SDKConnectV2/types/host-application-adapter.ts
@@ -1,4 +1,5 @@
-import { Connection } from './connection';
+import { Connection } from '../services/connection';
+import { Metadata } from './metadata';
 
 /**
  * Defines the contract for the host MetaMask Mobile application.
@@ -17,7 +18,7 @@ export interface IHostApplicationAdapter {
    */
   showConnectionApproval(
     connectionId: string,
-    dappMetadata: Connection['dappMetadata'],
+    dappMetadata: Metadata['dapp'],
   ): Promise<void>;
 
   /**
@@ -31,6 +32,13 @@ export interface IHostApplicationAdapter {
    */
   hideLoading(): void;
 
+  /**
+   * Displays a global, non-interactive alert.
+   * @param title The title of the alert.
+   * @param message The message to display in the alert.
+   */
+  showAlert(title: string, message: string): void;
+
   /**
    * Displays a modal for the user to enter a One-Time Password (OTP).
    * @returns A promise that resolves when the user has entered the OTP.
diff --git a/app/core/SDKConnectV2/types/metadata.ts b/app/core/SDKConnectV2/types/metadata.ts
new file mode 100644
index 00000000000..45e16c1f23a
--- /dev/null
+++ b/app/core/SDKConnectV2/types/metadata.ts
@@ -0,0 +1,14 @@
+/**
+ * Metadata about the dApp and SDK that is requesting the connection.
+ */
+export interface Metadata {
+  dapp: {
+    name: string;
+    url: string;
+    icon?: string;
+  };
+  sdk: {
+    version: string;
+    platform: string;
+  };
+}
diff --git a/app/core/SDKConnectV2/types/persisted-connection.ts b/app/core/SDKConnectV2/types/persisted-connection.ts
new file mode 100644
index 00000000000..3519889fa74
--- /dev/null
+++ b/app/core/SDKConnectV2/types/persisted-connection.ts
@@ -0,0 +1,9 @@
+import { Metadata } from './metadata';
+
+/**
+ * A connection that has been persisted to storage.
+ */
+export interface PersistedConnection {
+  id: string;
+  metadata: Metadata;
+}
diff --git a/app/core/redux/slices/card/index.test.ts b/app/core/redux/slices/card/index.test.ts
index 6a0b3e5f487..65cd8dfa5fb 100644
--- a/app/core/redux/slices/card/index.test.ts
+++ b/app/core/redux/slices/card/index.test.ts
@@ -12,23 +12,34 @@ import cardReducer, {
   setCardPriorityTokenLastFetched,
   initialState,
 } from '.';
-import { selectSelectedInternalAccountFormattedAddress } from '../../../../selectors/accountsController';
 import {
   CardTokenAllowance,
   AllowanceState,
 } from '../../../../components/UI/Card/types';
 import { ethers } from 'ethers';
 
-// Mock the accountsController selectors
-jest.mock('../../../../selectors/accountsController', () => ({
-  selectSelectedInternalAccountFormattedAddress: jest.fn(),
+// Mock the multichain selectors
+jest.mock('../../../../selectors/multichainAccounts/accounts', () => ({
+  selectSelectedInternalAccountByScope: jest.fn(),
 }));
 
-const mockSelectSelectedInternalAccountFormattedAddress =
-  selectSelectedInternalAccountFormattedAddress as jest.MockedFunction<
-    typeof selectSelectedInternalAccountFormattedAddress
+// Mock the multichain utils
+jest.mock('../../../Multichain/utils', () => ({
+  isEthAccount: jest.fn(),
+}));
+
+import { selectSelectedInternalAccountByScope } from '../../../../selectors/multichainAccounts/accounts';
+import { isEthAccount } from '../../../Multichain/utils';
+
+const mockSelectSelectedInternalAccountByScope =
+  selectSelectedInternalAccountByScope as jest.MockedFunction<
+    typeof selectSelectedInternalAccountByScope
   >;
 
+const mockIsEthAccount = isEthAccount as jest.MockedFunction<
+  typeof isEthAccount
+>;
+
 const CARDHOLDER_ACCOUNTS_MOCK: string[] = [
   '0x1234567890123456789012345678901234567890',
   '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
@@ -65,6 +76,23 @@ const EMPTY_CARD_STATE_MOCK: CardSliceState = {
   isLoaded: false,
 };
 
+// Mock account object that matches the expected structure
+const createMockAccount = (address: string) => ({
+  address: address.toLowerCase(),
+  id: `mock-id-${address}`,
+  metadata: {
+    name: 'Mock Account',
+    importTime: Date.now(),
+    keyring: {
+      type: 'HD Key Tree',
+    },
+  },
+  options: {},
+  methods: [],
+  type: 'eip155:eoa' as const,
+  scopes: ['eip155:59144' as const],
+});
+
 describe('Card Selectors', () => {
   describe('selectCardholderAccounts', () => {
     it('returns the cardholder accounts array from the card state', () => {
@@ -92,10 +120,13 @@ describe('Card Selectors', () => {
     });
 
     it('returns true when selected account is in cardholder accounts', () => {
-      const selectedAccount = CARDHOLDER_ACCOUNTS_MOCK[0];
-      mockSelectSelectedInternalAccountFormattedAddress.mockReturnValue(
-        selectedAccount,
+      const selectedAccount = createMockAccount(CARDHOLDER_ACCOUNTS_MOCK[0]);
+
+      // Mock the selector to return a function that returns the account
+      mockSelectSelectedInternalAccountByScope.mockReturnValue(
+        () => selectedAccount,
       );
+      mockIsEthAccount.mockReturnValue(true);
 
       const mockRootState = {
         card: CARD_STATE_MOCK,
@@ -105,10 +136,14 @@ describe('Card Selectors', () => {
     });
 
     it('returns false when selected account is not in cardholder accounts', () => {
-      const selectedAccount = '0x9999999999999999999999999999999999999999';
-      mockSelectSelectedInternalAccountFormattedAddress.mockReturnValue(
-        selectedAccount,
+      const selectedAccount = createMockAccount(
+        '0x9999999999999999999999999999999999999999',
+      );
+
+      mockSelectSelectedInternalAccountByScope.mockReturnValue(
+        () => selectedAccount,
       );
+      mockIsEthAccount.mockReturnValue(true);
 
       const mockRootState = {
         card: CARD_STATE_MOCK,
@@ -118,9 +153,23 @@ describe('Card Selectors', () => {
     });
 
     it('returns false when no account is selected', () => {
-      mockSelectSelectedInternalAccountFormattedAddress.mockReturnValue(
-        undefined,
+      mockSelectSelectedInternalAccountByScope.mockReturnValue(() => undefined);
+      mockIsEthAccount.mockReturnValue(false);
+
+      const mockRootState = {
+        card: CARD_STATE_MOCK,
+      } as unknown as RootState;
+
+      expect(selectIsCardholder(mockRootState)).toBe(false);
+    });
+
+    it('returns false when selected account is not an ETH account', () => {
+      const selectedAccount = createMockAccount(CARDHOLDER_ACCOUNTS_MOCK[0]);
+
+      mockSelectSelectedInternalAccountByScope.mockReturnValue(
+        () => selectedAccount,
       );
+      mockIsEthAccount.mockReturnValue(false);
 
       const mockRootState = {
         card: CARD_STATE_MOCK,
@@ -130,10 +179,14 @@ describe('Card Selectors', () => {
     });
 
     it('returns false when no cardholder accounts exist', () => {
-      const selectedAccount = '0x1234567890123456789012345678901234567890';
-      mockSelectSelectedInternalAccountFormattedAddress.mockReturnValue(
-        selectedAccount,
+      const selectedAccount = createMockAccount(
+        '0x1234567890123456789012345678901234567890',
+      );
+
+      mockSelectSelectedInternalAccountByScope.mockReturnValue(
+        () => selectedAccount,
       );
+      mockIsEthAccount.mockReturnValue(true);
 
       const mockRootState = {
         card: EMPTY_CARD_STATE_MOCK,
diff --git a/app/core/redux/slices/card/index.ts b/app/core/redux/slices/card/index.ts
index fc3c574ed4d..5ae171e6d3b 100644
--- a/app/core/redux/slices/card/index.ts
+++ b/app/core/redux/slices/card/index.ts
@@ -2,8 +2,9 @@ import { createSlice, createAsyncThunk, PayloadAction } from '@reduxjs/toolkit';
 import { createSelector } from 'reselect';
 import { RootState } from '../../../../reducers';
 import { getCardholder } from '../../../../components/UI/Card/util/getCardholder';
-import { selectSelectedInternalAccountFormattedAddress } from '../../../../selectors/accountsController';
 import Logger from '../../../../util/Logger';
+import { selectSelectedInternalAccountByScope } from '../../../../selectors/multichainAccounts/accounts';
+import { isEthAccount } from '../../../Multichain/utils';
 import { CardTokenAllowance } from '../../../../components/UI/Card/types';
 
 export interface CardSliceState {
@@ -83,6 +84,9 @@ export const selectCardholderAccounts = createSelector(
   (card) => card.cardholderAccounts,
 );
 
+const selectedAccount = (rootState: RootState) =>
+  selectSelectedInternalAccountByScope(rootState)('eip155:0');
+
 export const selectCardPriorityToken = (address?: string) =>
   createSelector(selectCardState, (card) =>
     address
@@ -105,17 +109,17 @@ export const selectIsCardCacheValid = (address?: string) =>
     return lastFetchedDate > fiveMinutesAgo;
   });
 
-const selectSelectedInternalAccount = (state: RootState) =>
-  selectSelectedInternalAccountFormattedAddress(state);
-
 export const selectIsCardholder = createSelector(
   selectCardholderAccounts,
-  selectSelectedInternalAccount,
-  (cardholderAccounts, selectedInternalAccountAddress) => {
-    if (!selectedInternalAccountAddress) {
+  selectedAccount,
+  (cardholderAccounts, selectedInternalAccount) => {
+    if (!selectedInternalAccount || !isEthAccount(selectedInternalAccount)) {
       return false;
     }
-    return cardholderAccounts.includes(selectedInternalAccountAddress);
+
+    return cardholderAccounts.includes(
+      selectedInternalAccount.address?.toLowerCase(),
+    );
   },
 );
 
diff --git a/app/selectors/featureFlagController/confirmations/index.test.ts b/app/selectors/featureFlagController/confirmations/index.test.ts
index 71884bf0b90..fd887cad70f 100644
--- a/app/selectors/featureFlagController/confirmations/index.test.ts
+++ b/app/selectors/featureFlagController/confirmations/index.test.ts
@@ -8,8 +8,8 @@ import {
   BUFFER_STEP_DEFAULT,
   BUFFER_INITIAL_DEFAULT,
   ATTEMPTS_MAX_DEFAULT,
-  SLIPPAGE_INITIAL_DEFAULT,
-  SLIPPAGE_SUBSEQUENT_DEFAULT,
+  SLIPPAGE_DEFAULT,
+  BUFFER_SUBSEQUENT_DEFAULT,
 } from '.';
 import mockedEngine from '../../../core/__mocks__/MockedEngine';
 import { mockedEmptyFlagsState, mockedUndefinedFlagsState } from '../mocks';
@@ -290,22 +290,22 @@ describe('MetaMask Pay Feature Flags', () => {
     );
   });
 
+  it('returns default buffer subsequent if not in feature flags', () => {
+    expect(
+      selectMetaMaskPayFlags(mockedEmptyFlagsState).bufferSubsequent,
+    ).toEqual(BUFFER_SUBSEQUENT_DEFAULT);
+  });
+
   it('returns default attempts max if not in feature flags', () => {
     expect(selectMetaMaskPayFlags(mockedEmptyFlagsState).attemptsMax).toEqual(
       ATTEMPTS_MAX_DEFAULT,
     );
   });
 
-  it('returns default initial slippage if not in feature flags', () => {
-    expect(
-      selectMetaMaskPayFlags(mockedEmptyFlagsState).slippageInitial,
-    ).toEqual(SLIPPAGE_INITIAL_DEFAULT);
-  });
-
-  it('returns default subsequent slippage if not in feature flags', () => {
-    expect(
-      selectMetaMaskPayFlags(mockedEmptyFlagsState).slippageSubsequent,
-    ).toEqual(SLIPPAGE_SUBSEQUENT_DEFAULT);
+  it('returns default slippage if not in feature flags', () => {
+    expect(selectMetaMaskPayFlags(mockedEmptyFlagsState).slippage).toEqual(
+      SLIPPAGE_DEFAULT,
+    );
   });
 
   it('returns buffer step from feature flag', () => {
@@ -334,42 +334,42 @@ describe('MetaMask Pay Feature Flags', () => {
     expect(selectMetaMaskPayFlags(state).bufferInitial).toEqual(2.345);
   });
 
-  it('returns max attempts from feature flag', () => {
+  it('returns subsequent buffer from feature flag', () => {
     const state = cloneDeep(mockedEmptyFlagsState);
 
     state.engine.backgroundState.RemoteFeatureFlagController.remoteFeatureFlags =
       {
         confirmation_pay: {
-          attemptsMax: 3,
+          bufferSubsequent: 5.678,
         },
       };
 
-    expect(selectMetaMaskPayFlags(state).attemptsMax).toEqual(3);
+    expect(selectMetaMaskPayFlags(state).bufferSubsequent).toEqual(5.678);
   });
 
-  it('returns initial slippage from feature flag', () => {
+  it('returns max attempts from feature flag', () => {
     const state = cloneDeep(mockedEmptyFlagsState);
 
     state.engine.backgroundState.RemoteFeatureFlagController.remoteFeatureFlags =
       {
         confirmation_pay: {
-          slippageInitial: 0.123,
+          attemptsMax: 3,
         },
       };
 
-    expect(selectMetaMaskPayFlags(state).slippageInitial).toEqual(0.123);
+    expect(selectMetaMaskPayFlags(state).attemptsMax).toEqual(3);
   });
 
-  it('returns subsequent slippage from feature flag', () => {
+  it('returns slippage from feature flag', () => {
     const state = cloneDeep(mockedEmptyFlagsState);
 
     state.engine.backgroundState.RemoteFeatureFlagController.remoteFeatureFlags =
       {
         confirmation_pay: {
-          slippageSubsequent: 0.234,
+          slippage: 0.123,
         },
       };
 
-    expect(selectMetaMaskPayFlags(state).slippageSubsequent).toEqual(0.234);
+    expect(selectMetaMaskPayFlags(state).slippage).toEqual(0.123);
   });
 });
diff --git a/app/selectors/featureFlagController/confirmations/index.ts b/app/selectors/featureFlagController/confirmations/index.ts
index 420fe4b53d2..bfeeed817da 100644
--- a/app/selectors/featureFlagController/confirmations/index.ts
+++ b/app/selectors/featureFlagController/confirmations/index.ts
@@ -6,8 +6,8 @@ import { Json } from '@metamask/utils';
 export const ATTEMPTS_MAX_DEFAULT = 2;
 export const BUFFER_INITIAL_DEFAULT = 0.025;
 export const BUFFER_STEP_DEFAULT = 0.025;
-export const SLIPPAGE_INITIAL_DEFAULT = 0.005;
-export const SLIPPAGE_SUBSEQUENT_DEFAULT = 0.02;
+export const BUFFER_SUBSEQUENT_DEFAULT = 0.05;
+export const SLIPPAGE_DEFAULT = 0.005;
 
 // A type predicate's type must be assignable to its parameter's type
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
@@ -29,8 +29,8 @@ export interface MetaMaskPayFlags {
   attemptsMax: number;
   bufferInitial: number;
   bufferStep: number;
-  slippageInitial: number;
-  slippageSubsequent: number;
+  bufferSubsequent: number;
+  slippage: number;
 }
 
 /**
@@ -152,17 +152,16 @@ export const selectMetaMaskPayFlags = createSelector(
     const bufferInitial =
       metaMaskPayFlags?.bufferInitial ?? BUFFER_INITIAL_DEFAULT;
     const bufferStep = metaMaskPayFlags?.bufferStep ?? BUFFER_STEP_DEFAULT;
-    const slippageInitial =
-      metaMaskPayFlags?.slippageInitial ?? SLIPPAGE_INITIAL_DEFAULT;
-    const slippageSubsequent =
-      metaMaskPayFlags?.slippageSubsequent ?? SLIPPAGE_SUBSEQUENT_DEFAULT;
+    const bufferSubsequent =
+      metaMaskPayFlags?.bufferSubsequent ?? BUFFER_SUBSEQUENT_DEFAULT;
+    const slippage = metaMaskPayFlags?.slippage ?? SLIPPAGE_DEFAULT;
 
     return {
       attemptsMax,
       bufferInitial,
       bufferStep,
-      slippageInitial,
-      slippageSubsequent,
+      bufferSubsequent,
+      slippage,
     } as MetaMaskPayFlags;
   },
 );
diff --git a/app/selectors/smartTransactionsController.test.ts b/app/selectors/smartTransactionsController.test.ts
index 26a778b8e23..c49b7b9bf5f 100644
--- a/app/selectors/smartTransactionsController.test.ts
+++ b/app/selectors/smartTransactionsController.test.ts
@@ -13,13 +13,17 @@ const TEST_ADDRESS_ONE = '0x5a3ca5cd63807ce5e4d7841ab32ce6b6d9bbba2d';
 const TEST_ADDRESS_TWO = '0x202637daaefbd7f131f90338a4a6c69f6cd5ce91';
 
 // Stub the accounts selector so that selectSelectedInternalAccountFormattedAddress returns TEST_ADDRESS_ONE
-jest.mock('./accountsController', () => ({
-  selectSelectedInternalAccountFormattedAddress: jest.fn(
-    () => TEST_ADDRESS_ONE,
-  ),
-  selectSelectedInternalAccountAddress: jest.fn(() => TEST_ADDRESS_ONE),
-  selectHasCreatedSolanaMainnetAccount: jest.fn(() => false),
-}));
+jest.mock('./accountsController', () => {
+  const actual = jest.requireActual('./accountsController');
+  return {
+    ...actual,
+    selectSelectedInternalAccountFormattedAddress: jest.fn(
+      () => TEST_ADDRESS_ONE,
+    ),
+    selectSelectedInternalAccountAddress: jest.fn(() => TEST_ADDRESS_ONE),
+    selectHasCreatedSolanaMainnetAccount: jest.fn(() => false),
+  };
+});
 
 jest.mock('./tokensController', () => ({
   selectTokensControllerState: jest.fn(),
diff --git a/app/util/transactions/hooks/pay-hook.test.ts b/app/util/transactions/hooks/pay-hook.test.ts
index d9935537f98..b2f8ba441df 100644
--- a/app/util/transactions/hooks/pay-hook.test.ts
+++ b/app/util/transactions/hooks/pay-hook.test.ts
@@ -1,5 +1,8 @@
 import { TransactionMeta } from '@metamask/transaction-controller';
-import { TransactionBridgeQuote } from '../../../components/Views/confirmations/utils/bridge';
+import {
+  TransactionBridgeQuote,
+  refreshQuote,
+} from '../../../components/Views/confirmations/utils/bridge';
 import { TransactionControllerInitMessenger } from '../../../core/Engine/messengers/transaction-controller-messenger';
 import { PayHook } from './pay-hook';
 import { Messenger } from '@metamask/base-controller';
@@ -16,6 +19,7 @@ import { selectShouldUseSmartTransaction } from '../../../selectors/smartTransac
 
 jest.mock('../../../selectors/smartTransactionsController');
 jest.mock('../../transaction-controller');
+jest.mock('../../../components/Views/confirmations/utils/bridge');
 
 const TRANSACTION_ID_MOCK = '123-456';
 const BRIDGE_TRANSACTION_ID_MOCK = '456-789';
@@ -61,6 +65,8 @@ describe('Pay Publish Hook', () => {
     BridgeStatusController['submitTx']
   > = jest.fn();
 
+  const refreshQuoteMock = jest.mocked(refreshQuote);
+
   function runHook() {
     return hook.getHook()(TRANSACTION_META_MOCK, '0x1234');
   }
@@ -85,7 +91,7 @@ describe('Pay Publish Hook', () => {
   }
 
   beforeEach(() => {
-    jest.clearAllMocks();
+    jest.resetAllMocks();
 
     baseMessenger = new Messenger<
       BridgeStatusControllerActions,
@@ -132,6 +138,8 @@ describe('Pay Publish Hook', () => {
     });
 
     selectShouldUseSmartTransactionMock.mockReturnValue(false);
+
+    refreshQuoteMock.mockImplementation(async (_quote) => _quote);
   });
 
   it('submits matching quotes to bridge status controller', async () => {
@@ -214,4 +222,10 @@ describe('Pay Publish Hook', () => {
       transactionHash: undefined,
     });
   });
+
+  it('refreshes quote if subsequent bridge transaction', async () => {
+    await runHook();
+
+    expect(refreshQuoteMock).toHaveBeenCalledWith(QUOTE_2_MOCK);
+  });
 });
diff --git a/app/util/transactions/hooks/pay-hook.ts b/app/util/transactions/hooks/pay-hook.ts
index a9327c31016..6f0d7d15459 100644
--- a/app/util/transactions/hooks/pay-hook.ts
+++ b/app/util/transactions/hooks/pay-hook.ts
@@ -12,7 +12,10 @@ import {
 import { TransactionControllerInitMessenger } from '../../../core/Engine/messengers/transaction-controller-messenger';
 import { store } from '../../../store';
 import { ExtractEventHandler } from '@metamask/base-controller';
-import { TransactionBridgeQuote } from '../../../components/Views/confirmations/utils/bridge';
+import {
+  TransactionBridgeQuote,
+  refreshQuote,
+} from '../../../components/Views/confirmations/utils/bridge';
 import { cloneDeep } from 'lodash';
 import { selectShouldUseSmartTransaction } from '../../../selectors/smartTransactionsController';
 import { toHex } from '@metamask/controller-utils';
@@ -82,7 +85,8 @@ export class PayHook {
     for (const quote of quotes) {
       log('Submitting bridge', index, quote);
 
-      await this.#submitBridgeTransaction(transactionId, quote);
+      const finalQuote = index > 0 ? await refreshQuote(quote) : quote;
+      await this.#submitBridgeTransaction(transactionId, finalQuote);
 
       index += 1;
     }
diff --git a/appwright/fixtures/performance-test.js b/appwright/fixtures/performance-test.js
index deb4d40ba74..7650dca0709 100644
--- a/appwright/fixtures/performance-test.js
+++ b/appwright/fixtures/performance-test.js
@@ -1,5 +1,6 @@
 import { test as base } from 'appwright';
 import { PerformanceTracker } from '../reporters/PerformanceTracker.js';
+import TimerHelper from '../utils/TimersHelper.js';
 
 // Create a custom test fixture that handles performance tracking and cleanup
 export const test = base.extend({
@@ -10,7 +11,99 @@ export const test = base.extend({
     // Provide the tracker to the test
     await use(performanceTracker);
 
-    // After test completes, handle session cleanup
+    // After test completes, handle performance metrics and session cleanup
+    console.log('🔍 Post-test cleanup: attaching performance metrics...');
+    console.log(
+      `📊 Found ${performanceTracker.timers.length} timers in tracker`,
+    );
+
+    if (performanceTracker.timers.length === 0) {
+      console.log('⚠️ No timers found in performance tracker');
+    }
+
+    // Enhanced timer recovery: capture any timers that weren't added to the tracker
+    try {
+      const Timers = await import('../utils/Timers.js').then((m) => m.default);
+      const allGlobalTimers = Timers.getAllTimers();
+
+      // Check for timers that exist globally but weren't added to the tracker
+      for (const globalTimer of allGlobalTimers) {
+        const existsInTracker = performanceTracker.timers.some(
+          (t) => t.id === globalTimer.id,
+        );
+
+        if (!existsInTracker) {
+          console.log(`🔄 Recovering orphaned timer: "${globalTimer.id}"`);
+
+          try {
+            const recoveredTimer = new TimerHelper(globalTimer.id);
+
+            if (globalTimer.start !== null && globalTimer.duration === null) {
+              recoveredTimer.stop();
+            }
+
+            performanceTracker.addTimer(recoveredTimer);
+          } catch (error) {
+            console.log(`⚠️ Failed to recover timer ${globalTimer.id}`);
+          }
+        }
+      }
+    } catch (importError) {
+      console.log(`⚠️ Timer recovery failed: ${importError.message}`);
+    }
+
+    // Stop any running timers in the tracker
+    for (const timer of performanceTracker.timers) {
+      try {
+        const isRunning = timer.isRunning ? timer.isRunning() : false;
+        const isCompleted = timer.isCompleted ? timer.isCompleted() : false;
+
+        if (isRunning && !isCompleted) {
+          timer.stop();
+        }
+      } catch (error) {
+        console.log(`⚠️ Error checking timer ${timer.id}`);
+      }
+    }
+
+    // Always try to attach performance metrics, even if test failed
+    try {
+      const metrics = await performanceTracker.attachToTest(testInfo);
+      console.log(
+        `✅ Performance metrics attached: ${
+          metrics.steps.length
+        } steps, ${metrics.total.toFixed(2)}s total`,
+      );
+    } catch (error) {
+      console.error('❌ Failed to attach performance metrics:', error.message);
+
+      // Create fallback metrics for failed tests
+      try {
+        const fallbackMetrics = {
+          testFailed: true,
+          failureReason: testInfo?.status || 'unknown',
+          testDuration: testInfo?.duration || 0,
+          message: 'Performance metrics could not be properly attached',
+          timersFound: performanceTracker.timers.length,
+          device: testInfo?.project?.use?.device || {
+            name: 'Unknown',
+            osVersion: 'Unknown',
+          },
+        };
+
+        await testInfo.attach(
+          `performance-metrics-fallback-${testInfo.title}`,
+          {
+            body: JSON.stringify(fallbackMetrics),
+            contentType: 'application/json',
+          },
+        );
+        console.log(`✅ Fallback metrics attached`);
+      } catch (fallbackError) {
+        console.error('❌ Fallback metrics attachment failed');
+      }
+    }
+
     console.log('🔍 Looking for session ID...');
 
     let sessionId = null;
@@ -19,7 +112,6 @@ export const test = base.extend({
       sessionId = testInfo.annotations.find(
         (annotation) => annotation.type === 'sessionId',
       )?.description;
-      console.log(`📊 Session ID from annotations: ${sessionId}`);
     }
 
     if (sessionId) {
@@ -34,24 +126,10 @@ export const test = base.extend({
         contentType: 'application/json',
       });
 
-      console.log('testInfo.project.name', testInfo.project.name);
       await performanceTracker.storeSessionData(sessionId, testInfo.title);
-      console.log(`✅ Session data stored successfully: ${sessionId}`);
+      console.log(`✅ Session data stored: ${sessionId}`);
     } else {
-      console.log('❌ No session ID found - video URL cannot be retrieved');
-      console.log(
-        'Available testInfo properties:',
-        Object.keys(testInfo || {}),
-      );
-      if (testInfo?.annotations) {
-        console.log(
-          'Available annotations:',
-          testInfo.annotations.map((a) => ({
-            type: a.type,
-            description: a.description?.substring(0, 50),
-          })),
-        );
-      }
+      console.log('⚠️ No session ID found - video URL cannot be retrieved');
     }
   },
 });
diff --git a/appwright/reporters/PerformanceTracker.js b/appwright/reporters/PerformanceTracker.js
index 0d6acc4c033..f2dcb87cf74 100644
--- a/appwright/reporters/PerformanceTracker.js
+++ b/appwright/reporters/PerformanceTracker.js
@@ -2,24 +2,21 @@ import axios from 'axios';
 
 export class PerformanceTracker {
   constructor() {
-    this.timers = {};
+    this.timers = [];
   }
 
   addTimer(timer) {
-    if (this.timers[timer.id]) {
-      // eslint-disable-next-line no-console
-      console.log('Timer already exists', timer.id);
+    if (this.timers.find((existingTimer) => existingTimer.id === timer.id)) {
       return;
     }
-    this.timers[timer.id] = timer;
+
+    this.timers.push(timer);
   }
 
   async storeSessionData(sessionId, testTitle) {
     // Store in process environment
     process.env.TEMP_SESSION_ID = sessionId;
     process.env.TEMP_TEST_TITLE = testTitle;
-
-    console.log(`✅ Session data stored: ${sessionId}`);
   }
 
   async getVideoURL(sessionId, maxRetries = 60, delayMs = 3000) {
@@ -29,16 +26,12 @@ export class PerformanceTracker {
     console.log(
       `🔄 STARTING RETRY MECHANISM: ${maxRetries} retries, ${delayMs}ms delays`,
     );
-    console.log(
-      `📊 Estimated total time: ${(maxRetries * delayMs) / 1000} seconds`,
-    );
-    console.log(`🕐 Start time: ${new Date().toISOString()}`);
-
+    console.log(`📊 Max total time: ${(maxRetries * delayMs) / 1000} seconds`);
     // Initial delay to let BrowserStack process the session
     console.log(
-      '⏱️ Initial 15-second wait for BrowserStack session processing...',
+      '⏱️ Initial 5-second wait for BrowserStack session processing...',
     );
-    await new Promise((resolve) => setTimeout(resolve, 15000));
+    await new Promise((resolve) => setTimeout(resolve, 5000));
 
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
       const startTime = Date.now();
@@ -119,19 +112,49 @@ export class PerformanceTracker {
   }
 
   async attachToTest(testInfo) {
-    const metrics = {};
+    const metrics = {
+      steps: [],
+    };
     let totalSeconds = 0;
-    for (const [id, timer] of Object.entries(this.timers)) {
-      metrics[id] = timer.getDuration();
-      totalSeconds += timer.getDurationInSeconds();
+
+    for (const timer of this.timers) {
+      const duration = timer.getDuration();
+      const durationInSeconds = timer.getDurationInSeconds();
+
+      if (duration !== null && !isNaN(duration) && duration > 0) {
+        // Create a step object with the timer id as key and duration as value
+        const stepObject = {};
+        stepObject[timer.id] = duration;
+        metrics.steps.push(stepObject);
+
+        totalSeconds += durationInSeconds;
+      }
     }
+
     metrics.total = totalSeconds;
-    metrics.device = testInfo.project.use.device;
 
-    await testInfo.attach(`performance-metrics-${testInfo.title}`, {
-      body: JSON.stringify(metrics),
-      contentType: 'application/json',
-    });
+    // Safely get device info with fallbacks
+    const deviceInfo = testInfo?.project?.use?.device;
+    if (deviceInfo) {
+      metrics.device = deviceInfo;
+    } else {
+      metrics.device = {
+        name: 'Unknown',
+        osVersion: 'Unknown',
+        provider: 'unknown',
+      };
+    }
+
+    try {
+      await testInfo.attach(`performance-metrics-${testInfo.title}`, {
+        body: JSON.stringify(metrics),
+        contentType: 'application/json',
+      });
+    } catch (error) {
+      console.error(`❌ Failed to attach performance metrics:`, error.message);
+      throw error;
+    }
+
     return metrics;
   }
 }
diff --git a/appwright/reporters/custom-reporter.js b/appwright/reporters/custom-reporter.js
index 254db559880..196c225660f 100644
--- a/appwright/reporters/custom-reporter.js
+++ b/appwright/reporters/custom-reporter.js
@@ -7,19 +7,24 @@ class CustomReporter {
   constructor() {
     this.metrics = [];
     this.sessions = []; // Array to store all session data
+    this.processedTests = new Set(); // Track processed tests to avoid duplicates
   }
 
   // We'll skip the onStdOut and onStdErr methods since the list reporter will handle those
 
   onTestEnd(test, result) {
-    console.log(`\n🔍 onTestEnd called for test: ${test.title}`);
-    console.log(`📊 Test status: ${result.status}`);
-    console.log(`📊 Test duration: ${result.duration}ms`);
-    // Look for session data in attachments (preferred method)
-    console.log(`🔍 Total attachments: ${result.attachments.length}`);
-    result.attachments.forEach((att, idx) => {
-      console.log(`  ${idx}: ${att.name} (${att.contentType})`);
-    });
+    // Create a unique test identifier to avoid duplicate processing
+    // Use test title and first few characters of attachments as unique ID
+    const attachmentNames = result.attachments.map((att) => att.name).join('|');
+    const testId = `${test.title}-${attachmentNames.substring(0, 50)}`;
+
+    if (this.processedTests.has(testId)) {
+      console.log(`⚠️ Test already processed, skipping: ${test.title}`);
+      return;
+    }
+    this.processedTests.add(testId);
+
+    console.log(`\n🔍 Processing test: ${test.title} (${result.status})`);
 
     const sessionAttachment = result.attachments.find(
       (att) => att.name === 'session-data',
@@ -33,19 +38,9 @@ class CustomReporter {
           testStatus: result.status,
           testDuration: result.duration,
         });
-        console.log(
-          `✅ Captured session data for test: ${sessionData.sessionId}`,
-        );
-        console.log(
-          `🔍 Project name from session data: ${sessionData.projectName}`,
-        );
       } catch (error) {
         console.log(`❌ Error parsing session data: ${error.message}`);
       }
-    } else {
-      console.log(
-        `❌ No session-data attachment found in ${result.attachments.length} attachments`,
-      );
     }
 
     // Fallback: Try to capture session ID from test result annotations
@@ -55,7 +50,6 @@ class CustomReporter {
       );
       if (sessionIdAnnotation) {
         const sessionId = sessionIdAnnotation.description;
-        console.log(`✅ Captured session ID from annotations: ${sessionId}`);
 
         // Only add if we didn't already capture it from attachments
         if (!this.sessions.find((s) => s.sessionId === sessionId)) {
@@ -70,7 +64,7 @@ class CustomReporter {
       }
     }
 
-    // Look for metrics in the attachments
+    // Look for metrics in the attachments (including fallback metrics)
     const metricsAttachment = result.attachments.find(
       (att) => att.name && att.name.includes('performance-metrics'),
     );
@@ -79,50 +73,101 @@ class CustomReporter {
       try {
         const metrics = JSON.parse(metricsAttachment.body.toString());
 
-        // Add a separator to make the metrics stand out in the logs
-        console.log('\n📊 Performance Metrics for:', test.title);
-        console.log('─'.repeat(50));
+        // Check if this is a fallback metrics entry
+        const isFallbackMetrics =
+          metricsAttachment.name.includes('fallback') ||
+          metrics.message ===
+            'Performance metrics could not be properly attached';
 
-        Object.entries(metrics).forEach(([key, value]) => {
-          if (key !== 'total' && key !== 'device') {
-            console.log(`${key.padEnd(30)}: ${value} ms`);
-          }
-        });
-
-        console.log('─'.repeat(50));
-        console.log(`TOTAL TIME: ${metrics.total.toFixed(2)} seconds`);
-        console.log('─'.repeat(50));
+        console.log(
+          `📊 Processing metrics for: ${test.title} ${
+            isFallbackMetrics ? '(fallback)' : ''
+          }`,
+        );
 
-        this.metrics.push({
+        // Create metrics entry with proper handling for both regular and fallback metrics
+        const metricsEntry = {
           testName: test.title,
           ...metrics,
-        });
+        };
+
+        // Always mark failed tests appropriately
+        if (result.status !== 'passed') {
+          metricsEntry.testFailed = true;
+          metricsEntry.failureReason = result.status;
+        }
+
+        // For fallback metrics, ensure we have proper structure for reporting
+        if (isFallbackMetrics) {
+          // Convert test duration to seconds if not already
+          if (!metricsEntry.total && metricsEntry.testDuration) {
+            metricsEntry.total = metricsEntry.testDuration / 1000;
+          }
+
+          // Ensure we have steps array for consistency
+          if (!metricsEntry.steps) {
+            metricsEntry.steps = [];
+          }
+
+          // Ensure device info exists
+          if (!metricsEntry.device) {
+            metricsEntry.device = { name: 'Unknown', osVersion: 'Unknown' };
+          }
+        }
+
+        this.metrics.push(metricsEntry);
       } catch (error) {
         console.error('Error processing metrics:', error);
       }
-    } else {
-      console.log('❌ No performance metrics found in attachments');
-
-      // For failed tests, still try to create a basic entry so we can capture video
-      if (result.status !== 'passed') {
-        console.log(
-          `⚠️  Test failed (${result.status}), creating basic metrics entry`,
-        );
-        this.metrics.push({
-          testName: test.title,
-          total: result.duration / 1000, // Convert to seconds
-          device: { name: 'Unknown', osVersion: 'Unknown' },
-          testFailed: true,
-          failureReason: result.status,
-        });
+    } else if (result.status !== 'passed') {
+      // For failed tests without metrics, create a basic entry
+      console.log(`⚠️ Test failed without metrics, creating basic entry`);
+
+      // Try to get device info from test project configuration
+      let deviceInfo = { name: 'Unknown', osVersion: 'Unknown' };
+
+      if (test?.parent?.project?.use?.device) {
+        deviceInfo = test.parent.project.use.device;
+      } else if (
+        process.env.BROWSERSTACK_DEVICE &&
+        process.env.BROWSERSTACK_OS_VERSION
+      ) {
+        deviceInfo = {
+          name: process.env.BROWSERSTACK_DEVICE,
+          osVersion: process.env.BROWSERSTACK_OS_VERSION,
+          provider: 'browserstack',
+        };
       }
+
+      const basicEntry = {
+        testName: test.title,
+        total: result.duration / 1000,
+        device: deviceInfo,
+        steps: [],
+        testFailed: true,
+        failureReason: result.status,
+        note: 'Test failed - no performance metrics collected',
+      };
+
+      this.metrics.push(basicEntry);
     }
   }
 
   async onEnd() {
-    console.log(
-      `\n🔍 onEnd called - Processing ${this.metrics.length} metrics entries and ${this.sessions.length} sessions`,
-    );
+    console.log(`\n📊 Generating reports for ${this.metrics.length} tests`);
+
+    // Analyze the test results for better reporting
+    const passedTests = this.metrics.filter((m) => !m.testFailed).length;
+    const failedTests = this.metrics.filter((m) => m.testFailed).length;
+    const testsWithSteps = this.metrics.filter(
+      (m) => m.steps && m.steps.length > 0,
+    ).length;
+    const testsWithFallbackData = this.metrics.filter(
+      (m) =>
+        m.note &&
+        (m.note.includes('failed') ||
+          m.note.includes('no performance metrics')),
+    ).length;
 
     // Determine if this is a BrowserStack run by checking session data
     let isBrowserStackRun = false;
@@ -133,26 +178,18 @@ class CustomReporter {
         .map((session) => session.projectName)
         .filter(Boolean);
 
-      console.log(`🔍 Project names from sessions: ${projectNames.join(', ')}`);
       isBrowserStackRun = projectNames.some((name) =>
         name.includes('browserstack-'),
       );
     }
 
-    console.log(`🔍 isBrowserStackRun: ${isBrowserStackRun}`);
-    console.log(`🔍 Sessions count: ${this.sessions.length}`);
-
     if (this.sessions.length > 0 && isBrowserStackRun) {
       console.log(
-        `🎥 BrowserStack configuration detected - fetching video URLs...`,
+        `🎥 Fetching video URLs for ${this.sessions.length} sessions`,
       );
       const tracker = new PerformanceTracker();
 
       for (const session of this.sessions) {
-        console.log(
-          `🎬 Fetching video URL for session: ${session.sessionId} (${session.testTitle})`,
-        );
-
         try {
           const videoURL = await tracker.getVideoURL(
             session.sessionId,
@@ -161,27 +198,11 @@ class CustomReporter {
           );
           if (videoURL) {
             session.videoURL = videoURL;
-            console.log(
-              `✅ Video URL fetched for ${session.testTitle}: ${videoURL}`,
-            );
-          } else {
-            console.log(
-              `❌ Video URL could not be fetched for ${session.testTitle}`,
-            );
           }
         } catch (error) {
-          console.error(
-            `❌ Error fetching video URL for ${session.testTitle}:`,
-            error.message,
-          );
+          console.error(`❌ Error fetching video URL for ${session.testTitle}`);
         }
       }
-    } else if (this.sessions.length > 0 && !isBrowserStackRun) {
-      console.log(
-        `📱 Local/emulator run detected - skipping video URL fetching (BrowserStack only feature)`,
-      );
-    } else {
-      console.log('❌ No session data available for video URL fetching');
     }
 
     // Clean up any leftover environment variables
@@ -224,6 +245,7 @@ class CustomReporter {
       }
 
       if (this.metrics.length > 0) {
+        console.log('Metrics are:', this.metrics);
         // Add video URLs to metrics by matching test names with sessions
         const metricsWithVideo = this.metrics.map((metric) => {
           const matchingSession = this.sessions.find(
@@ -264,6 +286,19 @@ class CustomReporter {
             <h1>Performance Report - ${
               this.metrics[0].device.name
             } - OS version: ${this.metrics[0].device.osVersion}</h1>
+            <div style="background-color: #e3f2fd; padding: 15px; border-radius: 8px; margin-bottom: 20px;">
+              <h3>📊 Test Suite Summary</h3>
+              <p><strong>Total Tests:</strong> ${this.metrics.length}</p>
+              <p><strong>Passed:</strong> ${passedTests} | <strong>Failed:</strong> ${failedTests}</p>
+              <p><strong>With Performance Data:</strong> ${testsWithSteps} | <strong>Fallback Data:</strong> ${testsWithFallbackData}</p>
+              <p style="font-style: italic; color: #555;">
+                ${
+                  failedTests > 0
+                    ? 'Failed tests are included in this report with available performance data collected until failure.'
+                    : 'All tests completed successfully with full performance metrics.'
+                }
+              </p>
+            </div>
             ${this.metrics
               .map(
                 (test) => `
@@ -273,34 +308,60 @@ class CustomReporter {
                   <th>Steps</th>
                   <th>Time (ms)</th>
                 </tr>
-                ${Object.entries(test)
-                  .filter(
-                    ([key]) =>
-                      key !== 'testName' &&
-                      key !== 'device' &&
-                      key !== 'videoURL' &&
-                      key !== 'sessionId' &&
-                      key !== 'testFailed' &&
-                      key !== 'failureReason' &&
-                      key !== 'note',
-                  )
-                  .map(([key, value]) => {
-                    if (key === 'total') {
-                      return `
-                        <tr class="total">
-                          <td>TOTAL TIME</td>
-                          <td>${value} s</td>
+                ${
+                  test.steps && Array.isArray(test.steps)
+                    ? // New array structure with steps
+                      test.steps
+                        .map((stepObject) => {
+                          const [stepName, duration] =
+                            Object.entries(stepObject)[0];
+                          return `
+                        <tr>
+                          <td>${stepName}</td>
+                          <td>${duration} ms</td>
                         </tr>
                       `;
-                    }
-                    return `
-                      <tr>
-                        <td>${key}</td>
-                        <td>${value} ms</td>
-                      </tr>
-                    `;
-                  })
-                  .join('')}
+                        })
+                        .join('')
+                    : test.steps && typeof test.steps === 'object'
+                    ? // Backward compatibility for old object structure
+                      Object.entries(test.steps)
+                        .map(
+                          ([stepName, duration]) => `
+                        <tr>
+                          <td>${stepName}</td>
+                          <td>${duration} ms</td>
+                        </tr>
+                      `,
+                        )
+                        .join('')
+                    : // Fallback to old structure
+                      Object.entries(test)
+                        .filter(
+                          ([key]) =>
+                            key !== 'testName' &&
+                            key !== 'device' &&
+                            key !== 'videoURL' &&
+                            key !== 'sessionId' &&
+                            key !== 'testFailed' &&
+                            key !== 'failureReason' &&
+                            key !== 'note' &&
+                            key !== 'total',
+                        )
+                        .map(
+                          ([key, value]) => `
+                        <tr>
+                          <td>${key}</td>
+                          <td>${value} ms</td>
+                        </tr>
+                      `,
+                        )
+                        .join('')
+                }
+                <tr class="total">
+                  <td>TOTAL TIME</td>
+                  <td>${test.total} s</td>
+                </tr>
                 ${
                   test.testFailed
                     ? `
@@ -395,27 +456,39 @@ class CustomReporter {
         // Add column headers
         csvRows.push('Step,Time (ms)');
 
-        // Add each step (excluding testName, device, videoURL, sessionId, testFailed, failureReason, and note)
-        Object.entries(test).forEach(([key, value]) => {
-          if (
-            key !== 'testName' &&
-            key !== 'device' &&
-            key !== 'videoURL' &&
-            key !== 'sessionId' &&
-            key !== 'testFailed' &&
-            key !== 'failureReason' &&
-            key !== 'note'
-          ) {
-            if (key === 'total') {
-              // Add a separator line before total
-              csvRows.push('---,---');
-              csvRows.push(`TOTAL TIME (s),${value}`);
-            } else {
-              // Regular step with time in ms
+        // Add each step based on structure (new array format, old object format, or legacy format)
+        if (test.steps && Array.isArray(test.steps)) {
+          // New array structure with steps
+          test.steps.forEach((stepObject) => {
+            const [stepName, duration] = Object.entries(stepObject)[0];
+            csvRows.push(`"${stepName}","${duration}"`);
+          });
+        } else if (test.steps && typeof test.steps === 'object') {
+          // Backward compatibility for old object structure
+          Object.entries(test.steps).forEach(([stepName, duration]) => {
+            csvRows.push(`"${stepName}","${duration}"`);
+          });
+        } else {
+          // Fallback to old format (excluding specific keys)
+          Object.entries(test).forEach(([key, value]) => {
+            if (
+              key !== 'testName' &&
+              key !== 'device' &&
+              key !== 'videoURL' &&
+              key !== 'sessionId' &&
+              key !== 'testFailed' &&
+              key !== 'failureReason' &&
+              key !== 'note' &&
+              key !== 'total'
+            ) {
               csvRows.push(`"${key}","${value}"`);
             }
-          }
-        });
+          });
+        }
+
+        // Add total time regardless of structure
+        csvRows.push('---,---');
+        csvRows.push(`TOTAL TIME (s),${test.total}`);
 
         // Add failure information if this was a failed test
         if (test.testFailed) {
diff --git a/appwright/tests/performance/scenario9.spec.js b/appwright/tests/performance/scenario9.spec.js
index 04b9ba2a458..d16df16a779 100644
--- a/appwright/tests/performance/scenario9.spec.js
+++ b/appwright/tests/performance/scenario9.spec.js
@@ -16,7 +16,7 @@ import WalletMainScreen from '../../../wdio/screen-objects/WalletMainScreen.js';
 import AccountListComponent from '../../../wdio/screen-objects/AccountListComponent.js';
 import AddAccountModal from '../../../wdio/screen-objects/Modals/AddAccountModal.js';
 import TokenOverviewScreen from '../../../wdio/screen-objects/TokenOverviewScreen.js';
-import { onboardingFlowImportSRP } from '../../utils/Flows.js';
+import { importSRPFlow, onboardingFlowImportSRP } from '../../utils/Flows.js';
 import SendScreen from '../../../wdio/screen-objects/SendScreen.js';
 import ConfirmationScreen from '../../../wdio/screen-objects/ConfirmationScreen.js';
 import WalletActionModal from '../../../wdio/screen-objects/Modals/WalletActionModal.js';
@@ -59,6 +59,8 @@ test('Send flow - Ethereum, SRP 1 + SRP 2 + SRP 3', async ({
   await WalletActionModal.tapSendButton();
   await SendScreen.isVisible();
   timer1.stop();
+  performanceTracker.addTimer(timer1);
+
   await SendScreen.typeAddressInSendAddressField(
     '0x8aBB895C61706f33060cDb40e7a2b496C3CA1Dcf',
   );
@@ -69,6 +71,8 @@ test('Send flow - Ethereum, SRP 1 + SRP 2 + SRP 3', async ({
   await SendScreen.tapOnNextButton();
   await SendScreen.isAmountScreenDisplayed();
   timer2.stop();
+  performanceTracker.addTimer(timer2);
+
   const timer3 = new TimerHelper(
     'Time since the user clicks on Next after entering the amount, until the user gets the confirmation screen',
   );
@@ -81,8 +85,6 @@ test('Send flow - Ethereum, SRP 1 + SRP 2 + SRP 3', async ({
   await ConfirmationScreen.isAdvancedSettingsDisplayed();
   timer3.stop();
 
-  performanceTracker.addTimer(timer1);
-  performanceTracker.addTimer(timer2);
   performanceTracker.addTimer(timer3);
   await performanceTracker.attachToTest(testInfo);
 });
@@ -114,8 +116,8 @@ test('Send flow - Solana, SRP 1 + SRP 2 + SRP 3', async ({
   SolanaConfirmationScreen.device = device;
   NetworksScreen.device = device;
 
-  await onboardingFlowImportSRP(device, process.env.TEST_SRP_1);
-  // await importSRPFlow(device, process.env.TEST_SRP_2);
+  await onboardingFlowImportSRP(device, process.env.TEST_SRP_2);
+  await importSRPFlow(device, process.env.TEST_SRP_1);
   // await importSRPFlow(device, process.env.TEST_SRP_3);
 
   await WalletMainScreen.tapIdenticon();
@@ -131,6 +133,7 @@ test('Send flow - Solana, SRP 1 + SRP 2 + SRP 3', async ({
   await WalletActionModal.tapSendButton();
   await SendSolanaScreen.isAddressFieldVisible();
   timer1.stop();
+  performanceTracker.addTimer(timer1);
 
   await SendSolanaScreen.fillAddressField(
     '3xTPAZxmpwd8GrNEKApaTw6VH4jqJ31WFXUvQzgwhR7c',
@@ -141,7 +144,6 @@ test('Send flow - Solana, SRP 1 + SRP 2 + SRP 3', async ({
   await SolanaConfirmationScreen.isConfirmButtonDisplayed();
 
   timer2.stop();
-  performanceTracker.addTimer(timer1);
   performanceTracker.addTimer(timer2);
   await performanceTracker.attachToTest(testInfo);
 });
diff --git a/appwright/utils/TimersHelper.js b/appwright/utils/TimersHelper.js
index e80630744ed..2bf44d80ceb 100644
--- a/appwright/utils/TimersHelper.js
+++ b/appwright/utils/TimersHelper.js
@@ -16,12 +16,35 @@ class TimerHelper {
 
   getDuration() {
     const timer = Timers.getTimer(this.id);
-    return timer.duration;
+    // If timer has been stopped, return the recorded duration
+    if (timer.duration !== null) {
+      return timer.duration;
+    }
+    // If timer is running but not stopped, calculate current elapsed time
+    if (timer.start !== null) {
+      const currentDuration = Date.now() - timer.start;
+      console.log(
+        `⏱️ Timer "${this.id}" is still running, current elapsed: ${currentDuration}ms`,
+      );
+      return currentDuration;
+    }
+    // Timer never started
+    return null;
   }
 
   getDurationInSeconds() {
+    const duration = this.getDuration();
+    return duration ? duration / 1000 : 0;
+  }
+
+  isRunning() {
+    const timer = Timers.getTimer(this.id);
+    return timer.start !== null && timer.duration === null;
+  }
+
+  isCompleted() {
     const timer = Timers.getTimer(this.id);
-    return timer.duration / 1000;
+    return timer.duration !== null;
   }
 
   get id() {
diff --git a/e2e/api-mocking/mock-config/perps-controller-mixin.ts b/e2e/api-mocking/mock-config/perps-controller-mixin.ts
new file mode 100644
index 00000000000..d9490746145
--- /dev/null
+++ b/e2e/api-mocking/mock-config/perps-controller-mixin.ts
@@ -0,0 +1,362 @@
+/**
+ * E2E Perps Controller Mixin
+ *
+ * Applies E2E mocking methods to the existing PerpsController
+ * during E2E test initialization. This approach allows us to override
+ * controller methods without modifying production code.
+ */
+
+import { PerpsE2EMockService } from '../mock-responses/perps-e2e-mocks';
+import type {
+  OrderParams,
+  OrderResult,
+  AccountState,
+  Position,
+  Order,
+  OrderFill,
+  PriceUpdate,
+  ClosePositionParams,
+} from '../../../app/components/UI/Perps/controllers/types';
+import type { PerpsControllerState } from '../../../app/components/UI/Perps/controllers/PerpsController';
+
+// Interface for controller with update method access
+interface ControllerWithUpdate {
+  update: (fn: (state: PerpsControllerState) => void) => void;
+}
+
+/**
+ * E2E Controller Method Overrides
+ * These methods replace controller methods when applied via applyE2EPerpsControllerMocks
+ */
+export class E2EControllerOverrides {
+  private mockService = PerpsE2EMockService.getInstance();
+  private controller: unknown; // Reference to the actual controller for Redux updates
+
+  constructor(controller: unknown) {
+    this.controller = controller;
+  }
+
+  // Mock order placement
+  async placeOrder(params: OrderParams): Promise<OrderResult> {
+    console.log('E2E Mock: Intercepted placeOrder:', params.coin);
+    const result = await this.mockService.mockPlaceOrder(params);
+
+    // Update Redux state to reflect the new position/balance
+    const mockAccount = this.mockService.getMockAccountState();
+    const mockPositions = this.mockService.getMockPositions();
+
+    (this.controller as ControllerWithUpdate).update(
+      (state: PerpsControllerState) => {
+        state.accountState = mockAccount;
+        state.positions = mockPositions;
+        state.lastUpdateTimestamp = Date.now();
+        state.lastError = null;
+      },
+    );
+
+    return result;
+  }
+
+  // Mock account state with Redux update
+  async getAccountState(): Promise<AccountState> {
+    console.log('E2E Mock: Intercepted getAccountState');
+    const mockAccount = this.mockService.getMockAccountState();
+
+    // Update Redux state just like the real controller does
+    (this.controller as ControllerWithUpdate).update(
+      (state: PerpsControllerState) => {
+        state.accountState = mockAccount;
+        state.lastUpdateTimestamp = Date.now();
+        state.lastError = null;
+      },
+    );
+
+    return mockAccount;
+  }
+
+  // Mock positions with Redux update
+  async getPositions(): Promise<Position[]> {
+    console.log('E2E Mock: Intercepted getPositions');
+    const mockPositions = this.mockService.getMockPositions();
+
+    // Update Redux state
+    (this.controller as ControllerWithUpdate).update(
+      (state: PerpsControllerState) => {
+        state.positions = mockPositions;
+        state.lastUpdateTimestamp = Date.now();
+        state.lastError = null;
+      },
+    );
+
+    return mockPositions;
+  }
+
+  // Mock close position
+  async closePosition(params: ClosePositionParams): Promise<OrderResult> {
+    console.log('E2E Mock: Intercepted closePosition:', {
+      coin: params.coin,
+      size: params.size,
+      orderType: params.orderType,
+    });
+
+    const result = await this.mockService.mockClosePosition(
+      params.coin,
+      params.size,
+    );
+
+    // Update Redux state to reflect the position closure
+    const mockAccount = this.mockService.getMockAccountState();
+    const mockPositions = this.mockService.getMockPositions();
+
+    (this.controller as ControllerWithUpdate).update(
+      (state: PerpsControllerState) => {
+        state.accountState = mockAccount;
+        state.positions = mockPositions;
+        state.lastUpdateTimestamp = Date.now();
+        state.lastError = null;
+      },
+    );
+
+    return result;
+  }
+
+  // Mock account subscription
+  subscribeToAccount(params: {
+    callback: (data: AccountState) => void;
+  }): () => void {
+    console.log('E2E Mock: Intercepted subscribeToAccount');
+    const mockAccount = this.mockService.getMockAccountState();
+
+    // Register for live updates
+    this.mockService.registerAccountCallback(params.callback);
+
+    // Send initial data
+    setTimeout(() => params.callback(mockAccount), 0);
+    return () => this.mockService.unregisterAccountCallback(params.callback);
+  }
+
+  // Mock positions subscription
+  subscribeToPositions(params: {
+    callback: (data: Position[]) => void;
+  }): () => void {
+    console.log('E2E Mock: Intercepted subscribeToPositions');
+    const mockPositions = this.mockService.getMockPositions();
+
+    // Register for live updates
+    this.mockService.registerPositionCallback(params.callback);
+
+    // Send initial data
+    setTimeout(() => params.callback(mockPositions), 0);
+    return () => this.mockService.unregisterPositionCallback(params.callback);
+  }
+
+  // Mock orders subscription
+  subscribeToOrders(params: { callback: (data: Order[]) => void }): () => void {
+    console.log('E2E Mock: Intercepted subscribeToOrders');
+    const mockOrders = this.mockService.getMockOrders();
+    setTimeout(() => params.callback(mockOrders), 0);
+    return () => undefined;
+  }
+
+  // Mock order fills subscription
+  subscribeToOrderFills(params: {
+    callback: (data: OrderFill[]) => void;
+  }): () => void {
+    console.log('E2E Mock: Intercepted subscribeToOrderFills');
+    const mockFills = this.mockService.getMockOrderFills();
+    setTimeout(() => params.callback(mockFills), 0);
+    return () => undefined;
+  }
+
+  // Mock price subscription
+  subscribeToPrices(params: {
+    symbols: string[];
+    callback: (data: PriceUpdate[]) => void;
+  }): () => void {
+    console.log('E2E Mock: Intercepted subscribeToPrices:', params.symbols);
+    const allPrices = this.mockService.getMockPrices();
+
+    const filteredPrices: PriceUpdate[] = params.symbols
+      .map((symbol) => allPrices[symbol])
+      .filter(Boolean);
+
+    setTimeout(() => params.callback(filteredPrices), 0);
+    return () => undefined;
+  }
+}
+
+/**
+ * Apply E2E mocks to PerpsController
+ * This function should be called during E2E test initialization
+ */
+export function applyE2EPerpsControllerMocks(controller: unknown): void {
+  console.log('Applying E2E mocks to PerpsController...');
+
+  const overrides = new E2EControllerOverrides(controller);
+
+  // Override key methods with E2E mocks
+  const methodsToOverride = [
+    'placeOrder',
+    'getAccountState',
+    'getPositions',
+    'closePosition',
+    'subscribeToAccount',
+    'subscribeToPositions',
+    'subscribeToOrders',
+    'subscribeToOrderFills',
+    'subscribeToPrices',
+  ];
+
+  methodsToOverride.forEach((method) => {
+    if (
+      (controller as unknown as Record<string, unknown>)[method] &&
+      (overrides as unknown as Record<string, unknown>)[method]
+    ) {
+      // Store original for potential restoration
+      (controller as unknown as Record<string, unknown>)[
+        `_original_${method}`
+      ] = (controller as unknown as Record<string, unknown>)[method];
+      // Apply mock override
+      (controller as unknown as Record<string, unknown>)[method] = (
+        (overrides as unknown as Record<string, unknown>)[method] as (
+          ...args: unknown[]
+        ) => unknown
+      ).bind(overrides);
+      console.log(`Mocked ${method} method`);
+    }
+  });
+
+  // Initialize Redux state with mock data immediately
+  const mockService = PerpsE2EMockService.getInstance();
+
+  // If the controller has a mockProfile in its state (injected via Fixture), apply it
+  try {
+    const maybeState = (controller as { state?: { mockProfile?: string } })
+      ?.state;
+    if (maybeState?.mockProfile) {
+      console.log(
+        'E2E Mock: Applying profile from fixture:',
+        maybeState.mockProfile,
+      );
+      PerpsE2EMockService.setProfile(maybeState.mockProfile);
+      mockService.reset();
+    }
+  } catch (e) {
+    // no-op if structure differs
+  }
+  const mockAccount = mockService.getMockAccountState();
+  const mockPositions = mockService.getMockPositions();
+
+  console.log('Initializing Redux state with mock data:', {
+    availableBalance: mockAccount.availableBalance,
+    totalBalance: mockAccount.totalBalance,
+    positionsCount: mockPositions.length,
+  });
+
+  (controller as ControllerWithUpdate).update((state: PerpsControllerState) => {
+    state.accountState = mockAccount;
+    state.positions = mockPositions;
+    state.lastUpdateTimestamp = Date.now();
+    state.lastError = null;
+    state.connectionStatus = 'connected';
+    state.isEligible = true;
+  });
+
+  console.log('✅ E2E PerpsController mocks applied with initial state');
+}
+
+/**
+ * Create E2E mock stream manager for PerpsStreamProvider
+ */
+export function createE2EMockStreamManager(): unknown {
+  console.log('Creating E2E mock stream manager');
+
+  // Use centralized E2E mock service for consistent state
+  const mockService = PerpsE2EMockService.getInstance();
+  const mockMarkets = mockService.getMockMarkets();
+  const mockPrices = mockService.getMockPrices();
+
+  return {
+    prices: {
+      subscribe: (params: {
+        callback: (data: Record<string, PriceUpdate>) => void;
+      }) => {
+        setTimeout(() => params.callback(mockPrices), 0);
+        return () => undefined;
+      },
+      subscribeToSymbols: (params: {
+        callback: (data: Record<string, PriceUpdate>) => void;
+        symbols: string[];
+      }) => {
+        const filteredPrices = Object.fromEntries(
+          params.symbols
+            .map((symbol) => [symbol, mockPrices[symbol]])
+            .filter(([, price]) => price),
+        );
+        setTimeout(() => params.callback(filteredPrices), 0);
+        return () => undefined;
+      },
+    },
+    marketData: {
+      subscribe: (params: { callback: (data: unknown[]) => void }) => {
+        console.log('E2E Mock: marketData.subscribe called');
+        console.log(
+          'E2E Mock: Providing markets:',
+          mockMarkets.length,
+          'markets',
+        );
+        console.log(
+          'E2E Mock: Market symbols:',
+          mockMarkets.map((m) => m.symbol),
+        );
+        setTimeout(() => {
+          console.log(
+            'E2E Mock: Calling market data callback with',
+            mockMarkets.length,
+            'markets',
+          );
+          params.callback(mockMarkets);
+        }, 0);
+        return () => undefined;
+      },
+    },
+    account: {
+      subscribe: (params: {
+        callback: (data: AccountState | null) => void;
+      }) => {
+        // Register callback for live updates
+        mockService.registerAccountCallback(params.callback);
+        // Send initial data
+        setTimeout(() => params.callback(mockService.getMockAccountState()), 0);
+        return () => mockService.unregisterAccountCallback(params.callback);
+      },
+    },
+    orders: {
+      subscribe: (params: { callback: (data: Order[]) => void }) => {
+        setTimeout(() => params.callback(mockService.getMockOrders()), 0);
+        return () => undefined;
+      },
+    },
+    positions: {
+      subscribe: (params: { callback: (data: Position[]) => void }) => {
+        // Register callback for live updates when positions change
+        mockService.registerPositionCallback(params.callback);
+        // Send initial data
+        setTimeout(() => params.callback(mockService.getMockPositions()), 0);
+        return () => mockService.unregisterPositionCallback(params.callback);
+      },
+    },
+    fills: {
+      subscribe: (params: { callback: (data: OrderFill[]) => void }) => {
+        setTimeout(() => params.callback(mockService.getMockOrderFills()), 0);
+        return () => undefined;
+      },
+    },
+  };
+}
+
+export default {
+  applyE2EPerpsControllerMocks,
+  createE2EMockStreamManager,
+  PerpsE2EMockService,
+};
diff --git a/e2e/api-mocking/mock-responses/perps-arbitrum-mocks.ts b/e2e/api-mocking/mock-responses/perps-arbitrum-mocks.ts
new file mode 100644
index 00000000000..44fd18129b4
--- /dev/null
+++ b/e2e/api-mocking/mock-responses/perps-arbitrum-mocks.ts
@@ -0,0 +1,146 @@
+/* eslint-disable no-console */
+/**
+ * Arbitrum RPC Mocks for Perps E2E Testing
+ *
+ * Mocks Arbitrum network calls to return static data quickly,
+ * preventing long-running network requests that block Detox.
+ */
+
+import type { Mockttp } from 'mockttp';
+import type { TestSpecificMock } from '../../framework';
+
+// Static mock responses for Arbitrum RPC calls
+const MOCK_RESPONSES: Record<string, unknown> = {
+  // eth_chainId
+  eth_chainId: '0xa4b1', // Arbitrum One chain ID
+
+  // eth_getBalance - mock balance
+  eth_getBalance: '0x0', // 0 ETH balance
+
+  // eth_call - contract calls (return empty data)
+  eth_call: '0x',
+
+  // eth_estimateGas - gas estimation
+  eth_estimateGas: '0x5208', // 21000 gas
+
+  // eth_gasPrice - gas price
+  eth_gasPrice: '0x9c7652400', // 42 gwei
+
+  // eth_getTransactionCount - nonce
+  eth_getTransactionCount: '0x0',
+
+  // eth_blockNumber - latest block
+  eth_blockNumber: '0x1234567',
+
+  // eth_getBlockByNumber - block data
+  eth_getBlockByNumber: {
+    number: '0x1234567',
+    hash: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+    timestamp: '0x' + Math.floor(Date.now() / 1000).toString(16),
+    gasLimit: '0x1c9c380',
+    gasUsed: '0x5208',
+    transactions: [],
+  },
+
+  // net_version
+  net_version: '42161', // Arbitrum One network ID
+};
+
+/**
+ * Simple SVG placeholder for coin images in E2E tests
+ */
+const MOCK_COIN_SVG = `<svg width="24" height="24" xmlns="http://www.w3.org/2000/svg">
+    <circle cx="12" cy="12" r="10" fill="lightgray"/>
+    <text x="12" y="16" text-anchor="middle" font-size="12" fill="gray">$</text>
+  </svg>`;
+
+/**
+ * TestSpecificMock function for Perps testing
+ * Sets up mocks to prevent live network requests to Arbitrum during E2E tests
+ */
+export const PERPS_ARBITRUM_MOCKS: TestSpecificMock = async (
+  mockServer: Mockttp,
+) => {
+  const ARBITRUM_RPC_URL = 'https://arb1.arbitrum.io/rpc';
+
+  // Mock Arbitrum RPC endpoint through the mobile proxy
+  await mockServer
+    .forPost('/proxy')
+    .matching((request) => {
+      const urlParam = new URL(request.url).searchParams.get('url');
+      return Boolean(urlParam?.includes(ARBITRUM_RPC_URL));
+    })
+    .asPriority(1000)
+    .thenCallback(async (request) => {
+      try {
+        const bodyText = await request.body.getText();
+        const body = bodyText ? JSON.parse(bodyText) : undefined;
+
+        console.log('[Perps E2E Mock] Intercepted Arbitrum RPC call');
+
+        // Handle batch requests
+        if (Array.isArray(body)) {
+          const results = body.map((req) => ({
+            id: req.id,
+            jsonrpc: '2.0',
+            result:
+              (MOCK_RESPONSES as Record<string, unknown>)[req.method] || '0x',
+          }));
+
+          return {
+            statusCode: 200,
+            body: JSON.stringify(results),
+          };
+        }
+
+        // Handle single requests
+        const method = body?.method as string | undefined;
+        const result = method
+          ? (MOCK_RESPONSES as Record<string, unknown>)[method] || '0x'
+          : '0x';
+
+        return {
+          statusCode: 200,
+          body: JSON.stringify({
+            id: body?.id ?? 1,
+            jsonrpc: '2.0',
+            result,
+          }),
+        };
+      } catch (error) {
+        console.log('[Perps E2E Mock] Error parsing request body:', error);
+        return {
+          statusCode: 200,
+          body: JSON.stringify({
+            id: 1,
+            jsonrpc: '2.0',
+            result: '0x',
+          }),
+        };
+      }
+    });
+
+  // Mock HyperLiquid coin image requests through the mobile proxy
+  await mockServer
+    .forGet('/proxy')
+    .matching((request) => {
+      const urlParam = new URL(request.url).searchParams.get('url');
+      return urlParam
+        ? /^https:\/\/app\.hyperliquid\.xyz\/coins\/.*\.svg$/.test(urlParam)
+        : false;
+    })
+    .asPriority(1000)
+    .thenCallback(() => {
+      console.log(
+        '[Perps E2E Mock] Intercepted HyperLiquid coin image request',
+      );
+      return {
+        statusCode: 200,
+        body: MOCK_COIN_SVG,
+        headers: {
+          'Content-Type': 'image/svg+xml',
+          'Cache-Control': 'public, max-age=3600',
+        },
+      };
+    });
+};
diff --git a/e2e/api-mocking/mock-responses/perps-e2e-mocks.ts b/e2e/api-mocking/mock-responses/perps-e2e-mocks.ts
new file mode 100644
index 00000000000..c54b97811fe
--- /dev/null
+++ b/e2e/api-mocking/mock-responses/perps-e2e-mocks.ts
@@ -0,0 +1,537 @@
+/**
+ * Perps E2E Mock Service
+ *
+ * Provides mock data and state management for Perps E2E tests.
+ * This service simulates the Hyperliquid SDK and controller responses
+ * without requiring real network calls or testnet funds.
+ */
+
+import type {
+  AccountState,
+  Position,
+  Order,
+  OrderFill,
+  OrderParams,
+  OrderResult,
+  PriceUpdate,
+  PerpsMarketData,
+  WithdrawParams,
+  WithdrawResult,
+  Funding,
+} from '../../../app/components/UI/Perps/controllers/types';
+
+export class PerpsE2EMockService {
+  private static instance: PerpsE2EMockService;
+  private static activeProfile: string | null = null;
+
+  // Mock state that persists across the E2E session
+  private mockAccount: AccountState = {
+    totalBalance: '10000.00',
+    availableBalance: '8000.00',
+    marginUsed: '2000.00',
+    unrealizedPnl: '150.00',
+    returnOnEquity: '0',
+    totalValue: '10000.00',
+  };
+
+  private mockPositions: Position[] = [];
+  private mockOrders: Order[] = [];
+  private mockOrderFills: OrderFill[] = [];
+
+  private orderIdCounter = 1;
+  private fillIdCounter = 1;
+
+  // Stream callbacks to notify about data changes
+  private positionCallbacks: ((positions: Position[]) => void)[] = [];
+  private accountCallbacks: ((account: AccountState) => void)[] = [];
+
+  private constructor() {
+    this.reset();
+  }
+
+  public static getInstance(): PerpsE2EMockService {
+    if (!PerpsE2EMockService.instance) {
+      PerpsE2EMockService.instance = new PerpsE2EMockService();
+    }
+    return PerpsE2EMockService.instance;
+  }
+
+  // Allow E2E to set a mock "profile" that controls initial state
+  public static setProfile(profile: string | null) {
+    PerpsE2EMockService.activeProfile = profile;
+  }
+
+  // Reset state for fresh test runs
+  public reset(): void {
+    const profile = PerpsE2EMockService.activeProfile;
+
+    // Default account state
+    this.mockAccount = {
+      totalBalance: profile === 'no-funds' ? '0.00' : '10000.00',
+      availableBalance: profile === 'no-funds' ? '0.00' : '8000.00',
+      marginUsed: profile === 'no-funds' ? '0.00' : '2000.00',
+      // Set a temporary value; we will recompute from positions below
+      unrealizedPnl: '0.00',
+      returnOnEquity: '0',
+      totalValue: profile === 'no-funds' ? '0.00' : '10000.00',
+    };
+
+    // Positions based on profile
+    if (profile === 'no-funds' || profile === 'no-positions') {
+      this.mockPositions = [];
+    } else if (profile === 'position-testing') {
+      // Rich set of positions for UI validation
+      this.mockPositions = [
+        {
+          coin: 'ETH',
+          entryPrice: '2500.00',
+          size: '1.0', // long
+          positionValue: '2500.00',
+          unrealizedPnl: '125.00',
+          marginUsed: '833.33',
+          leverage: { type: 'cross', value: 3 },
+          liquidationPrice: '2000.00',
+          maxLeverage: 40,
+          returnOnEquity: '0.05', // 5%
+          cumulativeFunding: { allTime: '0', sinceChange: '0', sinceOpen: '0' },
+        },
+        {
+          coin: 'BTC',
+          entryPrice: '45000.00',
+          size: '-0.05', // short
+          positionValue: '2250.00',
+          unrealizedPnl: '-50.00',
+          marginUsed: '225.00',
+          leverage: { type: 'cross', value: 10 },
+          liquidationPrice: '47250.00',
+          maxLeverage: 40,
+          returnOnEquity: '-0.02', // -2%
+          cumulativeFunding: { allTime: '0', sinceChange: '0', sinceOpen: '0' },
+        },
+        {
+          coin: 'SOL',
+          entryPrice: '100.00',
+          size: '5', // long
+          positionValue: '500.00',
+          unrealizedPnl: '25.00',
+          marginUsed: '25.00',
+          leverage: { type: 'cross', value: 20 },
+          liquidationPrice: '80.00',
+          maxLeverage: 40,
+          returnOnEquity: '0.10', // 10%
+          cumulativeFunding: { allTime: '0', sinceChange: '0', sinceOpen: '0' },
+        },
+      ];
+    } else {
+      this.mockPositions = [
+        {
+          coin: 'BTC',
+          entryPrice: '45000.00',
+          size: '0.1',
+          positionValue: '4500.00',
+          unrealizedPnl: '150.00',
+          marginUsed: '900.00',
+          leverage: {
+            type: 'cross',
+            value: 5,
+          },
+          liquidationPrice: '36000.00',
+          maxLeverage: 40,
+          returnOnEquity: '0.167',
+          cumulativeFunding: {
+            allTime: '0',
+            sinceChange: '0',
+            sinceOpen: '0',
+          },
+        },
+      ];
+    }
+
+    // Recompute account-level unrealized PnL from the sum of positions
+    this.mockAccount = {
+      ...this.mockAccount,
+      unrealizedPnl: this.computeTotalUnrealizedPnl().toFixed(2),
+    };
+
+    this.mockOrders = [];
+    this.mockOrderFills = [];
+    this.orderIdCounter = 1;
+    this.fillIdCounter = 1;
+
+    // Clear callbacks
+    this.positionCallbacks = [];
+    this.accountCallbacks = [];
+  }
+
+  // Mock successful order placement
+  public async mockPlaceOrder(params: OrderParams): Promise<OrderResult> {
+    const orderId = `mock_order_${this.orderIdCounter++}`;
+
+    // Calculate mock values
+    const notionalValue =
+      parseFloat(params.size) * (params.currentPrice || 50000);
+    const marginUsed = notionalValue / (params.leverage || 1);
+
+    // Update available balance
+    const newAvailableBalance =
+      parseFloat(this.mockAccount.availableBalance) - marginUsed;
+    const newMarginUsed = parseFloat(this.mockAccount.marginUsed) + marginUsed;
+
+    this.mockAccount = {
+      ...this.mockAccount,
+      availableBalance: newAvailableBalance.toString(),
+      marginUsed: newMarginUsed.toString(),
+    };
+
+    // Determine signed size based on direction (long = +, short = -)
+    const numericSize = Math.abs(parseFloat(params.size));
+    const signedSize = params.isBuy
+      ? numericSize.toString()
+      : (-numericSize).toString();
+
+    // Create mock position
+    const mockPosition: Position = {
+      coin: params.coin,
+      entryPrice: (params.currentPrice || 50000).toString(),
+      size: signedSize,
+      positionValue: notionalValue.toString(),
+      unrealizedPnl: '0',
+      marginUsed: marginUsed.toString(),
+      leverage: {
+        type: 'cross',
+        value: params.leverage || 1,
+      },
+      liquidationPrice: this.calculateMockLiquidationPrice(
+        params.currentPrice || 50000,
+        params.leverage || 1,
+        params.isBuy,
+      ).toString(),
+      maxLeverage: 50,
+      returnOnEquity: '0',
+      cumulativeFunding: {
+        allTime: '0',
+        sinceChange: '0',
+        sinceOpen: '0',
+      },
+    };
+
+    // Add to mock state
+    this.mockPositions.push(mockPosition);
+
+    // Create mock order fill
+    const mockFill: OrderFill = {
+      orderId,
+      symbol: params.coin,
+      size: params.size,
+      price: (params.currentPrice || 50000).toString(),
+      timestamp: Date.now(),
+      side: params.isBuy ? 'buy' : 'sell',
+      fee: '2.50',
+      feeToken: 'USDC',
+      pnl: '0.00',
+      direction: params.isBuy ? 'long' : 'short',
+    };
+
+    this.mockOrderFills.push(mockFill);
+
+    // Notify subscribers
+    this.notifyPositionCallbacks();
+    this.notifyAccountCallbacks();
+
+    return {
+      success: true,
+      orderId,
+    };
+  }
+
+  // Mock withdrawal (reserved for upcoming tests)
+  public async mockWithdraw(params: WithdrawParams): Promise<WithdrawResult> {
+    const withdrawAmount = parseFloat(params.amount);
+    const currentBalance = parseFloat(this.mockAccount.availableBalance);
+
+    if (withdrawAmount > currentBalance) {
+      return {
+        success: false,
+        error: 'Insufficient balance',
+      };
+    }
+
+    // Update balances
+    const newAvailableBalance = currentBalance - withdrawAmount;
+    const newTotalBalance =
+      parseFloat(this.mockAccount.totalBalance) - withdrawAmount;
+
+    this.mockAccount = {
+      ...this.mockAccount,
+      totalBalance: newTotalBalance.toString(),
+      availableBalance: newAvailableBalance.toString(),
+    };
+
+    // Notify subscribers
+    this.notifyAccountCallbacks();
+
+    return {
+      success: true,
+      txHash: `0x${Math.random().toString(16).slice(2)}`,
+      withdrawalId: `mock_withdrawal_${Date.now()}`,
+      estimatedArrivalTime: Date.now() + 5 * 60 * 1000, // 5 minutes
+    };
+  }
+
+  // Mock close position
+  public async mockClosePosition(
+    coin: string,
+    _size?: string,
+  ): Promise<OrderResult> {
+    const existingPosition = this.mockPositions.find((p) => p.coin === coin);
+    if (!existingPosition) {
+      return {
+        success: false,
+        error: 'Position not found',
+      };
+    }
+
+    // Use the current unrealized PnL of the position as the realized PnL on close
+    // This keeps UI estimates and account updates consistent and avoids sign errors
+    const pnl = parseFloat(existingPosition.unrealizedPnl || '0');
+
+    // Update account balances with realized PnL
+    const newAvailableBalance =
+      parseFloat(this.mockAccount.availableBalance) +
+      parseFloat(existingPosition.marginUsed) +
+      pnl;
+    const newMarginUsed =
+      parseFloat(this.mockAccount.marginUsed) -
+      parseFloat(existingPosition.marginUsed);
+    const newTotalBalance = parseFloat(this.mockAccount.totalBalance) + pnl;
+    this.mockAccount = {
+      ...this.mockAccount,
+      availableBalance: newAvailableBalance.toString(),
+      marginUsed: newMarginUsed.toString(),
+      totalBalance: newTotalBalance.toString(),
+    };
+
+    // Remove position
+    this.mockPositions = this.mockPositions.filter((p) => p.coin !== coin);
+
+    // Recompute account unrealized PnL based on remaining positions
+    const recomputedUnrealized = this.computeTotalUnrealizedPnl();
+    this.mockAccount.unrealizedPnl = recomputedUnrealized.toFixed(2);
+    // Keep totalValue aligned with equity (realized + unrealized)
+    this.mockAccount.totalValue = (
+      parseFloat(this.mockAccount.totalBalance) + recomputedUnrealized
+    ).toFixed(2);
+
+    // Notify position subscribers about the change
+    this.notifyPositionCallbacks();
+
+    // Notify account subscribers about balance change
+    this.notifyAccountCallbacks();
+
+    return {
+      success: true,
+      orderId: `mock_close_${this.orderIdCounter++}`,
+    };
+  }
+
+  // Callback management methods
+  public registerPositionCallback(
+    callback: (positions: Position[]) => void,
+  ): void {
+    this.positionCallbacks.push(callback);
+  }
+
+  public unregisterPositionCallback(
+    callback: (positions: Position[]) => void,
+  ): void {
+    this.positionCallbacks = this.positionCallbacks.filter(
+      (cb) => cb !== callback,
+    );
+  }
+
+  public registerAccountCallback(
+    callback: (account: AccountState) => void,
+  ): void {
+    this.accountCallbacks.push(callback);
+  }
+
+  public unregisterAccountCallback(
+    callback: (account: AccountState) => void,
+  ): void {
+    this.accountCallbacks = this.accountCallbacks.filter(
+      (cb) => cb !== callback,
+    );
+  }
+
+  private notifyPositionCallbacks(): void {
+    console.log(
+      '🎭 E2E Mock: Notifying position callbacks, positions count:',
+      this.mockPositions.length,
+    );
+    this.positionCallbacks.forEach((callback) => {
+      try {
+        callback([...this.mockPositions]); // Send a copy
+      } catch (error) {
+        console.warn('Error in position callback:', error);
+      }
+    });
+  }
+
+  private notifyAccountCallbacks(): void {
+    console.log(
+      '🎭 E2E Mock: Notifying account callbacks, balance:',
+      this.mockAccount.availableBalance,
+    );
+    this.accountCallbacks.forEach((callback) => {
+      try {
+        callback({ ...this.mockAccount }); // Send a copy
+      } catch (error) {
+        console.warn('Error in account callback:', error);
+      }
+    });
+  }
+
+  // Getter methods
+  public getMockAccountState(): AccountState {
+    return { ...this.mockAccount };
+  }
+
+  public getMockPositions(): Position[] {
+    return [...this.mockPositions];
+  }
+
+  public getMockOrders(): Order[] {
+    return [...this.mockOrders];
+  }
+
+  public getMockOrderFills(): OrderFill[] {
+    return [...this.mockOrderFills];
+  }
+
+  public getMockMarkets(): PerpsMarketData[] {
+    return [
+      {
+        symbol: 'BTC',
+        name: 'Bitcoin',
+        maxLeverage: '40x',
+        price: '$45,000.00',
+        change24h: '+$1,125.00',
+        change24hPercent: '+2.5%',
+        volume: '$1.2B',
+        nextFundingTime: Date.now() + 8 * 60 * 60 * 1000, // 8 hours from now
+        fundingIntervalHours: 8,
+      },
+      {
+        symbol: 'ETH',
+        name: 'Ethereum',
+        maxLeverage: '40x',
+        price: '$2,500.00',
+        change24h: '+$45.00',
+        change24hPercent: '+1.8%',
+        volume: '$850M',
+        nextFundingTime: Date.now() + 8 * 60 * 60 * 1000, // 8 hours from now
+        fundingIntervalHours: 8,
+      },
+      {
+        symbol: 'SOL',
+        name: 'Solana',
+        maxLeverage: '40x',
+        price: '$98.50',
+        change24h: '-$2.30',
+        change24hPercent: '-2.3%',
+        volume: '$425M',
+        nextFundingTime: Date.now() + 8 * 60 * 60 * 1000, // 8 hours from now
+        fundingIntervalHours: 8,
+      },
+    ];
+  }
+
+  public getMockPrices(): Record<string, PriceUpdate> {
+    return {
+      BTC: {
+        coin: 'BTC',
+        price: '45000.00',
+        timestamp: Date.now(),
+        percentChange24h: '2.5',
+        bestBid: '44995.00',
+        bestAsk: '45005.00',
+        spread: '10.00',
+        markPrice: '45000.00',
+        funding: 0.01,
+        openInterest: 50000000,
+        volume24h: 1000000,
+      },
+      ETH: {
+        coin: 'ETH',
+        price: '2500.00',
+        timestamp: Date.now(),
+        percentChange24h: '1.8',
+        bestBid: '2499.50',
+        bestAsk: '2500.50',
+        spread: '1.00',
+        markPrice: '2500.00',
+        funding: 0.005,
+        openInterest: 25000000,
+        volume24h: 500000,
+      },
+      SOL: {
+        coin: 'SOL',
+        price: '100.00',
+        timestamp: Date.now(),
+        percentChange24h: '-2.3',
+        bestBid: '99.90',
+        bestAsk: '100.10',
+        spread: '0.20',
+        markPrice: '100.00',
+        funding: 0.003,
+        openInterest: 12000000,
+        volume24h: 300000,
+      },
+    };
+  }
+
+  // Mock funding endpoint (reserved for upcoming tests)
+  public async mockGetFunding(): Promise<Funding[]> {
+    return [
+      {
+        symbol: 'BTC',
+        amountUsd: '1.50',
+        rate: '0.0125',
+        timestamp: Date.now(),
+      },
+    ];
+  }
+
+  private calculateMockLiquidationPrice(
+    entryPrice: number,
+    leverage: number,
+    isBuy: boolean,
+  ): number {
+    // Simplified liquidation price calculation for mocking
+    const maintenanceMarginRate = 0.05; // 5%
+    const liquidationBuffer =
+      entryPrice * (1 - 1 / leverage + maintenanceMarginRate);
+
+    return isBuy
+      ? entryPrice - liquidationBuffer
+      : entryPrice + liquidationBuffer;
+  }
+
+  private computeTotalUnrealizedPnl(): number {
+    return this.mockPositions.reduce((acc, pos) => {
+      const val = parseFloat(pos.unrealizedPnl || '0');
+      return acc + (isNaN(val) ? 0 : val);
+    }, 0);
+  }
+
+  // Update an existing position and notify subscribers (reserved for upcoming tests)
+  public mockUpdatePosition(coin: string, updates: Partial<Position>): boolean {
+    const index = this.mockPositions.findIndex((p) => p.coin === coin);
+    if (index === -1) return false;
+    this.mockPositions[index] = { ...this.mockPositions[index], ...updates };
+    this.notifyPositionCallbacks();
+    return true;
+  }
+}
+
+export default PerpsE2EMockService;
diff --git a/e2e/framework/fixtures/FixtureBuilder.ts b/e2e/framework/fixtures/FixtureBuilder.ts
index 2e0d534e81d..12d44968b84 100644
--- a/e2e/framework/fixtures/FixtureBuilder.ts
+++ b/e2e/framework/fixtures/FixtureBuilder.ts
@@ -113,6 +113,34 @@ class FixtureBuilder {
     return this;
   }
 
+  /**
+   * Defines a Perps profile for E2E mocks.
+   * The value is stored in the PerpsController state so that the mocks can read it.
+   * @param profile Profile, e.g.: 'no-funds', 'default'.
+   * @returns {FixtureBuilder}
+   */
+  withPerpsProfile(profile: string) {
+    merge(this.fixture.state.engine.backgroundState.PerpsController, {
+      // Field only for E2E; read by the mocks mixin
+      mockProfile: profile,
+    });
+    return this;
+  }
+
+  /**
+   * Forces the Perps first-time flag in the initial state.
+   * @param firstTime true to show tutorial; false to mark as seen.
+   */
+  withPerpsFirstTimeUser(firstTime: boolean) {
+    merge(this.fixture.state.engine.backgroundState.PerpsController, {
+      isFirstTimeUser: {
+        testnet: firstTime,
+        mainnet: firstTime,
+      },
+    });
+    return this;
+  }
+
   withSolanaFeatureSheetDisplayed() {
     if (!this.fixture.asyncState) {
       this.fixture.asyncState = {};
@@ -520,6 +548,12 @@ class FixtureBuilder {
               events: {},
             },
             SnapController: {},
+            PerpsController: {
+              isFirstTimeUser: {
+                testnet: false,
+                mainnet: false,
+              },
+            },
             NetworkEnablementController: {},
           },
         },
diff --git a/e2e/pages/Browser/ConnectedAccountsModal.ts b/e2e/pages/Browser/ConnectedAccountsModal.ts
index 2131c8a54c8..3eae58db7f3 100644
--- a/e2e/pages/Browser/ConnectedAccountsModal.ts
+++ b/e2e/pages/Browser/ConnectedAccountsModal.ts
@@ -133,6 +133,7 @@ class ConnectedAccountsModal {
   async tapManagePermissionsButton(): Promise<void> {
     await Gestures.waitAndTap(this.managePermissionsButton, {
       elemDescription: 'Manage permissions button',
+      waitForElementToDisappear: true,
     });
   }
 
diff --git a/e2e/pages/Perps/PerpsMarketDetailsView.ts b/e2e/pages/Perps/PerpsMarketDetailsView.ts
new file mode 100644
index 00000000000..79e17206f9e
--- /dev/null
+++ b/e2e/pages/Perps/PerpsMarketDetailsView.ts
@@ -0,0 +1,198 @@
+import {
+  PerpsMarketDetailsViewSelectorsIDs,
+  PerpsMarketHeaderSelectorsIDs,
+  PerpsCandlestickChartSelectorsIDs,
+} from '../../selectors/Perps/Perps.selectors';
+import Gestures from '../../framework/Gestures';
+import Matchers from '../../framework/Matchers';
+
+class PerpsMarketDetailsView {
+  // Container elements
+  get container() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.CONTAINER,
+    );
+  }
+
+  get loadingState() {
+    return Matchers.getElementByID(PerpsMarketDetailsViewSelectorsIDs.LOADING);
+  }
+
+  get errorState() {
+    return Matchers.getElementByID(PerpsMarketDetailsViewSelectorsIDs.ERROR);
+  }
+
+  // Header elements
+  get header() {
+    return Matchers.getElementByID(PerpsMarketDetailsViewSelectorsIDs.HEADER);
+  }
+
+  get backButton() {
+    return Matchers.getElementByID(PerpsMarketHeaderSelectorsIDs.BACK_BUTTON);
+  }
+
+  get assetIcon() {
+    return Matchers.getElementByID(PerpsMarketHeaderSelectorsIDs.ASSET_ICON);
+  }
+
+  get assetName() {
+    return Matchers.getElementByID(PerpsMarketHeaderSelectorsIDs.ASSET_NAME);
+  }
+
+  get price() {
+    return Matchers.getElementByID(PerpsMarketHeaderSelectorsIDs.PRICE);
+  }
+
+  get priceChange() {
+    return Matchers.getElementByID(PerpsMarketHeaderSelectorsIDs.PRICE_CHANGE);
+  }
+
+  get moreButton() {
+    return Matchers.getElementByID(PerpsMarketHeaderSelectorsIDs.MORE_BUTTON);
+  }
+
+  // Statistics elements
+  get statisticsHigh24h() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.STATISTICS_HIGH_24H,
+    );
+  }
+
+  get statisticsLow24h() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.STATISTICS_LOW_24H,
+    );
+  }
+
+  get statisticsVolume24h() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.STATISTICS_VOLUME_24H,
+    );
+  }
+
+  get statisticsOpenInterest() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.STATISTICS_OPEN_INTEREST,
+    );
+  }
+
+  get statisticsFundingRate() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.STATISTICS_FUNDING_RATE,
+    );
+  }
+
+  get statisticsFundingCountdown() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.STATISTICS_FUNDING_COUNTDOWN,
+    );
+  }
+
+  // Chart elements
+  get candlestickChart() {
+    return Matchers.getElementByID(PerpsCandlestickChartSelectorsIDs.CONTAINER);
+  }
+
+  get chartCandles() {
+    return Matchers.getElementByID(PerpsCandlestickChartSelectorsIDs.CANDLES);
+  }
+
+  get chartTooltip() {
+    return Matchers.getElementByID(PerpsCandlestickChartSelectorsIDs.TOOLTIP);
+  }
+
+  get chartLoadingSkeleton() {
+    return Matchers.getElementByID(
+      PerpsCandlestickChartSelectorsIDs.LOADING_SKELETON,
+    );
+  }
+
+  // Scroll view
+  get scrollView() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.SCROLL_VIEW,
+    );
+  }
+
+  // Trading action buttons
+  get longButton() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.LONG_BUTTON,
+    );
+  }
+
+  get shortButton() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.SHORT_BUTTON,
+    );
+  }
+
+  // Info icons
+  get openInterestInfoIcon() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.OPEN_INTEREST_INFO_ICON,
+    );
+  }
+
+  get fundingRateInfoIcon() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.FUNDING_RATE_INFO_ICON,
+    );
+  }
+
+  // Bottom sheet elements
+  get candlePeriodBottomSheet() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.CANDLE_PERIOD_BOTTOM_SHEET,
+    );
+  }
+
+  get bottomSheetTooltip() {
+    return Matchers.getElementByID(
+      PerpsMarketDetailsViewSelectorsIDs.BOTTOM_SHEET_TOOLTIP,
+    );
+  }
+
+  // Actions
+  async tapBackButton() {
+    await Gestures.waitAndTap(this.backButton);
+  }
+
+  async tapLongButton() {
+    await Gestures.waitAndTap(this.longButton);
+  }
+
+  async tapShortButton() {
+    await Gestures.waitAndTap(this.shortButton);
+  }
+
+  async tapMoreButton() {
+    await Gestures.waitAndTap(this.moreButton);
+  }
+
+  async tapOpenInterestInfoIcon() {
+    await Gestures.waitAndTap(this.openInterestInfoIcon);
+  }
+
+  async tapFundingRateInfoIcon() {
+    await Gestures.waitAndTap(this.fundingRateInfoIcon);
+  }
+
+  async waitForMarketDetailsToLoad() {
+    await Gestures.waitAndTap(this.container);
+  }
+
+  async waitForChartToLoad() {
+    await Gestures.waitAndTap(this.candlestickChart);
+  }
+
+  async scrollToBottom() {
+    await Gestures.swipe(this.scrollView as unknown as DetoxElement, 'up', {
+      speed: 'fast',
+      percentage: 0.7,
+      elemDescription: 'Perps market details scroll down',
+    });
+  }
+}
+
+export default new PerpsMarketDetailsView();
diff --git a/e2e/pages/Perps/PerpsMarketListView.ts b/e2e/pages/Perps/PerpsMarketListView.ts
new file mode 100644
index 00000000000..44283a7d120
--- /dev/null
+++ b/e2e/pages/Perps/PerpsMarketListView.ts
@@ -0,0 +1,98 @@
+import {
+  PerpsMarketListViewSelectorsIDs,
+  PerpsTokenSelectorSelectorsIDs,
+  getPerpsMarketRowItemSelector,
+} from '../../selectors/Perps/Perps.selectors';
+import Gestures from '../../framework/Gestures';
+import Matchers from '../../framework/Matchers';
+
+class PerpsMarketListView {
+  // Main container
+  get container() {
+    return Matchers.getElementByID(PerpsTokenSelectorSelectorsIDs.MODAL);
+  }
+
+  get title() {
+    return Matchers.getElementByID(PerpsTokenSelectorSelectorsIDs.TITLE);
+  }
+
+  get closeButton() {
+    return Matchers.getElementByID(
+      PerpsMarketListViewSelectorsIDs.CLOSE_BUTTON,
+    );
+  }
+
+  // Search functionality
+  get searchToggleButton() {
+    return Matchers.getElementByID(
+      PerpsMarketListViewSelectorsIDs.SEARCH_TOGGLE_BUTTON,
+    );
+  }
+
+  get searchClearButton() {
+    return Matchers.getElementByID(
+      PerpsMarketListViewSelectorsIDs.SEARCH_CLEAR_BUTTON,
+    );
+  }
+
+  get listHeader() {
+    return Matchers.getElementByID(PerpsMarketListViewSelectorsIDs.LIST_HEADER);
+  }
+
+  get marketRowItemBTC() {
+    return Matchers.getElementByID(
+      getPerpsMarketRowItemSelector.rowItem('BTC'),
+    );
+  }
+
+  // Generic selector for first market row item (regardless of coin)
+  get firstMarketRowItem() {
+    // Match any element with testID that starts with 'perps-market-row-item-' and get the first one
+    return Matchers.getElementByID(/^perps-market-row-item-.*/, 0);
+  }
+
+  get tokenSelectorContainer() {
+    return Matchers.getElementByID(PerpsTokenSelectorSelectorsIDs.CONTAINER);
+  }
+
+  get tokenSelectorModal() {
+    return Matchers.getElementByID(PerpsTokenSelectorSelectorsIDs.MODAL);
+  }
+
+  get closeTokenSelector() {
+    return Matchers.getElementByID(PerpsTokenSelectorSelectorsIDs.CLOSE_BUTTON);
+  }
+
+  // Actions
+  async tapMarketRowItemBTC() {
+    await Gestures.tap(this.marketRowItemBTC);
+  }
+
+  async tapFirstMarketRowItem() {
+    await Gestures.waitAndTap(this.firstMarketRowItem);
+  }
+
+  async tapSearchToggleButton() {
+    await Gestures.waitAndTap(this.searchToggleButton);
+  }
+
+  async tapSearchClearButton() {
+    await Gestures.waitAndTap(this.searchClearButton);
+  }
+
+  async tapCloseTokenSelector() {
+    await Gestures.waitAndTap(this.closeTokenSelector);
+  }
+
+  async waitForMarketListToLoad() {
+    await Gestures.waitAndTap(this.container);
+  }
+
+  // Helper method to select a specific market by text
+  async selectMarket(marketName: string) {
+    const marketElement = Matchers.getElementByText(marketName);
+    await Gestures.waitAndTap(marketElement);
+  }
+}
+
+export default new PerpsMarketListView();
diff --git a/e2e/pages/Perps/PerpsOnboarding.ts b/e2e/pages/Perps/PerpsOnboarding.ts
new file mode 100644
index 00000000000..81b5e23d255
--- /dev/null
+++ b/e2e/pages/Perps/PerpsOnboarding.ts
@@ -0,0 +1,27 @@
+import Gestures from '../../framework/Gestures';
+import Matchers from '../../framework/Matchers';
+import { PerpsTutorialSelectorsIDs } from '../../selectors/Perps/Perps.selectors';
+
+class PerpsOnboarding {
+  get continueButton(): DetoxElement {
+    return Matchers.getElementByID(PerpsTutorialSelectorsIDs.CONTINUE_BUTTON);
+  }
+
+  get skipButton(): DetoxElement {
+    return Matchers.getElementByID(PerpsTutorialSelectorsIDs.SKIP_BUTTON);
+  }
+
+  async tapContinueButton(): Promise<void> {
+    await Gestures.waitAndTap(this.continueButton, {
+      elemDescription: 'Perps Tutorial Continue Button',
+    });
+  }
+
+  async tapSkipButton(): Promise<void> {
+    await Gestures.waitAndTap(this.skipButton, {
+      elemDescription: 'Perps Tutorial Skip Button',
+    });
+  }
+}
+
+export default new PerpsOnboarding();
diff --git a/e2e/pages/Perps/PerpsOrderView.ts b/e2e/pages/Perps/PerpsOrderView.ts
new file mode 100644
index 00000000000..b495f8afee3
--- /dev/null
+++ b/e2e/pages/Perps/PerpsOrderView.ts
@@ -0,0 +1,152 @@
+import Gestures from '../../framework/Gestures';
+import Matchers from '../../framework/Matchers';
+import Assertions from '../../framework/Assertions';
+import {
+  PerpsOrderViewSelectorsIDs,
+  PerpsAmountDisplaySelectorsIDs,
+} from '../../selectors/Perps/Perps.selectors';
+import { waitFor, element as detoxElement, by as detoxBy } from 'detox';
+
+class PerpsOrderView {
+  get placeOrderButton() {
+    return Matchers.getElementByID(
+      PerpsOrderViewSelectorsIDs.PLACE_ORDER_BUTTON,
+    );
+  }
+
+  get takeProfitButton() {
+    return Matchers.getElementByID(
+      PerpsOrderViewSelectorsIDs.TAKE_PROFIT_BUTTON,
+    );
+  }
+
+  // Leverage chip by visible text, e.g., "3x", "10x", "20x"
+  leverageOption(leverageX: number, index = 0) {
+    return Matchers.getElementByText(`${leverageX}x`, index);
+  }
+
+  // Row label to open the leverage modal (uses visible text "Leverage")
+  get leverageRowLabel() {
+    return Matchers.getElementByText('Leverage');
+  }
+
+  // Modal title to ensure the leverage bottom sheet is visible
+  get leverageModalTitle() {
+    return Matchers.getElementByText('Set Leverage');
+  }
+
+  async tapPlaceOrderButton() {
+    await Gestures.waitAndTap(this.placeOrderButton);
+  }
+
+  async tapTakeProfitButton() {
+    await Gestures.waitAndTap(this.takeProfitButton);
+  }
+
+  async selectLeverage(leverageX: number) {
+    // Open leverage modal
+    await Gestures.waitAndTap(this.leverageRowLabel, {
+      elemDescription: 'Open leverage modal',
+    });
+
+    // Wait for the modal to be visible
+    const title = this.leverageModalTitle as unknown as DetoxElement;
+    await Assertions.expectElementToBeVisible(title, {
+      description: 'Leverage modal title visible',
+    });
+
+    // Tap quick option (2x/5x/10x/20x/40x)
+    // Robust against duplicates: detect the highest existing index and use it (button > slider label)
+    const label = `${leverageX}x`;
+    let chosenIdx = -1;
+    for (const idx of [3, 2, 1, 0]) {
+      try {
+        await waitFor(detoxElement(detoxBy.text(label)).atIndex(idx))
+          .toExist()
+          .withTimeout(250);
+        chosenIdx = idx;
+        break;
+      } catch {
+        // try next lower index
+      }
+    }
+    if (chosenIdx < 0) {
+      throw new Error(`Leverage option ${label} not found`);
+    }
+
+    // Prefer unwrapped Detox tap to avoid long internal retries and allow a quick fallback
+    let tapped = false;
+    for (const idx of [chosenIdx, 1, 0]) {
+      try {
+        await detoxElement(detoxBy.text(label)).atIndex(idx).tap();
+        tapped = true;
+        break;
+      } catch {
+        // try next index quickly
+      }
+    }
+    if (!tapped) {
+      // Final fallback with our wrapper to bubble a clear error
+      const option = this.leverageOption(
+        leverageX,
+        chosenIdx,
+      ) as unknown as DetoxElement;
+      await Gestures.waitAndTap(option, {
+        elemDescription: `Select leverage ${label} at index ${chosenIdx}`,
+      });
+    }
+
+    // Confirm by tapping footer button "Set Xx"
+    const confirm = Matchers.getElementByText(
+      `Set ${leverageX}x`,
+    ) as unknown as DetoxElement;
+    await Gestures.waitAndTap(confirm, {
+      elemDescription: `Confirm leverage ${leverageX}x`,
+    });
+  }
+
+  // Amount handling
+  get amountDisplay() {
+    return Matchers.getElementByID(PerpsAmountDisplaySelectorsIDs.CONTAINER);
+  }
+
+  get amountValue() {
+    return Matchers.getElementByID(PerpsAmountDisplaySelectorsIDs.AMOUNT_LABEL);
+  }
+
+  // Required for next test
+  async setAmountUSD(amount: string) {
+    // Open keypad by tapping the value by ID (more reliable than tapping the container)
+    await device.disableSynchronization();
+    const amountEl = this.amountValue as unknown as DetoxElement;
+    await Assertions.expectElementToBeVisible(amountEl, {
+      description: 'Amount value is visible',
+    });
+    await Gestures.waitAndTap(amountEl, {
+      elemDescription: 'Open amount keypad by tapping amount label',
+      checkEnabled: false,
+      checkVisibility: false,
+    });
+    // Type each character using the native keypad (buttons 0-9 and '.')
+    for (const ch of amount) {
+      const key = Matchers.getElementByText(ch);
+      await Gestures.waitAndTap(key as unknown as DetoxElement, {
+        elemDescription: `Keypad: ${ch}`,
+        checkEnabled: false,
+        checkVisibility: false,
+      });
+    }
+    // Close the keypad using the Done button (with locale fallbacks)
+    const doneByText = Matchers.getElementByText('Done');
+
+    await Gestures.waitAndTap(doneByText as unknown as DetoxElement, {
+      elemDescription: 'Tap Done (by text) to close keypad',
+      checkEnabled: false,
+      checkVisibility: false,
+    });
+
+    await device.enableSynchronization();
+  }
+}
+
+export default new PerpsOrderView();
diff --git a/e2e/pages/Perps/PerpsTabView.ts b/e2e/pages/Perps/PerpsTabView.ts
new file mode 100644
index 00000000000..0f525c62d8a
--- /dev/null
+++ b/e2e/pages/Perps/PerpsTabView.ts
@@ -0,0 +1,67 @@
+import Gestures from '../../framework/Gestures';
+import Matchers from '../../framework/Matchers';
+import { PerpsTabViewSelectorsIDs } from '../../selectors/Perps/Perps.selectors';
+
+class PerpsTabView {
+  get balanceButton(): DetoxElement {
+    return Matchers.getElementByID(PerpsTabViewSelectorsIDs.BALANCE_BUTTON);
+  }
+
+  get addFundsButton(): DetoxElement {
+    return Matchers.getElementByID(PerpsTabViewSelectorsIDs.ADD_FUNDS_BUTTON);
+  }
+
+  get withdrawButton(): DetoxElement {
+    return Matchers.getElementByID(PerpsTabViewSelectorsIDs.WITHDRAW_BUTTON);
+  }
+
+  get onboardingButton(): DetoxElement {
+    // The onboarding button no longer exposes a testID; select by visible text
+    return Matchers.getElementByText('Start trading');
+  }
+
+  get balanceValue(): DetoxElement {
+    return Matchers.getElementByID(PerpsTabViewSelectorsIDs.BALANCE_VALUE);
+  }
+
+  async tapBalanceButton(): Promise<void> {
+    await Gestures.waitAndTap(this.balanceButton, {
+      elemDescription: 'Perps Balance Button',
+    });
+  }
+
+  async tapAddFundsButton(): Promise<void> {
+    await Gestures.waitAndTap(this.addFundsButton, {
+      elemDescription: 'Perps Add Funds Button',
+    });
+  }
+
+  async tapWithdrawButton(): Promise<void> {
+    await Gestures.waitAndTap(this.withdrawButton, {
+      elemDescription: 'Perps Withdraw Button',
+    });
+  }
+
+  async tapOnboardingButton(): Promise<void> {
+    await Gestures.waitAndTap(this.onboardingButton, {
+      elemDescription: 'Perps Onboarding Button',
+    });
+  }
+
+  async getBalance(): Promise<number> {
+    const balanceElement = await this.balanceValue;
+    const attributes = await (
+      balanceElement as IndexableNativeElement
+    ).getAttributes();
+    const balanceText =
+      (attributes as { text: string; label: string }).text ||
+      (attributes as { text: string; label: string }).label ||
+      '0';
+
+    // Extract numeric value from balance text (remove currency symbols, commas, etc.)
+    const numericValue = balanceText.replace(/[^0-9.-]/g, '');
+    return parseFloat(numericValue) || 0;
+  }
+}
+
+export default new PerpsTabView();
diff --git a/e2e/pages/Perps/PerpsView.ts b/e2e/pages/Perps/PerpsView.ts
new file mode 100644
index 00000000000..9fe6e380782
--- /dev/null
+++ b/e2e/pages/Perps/PerpsView.ts
@@ -0,0 +1,256 @@
+import {
+  PerpsPositionCardSelectorsIDs,
+  PerpsGeneralSelectorsIDs,
+  PerpsOrderViewSelectorsIDs,
+  PerpsMarketListViewSelectorsIDs,
+  PerpsClosePositionViewSelectorsIDs,
+  getPerpsTPSLBottomSheetSelector,
+} from '../../selectors/Perps/Perps.selectors';
+import Gestures from '../../framework/Gestures';
+import Matchers from '../../framework/Matchers';
+import Assertions from '../../framework/Assertions';
+
+class PerpsView {
+  get closePositionButton() {
+    return Matchers.getElementByID(PerpsPositionCardSelectorsIDs.CLOSE_BUTTON);
+  }
+
+  getPositionItem(
+    symbol: string,
+    leverageX: number,
+    direction: 'long' | 'short',
+    index = 0,
+  ) {
+    return Matchers.getElementByID(
+      new RegExp(
+        `^perps-positions-item-${symbol}-${leverageX}x-${direction}-${index}$`,
+      ),
+    );
+  }
+
+  get setTpslButton() {
+    return Matchers.getElementByID(
+      PerpsGeneralSelectorsIDs.BOTTOM_SHEET_FOOTER_BUTTON,
+    );
+  }
+
+  // "Edit TP/SL" button visible on position details
+  get editTpslButton() {
+    return Matchers.getElementByText('Edit TP/SL');
+  }
+
+  get closePositionBottomSheetButton() {
+    return Matchers.getElementByID(
+      PerpsClosePositionViewSelectorsIDs.CLOSE_POSITION_CONFIRM_BUTTON,
+    );
+  }
+
+  get placeOrderButton() {
+    return Matchers.getElementByID(
+      PerpsOrderViewSelectorsIDs.PLACE_ORDER_BUTTON,
+    );
+  }
+
+  get backButtonPositionSheet() {
+    return Matchers.getElementByID(
+      PerpsMarketListViewSelectorsIDs.BACK_HEADER_BUTTON,
+    );
+  }
+  get backButtonMarketList() {
+    return Matchers.getElementByID(
+      PerpsMarketListViewSelectorsIDs.BACK_HEADER_BUTTON,
+    );
+  }
+
+  get orderSuccessToastDismissButton() {
+    return Matchers.getElementByID(
+      PerpsGeneralSelectorsIDs.ORDER_SUCCESS_TOAST_DISMISS_BUTTON,
+    );
+  }
+
+  get toastDismissButton() {
+    return Matchers.getElementByText('Dismiss');
+  }
+
+  get anchor() {
+    return Matchers.getElementByID(
+      'perps-tab-scroll-view',
+    ) as unknown as DetoxElement;
+  }
+
+  getTakeProfitPercentageButton(percentage: number) {
+    // Support legacy tests passing index (1..4) by mapping to actual ROE%
+    // TP quick buttons: [10, 25, 50, 100]
+    const mapped = [0, 10, 25, 50, 100][percentage] || percentage;
+    return Matchers.getElementByID(
+      getPerpsTPSLBottomSheetSelector.takeProfitPercentageButton(mapped),
+    );
+  }
+
+  getStopLossPercentageButton(percentage: number) {
+    // Support legacy tests passing index (1..4) by mapping to actual ROE% (loss magnitudes)
+    // SL quick buttons: [5, 10, 25, 50]
+    const mapped = [0, 5, 10, 25, 50][percentage] || percentage;
+    return Matchers.getElementByID(
+      getPerpsTPSLBottomSheetSelector.stopLossPercentageButton(mapped),
+    );
+  }
+
+  async expectPosition(
+    symbol: string,
+    leverageX: number,
+    direction: 'long' | 'short',
+    index = 0,
+  ) {
+    const el = this.getPositionItem(symbol, leverageX, direction, index);
+    await Assertions.expectElementToBeVisible(el as DetoxElement, {
+      description: `Expect ${symbol} ${leverageX}x ${direction} at index ${index}`,
+    });
+  }
+
+  async expectPerpsTabPosition(
+    symbol: string,
+    leverageX: number,
+    direction: 'long' | 'short',
+    index = 0,
+  ) {
+    const el = this.getPositionItem(symbol, leverageX, direction, index);
+    await Assertions.expectElementToBeVisible(el as DetoxElement, {
+      description: `Expect Perps tab position: ${symbol} ${leverageX}x ${direction} at index ${index}`,
+    });
+  }
+
+  // Tap a position in the Perps tab by its testID
+  async tapPerpsTabPosition(
+    symbol: string,
+    leverageX: number,
+    direction: 'long' | 'short',
+    index = 0,
+  ) {
+    const el = this.getPositionItem(symbol, leverageX, direction, index);
+    await Gestures.waitAndTap(el as DetoxElement, {
+      elemDescription: `Tap Perps tab position: ${symbol} ${leverageX}x ${direction} at index ${index}`,
+    });
+  }
+
+  // Scroll helper on Perps tab (swipe over the tab ScrollView)
+  async scrollDownOnPerpsTab(times = 1) {
+    const anchor = this.anchor;
+    for (let i = 0; i < times; i++) {
+      await Gestures.swipe(anchor, 'up', {
+        speed: 'fast',
+        percentage: 0.7,
+        elemDescription: 'Perps tab scroll down',
+      });
+    }
+  }
+
+  // Ensure a position card is visible on the Perps tab. Performs best-effort scrolls.
+  async ensurePerpsTabPositionVisible(
+    symbol: string,
+    leverageX: number,
+    direction: 'long' | 'short',
+    index = 0,
+  ) {
+    let visible = false;
+    for (let i = 0; i < 6; i++) {
+      try {
+        const el = this.getPositionItem(
+          symbol,
+          leverageX,
+          direction,
+          index,
+        ) as DetoxElement;
+        await Assertions.expectElementToBeVisible(el as DetoxElement, {
+          description: `Ensure visible: ${symbol} ${leverageX}x ${direction} at index ${index}`,
+          timeout: 750,
+        });
+        visible = true;
+        break;
+      } catch {
+        await this.scrollDownOnPerpsTab(1);
+      }
+    }
+    if (!visible) {
+      // Final attempt assertion to surface a clear error
+      await this.expectPerpsTabPosition(symbol, leverageX, direction, index);
+    }
+  }
+
+  async tapEditTpslButton() {
+    await Gestures.waitAndTap(this.editTpslButton as unknown as DetoxElement, {
+      elemDescription: 'Tap Edit TP/SL button',
+    });
+  }
+
+  async tapClosePositionButton() {
+    await Gestures.waitAndTap(this.closePositionButton, {
+      elemDescription: 'Close position button',
+    });
+  }
+
+  async tapConfirmClosePositionButton() {
+    await Gestures.waitAndTap(this.closePositionButton, {
+      elemDescription: 'Confirm close position button',
+    });
+  }
+
+  async tapTakeProfitPercentageButton(percentage: number) {
+    const button = this.getTakeProfitPercentageButton(percentage);
+    await Gestures.waitAndTap(button);
+  }
+
+  async tapStopLossPercentageButton(percentage: number) {
+    const button = this.getStopLossPercentageButton(percentage);
+    await Gestures.waitAndTap(button);
+  }
+
+  async tapSetTpslButton() {
+    await Gestures.waitAndTap(this.setTpslButton);
+  }
+
+  async tapPlaceOrderButton() {
+    await Gestures.waitAndTap(this.placeOrderButton);
+  }
+
+  async tapOrderSuccessToastDismissButton() {
+    await Gestures.waitAndTap(this.orderSuccessToastDismissButton);
+  }
+
+  async dismissToast(): Promise<void> {
+    const button = this.toastDismissButton;
+    await Assertions.expectElementToBeVisible(button, {
+      description: 'Toast Dismiss button visible',
+      timeout: 3000,
+    });
+    await Gestures.waitAndTap(button, {
+      elemDescription: 'Tap toast close',
+      delay: 100,
+    });
+  }
+
+  async tapClosePositionBottomSheetButton() {
+    await Gestures.waitAndTap(this.closePositionBottomSheetButton, {
+      elemDescription: 'Close position bottom sheet button',
+    });
+  }
+
+  // Generic scroll to bottom on Perps tab (positions list area)
+  async scrollToBottom(times: number = 1) {
+    await this.scrollDownOnPerpsTab(times);
+  }
+
+  async tapBackButtonPositionSheet() {
+    await Gestures.waitAndTap(this.backButtonPositionSheet, {
+      elemDescription: 'Back button position sheet',
+    });
+  }
+
+  async tapBackButtonMarketList() {
+    await Gestures.waitAndTap(this.backButtonMarketList, {
+      elemDescription: 'Back button market list',
+    });
+  }
+}
+
+export default new PerpsView();
diff --git a/e2e/pages/wallet/TabBarComponent.ts b/e2e/pages/wallet/TabBarComponent.ts
index 021bb67599e..b3a90d2aebe 100644
--- a/e2e/pages/wallet/TabBarComponent.ts
+++ b/e2e/pages/wallet/TabBarComponent.ts
@@ -54,11 +54,9 @@ class TabBarComponent {
   }
 
   async tapActions(): Promise<void> {
-    await device.disableSynchronization();
     await Gestures.waitAndTap(this.tabBarActionButton, {
       elemDescription: 'Tab Bar - Actions Button',
     });
-    await device.enableSynchronization();
   }
 
   async tapSettings(): Promise<void> {
diff --git a/e2e/pages/wallet/WalletActionsBottomSheet.ts b/e2e/pages/wallet/WalletActionsBottomSheet.ts
index 7c1d0192ec5..5c4d1971866 100644
--- a/e2e/pages/wallet/WalletActionsBottomSheet.ts
+++ b/e2e/pages/wallet/WalletActionsBottomSheet.ts
@@ -39,6 +39,12 @@ class WalletActionsBottomSheet {
     );
   }
 
+  get perpsButton(): DetoxElement {
+    return Matchers.getElementByID(
+      WalletActionsBottomSheetSelectorsIDs.PERPS_BUTTON,
+    );
+  }
+
   async tapSendButton(): Promise<void> {
     await Gestures.waitAndTap(this.sendButton);
   }
@@ -67,6 +73,10 @@ class WalletActionsBottomSheet {
     await Gestures.waitAndTap(this.sellButton);
   }
 
+  async tapPerpsButton(): Promise<void> {
+    await Gestures.waitAndTap(this.perpsButton);
+  }
+
   async swipeDownActionsBottomSheet(): Promise<void> {
     await Gestures.swipe(this.sendButton, 'down', {
       speed: 'fast',
diff --git a/e2e/pages/wallet/WalletView.ts b/e2e/pages/wallet/WalletView.ts
index ca14d76952b..e400ef3b273 100644
--- a/e2e/pages/wallet/WalletView.ts
+++ b/e2e/pages/wallet/WalletView.ts
@@ -560,6 +560,16 @@ class WalletView {
       elemDescription: 'Wallet Receive Button',
     });
   }
+
+  get perpsTab(): DetoxElement {
+    return Matchers.getElementByText(WalletViewSelectorsText.PERPS_TAB);
+  }
+
+  async tapOnPerpsTab(): Promise<void> {
+    await Gestures.waitAndTap(this.perpsTab, {
+      elemDescription: 'Perps Tab Button',
+    });
+  }
 }
 
 export default new WalletView();
diff --git a/e2e/selectors/Perps/Perps.selectors.ts b/e2e/selectors/Perps/Perps.selectors.ts
index 239204ff990..b208fb36b73 100644
--- a/e2e/selectors/Perps/Perps.selectors.ts
+++ b/e2e/selectors/Perps/Perps.selectors.ts
@@ -102,8 +102,11 @@ export const PerpsMarketListViewSelectorsIDs = {
   TUTORIAL_BUTTON: 'perps-market-list-tutorial-button',
   SEARCH_TOGGLE_BUTTON: 'perps-market-list-search-toggle-button',
   CLOSE_BUTTON: 'perps-market-list-close-button',
+  BACK_HEADER_BUTTON: 'perps-market-header-back-button',
+  BACK_LIST_BUTTON: 'perps-market-list-back-button',
   SEARCH_CLEAR_BUTTON: 'perps-market-list-search-clear-button',
   SKELETON_ROW: 'perps-market-list-skeleton-row',
+  LIST_HEADER: 'perps-market-list-header',
 };
 
 // ========================================
@@ -118,6 +121,8 @@ export const PerpsMarketRowItemSelectorsIDs = {
 export const getPerpsMarketRowItemSelector = {
   rowItem: (symbol: string) =>
     `${PerpsMarketRowItemSelectorsIDs.ROW_ITEM}-${symbol}`,
+  tokenLogo: (symbol: string) =>
+    `${PerpsMarketRowItemSelectorsIDs.ROW_ITEM}-${symbol}-token-logo`,
 };
 
 // ========================================
@@ -146,6 +151,8 @@ export const PerpsTokenSelectorSelectorsIDs = {
 
 export const PerpsAmountDisplaySelectorsIDs = {
   CONTAINER: 'perps-amount-display',
+  AMOUNT_LABEL: 'perps-amount-display-amount',
+  MAX_LABEL: 'perps-amount-display-max',
 };
 
 // ========================================
@@ -156,11 +163,20 @@ export const PerpsTabViewSelectorsIDs = {
   START_NEW_TRADE_CTA: 'perps-tab-view-start-new-trade-cta',
   GEO_BLOCK_BOTTOM_SHEET_TOOLTIP:
     'perps-tab-view-geo-block-bottom-sheet-tooltip',
+  ONBOARDING_BUTTON: 'perps-start-trading-button',
+  BALANCE_BUTTON: 'perps-balance-button',
+  ADD_FUNDS_BUTTON: 'perps-add-funds-button',
+  WITHDRAW_BUTTON: 'perps-withdraw-button',
+  BALANCE_VALUE: 'perps-balance-value',
+  SCROLL_VIEW: 'perps-tab-scroll-view',
 };
 
 export const PerpsPositionsViewSelectorsIDs = {
   REFRESH_CONTROL: 'refresh-control',
   BACK_BUTTON: 'button-icon-arrow-left',
+  POSITION_ITEM: 'perps-positions-item',
+  POSITIONS_SECTION: 'perps-positions-section',
+  POSITIONS_SECTION_TITLE: 'perps-positions-section-title',
 };
 
 export const PerpsPositionDetailsViewSelectorsIDs = {
@@ -178,6 +194,22 @@ export const PerpsPositionDetailsViewSelectorsIDs = {
   CHART_TOOLTIP: 'chart-tooltip',
 };
 
+// ========================================
+// PERPS TPSL BOTTOM SHEET SELECTORS
+// ========================================
+
+export const PerpsTPSLBottomSheetSelectorsIDs = {
+  BOTTOM_SHEET: 'perps-tpsl-bottomsheet',
+  SET_BUTTON: 'bottomsheetfooter-button',
+} as const;
+
+export const getPerpsTPSLBottomSheetSelector = {
+  takeProfitPercentageButton: (percentage: number) =>
+    `perps-tpsl-take-profit-percentage-button-${percentage}`,
+  stopLossPercentageButton: (percentage: number) =>
+    `perps-tpsl-stop-loss-percentage-button-${percentage}`,
+};
+
 // ========================================
 // TRADINGVIEW CHART SELECTORS
 // ========================================
@@ -332,6 +364,17 @@ export const PerpsBottomSheetTooltipSelectorsIDs = {
   GOT_IT_BUTTON: 'perps-bottom-sheet-tooltip-got-it-button',
 };
 
+// ========================================
+// PERPS TUTORIAL SELECTORS
+// ========================================
+
+export const PerpsTutorialSelectorsIDs = {
+  CONTINUE_BUTTON: 'perps-tutorial-continue-button',
+  SKIP_BUTTON: 'perps-tutorial-skip-button',
+  CAROUSEL: 'perps-tutorial-carousel',
+  CARD: 'perps-tutorial-card',
+} as const;
+
 // ========================================
 // PERPS GTM MODAL SELECTORS
 // ========================================
@@ -355,7 +398,11 @@ export const PerpsOrderViewSelectorsIDs = {
   LIQUIDATION_PRICE_INFO_ICON: 'perps-order-view-liquidation-price-info-icon',
   FEES_INFO_ICON: 'perps-order-view-fees-info-icon',
   TP_SL_INFO_ICON: 'perps-order-view-tp-sl-info-icon',
+  // Buttons present in PerpsOrderView (TouchableOpacity with testID)
+  TAKE_PROFIT_BUTTON: 'perps-order-view-stop-loss-button',
+  STOP_LOSS_BUTTON: 'perps-order-view-stop-loss-button',
   PLACE_ORDER_BUTTON: 'perps-order-view-place-order-button',
+  KEYPAD: 'perps-order-view-keypad',
 };
 
 // ========================================
@@ -411,3 +458,18 @@ export const PerpsMarketTabsSelectorsIDs = {
   SKELETON_TAB_BAR: 'perps-market-tabs-skeleton-tab-bar',
   SKELETON_CONTENT: 'perps-market-tabs-skeleton-content',
 };
+
+// ========================================
+// PERPS GENERAL (CROSS-COMPONENT) SELECTORS
+// ========================================
+
+export const PerpsGeneralSelectorsIDs = {
+  // TPSL bottom sheet primary action button ("Set" / "Updating")
+  BOTTOM_SHEET_FOOTER_BUTTON: 'bottomsheetfooter-button',
+  // Order success toast dismiss button on PerpsOrderView
+  ORDER_SUCCESS_TOAST_DISMISS_BUTTON:
+    'perps-order-success-toast-dismiss-button',
+  // Common action buttons that may appear in flows (keep for E2E compatibility)
+  CONTINUE_BUTTON: 'continue-button',
+  DONE_BUTTON: 'done-button',
+} as const;
diff --git a/e2e/selectors/wallet/WalletView.selectors.ts b/e2e/selectors/wallet/WalletView.selectors.ts
index 04c9e65b6d1..7b2c20fa1e2 100644
--- a/e2e/selectors/wallet/WalletView.selectors.ts
+++ b/e2e/selectors/wallet/WalletView.selectors.ts
@@ -86,6 +86,7 @@ export const WalletViewSelectorsText = {
   IMPORT_TOKENS: `${enContent.wallet.no_available_tokens} ${enContent.wallet.add_tokens}`,
   NFTS_TAB: enContent.wallet.collectibles,
   TOKENS_TAB: enContent.wallet.tokens,
+  PERPS_TAB: enContent.wallet.perps,
   HIDE_TOKENS: enContent.wallet.remove,
   STAKED_ETHEREUM: enContent.stake.staked_ethereum,
   DEFAULT_TOKEN: 'Ethereum',
diff --git a/e2e/specs/card/card-button.spec.ts b/e2e/specs/card/card-button.spec.ts
index 2f7e11eeb6a..8327a884739 100644
--- a/e2e/specs/card/card-button.spec.ts
+++ b/e2e/specs/card/card-button.spec.ts
@@ -19,6 +19,7 @@ describe(SmokeCard('Card NavBar Button'), () => {
         fixture: new FixtureBuilder()
           .withMetaMetricsOptIn()
           .withNetworkController(CustomNetworks.Tenderly.Linea)
+          .withAccountTreeController()
           .withTokens(
             [
               {
diff --git a/e2e/specs/card/card-home-add-funds.spec.ts b/e2e/specs/card/card-home-add-funds.spec.ts
index a5afb23d447..f6ac52976d3 100644
--- a/e2e/specs/card/card-home-add-funds.spec.ts
+++ b/e2e/specs/card/card-home-add-funds.spec.ts
@@ -19,6 +19,7 @@ describe(SmokeCard('CardHome - Add Funds'), () => {
         fixture: new FixtureBuilder()
           .withMetaMetricsOptIn()
           .withNetworkController(CustomNetworks.Tenderly.Linea)
+          .withAccountTreeController()
           .withTokens(
             [
               {
diff --git a/e2e/specs/card/card-home-manage-card.spec.ts b/e2e/specs/card/card-home-manage-card.spec.ts
index dbabe4bd08a..c694b31093f 100644
--- a/e2e/specs/card/card-home-manage-card.spec.ts
+++ b/e2e/specs/card/card-home-manage-card.spec.ts
@@ -19,6 +19,7 @@ describe(SmokeCard('CardHome - Manage Card'), () => {
         fixture: new FixtureBuilder()
           .withMetaMetricsOptIn()
           .withNetworkController(CustomNetworks.Tenderly.Linea)
+          .withAccountTreeController()
           .withTokens(
             [
               {
diff --git a/e2e/specs/perps/helpers/perps-helpers.ts b/e2e/specs/perps/helpers/perps-helpers.ts
new file mode 100644
index 00000000000..0959174d234
--- /dev/null
+++ b/e2e/specs/perps/helpers/perps-helpers.ts
@@ -0,0 +1,40 @@
+import WalletView from '../../../pages/wallet/WalletView';
+import PerpsTabView from '../../../pages/Perps/PerpsTabView';
+import PerpsOnboarding from '../../../pages/Perps/PerpsOnboarding';
+import { createLogger, LogLevel } from '../../../framework/logger';
+
+const logger = createLogger({
+  name: 'PerpsHelpers',
+  level: LogLevel.INFO,
+});
+
+/**
+ * Helper functions for common Perps e2e test operations
+ */
+export class PerpsHelpers {
+  /**
+   * Navigate to Perps tab with manual sync management (for when sync is disabled from launch)
+   * Uses waitFor patterns instead of automatic synchronization
+   */
+  static async navigateToPerpsTab() {
+    logger.info('[PerpsHelpers] Navigating to Perps tab...');
+    // Navigate to Perps tab
+    await WalletView.tapOnPerpsTab();
+    logger.info('[PerpsHelpers] Perps tab loaded successfully');
+  }
+
+  /**
+   * Helper function to go through Perps onboarding flow
+   */
+  static async completePerpsOnboarding() {
+    logger.info('[PerpsHelpers] Completing Perps onboarding...');
+    await PerpsTabView.tapOnboardingButton();
+    await PerpsOnboarding.tapContinueButton();
+    await PerpsOnboarding.tapContinueButton();
+    await PerpsOnboarding.tapContinueButton();
+    await PerpsOnboarding.tapContinueButton();
+    await PerpsOnboarding.tapContinueButton();
+    await PerpsOnboarding.tapSkipButton();
+    logger.info('[PerpsHelpers] Perps onboarding completed successfully');
+  }
+}
diff --git a/e2e/specs/perps/perps-no-funds-tutorial.spec.ts b/e2e/specs/perps/perps-no-funds-tutorial.spec.ts
new file mode 100644
index 00000000000..ff22df22fae
--- /dev/null
+++ b/e2e/specs/perps/perps-no-funds-tutorial.spec.ts
@@ -0,0 +1,66 @@
+import { withFixtures } from '../../framework/fixtures/FixtureHelper';
+import FixtureBuilder from '../../framework/fixtures/FixtureBuilder';
+import { RegressionTrade } from '../../tags';
+import { loginToApp } from '../../viewHelper';
+import WalletView from '../../pages/wallet/WalletView';
+import PerpsTabView from '../../pages/Perps/PerpsTabView';
+import Assertions from '../../framework/Assertions';
+import PerpsOnboarding from '../../pages/Perps/PerpsOnboarding';
+import PerpsMarketListView from '../../pages/Perps/PerpsMarketListView';
+import { PERPS_ARBITRUM_MOCKS } from '../../api-mocking/mock-responses/perps-arbitrum-mocks';
+
+describe(
+  RegressionTrade('Perps - no funds shows Start Trading and tutorial'),
+  () => {
+    beforeEach(async () => {
+      jest.setTimeout(150000);
+    });
+
+    it('should show Start Trading on Perps tab and then tutorial screens', async () => {
+      await withFixtures(
+        {
+          fixture: new FixtureBuilder()
+            .withPerpsProfile('no-funds')
+            .withPerpsFirstTimeUser(true)
+            .build(),
+          restartDevice: true,
+          // Ensure Hyperliquid icons and Arbitrum RPC are mocked (no live requests)
+          testSpecificMock: PERPS_ARBITRUM_MOCKS,
+        },
+        async () => {
+          await loginToApp();
+
+          // Go to Perps tab from Wallet
+          await WalletView.tapOnPerpsTab();
+
+          // Start Trading should be present for first-time/no-funds
+          await PerpsTabView.tapOnboardingButton();
+
+          await PerpsOnboarding.tapContinueButton();
+          await PerpsOnboarding.tapContinueButton();
+          await PerpsOnboarding.tapContinueButton();
+          await PerpsOnboarding.tapContinueButton();
+          await PerpsOnboarding.tapContinueButton();
+
+          await PerpsOnboarding.tapSkipButton();
+
+          // Return to Perps tab and verify the first-time CTA is visible
+          await Assertions.expectTextDisplayed('Start trading', {
+            description:
+              'Start trading CTA visible on Perps tab after tutorial',
+          });
+
+          // When tapping Start trading again, the market list modal should be visible
+          await PerpsTabView.tapOnboardingButton();
+          await Assertions.expectElementToBeVisible(
+            PerpsMarketListView.listHeader as DetoxElement,
+            {
+              description:
+                'Perps market list header visible after completing tutorial',
+            },
+          );
+        },
+      );
+    });
+  },
+);
diff --git a/e2e/specs/perps/perps-position.spec.ts b/e2e/specs/perps/perps-position.spec.ts
new file mode 100644
index 00000000000..515095a1dc2
--- /dev/null
+++ b/e2e/specs/perps/perps-position.spec.ts
@@ -0,0 +1,72 @@
+import { loginToApp } from '../../viewHelper';
+import { withFixtures } from '../../framework/fixtures/FixtureHelper';
+import { RegressionTrade } from '../../tags';
+import TabBarComponent from '../../pages/wallet/TabBarComponent';
+import FixtureBuilder from '../../framework/fixtures/FixtureBuilder';
+import { PerpsHelpers } from './helpers/perps-helpers';
+import WalletActionsBottomSheet from '../../pages/wallet/WalletActionsBottomSheet';
+import PerpsMarketListView from '../../pages/Perps/PerpsMarketListView';
+import { PERPS_ARBITRUM_MOCKS } from '../../api-mocking/mock-responses/perps-arbitrum-mocks';
+import PerpsMarketDetailsView from '../../pages/Perps/PerpsMarketDetailsView';
+import PerpsOrderView from '../../pages/Perps/PerpsOrderView';
+import PerpsView from '../../pages/Perps/PerpsView';
+import { createLogger, LogLevel } from '../../framework/logger';
+import helpers from '../../helpers';
+
+// E2E environment setup - mocks auto-configure via isE2E flag
+
+const logger = createLogger({
+  name: 'PerpsPositionSpec',
+  level: LogLevel.INFO,
+});
+
+describe(RegressionTrade('Perps Position'), () => {
+  it('should open a long position with custom profit and close it', async () => {
+    await withFixtures(
+      {
+        fixture: new FixtureBuilder().build(),
+        restartDevice: true,
+        testSpecificMock: PERPS_ARBITRUM_MOCKS,
+      },
+      async () => {
+        logger.info('💰 Using E2E mock balance - no wallet import needed');
+        logger.info('🎯 Mock account: $10,000 total, $8,000 available');
+        await loginToApp();
+
+        // Navigate to Perps tab using manual sync management
+        await PerpsHelpers.navigateToPerpsTab();
+
+        // Navigate to actions
+        await TabBarComponent.tapActions();
+
+        await WalletActionsBottomSheet.tapPerpsButton();
+
+        // Disable synchronization to timer
+        await device.disableSynchronization();
+        await PerpsMarketListView.tapFirstMarketRowItem();
+        await PerpsMarketDetailsView.tapLongButton();
+        await PerpsOrderView.tapTakeProfitButton();
+        await PerpsView.tapTakeProfitPercentageButton(1);
+        await PerpsView.tapStopLossPercentageButton(1);
+        await PerpsView.tapSetTpslButton();
+        await PerpsView.tapPlaceOrderButton();
+
+        logger.info('📈 E2E Mock: Order placed successfully');
+        logger.info('💎 E2E Mock: Position created with mock data');
+
+        // Use Page Object scroll on market details screen
+        await PerpsMarketDetailsView.scrollToBottom();
+        await helpers.delay(3000);
+
+        await PerpsView.tapClosePositionButton();
+
+        logger.info('📉 E2E Mock: Preparing to close position');
+
+        await PerpsView.tapClosePositionBottomSheetButton();
+
+        logger.info('🎉 E2E Mock: Position closed successfully');
+        logger.info('💰 E2E Mock: Balance updated with P&L');
+      },
+    );
+  });
+});
diff --git a/e2e/tags.js b/e2e/tags.js
index e2bbf8c70d4..c65f4646a53 100644
--- a/e2e/tags.js
+++ b/e2e/tags.js
@@ -76,7 +76,6 @@ const SmokeWalletUX = (testName) => `${tags.smokeWalletUX} ${testName}`;
 const RegressionWalletUX = (testName) =>
   `${tags.regressionWalletUX} ${testName}`;
 const FlaskBuildTests = (testName) => `${tags.FlaskBuildTests} ${testName}`;
-
 const SmokePerformance = (testName) => `${tags.performance} ${testName}`;
 
 export {
diff --git a/package.json b/package.json
index a9e3e05b172..6c665f36ab8 100644
--- a/package.json
+++ b/package.json
@@ -257,8 +257,8 @@
     "@metamask/logging-controller": "^6.0.4",
     "@metamask/message-signing-snap": "^1.1.2",
     "@metamask/metamask-eth-abis": "3.1.1",
-    "@metamask/mobile-wallet-protocol-core": "^0.0.6",
-    "@metamask/mobile-wallet-protocol-wallet-client": "^0.0.6",
+    "@metamask/mobile-wallet-protocol-core": "^0.1.0",
+    "@metamask/mobile-wallet-protocol-wallet-client": "^0.1.0",
     "@metamask/multichain-account-service": "^0.6.0",
     "@metamask/multichain-api-client": "^0.6.5",
     "@metamask/multichain-api-middleware": "^1.0.0",
@@ -295,7 +295,7 @@
     "@metamask/snaps-rpc-methods": "^13.5.0",
     "@metamask/snaps-sdk": "^9.3.0",
     "@metamask/snaps-utils": "^11.5.0",
-    "@metamask/solana-wallet-snap": "^2.3.7",
+    "@metamask/solana-wallet-snap": "^2.3.8",
     "@metamask/solana-wallet-standard": "^0.5.1",
     "@metamask/stake-sdk": "^3.2.0",
     "@metamask/swappable-obj-proxy": "^2.1.0",
diff --git a/wdio/helpers/AppwrightSelectors.js b/wdio/helpers/AppwrightSelectors.js
index 6f66efb7cfc..a8cc05c2f4d 100644
--- a/wdio/helpers/AppwrightSelectors.js
+++ b/wdio/helpers/AppwrightSelectors.js
@@ -48,7 +48,7 @@ export default class AppwrightSelectors {
   }
 
   static async scrollIntoView(device, element) {
-    for (let i = 0; i < 5; i++) {
+    for (let i = 0; i < 20; i++) {
       try {
         const isVisible = await element.isVisible({ timeout: 2000 });
         
diff --git a/yarn.lock b/yarn.lock
index 488541aea50..1625a426e88 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1686,11 +1686,6 @@
   resolved "https://registry.yarnpkg.com/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz#1d572bfbbe14b7704e0ba0f39b74815b84870d70"
   integrity sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==
 
-"@ecies/ciphers@^0.2.3":
-  version "0.2.4"
-  resolved "https://registry.yarnpkg.com/@ecies/ciphers/-/ciphers-0.2.4.tgz#20a4e51f61d521e5e311eb49385d93d91087de51"
-  integrity sha512-t+iX+Wf5nRKyNzk8dviW3Ikb/280+aEJAnw9YXvCp2tYGPSkMki+NRY+8aNLmVFv3eNtMdvViPNOPxS8SZNP+w==
-
 "@egjs/hammerjs@^2.0.17":
   version "2.0.17"
   resolved "https://registry.yarnpkg.com/@egjs/hammerjs/-/hammerjs-2.0.17.tgz#5dc02af75a6a06e4c2db0202cae38c9263895124"
@@ -5553,22 +5548,21 @@
   resolved "https://registry.yarnpkg.com/@metamask/mobile-provider/-/mobile-provider-3.0.0.tgz#8a6a5a0874c8cbe4b468f63dfc57117d207f9595"
   integrity sha512-XwFJk0rd9lAZR5xS3VC7ypEhD7DvZR2gi2Ch6PHnODIqeS9Te3OdVKK5+jHI4his8v/zs6LWdFdlRtx5/jL96w==
 
-"@metamask/mobile-wallet-protocol-core@^0.0.6":
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/@metamask/mobile-wallet-protocol-core/-/mobile-wallet-protocol-core-0.0.6.tgz#5112cd91c571e8c9e97769606cb76cff6383cc96"
-  integrity sha512-/RQwH1IoUTrhIgTn9P+XaWdD6R+JdtqiFGrs0A/D0EBoLV8jWtBhFzBIOzaNDKMGoKR6y3uSvDCDAj3V1tCz7g==
+"@metamask/mobile-wallet-protocol-core@^0.1.0":
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/@metamask/mobile-wallet-protocol-core/-/mobile-wallet-protocol-core-0.1.0.tgz#148a7393fc603af9eed89a1e2517df371eb01018"
+  integrity sha512-YcGPtV/I7GRAjtFhGQa6R+OwGYSrgKrel3PQbnoHPyvrzJ8wYW+ObeFuAHDiS79jbi10ETbDuf/5v/U62StahA==
   dependencies:
     centrifuge "^5.3.5"
-    eciesjs "^0.4.15"
     eventemitter3 "^5.0.1"
     uuid "^11.1.0"
 
-"@metamask/mobile-wallet-protocol-wallet-client@^0.0.6":
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/@metamask/mobile-wallet-protocol-wallet-client/-/mobile-wallet-protocol-wallet-client-0.0.6.tgz#5862bd975788f27b94f528882726e7aefedeea03"
-  integrity sha512-W/iRXuMvpImAlJLZ8BxtJp3raQZaPB8cR+gBY3Irtb+CUMclmuQL0mlLHs2tz0hLunhXd8rSRrI6W1T0AT4H6A==
+"@metamask/mobile-wallet-protocol-wallet-client@^0.1.0":
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/@metamask/mobile-wallet-protocol-wallet-client/-/mobile-wallet-protocol-wallet-client-0.1.0.tgz#738fc8fd9a604b079e2c11e9c898a2f99ee5ab8e"
+  integrity sha512-t3UKLP2XJ0vN5LL1nkb3y7neSARrnRlMZk+wmBgICnqHC8+1ebnE41KdeVqaRSfisK/EfmYEXqqob44N/zpy3Q==
   dependencies:
-    "@metamask/mobile-wallet-protocol-core" "^0.0.6"
+    "@metamask/mobile-wallet-protocol-core" "^0.1.0"
     "@metamask/utils" "^9.1.0"
     uuid "^11.1.0"
 
@@ -6146,10 +6140,10 @@
     ses "^1.14.0"
     validate-npm-package-name "^5.0.0"
 
-"@metamask/solana-wallet-snap@^2.3.7":
-  version "2.3.7"
-  resolved "https://registry.yarnpkg.com/@metamask/solana-wallet-snap/-/solana-wallet-snap-2.3.7.tgz#23da40bb5762a0dbe3f12b9d89d3cabaa5a57dd3"
-  integrity sha512-xHu3urjUkfMeXLm5SEl2CoBSXeWsEYIQ5SjipNBYs2ZKhhP1Tapz1OEN+TGSlusIgoWoBKyLtuUY/Xl53Kj3/w==
+"@metamask/solana-wallet-snap@^2.3.8":
+  version "2.3.8"
+  resolved "https://registry.yarnpkg.com/@metamask/solana-wallet-snap/-/solana-wallet-snap-2.3.8.tgz#73d9f525d61b24e44a1889352bd1d115314bc59f"
+  integrity sha512-UZnsCrhFVIY2HHOEILwBI2qtlxMTGqzln3kKNVVMGJq7+UmDftHyWbaYbD8go55GkCdaOTOBZ8ZhPsSU+JxDBg==
 
 "@metamask/solana-wallet-standard@^0.5.1":
   version "0.5.1"
@@ -18683,16 +18677,6 @@ eciesjs@^0.3.15:
     futoin-hkdf "^1.5.3"
     secp256k1 "^5.0.1"
 
-eciesjs@^0.4.15:
-  version "0.4.15"
-  resolved "https://registry.yarnpkg.com/eciesjs/-/eciesjs-0.4.15.tgz#8c7191ce425c54627ee5c65328ab54eaa6ed4556"
-  integrity sha512-r6kEJXDKecVOCj2nLMuXK/FCPeurW33+3JRpfXVbjLja3XUYFfD9I/JBreH6sUyzcm3G/YQboBjMla6poKeSdA==
-  dependencies:
-    "@ecies/ciphers" "^0.2.3"
-    "@noble/ciphers" "^1.3.0"
-    "@noble/curves" "^1.9.1"
-    "@noble/hashes" "^1.8.0"
-
 edge-paths@^2.1.0:
   version "2.2.1"
   resolved "https://registry.yarnpkg.com/edge-paths/-/edge-paths-2.2.1.tgz#d2d91513225c06514aeac9843bfce546abbf4391"