@deeeed/metamask-harness 0.78.0 → 0.80.0

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

@@ -5,9 +5,8 @@ import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 
-import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
-
 import { walletFixturePath } from '../../harness-exports.mjs';
+import { readFixtureAccounts } from '../wallet/_fixture-accounts.mjs';
 
 function controllerEntry(projectRoot) {
   return pathToFileURL(path.join(projectRoot, 'packages/perps-controller/src/index.ts')).href;
@@ -27,7 +26,7 @@ function messengerEntry(projectRoot) {
 // a persistent auto-reconnecting HyperLiquid WebSocket (HyperLiquidClientService
 // .initialize → wsTransport.ready()); these logs proved the order returns over
 // HTTP while that open socket kept the event loop alive — see disconnectAndExit.
-function buildInfrastructure(stubbed, input) {
+function buildInfrastructure(stubbed, input, rewardsSource) {
   const noop = () => undefined;
   const terminalApi = resolveTerminalApi(input);
   return {
@@ -69,153 +68,169 @@ function buildInfrastructure(stubbed, input) {
       removeItem: async () => undefined,
     },
     ...(terminalApi ? { terminalApi } : {}),
-    rewards: { getPerpsDiscountForAccount: async () => null },
+    rewards: {
+      getPerpsDiscountForAccount: (caipAccountId, baseFeeBips) =>
+        rewardsDiscount(rewardsSource.messenger, caipAccountId, baseFeeBips),
+    },
   };
 }
 
-// --- Account resolution from wallet-fixture.json ---
+// --- Rewards ---
 //
-// The core adapter resolves the signing account from the same wallet-fixture.json
-// that mobile/extension adapters use (recipeRuntimePath/wallet-fixture.json).
-// 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 signing key.
+// The clients answer the rewards dependency through the messenger's
+// RewardsController:getPerpsDiscountForAccount (extension perps-controller-init,
+// mobile mobileInfrastructure). Core has no RewardsController, so the handler
+// exists when the node supplies rewards_discount_bips, or when a driver
+// registers one on rootMessenger. Without a handler the answer is null: the
+// controller's "no discount known yet".
+//
+// The controller asks for the discount with the account's CAIP id, built from
+// the wallet's selected network (NetworkController:getState and
+// getNetworkClientById). A supplied discount therefore comes with the network a
+// fresh client wallet starts on, Ethereum mainnet; without one the headless
+// controller keeps having no NetworkController, as before.
 
-/**
- * Load wallet-fixture.json and return the named account entry.
- * Returns null if the fixture file does not exist.
- *
- * @param projectRoot - Absolute path to the project root.
- * @param accountName - The `name` field to match in fixture.accounts.
- */
-async function loadFixtureAccount(projectRoot, accountName) {
-  const fixturePath = walletFixturePath(projectRoot);
-  let raw;
+const REWARDS_DISCOUNT_ACTION = 'RewardsController:getPerpsDiscountForAccount';
+
+async function rewardsDiscount(rootMessenger, caipAccountId, baseFeeBips) {
+  if (!rootMessenger) return null;
   try {
-    raw = await readFile(fixturePath, 'utf8');
+    return await rootMessenger.call(REWARDS_DISCOUNT_ACTION, caipAccountId, baseFeeBips);
   } catch (error) {
-    if (error?.code === 'ENOENT') return null;
+    if (String(error?.message ?? '').includes(`${REWARDS_DISCOUNT_ACTION} has not been registered`)) return null;
     throw error;
   }
-  const fixture = JSON.parse(raw);
-  if (!Array.isArray(fixture.accounts) || fixture.accounts.length === 0) {
-    throw new Error(`wallet-fixture.json at ${fixturePath} has no accounts array.`);
-  }
-  const entry = fixture.accounts.find((a) => a?.name === accountName);
-  if (!entry) {
-    const names = fixture.accounts.map((a) => a?.name).filter(Boolean).join(', ');
-    throw new Error(
-      `wallet-fixture.json has no account named "${accountName}". Available: ${names}.`,
-    );
-  }
-  if (typeof entry.value !== 'string' || entry.value.trim().length === 0) {
-    throw new Error(`wallet-fixture.json account "${accountName}" has no value.`);
-  }
-  if (entry.type !== 'mnemonic' && entry.type !== 'privateKey') {
-    throw new Error(
-      `wallet-fixture.json account "${accountName}" type must be mnemonic or privateKey, got "${entry.type}".`,
-    );
-  }
-  return entry;
 }
 
 /**
- * Derive a viem account from a wallet-fixture account entry.
- * Mnemonics use BIP-44 account index 0 (MetaMask default derivation).
- * Private keys are accepted with or without a 0x prefix.
+ * The rewards discount a node supplies, in basis points (0-10000), or undefined.
+ *
+ * @param input - Adapter input (node.rewards_discount_bips).
  */
-function viemAccountFromFixtureEntry(entry) {
-  if (entry.type === 'mnemonic') {
-    return mnemonicToAccount(entry.value.trim(), { addressIndex: 0 });
-  }
-  // 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(
-      `wallet-fixture.json privateKey account "${entry.name}" is not a 32-byte hex key.`,
-    );
+export function requestedRewardsDiscountBips(input) {
+  const raw = optionalParam(input.node, 'rewards_discount_bips', 'rewardsDiscountBips');
+  if (raw === undefined) return undefined;
+  const bips = Number(raw);
+  if (!Number.isInteger(bips) || bips < 0 || bips > 10000) {
+    throw new Error(`rewards_discount_bips must be an integer from 0 through 10000; got ${raw}.`);
   }
-  return privateKeyToAccount(normalized);
+  return bips;
 }
 
-/**
- * Resolve the account name to use for signing.
- * Precedence: node.account_name → node.account (if not an address) → "dev1".
- */
-function resolveAccountName(input) {
-  const explicit = input.node?.account_name;
-  if (typeof explicit === 'string' && explicit.trim().length > 0) return explicit.trim();
-  // node.account can be either a name ("dev1") or an address ("0x...").
-  // If it looks like an address, ignore it here — the address will be derived
-  // from the fixture signer instead.
-  const nodeAccount = input.node?.account;
-  if (
-    typeof nodeAccount === 'string' &&
-    nodeAccount.trim().length > 0 &&
-    !/^0x[0-9a-fA-F]{40}$/u.test(nodeAccount.trim())
-  ) {
-    return nodeAccount.trim();
-  }
-  return 'dev1';
+const REWARDS_NETWORK_ACTIONS = ['NetworkController:getState', 'NetworkController:getNetworkClientById'];
+
+function registerRewardsHandler(rootMessenger, childMessenger, discountBips) {
+  if (discountBips === undefined) return;
+  rootMessenger.registerActionHandler(REWARDS_DISCOUNT_ACTION, async () => discountBips);
+  rootMessenger.registerActionHandler('NetworkController:getState', () => ({
+    selectedNetworkClientId: 'mainnet',
+  }));
+  rootMessenger.registerActionHandler('NetworkController:getNetworkClientById', (networkClientId) => {
+    if (networkClientId !== 'mainnet') throw new Error(`No network client with id ${networkClientId}.`);
+    return { configuration: { chainId: '0x1' } };
+  });
+  rootMessenger.delegate({ actions: REWARDS_NETWORK_ACTIONS, messenger: childMessenger });
+}
+
+// --- Account selection from wallet-fixture.json ---
+//
+// The core adapter reads the same wallet-fixture.json the mobile/extension
+// adapters use (recipeRuntimePath/wallet-fixture.json), expanded the way
+// list_accounts shows it (dev1..devN from a mnemonic with count N). A node
+// selects an account by name (`account_name`, or a non-address `account`) or by
+// 0x address (`account`, `address`, `userAddress`); dev1 when it names none.
+// An unknown name is refused, and an address is never swapped for another
+// account: one outside the fixture is read as given, and cannot sign.
+
+const ADDRESS_PATTERN = /^0x[0-9a-fA-F]{40}$/u;
+
+function trimmedString(value) {
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
 }
 
 /**
- * Resolve the viem signer and EVM address for writes.
- * The wallet fixture account selected by name is the only signing source.
+ * Resolve the account a node selects.
  *
- * @param input - Adapter input (context.projectRoot, node.account_name).
- * @returns { account: ViemAccount, address: string }
+ * @param input - Adapter input (context.projectRoot, node account fields).
+ * @returns { name, address, signer } — name and signer are null for an address outside the fixture.
  */
-async function resolveSignerFromFixture(input) {
+export async function selectAccount(input) {
+  const node = input.node ?? {};
   const projectRoot = input.context?.projectRoot;
-  const accountName = resolveAccountName(input);
+  const accountField = trimmedString(node.account);
+  const names = [trimmedString(node.account_name), accountField && !ADDRESS_PATTERN.test(accountField) ? accountField : undefined]
+    .filter((value) => value !== undefined);
+  const addresses = [node.account, node.address, node.userAddress]
+    .map(trimmedString)
+    .filter((value) => value !== undefined && ADDRESS_PATTERN.test(value));
+  if (new Set(names).size > 1) {
+    throw new Error(`core perps account selectors disagree: ${[...new Set(names)].join(' vs ')}; select one account.`);
+  }
+  if (new Set(addresses.map((value) => value.toLowerCase())).size > 1) {
+    throw new Error(`core perps account selectors disagree: ${addresses.join(' vs ')}; select one account.`);
+  }
+  const [name] = names;
+  const [address] = addresses;
+  const loaded = projectRoot ? await readFixtureAccounts(projectRoot) : null;
 
-  if (projectRoot) {
-    const entry = await loadFixtureAccount(projectRoot, accountName);
-    if (entry) {
-      const account = viemAccountFromFixtureEntry(entry);
-      return { account, address: account.address };
-    }
+  if (!loaded) {
+    if (!name && address) return { name: null, address, signer: null };
+    throw new Error(
+      `core perps account "${name ?? 'dev1'}" needs a wallet fixture at ` +
+      `${projectRoot ? walletFixturePath(projectRoot) : 'the checkout'}; ` +
+      'a read-only action can name a 0x address via account= instead.\n' +
+      'Next: run mm-harness fixtures set',
+    );
   }
 
-  throw new Error(
-    `core perps writes require wallet-fixture.json account "${accountName}". ` +
-    `Next: run mm-harness fixtures set`,
-  );
+  const available = loaded.accounts.map((account) => account.name).join(', ');
+  const byName = (wanted) => loaded.accounts.find((account) => account.name === wanted);
+  if (name) {
+    const matches = loaded.accounts.filter((account) => account.name === name);
+    if (matches.length > 1) {
+      throw new Error(`wallet fixture has ${matches.length} accounts named "${name}"; rename one in ${loaded.fixturePath}.`);
+    }
+    const [match] = matches;
+    if (!match) {
+      throw new Error(`wallet fixture has no account named "${name}". Available: ${available}.`);
+    }
+    if (address && match.address.toLowerCase() !== address.toLowerCase()) {
+      throw new Error(`fixture account "${name}" is ${match.address}, not ${address}; select one of them.`);
+    }
+    return match;
+  }
+  if (address) {
+    return loaded.accounts.find((account) => account.address.toLowerCase() === address.toLowerCase()) ??
+      { name: null, address, signer: null };
+  }
+  const fallback = byName('dev1');
+  if (!fallback) {
+    throw new Error(`wallet fixture has no account named "dev1" (the default). Available: ${available}; pass account=<name>.`);
+  }
+  return fallback;
 }
 
 /**
- * Resolve the account address for reads (no signing required).
- * Prefer the wallet fixture account; explicit node addresses support read-only calls.
+ * Resolve the viem signer and EVM address for writes: a fixture account,
+ * selected by name or by its address.
+ *
+ * @param input - Adapter input (context.projectRoot, node account fields).
+ * @returns { account: ViemAccount, address: string }
  */
-async function requireAccountAddress(input) {
-  const projectRoot = input.context?.projectRoot;
-  const accountName = resolveAccountName(input);
-
-  if (projectRoot) {
-    // No try/catch: loadFixtureAccount returns null when no fixture is present
-    // (the only recoverable case) and THROWS on a malformed / missing-named /
-    // empty / bad-type fixture. Those must fail loudly — swallowing them would
-    // let a read silently run against a different address than the writes use.
-    const entry = await loadFixtureAccount(projectRoot, accountName);
-    if (entry) {
-      const account = viemAccountFromFixtureEntry(entry);
-      return account.address;
-    }
-  }
-
-  // Read-only calls may name an address directly.
-  const fromNode = input.node?.account ?? input.node?.address ?? input.node?.userAddress;
-  const address = String(fromNode ?? '').trim();
-  if (!/^0x[0-9a-fA-F]{40}$/u.test(address)) {
+async function resolveSignerFromFixture(input) {
+  const selected = await selectAccount(input);
+  if (!selected.signer) {
     throw new Error(
-      `core perps reads require a wallet-fixture.json with account "${accountName}", ` +
-      `or a 0x EVM address via node.account.`,
+      `core perps writes sign with a wallet-fixture.json account; ${selected.address} is not one of them.\n` +
+      'Next: pass account=<fixture account name>, or an address listed by metamask.wallet.list_accounts',
     );
   }
-  return address;
+  return { account: selected.signer, address: selected.address };
+}
+
+/** The address a read acts on (no signing required). */
+async function requireAccountAddress(input) {
+  return (await selectAccount(input)).address;
 }
 
 let cached = null;
@@ -275,13 +290,15 @@ export async function getCoreController(input) {
   const network = resolveNetwork(input);
   const terminalApi = resolveTerminalApi(input);
   const terminalApiKey = JSON.stringify(terminalApi ?? null);
+  const rewardsDiscountBips = requestedRewardsDiscountBips(input);
 
   if (
     cached &&
     cached.projectRoot === projectRoot &&
     cached.network === network &&
     cached.accountAddress.toLowerCase() === accountAddress.toLowerCase() &&
-    cached.terminalApiKey === terminalApiKey
+    cached.terminalApiKey === terminalApiKey &&
+    cached.rewardsDiscountBips === rewardsDiscountBips
   ) {
     return { ...cached, accountAddress };
   }
@@ -307,7 +324,8 @@ export async function getCoreController(input) {
   );
 
   const stubbed = new Set();
-  const infrastructure = buildInfrastructure(stubbed, input);
+  const rewardsSource = {};
+  const infrastructure = buildInfrastructure(stubbed, input, rewardsSource);
 
   // Root + child messenger pair, mirroring the real app wiring (and the core
   // repo's own test harness in
@@ -323,6 +341,8 @@ export async function getCoreController(input) {
     parent: rootMessenger,
   });
   registerSelectedAccountHandler(rootMessenger, messenger, accountAddress);
+  registerRewardsHandler(rootMessenger, messenger, rewardsDiscountBips);
+  rewardsSource.messenger = rootMessenger;
 
   // Default testnet. Mainnet only on explicit node.network: "mainnet" — mainnet
   // reads are safe; mainnet mutations use real funds (gated in getCoreControllerWithSigner).
@@ -365,6 +385,7 @@ export async function getCoreController(input) {
     network,
     accountAddress,
     terminalApiKey,
+    rewardsDiscountBips,
   };
   return { ...cached, accountAddress };
 }
@@ -450,6 +471,9 @@ function registerSignerHandlers(rootMessenger, childMessenger, account) {
           'KeyringController:signTypedMessage received no typed data to sign.',
         );
       }
+      if (msgParams?.from && String(msgParams.from).toLowerCase() !== account.address.toLowerCase()) {
+        throw new Error(`KeyringController:signTypedMessage asked to sign for ${msgParams.from}; the selected account is ${account.address}.`);
+      }
       const { domain, types, primaryType, message } = typedData;
       // Strip the EIP712Domain entry if present: viem derives the domain types
       // from `domain` itself and rejects a duplicate EIP712Domain in `types`.
@@ -486,16 +510,16 @@ function registerSignerHandlers(rootMessenger, childMessenger, account) {
  * @returns { controller, projectRoot, network, accountAddress, signerAddress }.
  */
 export async function getCoreControllerWithSigner(input) {
-  const requestedName = input.node?.account_name ?? input.node?.account;
-  if (requestedName !== undefined && (
-    typeof requestedName !== 'string' || !requestedName.trim() ||
-    /^0x[0-9a-fA-F]{40}$/u.test(requestedName.trim())
-  )) {
+  // A selection given only as empty values must not quietly sign as dev1.
+  const selectors = ['account_name', 'account', 'address', 'userAddress'].filter((key) => input.node?.[key] != null);
+  if (selectors.length > 0 && selectors.every((key) => trimmedString(input.node[key]) === undefined)) {
     throw new Error(
-      'Core signing requires a non-empty fixture account name, not an address.\n' +
-      'Next: pass account=<reserved-fixture-name>; use addresses only for read-only actions.',
+      'Core signing requires a non-empty fixture account name or address.\n' +
+      'Next: pass account=<fixture account name>, or omit it to sign as dev1.',
     );
   }
+  // Refuse an account that cannot sign before any controller I/O.
+  const { account, address: signerAddress } = await resolveSignerFromFixture(input);
   const base = await getCoreController(input);
   const { controller, messenger: childMessenger, rootMessenger, accountAddress } = base;
   if (!rootMessenger || !childMessenger) {
@@ -517,7 +541,6 @@ export async function getCoreControllerWithSigner(input) {
     );
   }
 
-  const { account, address: signerAddress } = await resolveSignerFromFixture(input);
   registerSignerHandlers(rootMessenger, childMessenger, account);
 
   // Bring up the active provider. placeOrder/closePosition call
@@ -741,7 +764,7 @@ export function redactOrder(order) {
   };
 }
 
-// --- Adapter IO (mirrors the live-adapter contract in src/live-adapter-contract.ts) ---
+// --- Adapter IO (mirrors the live-adapter contract in @farmslot/recipe-cli/harness live-adapter-contract) ---
 
 async function loadInput() {
   const inputPath = process.argv[2] || process.env.METAMASK_RECIPE_ADAPTER_INPUT;
@@ -766,7 +789,7 @@ const fmtError = (e) => e?.stack ?? e?.message ?? String(e);
  * wsTransport.ready(). Orders themselves go over the HTTP ExchangeClient and
  * RETURN normally, but that open WebSocket keeps the Node event loop alive, so
  * the adapter process never exits. The runner only resolves on the child's
- * `close` event (src/live-adapter-contract.ts runProcess), so it waits out
+ * `close` event (@farmslot/recipe-cli/harness live-adapter-contract runProcess), so it waits out
  * live_adapter_timeout_ms, SIGTERMs the child, and reports `fail` even though
  * the trade filled and the output was computed. READ adapters use the
  * standalone HTTP-only InfoClient (utils/standaloneInfoClient) — no WebSocket —

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

@@ -0,0 +1,58 @@
+// Quote an order's fees through the controller's calculateFees: the preview the
+// clients show, with the rewards and subscription sources the fee resolver uses.
+// Read-only: nothing is signed or placed.
+
+import {
+  configuredSymbols,
+  getCoreController,
+  isDirectRun,
+  optionalBooleanParam,
+  optionalParam,
+  requestedRewardsDiscountBips,
+  runAdapter,
+} from './_controller.mjs';
+
+const ORDER_TYPES = ['market', 'limit'];
+
+export async function quoteFees(input) {
+  const symbols = configuredSymbols(input, []);
+  if (symbols.length !== 1) {
+    throw new Error(`metamask.perps.quote_fees requires exactly one market; got ${JSON.stringify(symbols)}.`);
+  }
+  const orderType = (optionalParam(input.node, 'order_type', 'orderType') ?? 'market').toLowerCase();
+  if (!ORDER_TYPES.includes(orderType)) {
+    throw new Error(`metamask.perps.quote_fees order_type must be ${ORDER_TYPES.join(' or ')}; got ${orderType}.`);
+  }
+  const isMaker = optionalBooleanParam(input.node, 'is_maker', 'isMaker');
+  const amount = optionalParam(input.node, 'amount');
+  if (amount !== undefined && !(Number(amount) > 0)) {
+    throw new Error(`metamask.perps.quote_fees amount must be a positive USD notional; got ${amount}.`);
+  }
+
+  const { controller, accountAddress, network } = await getCoreController(input);
+  // calculateFees routes to the active provider, which init() brings up.
+  await controller.init();
+  const fees = await controller.calculateFees({
+    symbol: symbols[0],
+    orderType,
+    ...(isMaker === undefined ? {} : { isMaker }),
+    ...(amount === undefined ? {} : { amount }),
+  });
+  return {
+    action: input.action,
+    source: 'perps-controller-calculateFees',
+    network,
+    account: accountAddress,
+    market: symbols[0],
+    orderType,
+    isMaker: isMaker ?? null,
+    amount: amount ?? null,
+    rewardsDiscountBips: requestedRewardsDiscountBips(input) ?? null,
+    // Core has no RewardsController: a discount here is the one the node supplied.
+    rewardsSource: requestedRewardsDiscountBips(input) === undefined ? null : 'node.rewards_discount_bips',
+    fees,
+    proofPath: 'perps-controller-calculateFees',
+  };
+}
+
+if (isDirectRun(import.meta.url)) runAdapter(quoteFees);

package/library/actions/core/wallet/_fixture-accounts.mjs

@@ -0,0 +1,69 @@
+// The checkout's wallet fixture expanded into accounts: a mnemonic entry with
+// count N yields N accounts at address indexes 0..N-1, named dev1..devN from the
+// entry's name. list_accounts shows them; Core Perps actions select from them.
+
+import { readFile } from 'node:fs/promises';
+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;
+}
+
+/**
+ * Expand fixture entries into `{ name, address, signer }`. `signer` is the viem
+ * account holding the key: use it to sign, never serialize it.
+ */
+export 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 signer = mnemonicToAccount(entry.value.trim(), { addressIndex });
+        return { name: fixtureAccountName(entry.name, addressIndex, count), address: signer.address, signer };
+      });
+    }
+    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 signer = privateKeyToAccount(normalized);
+      return [{ name: entry.name || `account${fixtureIndex + 1}`, address: signer.address, signer }];
+    }
+    throw new Error(`${fixturePath} accounts[${fixtureIndex}].type must be mnemonic or privateKey.`);
+  });
+}
+
+/** The checkout's fixture accounts, or null when it has no wallet fixture. */
+export async function readFixtureAccounts(projectRoot) {
+  const fixturePath = walletFixturePath(projectRoot);
+  let raw;
+  try {
+    raw = await readFile(fixturePath, 'utf8');
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  }
+  return { fixturePath, accounts: deriveFixtureAccounts(JSON.parse(raw), fixturePath) };
+}

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

@@ -3,72 +3,29 @@
 
 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.`);
-  });
-}
+import { readFixtureAccounts } from './_fixture-accounts.mjs';
 
 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 loaded = await readFixtureAccounts(input.context.projectRoot);
+  if (!loaded) {
+    throw new Error(
+      `no wallet fixture at ${walletFixturePath(input.context.projectRoot)}.\nNext: run mm-harness fixtures set`,
+    );
+  }
   const selectedName = String(input.node?.account_name ?? input.node?.account ?? 'dev1');
-  const accounts = deriveFixtureAccounts(fixture, fixturePath)
-    .map((account) => ({
-      ...account,
-      selected: account.name === selectedName,
+  const accounts = loaded.accounts
+    .map(({ name, address }) => ({
+      id: `fixture:${name}`,
+      address,
+      name,
+      type: 'eip155:eoa',
+      selected: name === selectedName,
     }))
     .filter((account) => {
       if (scope === 'selected') return account.selected;

package/library/actions/extension/feature_flags/state.mjs

@@ -15,7 +15,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { recipeRuntimeDir } from '../../harness-exports.mjs';
+import { recipeRuntimeDir } from '@farmslot/recipe-cli/harness';
 
 export const EXTENSION_SET_UNSUPPORTED_REASON =
   'The extension exposes no runtime remote feature-flag override RPC: RemoteFeatureFlagController.setFlagOverride is never registered in metamask-controller.js getApi(), so stateHooks.submitRequestToBackground cannot reach it. Overrides are pinned into the per-run dist snapshot manifest at launch.';

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

@@ -20,14 +20,8 @@ import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 
-import {
-  importRecipeHarnessRuntimeBrowserExtension,
-  importRecipeHarnessRuntimeCdp,
-  extensionIdPath,
-  recipeHarnessPath,
-  walletFixturePath,
-  captureActiveRecipeRecordingSnapshot,
-} from '../../harness-exports.mjs';
+import { captureActiveRecipeRecordingSnapshot, recipeHarnessPath } from '@farmslot/recipe-cli/harness';
+import { importRecipeHarnessRuntimeBrowserExtension, importRecipeHarnessRuntimeCdp, extensionIdPath, walletFixturePath } from '../../harness-exports.mjs';
 
 // Resolve the Farmslot harness through normal package dependencies by default.
 // Local Farmslot source is only a dev override handled by the harness paths module.