@deeeed/metamask-harness 0.80.0 → 0.82.0

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

@@ -6,7 +6,8 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 
 import { walletFixturePath } from '../../harness-exports.mjs';
-import { readFixtureAccounts } from '../wallet/_fixture-accounts.mjs';
+import { readFixtureAccounts } from '../../shared/wallet/fixture-accounts.mjs';
+import { createRewardsClient, rewardsApiUrl } from './_rewards.mjs';
 
 function controllerEntry(projectRoot) {
   return pathToFileURL(path.join(projectRoot, 'packages/perps-controller/src/index.ts')).href;
@@ -70,7 +71,7 @@ function buildInfrastructure(stubbed, input, rewardsSource) {
     ...(terminalApi ? { terminalApi } : {}),
     rewards: {
       getPerpsDiscountForAccount: (caipAccountId, baseFeeBips) =>
-        rewardsDiscount(rewardsSource.messenger, caipAccountId, baseFeeBips),
+        rewardsSource.messenger.call(REWARDS_DISCOUNT_ACTION, caipAccountId, baseFeeBips),
     },
   };
 }
@@ -79,28 +80,19 @@ function buildInfrastructure(stubbed, input, rewardsSource) {
 //
 // 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".
+// mobile mobileInfrastructure). Core has no RewardsController, so the headless
+// wallet registers one: the rewards client (_rewards.mjs) asks the rewards API
+// for the selected fixture account, as Mobile's RewardsController does. A node's
+// rewards_discount_bips replaces that answer, to prove a discount the fixture
+// accounts (non-VIP) cannot get from the backend.
 //
 // 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.
+// getNetworkClientById), so the wallet also answers those with the network a
+// fresh client wallet starts on, Ethereum mainnet.
 
 const REWARDS_DISCOUNT_ACTION = 'RewardsController:getPerpsDiscountForAccount';
 
-async function rewardsDiscount(rootMessenger, caipAccountId, baseFeeBips) {
-  if (!rootMessenger) return null;
-  try {
-    return await rootMessenger.call(REWARDS_DISCOUNT_ACTION, caipAccountId, baseFeeBips);
-  } catch (error) {
-    if (String(error?.message ?? '').includes(`${REWARDS_DISCOUNT_ACTION} has not been registered`)) return null;
-    throw error;
-  }
-}
 
 /**
  * The rewards discount a node supplies, in basis points (0-10000), or undefined.
@@ -119,9 +111,13 @@ export function requestedRewardsDiscountBips(input) {
 
 const REWARDS_NETWORK_ACTIONS = ['NetworkController:getState', 'NetworkController:getNetworkClientById'];
 
-function registerRewardsHandler(rootMessenger, childMessenger, discountBips) {
-  if (discountBips === undefined) return;
-  rootMessenger.registerActionHandler(REWARDS_DISCOUNT_ACTION, async () => discountBips);
+function registerRewardsHandler(rootMessenger, childMessenger, discountBips, rewardsClient) {
+  rootMessenger.registerActionHandler(
+    REWARDS_DISCOUNT_ACTION,
+    discountBips === undefined
+      ? (caipAccountId, baseFeeBips) => rewardsClient.getPerpsDiscountForAccount(caipAccountId, baseFeeBips)
+      : async () => discountBips,
+  );
   rootMessenger.registerActionHandler('NetworkController:getState', () => ({
     selectedNetworkClientId: 'mainnet',
   }));
@@ -228,11 +224,6 @@ async function resolveSignerFromFixture(input) {
   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;
 
 /**
@@ -286,7 +277,8 @@ export function requireRuntimeExport(moduleNamespace, exportName, sourceLabel) {
 export async function getCoreController(input) {
   const projectRoot = input.context?.projectRoot;
   if (!projectRoot) throw new Error('core adapter requires context.projectRoot.');
-  const accountAddress = await requireAccountAddress(input);
+  const selected = await selectAccount(input);
+  const accountAddress = selected.address;
   const network = resolveNetwork(input);
   const terminalApi = resolveTerminalApi(input);
   const terminalApiKey = JSON.stringify(terminalApi ?? null);
@@ -341,7 +333,10 @@ export async function getCoreController(input) {
     parent: rootMessenger,
   });
   registerSelectedAccountHandler(rootMessenger, messenger, accountAddress);
-  registerRewardsHandler(rootMessenger, messenger, rewardsDiscountBips);
+  // An address outside the fixture has no signer, so the client answers null:
+  // no subscription, as on Mobile for an account that never signed in.
+  const rewardsClient = createRewardsClient({ signer: selected.signer, baseUrl: rewardsApiUrl() });
+  registerRewardsHandler(rootMessenger, messenger, rewardsDiscountBips, rewardsClient);
   rewardsSource.messenger = rootMessenger;
 
   // Default testnet. Mainnet only on explicit node.network: "mainnet" — mainnet
@@ -386,6 +381,7 @@ export async function getCoreController(input) {
     accountAddress,
     terminalApiKey,
     rewardsDiscountBips,
+    rewardsClient,
   };
   return { ...cached, accountAddress };
 }

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

@@ -0,0 +1,186 @@
+// Headless rewards client for the core Perps controller's `rewards` dependency.
+// It makes the calls Mobile's RewardsController makes to answer
+// getPerpsDiscountForAccount: public opt-in check, mobile-login with a
+// personal_sign over `rewards,<address>,<unix seconds>`, then GET /vip/fees.
+// The session token stays in memory and is never printed. Mobile also gates the
+// call on its remote VIP feature flag (off: null); core has no remote flags, so
+// the client answers as Mobile does with VIP enabled.
+
+// Mobile's default outside production builds (METAMASK_ENVIRONMENT=dev on farm
+// slots), from AppConstants.REWARDS_API_URL.UAT.
+export const DEFAULT_REWARDS_API_URL = 'https://rewards.uat-api.cx.metamask.io';
+
+const CLIENT_ID = 'mm-harness-core';
+
+// Mobile's rewards-data-service DEFAULT_REQUEST_TIMEOUT_MS. A stalled backend
+// must not hold a fee calculation (and the order behind it) open.
+const REQUEST_TIMEOUT_MS = 10_000;
+
+export function rewardsApiUrl(env = process.env) {
+  return (env.CORE_PERPS_REWARDS_API_URL?.trim() || DEFAULT_REWARDS_API_URL).replace(/\/+$/u, '');
+}
+
+/**
+ * Mobile's VIP math (RewardsController #getVipPerpsDiscountBips): the backend
+ * returns an absolute builder fee, converted to a discount off `baseFeeBips`.
+ *
+ * @param vipFees - The /vip/fees body.
+ * @param baseFeeBips - The perps MetaMask builder base fee in bips.
+ * @returns Discount bips; 0 without a VIP fee; null for an unusable fee.
+ */
+export function vipDiscountBips(vipFees, baseFeeBips) {
+  if (!vipFees?.fees || !(vipFees.vipTier > 0)) return 0;
+  const raw = vipFees.fees.hyperliquid?.builderFeeBips;
+  if (raw === undefined || raw === null) return 0;
+  const builderFeeBips = Number.parseFloat(raw);
+  if (!Number.isFinite(builderFeeBips) || builderFeeBips < 0) return null;
+  const discount = Math.round(10000 * (1 - builderFeeBips / baseFeeBips));
+  return discount >= 0 && discount <= 10000 ? discount : 0;
+}
+
+// An error response keeps only its status and the fields the client acts on:
+// the body itself may echo the request, credentials included, and controller
+// logs print error messages.
+class RewardsApiError extends Error {
+  constructor(method, route, status, body) {
+    super(`rewards API ${method} ${route} returned ${status}.`);
+    this.status = status;
+    const data = parseErrorBody(body);
+    this.invalidTimestamp = /Invalid timestamp/u.test(String(data?.message ?? ''));
+    this.serverTimestampMs = Number(data?.serverTimestamp);
+  }
+}
+
+function parseErrorBody(body) {
+  try {
+    return JSON.parse(body);
+  } catch (error) {
+    // A non-JSON error page carries no field the client acts on; the status
+    // already says what failed.
+    if (error instanceof SyntaxError) return null;
+    throw error;
+  }
+}
+
+/**
+ * @param options.signer - viem account of the selected fixture account, or null.
+ * @param options.baseUrl - Rewards API base URL.
+ * @param options.fetchImpl - fetch, injectable for tests.
+ * @param options.now - clock in ms, injectable for tests.
+ * @param options.timeoutMs - per-request deadline, headers and body included.
+ * @returns The `rewards` platform dependency plus `calls`, one entry per
+ * answered request, for action output.
+ */
+export function createRewardsClient({
+  signer,
+  baseUrl,
+  fetchImpl = fetch,
+  now = Date.now,
+  timeoutMs = REQUEST_TIMEOUT_MS,
+}) {
+  const calls = [];
+  let feesPromise;
+
+  async function request(method, route, { body, token } = {}) {
+    const response = await fetchImpl(`${baseUrl}${route}`, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        'rewards-client-id': CLIENT_ID,
+        ...(token ? { 'rewards-access-token': token } : {}),
+      },
+      ...(body ? { body: JSON.stringify(body) } : {}),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    const text = await response.text();
+    if (!response.ok) throw new RewardsApiError(method, route, response.status, text);
+    return JSON.parse(text);
+  }
+
+  async function login(address, timestamp, retried = false) {
+    const message = `rewards,${address},${timestamp}`;
+    const signature = await signer.signMessage({ message });
+    try {
+      return await request('POST', '/auth/mobile-login', { body: { account: address, timestamp, signature } });
+    } catch (error) {
+      // Mobile re-signs once with the server clock when the backend rejects ours.
+      if (
+        !(error instanceof RewardsApiError) || retried || !error.invalidTimestamp ||
+        !Number.isFinite(error.serverTimestampMs)
+      ) {
+        throw error;
+      }
+      return login(address, Math.floor(error.serverTimestampMs / 1000), true);
+    }
+  }
+
+  // Mobile's silent auth: skip login only when the public opt-in check says the
+  // account never opted in, and read a 401 from login as not opted in.
+  async function openSession(address) {
+    let optedIn;
+    try {
+      const status = await request('POST', '/public/rewards/ois', { body: { addresses: [address] } });
+      optedIn = status?.ois?.[0];
+    } catch (error) {
+      // Mobile logs in anyway when the opt-in check fails: login answers the
+      // same question. A failure to reach the backend at all still throws.
+      if (!(error instanceof RewardsApiError)) throw error;
+    }
+    if (optedIn === false) return { optedIn: false };
+    let sessionId;
+    try {
+      ({ sessionId } = await login(address, Math.floor(now() / 1000)));
+    } catch (error) {
+      if (error instanceof RewardsApiError && error.status === 401) return { optedIn: false };
+      throw error;
+    }
+    if (typeof sessionId !== 'string' || !sessionId) {
+      throw new Error('rewards API mobile-login returned no sessionId.');
+    }
+    return { optedIn: true, token: sessionId };
+  }
+
+  // One login and one /vip/fees read per process (Mobile caches the fees for
+  // five minutes; an action process is shorter). The token is fresh, so the
+  // 403 re-login Mobile needs for a stored token does not arise here.
+  async function vipFees(address) {
+    const session = await openSession(address);
+    if (!session.optedIn) return session;
+    return { optedIn: true, fees: await request('GET', '/vip/fees', { token: session.token }) };
+  }
+
+  async function getPerpsDiscountForAccount(caipAccountId, baseFeeBips) {
+    // Lowercase, as Mobile's internal accounts store EVM addresses; the backend
+    // matches addresses case-insensitively.
+    const address = String(caipAccountId).split(':')[2]?.toLowerCase();
+    const record = (entry) => {
+      calls.push({ caipAccountId, baseFeeBips, ...entry });
+      return entry.discountBips;
+    };
+    if (!(Number.isFinite(baseFeeBips) && baseFeeBips > 0)) {
+      return record({ discountBips: null, reason: 'invalid-base-fee' });
+    }
+    // Only the selected fixture account can sign in; any other account has no
+    // subscription here, which Mobile also answers with null.
+    if (!signer || address !== signer.address.toLowerCase()) {
+      return record({ discountBips: null, reason: 'no-signer-for-account' });
+    }
+    feesPromise ??= vipFees(address);
+    let result;
+    try {
+      result = await feesPromise;
+    } catch (error) {
+      // Not cached: the next fee calculation asks the backend again.
+      feesPromise = undefined;
+      throw error;
+    }
+    if (!result.optedIn) return record({ discountBips: null, reason: 'not-opted-in' });
+    return record({
+      discountBips: vipDiscountBips(result.fees, baseFeeBips),
+      vipTier: result.fees.vipTier,
+      builderFeeBips: result.fees.fees?.hyperliquid?.builderFeeBips ?? null,
+    });
+  }
+
+  return { getPerpsDiscountForAccount, calls };
+}

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

@@ -19,7 +19,7 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-async function waitForPositionsAbsent(controller, accountAddress, symbols, timeoutMs) {
+export async function waitForPositionsAbsent(controller, accountAddress, symbols, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   let positions = [];
   for (;;) {

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

@@ -13,7 +13,16 @@ import {
   redactPosition,
   runAdapter,
   selectedItems,
+  symbolForItem,
 } from './_controller.mjs';
+import { waitForPositionsAbsent } from './close_positions.mjs';
+import {
+  assertFlatBeforeRoundTrip,
+  assertHouseLimitPosition,
+  closeImmediatelyRequested,
+  requireHouseNotional,
+  requirePerpsOrderAllowed,
+} from '../../shared/perps/order-policy.mjs';
 
 // LIMIT orders (orderType=limit) place a RESTING order on the book instead of
 // filling: the provider sends tif=Gtc and uses the provided `price` verbatim
@@ -359,7 +368,7 @@ export async function placeOrder(input) {
   if (usdAmount === undefined) {
     throw new Error('metamask.perps.place_order requires amount=<usd> or notional=<usd>.');
   }
-  const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
+  const { controller, accountAddress, network, signerAddress } = await getCoreControllerWithSigner(input);
   if (side !== 'long' && side !== 'short') {
     throw new Error(
       `metamask.perps.place_order received invalid side: ${side} (expected long or short).`,
@@ -421,7 +430,37 @@ export async function placeOrder(input) {
     throw new Error(`metamask.perps.place_order received invalid leverage: ${leverage}.`);
   }
 
+  const closeImmediately = closeImmediatelyRequested(input.node);
+  const policy = await requirePerpsOrderAllowed({
+    network,
+    amount: usdAmount,
+    leverage,
+    orderType,
+    closeImmediately,
+    projectRoot: input.context?.projectRoot,
+    selectedAddress: signerAddress,
+  });
+  if (closeImmediately) {
+    assertFlatBeforeRoundTrip(
+      await controller.getPositions({ standalone: true, userAddress: accountAddress }),
+      symbol,
+      symbolForItem,
+      await controller.getOpenOrders({ standalone: true, userAddress: accountAddress }),
+    );
+  }
+
   const currentPrice = await currentMarketPrice(controller, symbol);
+  const houseNotional = requireHouseNotional({
+    network,
+    symbol,
+    amount: usdAmount,
+    leverage,
+    price: currentPrice,
+    szDecimals: network === 'mainnet'
+      ? (await controller.getMarkets({ symbols: [symbol] }))?.find((market) => market?.name === symbol)?.szDecimals
+      : null,
+    maxSlippageBps,
+  });
 
   const reduceOnly = optionalBooleanParam(
     input.node ?? {},
@@ -524,59 +563,86 @@ export async function placeOrder(input) {
     };
   }
 
-  const result = await controller.placeOrder(orderParams);
-  if (!result || result.success !== true) {
-    throw controllerRejection({
-      action: 'core placeOrder',
-      detail: `${symbol} (${orderType}), currentPrice=${currentPrice}${limitPrice ? `, limitPrice=${limitPrice}` : ''}`,
-      code: result?.error ?? 'unknown error',
-    });
+  // close_immediately started from a flat market (checked above), so a position
+  // in it after a failed placement is this order's: close it rather than leave it open.
+  const restsOnBook = orderType === 'limit' || isTriggerOrderType(orderType);
+  const placeAndVerify = async () => {
+    const result = await controller.placeOrder(orderParams);
+    if (!result || result.success !== true) {
+      throw controllerRejection({
+        action: 'core placeOrder',
+        detail: `${symbol} (${orderType}), currentPrice=${currentPrice}${limitPrice ? `, limitPrice=${limitPrice}` : ''}`,
+        code: result?.error ?? 'unknown error',
+      });
+    }
+
+    // For limit orders, confirm a RESTING open order exists (not a filled position);
+    // for market orders, confirm the position opened. Both read the real
+    // provider/exchange state (not the submit ack) before reporting success.
+    let matchingOrders = [];
+    let positions = [];
+    if (restsOnBook) {
+      matchingOrders = await waitForPlacedOrder(
+        controller,
+        accountAddress,
+        input,
+        {
+          orderId: result.orderId,
+          triggerOrderType: isTriggerOrderType(orderType) ? orderType : null,
+          triggerPrice,
+          limitPrice,
+          size: result.submittedSize ?? orderParams.size,
+          reduceOnly: orderParams.reduceOnly ?? false,
+        },
+        Number(optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 30000),
+      );
+    } else {
+      positions = await controller.getPositions({
+        standalone: true,
+        userAddress: accountAddress,
+      });
+    }
+    const matchingPositions = selectedItems(input, positions, 'position');
+
+    if (restsOnBook && matchingOrders.length === 0) {
+      throw new Error(
+        `core placeOrder (${orderType}) for ${symbol} reported success but no resting open order is visible (orderId=${result.orderId ?? 'null'}, limitPrice=${limitPrice}, triggerPrice=${triggerPrice}).`,
+      );
+    }
+    if (!restsOnBook && matchingPositions.length === 0) {
+      throw new Error(
+        `core placeOrder (market) for ${symbol} reported success but no matching position is visible (orderId=${result.orderId ?? 'null'}).`,
+      );
+    }
+    return { result, matchingOrders, matchingPositions };
+  };
+  let placed;
+  try {
+    placed = await placeAndVerify();
+  } catch (error) {
+    if (!closeImmediately) throw error;
+    throw await closeAfterFailedPlacement({ controller, accountAddress, symbol, maxSlippageBps, error });
   }
+  const { result, matchingOrders, matchingPositions } = placed;
 
-  // For limit orders, confirm a RESTING open order exists (not a filled position);
-  // for market orders, confirm the position opened. Both read the real
-  // provider/exchange state (not the submit ack) before reporting success.
-  const restsOnBook = orderType === 'limit' || isTriggerOrderType(orderType);
-  let matchingOrders = [];
-  let positions = [];
-  if (restsOnBook) {
-    matchingOrders = await waitForPlacedOrder(
+  const roundTrip = closeImmediately
+    ? await closeOpenedPosition({
       controller,
       accountAddress,
-      input,
-      {
-        orderId: result.orderId,
-        triggerOrderType: isTriggerOrderType(orderType) ? orderType : null,
-        triggerPrice,
-        limitPrice,
-        size: result.submittedSize ?? orderParams.size,
-        reduceOnly: orderParams.reduceOnly ?? false,
-      },
-      Number(optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 30000),
-    );
-  } else {
-    positions = await controller.getPositions({
-      standalone: true,
-      userAddress: accountAddress,
-    });
-  }
-  const matchingPositions = selectedItems(input, positions, 'position');
-
-  if (restsOnBook && matchingOrders.length === 0) {
-    throw new Error(
-      `core placeOrder (${orderType}) for ${symbol} reported success but no resting open order is visible (orderId=${result.orderId ?? 'null'}, limitPrice=${limitPrice}, triggerPrice=${triggerPrice}).`,
-    );
-  }
-  if (!restsOnBook && matchingPositions.length === 0) {
-    throw new Error(
-      `core placeOrder (market) for ${symbol} reported success but no matching position is visible (orderId=${result.orderId ?? 'null'}).`,
-    );
-  }
+      symbol,
+      network,
+      maxSlippageBps,
+      timeoutMs: Number(optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 30000),
+    })
+    : null;
 
   return {
     action: input.action,
     source: 'perps-controller-placeOrder',
     network,
+    policy: policy.lane,
+    ...(houseNotional ? { houseNotional } : {}),
+    ...(roundTrip ? { roundTrip } : {}),
     account: accountAddress,
     market: symbol,
     side,
@@ -602,4 +668,60 @@ export async function placeOrder(input) {
   };
 }
 
+// close_immediately: close the position this order opened and prove the market
+// is flat. On mainnet the opened position must be isolated 1x; it is closed
+// either way before that check fails the action.
+async function closeOpenedPosition({ controller, accountAddress, symbol, network, maxSlippageBps, timeoutMs }) {
+  const positions = await controller.getPositions({ standalone: true, userAddress: accountAddress });
+  const position = positions.find((candidate) => symbolForItem(candidate) === symbol);
+  if (!position) throw new Error(`close_immediately could not find the ${symbol} position the order opened.`);
+  let limitError = null;
+  if (network === 'mainnet') {
+    try {
+      assertHouseLimitPosition(position, symbol);
+    } catch (error) {
+      limitError = error;
+    }
+  }
+  const currentPrice = await currentMarketPrice(controller, symbol);
+  const result = await controller.closePosition({
+    symbol,
+    orderType: 'market',
+    currentPrice,
+    priceAtCalculation: currentPrice,
+    maxSlippageBps,
+    position,
+  });
+  const after = await waitForPositionsAbsent(controller, accountAddress, [symbol], timeoutMs);
+  if (result?.success !== true || after.some((candidate) => symbolForItem(candidate) === symbol)) {
+    throw new Error(
+      `close_immediately left the ${symbol} position open (${result?.error ?? 'still visible after close'}): ${JSON.stringify(redactPosition(position))}. Close it now.`,
+    );
+  }
+  if (limitError) throw limitError;
+  return { opened: redactPosition(position), closed: true, result };
+}
+
+async function closeAfterFailedPlacement({ controller, accountAddress, symbol, maxSlippageBps, error }) {
+  const message = error instanceof Error ? error.message : String(error);
+  let outcome;
+  try {
+    const positions = await controller.getPositions({ standalone: true, userAddress: accountAddress });
+    const position = positions.find((candidate) => symbolForItem(candidate) === symbol);
+    if (!position) {
+      outcome = `no ${symbol} position is open`;
+    } else {
+      const currentPrice = await currentMarketPrice(controller, symbol);
+      await controller.closePosition({ symbol, orderType: 'market', currentPrice, priceAtCalculation: currentPrice, maxSlippageBps, position });
+      const after = await waitForPositionsAbsent(controller, accountAddress, [symbol], 30000);
+      outcome = after.some((candidate) => symbolForItem(candidate) === symbol)
+        ? `the ${symbol} position is STILL OPEN after a close; close it now`
+        : `the ${symbol} position it opened was closed`;
+    }
+  } catch (closeError) {
+    outcome = `the ${symbol} position could not be checked or closed (${closeError instanceof Error ? closeError.message : String(closeError)}); check it now`;
+  }
+  return new Error(`${message} close_immediately: ${outcome}.`);
+}
+
 if (isDirectRun(import.meta.url)) runAdapter(placeOrder);

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

@@ -1,6 +1,6 @@
 // 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.
+// Read-only: nothing is placed, and the only signature is the rewards API login.
 
 import {
   configuredSymbols,
@@ -11,6 +11,7 @@ import {
   requestedRewardsDiscountBips,
   runAdapter,
 } from './_controller.mjs';
+import { rewardsApiUrl } from './_rewards.mjs';
 
 const ORDER_TYPES = ['market', 'limit'];
 
@@ -29,7 +30,7 @@ export async function quoteFees(input) {
     throw new Error(`metamask.perps.quote_fees amount must be a positive USD notional; got ${amount}.`);
   }
 
-  const { controller, accountAddress, network } = await getCoreController(input);
+  const { controller, accountAddress, network, rewardsClient } = await getCoreController(input);
   // calculateFees routes to the active provider, which init() brings up.
   await controller.init();
   const fees = await controller.calculateFees({
@@ -48,8 +49,10 @@ export async function quoteFees(input) {
     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',
+    // The node's discount, or the rewards API's answer for the account.
+    rewardsSource: requestedRewardsDiscountBips(input) === undefined ? 'rewards-api' : 'node.rewards_discount_bips',
+    // Each discount the controller asked the rewards API for (no token).
+    rewardsApi: { url: rewardsApiUrl(), calls: rewardsClient.calls },
     fees,
     proofPath: 'perps-controller-calculateFees',
   };

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

@@ -5,7 +5,7 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { pathToFileURL } from 'node:url';
 
 import { walletFixturePath } from '../../harness-exports.mjs';
-import { readFixtureAccounts } from './_fixture-accounts.mjs';
+import { readFixtureAccounts } from '../../shared/wallet/fixture-accounts.mjs';
 
 async function listAccounts(input) {
   const scope = input.node?.scope == null ? 'named' : String(input.node.scope);

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

@@ -11,6 +11,7 @@ import {
   trustedExternalMutationBudget,
   trustedExternalMutationIdentity,
   trustedExternalMutationPlanIsExact,
+  withFixturePolicyContext,
   withExternalMutationRecovery,
 } from './mutation-receipt.mjs';
 import { observeHyperliquidSubmission, placementReceiptSelection, requireCurrentVisibleFundingBalance, requirePerpsTradingContext } from './perps.mjs';
@@ -248,6 +249,10 @@ export async function closeVisiblePosition(input) {
   if (input.node?.confirm_live !== true) {
     throw new Error('metamask.perps.close_visible_position requires confirm_live=true.');
   }
+  ({ input } = await withFixturePolicyContext(input, page, {
+    operations: [{ operation: 'perps-close-position', amount: String(input.node?.funding_amount ?? '') }],
+    mainnetAllowed: true,
+  }));
   const fundingSide = String(input.node?.funding_side ?? '').toLowerCase();
   const fundingAmount = String(input.node?.funding_amount ?? '');
   const fundingPositionSize = String(input.node?.funding_position_size ?? '');

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

@@ -8,6 +8,7 @@ import {
   readPriorMutationReceipt,
   runGuardedExternalMutation,
   trustedExternalMutationIdentity,
+  withFixturePolicyContext,
   withExternalMutationRecovery,
 } from './mutation-receipt.mjs';
 import { requireCurrentVisibleFundingBalance, requirePerpsTradingContext } from './perps.mjs';
@@ -182,6 +183,9 @@ export async function editMargin(input) {
   if (input.node?.confirm_live !== true) {
     throw new Error('metamask.perps.edit_margin requires confirm_live=true for live submission.');
   }
+  ({ input } = await withFixturePolicyContext(input, page, {
+    operations: [{ operation: 'perps-margin-adjust', amount, count: 2 }],
+  }));
   const identity = trustedExternalMutationIdentity(input, page, {
     operation: 'perps-margin-adjust',
     authorizationCount: 2,