Merge remote-tracking branch 'origin/main' into first-time-install-e2e-test

* origin/main: (57 commits)
  fix: cp-12.17.0 Fix remove nft (#32102)
  chore: rename migration 154 to 152.1 (#32109)
  feat: bump multichain-api-client 0.2.0 (#32104)
  chore: upgrade assets controllers to v58.0.0 (#32019)
  feat: upload test runs (#32103)
  chore: improving disabled functionality to tabs component (#32081)
  ci: add a soft gate for our page load benchmarks (#31912)
  test: Added bridge user action benchmark (#31952)
  fix: chromedriver crash on Windows (#31962)
  fix: add retries to get-job-id (#32015)
  feat: Adds Remote Mode hardware wallet gating (#32012)
  chore: clean up tech debt for `MegaETH Testnet` integration (#31867)
  chore: bump `@metamask/{polling,gas-fee}-controller` to `v13`,`v23` (#32035)
  chore(snaps): Bump Snaps packages (#32042)
  feat: auto create solana account after ondboarding or srp import cp-12.17.0 (#32038)
  feat: add option to switch from standard account <-> smart account on accounts details modal (#31899)
  fix: cp-12.17.0 - Center buttons in wider popup (#31897)
  feat: add non EVM testnets (#31702)
  feat: expose Multichain API via window.postMessage for Firefox (#30142)
  feat: Add "Create Solana Account" in connection flow when Solana is requested chain by dapp (#31781)
  ...

Author: Gudahtt

.github/scripts/create-e2e-test-report.ts

@@ -0,0 +1,285 @@
+import * as fs from 'fs/promises';
+import humanizeDuration from 'humanize-duration';
+import path from 'path';
+import * as xml2js from 'xml2js';
+
+const XML = {
+  parse: new xml2js.Parser().parseStringPromise,
+};
+
+const humanizer = humanizeDuration.humanizer({
+  language: 'shortEn',
+  languages: {
+    shortEn: {
+      y: () => 'y',
+      mo: () => 'mo',
+      w: () => 'w',
+      d: () => 'd',
+      h: () => 'h',
+      m: () => 'm',
+      s: () => 's',
+      ms: () => 'ms',
+    },
+  },
+  delimiter: ' ',
+  spacer: '',
+  round: true,
+});
+
+function formatTime(ms: number): string {
+  if (ms < 1000) {
+    return `${Math.round(ms)}ms`;
+  }
+  return humanizer(ms);
+}
+
+/**
+ * Replaces HTML `<strong>` tags with ANSI escape codes to format
+ * text as bold in the console output.
+ */
+function consoleBold(str: string): string {
+  return str
+    .replaceAll('<strong>', '\x1b[1m')
+    .replaceAll('</strong>', '\x1b[0m');
+}
+
+interface TestRun {
+  name: string;
+  testSuites: TestSuite[];
+}
+
+interface TestSuite {
+  name: string;
+  job: {
+    name: string;
+    id: string;
+  };
+  path: string;
+  date: Date;
+  tests: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  time: number;
+  testCases: TestCase[];
+}
+
+type TestCase =
+  | {
+      name: string;
+      time: number;
+      status: 'passed';
+    }
+  | {
+      name: string;
+      time: number;
+      status: 'failed';
+      error: string;
+    };
+
+async function main() {
+  const env = {
+    OWNER: process.env.OWNER || 'metamask',
+    REPOSITORY: process.env.REPOSITORY || 'metamask-extension',
+    BRANCH: process.env.BRANCH || 'main',
+    TEST_SUMMARY_PATH:
+      process.env.TEST_SUMMARY_PATH || 'test/test-results/summary.md',
+    TEST_RESULTS_PATH: process.env.TEST_RESULTS_PATH || 'test/test-results/e2e',
+    TEST_RUNS_PATH:
+      process.env.TEST_RUNS_PATH || 'test/test-results/test-runs.json',
+    RUN_ID: process.env.RUN_ID ? +process.env.RUN_ID : 0,
+    PR_NUMBER: process.env.PR_NUMBER ? +process.env.PR_NUMBER : 0,
+    GITHUB_ACTIONS: process.env.GITHUB_ACTIONS === 'true',
+  };
+
+  let summary = '';
+  const core = env.GITHUB_ACTIONS
+    ? await import('@actions/core')
+    : {
+        summary: {
+          addRaw: (text: string) => {
+            summary += text;
+          },
+          write: async () => await fs.writeFile(env.TEST_SUMMARY_PATH, summary),
+        },
+        setFailed: (msg: string) => console.error(msg),
+      };
+
+  try {
+    const testRuns: TestRun[] = [];
+    const filenames = await fs.readdir(env.TEST_RESULTS_PATH);
+
+    for (const filename of filenames) {
+      const file = await fs.readFile(
+        path.join(env.TEST_RESULTS_PATH, filename),
+        'utf8',
+      );
+      const results = await XML.parse(file);
+      for (const suite of results.testsuites.testsuite || []) {
+        if (!suite.testcase || !suite.$.file) continue;
+        const tests = +suite.$.tests;
+        const failed = +suite.$.failures;
+        const skipped = tests - suite.testcase.length;
+        const passed = tests - failed - skipped;
+        const testSuite: TestSuite = {
+          name: suite.$.name,
+          path: suite.$.file.slice(suite.$.file.indexOf(`test${path.sep}`)),
+          job: {
+            name: suite.properties?.[0].property?.[0]?.$.value ?? '',
+            id: suite.properties?.[0].property?.[1]?.$.value ?? '',
+          },
+          date: new Date(suite.$.timestamp),
+          tests,
+          passed,
+          failed,
+          skipped,
+          time: +suite.$.time * 1000, // convert to ms,
+          testCases: [],
+        };
+        for (const test of suite.testcase || []) {
+          const testCase: TestCase = {
+            name: test.$.name,
+            time: +test.$.time * 1000, // convert to ms
+            status: test.failure ? 'failed' : 'passed',
+            error: test.failure ? test.failure[0]._ : undefined,
+          };
+          testSuite.testCases.push(testCase);
+        }
+        const testRun: TestRun = {
+          // regex to remove the shard number from the job name
+          name: testSuite.job.name.replace(/\s+\(\d+\)$/, ''),
+          testSuites: [testSuite],
+        };
+        const existingRun = testRuns.find((run) => run.name === testRun.name);
+        if (existingRun) {
+          existingRun.testSuites.push(testSuite);
+        } else {
+          testRuns.push(testRun);
+        }
+      }
+    }
+
+    for (const testRun of testRuns) {
+      const deduped: { [path: string]: TestSuite } = {};
+      for (const suite of testRun.testSuites) {
+        const existing = deduped[suite.path];
+        // If there is a duplicate, we keep the suite with the latest date
+        if (!existing || existing.date < suite.date) {
+          deduped[suite.path] = suite;
+        }
+      }
+
+      const suites = Object.values(deduped);
+
+      const title = `<strong>${testRun.name}</strong>`;
+      console.log(consoleBold(title));
+
+      if (suites.length) {
+        const total = suites.reduce(
+          (acc, suite) => ({
+            tests: acc.tests + suite.tests,
+            passed: acc.passed + suite.passed,
+            failed: acc.failed + suite.failed,
+            skipped: acc.skipped + suite.skipped,
+          }),
+          { tests: 0, passed: 0, failed: 0, skipped: 0 },
+        );
+
+        core.summary.addRaw(
+          total.failed ? `\n<details open>\n` : `\n<details>\n`,
+        );
+        core.summary.addRaw(`\n<summary>${title}</summary>\n`);
+
+        const times = suites.map((suite) => {
+          const start = suite.date.getTime();
+          const duration = suite.time;
+          return { start, end: start + duration };
+        });
+        const earliestStart = Math.min(...times.map((t) => t.start));
+        const latestEnd = Math.max(...times.map((t) => t.end));
+        const executionTime = latestEnd - earliestStart;
+
+        const conclusion = `<strong>${
+          total.tests
+        }</strong> tests were completed in <strong>${formatTime(
+          executionTime,
+        )}</strong> with <strong>${total.passed}</strong> passed, <strong>${
+          total.failed
+        }</strong> failed and <strong>${total.skipped}</strong> skipped.`;
+
+        console.log(consoleBold(conclusion));
+        core.summary.addRaw(`\n${conclusion}\n`);
+
+        if (total.failed) {
+          console.error(`\n❌ Failed tests\n`);
+          core.summary.addRaw(`\n#### ❌ Failed tests\n`);
+          core.summary.addRaw(
+            `\n<hr style="height: 1px; margin-top: -5px; margin-bottom: 10px;">\n`,
+          );
+          for (const suite of suites) {
+            if (!suite.failed) continue;
+            console.error(suite.path);
+            core.summary.addRaw(
+              `\n#### [${suite.path}](https://github.com/${env.OWNER}/${env.REPOSITORY}/blob/${env.BRANCH}/${suite.path})\n`,
+            );
+            if (suite.job.name && suite.job.id && env.RUN_ID) {
+              core.summary.addRaw(
+                `\n##### Job: [${suite.job.name}](https://github.com/${
+                  env.OWNER
+                }/${env.REPOSITORY}/actions/runs/${env.RUN_ID}/job/${
+                  suite.job.id
+                }${env.PR_NUMBER ? `?pr=${env.PR_NUMBER}` : ''})\n`,
+              );
+            }
+            for (const test of suite.testCases) {
+              if (test.status !== 'failed') continue;
+              console.error(`  ${test.name}`);
+              console.error(`  ${test.error}\n`);
+              core.summary.addRaw(`\n##### ${test.name}\n`);
+              core.summary.addRaw(`\n\`\`\`js\n${test.error}\n\`\`\`\n`);
+            }
+          }
+        }
+
+        const rows = suites.map((suite) => ({
+          'Test suite': suite.path,
+          Passed: suite.passed ? `${suite.passed} ✅` : '',
+          Failed: suite.failed ? `${suite.failed} ❌` : '',
+          Skipped: suite.skipped ? `${suite.skipped} ⏩` : '',
+          Time: formatTime(suite.time),
+        }));
+
+        const columns = Object.keys(rows[0]);
+        const header = `| ${columns.join(' | ')} |`;
+        const alignment = '| :--- | ---: | ---: | ---: | ---: |';
+        const body = rows
+          .map((row) => {
+            const data = {
+              ...row,
+              'Test suite': `[${row['Test suite']}](https://github.com/${env.OWNER}/${env.REPOSITORY}/blob/${env.BRANCH}/${row['Test suite']})`,
+            };
+            return `| ${Object.values(data).join(' | ')} |`;
+          })
+          .join('\n');
+        const table = [header, alignment, body].join('\n');
+
+        console.table(rows);
+        core.summary.addRaw(`\n${table}\n`);
+      } else {
+        core.summary.addRaw(`\n<details open>\n`);
+        core.summary.addRaw(`<summary>${title}</summary>\n`);
+        console.log('No tests found');
+        core.summary.addRaw('No tests found');
+      }
+      console.log();
+      core.summary.addRaw(`</details>\n`);
+    }
+
+    await core.summary.write();
+    await fs.writeFile(env.TEST_RUNS_PATH, JSON.stringify(testRuns, null, 2));
+  } catch (error) {
+    core.setFailed(`Error creating the test report: ${error}`);
+  }
+}
+
+main();

.github/scripts/get-job-id.ts

@@ -0,0 +1,41 @@
+import { retry } from './shared/utils';
+import * as core from '@actions/core';
+
+async function main() {
+  const { Octokit } = await import('octokit');
+
+  const env = {
+    OWNER: process.env.OWNER || 'metamask',
+    REPOSITORY: process.env.REPOSITORY || 'metamask-extension',
+    RUN_ID: +process.env.RUN_ID!,
+    JOB_NAME: process.env.JOB_NAME!,
+    ATTEMPT_NUMBER: +process.env.ATTEMPT_NUMBER!,
+    GITHUB_TOKEN: process.env.GITHUB_TOKEN!,
+    GITHUB_ACTIONS: process.env.GITHUB_ACTIONS === 'true',
+  };
+
+  const github = new Octokit({ auth: env.GITHUB_TOKEN });
+
+  const job = await retry(async () => {
+    const jobs = github.paginate.iterator(
+      github.rest.actions.listJobsForWorkflowRunAttempt,
+      {
+        owner: env.OWNER,
+        repo: env.REPOSITORY,
+        run_id: env.RUN_ID,
+        attempt_number: env.ATTEMPT_NUMBER,
+        per_page: 100,
+      },
+    );
+    for await (const response of jobs) {
+      const job = response.data.find((job) => job.name.endsWith(env.JOB_NAME));
+      if (job) return job;
+    }
+    throw new Error(`Job with name '${env.JOB_NAME}' not found`);
+  });
+
+  console.log(`The job id for '${env.JOB_NAME}' is '${job.id}'`);
+  if (env.GITHUB_ACTIONS) core.setOutput('job-id', job.id);
+}
+
+main();

.github/scripts/shared/utils.ts

@@ -1,3 +1,5 @@
+import { setTimeout } from 'node:timers/promises';
+
 // This helper function checks if version has the correct format: "x.y.z" where "x", "y" and "z" are numbers.
 export function isValidVersionFormat(str: string): boolean {
   const regex = /^\d+\.\d+\.\d+$/;
@@ -39,12 +41,31 @@ export function getCurrentDateFormatted(): string {
 
 // This mapping is used to know what planning repo is used for each code repo
 export const codeRepoToPlanningRepo: { [key: string]: string } = {
-  "metamask-extension": "MetaMask-planning",
-  "metamask-mobile": "mobile-planning"
-}
+  'metamask-extension': 'MetaMask-planning',
+  'metamask-mobile': 'mobile-planning',
+};
 
 // This mapping is used to know what platform each code repo is used for
 export const codeRepoToPlatform: { [key: string]: string } = {
-  "metamask-extension": "extension",
-  "metamask-mobile": "mobile",
+  'metamask-extension': 'extension',
+  'metamask-mobile': 'mobile',
+};
+
+export async function retry<T extends (...args: any[]) => any>(
+  fn: T,
+  { retries = 3, delay = 5000 } = { retries: 3, delay: 5000 },
+): Promise<Awaited<ReturnType<T>>> {
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (attempt === retries) throw err;
+      console.log(
+        `Attempt ${attempt} failed: ${err.message}. Retrying in ${delay}ms...`,
+      );
+      await setTimeout(delay);
+      delay *= 2;
+    }
+  }
+  throw new Error('Retries exhausted');
 }

.github/workflows/automated-rca.yml

@@ -0,0 +1,19 @@
+name: Automated RCA
+
+on:
+  issues:
+    types: [closed]
+
+permissions:
+  issues: write
+  contents: read
+
+jobs:
+  automated-rca:
+    uses: MetaMask/github-tools/.github/workflows/post-gh-rca.yml@115cc6dce7aa32c85cbd77a19e9c04db85fb7920
+    with:
+      google-form-base-url: 'https://docs.google.com/forms/d/e/1FAIpQLSfnfEWH7JCFFtvjCHixgyqJdTU3LW3BmTwdF1dDezTNf7m4ig/viewform?usp=pp_url&entry.340898780='
+      repo-owner: ${{ github.repository_owner }}
+      repo-name: ${{ github.event.repository.name }}
+      issue-number: ${{ github.event.issue.number }}
+      issue-labels: '["Sev0-urgent", "Sev1-high"]'