@deeeed/metamask-harness 0.79.0 → 0.81.0

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

@@ -5,9 +5,9 @@ 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 '../../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;
@@ -27,7 +27,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 +69,159 @@ function buildInfrastructure(stubbed, input) {
       removeItem: async () => undefined,
     },
     ...(terminalApi ? { terminalApi } : {}),
-    rewards: { getPerpsDiscountForAccount: async () => null },
+    rewards: {
+      getPerpsDiscountForAccount: (caipAccountId, baseFeeBips) =>
+        rewardsSource.messenger.call(REWARDS_DISCOUNT_ACTION, 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 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), so the wallet also answers those with the network a
+// fresh client wallet starts on, Ethereum mainnet.
+
+const REWARDS_DISCOUNT_ACTION = 'RewardsController:getPerpsDiscountForAccount';
+
 
 /**
- * Load wallet-fixture.json and return the named account entry.
- * Returns null if the fixture file does not exist.
+ * The rewards discount a node supplies, in basis points (0-10000), or undefined.
  *
- * @param projectRoot - Absolute path to the project root.
- * @param accountName - The `name` field to match in fixture.accounts.
+ * @param input - Adapter input (node.rewards_discount_bips).
  */
-async function loadFixtureAccount(projectRoot, accountName) {
-  const fixturePath = walletFixturePath(projectRoot);
-  let raw;
-  try {
-    raw = await readFile(fixturePath, 'utf8');
-  } catch (error) {
-    if (error?.code === 'ENOENT') 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}".`,
-    );
+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 entry;
+  return bips;
 }
 
-/**
- * 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.
- */
-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.`,
-    );
-  }
-  return privateKeyToAccount(normalized);
+const REWARDS_NETWORK_ACTIONS = ['NetworkController:getState', 'NetworkController:getNetworkClientById'];
+
+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',
+  }));
+  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 });
 }
 
-/**
- * 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';
+// --- 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 };
 }
 
 let cached = null;
@@ -271,17 +277,20 @@ 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);
+  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 +316,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 +333,11 @@ export async function getCoreController(input) {
     parent: rootMessenger,
   });
   registerSelectedAccountHandler(rootMessenger, messenger, accountAddress);
+  // 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
   // reads are safe; mainnet mutations use real funds (gated in getCoreControllerWithSigner).
@@ -365,6 +380,8 @@ export async function getCoreController(input) {
     network,
     accountAddress,
     terminalApiKey,
+    rewardsDiscountBips,
+    rewardsClient,
   };
   return { ...cached, accountAddress };
 }
@@ -450,6 +467,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 +506,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 +537,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 +760,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 +785,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/_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 (;;) {