@deeeed/metamask-harness 0.40.0 → 0.41.0

package/library/actions/mobile/perps/performance-capture.mjs

@@ -1,8 +1,11 @@
 import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 
-const MARKER = "[HomepagePerf]";
+const MARKER = "[PerpsPerf]";
+const LEGACY_MARKER = "[HomepagePerf]";
+const DETAILED_MARKERS = [MARKER, LEGACY_MARKER];
 const STARTUP_MARKER = "[StartupPerf]";
+const LOAD_PROOF_MARKER = "[PerpsLoadProof]";
 const STATE_FILE = ".homepage-performance-capture.json";
 const FRESH_SOURCES = new Set([
   "fresh_socket",
@@ -44,6 +47,201 @@ function parseRecord(line, marker) {
   }
 }
 
+function detailedMarker(line) {
+  return DETAILED_MARKERS.find((marker) => line.includes(marker)) ?? null;
+}
+
+function parseDetailedRecord(line) {
+  const marker = detailedMarker(line);
+  return marker ? parseRecord(line, marker) : null;
+}
+
+function latestPerpsBootstrapStartRecord(content) {
+  return content
+    .split(/\r?\n/u)
+    .filter((line) => line.includes(LOAD_PROOF_MARKER))
+    .map((line) => parseRecord(line, LOAD_PROOF_MARKER))
+    .filter((record) => record?.stage === "perps_bootstrap_start")
+    .at(-1) ?? null;
+}
+
+function consoleClockMs(line) {
+  const match = line.match(/\b(\d{2}):(\d{2}):(\d{2})\.(\d{3})\b/u);
+  if (!match) return null;
+  return (
+    Number(match[1]) * 3_600_000 +
+    Number(match[2]) * 60_000 +
+    Number(match[3]) * 1_000 +
+    Number(match[4])
+  );
+}
+
+function existingLiveStreamRecords(segmentLines, markerRecords) {
+  let bootstrapLineIndex = -1;
+  segmentLines.forEach((line, index) => {
+    if (
+      line.includes(LOAD_PROOF_MARKER) &&
+      line.includes('"stage":"perps_bootstrap_start"')
+    ) {
+      bootstrapLineIndex = index;
+    }
+  });
+  const bootstrapLine =
+    bootstrapLineIndex >= 0 ? segmentLines[bootstrapLineIndex] : undefined;
+  const liveLines =
+    bootstrapLineIndex >= 0
+      ? segmentLines.slice(bootstrapLineIndex + 1)
+      : segmentLines;
+  const bootstrapClock = bootstrapLine ? consoleClockMs(bootstrapLine) : null;
+  const bootstrapRecord = markerRecords
+    .filter((record) => record.stage === "perps_bootstrap_start")
+    .at(-1);
+  const patterns = new Map([
+    ["PerpsWS: First price data received", "prices"],
+    ["PerpsWS: First position data received", "positions"],
+    ["PerpsWS: First order data received", "orders"],
+    ["PerpsWS: First account data received", "account"],
+  ]);
+  const records = [];
+  for (const [message, stream] of patterns) {
+    const line = liveLines.find((candidate) => candidate.includes(message));
+    if (!line) continue;
+    const eventClock = consoleClockMs(line);
+    let elapsedMs = null;
+    if (bootstrapClock !== null && eventClock !== null) {
+      elapsedMs = eventClock - bootstrapClock;
+      if (elapsedMs < 0) elapsedMs += 24 * 3_600_000;
+    }
+    records.push({
+      stage: "values_ready",
+      stream,
+      source: "fresh_socket",
+      item_count: null,
+      elapsed_ms: elapsedMs,
+      monotonic_ms:
+        elapsedMs !== null &&
+        Number.isFinite(Number(bootstrapRecord?.monotonic_ms))
+          ? Number(bootstrapRecord.monotonic_ms) + elapsedMs
+          : null,
+      evidence: "existing_sentry_ws_marker",
+    });
+  }
+  return records;
+}
+
+function mergeLoadProofRecords(records) {
+  const byStageStreamSource = new Map();
+  for (const record of records) {
+    const key = `${record.stage ?? "unknown"}:${record.stream ?? ""}:${record.source ?? ""}`;
+    const current = byStageStreamSource.get(key);
+    if (record.stage === "perps_bootstrap_start") {
+      if (
+        !current ||
+        Number(record.monotonic_ms) > Number(current.monotonic_ms)
+      ) {
+        byStageStreamSource.set(key, record);
+      }
+      continue;
+    }
+    const recordIsFallback =
+      record.evidence === "existing_sentry_ws_marker";
+    const currentIsFallback =
+      current?.evidence === "existing_sentry_ws_marker";
+    const recordElapsedMs = Number(record.elapsed_ms);
+    const currentElapsedMs = Number(current?.elapsed_ms);
+    const sameEvidenceClassEarlier =
+      recordIsFallback === currentIsFallback &&
+      record.elapsed_ms !== null &&
+      record.elapsed_ms !== undefined &&
+      Number.isFinite(recordElapsedMs) &&
+      current?.elapsed_ms !== null &&
+      current?.elapsed_ms !== undefined &&
+      Number.isFinite(currentElapsedMs) &&
+      recordElapsedMs < currentElapsedMs;
+    if (
+      !current ||
+      (currentIsFallback && !recordIsFallback) ||
+      sameEvidenceClassEarlier
+    ) {
+      byStageStreamSource.set(key, record);
+    }
+  }
+  return [...byStageStreamSource.values()];
+}
+
+async function waitForPerformanceRecord({ node, sourceFile, offset }) {
+  const stage = node.wait_for_stage;
+  const requiredLiveStreams = Array.isArray(node.required_live_streams)
+    ? node.required_live_streams.map(String)
+    : [];
+  if (stage === undefined && requiredLiveStreams.length === 0) return;
+
+  const expected =
+    stage === undefined
+      ? null
+      : {
+          stage: String(stage),
+          ...(node.wait_for_source !== undefined
+            ? { source: String(node.wait_for_source) }
+            : {}),
+          ...(node.wait_for_lifecycle !== undefined
+            ? { lifecycle: String(node.wait_for_lifecycle) }
+            : {}),
+        };
+  const timeoutMs = Math.max(1, Number(node.wait_timeout_ms ?? 60_000));
+  const pollIntervalMs = Math.max(
+    10,
+    Number(node.wait_poll_interval_ms ?? 100),
+  );
+  const deadline = Date.now() + timeoutMs;
+
+  while (true) {
+    const content = await readFile(sourceFile);
+    const start = offset <= content.length ? offset : 0;
+    const segmentLines = content
+      .subarray(start)
+      .toString("utf8")
+      .split(/\r?\n/u);
+    const performanceRecords = segmentLines
+      .filter(detailedMarker)
+      .map(parseDetailedRecord)
+      .filter(Boolean);
+    const stageMatched =
+      expected === null ||
+      performanceRecords.some((record) =>
+        Object.entries(expected).every(
+          ([key, value]) => String(record[key] ?? "") === value,
+        ),
+      );
+    const markerLoadProofRecords = segmentLines
+      .filter((line) => line.includes(LOAD_PROOF_MARKER))
+      .map((line) => parseRecord(line, LOAD_PROOF_MARKER))
+      .filter(Boolean);
+    const liveStreams = new Set(
+      mergeLoadProofRecords([
+        ...markerLoadProofRecords,
+        ...existingLiveStreamRecords(segmentLines, markerLoadProofRecords),
+      ])
+        .filter(
+          (record) =>
+            record.stage === "values_ready" &&
+            record.source === "fresh_socket",
+        )
+        .map((record) => String(record.stream ?? "")),
+    );
+    const liveStreamsMatched = requiredLiveStreams.every((stream) =>
+      liveStreams.has(stream),
+    );
+    if (stageMatched && liveStreamsMatched) return;
+    if (Date.now() >= deadline) {
+      throw new Error(
+        `Timed out waiting ${timeoutMs}ms for ${MARKER} stage ${JSON.stringify(expected)} and live streams ${JSON.stringify(requiredLiveStreams)}.`,
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+}
+
 function startupMeasurements(records) {
   return records.map((record) => {
     const processToStageMs = Number(
@@ -72,6 +270,60 @@ function startupMeasurements(records) {
   });
 }
 
+function perpsBootstrapBoundary(homepageRecords, loadProofRecords) {
+  const demandTimes = homepageRecords
+    .filter((record) => record.stage === "surface_demand")
+    .map((record) => Number(record.monotonic_ms))
+    .filter(Number.isFinite);
+  const firstDemandAt = demandTimes.length > 0 ? Math.min(...demandTimes) : null;
+  const bootstrapTimes = loadProofRecords
+    .filter((record) => record.stage === "perps_bootstrap_start")
+    .map((record) => Number(record.monotonic_ms))
+    .filter(
+      (value) =>
+        Number.isFinite(value) &&
+        (firstDemandAt === null || value <= firstDemandAt),
+    );
+  const bootstrapAt =
+    bootstrapTimes.length > 0 ? Math.max(...bootstrapTimes) : null;
+  const failureReason =
+    firstDemandAt === null
+      ? "missing_surface_demand"
+      : bootstrapAt === null
+        ? "missing_prior_perps_bootstrap_start"
+        : null;
+  return {
+    status: failureReason === null ? "pass" : "fail",
+    perpsBootstrapStartAtMonotonicMs: bootstrapAt,
+    firstDemandAtMonotonicMs: firstDemandAt,
+    demandAfterPerpsBootstrapStartMs:
+      bootstrapAt !== null && firstDemandAt !== null
+        ? roundMs(firstDemandAt - bootstrapAt)
+        : null,
+    failureReason,
+  };
+}
+
+function loadProofMeasurements(records) {
+  return records
+    .filter((record) => record.stage === "values_ready")
+    .map((record) => {
+      const elapsedMs = finiteNumberOrNull(record.elapsed_ms);
+      return {
+        stream: String(record.stream ?? "unknown"),
+        source: String(record.source ?? "unknown"),
+        evidence: String(record.evidence ?? LOAD_PROOF_MARKER),
+        itemCount: finiteNumberOrNull(record.item_count),
+        elapsedAfterPerpsBootstrapStartMs:
+          elapsedMs === null ? null : roundMs(elapsedMs),
+        mainMarketCount: finiteNumberOrNull(record.main_market_count),
+        hip3MarketCount: finiteNumberOrNull(record.hip3_market_count),
+        pricedMarketCount: finiteNumberOrNull(record.priced_market_count),
+        trendMarketCount: finiteNumberOrNull(record.trend_market_count),
+      };
+    });
+}
+
 function increment(counts, value) {
   const key = value == null || value === "" ? "unknown" : String(value);
   counts[key] = (counts[key] ?? 0) + 1;
@@ -81,6 +333,12 @@ function roundMs(value) {
   return Number(value.toFixed(3));
 }
 
+function finiteNumberOrNull(value) {
+  if (value === null || value === undefined) return null;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
 function contentVariantSatisfies(actual, required) {
   if (actual === required) return true;
   return (
@@ -139,7 +397,7 @@ function frameIsCached(record) {
 function visibleFrameGroups(records) {
   const demandLifecycles = new Map(
     records
-      .filter((record) => record.stage === "viewport_demand")
+      .filter((record) => record.stage === "surface_demand")
       .map((record) => [
         String(record.demand_id ?? ""),
         record.lifecycle ?? "unknown",
@@ -215,7 +473,7 @@ function cacheTakeoverMeasurement(records, requiredContentVariants = []) {
   const failureReason = !cached
     ? "missing_cached_visible_frame"
     : !fresh
-      ? "missing_later_fresh_visible_frame"
+      ? "missing_later_surface_live_frame"
       : cacheHydratedAt === null
         ? "missing_disk_cache_hydrated"
         : null;
@@ -248,7 +506,7 @@ function cacheTakeoverMeasurement(records, requiredContentVariants = []) {
 
 function visibleMeasurements(records, requiredFreshContentVariants = []) {
   const demands = records.filter(
-    (record) => record.stage === "viewport_demand",
+    (record) => record.stage === "surface_demand",
   );
   return demands.map((demand) => {
     const demandId = String(demand.demand_id ?? "");
@@ -265,13 +523,16 @@ function visibleMeasurements(records, requiredFreshContentVariants = []) {
       (record) =>
         record.stage === "next_frame_checkpoint" && belongsToDemand(record),
     );
+    const commits = records.filter(
+      (record) => record.stage === "react_commit" && belongsToDemand(record),
+    );
     const firstVisibleBoundary = records.find(
       (record) =>
-        record.stage === "first_visible_recorded" && belongsToDemand(record),
+        record.stage === "surface_resolved_recorded" && belongsToDemand(record),
     );
     const freshVisibleBoundary = records.find(
       (record) =>
-        record.stage === "fresh_visible_recorded" && belongsToDemand(record),
+        record.stage === "surface_live_recorded" && belongsToDemand(record),
     );
     const frameTimes = frames
       .map((record) =>
@@ -352,9 +613,12 @@ function visibleMeasurements(records, requiredFreshContentVariants = []) {
           : null,
       freshVisibleAtMonotonicMs: freshVisibleAt,
       freshContentVariant,
-      dataReadyAtDemand: sortedFrames.some(
-        (frame) => frame.data_ready_at_demand === true && frameIsFresh(frame),
-      ),
+      dataReadyAtDemand:
+        firstVisibleBoundary?.data_ready_at_demand === true ||
+        commits.some(
+          (commit) =>
+            commit.data_ready_at_demand === true && frameIsFresh(commit),
+        ),
       dfdMs: Number.isFinite(Number(freshVisibleBoundary?.duration_ms))
         ? roundMs(Number(freshVisibleBoundary.duration_ms))
         : Number.isFinite(startedAt) && freshVisibleAt != null
@@ -527,6 +791,7 @@ function firstFreshDeliveryChecks(records, requirements) {
 function summarize(
   records,
   startupRecords,
+  loadProofRecords,
   sourcePath,
   offset,
   bytesScanned,
@@ -554,6 +819,10 @@ function summarize(
   for (const record of startupRecords) {
     increment(startupStages, record.stage);
   }
+  const loadProofStages = {};
+  for (const record of loadProofRecords) {
+    increment(loadProofStages, record.stage);
+  }
   return {
     schemaVersion: 1,
     marker: MARKER,
@@ -565,6 +834,11 @@ function summarize(
     startupRecordCount: startupRecords.length,
     startupStages,
     startupMeasurements: startupMeasurements(startupRecords),
+    loadProofMarker: LOAD_PROOF_MARKER,
+    loadProofRecordCount: loadProofRecords.length,
+    loadProofStages,
+    loadProofMeasurements: loadProofMeasurements(loadProofRecords),
+    perpsBootstrapBoundary: perpsBootstrapBoundary(records, loadProofRecords),
     stages,
     lifecycles,
     streams,
@@ -587,7 +861,7 @@ function summarize(
   };
 }
 
-export async function captureHomepagePerformance(input) {
+export async function capturePerpsPerformance(input) {
   const node = input.node ?? {};
   const phase = String(node.phase ?? "").toLowerCase();
   if (phase !== "start" && phase !== "end") {
@@ -612,9 +886,21 @@ export async function captureHomepagePerformance(input) {
 
   if (phase === "start") {
     const offset = await fileSize(sourceFile);
+    const existingContent =
+      offset > 0 ? (await readFile(sourceFile)).toString("utf8") : "";
     await writeFile(
       stateFile,
-      `${JSON.stringify({ sourcePath, offset }, null, 2)}\n`,
+      `${JSON.stringify(
+        {
+          sourcePath,
+          offset,
+          captureStartedAtEpochMs: Date.now(),
+          perpsBootstrapStartRecord:
+            latestPerpsBootstrapStartRecord(existingContent),
+        },
+        null,
+        2,
+      )}\n`,
     );
     return { phase, sourcePath, offset };
   }
@@ -631,27 +917,52 @@ export async function captureHomepagePerformance(input) {
   if (
     state.sourcePath !== sourcePath ||
     !Number.isInteger(state.offset) ||
-    state.offset < 0
+    state.offset < 0 ||
+    !Number.isFinite(state.captureStartedAtEpochMs)
   ) {
     throw new Error(
       "metamask.perps.capture_performance capture state is invalid or uses a different source_path.",
     );
   }
 
+  await waitForPerformanceRecord({
+    node,
+    sourceFile,
+    offset: state.offset,
+  });
+
   const content = await readFile(sourceFile);
   const offset = state.offset <= content.length ? state.offset : 0;
   const segment = content.subarray(offset).toString("utf8");
-  const lines = segment
-    .split(/\r?\n/u)
-    .filter((line) => line.includes(MARKER) || line.includes(STARTUP_MARKER));
+  const segmentLines = segment.split(/\r?\n/u);
+  const lines = segmentLines
+    .filter(
+      (line) =>
+        detailedMarker(line) ||
+        line.includes(STARTUP_MARKER) ||
+        line.includes(LOAD_PROOF_MARKER),
+    );
   const records = lines
-    .filter((line) => line.includes(MARKER))
-    .map((line) => parseRecord(line, MARKER))
+    .filter(detailedMarker)
+    .map(parseDetailedRecord)
     .filter(Boolean);
   const startupRecords = lines
     .filter((line) => line.includes(STARTUP_MARKER))
     .map((line) => parseRecord(line, STARTUP_MARKER))
     .filter(Boolean);
+  const markerLoadProofRecords = [
+    ...(state.perpsBootstrapStartRecord
+      ? [state.perpsBootstrapStartRecord]
+      : []),
+    ...lines
+      .filter((line) => line.includes(LOAD_PROOF_MARKER))
+      .map((line) => parseRecord(line, LOAD_PROOF_MARKER))
+      .filter(Boolean),
+  ];
+  const loadProofRecords = mergeLoadProofRecords([
+    ...markerLoadProofRecords,
+    ...existingLiveStreamRecords(segmentLines, markerLoadProofRecords),
+  ]);
   const requireRecords = node.require_records !== false;
   const requiredStages = Array.isArray(node.required_stages)
     ? node.required_stages.map(String)
@@ -732,6 +1043,26 @@ export async function captureHomepagePerformance(input) {
     (check) => check.status === "fail",
   );
   const requireCacheBeforeFresh = node.require_cache_before_fresh === true;
+  const requirePerpsBootstrapStartBeforeDemand =
+    node.require_perps_bootstrap_start_before_demand === true;
+  const requiredLiveStreams = Array.isArray(node.required_live_streams)
+    ? node.required_live_streams.map(String)
+    : [];
+  const presentLiveStreams = new Set(
+    loadProofRecords
+      .filter(
+        (record) =>
+          record.stage === "values_ready" && record.source === "fresh_socket",
+      )
+      .map((record) => String(record.stream ?? "")),
+  );
+  const missingLiveStreams = requiredLiveStreams.filter(
+    (stream) => !presentLiveStreams.has(stream),
+  );
+  const measuredPerpsBootstrapBoundary = perpsBootstrapBoundary(
+    records,
+    loadProofRecords,
+  );
   const cacheTakeover = cacheTakeoverMeasurement(
     records,
     requiredFreshContentVariants,
@@ -756,6 +1087,9 @@ export async function captureHomepagePerformance(input) {
       missingFreshLifecycles.length === 0 &&
       missingFreshContentVariants.length === 0 &&
       failedFirstFreshDeliveries.length === 0 &&
+      missingLiveStreams.length === 0 &&
+      (!requirePerpsBootstrapStartBeforeDemand ||
+        measuredPerpsBootstrapBoundary.status === "pass") &&
       (!requireCacheBeforeFresh || cacheTakeover.status === "pass")
         ? "pass"
         : "fail",
@@ -767,20 +1101,31 @@ export async function captureHomepagePerformance(input) {
     missingFreshLifecycles,
     missingFreshContentVariants,
     failedFirstFreshDeliveries,
+    missingLiveStreams,
+    perpsBootstrapStartBeforeDemand: requirePerpsBootstrapStartBeforeDemand
+      ? measuredPerpsBootstrapBoundary.status
+      : "not_required",
     cacheBeforeFresh: requireCacheBeforeFresh
       ? cacheTakeover.status
       : "not_required",
   };
+  const captureEndedAtEpochMs = Date.now();
   const summary = {
     ...summarize(
       records,
       startupRecords,
+      loadProofRecords,
       sourcePath,
       offset,
       content.length - offset,
       requiredFreshContentVariants,
       firstFreshDeliveryRequirements,
     ),
+    captureWindow: {
+      startedAtEpochMs: state.captureStartedAtEpochMs,
+      endedAtEpochMs: captureEndedAtEpochMs,
+      durationMs: captureEndedAtEpochMs - state.captureStartedAtEpochMs,
+    },
     validation,
   };
   const nodeId = String(input.context?.nodeId ?? "capture-performance");
@@ -804,6 +1149,19 @@ export async function captureHomepagePerformance(input) {
       `Missing required ${STARTUP_MARKER} stages: ${missingStartupStages.join(", ")}.`,
     );
   }
+  if (
+    requirePerpsBootstrapStartBeforeDemand &&
+    measuredPerpsBootstrapBoundary.status !== "pass"
+  ) {
+    throw new Error(
+      `Perps bootstrap boundary requirement failed: ${measuredPerpsBootstrapBoundary.failureReason}.`,
+    );
+  }
+  if (missingLiveStreams.length > 0) {
+    throw new Error(
+      `Missing required live Perps streams: ${missingLiveStreams.join(", ")}.`,
+    );
+  }
   if (missingLifecycles.length > 0) {
     throw new Error(
       `Missing required ${MARKER} lifecycles: ${missingLifecycles.join(", ")}.`,

package/library/actions/mobile/perps/perps.mjs

@@ -6,6 +6,7 @@ import {
   runAdapter,
 } from '../platform/bridge.mjs';
 import { ensureUnlocked } from '../wallet/ensure_unlocked.mjs';
+import { selectAccount } from '../wallet/select_account.mjs';
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -961,29 +962,74 @@ async function applyTutorialState(input, config) {
 export async function startState(input) {
   const params = paramsForState(input);
   const config = mergeStateConfig(profileDefaults(params.profile), params);
+  const timeoutMs = Math.max(1, Number(input.node?.timeout_ms ?? 30_000));
+  const deadline = Date.now() + timeoutMs;
+  const stateInput = () => {
+    const remainingMs = Math.max(1, deadline - Date.now());
+    const configuredTargetMs = Number(input.node?.target_timeout_ms);
+    const targetTimeoutMs = Math.min(
+      remainingMs,
+      Number.isFinite(configuredTargetMs) && configuredTargetMs > 0
+        ? configuredTargetMs
+        : Math.min(30_000, Math.ceil(remainingMs / 3)),
+    );
+    const configuredUnlockMs = Number(input.node?.unlock_timeout_ms);
+    const unlockTimeoutMs = Math.min(
+      Math.max(1, remainingMs - targetTimeoutMs),
+      Number.isFinite(configuredUnlockMs) && configuredUnlockMs > 0
+        ? configuredUnlockMs
+        : remainingMs,
+    );
+    return {
+      ...input,
+      node: {
+        ...input.node,
+        timeout_ms: remainingMs,
+        bridge_timeout_ms: remainingMs,
+        cdp_timeout_ms: remainingMs,
+        controller_ready_timeout_ms: remainingMs,
+        target_timeout_ms: targetTimeoutMs,
+        unlock_timeout_ms: unlockTimeoutMs,
+      },
+    };
+  };
   // Product edits require an app restart before proof. Mobile relocks on restart,
   // so a deterministic Perps start state must restore the fixture-backed wallet
   // prerequisite before it navigates or converges controller state.
+  const walletInput = stateInput();
   const wallet = await ensureUnlocked({
-    ...input,
+    ...walletInput,
     action: 'metamask.wallet.ensure_unlocked',
-    node: { ...input.node, action: 'metamask.wallet.ensure_unlocked' },
+    node: { ...walletInput.node, action: 'metamask.wallet.ensure_unlocked' },
   });
+  const accountInput = stateInput();
+  const account = typeof config.account === 'string' && config.account.trim()
+    ? await selectAccount({
+      ...accountInput,
+      action: 'metamask.wallet.select_account',
+      node: {
+        ...accountInput.node,
+        action: 'metamask.wallet.select_account',
+        name: config.account.trim(),
+      },
+    })
+    : { skipped: true };
   // Entering Perps initializes the provider client on a freshly launched app.
   // State reads before this navigation fail with CLIENT_NOT_INITIALIZED.
-  const navigation = await applyStateNavigation(input, config);
-  const provider = await ensureProvider(input, config);
-  const network = await ensureNetwork(input, config);
-  const tutorial = await applyTutorialState(input, config);
-  const readyToTrade = await assertReadyToTrade(input, config);
-  const balance = await assertBalance(input, config);
-  const orders = await applyOrdersState(input, config.orders);
-  const positions = await applyPositionsState(input, config.positions);
+  const navigation = await applyStateNavigation(stateInput(), config);
+  const provider = await ensureProvider(stateInput(), config);
+  const network = await ensureNetwork(stateInput(), config);
+  const tutorial = await applyTutorialState(stateInput(), config);
+  const readyToTrade = await assertReadyToTrade(stateInput(), config);
+  const balance = await assertBalance(stateInput(), config);
+  const orders = await applyOrdersState(stateInput(), config.orders);
+  const positions = await applyPositionsState(stateInput(), config.positions);
   return {
     action: input.action,
     profile: config.profile ?? params.profile ?? 'clean_market_testnet',
     phase: 'start_state',
     wallet,
+    account,
     provider,
     network,
     tutorial,