@deeeed/metamask-harness 0.2.0

package/library/actions/mobile/bridge-runtime/setup-wallet.sh

@@ -0,0 +1,442 @@
+#!/bin/bash
+# Setup wallet from a JSON fixture via CDP + AgenticService.setupWallet().
+#
+# Expects a FRESH app (no existing vault). For a clean environment, run:
+#   yarn a:setup:ios   # full clean setup + wallet
+#
+# Usage:
+#   setup-wallet.sh [--fixture path/to/fixture.json]
+#
+# Fixture JSON format:
+#   {
+#     "password": "yourpassword",
+#     "accounts": [
+#       { "type": "mnemonic", "value": "word1 word2 ...", "name": "Primary" },
+#       { "type": "privateKey", "value": "0xabc...", "name": "dev1" },
+#       { "type": "privateKey", "value": "0xdef...", "name": "dev2" }
+#     ],
+#     "settings": { "metametrics": true, "skipGtmModals": true, "skipPerpsTutorial": true, "autoLockNever": true, "deviceAuthEnabled": true }
+#   }
+
+set -euo pipefail
+
+# Resolve the script directory to an absolute path BEFORE cd, so sourcing and
+# helper paths work regardless of the caller's CWD (e.g. ./setup-wallet.sh).
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# Run from the target product checkout; the runner invokes this with cwd=projectRoot.
+APP_ROOT="${APP_ROOT:-$PWD}"
+cd "$APP_ROOT"
+
+PORT="${WATCHER_PORT:-8081}"
+[[ "$PORT" =~ ^[0-9]+$ ]] || { echo "ERROR: WATCHER_PORT must be numeric (got: $PORT)" >&2; exit 1; }
+SCRIPTS="$SCRIPT_DIR"
+# Account derivation (applyWalletFixture / setupWallet) is far slower than a
+# normal eval — a 10+ account fixture easily exceeds 30s. The value is a cap, not
+# a delay, so a high default is harmless for the fast evals. Override via env.
+export CDP_TIMEOUT="${CDP_TIMEOUT:-120000}"
+export CDP_DISCOVERY_RETRIES="${CDP_DISCOVERY_RETRIES:-3}"
+WALLET_SETUP_SETTLE_TIMEOUT="${WALLET_SETUP_SETTLE_TIMEOUT:-180}"
+CDP="node $SCRIPTS/cdp-bridge.cjs"
+FIXTURE_PATH=""
+
+cdp_json_command() {
+  local mode="$1"
+  local expression="$2"
+  local output=""
+  if ! output=$($CDP "$mode" "$expression" 2>&1); then
+    echo "ERROR: CDP ${mode} failed: $output" >&2
+    return 1
+  fi
+  if ! printf '%s\n' "$output" | jq -r '.'; then
+    echo "ERROR: CDP ${mode} returned non-JSON output: $output" >&2
+    return 1
+  fi
+}
+cdp_eval() { cdp_json_command eval "$1"; }
+cdp_eval_async() { cdp_json_command eval-async "$1"; }
+
+# -- Parse args --
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --fixture)
+      [ $# -ge 2 ] || { echo "ERROR: --fixture requires a path argument"; exit 2; }
+      FIXTURE_PATH="$2"; shift 2 ;;
+    -h|--help) echo "Usage: setup-wallet.sh [--fixture path.json]"; exit 0 ;;
+    *)         echo "Unknown arg: $1"; exit 2 ;;
+  esac
+done
+
+# -- Resolve + validate fixture --
+[ -z "$FIXTURE_PATH" ] && FIXTURE_PATH="${WALLET_FIXTURE:-${RECIPE_RUNTIME_DIR:-temp/recipe/runtime}/wallet-fixture.json}"
+
+if [ ! -f "$FIXTURE_PATH" ]; then
+  echo "ERROR: Fixture not found: $FIXTURE_PATH"
+  echo "  create ${RECIPE_RUNTIME_DIR:-temp/recipe/runtime}/wallet-fixture.json"
+  exit 1
+fi
+echo "Reading fixture: $FIXTURE_PATH"
+
+jq empty "$FIXTURE_PATH" 2>/dev/null || { echo "ERROR: Invalid JSON"; exit 1; }
+
+PASSWORD=$(jq -r '.password // empty' "$FIXTURE_PATH")
+[ -z "$PASSWORD" ] && { echo "ERROR: fixture missing 'password'"; exit 1; }
+
+if jq -e '.import' "$FIXTURE_PATH" >/dev/null 2>&1 && ! jq -e '.accounts' "$FIXTURE_PATH" >/dev/null 2>&1; then
+  echo "ERROR: Old format. Use an accounts array in the wallet fixture."
+  exit 1
+fi
+
+ACCOUNT_COUNT=$(jq -r '.accounts | length // 0' "$FIXTURE_PATH" 2>/dev/null || echo 0)
+for i in $(seq 0 $((ACCOUNT_COUNT - 1))); do
+  ACC_TYPE=$(jq -r ".accounts[$i].type // empty" "$FIXTURE_PATH")
+  ACC_VALUE=$(jq -r ".accounts[$i].value // empty" "$FIXTURE_PATH")
+  if [ -z "$ACC_TYPE" ] || { [ "$ACC_TYPE" != "mnemonic" ] && [ "$ACC_TYPE" != "privateKey" ]; }; then
+    echo "ERROR: accounts[$i].type must be 'mnemonic' or 'privateKey' (got '${ACC_TYPE:-empty}')"
+    echo "  See the Recipe runner Mobile fixture format."
+    exit 1
+  fi
+  [ -z "$ACC_VALUE" ] && { echo "ERROR: accounts[$i].value is empty"; exit 1; }
+done
+# Expected EVM account total = sum of mnemonic counts + one per private key.
+# A mnemonic entry with count=N materializes N HD accounts, not one, so the
+# entry count alone (ACCOUNT_COUNT) under-counts and would let setup pass while
+# silently missing HD accounts.
+EXPECTED_ETH_TOTAL=$(jq -r '[.accounts[] | if .type == "mnemonic" then (.count // .numberOfAccounts // 1) else 1 end] | add // 0' "$FIXTURE_PATH")
+echo "Fixture OK: password + ${ACCOUNT_COUNT} entry(ies), ${EXPECTED_ETH_TOTAL} expected EVM account(s)"
+
+wait_for_cdp_bridge() {
+  local waited=0
+  local max="${CDP_READY_TIMEOUT:-90}"
+  local output=""
+  while [ "$waited" -lt "$max" ]; do
+    if output=$($CDP eval "JSON.stringify({ok:true})" 2>&1); then
+      echo "CDP bridge connected."
+      return 0
+    fi
+    sleep 1
+    waited=$((waited + 1))
+    [ "$waited" -eq 5 ] && echo "Waiting for CDP bridge..."
+  done
+  echo "ERROR: CDP not reachable after ${max}s"
+  [ -n "$output" ] && echo "$output" >&2
+  return 1
+}
+
+# -- Check CDP --
+wait_for_cdp_bridge
+
+wait_for_engine() {
+  local waited=0
+  local max="${ENGINE_READY_TIMEOUT:-60}"
+  local engine_ok=""
+  while [ "$waited" -lt "$max" ]; do
+    engine_ok=$(cdp_eval "(function(){ var engine = globalThis.Engine; return engine && engine.context && engine.context.KeyringController ? 'ready' : 'waiting'; })()" 2>/dev/null || echo "")
+    [ "$engine_ok" = "ready" ] && return 0
+    sleep 1
+    waited=$((waited + 1))
+    [ "$waited" -eq 5 ] && echo "Waiting for Engine to initialize..."
+  done
+  echo "ERROR: Engine.context.KeyringController not available after ${max}s"
+  return 1
+}
+
+# -- Wait for Engine to be ready (KeyringController must exist) --
+wait_for_engine
+
+# The backup subscriber reads the Engine *class* static
+# `disableAutomaticVaultBackup`. AgenticService.setupWallet/applyWalletFixture
+# set that static authoritatively before any account import/rename. The
+# CDP-exposed `Engine` is the facade object, not the class, so we cannot set the
+# static from here — only record harness intent for observability.
+if ! DISABLE_BACKUP=$(cdp_eval "(function(){ globalThis.__AGENTIC_DISABLE_VAULT_BACKUP = true; return JSON.stringify({agenticDisableVaultBackup: globalThis.__AGENTIC_DISABLE_VAULT_BACKUP === true}); })()"); then
+  echo "WARN: could not record vault backup guard intent before wallet setup"
+  DISABLE_BACKUP='{}'
+fi
+echo "Vault backup guard intent: $DISABLE_BACKUP"
+wait_for_engine
+
+# Read fixture JSON and escape it for safe embedding in a JS string literal.
+FIXTURE_JSON=$(jq -c '.' "$FIXTURE_PATH")
+ESCAPED_FIXTURE=$(node -p "JSON.stringify(JSON.stringify(JSON.parse(process.argv[1])))" "$FIXTURE_JSON")
+EXPECTED_ADDRESSES=$(node - "$FIXTURE_PATH" <<'NODE'
+const fs = require('fs');
+const { Wallet } = require('ethers');
+const fixture = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
+const addresses = [];
+for (const account of fixture.accounts || []) {
+  if (account.type === 'mnemonic') {
+    const rawCount =
+      account.count != null
+        ? account.count
+        : account.numberOfAccounts != null
+        ? account.numberOfAccounts
+        : 1;
+    const count = Number(rawCount);
+    for (let i = 0; i < count; i += 1) {
+      addresses.push(
+        Wallet.fromMnemonic(account.value, `m/44'/60'/0'/0/${i}`).address.toLowerCase(),
+      );
+    }
+  } else if (account.type === 'privateKey') {
+    const key = account.value.startsWith('0x') ? account.value : `0x${account.value}`;
+    addresses.push(new Wallet(key).address.toLowerCase());
+  }
+}
+console.log(JSON.stringify(addresses));
+NODE
+)
+FIRST_EXPECTED_ADDRESS=$(EXPECTED_JSON="$EXPECTED_ADDRESSES" node <<'NODE'
+const addresses = JSON.parse(process.env.EXPECTED_JSON || '[]');
+process.stdout.write(addresses[0] || '');
+NODE
+)
+
+read_wallet_state() {
+  cdp_eval "(function(){ try { var engine = globalThis.Engine; var ctx = engine && engine.context ? engine.context : {}; var accountsController = ctx.AccountsController || {}; var keyringController = ctx.KeyringController || {}; var state = accountsController.state || {}; var internalAccounts = state.internalAccounts || {}; var accountsById = internalAccounts.accounts || {}; var accs = Object.values(accountsById); var eth = accs.filter(function(a){ return String(a && a.address || '').indexOf('0x') === 0; }); var route = globalThis.__AGENTIC__ && globalThis.__AGENTIC__.getRoute ? globalThis.__AGENTIC__.getRoute() : null; var selected = null; if (typeof accountsController.getSelectedAccount === 'function') { selected = accountsController.getSelectedAccount(); } else if (internalAccounts.selectedAccount && accountsById[internalAccounts.selectedAccount]) { selected = accountsById[internalAccounts.selectedAccount]; } return JSON.stringify({ok:true, unlocked: typeof keyringController.isUnlocked === 'function' ? keyringController.isUnlocked() : null, routeName: route && route.name, selected: selected ? {name: selected.metadata && selected.metadata.name, address: selected.address} : null, total: accs.length, ethAccounts: eth.length, accounts: eth.map(function(a){ return {name: a && a.metadata && a.metadata.name, address: a && a.address}; }), first3: eth.slice(0,3).map(function(a){ return {name: a && a.metadata && a.metadata.name, address: a && a.address}; })}); } catch (e) { return JSON.stringify({ok:false, error: e && (e.stack || e.message) || String(e)}); } })()"
+}
+
+missing_fixture_addresses() {
+  ACCOUNTS_JSON="$1" EXPECTED_JSON="$EXPECTED_ADDRESSES" node <<'NODE'
+const accounts = JSON.parse(process.env.ACCOUNTS_JSON);
+const expected = JSON.parse(process.env.EXPECTED_JSON);
+const actual = new Set((accounts.accounts || accounts.first3 || []).map((a) => String(a.address || '').toLowerCase()));
+const missing = expected.filter((address) => !actual.has(address));
+console.log(JSON.stringify(missing));
+NODE
+}
+
+wallet_state_issue() {
+  local accounts_json="$1"
+  if [ -z "$accounts_json" ]; then
+    echo "wallet state unavailable"
+    return
+  fi
+
+  local ok unlocked eth_count missing_count
+  ok=$(echo "$accounts_json" | jq -r '.ok // false' 2>/dev/null || echo false)
+  if [ "$ok" != "true" ]; then
+    echo "$(echo "$accounts_json" | jq -r '.error // "wallet state read failed"' 2>/dev/null || echo "wallet state read failed")"
+    return
+  fi
+
+  unlocked=$(echo "$accounts_json" | jq -r '.unlocked')
+  eth_count=$(echo "$accounts_json" | jq -r '.ethAccounts')
+  if [ "$unlocked" != "true" ]; then
+    echo "vault still locked"
+    return
+  fi
+  if [ "$eth_count" -lt "$EXPECTED_ETH_TOTAL" ]; then
+    echo "$eth_count ETH account(s), expected at least $EXPECTED_ETH_TOTAL"
+    return
+  fi
+
+  missing_count=$(missing_fixture_addresses "$accounts_json" | jq -r 'length')
+  if [ "$missing_count" != "0" ]; then
+    echo "$missing_count expected fixture address(es) missing"
+    return
+  fi
+
+  echo "ready"
+}
+
+wallet_state_ready() {
+  [ "$(wallet_state_issue "$1")" = "ready" ]
+}
+
+wallet_fixture_present() {
+  local accounts_json="$1"
+  local ok eth_count missing_count
+  [ -n "$accounts_json" ] || return 1
+  ok=$(echo "$accounts_json" | jq -r '.ok // false' 2>/dev/null || echo false)
+  [ "$ok" = "true" ] || return 1
+  eth_count=$(echo "$accounts_json" | jq -r '.ethAccounts // 0' 2>/dev/null || echo 0)
+  [ "$eth_count" -ge "$EXPECTED_ETH_TOTAL" ] || return 1
+  missing_count=$(missing_fixture_addresses "$accounts_json" | jq -r 'length')
+  [ "$missing_count" = "0" ]
+}
+
+PRECHECK_ACCOUNTS=$(read_wallet_state || true)
+if wallet_state_ready "$PRECHECK_ACCOUNTS"; then
+  echo "Wallet fixture already valid; skipping wallet mutation."
+else
+
+wait_for_wallet_state_after_eval_timeout() {
+  local label="$1"
+  local rc="$2"
+  local elapsed=0
+  local interval=5
+  local last_accounts=""
+  local issue=""
+
+  echo "WARN: ${label} eval did not return (rc=$rc) before ${CDP_TIMEOUT}ms; validating app wallet state for up to ${WALLET_SETUP_SETTLE_TIMEOUT}s."
+  while [ "$elapsed" -le "$WALLET_SETUP_SETTLE_TIMEOUT" ]; do
+    last_accounts=$(read_wallet_state 2>/dev/null || true)
+    if wallet_state_ready "$last_accounts"; then
+      echo "Wallet state validated after ${label} eval timeout."
+      return 0
+    fi
+
+    issue=$(wallet_state_issue "$last_accounts")
+    [ "$elapsed" -eq 0 ] && echo "  Still waiting for fixture completion: $issue"
+    sleep "$interval"
+    elapsed=$((elapsed + interval))
+  done
+
+  echo "ERROR: ${label} eval failed or timed out (rc=$rc), and wallet state did not validate after ${WALLET_SETUP_SETTLE_TIMEOUT}s."
+  echo "Last observed state:"
+  if [ -n "$last_accounts" ]; then
+    echo "$last_accounts" | jq .
+  else
+    echo "  unavailable"
+  fi
+  return 1
+}
+
+# -- Check vault state --
+VAULT_STATE=$(cdp_eval "(function(){ var engine = globalThis.Engine; var ctx = engine && engine.context; var keyringController = ctx && ctx.KeyringController; if (!keyringController) return JSON.stringify({ready:false, hasVault:false, isUnlocked:false}); var v = keyringController.state || {}; return JSON.stringify({ready:true, hasVault: v.vault !== undefined && v.vault !== null, isUnlocked: keyringController.isUnlocked()}); })()")
+HAS_VAULT=$(echo "$VAULT_STATE" | jq -r '.hasVault')
+IS_UNLOCKED=$(echo "$VAULT_STATE" | jq -r '.isUnlocked')
+echo "Vault state: hasVault=$HAS_VAULT, isUnlocked=$IS_UNLOCKED"
+
+if [ "$HAS_VAULT" = "true" ]; then
+  if wallet_fixture_present "$PRECHECK_ACCOUNTS"; then
+    if [ "$IS_UNLOCKED" = "true" ]; then
+      echo "Wallet fixture already present; vault is unlocked. Skipping wallet mutation."
+    else
+      echo "Wallet fixture already present; unlocking existing vault without wallet mutation."
+      $CDP unlock "$PASSWORD" >/dev/null
+      for _ in $(seq 1 30); do
+        POST_UNLOCK_ACCOUNTS=$(read_wallet_state 2>/dev/null || true)
+        if wallet_state_ready "$POST_UNLOCK_ACCOUNTS"; then
+          echo "Existing fixture vault unlocked."
+          break
+        fi
+        sleep 1
+      done
+      if ! wallet_state_ready "${POST_UNLOCK_ACCOUNTS:-}"; then
+        echo "WARN: existing fixture vault did not validate after unlock; falling back to fixture apply."
+      fi
+    fi
+  fi
+
+  if wallet_state_ready "${POST_UNLOCK_ACCOUNTS:-$PRECHECK_ACCOUNTS}"; then
+    :
+  else
+  # Do NOT unlock here with a bare KeyringController.submitPassword(): that
+  # bypasses the real auth flow (multichain init + dispatchLogin/password state)
+  # and can leave Redux/auth state stale. applyWalletFixture tries the real
+  # Authentication.unlockWallet() path first, then recovers interrupted fixture
+  # state with a keyring fallback inside AgenticService.
+  if [ "$IS_UNLOCKED" = "true" ]; then
+    echo "Vault already unlocked."
+  else
+    echo "Vault locked — applyWalletFixture will unlock via auth flow with fixture recovery fallback."
+  fi
+
+  echo "Applying fixture accounts/names to existing vault..."
+  set +e
+  APPLY_RESULT=$(cdp_eval_async "(function(){ var fixture = JSON.parse($ESCAPED_FIXTURE); if (!globalThis.__AGENTIC__ || typeof globalThis.__AGENTIC__.applyWalletFixture !== 'function') { return JSON.stringify({ok:false, error:'__AGENTIC__.applyWalletFixture is not installed; reload the app from Metro'}); } return globalThis.__AGENTIC__.applyWalletFixture(fixture).then(function(r){ return JSON.stringify(r); }).catch(function(e){ return JSON.stringify({ok:false, error: e.message || String(e)}); }); })()")
+  APPLY_RC=$?
+  set -e
+  if [ "$APPLY_RC" -ne 0 ] || [ -z "$APPLY_RESULT" ]; then
+    wait_for_wallet_state_after_eval_timeout "applyWalletFixture" "$APPLY_RC" || exit 1
+    echo "Wallet fixture apply result recovered from validated wallet state."
+  else
+    APPLY_OK=$(echo "$APPLY_RESULT" | jq -r '.ok')
+    if [ "$APPLY_OK" != "true" ]; then
+      APPLY_ERR=$(echo "$APPLY_RESULT" | jq -r '.error // "unknown error"')
+      echo "ERROR: applyWalletFixture failed — $APPLY_ERR"
+      exit 1
+    fi
+    echo "Wallet fixture apply result:"
+    echo "$APPLY_RESULT" | jq -r '.accounts[]? | "  \(.name): \(.address)"'
+  fi
+  fi
+else
+  # -- Call AgenticService.setupWallet() on fresh app only --
+  echo "Calling __AGENTIC__.setupWallet()..."
+
+  set +e
+  SETUP_RESULT=$(cdp_eval_async "(function(){ var fixture = JSON.parse($ESCAPED_FIXTURE); if (!globalThis.__AGENTIC__ || typeof globalThis.__AGENTIC__.setupWallet !== 'function') { return JSON.stringify({ok:false, error:'__AGENTIC__.setupWallet is not installed'}); } return globalThis.__AGENTIC__.setupWallet(fixture).then(function(r){ return JSON.stringify(r); }).catch(function(e){ return JSON.stringify({ok:false, error: e.message || String(e)}); }); })()")
+  SETUP_RC=$?
+  set -e
+  if [ "$SETUP_RC" -ne 0 ] || [ -z "$SETUP_RESULT" ]; then
+    wait_for_wallet_state_after_eval_timeout "setupWallet" "$SETUP_RC" || exit 1
+    echo "Wallet setup result recovered from validated wallet state."
+  else
+    SETUP_OK=$(echo "$SETUP_RESULT" | jq -r '.ok')
+    if [ "$SETUP_OK" != "true" ]; then
+      SETUP_ERR=$(echo "$SETUP_RESULT" | jq -r '.error // "unknown error"')
+      SETUP_STEP=$(echo "$SETUP_RESULT" | jq -r '.step // "unknown-step"')
+      echo "ERROR: setupWallet failed at ${SETUP_STEP} — $SETUP_ERR"
+      exit 1
+    fi
+
+    echo "Wallet setup result:"
+    echo "$SETUP_RESULT" | jq -r '.accounts[]? | "  \(.name): \(.address)"'
+  fi
+  sleep 2
+fi
+fi
+
+# -- Ask the app to leave auth/onboarding after unlock.
+# HomeNav matches the product auth reset path, but some warm/onboarding states
+# land on intermediate post-onboarding screens. Follow with WalletView so the
+# harness proves the user-visible unlocked wallet, not just a populated vault.
+$CDP navigate HomeNav >/dev/null 2>&1 || true
+sleep 1
+$CDP navigate WalletView >/dev/null 2>&1 || true
+sleep 1
+if [ -n "$FIRST_EXPECTED_ADDRESS" ]; then
+  cdp_eval "(function(){ try { if (globalThis.__AGENTIC__ && typeof globalThis.__AGENTIC__.switchAccount === 'function') { return JSON.stringify(globalThis.__AGENTIC__.switchAccount('$FIRST_EXPECTED_ADDRESS')); } return JSON.stringify({switched:false, error:'__AGENTIC__.switchAccount unavailable'}); } catch (e) { return JSON.stringify({switched:false, error:e && (e.message || String(e))}); } })()" >/dev/null 2>&1 || true
+fi
+
+# -- Summary + hard validation --
+ACCOUNTS=$(read_wallet_state)
+ACCOUNTS_OK=$(echo "$ACCOUNTS" | jq -r '.ok // false')
+if [ "$ACCOUNTS_OK" != "true" ]; then
+  echo "ERROR: Unable to read wallet state after setupWallet"
+  echo "$ACCOUNTS" | jq .
+  exit 1
+fi
+TOTAL=$(echo "$ACCOUNTS" | jq -r '.total')
+ETH_COUNT=$(echo "$ACCOUNTS" | jq -r '.ethAccounts')
+UNLOCKED=$(echo "$ACCOUNTS" | jq -r '.unlocked')
+ROUTE_NAME=$(echo "$ACCOUNTS" | jq -r '.routeName // empty')
+MISSING_ADDRESSES=$(missing_fixture_addresses "$ACCOUNTS")
+if [ "$UNLOCKED" != "true" ]; then
+  echo "ERROR: Wallet setup did not unlock the vault"
+  echo "$ACCOUNTS" | jq .
+  exit 1
+fi
+if [ "$ETH_COUNT" -lt "$EXPECTED_ETH_TOTAL" ]; then
+  echo "ERROR: Wallet setup produced $ETH_COUNT ETH account(s), expected at least $EXPECTED_ETH_TOTAL from fixture"
+  echo "$ACCOUNTS" | jq .
+  exit 1
+fi
+if [ "$(echo "$MISSING_ADDRESSES" | jq 'length')" != "0" ]; then
+  echo "ERROR: Wallet setup did not import/unlock the expected fixture account(s)"
+  echo "Missing addresses:"
+  echo "$MISSING_ADDRESSES" | jq -r '.[] | "  " + .'
+  echo "Actual wallet state:"
+  echo "$ACCOUNTS" | jq .
+  exit 1
+fi
+case "$ROUTE_NAME" in
+  Login|Onboarding|ExperienceEnhancer|FoxLoader|"")
+    echo "ERROR: Wallet setup did not reach the unlocked wallet UI (route=${ROUTE_NAME:-empty})"
+    echo "$ACCOUNTS" | jq .
+    exit 1
+    ;;
+esac
+echo ""
+echo "=== Wallet Ready ==="
+echo "Route: ${ROUTE_NAME:-unknown}"
+echo "Unlocked: $UNLOCKED"
+echo "Accounts: $ETH_COUNT ETH (${TOTAL} total)"
+echo "$ACCOUNTS" | jq -r '.first3[] | "  \(.name): \(.address)"'
+echo "Selected:"
+echo "$ACCOUNTS" | jq -r '.selected | "  \(.name): \(.address)"'
+echo ""
+echo "Done."
+exit 0

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

@@ -0,0 +1,11 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { assertOrders } from './perps.mjs';
+
+function expectedOpen(input) {
+  const state = String(input.node?.state ?? input.node?.orders ?? 'open').toLowerCase();
+  if (state === 'open' || state === 'present') return true;
+  if (state === 'none' || state === 'closed' || state === 'absent') return false;
+  throw new Error(`metamask.perps.assert_orders received unsupported state: ${state}`);
+}
+
+runAdapter((input) => assertOrders(input, expectedOpen(input)));

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

@@ -0,0 +1,11 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { assertPositions } from './perps.mjs';
+
+function expectedOpen(input) {
+  const state = String(input.node?.state ?? input.node?.position ?? 'open').toLowerCase();
+  if (state === 'open' || state === 'present') return true;
+  if (state === 'none' || state === 'closed' || state === 'absent') return false;
+  throw new Error(`metamask.perps.assert_positions received unsupported state: ${state}`);
+}
+
+runAdapter((input) => assertPositions(input, expectedOpen(input)));

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

@@ -0,0 +1,8 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { assertOrders, closeOrders } from './perps.mjs';
+
+runAdapter(async (input) => {
+  const close = await closeOrders(input);
+  const assertion = await assertOrders(input, false);
+  return { ...assertion, close };
+});

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

@@ -0,0 +1,8 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { assertPositions, closePositions } from './perps.mjs';
+
+runAdapter(async (input) => {
+  const close = await closePositions(input);
+  const assertion = await assertPositions(input, false);
+  return { ...assertion, close };
+});

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

@@ -0,0 +1,4 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { ensureOrders } from './perps.mjs';
+
+runAdapter(ensureOrders);

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

@@ -0,0 +1,4 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { ensurePositions } from './perps.mjs';
+
+runAdapter(ensurePositions);