diff --git a/.github/workflows/generate-lighthouse-diff.yml b/.github/workflows/generate-lighthouse-diff.yml new file mode 100644 index 0000000000..72a6bee774 --- /dev/null +++ b/.github/workflows/generate-lighthouse-diff.yml @@ -0,0 +1,86 @@ +name: Run Lighthouse Diff + +on: + pull_request: + branches: ["master"] + types: + - opened + - reopened + - synchronize + # we skip ci for draft PRs + # https://github.com/reviewdog/action-eslint/issues/29#issuecomment-985939887 + - ready_for_review + workflow_dispatch: + merge_group: + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +jobs: + generate_lighthouse_diff: + name: "Generate lighthouse diff" + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + token: ${{ secrets.GITHUB_TOKEN }} + + - name: Setup Node.js + uses: actions/setup-node@v3 + with: + node-version: '20' + cache: 'yarn' + + - name: Install node_modules + uses: OffchainLabs/actions/node-modules/install@main + + - name: Build scripts + run: yarn workspace scripts build + + - name: Build the bridge + run: yarn build + env: + NEXT_PUBLIC_INFURA_KEY: ${{ secrets.NEXT_PUBLIC_INFURA_KEY }} + NEXT_PUBLIC_INFURA_KEY_ETHEREUM: https://mainnet.infura.io/v3/${{ secrets.NEXT_PUBLIC_INFURA_KEY }} + NEXT_PUBLIC_INFURA_KEY_SEPOLIA: https://sepolia.infura.io/v3/${{ secrets.NEXT_PUBLIC_INFURA_KEY }} + NEXT_PUBLIC_INFURA_KEY_ARBITRUM_ONE: https://arbitrum-mainnet.infura.io/v3/${{ secrets.NEXT_PUBLIC_INFURA_KEY }} + NEXT_PUBLIC_INFURA_KEY_BASE: https://base-mainnet.infura.io/v3/${{ secrets.NEXT_PUBLIC_INFURA_KEY }} + NEXT_PUBLIC_INFURA_KEY_ARBITRUM_SEPOLIA: https://arbitrum-sepolia.infura.io/v3/${{ secrets.NEXT_PUBLIC_INFURA_KEY }} + NEXT_PUBLIC_INFURA_KEY_BASE_SEPOLIA: https://base-sepolia.infura.io/v3/${{ secrets.NEXT_PUBLIC_INFURA_KEY }} + NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID: ${{ secrets.NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID }} + THE_GRAPH_NETWORK_API_KEY: ${{ secrets.THE_GRAPH_NETWORK_API_KEY }} + + - name: Start server and wait + run: yarn start & npx wait-on http://localhost:3000 + + - name: Install linux dependencies + run: | + sudo apt-get update + sudo apt-get install --no-install-recommends -y \ + fluxbox \ + xvfb + + - name: Run xvfb and fluxbox + run: | + Xvfb :0 -screen 0 1366x768x24 -listen tcp -ac & + fluxbox & + env: + DISPLAY: :0.0 + + - name: Run generateLighthouseDiff script + run: yarn workspace scripts generate-lighthouse-diff + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + NEXT_PUBLIC_INFURA_KEY: ${{ secrets.NEXT_PUBLIC_INFURA_KEY }} + DISPLAY: :0.0 + + - name: Upload reports + uses: actions/upload-artifact@v4 + with: + name: lighthouse-reports-${{ github.sha }} + path: | + ./lhreport.html + if-no-files-found: 'ignore' + continue-on-error: true \ No newline at end of file diff --git a/packages/arb-token-bridge-ui/package.json b/packages/arb-token-bridge-ui/package.json index 98a4ee6d54..b07ca300d8 100644 --- a/packages/arb-token-bridge-ui/package.json +++ b/packages/arb-token-bridge-ui/package.json @@ -64,6 +64,7 @@ "start": "next start", "test": "vitest --config vitest.config.ts --watch", "test:ci": "vitest --config vitest.config.ts --run", + "test:perf": "ts-node ./tests/perf/switchNetwork.mts", "lint": "tsc && eslint", "lint:fix": "tsc && eslint --quiet --fix", "prettier:format": "prettier --config-precedence file-override --write \"src/**/*.{tsx,ts,scss,md,json}\"", diff --git a/packages/arb-token-bridge-ui/src/components/TransferPanel/TokenRow.tsx b/packages/arb-token-bridge-ui/src/components/TransferPanel/TokenRow.tsx index d0a5cd9358..91bb39e65d 100644 --- a/packages/arb-token-bridge-ui/src/components/TransferPanel/TokenRow.tsx +++ b/packages/arb-token-bridge-ui/src/components/TransferPanel/TokenRow.tsx @@ -341,6 +341,7 @@ export function TokenRow({ onClick={() => onTokenSelected(token)} style={{ ...style, minHeight: '84px' }} disabled={!tokenIsBridgeable} + aria-label={`Select ${token?.symbol}`} className={twMerge( 'flex w-full flex-row items-center justify-between px-4 py-3 transition duration-200 hover:bg-white/10', tokenIsBridgeable diff --git a/packages/arb-token-bridge-ui/src/components/TransferPanel/TokenSearch.tsx b/packages/arb-token-bridge-ui/src/components/TransferPanel/TokenSearch.tsx index da06258931..c70253c962 100644 --- a/packages/arb-token-bridge-ui/src/components/TransferPanel/TokenSearch.tsx +++ b/packages/arb-token-bridge-ui/src/components/TransferPanel/TokenSearch.tsx @@ -542,7 +542,6 @@ function TokensPanel({ errorMessage={errorMessage} onSubmit={addNewToken} SearchInputButton={AddButton} - dataCy="tokenSearchList" isDialog={true} > diff --git a/packages/arb-token-bridge-ui/src/components/common/NetworkSelectionContainer.tsx b/packages/arb-token-bridge-ui/src/components/common/NetworkSelectionContainer.tsx index 4c6b0e7d85..2bab60cb60 100644 --- a/packages/arb-token-bridge-ui/src/components/common/NetworkSelectionContainer.tsx +++ b/packages/arb-token-bridge-ui/src/components/common/NetworkSelectionContainer.tsx @@ -155,6 +155,9 @@ export function NetworkButton({ )} disabled={disabled} onClick={onClick} + aria-label={ + (isSource ? 'From: ' : 'To: ') + getNetworkName(selectedChainId) + } > {isSource ? 'From:' : 'To: '} {getNetworkName(selectedChainId)} diff --git a/packages/arb-token-bridge-ui/tests/support/commands.ts b/packages/arb-token-bridge-ui/tests/support/commands.ts index 3d3801e53c..5378864a18 100644 --- a/packages/arb-token-bridge-ui/tests/support/commands.ts +++ b/packages/arb-token-bridge-ui/tests/support/commands.ts @@ -163,20 +163,13 @@ export function typeAmount2( export function findSourceChainButton( chain: string ): Cypress.Chainable> { - return cy - .findByRole('button', { name: `From: ${chain}` }) - .should('be.visible') + return cy.get(`[aria-label="From: ${chain}"]`).should('be.visible') } export function findDestinationChainButton( chain: string ): Cypress.Chainable> { - return ( - cy - // - .findByRole('button', { name: `To: ${chain}` }) - .should('be.visible') - ) + return cy.get(`[aria-label="To: ${chain}"]`).should('be.visible') } export function findGasFeeSummary( diff --git a/packages/scripts/package.json b/packages/scripts/package.json index 2564914c93..d4b51eda7b 100644 --- a/packages/scripts/package.json +++ b/packages/scripts/package.json @@ -9,7 +9,8 @@ "test": "vitest", "coverage": "vitest run --coverage", "start": "node dist/index.js", - "add-orbit-chain": "node dist/scripts.cjs.js add-orbit-chain" + "add-orbit-chain": "node dist/scripts.cjs.js add-orbit-chain", + "generate-lighthouse-diff": "node dist/scripts.cjs.js generate-lighthouse-report" }, "author": "", "license": "ISC", @@ -22,7 +23,9 @@ "commander": "^12.1.0", "ethers": "^5.7.2", "file-type": "^19.6.0", + "lighthouse": "^12.6.0", "mime-types": "^2.1.35", + "puppeteer": "^24.9.0", "sharp": "0.32.6", "zod": "^3.23.8" }, diff --git a/packages/scripts/src/generateLighthouseReport/compareLighthouseReports.ts b/packages/scripts/src/generateLighthouseReport/compareLighthouseReports.ts new file mode 100644 index 0000000000..8bd0469047 --- /dev/null +++ b/packages/scripts/src/generateLighthouseReport/compareLighthouseReports.ts @@ -0,0 +1,184 @@ +import { + NavigationResult, + SnapshotResult, + TimespanResult, +} from "./parseLighthouseReports"; +import { parseToFixedNumber } from "./parseToFixedNumber"; + +export async function compareLighthouseReports({ + prevReport, + results, +}: { + prevReport: [NavigationResult, TimespanResult, SnapshotResult]; + results: [NavigationResult, TimespanResult, SnapshotResult]; +}): Promise<{ + navigationDiff: NavigationResult; + timespanDiff: TimespanResult; + snapshotDiff: SnapshotResult; +}> { + // Compare Navigation Results + const prevNavigationResult = prevReport[0]; + const navigationResult = results[0]; + const navigationDiff = { + fcp: { + numericValue: parseToFixedNumber( + prevNavigationResult.fcp.numericValue - + navigationResult.fcp.numericValue, + 3 + ), + score: parseToFixedNumber( + prevNavigationResult.fcp.score - navigationResult.fcp.score, + 2 + ), + }, + lcp: { + numericValue: parseToFixedNumber( + prevNavigationResult.lcp.numericValue - + navigationResult.lcp.numericValue, + 3 + ), + score: parseToFixedNumber( + prevNavigationResult.lcp.score - navigationResult.lcp.score, + 2 + ), + }, + tbt: { + numericValue: parseToFixedNumber( + prevNavigationResult.tbt.numericValue - + navigationResult.tbt.numericValue, + 3 + ), + score: parseToFixedNumber( + prevNavigationResult.tbt.score - navigationResult.tbt.score, + 2 + ), + }, + cls: { + numericValue: parseToFixedNumber( + prevNavigationResult.cls.numericValue - + navigationResult.cls.numericValue, + 3 + ), + score: parseToFixedNumber( + prevNavigationResult.cls.score - navigationResult.cls.score, + 2 + ), + }, + speed: { + numericValue: parseToFixedNumber( + prevNavigationResult.speed.numericValue - + navigationResult.speed.numericValue, + 3 + ), + score: parseToFixedNumber( + prevNavigationResult.speed.score - navigationResult.speed.score, + 2 + ), + }, + performance: parseToFixedNumber( + prevNavigationResult.performance - navigationResult.performance, + 2 + ), + accessibility: parseToFixedNumber( + prevNavigationResult.accessibility - navigationResult.accessibility, + 2 + ), + best_practices: parseToFixedNumber( + prevNavigationResult.best_practices - navigationResult.best_practices, + 2 + ), + seo: parseToFixedNumber(prevNavigationResult.seo - navigationResult.seo, 2), + bundle_size: { + numericValue: parseToFixedNumber( + prevNavigationResult.bundle_size.numericValue - + navigationResult.bundle_size.numericValue, + 3 + ), + score: parseToFixedNumber( + prevNavigationResult.bundle_size.score - + navigationResult.bundle_size.score, + 2 + ), + }, + } satisfies NavigationResult; + + // Compare Timespan Results + const prevTimespanResult = prevReport[1]; + const timespanResult = results[1]; + const timespanDiff = { + tbt: { + numericValue: parseToFixedNumber( + prevTimespanResult.tbt.numericValue - timespanResult.tbt.numericValue, + 3 + ), + score: parseToFixedNumber( + prevTimespanResult.tbt.score - timespanResult.tbt.score, + 2 + ), + }, + cls: { + numericValue: parseToFixedNumber( + prevTimespanResult.cls.numericValue - timespanResult.cls.numericValue, + 3 + ), + score: parseToFixedNumber( + prevTimespanResult.cls.score - timespanResult.cls.score, + 2 + ), + }, + inp: { + numericValue: parseToFixedNumber( + prevTimespanResult.inp.numericValue - timespanResult.inp.numericValue, + 3 + ), + score: parseToFixedNumber( + prevTimespanResult.inp.score - timespanResult.inp.score, + 2 + ), + }, + best_practices: parseToFixedNumber( + prevTimespanResult.best_practices - timespanResult.best_practices, + 2 + ), + longTasks: { + durationMs: parseToFixedNumber( + prevTimespanResult.longTasks.durationMs - + timespanResult.longTasks.durationMs, + 3 + ), + total: parseToFixedNumber( + prevTimespanResult.longTasks.total - timespanResult.longTasks.total, + 2 + ), + }, + performance: parseToFixedNumber( + prevTimespanResult.performance - timespanResult.performance, + 2 + ), + } satisfies TimespanResult; + + // Compare Snapshot Result + const prevSnapshotResult = prevReport[2]; + const snapshotResult = results[2]; + const snapshotDiff = { + performance: parseToFixedNumber( + prevSnapshotResult.performance - snapshotResult.performance, + 2 + ), + accessibility: parseToFixedNumber( + prevSnapshotResult.accessibility - snapshotResult.accessibility, + 2 + ), + best_practices: parseToFixedNumber( + prevSnapshotResult.best_practices - snapshotResult.best_practices, + 2 + ), + seo: parseToFixedNumber(prevSnapshotResult.seo - snapshotResult.seo, 2), + } satisfies SnapshotResult; + + return { + navigationDiff, + timespanDiff, + snapshotDiff, + }; +} diff --git a/packages/scripts/src/generateLighthouseReport/executeLighthouse.ts b/packages/scripts/src/generateLighthouseReport/executeLighthouse.ts new file mode 100644 index 0000000000..6e8f315414 --- /dev/null +++ b/packages/scripts/src/generateLighthouseReport/executeLighthouse.ts @@ -0,0 +1,84 @@ +import puppeteer from "puppeteer"; +import * as core from "@actions/core"; +import { startFlow, desktopConfig } from "lighthouse"; +import { writeFileSync } from "fs"; +import { join, resolve } from "path"; + +const workspaceRoot = resolve(process.cwd(), "../.."); +export async function executeLighthouseFlow(chromePath?: string) { + core.startGroup("Lighthouse execution"); + // Setup the browser and Lighthouse. + const browser = await puppeteer.launch({ + headless: false, + args: ["--no-sandbox"], + dumpio: true, + ...(chromePath ? { executablePath: chromePath } : {}), + }); + const page = await browser.newPage(); + await page.setViewport({ width: 1366, height: 768 }); + + const flow = await startFlow(page, { + config: desktopConfig, + }); + + page.on("console", (log) => { + core.info(`[log] ${log.text()}`); + }); + + page.on("pageError", (err) => { + core.error(`[err] ${err}`); + }); + + await flow.navigate( + "http://localhost:3000/?sourceChain=ethereum&destinationChain=arbitrum-one&tab=bridge&txHistory=0" + ); + + await flow.startTimespan(); + + // Type amount + const input = await page.waitForSelector('[aria-label="Amount input"]'); + await input?.type("2"); + await page.waitForSelector('[aria-label="Route arbitrum"]'); + + // Switch network + await page.click('[aria-label="Switch Networks"]'); + await page.waitForSelector("[aria-label='From: Arbitrum One']"); + + // Open token selection + await page.click("[aria-label='Select Token']"); + const tokenInput = await page.waitForSelector( + "[placeholder='Search by token name, symbol, or address']" + ); + await tokenInput?.type("USDC"); + const usdcButton = await page.waitForSelector('[aria-label="Select USDC.e"]'); + await usdcButton?.click(); + await page.waitForSelector("xpath///button[contains(., 'USDC.e')]"); + + // Open chain selection + await page.click("[aria-label='From: Arbitrum One']"); + const chainInput = await page.waitForSelector( + '[placeholder="Search a network name"]' + ); + await chainInput?.type("Xai"); + + const xaiRow = await page.waitForSelector('[aria-label="Switch to Xai"]'); + await xaiRow?.click(); + await page.waitForSelector("[aria-label='From: Xai']"); + + await flow.endTimespan(); + await flow.snapshot(); + + // Get the comprehensive flow report. + const report = await flow.createFlowResult(); + + writeFileSync( + join(workspaceRoot, "./lhreport.html"), + await flow.generateReport() + ); + + // Cleanup. + await browser.close(); + core.endGroup(); + + return report; +} diff --git a/packages/scripts/src/generateLighthouseReport/index.ts b/packages/scripts/src/generateLighthouseReport/index.ts new file mode 100644 index 0000000000..0630ff867a --- /dev/null +++ b/packages/scripts/src/generateLighthouseReport/index.ts @@ -0,0 +1,60 @@ +import * as core from "@actions/core"; +import { executeLighthouseFlow } from "./executeLighthouse"; +import { + NavigationResult, + parseLighthouseReports, + SnapshotResult, + TimespanResult, +} from "./parseLighthouseReports"; +import { join, resolve } from "path"; +import { config } from "../../../../package.json"; +import { postComment } from "./postComment"; +import { compareLighthouseReports } from "./compareLighthouseReports"; +import lighthouseBaseline from "./lighthouseBaseline.json"; + +const workspaceRoot = resolve(process.cwd(), "../.."); +// "node_modules/.cache/synpress/chrome/linux-128.0.6613.137/chrome-linux64/chrome" +const chromePath = join( + workspaceRoot, + config.chromePath, + `/chrome/linux-${config.chromeVersion}`, + "chrome-linux64/chrome" +); +export async function generateLighthouseReport() { + try { + // Reports need to be run sequentially + const report1 = await executeLighthouseFlow(chromePath); + const report2 = await executeLighthouseFlow(chromePath); + const report3 = await executeLighthouseFlow(chromePath); + + core.startGroup("Parse lighthouse report"); + const [parsedNavigationReport, parsedTimespanReport, parsedSnapshotReport] = + parseLighthouseReports([report1, report2, report3]); + core.endGroup(); + + core.setOutput("parsedNavigationReport", parsedNavigationReport); + core.startGroup("Compare lighthouse results"); + const diff = await compareLighthouseReports({ + prevReport: lighthouseBaseline as [ + NavigationResult, + TimespanResult, + SnapshotResult + ], + results: [ + parsedNavigationReport, + parsedTimespanReport, + parsedSnapshotReport, + ], + }); + core.endGroup(); + + await postComment({ + parsedNavigationReport, + parsedTimespanReport, + parsedSnapshotReport, + ...diff, + }); + } catch (error) { + console.log(error); + } +} diff --git a/packages/scripts/src/generateLighthouseReport/lighthouseBaseline.json b/packages/scripts/src/generateLighthouseReport/lighthouseBaseline.json new file mode 100755 index 0000000000..8342ff942c --- /dev/null +++ b/packages/scripts/src/generateLighthouseReport/lighthouseBaseline.json @@ -0,0 +1,23 @@ +[ + { + "fcp": { "numericValue": 729.705, "score": 96.67 }, + "lcp": { "numericValue": 2824.252, "score": 38 }, + "tbt": { "numericValue": 124.167, "score": 93.33 }, + "cls": { "numericValue": 0, "score": 100 }, + "speed": { "numericValue": 1274.504, "score": 90.33 }, + "performance": 81.33, + "accessibility": 90, + "best_practices": 100, + "seo": 100, + "bundle_size": { "numericValue": 2754742.333, "score": 50 } + }, + { + "performance": 49.67, + "tbt": { "numericValue": 931.928, "score": 7.33 }, + "cls": { "numericValue": 0.005, "score": 100 }, + "inp": { "numericValue": 189.333, "score": 91 }, + "best_practices": 95, + "longTasks": { "total": 16, "durationMs": 1748.595 } + }, + { "performance": 0, "best_practices": 100, "accessibility": 91, "seo": 100 } +] diff --git a/packages/scripts/src/generateLighthouseReport/parseLighthouseReports.ts b/packages/scripts/src/generateLighthouseReport/parseLighthouseReports.ts new file mode 100644 index 0000000000..0eac342504 --- /dev/null +++ b/packages/scripts/src/generateLighthouseReport/parseLighthouseReports.ts @@ -0,0 +1,319 @@ +import { FlowResult } from "lighthouse"; +import { parseToFixedNumber } from "./parseToFixedNumber"; +import { log } from "console"; + +type Metric = { + /** Number from 0 to 1 */ + score: number; + numericValue: number; +}; +export type NavigationResult = { + fcp: Metric; + lcp: Metric; + tbt: Metric; + cls: Metric; + speed: Metric; + bundle_size: Metric; + performance: number; + accessibility: number; + best_practices: number; + seo: number; +}; +export type TimespanResult = { + performance: number; + tbt: Metric; + cls: Metric; + inp: Metric; + best_practices: number; + longTasks: { + total: number; + durationMs: number; + }; +}; +export type SnapshotResult = { + performance: number; + accessibility: number; + best_practices: number; + seo: number; +}; + +function parse(result: FlowResult.Step, metricName: string): Metric { + const metric = result.lhr.audits[metricName]; + + return { + score: metric.score || 0, + numericValue: metric.numericValue || 0, + }; +} + +function generateMetric({ + key, + length, + report, +}: { + key: TKey; + length: number; + report: { + [key in TKey]: { + numericValue: number; + score: number; + }; + }; +}) { + return { + numericValue: parseToFixedNumber(report[key].numericValue / length, 3), + score: parseToFixedNumber((report[key].score / length) * 100, 2), + }; +} + +export function parseNavigationResults( + navigationReports: FlowResult.Step[] +): NavigationResult { + const mergedReports = navigationReports.reduce( + function parseNavigationResultsReduce(acc, report) { + const fcp = parse(report, "first-contentful-paint"); + const lcp = parse(report, "largest-contentful-paint"); + const tbt = parse(report, "total-blocking-time"); + const cls = parse(report, "cumulative-layout-shift"); + const bundle_size = parse(report, "total-byte-weight"); + const speed = report.lhr.audits["speed-index"]; + + return { + fcp: { + numericValue: acc.fcp.numericValue + fcp.numericValue, + score: acc.fcp.score + fcp.score, + }, + lcp: { + numericValue: acc.lcp.numericValue + lcp.numericValue, + score: acc.lcp.score + lcp.score, + }, + tbt: { + numericValue: acc.tbt.numericValue + tbt.numericValue, + score: acc.tbt.score + tbt.score, + }, + cls: { + numericValue: acc.cls.numericValue + cls.numericValue, + score: acc.cls.score + cls.score, + }, + speed: { + numericValue: acc.speed.numericValue + (speed.numericValue || 0), + score: acc.speed.score + (speed.score || 0), + }, + bundle_size: { + numericValue: acc.bundle_size.numericValue + bundle_size.numericValue, + score: acc.bundle_size.score + bundle_size.score, + }, + performance: + acc.performance + (report.lhr.categories.performance.score || 0), + accessibility: + acc.accessibility + (report.lhr.categories.accessibility.score || 0), + best_practices: + acc.best_practices + + (report.lhr.categories["best-practices"].score || 0), + seo: acc.seo + (report.lhr.categories.seo.score || 0), + }; + }, + { + fcp: { + numericValue: 0, + score: 0, + }, + lcp: { + numericValue: 0, + score: 0, + }, + tbt: { + numericValue: 0, + score: 0, + }, + cls: { + numericValue: 0, + score: 0, + }, + speed: { + numericValue: 0, + score: 0, + }, + bundle_size: { + numericValue: 0, + score: 0, + }, + performance: 0, + accessibility: 0, + best_practices: 0, + seo: 0, + } satisfies NavigationResult + ); + + const length = navigationReports.length; + return { + fcp: generateMetric({ key: "fcp", length, report: mergedReports }), + lcp: generateMetric({ key: "lcp", length, report: mergedReports }), + tbt: generateMetric({ key: "tbt", length, report: mergedReports }), + cls: generateMetric({ key: "cls", length, report: mergedReports }), + speed: generateMetric({ key: "speed", length, report: mergedReports }), + bundle_size: generateMetric({ + key: "bundle_size", + length, + report: mergedReports, + }), + performance: parseToFixedNumber( + (mergedReports.performance / length) * 100, + 2 + ), + accessibility: parseToFixedNumber( + (mergedReports.accessibility / length) * 100, + 2 + ), + best_practices: parseToFixedNumber( + (mergedReports.best_practices / length) * 100, + 2 + ), + seo: parseToFixedNumber((mergedReports.seo / length) * 100, 2), + }; +} + +export function parseTimespanResults( + timespanReports: FlowResult.Step[] +): TimespanResult { + const mergedReports = timespanReports.reduce( + function parseTimespanResultsReduce(acc, report) { + const tbt = parse(report, "total-blocking-time"); + const cls = parse(report, "cumulative-layout-shift"); + const inp = parse(report, "interaction-to-next-paint"); + const longTasks = ( + report.lhr.audits["long-tasks"].details! as unknown as { + items: { + url: string; + duration: number; + startTime: number; + }[]; + } + ).items; + + return { + performance: + acc.performance + (report.lhr.categories.performance.score || 0), + tbt: { + numericValue: acc.tbt.numericValue + tbt.numericValue, + score: acc.tbt.score + tbt.score, + }, + cls: { + numericValue: acc.cls.numericValue + cls.numericValue, + score: acc.cls.score + cls.score, + }, + inp: { + numericValue: acc.inp.numericValue + inp.numericValue, + score: acc.inp.score + inp.score, + }, + best_practices: + acc.best_practices + + (report.lhr.categories["best-practices"].score || 0), + longTasks: { + total: acc.longTasks.total + longTasks.length, + durationMs: longTasks.reduce( + (sum, task) => sum + task.duration, + acc.longTasks.durationMs + ), + }, + }; + }, + { + performance: 0, + tbt: { + numericValue: 0, + score: 0, + }, + cls: { + numericValue: 0, + score: 0, + }, + inp: { numericValue: 0, score: 0 }, + best_practices: 0, + longTasks: { + total: 0, + durationMs: 0, + }, + } satisfies TimespanResult + ); + + const length = timespanReports.length; + return { + performance: parseToFixedNumber( + (mergedReports.performance / length) * 100, + 2 + ), + tbt: generateMetric({ key: "tbt", length, report: mergedReports }), + cls: generateMetric({ key: "cls", length, report: mergedReports }), + inp: generateMetric({ key: "inp", length, report: mergedReports }), + best_practices: parseToFixedNumber( + (mergedReports.best_practices / length) * 100, + 2 + ), + longTasks: { + total: parseToFixedNumber(mergedReports.longTasks.total / length, 2), + durationMs: parseToFixedNumber( + mergedReports.longTasks.durationMs / length, + 3 + ), + }, + }; +} + +export function parseSnapshotResults( + snapshotReports: FlowResult.Step[] +): SnapshotResult { + const mergedReports = snapshotReports.reduce( + function parseSnapshotResultsReduce(acc, report) { + return { + performance: + acc.performance + (report.lhr.categories.performance.score || 0), + best_practices: + acc.best_practices + + (report.lhr.categories["best-practices"].score || 0), + accessibility: + acc.accessibility + (report.lhr.categories.accessibility.score || 0), + seo: acc.seo + (report.lhr.categories.seo.score || 0), + }; + }, + { + performance: 0, + best_practices: 0, + accessibility: 0, + seo: 0, + } satisfies SnapshotResult + ); + + const length = snapshotReports.length; + return { + performance: parseToFixedNumber( + (mergedReports.performance / length) * 100, + 2 + ), + best_practices: parseToFixedNumber( + (mergedReports.best_practices / length) * 100, + 2 + ), + accessibility: parseToFixedNumber( + (mergedReports.accessibility / length) * 100, + 2 + ), + seo: parseToFixedNumber((mergedReports.seo / length) * 100, 2), + }; +} + +export function parseLighthouseReports( + reports: FlowResult[] +): [NavigationResult, TimespanResult, SnapshotResult] { + const navigationReports = reports.map((report) => report.steps[0]); + const timespanReports = reports.map((report) => report.steps[1]); + const snapshotReports = reports.map((report) => report.steps[2]); + + console.log(parseNavigationResults(navigationReports)); + + return [ + parseNavigationResults(navigationReports), + parseTimespanResults(timespanReports), + parseSnapshotResults(snapshotReports), + ] as const; +} diff --git a/packages/scripts/src/generateLighthouseReport/parseToFixedNumber.ts b/packages/scripts/src/generateLighthouseReport/parseToFixedNumber.ts new file mode 100644 index 0000000000..c610b0a1a5 --- /dev/null +++ b/packages/scripts/src/generateLighthouseReport/parseToFixedNumber.ts @@ -0,0 +1,3 @@ +export function parseToFixedNumber(num: number, fractionDigits: number) { + return Number(num.toFixed(fractionDigits)); +} diff --git a/packages/scripts/src/generateLighthouseReport/postComment.ts b/packages/scripts/src/generateLighthouseReport/postComment.ts new file mode 100644 index 0000000000..2b76ff34cf --- /dev/null +++ b/packages/scripts/src/generateLighthouseReport/postComment.ts @@ -0,0 +1,79 @@ +import * as core from "@actions/core"; +import { getOctokit, context } from "@actions/github"; +import { + NavigationResult, + SnapshotResult, + TimespanResult, +} from "./parseLighthouseReports"; + +export async function postComment({ + parsedNavigationReport, + parsedTimespanReport, + parsedSnapshotReport, + navigationDiff, + timespanDiff, + snapshotDiff, +}: { + parsedNavigationReport: NavigationResult; + parsedTimespanReport: TimespanResult; + parsedSnapshotReport: SnapshotResult; + navigationDiff: NavigationResult; + timespanDiff: TimespanResult; + snapshotDiff: SnapshotResult; +}) { + core.startGroup("Post comment"); + const github = getOctokit(process.env.GITHUB_TOKEN || ""); + + const { data: comment } = await github.rest.issues.createComment({ + ...context.repo, + issue_number: context.issue.number, + // Identation needs to be on the same level, otherwise github doesn't format it properly + // prettier-ignore + body: ` +
+Lighthouse results + + + +Navigation: +| Name | Result | Delta | +|----------------------------|---------------------------------|-------| +| Performance | ${parsedNavigationReport.performance} | ${navigationDiff.performance} | +| Accessibility | ${parsedNavigationReport.accessibility} | ${navigationDiff.accessibility} | +| Best Practices | ${parsedNavigationReport.best_practices} | ${navigationDiff.best_practices} | +| SEO | ${parsedNavigationReport.seo} | ${navigationDiff.seo} | +| First Contentful Paint | ${parsedNavigationReport.fcp.score} (${parsedNavigationReport.fcp.numericValue} ms) | ${navigationDiff.fcp.score} (${navigationDiff.fcp.numericValue} ms) | +| Largest Contentful Paint | ${parsedNavigationReport.lcp.score} (${parsedNavigationReport.lcp.numericValue} s) | ${navigationDiff.lcp.score} (${navigationDiff.lcp.numericValue} ms) | +| Total Blocking Time | ${parsedNavigationReport.tbt.score} (${parsedNavigationReport.tbt.numericValue} ms) | ${navigationDiff.tbt.score} (${navigationDiff.tbt.numericValue} ms) | +| Cumulative Layout Shift | ${parsedNavigationReport.cls.score} (${parsedNavigationReport.cls.numericValue}) | ${navigationDiff.cls.score} (${navigationDiff.cls.numericValue} ms) | +| Speed Index | ${parsedNavigationReport.speed.score} (${parsedNavigationReport.speed.numericValue}s) | ${navigationDiff.speed.score} (${navigationDiff.speed.numericValue} ms) | +| Bundle Size | ${parsedNavigationReport.bundle_size.score} (${parsedNavigationReport.bundle_size.numericValue} byte) | ${navigationDiff.bundle_size.score} (${navigationDiff.bundle_size.numericValue} byte) | + + +Timespan: +| Name | Result | Delta | +|----------------------------|---------------------------------|-------| +| Performance | ${parsedTimespanReport.performance} |${timespanDiff.performance} | +| Total Blocking Time | ${parsedTimespanReport.tbt.score} (${parsedTimespanReport.tbt.numericValue} ms) | ${timespanDiff.tbt.score} (${timespanDiff.tbt.numericValue} ms) | +| Cumulative Layout Shift | ${parsedTimespanReport.cls.score} (${parsedTimespanReport.cls.numericValue}) | ${timespanDiff.cls.score} (${timespanDiff.cls.numericValue} ms) | +| Interaction to Next Paint | ${parsedTimespanReport.inp.score} (${parsedTimespanReport.inp.numericValue} ms) | ${timespanDiff.inp.score} (${timespanDiff.inp.numericValue} ms) | +| Best practices | ${parsedTimespanReport.best_practices} | ${timespanDiff.best_practices} | +| Long tasks | ${parsedTimespanReport.longTasks.total} (${parsedTimespanReport.longTasks.durationMs} ms) | ${timespanDiff.longTasks.total} (${timespanDiff.longTasks.durationMs} ms) | + +Snapshot: +| Name | Result | Delta | +|----------------------------|---------------------------------|-------| +| Performance | ${parsedSnapshotReport.performance} | ${snapshotDiff.performance} | +| Accessibility | ${parsedSnapshotReport.accessibility} | ${snapshotDiff.accessibility} | +| Best practices | ${parsedSnapshotReport.best_practices} | ${snapshotDiff.best_practices} | +| SEO | ${parsedSnapshotReport.seo} | ${snapshotDiff.seo} | + +
+ `, + }); + + core.info( + `Created comment id '${comment.id}' on issue '${context.issue.number}'.` + ); + core.endGroup(); +} diff --git a/packages/scripts/src/generateLighthouseReport/tests/__mocks__/output.json b/packages/scripts/src/generateLighthouseReport/tests/__mocks__/output.json new file mode 100644 index 0000000000..19b9823e5b --- /dev/null +++ b/packages/scripts/src/generateLighthouseReport/tests/__mocks__/output.json @@ -0,0 +1,26650 @@ +{ + "steps": [ + { + "lhr": { + "lighthouseVersion": "12.6.0", + "requestedUrl": "http://localhost:3000/?sourceChain=ethereum&destinationChain=arbitrum-one&tab=bridge&txHistory=0", + "mainDocumentUrl": "http://localhost:3000/?sourceChain=ethereum&destinationChain=arbitrum-one&tab=bridge&txHistory=0", + "finalDisplayedUrl": "http://localhost:3000/?sourceChain=ethereum&destinationChain=arbitrum-one&tab=bridge&txHistory=0", + "finalUrl": "http://localhost:3000/?sourceChain=ethereum&destinationChain=arbitrum-one&tab=bridge&txHistory=0", + "fetchTime": "2025-05-30T19:04:56.257Z", + "gatherMode": "navigation", + "runWarnings": [], + "userAgent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36", + "environment": { + "networkUserAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36", + "hostUserAgent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36", + "benchmarkIndex": 3387.5, + "credits": { + "axe-core": "4.10.3" + } + }, + "audits": { + "is-on-https": { + "id": "is-on-https", + "title": "Uses HTTPS", + "description": "All sites should be protected with HTTPS, even ones that don't handle sensitive data. This includes avoiding [mixed content](https://developers.google.com/web/fundamentals/security/prevent-mixed-content/what-is-mixed-content), where some resources are loaded over HTTP despite the initial request being served over HTTPS. HTTPS prevents intruders from tampering with or passively listening in on the communications between your app and your users, and is a prerequisite for HTTP/2 and many new web platform APIs. [Learn more about HTTPS](https://developer.chrome.com/docs/lighthouse/pwa/is-on-https/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "redirects-http": { + "id": "redirects-http", + "title": "Redirects HTTP traffic to HTTPS", + "description": "Make sure that you redirect all HTTP traffic to HTTPS in order to enable secure web features for all your users. [Learn more](https://developer.chrome.com/docs/lighthouse/pwa/redirects-http/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "viewport": { + "id": "viewport", + "title": "Has a `` tag with `width` or `initial-scale`", + "description": "A `` not only optimizes your app for mobile screen sizes, but also prevents [a 300 millisecond delay to user input](https://developer.chrome.com/blog/300ms-tap-delay-gone-away/). [Learn more about using the viewport meta tag](https://developer.chrome.com/docs/lighthouse/pwa/viewport/).", + "score": 1, + "scoreDisplayMode": "metricSavings", + "warnings": [], + "metricSavings": { + "INP": 0 + }, + "details": { + "type": "debugdata", + "viewportContent": "width=device-width, initial-scale=1" + }, + "guidanceLevel": 3 + }, + "first-contentful-paint": { + "id": "first-contentful-paint", + "title": "First Contentful Paint", + "description": "First Contentful Paint marks the time at which the first text or image is painted. [Learn more about the First Contentful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/first-contentful-paint/).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 442.24474999999995, + "numericUnit": "millisecond", + "displayValue": "0.4 s", + "scoringOptions": { + "p10": 934, + "median": 1600 + } + }, + "largest-contentful-paint": { + "id": "largest-contentful-paint", + "title": "Largest Contentful Paint", + "description": "Largest Contentful Paint marks the time at which the largest text or image is painted. [Learn more about the Largest Contentful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-largest-contentful-paint/)", + "score": 0.03, + "scoreDisplayMode": "numeric", + "numericValue": 6386.565749999998, + "numericUnit": "millisecond", + "displayValue": "6.4 s", + "scoringOptions": { + "p10": 1200, + "median": 2400 + } + }, + "first-meaningful-paint": { + "id": "first-meaningful-paint", + "title": "First Meaningful Paint", + "description": "First Meaningful Paint measures when the primary content of a page is visible. [Learn more about the First Meaningful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/first-meaningful-paint/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "speed-index": { + "id": "speed-index", + "title": "Speed Index", + "description": "Speed Index shows how quickly the contents of a page are visibly populated. [Learn more about the Speed Index metric](https://developer.chrome.com/docs/lighthouse/performance/speed-index/).", + "score": 0.01, + "scoreDisplayMode": "numeric", + "numericValue": 5786.937630172584, + "numericUnit": "millisecond", + "displayValue": "5.8 s", + "scoringOptions": { + "p10": 1311, + "median": 2300 + } + }, + "screenshot-thumbnails": { + "id": "screenshot-thumbnails", + "title": "Screenshot Thumbnails", + "description": "This is what the load of your site looked like.", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "filmstrip", + "scale": 5187, + "items": [ + { + "timing": 648, + "timestamp": 31363305945, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 1297, + "timestamp": 31363954320, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 1945, + "timestamp": 31364602695, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 2594, + "timestamp": 31365251070, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 3242, + "timestamp": 31365899445, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 3890, + "timestamp": 31366547820, + "data": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAFcAfQDASIAAhEBAxEB/8QAHAABAQEAAwEBAQAAAAAAAAAAAAECAwQFBgcI/8QARhAAAQMCBAQDBAYIBgAGAwEAAQACESExAxJBUQQFYXEigZEGEzKhNEKxs8HwFBVSU3OS0eEHFiNUg/EkM2JjgqIXNXKy/8QAFgEBAQEAAAAAAAAAAAAAAAAAAAMB/8QAHREBAAMAAgMBAAAAAAAAAAAAAAECAyExBBFxgf/aAAwDAQACEQMRAD8A/lRERBRVbx8HF4fFOHj4b8LEF2vaQR5Ffrn+Dns3w3MsflMMGE/iDj4/F8dlzYnD4GFVxw5kNMD4omSKr3v8QPZvg+G5vh8m4k43H4TcH3eLjcS8PxuH4j3fvHNY8AHKMwGUyCQ6ivXCbRx9RttFZ5+PwFF9LyH2N5rzv2f5lzfgsOeH4KfCWuJxS1uZ4aQI8LamSLgCSYXv/wD4s479J4XB/WvL5xjiAklwyFmA7GdcVhrY6Fzd1BZ+dovt+L/w+4jg+b8LwPFc04JjeJ4jC4bCxgHuaXYmG17bC3jAneU4P2AxOO5ZxnHcJzfgn4OA/iGNLmvbn9zhNxHmooIdAnUIPiEX2vA/4d8x4nmPGcNj8Vw3CYfC8QMB3EY4eMMzhYuLnBy1aG4LvULzfaf2R4/2b5dy/ieZuwmY3F4mNhO4YT7zAdh5DD6RUYjXCCaEIPnF3OVU4s/wcX7ty6a7nKjHFk/+zi/duQZLyYmQVkENPmqA1wEkknXdLODhF+yDJFYBvYpBAIEnfcQtGJDW96bqCCQAKGhlBMQHWk26/wB1kWkD5rYia0aFGkx8RHVBIGWJnWiy01kUWy3S2klQkk1jZBnfqpJn+i5CZmNLLPhJobVqgzFCRZCKa+a19WJ8hqoGyJrEoM2Qg3gwFtwuKmKys6XrZBlW2qsXglAEGYTZUCoVIjqgzFVf+qoDFIohEIJCBW3/AErcfggkHZAN1SKCkKT8rIBqTZAkX0hU1N0AeKalSB2K0IqTPkqAJoCQgxFJlaFHQZQkEGpn7FQ2Yj0QZN4M7LUDOdgkTQhVsxBogoBDQQTX5o0DNY0Ky2ZIFIuCFco0PWqCw6JcdN6wo4DLYiLrRnLammv5soASZEemkIDvjnWbkpGzTHTRXNmIMmR0WnTJa3WNb/ggyMrXRILgPxWiSCTMk0slSMooJpT7VS2WA1j5IIQC2Y8O5rVaAJaSyZ0UMTIJtQXqoHAgDLp2CDRaTJmgGtFAR4S3WNaKukOBAruaJv8AslAFIAO8CFWgzUSZvNVkvEyWzAgU1Vd/6ZyFBoQ0A0ppKhOWLARUbowTJaBEajqgAafCBertEEgUPn3CrWQKAz6IBMGg72WgfqiSSb7oGUychdHQSihGG6C8uBjSP6og6KIiD9T/AMHf8T+H9i8X9F5ty39K4F5DTj4JjGw2Z2vcwAnK5rixsihia6K+1H+IvDYjMc8E39P5lxD34mLxeI04eGx7i7xMZcuh5EmBSxX5WitnvfOJis98I6ePTSYm0dT7/XKzHxmZMmLiN92SWQ4jKTcjZcuDx/GYGL73B4viMPFzZs7MQgzBEyDeCR5rqoorOzjcdxePi+9xuKx8TFzB+d+IScwoDJ1oKrjbxGM0ANxcQQXEQ40LhB9RQriRB28XmXHYuFh4WLxvEvw8MFrGOxXENBEEATSlOy4sficfiP8Az8bExaz43F1YAmvQAeQXCiAvT5LwmNi4zsQNAw/d4jcz3BoJLCIEmtSF5i+ojD8AE+6GGPdxtFP7+aDxcTCxMB4biYbmvH7Q+zosQdbSvT5oQOCwS74g9wbvEV8p/FeVAzajbqgpEQ4VtCj2nNmiT2VIgPLhJ7/nZUiIyOAM+qDNXOBLSQL0UFC0x4gNbo51KyCkzFrQKIBFpNR/ZKGZEBAPDlg7wlIBLTF5hBm7aEeSkxUWWg2RDYM3VGrpMXiUGCRBhU5dLWViDEXrZSDMmIAQQmYp1SBFq3qUdBrQKkBryIMdUGSLaEoLRFStaEGpjZZyyZEXtKBHenkhjSw1hUVl327IR9aIGkFBkggiPkraonaq1dwLbmlYSDljQ2KDBAJOvUIRfZaaREUVMtkFBmKwNOqOob9aLQOY7QVBUZZN0EAEmIPZXWDQ2rokDM0RrUI+C42jcIJXQSFogRFkGYV0KoBcJNuyCNiKkXmd1Klw0JVja32qhtiI72QSn1fivdUAGwFkbQTUTFBqjYtFYkSgHKImdFXNGUAECLpJAJoBMwbSqIIdIMaIIyRBJpNzVIMCN7ha+o60EUhMw+G1KHZBHUAB0CTLIqdQFRUExmadyqYNA0x106IMgj6sxNlqKTtFwo6Qz6uXSiAOiWkO6FBWkCwEbfiq3M42oKfkqtBBM3BuFl4giAe0zCChkNNQCDUmy04QB28isGC2ktFqrkgSYmBYHXdBggVEiAjgXPOUtIHmtAeIzQXEqMuIuDogrTSHNg7ApJEC7TSoWZmWkVF+q040BBMDRBAYNJpK0CAKyB9qjw0iWnSST9ioyyKy3qgzmj4JLUR4gxl07og6SIvV5dy7C4jgzjPGK8y8EMc1uQNDSXV+K/wiLXQeUi5eJwxg8Ri4QdmDHluaImDdfVYPslgcVh/+G5iw4mXBcWZSSzOxpM0Fi6SQTDQTog+QRfXcP7HDiMTDw8HmWG55+Jow62efDXxHwHa6+V4jD9zj4mFma7I4tzNsYNwg40REBERAXqcl4vGZinBzNdhDDxHBr2BwBDHERNqheWu7yj6baf8ASxaf8bkFx8bE4jEOJivLndBAA2AFlhziRMgQtBpzCYzaQbrMy4tkiOiCuENJJgnULjzZRFDZcg+Ks0gmVH1EnKZCAPDMnvW/RRokU9JWoDpAg6KPkRQ2iSgmU5TFtf7qVqABG5NIVMgy416KQIsADqghqbwJ9FXANIDhF6KmYgSDO1goQPFJH4oIGfFUwNolUuENExocuygIh2WD3FwjW+EzfqLeaASRSLbpEyXGBukkuA3GtFqmU0qDSshBgthpn5FLtvDYsAr9WNbd1lon4SIQGtBcMtpoFW5phoofktGAXEx5BQgGNPK6COgmjYO26RB8JJMLbpJM62IWDNNftQAJAMjZMsmC5sEUKrhLQTrpCy3xGAPIaoAAkyDTohLf2SOqoaWu/Z1lDE0oNBqgrWmCZIi1JUc2x8J0haJ8NulrKQ0vES5BKEgREbK5q0aZ3NVREa3SA0kE/L0QZ+re4tqgAoL/AClUzPS4GypcSJIgxCCUkzYUJurIpAMil0IDqFpE6hVkxAbQCsfigQC3KBXWEjK6oIJ0V6UmNFgSGmCaiaINCDmBEk2MVRroi+xK1mAoBDtlGmHRA3QQtIOhBt1W2EEVME3KyKgTF6aKZGggWA13QaEF4iDNh+CgkyXC52VEXg1VnMIuPmghEAE2NAjRcxEChIojSTrFhmWjSpPlsgxmrAbEii0AcpMmRoggggBxGm4VkxBB2tdBIMGoEXhC0ONAaKkxGx1hHmkkAMOkoBywamJ12VmIIED5eqhl2WABShujiZObylABGYgAA3pZUAtJFDIspehMdJVJIAAgDQmkoKC8D/TcQOlUQZYrHmUQeeubC4nHwWhuDj4uG0OzANeQJiJ7wuFUAkgASToEAkkkkySoi3iYWJhhpxGOYHCW5hEjcIMIqQREgiajqogIiICIiAu7yj6b/wAWL925dJd3lAnjSN8LF+7cgOABkQJqQbpEGghrlWmTmI0vKtibAkWQRwDSS2SRv/VQtaC01rbLooAADW3VUnxQRS8oBzZiSTIuTVZe00E2G6pgkCSQfVQSXNqZ3CC2zAzSpooQWOgilgtGjqGZG35hSHQJAmNkEMVbAE9EALjNsupVE9zJ0QARqBuaoJd0CADedUIE5aiPNUGW11oaXWWiGiImboAmIcfCEkAAgxQ6LVBWovSVfdxMDxAWugwRldJ1+SZhIgG9VZj4gbpAAMmulOiDAEaCZWvCILW70280aTMANFVDlmsz0KCOadSZtGvZNYipNitQDRrT21QNrB7AislBSMstaRI06qNEggUAqdFS2oI+ExQo4dIg3miCQBDtRbdGtMRSpoq6hcZ17K0c1pmTNBsgw0AyHCCLWkq3a1tQJoFGgzAkxotukHKROkgygyZECbeagBIIkTe626SaXNyoA4EUpugBggmfQW6qGRM1msEWWgSGgmbo0gEz4iBUA3QRwNyAR1QACKW6LQgkiDeoNkIEQCZGlkEFiBIFzF1C2JBJmalGhpaSQdoQglppTqgNFCQKawbrTodEECKqVAkCDpW9EBzOgTBsgEUDq+a1if8AoMuGoWYIoXVIiq1QeIxG6CZpoL0gxdVoBBkxWOqG2gEU6pM00HkgsFrBlmlaBZbWp9LrQDhILqRJ03WRBdAoImyA6KkGusBUkm5EdRCvwtNZ0gBRwBcJidOqDYMtaCCfsWIpQweyHck5TaStVNRTsEEdMUieqraUBHf+6ggurQ2lUgUIMoDiSZNxuoILaECTuqRawOpCgIBmCYrCDbZAo6JrVFhzm0zNJMIg6C9v2a51hcpxcT33C4WK3EBHvcjXYjKfVn5ikgnoR4iIOXisQY3FY2KM0PeXDNep1jVfRn2sOI3CwsfgsLE4fDGGGtIBIysaxxBcDU5GnaljWfl0QfaYntVyocLhYbOR4GI/KM2I4NBB94XUpBpFYAkmkUXS4z2k4bieV4nCP5c1zzhe6w8VxZLP9R75EMH7cGNl8wiAiIgKqIg5uIxhi5cuFh4cXyC53/tZc/KBPGkD91i/duXSXd5R9N/4sX7tyCuMkTWLxsoQQbSQtD4RFRa0JBu02QZIgVFPmmIZOubUlWJbeD8kgtrEIIYIJFxRCCQwxlO6Am1Z8pVn4aAt1QZioJr3K1BBANTfshq3wjXQyhgk5iB1j5IIaSKgaUUMCQ74tPz6KkZnF0gnU+SZh1z/ACQWCKCSdOnf5qeKQQTJQgS05SBKpF4AJtO6DLRYNBO8IQSM1gLkqxFWkEWJUMNdQz03QMpyk1MXmifitOmNiakBQAxAmSbIJJMQel1GyerkggxHi0islVsE6oJNTGmioEtoSXWlKmKHL3gFVriYuUGYBh0xmpGqsawcxF91TB+qMp6IaEAm2oCDIFDMiTfWFoiY8OU27lUQXCmmiAOOJLe4O5lBxkGXSCIETZaIp/puHqtGCYiZ2EKONAIl03hAyWBfIhAMosY3U+sKdVQPGYmDcIJiNbJAIANwFQG9aa3CNJdQAzYSbKZSYNfVAdR3i0tstNMACmW1Vkia1A62W2WEAX9EGDJkg+qtGuMCYvJVaMzRJ9CsgSBm+yUFvvAuq4eEZ4vvUpBzCppQqCIBgDVBZBr8XktBx/Hush0SDsqQBm/JQCJHigUiqB0ERBIOuqRmJPiyk67IZmxjQwgjgRSonqjgGmk7I8SAJgD1RrpcadUFtNIMwoW+HNeKrZAvqFMtIAoKIINYN7yoRIMGY+aOAgB0yRNlTFADVAcA45ZVg0m2+6FwJNzKUBpaUAEEi5O5UgCtANf7qiBB3Q+E6ygB0TH2IlKyWog89fReznsxi874HH4jC4hrXYZLW4LWFz3QASYtFQPPtPzq7HDcbxPChw4bHxMIEycjiK79+qDixsM4ONiYTozMcWmNwV9Lg+yn6Q1zMLi3Nx24WG//AFcAtw3uecPK1rwTP/mCpA9DI+YXL+lcRlY33+LlYIaM5homabVqg+kPsTx4bh5uI4Vr3tDmgl2rxh5bSHZzEEQIuvF51yrH5RxTMDiH4b3OYHh2GSWkSRcgWII8l13cZxLiC7iMYkAAS80io+wLjxcXExnB2LiPe4AAFxkwLBBxoiICqiIObiOHfgZRiZZdUQ4GRv2K5+UfTafusX7ty6S7vKPpv/Fi/duQbnMRVwOqAtkuESEcbFpnrF1mQTWkGaoIL2mqpa4v77pM2tuq4VmZ7oJMtE6UgBWA0VgmKR9iXZ1FYk2QkmgsAgAm8VBqo4QZJkdPtWtBQgmkBZhskn7UFMA7WUEULLnWEzZZADr6lWoBMQ4BBDaDbSkqAS0itdlIBIAJihiJVcSSDbpsgsG/WYmqXbMWkXVcTQOMg6JWYGp7oIWmZmm0/JQSQdY+SoEiACCdQFBsKOFzugpEkD8wkyRAJpus3JoAPsW7kZTGsoMkHKKG2gVFDLQKbKkZZkSRoAo4ENJMDSUB1cSkV2qo4QDS2sKl3hBGiGK6dJQAI+KJCxOUCg2rdcsiojMeizQhwAIcQgyQ0ipAJ0W2gB0ugD1BUNT21CgNhJ9ZQaEZGgV8tVWgu+EEE9Flo2pN5pqo0eICsV6IKQAYkE9AhFZIvQZhZUUEkAx0UiIIbM2MIBgiDJ7hWAYaB6rIgtMmtqarREkkzUaUQUACw+EeilWiQPRQxczJ3RpoPF80ABtpP4qisjzIFFp1w426aLIphjLX5SgTmvQg9lDJEGu61Uwa1rMqTDT13CDVCIBFFBINfkskQQTJmlloiAQCD/RAAkNEg3UgxMg61VzGhJE6IInMUEAGUeeqUAMHXRCJEgkBNDAiEFmI10hRo1Ov2KQYArVARNCZhBomb2Q/DDhrKklsjyQXNCgsC8fihrbQKR4jeNaKH0KC+FEqbIg6vC4J4jicPCBgvcGzsvoP8t4f+4f/ACheLyn/APZ8N/EC/S+XcVw+BwmMziG+8zOBDMt6HXTvceaD4/8Ay3h/7h/8oT/LeH/uH/yhe+4guJaIBNBsvteK9p+VY3C8uYeCxH4nDtw2uc7DFAG4YcGkvOrDUZRWwMkh+V/5bw/9w/8AlCf5bw/9w/8AlC/WWc39lsbCa/H4MjD4doaOHOBDsVpxHuytcCYgOAzGrtl8lzvH4TiOZ42Ly7Cdg8K7Lla4AGjQCYBgSZMClUHyf+W8P/cP/lCf5bw/9w/+UL3kQeD/AJbw/wDcP/lCf5bw/wDcP/lC95EHz2L7OMGG4s4h2YCRLV5PKfphrH+li/duX22J8Duy+J5T9MM/usX7tyDkdBBlZJAMUI1QVshMC9xUIA0BkFU1oDRTpSFKFpMQAgsS7xCiXBIpGyfWI10lQG0gxZBQ2gy0r+CprTNWKIDmIMxCyySdj2ugGARv3VBGU5Z7oQZBAVba5CDEwDIEm8LTq1kgJM0AGVaHw3oEGZaIp/0roIoJklRoJ080rvHRBWEai6hbSa7GShuKnW+gS+ZBbDKbxF1gANgEkTfotQQ2axA3ukzJr0CCRMTUdlTaSCGiqYYiZpFLKikgTHVBkgzOaAfkrJs26kyfDJKs5miR1QaBA8qgrIMmbKOMyanSVS0A1I66IMkUkCu/Rcgv8pCzYwwmSFa02HyQHRJAJG6y4iAaze91fiJnSlKKWLooCgsOLiazruow+Gs1JNT+K3EFwp6LLsr3QadEAOJEyJB2soazSTVWoaIgkqAaRQVi1EACNoB3+a1mECkEdUE7RFgVCa/hCBJPiNzbujgGnczQK6kmOoU+rOuvVBJiKqgS2ovSysUFutVK2QAJiJ6AqktAFLdVAZIgKCKghBqhH91IMiNQm80EeRQkAgkk+aCNMB26ovf5KmKk72UsNUBxkzpujaztol4oZQSNUA3B0U03QkECboagj8UFoDaiExNVmbXhVAk6NBHUosk/mUQdbDe7CxGvYYe0yDsV6P6947943+QLy17HKeQ4/M+EfxGHxPCYTGuc0jFeQaAEmgNBmFUHH+veO/eN/kCfr3jv3jf5AuhxOC7h+JxcB5BfhvLCRaQYXvYfsjzHicMO5fk4tzWNfitYcpw8zWuE5oB+MCmsoOh+veO/eN/kCfr3jv3jf5Au7h+x/OX4TsV3ChmA0ua7ELwQCDGh3j1BtVYb7J84fisw8PhmPxHuyMa3GYS4g5TFawQQdoKDq/r3jv3jf5An6947943+QLscT7Lc24ZmK7G4djfdYRxnt96yQwEjNEzFCvDQep+veO/eN/kCfr3jv3jf5AvLVFSg9HE53xz2OacRoBEUaFxco+m/8WL925dfG4fFwI98wsmYnXr26rsco+mH+Fi/duQacdhFIUBAd0iyoAmLqeVdUENTWypqRNig+GGxGhQE1pXVBqYcIk6rLulldjQlBcwfRANgTUzSiV3lQE9ITUwAWoNSSCTQfijTQkVUqOnVKwMoBIQVwpQ1sVa6GAdFDNKhSZ1KAD4YinRO8xaQUDYIACaidKIAkkH57pQmgk7hUfFIifRQSCSPRBRUVMDc6rLZyRAJQEERXurBgDa9UAyRJiZqmunorPWTCyfiA6INaaECqzJIAkg9FawCSJ06pQxN0BoqJMdypqbGbK6mLE3VBgUNkCK0pNFJiJkfiodJ9FSQBEHdAAAFLWlSOpurQ1nzUsIFpQan4bQCoDlmBUqmO4UJA0kmw1QIpBubplbl0gfNHGSDlU+rQDz1QaJIFrIJoBTZQ0EGhSKGZJ3KBUd+iTqP7pQRFkpB6ILSTQQstNJhUOmhoEtapCA45T0FJRuwoFNSeiTLTsgrY1JMISIN/NTSiG1/JAO+iEVrEKTYAQElBSaWispNysyPIK3mqAla6KEo4Em6CglSZ6lJ2KdUEJGoqiE7FEHUXd4LmnF8FguwuHewYbiSQ7CY+8T8QN4HoukiDeLiOxcV+JiHM95LnE6krujnPMg1gHH8SAxnu2gYhgNpT/6t9BsvPRB3/wBb8xyFn6dxOUgAj3hsAAB6NaPIbLmPtDzY4WT9YcT8Yfm94c0iore9e68pEHedzbmDs+bjeIOdhw3eM1bWnbxO9SuiiICIiCkk3JOlV3OU/TD/AAsX7ty6S7nKfph/hYv3bkFmx1TXqnolqoArpC06xlZ0QQQgtyAQkmL2U6geidAgoO8zNEqApPQU6K3N0F7mNk1m80UkmNkG4QDNDsk1pIndDOspFYBQN+i1JtdZzVPVAYrpKAQbRU6pMWMKSe/RWQRYygpaSBUwlqkqTTQppRAsbytN2BWBWOoVdU3oEFdal91ZO1bqE2UJk1FEEioNOpWoq2ukd1L90M9u6C3Na9bKAkAW6laJnSt1m2qCmwEDp0QX06qA02CggTqgs2isUKp6mhF1loGnmrRBLkVjVXaahJuVKxTVBTekdVQabrNxMBAgGTJBgQrBkWU1lOseqC0snf0Uk0qpNB9qCg1tBKT1KkwOqTMILYShqKqC1oQFApoU0KaUuoe6C/JSaQpKEoNC11FNE1QL6pqkrM1QWeyKIg669z2cxOV4TOIdzVzDGV2HhnBLySJN5FDaNZC8NEHJjlrsfEdhiGFxLaRSdqwvp8PiuQ4vuhxYwzgNwmhuGzhyx7DDA/M9sFzjDy2ZExMAkL5REH1o4j2VzA/oToa4UzYviGZ4M+L9n3ZprPZcYxPZnK/G9y7OMN2Xhz7yC/IIMzMZp1XyyIPsuIxfZjH4fiW4GAGjB95iYTiXNe/4BhtNaiQ4HWs7r41EQEREBdzlP0s/wsX7ty6a7nKvpZ/g4v3bkEV2WFUGkCk0QygoIQHeVKqoBJqECJY9UFuKyoVfOENUCTKXoU1kp2QBIiiV7oe1Va9kEjog6qogkaBU7xRXVIQZ2JNbK7UQ9fNUiRqgkeVUNwRKGiV6oE2lDXRKd1ZJogxUp1KqBBJjzTWbK1VQZNehVtZKWRANaIVIRAnSyEypZNUFN7+SKSog1KgP5JU+aAoF0ndJUlBqVJqpMoSgs0UUJgoSgspKySkoLokqSsyg2SoTVZlCUGpCLCIONdnA4PExsL3gdhMZmygvxA2T59wusu1wnHY3CtyMGC9mbNlxcJuIJ/8AkDCDgxsJ+DjYmFiCHscWuGxFCvUPs/zAtZ7nCGM9zQ52HhmXMkNIB6nM22pi9F5eLiOxcV+JiHM95LnE6kr2eG9q+c8Lg+64fjBhsyhhy4TJcAABmMSaNFTsgxh+zXNMV2OMPhi84BIxSw5wyGF9SJFgs4ns7zXDwPev4PEAlwI1GXLP/wDoDvI0XCOc8eMX3jcfK+ZkMaK5Mk2vl/rdd/F9ruc4zcX3/EsxXYlc7sJksNJLaUNBW+yD59ERAWmNc97WsBLnGABqVlbwnuwsVmIww5hDgeoQc2PweJgYLMTEOHDyQA14ce9NFvlX0t38HF+7cuLieJdjhoLWta2wbPQak7D0XLyr6Wf4OL925BgKoqgQqoqgIiqBSEhEQVIREBOyKoCVSiaWQFQmin5ugBDqqUCCUXc4Ll3G8wbxDuC4bF4j9HZ73F923MWMF3EXganRdTXZdjl/G8Ty/jcHjOBxsTA4nBeH4eIx0Oa4WIQdaKoIX0Pt1g4OF7QuxeHwm4LOL4fh+NOEwQ3DdjYLMRzWjRoLjA2hfPQgp+aitFKV6oB6KK0sEQFO6qhugQeigVTVBEiqGyIIkFE1QFFVEAqKqFBO6kBVRAKmiqhQSVCdlSsoLKiKFBUUUlBZSVJUlBqUWZRBEREBERAREQEREBERAXc5V9LP8HF+7cumu5yr6Wf4OL925BlFFUFVCza6qCqrM06og0inRUHcoE3VUlEFVBWRZWUF0TVSQkjVBepKaJO6SgtUEqZlLhBqUlSm6pPRBycRxGLxOJ7zicV+LiZWtzPcSYaAAK6AAAdAuM2U1umkICJPZCZKBqk9VJ80JQXzRSUQEUunogqihRBSimqICiSEJQCoiIIorqogKFWFIQZUW4opCDKLUKQgyQkLRChQZhIWkhBiEWoRBhERAREQEREBERAREQF3OVfSz/Bxfu3LprucprxZ/hYv3bkEFk8vkrZNaoJCqeiRJhAT5q6XolCawEGfVVNVblASysSpA1JQBQlSYokSIPyVAkDsga2TXfuodYVyoKDVCfJIhU07oJqJlXyU021S4kSgTsUmbdoT7EMkT0QCdCk9eyAVjpqhFYKAdFBVB5J0sUAka3SdkunZAomkoJMmyu2soMmkQrfRIBoEqOkIINYUWo2CC/2IIpfQlaHSibIMxOiarW9iFIMwgkbKRRaVitEGIQBag0UhBmKotxopsgyoVvupqgz80hahCEHHCQtxRRBiEhbhSEGYRajuiDgREQEREBERAREQEREBd3lP0w/wsX7ty6S7vKPpp/hYv3bkAVKR6oNjrstVFUE9ApFImkKjxKRMSEFGwS16LQpAvRZIpMIAG4p0S2qpNhPksujr80FFp2Q0iShuIkk+SpFOlkGQCJk1QCJmq0abQUEwD80EJHl0QCJr1VJr8PZSTB6hBowaxZZNIVIBpEFR3wy69AgeYVJEhGyBMT2SsgD4kBzZvRQ0pZUkQSKnolx3qgkW1VtUx6IABR3zUyzv1hBXDLMbSjtQUEE1toUG8iiB4Y+cI2nYoKCteypy1NuiDP1BRBUxWFSIIN+yhEiD2CBorB7qmlJusigp2QDtolLAKyAOgUsJp3QLmwCXB/MIAK+qEf0QQSaAqkdUMzVCQRsQgl5QnXVPSFYodwgz0NE1C04UEoRTVBCIhISka90E0sgkSisGYUNqoJSUjdW5okDfzQZSPVagSgCDCEVWp2QgygzHdFa7Ig6qIiAiIgIiICIiAiIgLu8ppxh/hYv3bl0l3eUfTD/Cxfu3INfV3lSfEZt9qA36Ki2kdQgutlmpor0MK6mJ6HRBP/kEpmBrJ3VtSKoKig7BAAzGkHqoZMkGesI4gk1PaFJlwJM9IQac6CAPMKCYBCtpNCdK3UYJEH1hANSKEgFIM9NkfUAo0ajVBSDcCeu6h8U+I+agAu6AOipjKT0ogtJpUnRQC5ERpVK0JIQgAAE3QQmhg1mZVuYOigrU5u2qpdUyK37oBbIJABKUpqCKIKkmL7q5ZMka7IBgkAnX8/io2S+ZFN9kBnQZq6KCrzIidZQWRUmuxO6NEN22VNSct4lZJltb7oLMi1NyFJltLLUQRWDb8/NKXJ2BQQASZPRUgTETW0o2HONBChikigsgpAoKSkS6XCirSXCYpusggTKBO9R2ToZOy0YIoBIWWiQcogg6oBIBMj0oht/ZQ3+ExOioqCAgVEHKOqGlbwnxReDupE6UFO6BUyaEJJgHpJVrEReqZQKHQUQIqSEIg1JAhUEk2pGhQ0BqAEGbR9iQhLRee5VAoDFUEAmybkmqa9EilB5IBhw6qQZVgAx0QAioEoMihk6qmZsVSDEbJBE/0QZhQCnRaiQkEIMkT1RC4C5RB1EREBERAREQEREBERAXd5QJ4wj/ANrF+7cuku7yj6Yf4WL925Bu5Mg+iyaEiNYKsQ8RJ7oB0oNUEJOYTfutGBepN1PrZQbwlQTPw/YgT9Wh6wkiAKea0aCG3GsrLnZiZg9kA1sewCgFajWxQgh0a2sr5STqUGakn56yth4LocAcu4WcwkwI7VVgF2pBM1QSYgawgBgiaIfguZFb3VBmpJ8+yDUQyYg60WTEgkaUTNSK9KqTmqPlugombmijQdKEC6o1mriNEa+ALhw1QDQAiR13Q10j8EME2HStlHGTXVBRRwm0VJ0QHwmJj8VBQhthMlDUwK+SAJEkDaYC0YoNRdSBF+kKNlpkzBFOiCgARJ6FUihFZ7LEgy6o7arTHOA8U5oQKSTpMmd1CMtGjsrIiuhBAKhcYkGs+iC/W+2Cjj4paDlOhUdpJok2ESB5oLILiD/0oZ21RkzUQ6Jsjj18Rp2QWJEUJhMsCsCygk1r591TBsK6AINaxBAWRQEgAQhMOMmSEkmGzAOm6BQiQVSDBoOyn1om11T6fgggjaltlQLaKSTJAGXqVGmv2oNEUM0KjhWakXoq4SKgwsmxrpogoIy+JIrShvRG1gGRpXVNRFNwgEVGiSCOkIAC25lSBAogtMvSVkCTUyNIWqFxm4VilBRBBHposik9Vp9KGiBs7jVBDU17pJm6C96JqZ0QTL0HmisnQGOyIOiiIgIiICIiAiIgIiIC7vJwTxsC/usX7ty6S73J/p3/ABYv3bkFAyxmFOpog60PdCCXUByilqSjqwZmsyTdAaQRBnsoJ8RsbpmmNN0m8UpogpMBocI6hIGYgOMQgoJg1KAkkwa27IAByiS6TTupUNBginZSZJBLYECLqknPWm6B5DMYFQqZgwK7kLJNzUd1TApNjEboNZfAZME6DVZF61mwsoCKkix2VLqV/wCwgBji4h1R3UNfhdPdHPkGnxAKOteo0QC6HCgm11trjNDOygBgyddlBOUuBuPz+CCkyW31tdCfBN6rJBBmLfJU2sK2ogromTG1KqToQK7Kl3gANt1mZuQNqINEtmNeyGCJoOl/RQGQS2SCIUe+aCSdASg1QEAyIsRoVB4nZnGTGiS2BBrNoUIEkGZ1iqDVM1YM7Kz4iCSBJusu8JDRJMTRUmgNmzWqA6DRo60UIzQ0AeEzVWIIkkTJWbAGkSg0Ia03tTotS4GoIiBssmJIaD0CMJJBfAIv+fNBTO5qgGUDMaG6kOc2u3yRsAAblAu6DBIuFrVsa7LJdFaXhTam0IKYIJoPxVOWBc91kkOIpA7KiMoDTXrugolxFh5IKtOYeqNgEijSd9E0AcSLWQCSdKzqrABpWL7Kk6kGRqsihMCSOmiC3AnegsoJAOWQdlSC6wkd1CTUefmgoIzAnQaqUbLqwLxqlAdW91TMmKlAktvAUIMEtH9EdMVqQkTECvVAcelVWui/2oTDhWiggm0/igkEf9oD5n1VoBJU1qLbIKDTTzCKFuYyLIg6K+o9n8bkP6r93zfhMF2KDjziNxHsxSBguOHBktH+plHwnqvl19V7Pcg4Xj28txsZ04OIcYcT/wCIbh5MolsUJmNIM2og9M8v9iuB5twJHH4/H8Cf0kcTnMUGGfdluUAg5ovQwDai5eI5X7FPPBsHMnt92xuFxOJg4hGd4xCHYjQ5pnOJIq0NABIMrqck9neR835aQ/mI5bxTMXHBxOIxA7MxhwsvgEQT7xxJkjwGNVseyPJpw8B/PgzGdjZfe5cM4bmZmtLhGJIEEuEwSNBdBocH7LYHGuZwjuG4hg4R0HjOIfkOKOKAqWBpn3NaUOklXj+UexIw2v4Dm/FvzNLi3FcGZAQDMZCSQSW5KF0SCAscJ7HcoxP0Z2J7Q4AZxDGkOdkaMMva4gO8Zq3KMwgDxCq5cL2A4fHwmOwecNPvHNa1zsJuRrzhl2R5DzDgWwYBAm9wjB/KvYjB4wtZzDi8dmZ0B+O1oI/0gASGal+I6dAyI1WuA5X7EjGa/H5jinD/AEo4RZi4uYHChwz+FrSDIadRDhcgx8DjhjcbEbgvL8MOIa4iCRoY0WEa+9byT2N/Qg7F5txDeLDW+BuOxzHOhpjNkloJL2yQcuSTcBfJ+0LOCw+d8YzlZB4FuIRhQ8u8PcgT3gLzkQF3eUfTa291i/duXSXd5R9MP8LF+7cg1QCAZgEx/RAa1l0jyQEGKCNTKOcfERFTrqgkOkUFaShh0yZbuFHRlkHuEBzOkxfXVBDpPnKoBuZBNDWEzNmAaHdRoLiBUnc6INAmtBEi6w4GbUvT8FrDItFt9VSDGoNkEjM0EEkDYoPCARO17KNNYAIPVZqXNLkHIQQ2sgEWBtqoB4AA6dZUzRr8JkHbqoSDUudG2qDcREkTf+yOzNMmBRYytbUgz007pQCQ49oQaEPZAb4p20TMIOWfSnT8VholooQRQStOc73gnQaG4QC4FsCaBU3oBBuIosgZKmQTI6yhEip6beaDQNS3aIIQ3ggtE+dFIoImgFRZQEFpNSSgpJy+IQdPRSRWtRSQVJI+qZB0CUgk3JpVBoeGpE1sKKty5gHGQe5WWnM7w9r2Q2tToEGjUEPEN1KlADMnaiNa1wdeflRV86En9pBBQ1vpRVxoAPipYXUNCc16WoqKGlSDEzfogpJEAX0jRZNYp4jdGggktkAecpLQTem1kFEZG7gai6pgR6lSYkGgBqB+fzCjoghprc/2QaLpBmrUlvvIF+qy5vhJrO90c4kE7BAkbXtBSLG2yPmCSLD1WiS6DPcnVAOXXVJhsqRI+rt2VgAXsB3QQ0zEwOi1mFTWnqpR4MECNkJlsT4rHsgCQZbRpVcCWyIA1UEOMfMfYkmSM1EGgCRt9isOLhJgbBZMUc5sTaqRMBszP4IFAflBUJ8cgfJaMxYSB6lQSKkmT6oKJJ/tZSt4gqjQCSbzsoTFZM3hBZBaK3UmdaBLGkSd1YDbGNkEDSbOjzRUBv7RHmiDz1oNcRIaSOyyucYPEDAGKMPE9z+0AYQcWR/7LvRMj/2Xei073jTDs4MTWbIz3mI9rGZ3OcYAFyUGcj/2Xei5WYvEsw/dsfjNw5JygkCSINO1FX4HEsexj8PFa5/wggguqRTzBHkph4XEYjnNw2Yji0FzgATAGpQcWR/7LvRMj/2XeirjiNdDi4HYqZ3ftH1QMj/2XeiZH/su9Ezu/aPqmd37R9UELSLgjuF2+Uz+mGL+6xfu3LqFxNyT3Xc5RTjbT/pYtP8AjcgofYWBsoW0bmAtFFDWsVEKul2U6zFUEAAJyk0F5urEUMg6LBtM/DVXNmHlYUQJlwtlGwVqKglvQaLNcwkyR6QjYk3NJiUFbIvOxiipJDgTTelVJgVPWBVZBpvEWEoNl5DSA4lp/PojRXWdxFFkHxAAT5LMgSGgz1QcjoBIMa3N1ik2BMaGiNBmRUCshXKMoJE1QamgiCVPidQf062WSaz4gAYAVdmDrQDpKCNiJaSDM1WiQSctlmuagqoJy0oJ+KqDYFIBgCoIqpJdAMDWFMwLQQSZ06qNdmcSQDNNkGnCMMDMJrToszXrqDEI4w6JpoYoEInW1UGiTIhxG0K2MOFRuFmIENkzQygLnEbXHRBc1zS9hokloqCKz1UAhtSKpmLiZpJ0QaIH1YJj0UqC4GkCukHsowCjQJJ2QuhpMjtKDRMgxWK6IKZnGs3BWRBNBA+apdLnNItoUGgA7xQBSqgcSCb9D+eiklwEgUMBys1BIB6CtUAgCDFSVqjhIEz8lnNE5o2N1JMgASIQUwWgmQVYFDOlYKw6ND6LcNIMV2lBfqSJI7UCrhD8ov0WDOWQa1qTdatcgxWQEFjK3M6s0rdJIEA0j4tFGuJAmf8A+aLLZOGM0UsIQbMQATBi8KTE6eSoNILmuP2KOoTM5boKSPrCGgdirGUCWjyKy10gihd9tFporW1kC5NJFpiqkZoJmDrFVWuDjDmnyGik0dQ7VQCDIzTF6JPiNKapSYy17qxlIkV6IKR1rpFVMsUFlmMo8JBPTRaaTlNTFh1QKyCBZJuR5q6yXSskkw7dBS131RI7otBwG57NRB5y9TguacZwfCsw8JjThZqFzSZrMeo/MBeWvT5dzZ3BYLMMYOHiZHnEaXaEgD8J7oObiOf8bi+/bitws2Kz3b/CQYiIvpJXns4jiGN4bxOLMFxfhA2BkEx6Bax+NdiY/EYgw8Me+blILQ6BS02NLiNdF2MDnGNhcNg4HusF+HhtIAewGTLjP/2Qdke0/MA5pJwiWmQckH5ev5K4nc646GyzDAcws+CjwXAn5tC2znOB4Wv5bwwww6TlaJLf2ZPTW+qxg88xWYbGPwMHEbhwWS0DKdfWnoEHncXxGJxXEOxcb4yAD5CPwXCvS4/mOHxXDZBwuFhYmYHMxoECKjzMenVeagIiIC7nK/pTv4OL925dNd3lP0wz+6xfu3IMua4tqRAr3UggkEjrTRaBDbVHzWSRc0nUi6DROUBzRLSdJUaSJpUWiigpmgSLCCjScwNKiOiCyXEEtJigUDQ2sku7KRfYmTApZQE5hW03QaJihA7BZOYuLrAbKl3xbxTsoXOca1NvEgTLakTWFScwb4Ra6hOmYxSetVDR0kz+KCyBQWuYMqNnSSdloXn0Ky50iJMDqgSYibnVaYDYEGBpYLDjJMHw9knwSQNkFeZNqD5pcVDqGmwSoBNfOxQEma2+xAa0kEzTUbq5bHMC22y4xJNpC1QAREoNGNqjVIgyJmKDy/PqsjrQqUih/ug04tLJNI6XVzUJnTyKmaozCRYHopcwDAJogsE0LaDVBR0GtFkdbDQqg1oaC0INgy4kGZuQo515MyNVkk3M+qoPhbA11QUmmYDpVVghxDoMaXhZzDNLpi99Uc7NWaWoLoLUVFb1VgAA6zbbyWWiwBgET2VJknNpZBouEzQCphBDhVxg7BQEtIkGBrqFKTrayDYAi4ncISSRaggzVZ3N/sQOg2JBqNEFc4y2KkyFQSQAB3hRpk7mdVcsYgmk/JBSBSs03sk307KUImMzroSHRSL1CCgnLY9UcRBmZFiBqo1wFQASK1CETBFIuEFBDia10Mqn4AZqFHS5sWnQVP5/otmLGDWpQZAEEF16EbVSpbl2rQKCKifOJVaPCNhpqgsFzBEE7wgiQdYtYypJJml9LqyakRI1/PkgM8Mik5rLZbEkQKVkLIOZvWllmAYABJQakkgaHVJDjoWnqmUj4p6AJApEbWsghdJMNBRZodHTrSUQdNexwnJX8Vy1nE4WM0OLoLHCKSQYPSJPQrx16nC8JwGNwuG/F4wYOKAS5paTJk+lI9UHO/kGJ7wtwuK4dwGGMQlxLYEme8R9iY/ITh4+FhN4vBe7EbNJoTJA+X9lp/BcnODmbzBzXZz4Qwnw0j8VwM4XlrXYxfxhe1uGSxobBc7LQev2IOQez+MHNz8Tw2Q4jMMlriT4nZZiNDPoVlvJHNxvd4+OwS3MCwF0DNlLjMQAZnURZcn6HygzHHOH+n+yYDgWg958RCzicLy19f1i/KzCBDXNkzXwj86oOTG9nizExms47h3hg8LocA40pMdfzdcePyDGwDhh+Pgue8luTDJc6QCbRrAHms4fBcrdmDuYObDqEsuIabdy4eSruD5Uc2XjnNIAABbOYxWulaIOVvs1xLsHBccbAa/FGbI4kZREgExe9OnePDe1zHua9pa5pggiCCvewuVcsx8WMHmJLQzMfBWQK36/b0Xi8XhtwuJxGMxBita4gPFndUHCu5yqP0szb3OL925dNdzlX0s/wsX7tyDAJzkxE2CpxHTrBE3qk+KQ6kyP+1CKSKfh5oKCGwRP2wkkvzC07rJ8ThmGU0UBm4FflVBQfFSIt3CplsAtmtVjKCZBFawqSSZzRYoKDAFYFxKjaX0qAo0kknVQEXmoQWfD8kaJNEmRV0nrsoSRSlNUCt6WVlogEGNlPrkvEGahKkyQTTZBmKUW5lsWitqfm6zJ2SZ9JqgSZE6HQquiCZvW6xNIrKsyKCKoNF01IFUkiTBgqGC41WdAg0PiDoAmyE962KgJAt5o61ZKDUyAAdNEExahssTutOtMjsgEDKBWeqAxQV6FQGulEudyUG5Gh0rKhGkkgWUDjTdNSHILUgD1VFxIFaSSlwCaTqpJLoimkhBQ42M1QbaJJMzE3qVAJiRGyDTc0n1m6skkk/0WZgSKBWSRQgEGEFIgutNaFUQHAmREVAlDBnJruFmSQdqTKDUtMAgzoVqSD4TeQKLBgsmg0lWfBao13QUtpS0/EEEDWTbRNAXEA7aqijTlHnsgGa5c3QlNssEjXZZrJoWkChmxVDgHmYrpN0GyY+G8WClGgZRTcqSYq6SaD+qkmCHOt6ILrSgvutGxGYh23RZE1IN7zSQjSbERAog1dxgGbURsloAI60UNIIMhabQwBMaWQT4rBqrXGJv0UY2ZBJmKiEaQXdkGqzQxTtCOAdAEUN0ub3FNkpTLAPVBczRRwr2RYOGHmXuM2oNEQdJERAREQEREBERAREQF3OVfSzIn/Rxaf8bl012+VmOKcR+5xfu3IMyAQXiAaw1ZLpAzQT3Um51yhCTkd0iEGnQQKXpPVQUOgjWIRzfCwmskoJeXSTRpPyQV4BsZE6LIEitSd0d4cNpFMwr6qtEz0EhAiCb5QsmQARrSAlrEisLIJI7IKTInTVQGxmqsw2df+1CInoUFJqQLdUEmklZt6IKmqBdL0/FUgBvmsoNaT5dlD5hQqING8TRUHoFlRBVQYvVQGEQWaaJOkrKpugoooVWiTCiCi9fkqPOftWVd0FJk01VEZqzBWQPEB1S5EoKTWiod1RokOQfF5BBombCgQGbCIF1kUaTsjXGnRBuYPirTdQGCQPtU/aOyl3AG0wg5SQNSWxFkdJ3MGxRrQcQA7lYA8M1kWQacTlJuDYzYbJ4gKaE2Vb8JoLphjM1xJMgSgD4q/EdTZacYME5Y01VxvC2RvFVxkwBGp/og5M2hoTYlRraAzYXKy4ZCYrlNJ8lb4rQdSZQUH4QKk3qgAaYFiSAPz5Lja8kVg6V0XJTIxxAJNSg0fCZERrGykS0d0Y4uGaYIMCFCIc2Cg5JAAIFRcwsE5a6R8lXkgnp/dMMSTOjSUFaDAmYHoFXNLq0EihIWXtiamn5/BUXDTUINMcC2ulKD+yLh989tBl8wEQf/2Q==" + }, + { + "timing": 4539, + "timestamp": 31367196195, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 5187, + "timestamp": 31367844570, + "data": "data:image/jpeg;base64,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" + } + ] + } + }, + "final-screenshot": { + "id": "final-screenshot", + "title": "Final Screenshot", + "description": "The last screenshot captured of the pageload.", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "screenshot", + "timing": 5188, + "timestamp": 31367845236, + "data": "data:image/jpeg;base64,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" + } + }, + "total-blocking-time": { + "id": "total-blocking-time", + "title": "Total Blocking Time", + "description": "Sum of all time periods between FCP and Time to Interactive, when task length exceeded 50ms, expressed in milliseconds. [Learn more about the Total Blocking Time metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-total-blocking-time/).", + "score": 0, + "scoreDisplayMode": "numeric", + "numericValue": 2630, + "numericUnit": "millisecond", + "displayValue": "2,630 ms", + "scoringOptions": { + "p10": 150, + "median": 350 + } + }, + "max-potential-fid": { + "id": "max-potential-fid", + "title": "Max Potential First Input Delay", + "description": "The maximum potential First Input Delay that your users could experience is the duration of the longest task. [Learn more about the Maximum Potential First Input Delay metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-max-potential-fid/).", + "score": 0, + "scoreDisplayMode": "numeric", + "numericValue": 1196, + "numericUnit": "millisecond", + "displayValue": "1,200 ms" + }, + "cumulative-layout-shift": { + "id": "cumulative-layout-shift", + "title": "Cumulative Layout Shift", + "description": "Cumulative Layout Shift measures the movement of visible elements within the viewport. [Learn more about the Cumulative Layout Shift metric](https://web.dev/articles/cls).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 0, + "numericUnit": "unitless", + "displayValue": "0", + "scoringOptions": { + "p10": 0.1, + "median": 0.25 + }, + "details": { + "type": "debugdata", + "items": [ + { + "cumulativeLayoutShiftMainFrame": 0, + "newEngineResult": { + "cumulativeLayoutShift": 0, + "cumulativeLayoutShiftMainFrame": 0 + }, + "newEngineResultDiffered": false + } + ] + } + }, + "errors-in-console": { + "id": "errors-in-console", + "title": "Browser errors were logged to the console", + "description": "Errors logged to the console indicate unresolved problems. They can come from network request failures and other browser concerns. [Learn more about this errors in console diagnostic audit](https://developer.chrome.com/docs/lighthouse/best-practices/errors-in-console/)", + "score": 0, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "sourceLocation", + "valueType": "source-location", + "label": "Source" + }, + { + "key": "description", + "valueType": "code", + "label": "Description" + } + ], + "items": [ + { + "source": "console.error", + "description": "[PostHog.js] PostHog was initialized without a token. This likely indicates a misconfiguration. Please check the first argument passed to posthog.init()", + "sourceLocation": { + "type": "source-location", + "url": "webpack-internal:///../../node_modules/next/dist/client/components/react-dev-overlay/internal/helpers/hydration-error-info.js", + "urlProvider": "network", + "line": 70, + "column": 13 + } + }, + { + "source": "network", + "description": "Failed to load resource: net::ERR_CONNECTION_REFUSED", + "sourceLocation": { + "type": "source-location", + "url": "http://127.0.0.1:8547/", + "urlProvider": "network", + "line": 0, + "column": 0 + } + }, + { + "source": "network", + "description": "Failed to load resource: net::ERR_CONNECTION_REFUSED", + "sourceLocation": { + "type": "source-location", + "url": "http://127.0.0.1:8547/", + "urlProvider": "network", + "line": 0, + "column": 0 + } + }, + { + "source": "network", + "description": "Failed to load resource: net::ERR_CONNECTION_REFUSED", + "sourceLocation": { + "type": "source-location", + "url": "http://127.0.0.1:8547/", + "urlProvider": "network", + "line": 0, + "column": 0 + } + }, + { + "source": "network", + "description": "Failed to load resource: net::ERR_CONNECTION_REFUSED", + "sourceLocation": { + "type": "source-location", + "url": "http://127.0.0.1:8547/", + "urlProvider": "network", + "line": 0, + "column": 0 + } + }, + { + "source": "console.error", + "description": "OVERMIND DEVTOOLS: Not able to connect. You are trying to connect to \"localhost:3031\", but there was no devtool there. Try the following:\n \n - Make sure you are running the latest version of the devtools, using \"npx overmind-devtools@latest\" or install latest extension for VSCode\n - Close the current tab and open a new one\n - Make sure the correct port is configured in the devtools\n ", + "sourceLocation": { + "type": "source-location", + "url": "webpack-internal:///../../node_modules/next/dist/client/components/react-dev-overlay/internal/helpers/hydration-error-info.js", + "urlProvider": "network", + "line": 70, + "column": 13 + } + }, + { + "source": "network", + "description": "WebSocket connection to 'ws://localhost:3031/?name=Bridge%20to%20Arbitrum%20One' failed: Error in connection establishment: net::ERR_CONNECTION_REFUSED", + "sourceLocation": { + "type": "source-location", + "url": "webpack-internal:///../../node_modules/overmind/es/Devtools.js", + "urlProvider": "network", + "line": 20, + "column": 22 + } + } + ] + } + }, + "server-response-time": { + "id": "server-response-time", + "title": "Initial server response time was short", + "description": "Keep the server response time for the main document short because all other requests depend on it. [Learn more about the Time to First Byte metric](https://developer.chrome.com/docs/lighthouse/performance/time-to-first-byte/).", + "score": 1, + "scoreDisplayMode": "metricSavings", + "numericValue": 24.311, + "numericUnit": "millisecond", + "displayValue": "Root document took 20 ms", + "metricSavings": { + "FCP": 0, + "LCP": 0 + }, + "details": { + "type": "opportunity", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "responseTime", + "valueType": "timespanMs", + "label": "Time Spent" + } + ], + "items": [ + { + "url": "http://localhost:3000/?sourceChain=ethereum&destinationChain=arbitrum-one&tab=bridge&txHistory=0", + "responseTime": 24.311 + } + ], + "overallSavingsMs": 0 + }, + "guidanceLevel": 1 + }, + "interactive": { + "id": "interactive", + "title": "Time to Interactive", + "description": "Time to Interactive is the amount of time it takes for the page to become fully interactive. [Learn more about the Time to Interactive metric](https://developer.chrome.com/docs/lighthouse/performance/interactive/).", + "score": 0, + "scoreDisplayMode": "numeric", + "numericValue": 15824.922262500015, + "numericUnit": "millisecond", + "displayValue": "15.8 s" + }, + "user-timings": { + "id": "user-timings", + "title": "User Timing marks and measures", + "description": "Consider instrumenting your app with the User Timing API to measure your app's real-world performance during key user experiences. [Learn more about User Timing marks](https://developer.chrome.com/docs/lighthouse/performance/user-timings/).", + "score": 1, + "scoreDisplayMode": "informative", + "displayValue": "4 user timings", + "details": { + "type": "table", + "headings": [ + { + "key": "name", + "valueType": "text", + "label": "Name" + }, + { + "key": "timingType", + "valueType": "text", + "label": "Type" + }, + { + "key": "startTime", + "valueType": "ms", + "granularity": 0.01, + "label": "Start Time" + }, + { + "key": "duration", + "valueType": "ms", + "granularity": 0.01, + "label": "Duration" + } + ], + "items": [ + { + "name": "Next.js-before-hydration", + "startTime": 0, + "duration": 1768.372, + "timingType": "Measure" + }, + { + "name": "Next.js-hydration", + "startTime": 1768.372, + "duration": 32.067, + "timingType": "Measure" + }, + { + "name": "beforeRender", + "startTime": 1768.372, + "timingType": "Mark" + }, + { + "name": "afterHydrate", + "startTime": 1800.439, + "timingType": "Mark" + } + ] + }, + "guidanceLevel": 2 + }, + "critical-request-chains": { + "id": "critical-request-chains", + "title": "Avoid chaining critical requests", + "description": "The Critical Request Chains below show you what resources are loaded with a high priority. Consider reducing the length of chains, reducing the download size of resources, or deferring the download of unnecessary resources to improve page load. [Learn how to avoid chaining critical requests](https://developer.chrome.com/docs/lighthouse/performance/critical-request-chains/).", + "score": 1, + "scoreDisplayMode": "informative", + "displayValue": "1 chain found", + "details": { + "type": "criticalrequestchain", + "chains": { + "D7DAA8A36A4A8B8F6DA92B5D47DDD0D3": { + "request": { + "url": "http://localhost:3000/?sourceChain=ethereum&destinationChain=arbitrum-one&tab=bridge&txHistory=0", + "startTime": 31362.659238, + "endTime": 31362.684541, + "responseReceivedTime": 31362.683994000003, + "transferSize": 1685 + }, + "children": { + "27474.11": { + "request": { + "url": "http://localhost:3000/_next/static/chunks/react-refresh.js", + "startTime": 31362.690642, + "endTime": 31362.697673, + "responseReceivedTime": 31362.696745999998, + "transferSize": 25433 + } + } + } + } + }, + "longestChain": { + "duration": 38.434999998658895, + "length": 2, + "transferSize": 25433 + } + }, + "guidanceLevel": 1 + }, + "redirects": { + "id": "redirects", + "title": "Avoid multiple page redirects", + "description": "Redirects introduce additional delays before the page can be loaded. [Learn how to avoid page redirects](https://developer.chrome.com/docs/lighthouse/performance/redirects/).", + "score": 1, + "scoreDisplayMode": "metricSavings", + "numericValue": 0, + "numericUnit": "millisecond", + "displayValue": "", + "metricSavings": { + "LCP": 0, + "FCP": 0 + }, + "details": { + "type": "opportunity", + "headings": [], + "items": [], + "overallSavingsMs": 0 + }, + "guidanceLevel": 2 + }, + "image-aspect-ratio": { + "id": "image-aspect-ratio", + "title": "Displays images with correct aspect ratio", + "description": "Image display dimensions should match natural aspect ratio. [Learn more about image aspect ratio](https://developer.chrome.com/docs/lighthouse/best-practices/image-aspect-ratio/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "image-size-responsive": { + "id": "image-size-responsive", + "title": "Serves images with appropriate resolution", + "description": "Image natural dimensions should be proportional to the display size and the pixel ratio to maximize image clarity. [Learn how to provide responsive images](https://web.dev/articles/serve-responsive-images).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "deprecations": { + "id": "deprecations", + "title": "Avoids deprecated APIs", + "description": "Deprecated APIs will eventually be removed from the browser. [Learn more about deprecated APIs](https://developer.chrome.com/docs/lighthouse/best-practices/deprecations/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "third-party-cookies": { + "id": "third-party-cookies", + "title": "Avoids third-party cookies", + "description": "Third-party cookies may be blocked in some contexts. [Learn more about preparing for third-party cookie restrictions](https://privacysandbox.google.com/cookies/prepare/overview).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "mainthread-work-breakdown": { + "id": "mainthread-work-breakdown", + "title": "Minimize main-thread work", + "description": "Consider reducing the time spent parsing, compiling and executing JS. You may find delivering smaller JS payloads helps with this. [Learn how to minimize main-thread work](https://developer.chrome.com/docs/lighthouse/performance/mainthread-work-breakdown/)", + "score": 0, + "scoreDisplayMode": "metricSavings", + "numericValue": 4661.641000000063, + "numericUnit": "millisecond", + "displayValue": "4.7 s", + "metricSavings": { + "TBT": 2650 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "groupLabel", + "valueType": "text", + "label": "Category" + }, + { + "key": "duration", + "valueType": "ms", + "granularity": 1, + "label": "Time Spent" + } + ], + "items": [ + { + "group": "scriptParseCompile", + "groupLabel": "Script Parsing & Compilation", + "duration": 3230.0540000001097 + }, + { + "group": "scriptEvaluation", + "groupLabel": "Script Evaluation", + "duration": 1194.2339999999524 + }, + { + "group": "other", + "groupLabel": "Other", + "duration": 161.93500000000057 + }, + { + "group": "garbageCollection", + "groupLabel": "Garbage Collection", + "duration": 42.045000000000016 + }, + { + "group": "styleLayout", + "groupLabel": "Style & Layout", + "duration": 27.511000000000013 + }, + { + "group": "paintCompositeRender", + "groupLabel": "Rendering", + "duration": 2.960999999999995 + }, + { + "group": "parseHTML", + "groupLabel": "Parse HTML & CSS", + "duration": 2.9009999999999994 + } + ], + "sortedBy": ["duration"] + }, + "guidanceLevel": 1 + }, + "bootup-time": { + "id": "bootup-time", + "title": "Reduce JavaScript execution time", + "description": "Consider reducing the time spent parsing, compiling, and executing JS. You may find delivering smaller JS payloads helps with this. [Learn how to reduce Javascript execution time](https://developer.chrome.com/docs/lighthouse/performance/bootup-time/).", + "score": 0, + "scoreDisplayMode": "metricSavings", + "numericValue": 4345.536000000076, + "numericUnit": "millisecond", + "displayValue": "4.3 s", + "metricSavings": { + "TBT": 2650 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "total", + "granularity": 1, + "valueType": "ms", + "label": "Total CPU Time" + }, + { + "key": "scripting", + "granularity": 1, + "valueType": "ms", + "label": "Script Evaluation" + }, + { + "key": "scriptParseCompile", + "granularity": 1, + "valueType": "ms", + "label": "Script Parse" + } + ], + "items": [ + { + "url": "http://localhost:3000/_next/static/chunks/src_components_App_App_tsx.js", + "total": 2392.5660000000803, + "scripting": 181.6330000000002, + "scriptParseCompile": 2188.1670000000795 + }, + { + "url": "http://localhost:3000/_next/static/chunks/pages/_app.js", + "total": 1169.038999999994, + "scripting": 344.98599999999425, + "scriptParseCompile": 818.1769999999999 + }, + { + "url": "http://localhost:3000/_next/static/chunks/main.js", + "total": 341.58799999999957, + "scripting": 221.23599999999956, + "scriptParseCompile": 116.766 + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_ethereum-provider_dist_index_es_js.js", + "total": 145.26000000000204, + "scripting": 99.19300000000203, + "scriptParseCompile": 37.504 + }, + { + "url": "Unattributable", + "total": 140.86500000000157, + "scripting": 9.475999999999994, + "scriptParseCompile": 0 + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_offchainlabs_cobalt_dist_cobalt_es_js.js", + "total": 82.45600000000012, + "scripting": 67.12700000000011, + "scriptParseCompile": 11.775000000000002 + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_modal-ui_dist_index_js.js", + "total": 75.68499999999992, + "scripting": 50.400999999999904, + "scriptParseCompile": 22.612000000000002 + }, + { + "url": "webpack-internal:///../../node_modules/scheduler/cjs/scheduler.development.js", + "total": 70.4140000000001, + "scripting": 69.2150000000001, + "scriptParseCompile": 0 + }, + { + "url": "webpack-internal:///../../node_modules/idb-keyval/dist/index.js", + "total": 60.43000000000005, + "scripting": 55.07600000000005, + "scriptParseCompile": 0 + }, + { + "url": "http://localhost:3000/_next/static/chunks/pages/index.js", + "total": 52.19200000000005, + "scripting": 37.15200000000005, + "scriptParseCompile": 15.04 + } + ], + "summary": { + "wastedMs": 4345.536000000076 + }, + "sortedBy": ["total"] + }, + "guidanceLevel": 1 + }, + "uses-rel-preconnect": { + "id": "uses-rel-preconnect", + "title": "Preconnect to required origins", + "description": "Consider adding `preconnect` or `dns-prefetch` resource hints to establish early connections to important third-party origins. [Learn how to preconnect to required origins](https://developer.chrome.com/docs/lighthouse/performance/uses-rel-preconnect/).", + "score": 0, + "scoreDisplayMode": "metricSavings", + "numericValue": 118.932, + "numericUnit": "millisecond", + "displayValue": "Est savings of 120 ms", + "warnings": [], + "metricSavings": { + "LCP": 100, + "FCP": 100 + }, + "details": { + "type": "opportunity", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "wastedMs", + "valueType": "timespanMs", + "label": "Est Savings" + } + ], + "items": [ + { + "url": "https://fonts.googleapis.com", + "wastedMs": 118.932 + } + ], + "overallSavingsMs": 118.932, + "sortedBy": ["wastedMs"] + }, + "guidanceLevel": 3 + }, + "font-display": { + "id": "font-display", + "title": "Ensure text remains visible during webfont load", + "description": "Leverage the `font-display` CSS feature to ensure text is user-visible while webfonts are loading. [Learn more about `font-display`](https://developer.chrome.com/docs/lighthouse/performance/font-display/).", + "score": 0.5, + "scoreDisplayMode": "metricSavings", + "warnings": [], + "details": { + "type": "table", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "wastedMs", + "valueType": "ms", + "label": "Est Savings" + } + ], + "items": [ + { + "url": "https://fonts.gstatic.com/s/roboto/v47/KFO7CnqEu92Fr1ME7kSn66aGLdTylUAMa3yUBHMdazQ.woff2", + "wastedMs": 21.74099999666214 + } + ] + }, + "guidanceLevel": 3 + }, + "diagnostics": { + "id": "diagnostics", + "title": "Diagnostics", + "description": "Collection of useful page vitals.", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "debugdata", + "items": [ + { + "numRequests": 64, + "numScripts": 23, + "numStylesheets": 1, + "numFonts": 4, + "numTasks": 3336, + "numTasksOver10ms": 14, + "numTasksOver25ms": 9, + "numTasksOver50ms": 7, + "numTasksOver100ms": 4, + "numTasksOver500ms": 2, + "rtt": 0, + "throughput": 120020378.17802115, + "maxRtt": 27.57, + "maxServerLatency": 30.154, + "totalByteWeight": 17480764, + "totalTaskTime": 4661.641000000021, + "mainDocumentTransferSize": 1685 + } + ] + } + }, + "network-requests": { + "id": "network-requests", + "title": "Network Requests", + "description": "Lists the network requests that were made during page load.", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "protocol", + "valueType": "text", + "label": "Protocol" + }, + { + "key": "networkRequestTime", + "valueType": "ms", + "granularity": 1, + "label": "Network Request Time" + }, + { + "key": "networkEndTime", + "valueType": "ms", + "granularity": 1, + "label": "Network End Time" + }, + { + "key": "transferSize", + "valueType": "bytes", + "displayUnit": "kb", + "granularity": 1, + "label": "Transfer Size" + }, + { + "key": "resourceSize", + "valueType": "bytes", + "displayUnit": "kb", + "granularity": 1, + "label": "Resource Size" + }, + { + "key": "statusCode", + "valueType": "text", + "label": "Status Code" + }, + { + "key": "mimeType", + "valueType": "text", + "label": "MIME Type" + }, + { + "key": "resourceType", + "valueType": "text", + "label": "Resource Type" + } + ], + "items": [ + { + "url": "http://localhost:3000/?sourceChain=ethereum&destinationChain=arbitrum-one&tab=bridge&txHistory=0", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 0, + "networkRequestTime": 0.6770000010728836, + "networkEndTime": 25.979999996721745, + "finished": true, + "transferSize": 1685, + "resourceSize": 4734, + "statusCode": 200, + "mimeType": "text/html", + "resourceType": "Document", + "priority": "VeryHigh", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/media/e1d74c7d0918b0fb-s.p.woff2", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 30.281999997794628, + "networkRequestTime": 30.83500000089407, + "networkEndTime": 39.99100000038743, + "finished": true, + "transferSize": 72022, + "resourceSize": 71721, + "statusCode": 200, + "mimeType": "font/woff2", + "resourceType": "Font", + "priority": "High", + "isLinkPreload": true, + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/media/47bad734875a3c19-s.p.woff2", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 30.534000001847744, + "networkRequestTime": 31.096999999135733, + "networkEndTime": 40.40299999713898, + "finished": true, + "transferSize": 73529, + "resourceSize": 73228, + "statusCode": 200, + "mimeType": "font/woff2", + "resourceType": "Font", + "priority": "High", + "isLinkPreload": true, + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/media/a0dda0300042e3c7-s.p.woff2", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 30.682000000029802, + "networkRequestTime": 31.3260000012815, + "networkEndTime": 40.19200000166893, + "finished": true, + "transferSize": 74635, + "resourceSize": 74334, + "statusCode": 200, + "mimeType": "font/woff2", + "resourceType": "Font", + "priority": "High", + "isLinkPreload": true, + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/webpack.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 30.822999998927116, + "networkRequestTime": 36.493000000715256, + "networkEndTime": 48.94700000062585, + "finished": true, + "transferSize": 10384, + "resourceSize": 53011, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/main.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 30.943999998271465, + "networkRequestTime": 36.82899999991059, + "networkEndTime": 158.5190000012517, + "finished": true, + "transferSize": 1177149, + "resourceSize": 5287954, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/pages/_app.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 31.07599999755621, + "networkRequestTime": 39.418000001460314, + "networkEndTime": 383.3449999988079, + "finished": true, + "transferSize": 3979857, + "resourceSize": 18915423, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/pages/index.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 31.195000000298023, + "networkRequestTime": 40.53700000047684, + "networkEndTime": 71.51000000163913, + "finished": true, + "transferSize": 196454, + "resourceSize": 895933, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/development/_buildManifest.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 31.313999999314547, + "networkRequestTime": 40.64799999818206, + "networkEndTime": 49.53000000119209, + "finished": true, + "transferSize": 633, + "resourceSize": 296, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/development/_ssgManifest.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 31.46900000050664, + "networkRequestTime": 40.76400000229478, + "networkEndTime": 50.05199999734759, + "finished": true, + "transferSize": 411, + "resourceSize": 76, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/react-refresh.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 31.605000000447035, + "networkRequestTime": 32.08100000023842, + "networkEndTime": 39.11199999973178, + "finished": true, + "transferSize": 25433, + "resourceSize": 79107, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;600;700", + "sessionTargetType": "page", + "protocol": "h2", + "rendererStartTime": 983.8819999992847, + "networkRequestTime": 984.3619999997318, + "networkEndTime": 1132.8929999992251, + "finished": true, + "transferSize": 2318, + "resourceSize": 27200, + "statusCode": 200, + "mimeType": "text/css", + "resourceType": "Stylesheet", + "priority": "VeryHigh", + "experimentalFromMainFrame": true, + "entity": "Google Fonts" + }, + { + "url": "http://localhost:3000/_next/static/development/_devMiddlewareManifest.json", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 1744.6009999997914, + "networkRequestTime": 1745.2359999977052, + "networkEndTime": 1747.2919999994338, + "finished": true, + "transferSize": 213, + "resourceSize": 2, + "statusCode": 200, + "mimeType": "application/json", + "resourceType": "Fetch", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/logo.png", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 1761.6409999988973, + "networkRequestTime": 1762.0570000000298, + "networkEndTime": 1764.5969999991357, + "finished": true, + "transferSize": 22781, + "resourceSize": 22500, + "statusCode": 200, + "mimeType": "image/png", + "resourceType": "Other", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Feclipse_bottom.4304bd37.png&w=1920&q=75", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 1772.6860000006855, + "networkRequestTime": 1773.0720000006258, + "networkEndTime": 1779.062000002712, + "finished": true, + "transferSize": 477810, + "resourceSize": 477384, + "statusCode": 200, + "mimeType": "image/webp", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_offchainlabs_cobalt_dist_cobalt_es_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 1793.5509999990463, + "networkRequestTime": 1794.4749999977648, + "networkEndTime": 1809.2509999983013, + "finished": true, + "transferSize": 147417, + "resourceSize": 576083, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/api/status", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 1812.562999997288, + "networkRequestTime": 1813.2269999980927, + "networkEndTime": 1925.8379999995232, + "finished": true, + "transferSize": 1070, + "resourceSize": 3206, + "statusCode": 200, + "mimeType": "application/json", + "resourceType": "Fetch", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/api/status", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 1817.8459999971092, + "networkRequestTime": 1818.5679999999702, + "networkEndTime": 1957.3759999983013, + "finished": true, + "transferSize": 1072, + "resourceSize": 3206, + "statusCode": 200, + "mimeType": "application/json", + "resourceType": "Fetch", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6I…", + "sessionTargetType": "page", + "protocol": "data", + "rendererStartTime": 1912.9109999984503, + "networkRequestTime": 1912.9109999984503, + "networkEndTime": 1913.1499999985099, + "finished": true, + "transferSize": 0, + "resourceSize": 6129, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true + }, + { + "url": "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6I…", + "sessionTargetType": "page", + "protocol": "data", + "rendererStartTime": 1913.7819999977946, + "networkRequestTime": 1913.7819999977946, + "networkEndTime": 1913.910000000149, + "finished": true, + "transferSize": 0, + "resourceSize": 2056, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true + }, + { + "url": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ib…", + "sessionTargetType": "page", + "protocol": "data", + "rendererStartTime": 1914.3499999977648, + "networkRequestTime": 1914.3499999977648, + "networkEndTime": 1914.4659999981523, + "finished": true, + "transferSize": 0, + "resourceSize": 1720, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true + }, + { + "url": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ib…", + "sessionTargetType": "page", + "protocol": "data", + "rendererStartTime": 1915.2939999997616, + "networkRequestTime": 1915.2939999997616, + "networkEndTime": 1915.3699999973178, + "finished": true, + "transferSize": 0, + "resourceSize": 1611, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true + }, + { + "url": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjUiIGhlaWdodD0iMjUiIHZpZXdCb3g9IjAgMCAyNSAyNSIgZmlsbD0ib…", + "sessionTargetType": "page", + "protocol": "data", + "rendererStartTime": 1916.1579999998212, + "networkRequestTime": 1916.1579999998212, + "networkEndTime": 1916.2780000008643, + "finished": true, + "transferSize": 0, + "resourceSize": 2112, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true + }, + { + "url": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ib…", + "sessionTargetType": "page", + "protocol": "data", + "rendererStartTime": 1917.0289999991655, + "networkRequestTime": 1917.0289999991655, + "networkEndTime": 1917.1369999982417, + "finished": true, + "transferSize": 0, + "resourceSize": 1166, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true + }, + { + "url": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjUiIGhlaWdodD0iMjUiIHZpZXdCb3g9IjAgMCAyNSAyNSIgZmlsbD0ib…", + "sessionTargetType": "page", + "protocol": "data", + "rendererStartTime": 1917.8579999990761, + "networkRequestTime": 1917.8579999990761, + "networkEndTime": 1917.9680000022054, + "finished": true, + "transferSize": 0, + "resourceSize": 1790, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true + }, + { + "url": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ib…", + "sessionTargetType": "page", + "protocol": "data", + "rendererStartTime": 1918.7769999988377, + "networkRequestTime": 1918.7769999988377, + "networkEndTime": 1918.9079999998212, + "finished": true, + "transferSize": 0, + "resourceSize": 3274, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true + }, + { + "url": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ib…", + "sessionTargetType": "page", + "protocol": "data", + "rendererStartTime": 1919.582999996841, + "networkRequestTime": 1919.582999996841, + "networkEndTime": 1919.6530000008643, + "finished": true, + "transferSize": 0, + "resourceSize": 1046, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true + }, + { + "url": "https://fonts.gstatic.com/s/roboto/v47/KFO7CnqEu92Fr1ME7kSn66aGLdTylUAMa3yUBHMdazQ.woff2", + "sessionTargetType": "page", + "protocol": "h3", + "rendererStartTime": 1930.684999998659, + "networkRequestTime": 1935.3220000006258, + "networkEndTime": 1957.062999997288, + "finished": true, + "transferSize": 34700, + "resourceSize": 34668, + "statusCode": 200, + "mimeType": "font/woff2", + "resourceType": "Font", + "priority": "VeryHigh", + "experimentalFromMainFrame": true, + "entity": "Google Fonts" + }, + { + "url": "http://127.0.0.1:8547/", + "sessionTargetType": "page", + "protocol": "", + "rendererStartTime": 1942.6429999992251, + "networkRequestTime": 1942.6429999992251, + "networkEndTime": 1946.6990000009537, + "finished": true, + "transferSize": 0, + "resourceSize": 0, + "statusCode": -1, + "mimeType": "", + "resourceType": "Fetch", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:8547/", + "sessionTargetType": "page", + "protocol": "", + "rendererStartTime": 1945.2060000002384, + "networkRequestTime": 1945.2060000002384, + "networkEndTime": 1945.3269999995828, + "finished": true, + "transferSize": 0, + "resourceSize": 0, + "statusCode": -1, + "mimeType": "", + "resourceType": "Preflight", + "priority": "High", + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:8547/", + "sessionTargetType": "page", + "protocol": "", + "rendererStartTime": 1947.9059999994934, + "networkRequestTime": 1947.9059999994934, + "networkEndTime": 1950.422999996692, + "finished": true, + "transferSize": 0, + "resourceSize": 0, + "statusCode": -1, + "mimeType": "", + "resourceType": "Fetch", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:8547/", + "sessionTargetType": "page", + "protocol": "", + "rendererStartTime": 1948.6519999988377, + "networkRequestTime": 1948.6519999988377, + "networkEndTime": 1949.7069999985397, + "finished": true, + "transferSize": 0, + "resourceSize": 0, + "statusCode": -1, + "mimeType": "", + "resourceType": "Preflight", + "priority": "High", + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:8547/", + "sessionTargetType": "page", + "protocol": "", + "rendererStartTime": 1954.5719999969006, + "networkRequestTime": 1954.5719999969006, + "networkEndTime": 1957.1109999977052, + "finished": true, + "transferSize": 0, + "resourceSize": 0, + "statusCode": -1, + "mimeType": "", + "resourceType": "Fetch", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:8547/", + "sessionTargetType": "page", + "protocol": "", + "rendererStartTime": 1955.7359999977052, + "networkRequestTime": 1955.7359999977052, + "networkEndTime": 1957.030000001192, + "finished": true, + "transferSize": 0, + "resourceSize": 0, + "statusCode": -1, + "mimeType": "", + "resourceType": "Preflight", + "priority": "High", + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:8547/", + "sessionTargetType": "page", + "protocol": "", + "rendererStartTime": 1957.8319999985397, + "networkRequestTime": 1957.8319999985397, + "networkEndTime": 1960.0109999999404, + "finished": true, + "transferSize": 0, + "resourceSize": 0, + "statusCode": -1, + "mimeType": "", + "resourceType": "Fetch", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:8547/", + "sessionTargetType": "page", + "protocol": "", + "rendererStartTime": 1959.605000000447, + "networkRequestTime": 1959.605000000447, + "networkEndTime": 1959.9219999983907, + "finished": true, + "transferSize": 0, + "resourceSize": 0, + "statusCode": -1, + "mimeType": "", + "resourceType": "Preflight", + "priority": "High", + "entity": "127.0.0.1" + }, + { + "url": "http://localhost:3000/_next/static/chunks/src_components_App_App_tsx.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 1960.4829999990761, + "networkRequestTime": 1960.925000000745, + "networkEndTime": 2658.162999998778, + "finished": true, + "transferSize": 9942484, + "resourceSize": 43420453, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_ethereum-provider_dist_index_es_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 4986.796000000089, + "networkRequestTime": 4987.328999999911, + "networkEndTime": 5038.241999998689, + "finished": true, + "transferSize": 639168, + "resourceSize": 2332526, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_safeWallet-VUYZPLY4_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5140.322000000626, + "networkRequestTime": 5140.866000000387, + "networkEndTime": 5144.382999997586, + "finished": true, + "transferSize": 3266, + "resourceSize": 5674, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_rainbowWallet-2SR6TVBF_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5140.985999997705, + "networkRequestTime": 5141.56799999997, + "networkEndTime": 5145.585999999195, + "finished": true, + "transferSize": 4076, + "resourceSize": 11347, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_coinbaseWallet-WWX6LF36_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5141.629999998957, + "networkRequestTime": 5142.051999997348, + "networkEndTime": 5146.741999998689, + "finished": true, + "transferSize": 2301, + "resourceSize": 3751, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_metaMaskWallet-YFHEHW7V_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5142.186999998987, + "networkRequestTime": 5142.592000000179, + "networkEndTime": 5148.065000001341, + "finished": true, + "transferSize": 4980, + "resourceSize": 18353, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_walletConnectWallet-FNSU4KNU_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5142.726999998093, + "networkRequestTime": 5143.187000002712, + "networkEndTime": 5148.48900000006, + "finished": true, + "transferSize": 3315, + "resourceSize": 5968, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_wallets_walletConnectors_okxWallet-GJMKZIND_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5143.3069999963045, + "networkRequestTime": 5143.695999998599, + "networkEndTime": 5149.804000001401, + "finished": true, + "transferSize": 2437, + "resourceSize": 4565, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_wallets_walletConnectors_trustWallet-E2GVGE4U_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5143.853000000119, + "networkRequestTime": 5144.5289999991655, + "networkEndTime": 5150.170000001788, + "finished": true, + "transferSize": 2509, + "resourceSize": 4371, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_wallets_walletConnectors_rabbyWallet-FLVUU35F_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5144.51099999994, + "networkRequestTime": 5145.7289999984205, + "networkEndTime": 5151.063000001013, + "finished": true, + "transferSize": 4330, + "resourceSize": 8269, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_assets-NU2OP443_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5145.228000000119, + "networkRequestTime": 5146.85000000149, + "networkEndTime": 5152.309000000358, + "finished": true, + "transferSize": 12469, + "resourceSize": 45515, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_login-CWDTIDNK_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5145.796000000089, + "networkRequestTime": 5148.248999997973, + "networkEndTime": 5152.491000000387, + "finished": true, + "transferSize": 9697, + "resourceSize": 24218, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "data:image/svg+xml;base64,PHN2ZwogIHdpZHRoPSIxNiIKICBoZWlnaHQ9IjEyIgogIHZpZXdCb3g9IjAgMCAxNiAxMiIKI…", + "sessionTargetType": "page", + "protocol": "data", + "rendererStartTime": 5166.4310000017285, + "networkRequestTime": 5166.4310000017285, + "networkEndTime": 5166.513000000268, + "finished": true, + "transferSize": 0, + "resourceSize": 280, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true + }, + { + "url": "https://verify.walletconnect.com/8702c5ea8d157774a011deb8e1433d01", + "sessionTargetType": "iframe", + "protocol": "h3", + "rendererStartTime": 5554.9439999982715, + "networkRequestTime": 5555.662999998778, + "networkEndTime": 5660.646999999881, + "finished": true, + "transferSize": 278, + "resourceSize": 62, + "statusCode": 200, + "mimeType": "text/html", + "resourceType": "Document", + "priority": "VeryHigh", + "entity": "walletconnect.com" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_coinbase_wallet-sdk_dist_index_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5554.157999999821, + "networkRequestTime": 5554.584000002593, + "networkEndTime": 5567.478000000119, + "finished": true, + "transferSize": 173361, + "resourceSize": 657128, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5601.936999998987, + "networkRequestTime": 5602.295000001788, + "networkEndTime": 5613.890999998897, + "finished": true, + "transferSize": 276, + "resourceSize": 0, + "statusCode": 200, + "mimeType": "text/html", + "resourceType": "Fetch", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_modal_dist_index_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5633.605000000447, + "networkRequestTime": 5634.261999998242, + "networkEndTime": 5637.504999998957, + "finished": true, + "transferSize": 22370, + "resourceSize": 63923, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_modal-ui_dist_index_js.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "rendererStartTime": 5643.223999999464, + "networkRequestTime": 5643.6819999963045, + "networkEndTime": 5668.773000001907, + "finished": true, + "transferSize": 334017, + "resourceSize": 1321332, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "localhost" + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getDesktopListings?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2&page=1&entries=9&version=2", + "sessionTargetType": "page", + "protocol": "h3", + "rendererStartTime": 5745.813000001013, + "networkRequestTime": 5746.335000000894, + "networkEndTime": 6012.017999999225, + "finished": true, + "transferSize": 2226, + "resourceSize": 7613, + "statusCode": 200, + "mimeType": "application/json", + "resourceType": "Fetch", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "walletconnect.com" + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/3d7eb880-7654-431f-ed84-a25712b45200?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "sessionTargetType": "page", + "protocol": "h3", + "rendererStartTime": 6013.951999999583, + "networkRequestTime": 6014.236999999732, + "networkEndTime": 6220.143999997526, + "finished": true, + "transferSize": 2572, + "resourceSize": 2176, + "statusCode": 200, + "mimeType": "image/webp", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "walletconnect.com" + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/4e7d6f52-f663-4fc1-4b88-eebe7fc72800?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "sessionTargetType": "page", + "protocol": "h3", + "rendererStartTime": 6014.06099999696, + "networkRequestTime": 6014.401000000536, + "networkEndTime": 6061.516000002623, + "finished": true, + "transferSize": 2038, + "resourceSize": 1638, + "statusCode": 200, + "mimeType": "image/webp", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "walletconnect.com" + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/d8e930b6-ccde-471e-ecbe-6967b1c0c400?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "sessionTargetType": "page", + "protocol": "h3", + "rendererStartTime": 6014.12899999693, + "networkRequestTime": 6014.546999998391, + "networkEndTime": 6076.444999996573, + "finished": true, + "transferSize": 1974, + "resourceSize": 1576, + "statusCode": 200, + "mimeType": "image/webp", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "walletconnect.com" + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/77c1d3dd-0213-400a-f9cc-bfd524c47f00?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "sessionTargetType": "page", + "protocol": "h3", + "rendererStartTime": 6014.242000002414, + "networkRequestTime": 6014.741000000387, + "networkEndTime": 6067.776999998838, + "finished": true, + "transferSize": 1804, + "resourceSize": 1404, + "statusCode": 200, + "mimeType": "image/webp", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "walletconnect.com" + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/c20e1cec-05e8-4ac6-a086-7ce355092400?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "sessionTargetType": "page", + "protocol": "h3", + "rendererStartTime": 6014.335999999195, + "networkRequestTime": 6014.942000001669, + "networkEndTime": 6070.927999999374, + "finished": true, + "transferSize": 1592, + "resourceSize": 1192, + "statusCode": 200, + "mimeType": "image/webp", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "walletconnect.com" + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/67336675-0daa-489b-6885-cb95234bc400?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "sessionTargetType": "page", + "protocol": "h3", + "rendererStartTime": 6014.425000000745, + "networkRequestTime": 6015.127999998629, + "networkEndTime": 6071.069999996573, + "finished": true, + "transferSize": 2273, + "resourceSize": 1872, + "statusCode": 200, + "mimeType": "image/webp", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "walletconnect.com" + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/a578bd45-b418-4111-2c56-8ddcd1417c00?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "sessionTargetType": "page", + "protocol": "h3", + "rendererStartTime": 6014.479000002146, + "networkRequestTime": 6015.288999997079, + "networkEndTime": 6073.75, + "finished": true, + "transferSize": 1972, + "resourceSize": 1572, + "statusCode": 200, + "mimeType": "image/webp", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "walletconnect.com" + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/7e1514ba-932d-415d-1bdb-bccb6c2cbc00?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "sessionTargetType": "page", + "protocol": "h3", + "rendererStartTime": 6014.559999998659, + "networkRequestTime": 6015.457999996841, + "networkEndTime": 6080.824000000954, + "finished": true, + "transferSize": 1309, + "resourceSize": 910, + "statusCode": 200, + "mimeType": "image/webp", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "walletconnect.com" + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/f5b26eef-c5e8-421a-e379-ae010b4a7400?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "sessionTargetType": "page", + "protocol": "h3", + "rendererStartTime": 6014.614999998361, + "networkRequestTime": 6015.614999998361, + "networkEndTime": 6073.625, + "finished": true, + "transferSize": 2097, + "resourceSize": 1694, + "statusCode": 200, + "mimeType": "image/webp", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "walletconnect.com" + } + ], + "debugData": { + "type": "debugdata", + "networkStartTimeTs": 31362658561 + } + } + }, + "network-rtt": { + "id": "network-rtt", + "title": "Network Round Trip Times", + "description": "Network round trip times (RTT) have a large impact on performance. If the RTT to an origin is high, it's an indication that servers closer to the user could improve performance. [Learn more about the Round Trip Time](https://hpbn.co/primer-on-latency-and-bandwidth/).", + "score": 1, + "scoreDisplayMode": "informative", + "numericValue": 27.57, + "numericUnit": "millisecond", + "displayValue": "30 ms", + "details": { + "type": "table", + "headings": [ + { + "key": "origin", + "valueType": "text", + "label": "URL" + }, + { + "key": "rtt", + "valueType": "ms", + "granularity": 1, + "label": "Time Spent" + } + ], + "items": [ + { + "origin": "https://verify.walletconnect.com", + "rtt": 27.57 + }, + { + "origin": "https://explorer-api.walletconnect.com", + "rtt": 26.305 + }, + { + "origin": "https://fonts.googleapis.com", + "rtt": 19.466 + }, + { + "origin": "http://localhost:3000", + "rtt": 0.03675 + }, + { + "origin": "https://fonts.gstatic.com", + "rtt": 0 + } + ], + "sortedBy": ["rtt"] + } + }, + "network-server-latency": { + "id": "network-server-latency", + "title": "Server Backend Latencies", + "description": "Server latencies can impact web performance. If the server latency of an origin is high, it's an indication the server is overloaded or has poor backend performance. [Learn more about server response time](https://hpbn.co/primer-on-web-performance/#analyzing-the-resource-waterfall).", + "score": 1, + "scoreDisplayMode": "informative", + "numericValue": 30.154, + "numericUnit": "millisecond", + "displayValue": "30 ms", + "details": { + "type": "table", + "headings": [ + { + "key": "origin", + "valueType": "text", + "label": "URL" + }, + { + "key": "serverResponseTime", + "valueType": "ms", + "granularity": 1, + "label": "Time Spent" + } + ], + "items": [ + { + "origin": "https://explorer-api.walletconnect.com", + "serverResponseTime": 30.154 + }, + { + "origin": "https://fonts.googleapis.com", + "serverResponseTime": 19.48600000000001 + }, + { + "origin": "https://fonts.gstatic.com", + "serverResponseTime": 18.366 + }, + { + "origin": "https://verify.walletconnect.com", + "serverResponseTime": 13.793 + }, + { + "origin": "http://localhost:3000", + "serverResponseTime": 4.28725 + } + ], + "sortedBy": ["serverResponseTime"] + } + }, + "main-thread-tasks": { + "id": "main-thread-tasks", + "title": "Tasks", + "description": "Lists the toplevel main thread tasks that executed during page load.", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "startTime", + "valueType": "ms", + "granularity": 1, + "label": "Start Time" + }, + { + "key": "duration", + "valueType": "ms", + "granularity": 1, + "label": "End Time" + } + ], + "items": [ + { + "duration": 6.119, + "startTime": 29.302 + }, + { + "duration": 6.4, + "startTime": 52.092 + }, + { + "duration": 341.588, + "startTime": 172.552 + }, + { + "duration": 9.503, + "startTime": 515.115 + }, + { + "duration": 1169.039, + "startTime": 524.635 + }, + { + "duration": 52.192, + "startTime": 1693.778 + }, + { + "duration": 6.687, + "startTime": 1767.221 + }, + { + "duration": 27.735, + "startTime": 1773.964 + }, + { + "duration": 17.067, + "startTime": 1810.716 + }, + { + "duration": 9.507, + "startTime": 1831.01 + }, + { + "duration": 82.731, + "startTime": 1840.89 + }, + { + "duration": 12.054, + "startTime": 1923.692 + }, + { + "duration": 5.147, + "startTime": 2692.1 + }, + { + "duration": 24.434, + "startTime": 2751.595 + }, + { + "duration": 2392.075, + "startTime": 2776.096 + }, + { + "duration": 5.452, + "startTime": 5168.969 + }, + { + "duration": 144.056, + "startTime": 5185.436 + }, + { + "duration": 23.188, + "startTime": 5409.964 + }, + { + "duration": 11.402, + "startTime": 5435.098 + }, + { + "duration": 8.081, + "startTime": 5448.236 + }, + { + "duration": 35.519, + "startTime": 5570.688 + }, + { + "duration": 5.66, + "startTime": 5639.285 + }, + { + "duration": 75.716, + "startTime": 5675.205 + }, + { + "duration": 6.075, + "startTime": 5750.934 + } + ] + } + }, + "metrics": { + "id": "metrics", + "title": "Metrics", + "description": "Collects all available metrics.", + "score": 1, + "scoreDisplayMode": "informative", + "numericValue": 15825, + "numericUnit": "millisecond", + "details": { + "type": "debugdata", + "items": [ + { + "firstContentfulPaint": 442, + "largestContentfulPaint": 6387, + "interactive": 15825, + "speedIndex": 5787, + "totalBlockingTime": 2630, + "maxPotentialFID": 1196, + "cumulativeLayoutShift": 0, + "cumulativeLayoutShiftMainFrame": 0, + "lcpLoadStart": 5942, + "lcpLoadEnd": 5962, + "timeToFirstByte": 124, + "observedTimeOrigin": 0, + "observedTimeOriginTs": 31362657570, + "observedNavigationStart": 0, + "observedNavigationStartTs": 31362657570, + "observedFirstPaint": 1879, + "observedFirstPaintTs": 31364536563, + "observedFirstContentfulPaint": 1907, + "observedFirstContentfulPaintTs": 31364564476, + "observedFirstContentfulPaintAllFrames": 1907, + "observedFirstContentfulPaintAllFramesTs": 31364564476, + "observedLargestContentfulPaint": 1907, + "observedLargestContentfulPaintTs": 31364564476, + "observedLargestContentfulPaintAllFrames": 1907, + "observedLargestContentfulPaintAllFramesTs": 31364564476, + "observedTraceEnd": 7051, + "observedTraceEndTs": 31369708833, + "observedLoad": 1759, + "observedLoadTs": 31364416347, + "observedDomContentLoaded": 1751, + "observedDomContentLoadedTs": 31364408638, + "observedCumulativeLayoutShift": 0, + "observedCumulativeLayoutShiftMainFrame": 0, + "observedFirstVisualChange": 1854, + "observedFirstVisualChangeTs": 31364511570, + "observedLastVisualChange": 5187, + "observedLastVisualChangeTs": 31367844570, + "observedSpeedIndex": 2191, + "observedSpeedIndexTs": 31364848523 + }, + { + "lcpInvalidated": false + } + ] + } + }, + "resource-summary": { + "id": "resource-summary", + "title": "Resources Summary", + "description": "Aggregates all network requests and groups them by type", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "label", + "valueType": "text", + "label": "Resource Type" + }, + { + "key": "requestCount", + "valueType": "numeric", + "label": "Requests" + }, + { + "key": "transferSize", + "valueType": "bytes", + "label": "Transfer Size" + } + ], + "items": [ + { + "resourceType": "total", + "label": "Total", + "requestCount": 54, + "transferSize": 17480764 + }, + { + "resourceType": "script", + "label": "Script", + "requestCount": 23, + "transferSize": 16698518 + }, + { + "resourceType": "image", + "label": "Image", + "requestCount": 10, + "transferSize": 495441 + }, + { + "resourceType": "font", + "label": "Font", + "requestCount": 4, + "transferSize": 254886 + }, + { + "resourceType": "other", + "label": "Other", + "requestCount": 14, + "transferSize": 27638 + }, + { + "resourceType": "stylesheet", + "label": "Stylesheet", + "requestCount": 1, + "transferSize": 2318 + }, + { + "resourceType": "document", + "label": "Document", + "requestCount": 2, + "transferSize": 1963 + }, + { + "resourceType": "media", + "label": "Media", + "requestCount": 0, + "transferSize": 0 + }, + { + "resourceType": "third-party", + "label": "Third-party", + "requestCount": 21, + "transferSize": 57153 + } + ] + } + }, + "third-party-summary": { + "id": "third-party-summary", + "title": "Minimize third-party usage", + "description": "Third-party code can significantly impact load performance. Limit the number of redundant third-party providers and try to load third-party code after your page has primarily finished loading. [Learn how to minimize third-party impact](https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/loading-third-party-javascript/).", + "score": 1, + "scoreDisplayMode": "informative", + "displayValue": "Third-party code blocked the main thread for 0 ms", + "metricSavings": { + "TBT": 0 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "entity", + "valueType": "text", + "label": "Third-Party", + "subItemsHeading": { + "key": "url", + "valueType": "url" + } + }, + { + "key": "transferSize", + "granularity": 1, + "valueType": "bytes", + "label": "Transfer Size", + "subItemsHeading": { + "key": "transferSize" + } + }, + { + "key": "blockingTime", + "granularity": 1, + "valueType": "ms", + "label": "Main-Thread Blocking Time", + "subItemsHeading": { + "key": "blockingTime" + } + } + ], + "items": [ + { + "mainThreadTime": 1.65, + "blockingTime": 0, + "transferSize": 37018, + "tbtImpact": 0, + "entity": "Google Fonts", + "subItems": { + "type": "subitems", + "items": [ + { + "url": "https://fonts.gstatic.com/s/roboto/v47/KFO7CnqEu92Fr1ME7kSn66aGLdTylUAMa3yUBHMdazQ.woff2", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 34700, + "tbtImpact": 0 + }, + { + "url": "https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;600;700", + "mainThreadTime": 1.65, + "blockingTime": 0, + "transferSize": 2318, + "tbtImpact": 0 + } + ] + } + }, + { + "mainThreadTime": 0.052000000000000005, + "blockingTime": 0, + "transferSize": 20135, + "tbtImpact": 0, + "entity": "walletconnect.com", + "subItems": { + "type": "subitems", + "items": [ + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/3d7eb880-7654-431f-ed84-a25712b45200?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 2572, + "tbtImpact": 0 + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/67336675-0daa-489b-6885-cb95234bc400?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 2273, + "tbtImpact": 0 + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getDesktopListings?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2&page=1&entries=9&version=2", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 2226, + "tbtImpact": 0 + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/f5b26eef-c5e8-421a-e379-ae010b4a7400?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 2097, + "tbtImpact": 0 + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/4e7d6f52-f663-4fc1-4b88-eebe7fc72800?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 2038, + "tbtImpact": 0 + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/d8e930b6-ccde-471e-ecbe-6967b1c0c400?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 1974, + "tbtImpact": 0 + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/a578bd45-b418-4111-2c56-8ddcd1417c00?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 1972, + "tbtImpact": 0 + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/77c1d3dd-0213-400a-f9cc-bfd524c47f00?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 1804, + "tbtImpact": 0 + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/c20e1cec-05e8-4ac6-a086-7ce355092400?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 1592, + "tbtImpact": 0 + }, + { + "url": "https://explorer-api.walletconnect.com/w3m/v1/getWalletImage/7e1514ba-932d-415d-1bdb-bccb6c2cbc00?projectId=8702c5ea8d157774a011deb8e1433d01&sdkType=wcm&sdkVersion=js-2.6.2", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 1309, + "tbtImpact": 0 + }, + { + "url": "https://verify.walletconnect.com/8702c5ea8d157774a011deb8e1433d01", + "mainThreadTime": 0.052000000000000005, + "blockingTime": 0, + "transferSize": 278, + "tbtImpact": 0 + } + ] + } + }, + { + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 0, + "tbtImpact": 0, + "entity": "127.0.0.1", + "subItems": { + "type": "subitems", + "items": [ + { + "url": "http://127.0.0.1:8547/", + "mainThreadTime": 0, + "blockingTime": 0, + "transferSize": 0, + "tbtImpact": 0 + } + ] + } + } + ], + "summary": { + "wastedBytes": 57153, + "wastedMs": 0 + }, + "isEntityGrouped": true + }, + "guidanceLevel": 1 + }, + "third-party-facades": { + "id": "third-party-facades", + "title": "Lazy load third-party resources with facades", + "description": "Some third-party embeds can be lazy loaded. Consider replacing them with a facade until they are required. [Learn how to defer third-parties with a facade](https://developer.chrome.com/docs/lighthouse/performance/third-party-facades/).", + "score": null, + "scoreDisplayMode": "notApplicable", + "metricSavings": { + "TBT": 0 + }, + "guidanceLevel": 3 + }, + "largest-contentful-paint-element": { + "id": "largest-contentful-paint-element", + "title": "Largest Contentful Paint element", + "description": "This is the largest contentful element painted within the viewport. [Learn more about the Largest Contentful Paint element](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-largest-contentful-paint/)", + "score": 0, + "scoreDisplayMode": "metricSavings", + "displayValue": "6,390 ms", + "metricSavings": { + "LCP": 5200 + }, + "details": { + "type": "list", + "items": [ + { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "label": "Element" + } + ], + "items": [ + { + "node": { + "type": "node", + "lhId": "page-0-IMG", + "path": "1,HTML,1,BODY,0,DIV,0,DIV,1,IMG", + "selector": "body > div#__next > div.relative > img.absolute", + "boundingRect": { + "top": 366, + "bottom": 940, + "left": 0, + "right": 1350, + "width": 1350, + "height": 574 + }, + "snippet": "\"grains\"", + "nodeLabel": "grains" + } + } + ] + }, + { + "type": "table", + "headings": [ + { + "key": "phase", + "valueType": "text", + "label": "Phase" + }, + { + "key": "percent", + "valueType": "text", + "label": "% of LCP" + }, + { + "key": "timing", + "valueType": "ms", + "label": "Timing" + } + ], + "items": [ + { + "phase": "TTFB", + "timing": 124.28725, + "percent": "2%" + }, + { + "phase": "Load Delay", + "timing": 5817.363777449029, + "percent": "91%" + }, + { + "phase": "Load Time", + "timing": 20.061570342651066, + "percent": "0%" + }, + { + "phase": "Render Delay", + "timing": 424.8531522083176, + "percent": "7%" + } + ] + } + ] + }, + "guidanceLevel": 1 + }, + "lcp-lazy-loaded": { + "id": "lcp-lazy-loaded", + "title": "Largest Contentful Paint image was lazily loaded", + "description": "Above-the-fold images that are lazily loaded render later in the page lifecycle, which can delay the largest contentful paint. [Learn more about optimal lazy loading](https://web.dev/articles/lcp-lazy-loading).", + "score": 0, + "scoreDisplayMode": "metricSavings", + "metricSavings": { + "LCP": 950 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "label": "Element" + } + ], + "items": [ + { + "node": { + "type": "node", + "lhId": "1-32-IMG", + "path": "1,HTML,1,BODY,0,DIV,0,DIV,1,IMG", + "selector": "body > div#__next > div.relative > img.absolute", + "boundingRect": { + "top": 366, + "bottom": 940, + "left": 0, + "right": 1350, + "width": 1350, + "height": 574 + }, + "snippet": "\"grains\"", + "nodeLabel": "grains" + } + } + ] + }, + "guidanceLevel": 3 + }, + "layout-shifts": { + "id": "layout-shifts", + "title": "Avoid large layout shifts", + "description": "These are the largest layout shifts observed on the page. Each table item represents a single layout shift, and shows the element that shifted the most. Below each item are possible root causes that led to the layout shift. Some of these layout shifts may not be included in the CLS metric value due to [windowing](https://web.dev/articles/cls#what_is_cls). [Learn how to improve CLS](https://web.dev/articles/optimize-cls)", + "score": null, + "scoreDisplayMode": "notApplicable", + "metricSavings": { + "CLS": 0 + }, + "details": { + "type": "table", + "headings": [], + "items": [] + }, + "guidanceLevel": 2 + }, + "long-tasks": { + "id": "long-tasks", + "title": "Avoid long main-thread tasks", + "description": "Lists the longest tasks on the main thread, useful for identifying worst contributors to input delay. [Learn how to avoid long main-thread tasks](https://web.dev/articles/optimize-long-tasks)", + "score": 1, + "scoreDisplayMode": "informative", + "displayValue": "5 long tasks found", + "metricSavings": { + "TBT": 2650 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "startTime", + "valueType": "ms", + "granularity": 1, + "label": "Start Time" + }, + { + "key": "duration", + "valueType": "ms", + "granularity": 1, + "label": "Duration" + } + ], + "items": [ + { + "url": "http://localhost:3000/_next/static/chunks/src_components_App_App_tsx.js", + "duration": 1196, + "startTime": 14034.225250000014 + }, + { + "url": "http://localhost:3000/_next/static/chunks/pages/_app.js", + "duration": 1169, + "startTime": 9261.277500000007 + }, + { + "url": "http://localhost:3000/_next/static/chunks/main.js", + "duration": 342, + "startTime": 4692.8007499999985 + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_ethereum-provider_dist_index_es_js.js", + "duration": 144, + "startTime": 15915.137250000013 + }, + { + "url": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_modal-ui_dist_index_js.js", + "duration": 76, + "startTime": 15230.225250000014 + } + ], + "sortedBy": ["duration"], + "skipSumming": ["startTime"], + "debugData": { + "type": "debugdata", + "urls": [ + "http://localhost:3000/_next/static/chunks/src_components_App_App_tsx.js", + "http://localhost:3000/_next/static/chunks/pages/_app.js", + "http://localhost:3000/_next/static/chunks/main.js", + "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_ethereum-provider_dist_index_es_js.js", + "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_modal-ui_dist_index_js.js" + ], + "tasks": [ + { + "urlIndex": 0, + "startTime": 14034.2, + "duration": 1196, + "other": 1196, + "scriptEvaluation": 0 + }, + { + "urlIndex": 1, + "startTime": 9261.3, + "duration": 1169, + "other": 1169, + "scriptEvaluation": 0 + }, + { + "urlIndex": 2, + "startTime": 4692.8, + "duration": 342, + "other": 342, + "scriptEvaluation": 0 + }, + { + "urlIndex": 3, + "startTime": 15915.1, + "duration": 144, + "other": 144, + "scriptEvaluation": 0 + }, + { + "urlIndex": 4, + "startTime": 15230.2, + "duration": 76, + "other": 76, + "scriptEvaluation": 0 + } + ] + } + }, + "guidanceLevel": 1 + }, + "non-composited-animations": { + "id": "non-composited-animations", + "title": "Avoid non-composited animations", + "description": "Animations which are not composited can be janky and increase CLS. [Learn how to avoid non-composited animations](https://developer.chrome.com/docs/lighthouse/performance/non-composited-animations/)", + "score": 1, + "scoreDisplayMode": "informative", + "displayValue": "4 animated elements found", + "metricSavings": { + "CLS": 0 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "failureReason", + "valueType": "text" + }, + "label": "Element" + }, + { + "key": null, + "valueType": "text", + "subItemsHeading": { + "key": "animation", + "valueType": "text" + }, + "label": "Name" + } + ], + "items": [ + { + "node": { + "type": "node", + "lhId": "page-1-DIV", + "path": "1,HTML,1,BODY,0,DIV,0,DIV,2,DIV,0,DIV,0,DIV,0,DIV,0,DIV,2,DIV,4,DIV,1,DIV", + "selector": "div.relative > div.z-10 > div.flex > div.flex", + "boundingRect": { + "top": 364, + "bottom": 364, + "left": 50, + "right": 237, + "width": 187, + "height": 0 + }, + "snippet": "
", + "nodeLabel": "div.relative > div.z-10 > div.flex > div.flex" + }, + "subItems": { + "type": "subitems", + "items": [ + { + "failureReason": "Unsupported CSS Property: scrollbar-color", + "animation": "scrollbar-color" + }, + { + "failureReason": "Unsupported CSS Property: scrollbar-color", + "animation": "scrollbar-color" + } + ] + } + }, + { + "node": { + "type": "node", + "lhId": "page-2-DIV", + "path": "1,HTML,1,BODY,0,DIV,0,DIV,2,DIV,0,DIV,0,DIV,0,DIV,0,DIV,2,DIV,1,DIV,1,DIV", + "selector": "div.relative > div.z-10 > div.flex > div.flex", + "boundingRect": { + "top": 199, + "bottom": 199, + "left": 50, + "right": 237, + "width": 187, + "height": 0 + }, + "snippet": "
", + "nodeLabel": "div.relative > div.z-10 > div.flex > div.flex" + }, + "subItems": { + "type": "subitems", + "items": [ + { + "failureReason": "Unsupported CSS Property: scrollbar-color", + "animation": "scrollbar-color" + }, + { + "failureReason": "Unsupported CSS Property: scrollbar-color", + "animation": "scrollbar-color" + } + ] + } + }, + { + "node": { + "type": "node", + "lhId": "page-3-DIV", + "path": "1,HTML,1,BODY,0,DIV,0,DIV,2,DIV,0,DIV,0,DIV,0,DIV,0,DIV,2,DIV,2,DIV,1,DIV", + "selector": "div.relative > div.z-10 > div.flex > div.flex", + "boundingRect": { + "top": 254, + "bottom": 254, + "left": 50, + "right": 237, + "width": 187, + "height": 0 + }, + "snippet": "
", + "nodeLabel": "div.relative > div.z-10 > div.flex > div.flex" + }, + "subItems": { + "type": "subitems", + "items": [ + { + "failureReason": "Unsupported CSS Property: scrollbar-color", + "animation": "scrollbar-color" + }, + { + "failureReason": "Unsupported CSS Property: scrollbar-color", + "animation": "scrollbar-color" + } + ] + } + }, + { + "node": { + "type": "node", + "lhId": "page-4-DIV", + "path": "1,HTML,1,BODY,0,DIV,0,DIV,2,DIV,0,DIV,0,DIV,0,DIV,0,DIV", + "selector": "div.relative > div.sticky > div.sticky > div.relative", + "boundingRect": { + "top": 0, + "bottom": 940, + "left": 0, + "right": 256, + "width": 256, + "height": 940 + }, + "snippet": "
", + "nodeLabel": "Home\nProjects\nChains\nBridge\nDevelopers\nCommunity\nGet Help\nThe Most Decentralize…" + }, + "subItems": { + "type": "subitems", + "items": [ + { + "failureReason": "Unsupported CSS Property: scrollbar-color", + "animation": "scrollbar-color" + } + ] + } + } + ] + }, + "guidanceLevel": 2 + }, + "unsized-images": { + "id": "unsized-images", + "title": "Image elements have explicit `width` and `height`", + "description": "Set an explicit width and height on image elements to reduce layout shifts and improve CLS. [Learn how to set image dimensions](https://web.dev/articles/optimize-cls#images_without_dimensions)", + "score": 1, + "scoreDisplayMode": "metricSavings", + "metricSavings": { + "CLS": 0 + }, + "details": { + "type": "table", + "headings": [], + "items": [] + }, + "guidanceLevel": 4 + }, + "valid-source-maps": { + "id": "valid-source-maps", + "title": "Missing source maps for large first-party JavaScript", + "description": "Source maps translate minified code to the original source code. This helps developers debug in production. In addition, Lighthouse is able to provide further insights. Consider deploying source maps to take advantage of these benefits. [Learn more about source maps](https://developer.chrome.com/docs/devtools/javascript/source-maps/).", + "score": 0, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "scriptUrl", + "valueType": "url", + "subItemsHeading": { + "key": "error" + }, + "label": "URL" + }, + { + "key": "sourceMapUrl", + "valueType": "url", + "label": "Map URL" + } + ], + "items": [ + { + "scriptUrl": "http://localhost:3000/_next/static/chunks/src_components_App_App_tsx.js", + "subItems": { + "type": "subitems", + "items": [ + { + "error": "Large JavaScript file is missing a source map" + } + ] + } + }, + { + "scriptUrl": "http://localhost:3000/_next/static/chunks/pages/index.js", + "subItems": { + "type": "subitems", + "items": [ + { + "error": "Large JavaScript file is missing a source map" + } + ] + } + }, + { + "scriptUrl": "http://localhost:3000/_next/static/chunks/pages/_app.js", + "subItems": { + "type": "subitems", + "items": [ + { + "error": "Large JavaScript file is missing a source map" + } + ] + } + }, + { + "scriptUrl": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_modal-ui_dist_index_js.js", + "subItems": { + "type": "subitems", + "items": [ + { + "error": "Large JavaScript file is missing a source map" + } + ] + } + }, + { + "scriptUrl": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_ethereum-provider_dist_index_es_js.js", + "subItems": { + "type": "subitems", + "items": [ + { + "error": "Large JavaScript file is missing a source map" + } + ] + } + }, + { + "scriptUrl": "http://localhost:3000/_next/static/chunks/node_modules_offchainlabs_cobalt_dist_cobalt_es_js.js", + "subItems": { + "type": "subitems", + "items": [ + { + "error": "Large JavaScript file is missing a source map" + } + ] + } + }, + { + "scriptUrl": "http://localhost:3000/_next/static/chunks/node_modules_coinbase_wallet-sdk_dist_index_js.js", + "subItems": { + "type": "subitems", + "items": [ + { + "error": "Large JavaScript file is missing a source map" + } + ] + } + }, + { + "scriptUrl": "http://localhost:3000/_next/static/chunks/main.js", + "subItems": { + "type": "subitems", + "items": [ + { + "error": "Large JavaScript file is missing a source map" + } + ] + } + } + ] + } + }, + "prioritize-lcp-image": { + "id": "prioritize-lcp-image", + "title": "Preload Largest Contentful Paint image", + "description": "If the LCP element is dynamically added to the page, you should preload the image in order to improve LCP. [Learn more about preloading LCP elements](https://web.dev/articles/optimize-lcp#optimize_when_the_resource_is_discovered).", + "score": 1, + "scoreDisplayMode": "metricSavings", + "numericValue": 0, + "numericUnit": "millisecond", + "displayValue": "", + "metricSavings": { + "LCP": 0 + }, + "details": { + "type": "opportunity", + "headings": [], + "items": [], + "overallSavingsMs": 0, + "sortedBy": ["wastedMs"], + "debugData": { + "type": "debugdata", + "initiatorPath": [ + { + "url": "http://localhost:3000/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Feclipse_bottom.4304bd37.png&w=1920&q=75", + "initiatorType": "fallbackToMain" + }, + { + "url": "http://localhost:3000/?sourceChain=ethereum&destinationChain=arbitrum-one&tab=bridge&txHistory=0", + "initiatorType": "other" + } + ], + "pathLength": 2 + } + }, + "guidanceLevel": 4 + }, + "csp-xss": { + "id": "csp-xss", + "title": "Ensure CSP is effective against XSS attacks", + "description": "A strong Content Security Policy (CSP) significantly reduces the risk of cross-site scripting (XSS) attacks. [Learn how to use a CSP to prevent XSS](https://developer.chrome.com/docs/lighthouse/best-practices/csp-xss/)", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "description", + "valueType": "text", + "subItemsHeading": { + "key": "description" + }, + "label": "Description" + }, + { + "key": "directive", + "valueType": "code", + "subItemsHeading": { + "key": "directive" + }, + "label": "Directive" + }, + { + "key": "severity", + "valueType": "text", + "subItemsHeading": { + "key": "severity" + }, + "label": "Severity" + } + ], + "items": [ + { + "severity": "High", + "description": "No CSP found in enforcement mode" + } + ] + } + }, + "has-hsts": { + "id": "has-hsts", + "title": "Use a strong HSTS policy", + "description": "Deployment of the HSTS header significantly reduces the risk of downgrading HTTP connections and eavesdropping attacks. A rollout in stages, starting with a low max-age is recommended. [Learn more about using a strong HSTS policy.](https://developer.chrome.com/docs/lighthouse/best-practices/has-hsts)", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "description", + "valueType": "text", + "subItemsHeading": { + "key": "description" + }, + "label": "Description" + }, + { + "key": "directive", + "valueType": "code", + "subItemsHeading": { + "key": "directive" + }, + "label": "Directive" + }, + { + "key": "severity", + "valueType": "text", + "subItemsHeading": { + "key": "severity" + }, + "label": "Severity" + } + ], + "items": [ + { + "severity": "High", + "description": "No HSTS header found" + } + ] + } + }, + "origin-isolation": { + "id": "origin-isolation", + "title": "Ensure proper origin isolation with COOP", + "description": "The Cross-Origin-Opener-Policy (COOP) can be used to isolate the top-level window from other documents such as pop-ups. [Learn more about deploying the COOP header.](https://web.dev/articles/why-coop-coep#coop)", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "description", + "valueType": "text", + "subItemsHeading": { + "key": "description" + }, + "label": "Description" + }, + { + "key": "directive", + "valueType": "code", + "subItemsHeading": { + "key": "directive" + }, + "label": "Directive" + }, + { + "key": "severity", + "valueType": "text", + "subItemsHeading": { + "key": "severity" + }, + "label": "Severity" + } + ], + "items": [ + { + "description": "No COOP header found", + "severity": "High" + } + ] + } + }, + "clickjacking-mitigation": { + "id": "clickjacking-mitigation", + "title": "Mitigate clickjacking with XFO or CSP", + "description": "The `X-Frame-Options` (XFO) header or the `frame-ancestors` directive in the `Content-Security-Policy` (CSP) header control where a page can be embedded. These can mitigate clickjacking attacks by blocking some or all sites from embedding the page. [Learn more about mitigating clickjacking](https://developer.chrome.com/docs/lighthouse/best-practices/clickjacking-mitigation).", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "description", + "valueType": "text", + "subItemsHeading": { + "key": "description" + }, + "label": "Description" + }, + { + "key": "severity", + "valueType": "text", + "subItemsHeading": { + "key": "severity" + }, + "label": "Severity" + } + ], + "items": [ + { + "severity": "High", + "description": "No frame control policy found" + } + ] + } + }, + "script-treemap-data": { + "id": "script-treemap-data", + "title": "Script Treemap Data", + "description": "Used for treemap app", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "treemap-data", + "nodes": [ + { + "name": "http://localhost:3000/_next/static/chunks/react-refresh.js", + "resourceBytes": 79107, + "encodedBytes": 25063, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/webpack.js", + "resourceBytes": 53011, + "encodedBytes": 10015, + "unusedBytes": 28078 + }, + { + "name": "http://localhost:3000/_next/static/chunks/main.js", + "resourceBytes": 5287916, + "encodedBytes": 1176778, + "unusedBytes": 23699 + }, + { + "name": "http://localhost:3000/_next/static/chunks/pages/_app.js", + "resourceBytes": 18915166, + "encodedBytes": 3979485, + "unusedBytes": 83488 + }, + { + "name": "http://localhost:3000/_next/static/chunks/pages/index.js", + "resourceBytes": 895933, + "encodedBytes": 196084, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/development/_buildManifest.js", + "resourceBytes": 296, + "encodedBytes": 296, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/development/_ssgManifest.js", + "resourceBytes": 76, + "encodedBytes": 76, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_offchainlabs_cobalt_dist_cobalt_es_js.js", + "resourceBytes": 576077, + "encodedBytes": 147047, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/src_components_App_App_tsx.js", + "resourceBytes": 43336048, + "encodedBytes": 9942112, + "unusedBytes": 574631 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_ethereum-provider_dist_index_es_js.js", + "resourceBytes": 2332522, + "encodedBytes": 638797, + "unusedBytes": 1282 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_safeWallet-VUYZPLY4_js.js", + "resourceBytes": 5674, + "encodedBytes": 2897, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_rainbowWallet-2SR6TVBF_js.js", + "resourceBytes": 11347, + "encodedBytes": 3707, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_coinbaseWallet-WWX6LF36_js.js", + "resourceBytes": 3751, + "encodedBytes": 1933, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_metaMaskWallet-YFHEHW7V_js.js", + "resourceBytes": 18353, + "encodedBytes": 4611, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_walletConnectWallet-FNSU4KNU_js.js", + "resourceBytes": 5968, + "encodedBytes": 2946, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_wallets_walletConnectors_okxWallet-GJMKZIND_js.js", + "resourceBytes": 4565, + "encodedBytes": 2068, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_wallets_walletConnectors_trustWallet-E2GVGE4U_js.js", + "resourceBytes": 4371, + "encodedBytes": 2140, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_wallets_walletConnectors_rabbyWallet-FLVUU35F_js.js", + "resourceBytes": 8269, + "encodedBytes": 3961, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_assets-NU2OP443_js.js", + "resourceBytes": 45515, + "encodedBytes": 12100, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_rainbow-me_rainbowkit_dist_login-CWDTIDNK_js.js", + "resourceBytes": 24218, + "encodedBytes": 9328, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_coinbase_wallet-sdk_dist_index_js.js", + "resourceBytes": 657123, + "encodedBytes": 172991, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_modal_dist_index_js.js", + "resourceBytes": 63923, + "encodedBytes": 22001, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/node_modules_walletconnect_modal-ui_dist_index_js.js", + "resourceBytes": 1321329, + "encodedBytes": 333646, + "unusedBytes": 0 + } + ] + } + }, + "accesskeys": { + "id": "accesskeys", + "title": "`[accesskey]` values are unique", + "description": "Access keys let users quickly focus a part of the page. For proper navigation, each access key must be unique. [Learn more about access keys](https://dequeuniversity.com/rules/axe/4.10/accesskeys).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-allowed-attr": { + "id": "aria-allowed-attr", + "title": "`[aria-*]` attributes match their roles", + "description": "Each ARIA `role` supports a specific subset of `aria-*` attributes. Mismatching these invalidates the `aria-*` attributes. [Learn how to match ARIA attributes to their roles](https://dequeuniversity.com/rules/axe/4.10/aria-allowed-attr).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-allowed-role": { + "id": "aria-allowed-role", + "title": "Uses ARIA roles only on compatible elements", + "description": "Many HTML elements can only be assigned certain ARIA roles. Using ARIA roles where they are not allowed can interfere with the accessibility of the web page. [Learn more about ARIA roles](https://dequeuniversity.com/rules/axe/4.10/aria-allowed-role).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-command-name": { + "id": "aria-command-name", + "title": "`button`, `link`, and `menuitem` elements have accessible names", + "description": "When an element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to make command elements more accessible](https://dequeuniversity.com/rules/axe/4.10/aria-command-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-conditional-attr": { + "id": "aria-conditional-attr", + "title": "ARIA attributes are used as specified for the element's role", + "description": "Some ARIA attributes are only allowed on an element under certain conditions. [Learn more about conditional ARIA attributes](https://dequeuniversity.com/rules/axe/4.10/aria-conditional-attr).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-deprecated-role": { + "id": "aria-deprecated-role", + "title": "Deprecated ARIA roles were not used", + "description": "Deprecated ARIA roles may not be processed correctly by assistive technology. [Learn more about deprecated ARIA roles](https://dequeuniversity.com/rules/axe/4.10/aria-deprecated-role).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-dialog-name": { + "id": "aria-dialog-name", + "title": "Elements with `role=\"dialog\"` or `role=\"alertdialog\"` do not have accessible names.", + "description": "ARIA dialog elements without accessible names may prevent screen readers users from discerning the purpose of these elements. [Learn how to make ARIA dialog elements more accessible](https://dequeuniversity.com/rules/axe/4.10/aria-dialog-name).", + "score": 0, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [ + { + "node": { + "type": "node", + "lhId": "1-0-DIV", + "path": "1,HTML,1,BODY,7,WCM-MODAL,a,#document-fragment,3,DIV", + "selector": "div#wcm-modal", + "boundingRect": { + "top": 0, + "bottom": 940, + "left": 0, + "right": 1350, + "width": 1350, + "height": 940 + }, + "snippet": "
", + "nodeLabel": "div#wcm-modal", + "explanation": "Fix any of the following:\n aria-label attribute does not exist or is empty\n aria-labelledby attribute does not exist, references elements that do not exist or references elements that are empty\n Element has no title attribute" + } + } + ], + "debugData": { + "type": "debugdata", + "impact": "serious", + "tags": ["cat.aria", "best-practice"] + } + } + }, + "aria-hidden-body": { + "id": "aria-hidden-body", + "title": "`[aria-hidden=\"true\"]` is not present on the document ``", + "description": "Assistive technologies, like screen readers, work inconsistently when `aria-hidden=\"true\"` is set on the document ``. [Learn how `aria-hidden` affects the document body](https://dequeuniversity.com/rules/axe/4.10/aria-hidden-body).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-hidden-focus": { + "id": "aria-hidden-focus", + "title": "`[aria-hidden=\"true\"]` elements do not contain focusable descendents", + "description": "Focusable descendents within an `[aria-hidden=\"true\"]` element prevent those interactive elements from being available to users of assistive technologies like screen readers. [Learn how `aria-hidden` affects focusable elements](https://dequeuniversity.com/rules/axe/4.10/aria-hidden-focus).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-input-field-name": { + "id": "aria-input-field-name", + "title": "ARIA input fields have accessible names", + "description": "When an input field doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more about input field labels](https://dequeuniversity.com/rules/axe/4.10/aria-input-field-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-meter-name": { + "id": "aria-meter-name", + "title": "ARIA `meter` elements have accessible names", + "description": "When a meter element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to name `meter` elements](https://dequeuniversity.com/rules/axe/4.10/aria-meter-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-progressbar-name": { + "id": "aria-progressbar-name", + "title": "ARIA `progressbar` elements have accessible names", + "description": "When a `progressbar` element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to label `progressbar` elements](https://dequeuniversity.com/rules/axe/4.10/aria-progressbar-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-prohibited-attr": { + "id": "aria-prohibited-attr", + "title": "Elements use only permitted ARIA attributes", + "description": "Using ARIA attributes in roles where they are prohibited can mean that important information is not communicated to users of assistive technologies. [Learn more about prohibited ARIA roles](https://dequeuniversity.com/rules/axe/4.10/aria-prohibited-attr).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-required-attr": { + "id": "aria-required-attr", + "title": "`[role]`s have all required `[aria-*]` attributes", + "description": "Some ARIA roles have required attributes that describe the state of the element to screen readers. [Learn more about roles and required attributes](https://dequeuniversity.com/rules/axe/4.10/aria-required-attr).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-required-children": { + "id": "aria-required-children", + "title": "Elements with an ARIA `[role]` that require children to contain a specific `[role]` have all required children.", + "description": "Some ARIA parent roles must contain specific child roles to perform their intended accessibility functions. [Learn more about roles and required children elements](https://dequeuniversity.com/rules/axe/4.10/aria-required-children).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-required-parent": { + "id": "aria-required-parent", + "title": "`[role]`s are contained by their required parent element", + "description": "Some ARIA child roles must be contained by specific parent roles to properly perform their intended accessibility functions. [Learn more about ARIA roles and required parent element](https://dequeuniversity.com/rules/axe/4.10/aria-required-parent).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-roles": { + "id": "aria-roles", + "title": "`[role]` values are valid", + "description": "ARIA roles must have valid values in order to perform their intended accessibility functions. [Learn more about valid ARIA roles](https://dequeuniversity.com/rules/axe/4.10/aria-roles).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-text": { + "id": "aria-text", + "title": "Elements with the `role=text` attribute do not have focusable descendents.", + "description": "Adding `role=text` around a text node split by markup enables VoiceOver to treat it as one phrase, but the element's focusable descendents will not be announced. [Learn more about the `role=text` attribute](https://dequeuniversity.com/rules/axe/4.10/aria-text).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-toggle-field-name": { + "id": "aria-toggle-field-name", + "title": "ARIA toggle fields have accessible names", + "description": "When a toggle field doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more about toggle fields](https://dequeuniversity.com/rules/axe/4.10/aria-toggle-field-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-tooltip-name": { + "id": "aria-tooltip-name", + "title": "ARIA `tooltip` elements have accessible names", + "description": "When a tooltip element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to name `tooltip` elements](https://dequeuniversity.com/rules/axe/4.10/aria-tooltip-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-treeitem-name": { + "id": "aria-treeitem-name", + "title": "ARIA `treeitem` elements have accessible names", + "description": "When a `treeitem` element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more about labeling `treeitem` elements](https://dequeuniversity.com/rules/axe/4.10/aria-treeitem-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-valid-attr-value": { + "id": "aria-valid-attr-value", + "title": "`[aria-*]` attributes have valid values", + "description": "Assistive technologies, like screen readers, can't interpret ARIA attributes with invalid values. [Learn more about valid values for ARIA attributes](https://dequeuniversity.com/rules/axe/4.10/aria-valid-attr-value).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-valid-attr": { + "id": "aria-valid-attr", + "title": "`[aria-*]` attributes are valid and not misspelled", + "description": "Assistive technologies, like screen readers, can't interpret ARIA attributes with invalid names. [Learn more about valid ARIA attributes](https://dequeuniversity.com/rules/axe/4.10/aria-valid-attr).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "button-name": { + "id": "button-name", + "title": "Buttons do not have an accessible name", + "description": "When a button doesn't have an accessible name, screen readers announce it as \"button\", making it unusable for users who rely on screen readers. [Learn how to make buttons more accessible](https://dequeuniversity.com/rules/axe/4.10/button-name).", + "score": 0, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [ + { + "node": { + "type": "node", + "lhId": "1-1-BUTTON", + "path": "1,HTML,1,BODY,0,DIV,0,DIV,2,DIV,0,DIV,0,DIV,0,DIV,0,DIV,0,BUTTON", + "selector": "div.sticky > div.sticky > div.relative > button.absolute", + "boundingRect": { + "top": 60, + "bottom": 92, + "left": 239, + "right": 271, + "width": 32, + "height": 32 + }, + "snippet": "