@deeeed/metamask-harness 0.17.5 → 0.19.0

package/library/actions/core/perps/_controller.mjs

@@ -90,12 +90,7 @@ function buildInfrastructure(stubbed) {
 // The fixture has the standard { accounts: [{ type, value, name }] } shape from
 // wallet-fixture.json.sample. The recipe node selects an account by name via
 // `account_name` (default "dev1"). The viem account derived from the fixture
-// entry is the authoritative source for both the address AND the signing key —
-// no separate MM_TEST_ACCOUNT_ADDRESS env var needed.
-//
-// Env-var fallback: if no fixture is present (e.g. direct CLI invocation),
-// MM_TEST_ACCOUNT_SRP / MM_TEST_ACCOUNT_PRIVATE_KEY + MM_TEST_ACCOUNT_ADDRESS
-// are still accepted for backward compatibility.
+// entry is the authoritative source for both the address and signing key.
 
 /**
  * Load wallet-fixture.json and return the named account entry.
@@ -155,26 +150,6 @@ function viemAccountFromFixtureEntry(entry) {
   return privateKeyToAccount(normalized);
 }
 
-// Env-var fallback constants (used only when wallet-fixture.json is absent).
-const SIGNER_PRIVATE_KEY_ENV = 'MM_TEST_ACCOUNT_PRIVATE_KEY';
-const SIGNER_MNEMONIC_ENV = 'MM_TEST_ACCOUNT_SRP';
-
-function signerFromEnv() {
-  const pk = process.env[SIGNER_PRIVATE_KEY_ENV]?.trim();
-  if (pk && pk.length > 0) {
-    const normalized = pk.startsWith('0x') ? pk : `0x${pk}`;
-    if (!/^0x[0-9a-fA-F]{64}$/u.test(normalized)) {
-      throw new Error(`${SIGNER_PRIVATE_KEY_ENV} is not a 32-byte hex private key.`);
-    }
-    return privateKeyToAccount(normalized);
-  }
-  const mnemonic = process.env[SIGNER_MNEMONIC_ENV]?.trim();
-  if (mnemonic && mnemonic.split(/\s+/u).length >= 12) {
-    return mnemonicToAccount(mnemonic, { addressIndex: 0 });
-  }
-  return null;
-}
-
 /**
  * Resolve the account name to use for signing.
  * Precedence: node.account_name → node.account (if not an address) → "dev1".
@@ -198,9 +173,7 @@ function resolveAccountName(input) {
 
 /**
  * Resolve the viem signer and EVM address for writes.
- * Primary: wallet-fixture.json account selected by name.
- * Fallback: MM_TEST_ACCOUNT_PRIVATE_KEY / MM_TEST_ACCOUNT_SRP env vars
- *           (requires MM_TEST_ACCOUNT_ADDRESS for address verification).
+ * The wallet fixture account selected by name is the only signing source.
  *
  * @param input - Adapter input (context.projectRoot, node.account_name).
  * @returns { account: ViemAccount, address: string }
@@ -209,7 +182,6 @@ async function resolveSignerFromFixture(input) {
   const projectRoot = input.context?.projectRoot;
   const accountName = resolveAccountName(input);
 
-  // Primary: fixture
   if (projectRoot) {
     const entry = await loadFixtureAccount(projectRoot, accountName);
     if (entry) {
@@ -218,32 +190,15 @@ async function resolveSignerFromFixture(input) {
     }
   }
 
-  // Fallback: env vars (no fixture present — direct CLI use)
-  const account = signerFromEnv();
-  if (!account) {
-    throw new Error(
-      `core perps writes require a wallet-fixture.json with account "${accountName}", ` +
-      `or env vars ${SIGNER_PRIVATE_KEY_ENV} / ${SIGNER_MNEMONIC_ENV} + MM_TEST_ACCOUNT_ADDRESS.`,
-    );
-  }
-  const envAddress = String(process.env.MM_TEST_ACCOUNT_ADDRESS ?? '').trim();
-  if (!/^0x[0-9a-fA-F]{40}$/u.test(envAddress)) {
-    throw new Error(
-      `Env-var fallback requires MM_TEST_ACCOUNT_ADDRESS (a 0x EVM address) to verify the signer.`,
-    );
-  }
-  if (account.address.toLowerCase() !== envAddress.toLowerCase()) {
-    throw new Error(
-      `Env-var signer derives ${account.address} but MM_TEST_ACCOUNT_ADDRESS is ${envAddress}; signatures would be invalid.`,
-    );
-  }
-  return { account, address: envAddress };
+  throw new Error(
+    `core perps writes require wallet-fixture.json account "${accountName}". ` +
+    `Next: run mm-harness fixtures set`,
+  );
 }
 
 /**
  * Resolve the account address for reads (no signing required).
- * Primary: wallet-fixture.json account selected by name (address derived from key).
- * Fallback: node.account / node.address / MM_TEST_ACCOUNT_ADDRESS env var.
+ * Prefer the wallet fixture account; explicit node addresses support read-only calls.
  */
 async function requireAccountAddress(input) {
   const projectRoot = input.context?.projectRoot;
@@ -261,13 +216,13 @@ async function requireAccountAddress(input) {
     }
   }
 
-  // Fallback: explicit address from node or env
+  // Read-only calls may name an address directly.
   const fromNode = input.node?.account ?? input.node?.address ?? input.node?.userAddress;
-  const address = String(fromNode ?? process.env.MM_TEST_ACCOUNT_ADDRESS ?? '').trim();
+  const address = String(fromNode ?? '').trim();
   if (!/^0x[0-9a-fA-F]{40}$/u.test(address)) {
     throw new Error(
       `core perps reads require a wallet-fixture.json with account "${accountName}", ` +
-      `or a 0x EVM address via node.account / MM_TEST_ACCOUNT_ADDRESS.`,
+      `or a 0x EVM address via node.account.`,
     );
   }
   return address;
@@ -291,6 +246,14 @@ export function resolveNetwork(input) {
   return raw;
 }
 
+export function requireRuntimeExport(moduleNamespace, exportName, sourceLabel) {
+  const value = moduleNamespace?.[exportName] ?? moduleNamespace?.default?.[exportName];
+  if (value === undefined) {
+    throw new Error(`${sourceLabel} does not export ${exportName}.`);
+  }
+  return value;
+}
+
 /**
  * Instantiate the PerpsController headlessly against the resolved core checkout.
  * Returns the controller plus the resolved read account address. Cached per
@@ -306,10 +269,25 @@ export async function getCoreController(input) {
     return { ...cached, accountAddress };
   }
 
-  const [{ PerpsController }, { Messenger, MOCK_ANY_NAMESPACE }] = await Promise.all([
+  const [controllerModule, messengerModule] = await Promise.all([
     import(controllerEntry(projectRoot)),
     import(messengerEntry(projectRoot)),
   ]);
+  const PerpsController = requireRuntimeExport(
+    controllerModule,
+    'PerpsController',
+    'Core perps-controller entrypoint',
+  );
+  const Messenger = requireRuntimeExport(
+    messengerModule,
+    'Messenger',
+    'Core messenger entrypoint',
+  );
+  const MOCK_ANY_NAMESPACE = requireRuntimeExport(
+    messengerModule,
+    'MOCK_ANY_NAMESPACE',
+    'Core messenger entrypoint',
+  );
 
   const stubbed = new Set();
   const infrastructure = buildInfrastructure(stubbed);
@@ -603,6 +581,15 @@ export function configuredSymbols(input, items) {
   return single ? [normalizeMarketSymbol(single)] : [];
 }
 
+export function requireExplicitSelection(input) {
+  const selector =
+    input.node?.selector && typeof input.node.selector === 'object' ? input.node.selector : {};
+  const mode = String(input.node?.mode ?? selector.mode ?? '').toLowerCase();
+  if (configuredSymbols(input, []).length === 0 && mode !== 'all') {
+    throw new Error(`${input.action} requires market=<symbol> or mode=all.`);
+  }
+}
+
 /**
  * Filter live items to the recipe-selected subset using the same market/side
  * vocabulary as the extension perps adapter. With no selector and no

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

@@ -2,6 +2,7 @@ import {
   getCoreController,
   isDirectRun,
   redactOrder,
+  requireExplicitSelection,
   runAdapter,
   selectedItems,
 } from './_controller.mjs';
@@ -12,13 +13,15 @@ import {
 // assert_positions.mjs.
 
 export function expectedOpen(input) {
-  const state = String(input.node?.state ?? input.node?.order ?? 'open').toLowerCase();
+  if (input.node?.state == null) throw new Error('metamask.perps.assert_orders requires state=open or state=none.');
+  const state = String(input.node.state).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}`);
 }
 
 export async function assertOrders(input, expectOpen = expectedOpen(input)) {
+  requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreController(input);
   const orders = await controller.getOpenOrders({
     standalone: true,
@@ -28,14 +31,10 @@ export async function assertOrders(input, expectOpen = expectedOpen(input)) {
   const hasOrder = matching.length > 0;
 
   if (expectOpen && !hasOrder) {
-    throw new Error(
-      `Expected selected Perps open order(s), but none matched ${JSON.stringify(input.node)}.`,
-    );
+    throw new Error('Expected at least one matching open Perps order, but found none.');
   }
   if (!expectOpen && hasOrder) {
-    throw new Error(
-      `Expected no selected Perps open orders, but ${matching.length} matched ${JSON.stringify(input.node)}.`,
-    );
+    throw new Error(`Expected no matching open Perps orders, but found ${matching.length}.`);
   }
 
   return {

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

@@ -2,6 +2,7 @@ import {
   getCoreController,
   isDirectRun,
   redactPosition,
+  requireExplicitSelection,
   runAdapter,
   selectedItems,
 } from './_controller.mjs';
@@ -11,13 +12,15 @@ import {
 // throws on mismatch so the recipe fails loudly.
 
 export function expectedOpen(input) {
-  const state = String(input.node?.state ?? input.node?.position ?? 'open').toLowerCase();
+  if (input.node?.state == null) throw new Error('metamask.perps.assert_positions requires state=open or state=none.');
+  const state = String(input.node.state).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}`);
 }
 
 export async function assertPositions(input, expectOpen = expectedOpen(input)) {
+  requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreController(input);
   const positions = await controller.getPositions({
     standalone: true,
@@ -27,14 +30,10 @@ export async function assertPositions(input, expectOpen = expectedOpen(input)) {
   const hasPosition = matching.length > 0;
 
   if (expectOpen && !hasPosition) {
-    throw new Error(
-      `Expected selected Perps position(s), but none matched ${JSON.stringify(input.node)}.`,
-    );
+    throw new Error('Expected at least one matching open Perps position, but found none.');
   }
   if (!expectOpen && hasPosition) {
-    throw new Error(
-      `Expected no selected Perps positions, but ${matching.length} matched ${JSON.stringify(input.node)}.`,
-    );
+    throw new Error(`Expected no matching open Perps positions, but found ${matching.length}.`);
   }
 
   return {

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

@@ -2,6 +2,7 @@ import {
   getCoreControllerWithSigner,
   isDirectRun,
   redactOrder,
+  requireExplicitSelection,
   runAdapter,
   selectedItems,
   symbolForItem,
@@ -37,6 +38,7 @@ async function waitForOrdersAbsent(controller, accountAddress, symbols, timeoutM
 }
 
 export async function closeOrders(input) {
+  requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
   const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
 

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

@@ -3,6 +3,7 @@ import {
   getCoreControllerWithSigner,
   isDirectRun,
   redactPosition,
+  requireExplicitSelection,
   runAdapter,
   selectedItems,
   symbolForItem,
@@ -36,6 +37,7 @@ async function waitForPositionsAbsent(controller, accountAddress, symbols, timeo
 }
 
 export async function closePositions(input) {
+  requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
   const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
   const maxSlippageBps = Number(

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

@@ -1,4 +1,4 @@
-import { getCoreController, isDirectRun, runAdapter, selectedItems } from './_controller.mjs';
+import { getCoreController, isDirectRun, requireExplicitSelection, runAdapter, selectedItems } from './_controller.mjs';
 import { assertOrders } from './assert_orders.mjs';
 import { closeOrders } from './close_orders.mjs';
 import { placeOrder } from './place_order.mjs';
@@ -8,7 +8,9 @@ import { placeOrder } from './place_order.mjs';
 // order state. Mirrors ensure_positions.mjs.
 
 export async function ensureOrders(input) {
-  const state = String(input.node?.state ?? input.node?.order ?? 'none').toLowerCase();
+  if (input.node?.state == null) throw new Error('metamask.perps.ensure_orders requires state=open or state=none.');
+  requireExplicitSelection(input);
+  const state = String(input.node.state).toLowerCase();
 
   if (state === 'none' || state === 'closed' || state === 'absent') {
     const close = await closeOrders(input);

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

@@ -1,4 +1,4 @@
-import { getCoreController, isDirectRun, runAdapter, selectedItems } from './_controller.mjs';
+import { getCoreController, isDirectRun, requireExplicitSelection, runAdapter, selectedItems } from './_controller.mjs';
 import { assertPositions } from './assert_positions.mjs';
 import { closePositions } from './close_positions.mjs';
 import { placeOrder } from './place_order.mjs';
@@ -8,7 +8,9 @@ import { placeOrder } from './place_order.mjs';
 // state. Mirrors the extension ensure_positions semantics.
 
 export async function ensurePositions(input) {
-  const state = String(input.node?.state ?? input.node?.position ?? 'none').toLowerCase();
+  if (input.node?.state == null) throw new Error('metamask.perps.ensure_positions requires state=open or state=none.');
+  requireExplicitSelection(input);
+  const state = String(input.node.state).toLowerCase();
 
   if (state === 'none' || state === 'closed' || state === 'absent') {
     const close = await closePositions(input);

package/library/actions/core/perps/place_order.mjs

@@ -81,12 +81,16 @@ function resolveLimitPrice(input, isBuy, mid) {
 }
 
 export async function placeOrder(input) {
-  const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
   const symbol = resolveSymbol(input);
-  const side = String(input.node?.side ?? 'long').toLowerCase();
+  if (input.node?.side == null) throw new Error('metamask.perps.place_order requires side=long or side=short.');
+  if (input.node?.amount == null && input.node?.notional == null) {
+    throw new Error('metamask.perps.place_order requires amount=<usd> or notional=<usd>.');
+  }
+  const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
+  const side = String(input.node.side).toLowerCase();
   const isBuy = side !== 'short';
   const orderType = resolveOrderType(input);
-  const usdAmount = String(input.node?.amount ?? input.node?.notional ?? '11');
+  const usdAmount = String(input.node.amount ?? input.node.notional);
   const leverage = Number(input.node?.leverage ?? 3);
   const maxSlippageBps = Number(
     input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300,

package/library/actions/core/perps/read_account.mjs

@@ -1,4 +1,4 @@
-import { getCoreController, runAdapter } from './_controller.mjs';
+import { getCoreController, isDirectRun, runAdapter } from './_controller.mjs';
 
 function redactAccount(account) {
   return {
@@ -27,4 +27,4 @@ export async function readAccount(input) {
   };
 }
 
-runAdapter(readAccount);
+if (isDirectRun(import.meta.url)) runAdapter(readAccount);

package/library/actions/core/perps/read_orders.mjs

@@ -1,5 +1,6 @@
 import {
   getCoreController,
+  isDirectRun,
   redactOrder,
   runAdapter,
   selectedItems,
@@ -24,4 +25,4 @@ export async function readOrders(input) {
   };
 }
 
-runAdapter(readOrders);
+if (isDirectRun(import.meta.url)) runAdapter(readOrders);

package/library/actions/core/perps/read_positions.mjs

@@ -1,5 +1,6 @@
 import {
   getCoreController,
+  isDirectRun,
   redactPosition,
   runAdapter,
   selectedItems,
@@ -24,4 +25,4 @@ export async function readPositions(input) {
   };
 }
 
-runAdapter(readPositions);
+if (isDirectRun(import.meta.url)) runAdapter(readPositions);

package/library/actions/core/wallet/list_accounts.mjs

@@ -0,0 +1,95 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+
+import { walletFixturePath } from '../../harness-exports.mjs';
+
+function fixtureAccountName(base, index, count) {
+  if (count === 1) return base || 'account1';
+  const match = /^(.*?)(\d+)$/u.exec(base || 'account1');
+  return match
+    ? `${match[1]}${Number(match[2]) + index}`
+    : `${base || 'account'}${index + 1}`;
+}
+
+function mnemonicCount(entry, fixturePath, index) {
+  const count = Number(entry.count ?? entry.numberOfAccounts ?? 1);
+  if (!Number.isInteger(count) || count < 1 || count > 100) {
+    throw new Error(`${fixturePath} accounts[${index}] mnemonic count must be an integer from 1 through 100.`);
+  }
+  return count;
+}
+
+function deriveFixtureAccounts(fixture, fixturePath) {
+  if (!Array.isArray(fixture.accounts) || fixture.accounts.length === 0) {
+    throw new Error(`wallet fixture at ${fixturePath} has no accounts array.`);
+  }
+  return fixture.accounts.flatMap((entry, fixtureIndex) => {
+    if (!entry || typeof entry !== 'object' || typeof entry.value !== 'string' || !entry.value.trim()) {
+      throw new Error(`${fixturePath} accounts[${fixtureIndex}] must contain a non-empty value.`);
+    }
+    if (entry.type === 'mnemonic') {
+      const count = mnemonicCount(entry, fixturePath, fixtureIndex);
+      return Array.from({ length: count }, (_, addressIndex) => {
+        const account = mnemonicToAccount(entry.value.trim(), { addressIndex });
+        return {
+          id: `fixture:${fixtureAccountName(entry.name, addressIndex, count)}`,
+          address: account.address,
+          name: fixtureAccountName(entry.name, addressIndex, count),
+          type: 'eip155:eoa',
+        };
+      });
+    }
+    if (entry.type === 'privateKey') {
+      const raw = entry.value.trim();
+      const normalized = raw.startsWith('0x') ? raw : `0x${raw}`;
+      if (!/^0x[0-9a-fA-F]{64}$/u.test(normalized)) {
+        throw new Error(`${fixturePath} accounts[${fixtureIndex}] privateKey is not a 32-byte hex key.`);
+      }
+      const account = privateKeyToAccount(normalized);
+      const name = entry.name || `account${fixtureIndex + 1}`;
+      return [{ id: `fixture:${name}`, address: account.address, name, type: 'eip155:eoa' }];
+    }
+    throw new Error(`${fixturePath} accounts[${fixtureIndex}].type must be mnemonic or privateKey.`);
+  });
+}
+
+async function listAccounts(input) {
+  const scope = input.node?.scope == null ? 'named' : String(input.node.scope);
+  if (scope !== 'selected' && scope !== 'named' && scope !== 'evm' && scope !== 'all') {
+    throw new Error('metamask.wallet.list_accounts scope must be selected, named, evm, or all.');
+  }
+  const fixturePath = walletFixturePath(input.context.projectRoot);
+  const fixture = JSON.parse(await readFile(fixturePath, 'utf8'));
+  const selectedName = String(input.node?.account_name ?? input.node?.account ?? 'dev1');
+  const accounts = deriveFixtureAccounts(fixture, fixturePath)
+    .map((account) => ({
+      ...account,
+      selected: account.name === selectedName,
+    }))
+    .filter((account) => {
+      if (scope === 'selected') return account.selected;
+      if (scope === 'all') return true;
+      if (scope === 'evm') return /^0x[0-9a-f]{40}$/iu.test(account.address);
+      return account.selected || Boolean(account.name.trim());
+    });
+  return {
+    action: input.action,
+    source: 'core-headless-wallet-fixture',
+    scope,
+    accounts,
+    count: accounts.length,
+    redacted: true,
+    selectionSource: 'explicit-controller-account-input',
+    proofPath: 'core-wallet-fixture-accounts',
+  };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const inputPath = process.argv[2] || process.env.METAMASK_RECIPE_ADAPTER_INPUT;
+  if (!inputPath) throw new Error('Adapter input path is required.');
+  const input = JSON.parse(await readFile(inputPath, 'utf8'));
+  const result = await listAccounts(input);
+  if (input.outputPath) await writeFile(input.outputPath, `${JSON.stringify(result, null, 2)}\n`);
+  else process.stdout.write(`${JSON.stringify(result)}\n`);
+}

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

@@ -2,7 +2,8 @@ import { runAdapter } from '../platform/cdp.mjs';
 import { assertOrders } from './perps.mjs';
 
 function expectedOpen(input) {
-  const state = String(input.node?.state ?? input.node?.orders ?? 'open').toLowerCase();
+  if (input.node?.state == null) throw new Error('metamask.perps.assert_orders requires state=open or state=none.');
+  const state = String(input.node.state).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}`);

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

@@ -2,7 +2,8 @@ import { runAdapter } from '../platform/cdp.mjs';
 import { assertPositions } from './perps.mjs';
 
 function expectedOpen(input) {
-  const state = String(input.node?.state ?? input.node?.position ?? 'open').toLowerCase();
+  if (input.node?.state == null) throw new Error('metamask.perps.assert_positions requires state=open or state=none.');
+  const state = String(input.node.state).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}`);

package/library/actions/extension/perps/perps.mjs

@@ -24,20 +24,39 @@ function configuredSymbols(input, items) {
   const explicit = input.node?.markets ?? input.node?.symbols ?? selector.markets ?? selector.symbols;
   if (Array.isArray(explicit) && explicit.length > 0) return uniqueSymbols(explicit.map(normalizeMarketSymbol));
   if (typeof explicit === 'string' && explicit.length > 0) return uniqueSymbols(explicit.split(',').map((part) => normalizeMarketSymbol(part.trim())).filter(Boolean));
-  return [marketSymbol(input)];
+  const single = input.node?.market ?? input.node?.symbol ?? selector.market ?? selector.symbol;
+  return single ? [normalizeMarketSymbol(single)] : [];
 }
 
-function selectedItems(input, items) {
-  const symbols = new Set(configuredSymbols(input, items));
+export function selectedItems(input, items) {
+  const requested = configuredSymbols(input, items);
+  const symbols = requested.length > 0 ? new Set(requested) : null;
   const selector = input.node?.selector && typeof input.node.selector === 'object' ? input.node.selector : {};
   const side = input.node?.side ?? selector.side;
   return items.filter((item) => {
-    if (!symbols.has(symbolForItem(item))) return false;
+    if (symbols && !symbols.has(symbolForItem(item))) return false;
     if (side && sideForItem(item) && sideForItem(item) !== String(side).toLowerCase()) return false;
     return true;
   });
 }
 
+function requireExplicitSelection(input) {
+  const node = input.node ?? {};
+  const selector = node.selector && typeof node.selector === 'object' ? node.selector : {};
+  const values = [node.market, node.symbol, node.markets, node.symbols, selector.market, selector.symbol, selector.markets, selector.symbols];
+  const selected = values.some((value) => Array.isArray(value) ? value.length > 0 : value != null && String(value).trim() !== '');
+  if (!selected && node.mode !== 'all' && selector.mode !== 'all') {
+    throw new Error(`${input.action} requires market=<symbol> or mode=all.`);
+  }
+}
+
+function requirePlaceOrderInputs(input) {
+  const node = input.node ?? {};
+  if (node.market == null && node.symbol == null) throw new Error(`${input.action} requires market=<symbol>.`);
+  if (node.side == null) throw new Error(`${input.action} requires side=long or side=short.`);
+  if (node.amount == null && node.notional == null) throw new Error(`${input.action} requires amount=<usd> or notional=<usd>.`);
+}
+
 export function positionSelectionState(input, positions) {
   return { hasMatching: selectedItems(input, positions).length > 0 };
 }
@@ -85,33 +104,37 @@ export async function readOrders(input) {
 }
 
 export async function assertPositions(input, expectedOpen) {
+  requireExplicitSelection(input);
   return withExtensionPage(input, async (page) => {
     const timeoutMs = Number(input.node?.timeout_ms ?? 0);
-    if (expectedOpen && timeoutMs > 0) {
-      await waitForPositionPresent(page, marketSymbol(input), timeoutMs);
+    const requested = configuredSymbols(input, []);
+    if (expectedOpen && timeoutMs > 0 && requested.length === 1) {
+      await waitForPositionPresent(page, requested[0], timeoutMs);
     }
     const state = await page.readPositions();
     if (!state.available) throw new Error('stateHooks.submitRequestToBackground is unavailable; cannot assert live Perps positions.');
     const matching = selectedItems(input, state.positions);
     const hasPosition = matching.length > 0;
-    if (expectedOpen && !hasPosition) throw new Error(`Expected selected Perps position(s), but none matched ${JSON.stringify(input.node)}.`);
-    if (!expectedOpen && hasPosition) throw new Error(`Expected no selected Perps positions, but ${matching.length} matched ${JSON.stringify(input.node)}.`);
+    if (expectedOpen && !hasPosition) throw new Error('Expected at least one matching open Perps position, but found none.');
+    if (!expectedOpen && hasPosition) throw new Error(`Expected no matching open Perps positions, but found ${matching.length}.`);
     return { action: input.action, expectedOpen, matchingCount: matching.length, positions: matching.map(redactPosition), source: state.source ?? 'perps-stream-manager-cache' };
   });
 }
 
 export async function assertOrders(input, expectedOpen) {
+  requireExplicitSelection(input);
   return withExtensionPage(input, async (page) => {
     const orders = await readOpenOrders(page);
     const matching = selectedItems(input, orders);
     const hasOrders = matching.length > 0;
-    if (expectedOpen && !hasOrders) throw new Error(`Expected selected Perps order(s), but none matched ${JSON.stringify(input.node)}.`);
-    if (!expectedOpen && hasOrders) throw new Error(`Expected no selected Perps orders, but ${matching.length} matched ${JSON.stringify(input.node)}.`);
+    if (expectedOpen && !hasOrders) throw new Error('Expected at least one matching open Perps order, but found none.');
+    if (!expectedOpen && hasOrders) throw new Error(`Expected no matching open Perps orders, but found ${matching.length}.`);
     return { action: input.action, expectedOpen, matchingCount: matching.length, orders: matching.map(redactOrder), source: 'perps-stream-manager-cache' };
   });
 }
 
 export async function closePositions(input) {
+  requireExplicitSelection(input);
   return withExtensionPage(input, async (page) => {
     const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
     const state = await page.readPositions();
@@ -147,6 +170,7 @@ export async function closePositions(input) {
 }
 
 export async function closeOrders(input) {
+  requireExplicitSelection(input);
   return withExtensionPage(input, async (page) => {
     const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
     const before = await readOpenOrders(page);
@@ -370,9 +394,10 @@ async function waitForPositionPresent(page, symbol, timeoutMs) {
 }
 
 export async function placeOrder(input) {
+  requirePlaceOrderInputs(input);
   const symbol = marketSymbol(input);
-  const side = String(input.node?.side ?? 'long').toLowerCase();
-  const amount = String(input.node?.amount ?? input.node?.notional ?? '11');
+  const side = String(input.node.side).toLowerCase();
+  const amount = String(input.node.amount ?? input.node.notional);
   const leverage = Number(input.node?.leverage ?? 3);
   return withExtensionPage(input, async (page) => {
     await page.navigateHash(`#/perps/market/${encodeURIComponent(symbol)}`);
@@ -427,7 +452,9 @@ export async function placeOrder(input) {
 }
 
 export async function ensurePositions(input) {
-  const state = String(input.node?.state ?? input.node?.position ?? 'none').toLowerCase();
+  if (input.node?.state == null) throw new Error('metamask.perps.ensure_positions requires state=open or state=none.');
+  requireExplicitSelection(input);
+  const state = String(input.node.state).toLowerCase();
   if (state === 'none' || state === 'closed' || state === 'absent') {
     const close = await closePositions(input);
     return { ...(await assertPositions(input, false)), close };
@@ -445,7 +472,9 @@ export async function ensurePositions(input) {
 }
 
 export async function ensureOrders(input) {
-  const state = String(input.node?.state ?? input.node?.orders ?? 'none').toLowerCase();
+  if (input.node?.state == null) throw new Error('metamask.perps.ensure_orders requires state=open or state=none.');
+  requireExplicitSelection(input);
+  const state = String(input.node.state).toLowerCase();
   if (state === 'none' || state === 'closed' || state === 'absent') {
     const close = await closeOrders(input);
     return { ...(await assertOrders(input, false)), close };

package/library/actions/extension/platform/cdp.mjs

@@ -397,6 +397,7 @@ async function launchExistingDistRuntime(input, port) {
   try {
     child = spawn(chrome, [
       `--user-data-dir=${profileDir}`,
+      ...(process.platform === 'darwin' ? ['--use-mock-keychain'] : []),
       '--remote-debugging-address=127.0.0.1',
       `--remote-debugging-port=${port}`,
       '--no-first-run',