@deeeed/metamask-harness 0.80.0 → 0.82.0

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

@@ -1,40 +0,0 @@
-// Assert presence, absence or exact count of the selected venue positions,
-// polling up to timeout_ms for the expected state.
-
-import { isDirectRun, resolveAccountAddress, runAdapter } from '../platform/runtime.mjs';
-import { expectedOpen, pollUntil, readVenueState, resolveNetwork, selectItems } from './_venue.mjs';
-
-export async function assertPositions(input, deps = {}) {
-  const node = input.node ?? {};
-  const expectOpen = expectedOpen(node, 'metamask.perps.assert_positions');
-  const network = resolveNetwork(node);
-  const { name, address } = await resolveAccountAddress(input);
-  const expectCount = node.expect_count ?? node.expectCount;
-  const reached = (matching) => {
-    if (!expectOpen) return matching.length === 0;
-    return expectCount == null ? matching.length > 0 : matching.length === Number(expectCount);
-  };
-  const matching = await pollUntil(
-    async () => selectItems(node, (await readVenueState({ network, user: address, fetchImpl: deps.fetchImpl })).positions, 'position'),
-    reached,
-    node.timeout_ms,
-  );
-  if (!reached(matching)) {
-    const wanted = !expectOpen ? 'no' : expectCount == null ? 'at least one' : `exactly ${expectCount}`;
-    throw new Error(`Expected ${wanted} matching venue position(s), found ${matching.length}: ${JSON.stringify(matching)}`);
-  }
-  return {
-    action: input.action,
-    source: 'hyperliquid-info-clearinghouseState',
-    network,
-    account: address,
-    accountName: name,
-    expectedOpen: expectOpen,
-    matchingCount: matching.length,
-    expectedCount: expectCount == null ? null : Number(expectCount),
-    positions: matching,
-    proofPath: 'venue-clearinghouseState',
-  };
-}
-
-if (isDirectRun(import.meta.url)) runAdapter((input) => assertPositions(input));

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

@@ -1,26 +0,0 @@
-// Read the fixture account's Hyperliquid open orders for the selected markets.
-
-import { isDirectRun, resolveAccountAddress, runAdapter } from '../platform/runtime.mjs';
-import { filterOrderKind, readVenueState, resolveNetwork, selectItems } from './_venue.mjs';
-
-export async function readOrders(input, deps = {}) {
-  const node = input.node ?? {};
-  const network = resolveNetwork(node);
-  const { name, address } = await resolveAccountAddress(input);
-  const state = await readVenueState({ network, user: address, fetchImpl: deps.fetchImpl });
-  const matching = filterOrderKind(node, selectItems(node, state.orders, 'order'));
-  return {
-    action: input.action,
-    source: 'hyperliquid-info-frontendOpenOrders',
-    network,
-    account: address,
-    accountName: name,
-    count: state.orders.length,
-    matchingCount: matching.length,
-    orders: matching,
-    orderIds: matching.map((order) => order.orderId),
-    proofPath: 'venue-frontendOpenOrders',
-  };
-}
-
-if (isDirectRun(import.meta.url)) runAdapter((input) => readOrders(input));

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

@@ -1,25 +0,0 @@
-// Read the fixture account's Hyperliquid positions for the selected markets.
-
-import { isDirectRun, resolveAccountAddress, runAdapter } from '../platform/runtime.mjs';
-import { readVenueState, resolveNetwork, selectItems } from './_venue.mjs';
-
-export async function readPositions(input, deps = {}) {
-  const node = input.node ?? {};
-  const network = resolveNetwork(node);
-  const { name, address } = await resolveAccountAddress(input);
-  const state = await readVenueState({ network, user: address, fetchImpl: deps.fetchImpl });
-  const matching = selectItems(node, state.positions, 'position');
-  return {
-    action: input.action,
-    source: 'hyperliquid-info-clearinghouseState',
-    network,
-    account: address,
-    accountName: name,
-    count: state.positions.length,
-    matchingCount: matching.length,
-    positions: matching,
-    proofPath: 'venue-clearinghouseState',
-  };
-}
-
-if (isDirectRun(import.meta.url)) runAdapter((input) => readPositions(input));

package/library/actions/terminal/perps/read_snapshot.mjs

@@ -1,40 +0,0 @@
-// Snapshot the fixture account's venue state: positions, open orders, agents and
-// balances, optionally scoped to markets. Used for before/after comparison.
-
-import { isDirectRun, resolveAccountAddress, runAdapter } from '../platform/runtime.mjs';
-import { readVenueState, resolveNetwork, selectItems } from './_venue.mjs';
-
-const MARKET_KEYS = ['market', 'markets', 'symbol', 'symbols'];
-
-// The snapshot covers every market unless the node names some, through any of
-// the selector spellings selectItems accepts.
-export function snapshotSelector(raw = {}) {
-  const node = { ...raw };
-  const selector = node.selector && typeof node.selector === 'object' ? node.selector : {};
-  const named = MARKET_KEYS.some((key) => node[key] != null || selector[key] != null);
-  if (node.mode == null && selector.mode == null && !named) node.mode = 'all';
-  return node;
-}
-
-export async function readSnapshot(input, deps = {}) {
-  const node = snapshotSelector(input.node ?? {});
-  const network = resolveNetwork(node);
-  const { name, address } = await resolveAccountAddress(input);
-  const state = await readVenueState({ network, user: address, fetchImpl: deps.fetchImpl });
-  return {
-    action: input.action,
-    source: 'hyperliquid-info',
-    network,
-    account: address,
-    accountName: name,
-    at: new Date().toISOString(),
-    positions: selectItems(node, state.positions, 'position'),
-    orders: selectItems(node, state.orders, 'order'),
-    agents: state.agents,
-    accountValue: state.accountValue,
-    withdrawable: state.withdrawable,
-    proofPath: 'venue-snapshot',
-  };
-}
-
-if (isDirectRun(import.meta.url)) runAdapter((input) => readSnapshot(input));

package/library/actions/terminal/perps/revoke_agent.mjs

@@ -1,58 +0,0 @@
-// Lifecycle step (testnet; mainnet only with mainnet_confirmation=REAL_FUNDS): revoke the Web Terminal's Hyperliquid agent(s) for the
-// fixture account outside the UI (approveAgent to the zero address under the
-// same name, user-signed in Node), then assert none is left. The next UI write
-// must therefore ask the wallet for a fresh ApproveAgent.
-
-import { accountName, fixtureAccount, isDirectRun, readBrowserState, runAdapter } from '../platform/runtime.mjs';
-import { TERMINAL_AGENT_PREFIX, loadTargetHyperliquid, pollUntil, readVenueState, requireTestnet } from './_venue.mjs';
-
-const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-
-export function agentBaseName(name) {
-  return String(name).replace(/\s+valid_until\s+\d+$/u, '');
-}
-
-export function terminalAgents(agents, prefix = TERMINAL_AGENT_PREFIX) {
-  return agents.filter((agent) => agentBaseName(agent.name) === prefix);
-}
-
-export async function revokeAgent(input, deps = {}) {
-  const node = input.node ?? {};
-  const network = requireTestnet(node, 'metamask.perps.revoke_agent');
-  const prefix = node.agent_name ?? TERMINAL_AGENT_PREFIX;
-  const projectRoot = input.context?.projectRoot;
-  const name = accountName(input, await readBrowserState(projectRoot));
-  const account = deps.account ?? (await fixtureAccount(projectRoot, name));
-  const read = () => readVenueState({ network, user: account.address, fetchImpl: deps.fetchImpl });
-  const before = terminalAgents((await read()).agents, prefix);
-  const responses = [];
-  if (before.length > 0) {
-    const hl = deps.hl ?? (await loadTargetHyperliquid(projectRoot));
-    const exchange = new hl.ExchangeClient({ wallet: account, transport: new hl.HttpTransport({ isTestnet: network === 'testnet' }) });
-    for (const agentName of new Set(before.map((agent) => agentBaseName(agent.name)))) {
-      const response = await exchange.approveAgent({ agentAddress: ZERO_ADDRESS, agentName });
-      responses.push({ agentName, status: response?.status ?? null });
-    }
-  }
-  const after = await pollUntil(
-    async () => terminalAgents((await read()).agents, prefix),
-    (agents) => agents.length === 0,
-    node.timeout_ms ?? 20000,
-  );
-  if (after.length > 0) {
-    throw new Error(`terminal agent still approved after revoke: ${JSON.stringify(after.map((agent) => agent.address))}`);
-  }
-  return {
-    action: input.action,
-    source: 'hyperliquid-exchange-fixture-signer',
-    network,
-    account: account.address,
-    accountName: name,
-    revokedAgents: before.map((agent) => ({ name: agent.name, address: agent.address })),
-    responses,
-    remainingAgents: after.length,
-    proofPath: 'venue-extraAgents',
-  };
-}
-
-if (isDirectRun(import.meta.url)) runAdapter((input) => revokeAgent(input));

package/library/actions/terminal/perps/teardown_state.mjs

@@ -1,104 +0,0 @@
-// Testnet cleanup for one reserved market: cancel its open orders (or only the
-// listed order_ids) and close its position with a reduce-only IOC order, signed
-// in Node by the fixture account, then assert the requested end state. Testnet by
-// default; mainnet only with mainnet_confirmation=REAL_FUNDS. Refuses
-// account-wide selection.
-
-import { fixtureAccount, isDirectRun, readBrowserState, accountName, runAdapter } from '../platform/runtime.mjs';
-import {
-  filterOrderKind,
-  info,
-  loadTargetHyperliquid,
-  pollUntil,
-  readVenueState,
-  requireTestnet,
-  requestedMarkets,
-  selectItems,
-  venuePrice,
-} from './_venue.mjs';
-
-const CLOSE_SLIPPAGE = 0.05;
-
-function wantsNone(spec, label) {
-  if (spec == null) return false;
-  const state = String(spec.state ?? spec).toLowerCase();
-  if (state === 'none' || state === 'closed' || state === 'absent') return true;
-  throw new Error(`metamask.perps.teardown_state only converges ${label} to state=none, got ${state}.`);
-}
-
-export async function teardownState(input, deps = {}) {
-  const node = input.node ?? {};
-  const network = requireTestnet(node, 'metamask.perps.teardown_state');
-  const markets = requestedMarkets(node);
-  if (!markets) throw new Error('metamask.perps.teardown_state requires an explicit market; mode=all is refused.');
-  const closePositions = wantsNone(node.positions ?? { state: 'none' }, 'positions');
-  const cancelOrders = wantsNone(node.orders ?? { state: 'none' }, 'orders');
-  const projectRoot = input.context?.projectRoot;
-  const name = accountName(input, await readBrowserState(projectRoot));
-  const account = deps.account ?? (await fixtureAccount(projectRoot, name));
-  const user = account.address;
-  const read = () => readVenueState({ network, user, fetchImpl: deps.fetchImpl });
-  const before = await read();
-  const orders = cancelOrders ? filterOrderKind(node, selectItems(node, before.orders, 'order')) : [];
-  const positions = closePositions ? selectItems(node, before.positions, 'position') : [];
-  const actions = { canceledOrderIds: [], closedPositions: [], responses: [] };
-
-  if (orders.length > 0 || positions.length > 0) {
-    const hl = deps.hl ?? (await loadTargetHyperliquid(projectRoot));
-    const exchange = new hl.ExchangeClient({ wallet: account, transport: new hl.HttpTransport({ isTestnet: network === 'testnet' }) });
-    const [meta, mids] = await Promise.all([
-      info(network, { type: 'meta' }, deps.fetchImpl),
-      info(network, { type: 'allMids' }, deps.fetchImpl),
-    ]);
-    const assetOf = (market) => {
-      const index = meta.universe.findIndex((asset) => asset.name.toUpperCase() === market);
-      if (index < 0) throw new Error(`market ${market} is not in the ${network} perps universe.`);
-      return { index, szDecimals: meta.universe[index].szDecimals };
-    };
-    if (orders.length > 0) {
-      const response = await exchange.cancel({
-        cancels: orders.map((order) => ({ a: assetOf(order.market).index, o: Number(order.orderId) })),
-      });
-      actions.responses.push({ cancel: response?.response?.data ?? response });
-      actions.canceledOrderIds.push(...orders.map((order) => order.orderId));
-    }
-    for (const position of positions) {
-      const { index, szDecimals } = assetOf(position.market);
-      const mid = Number(mids[position.market]);
-      if (!Number.isFinite(mid)) throw new Error(`no ${network} mid price for ${position.market}.`);
-      const isBuy = position.side === 'short';
-      const price = venuePrice(mid * (isBuy ? 1 + CLOSE_SLIPPAGE : 1 - CLOSE_SLIPPAGE), szDecimals);
-      const response = await exchange.order({
-        orders: [{ a: index, b: isBuy, p: price, s: position.size, r: true, t: { limit: { tif: 'Ioc' } } }],
-        grouping: 'na',
-      });
-      actions.responses.push({ close: response?.response?.data ?? response });
-      actions.closedPositions.push({ market: position.market, side: position.side, size: position.size });
-    }
-  }
-
-  const done = (state) =>
-    (!cancelOrders || filterOrderKind(node, selectItems(node, state.orders, 'order')).length === 0) &&
-    (!closePositions || selectItems(node, state.positions, 'position').length === 0);
-  const after = await pollUntil(read, done, node.timeout_ms ?? 30000);
-  const remaining = {
-    orders: cancelOrders ? filterOrderKind(node, selectItems(node, after.orders, 'order')) : [],
-    positions: closePositions ? selectItems(node, after.positions, 'position') : [],
-  };
-  if (!done(after)) {
-    throw new Error(`testnet cleanup left state behind for ${[...markets].join(',')}: ${JSON.stringify(remaining)}`);
-  }
-  return {
-    action: input.action,
-    source: 'hyperliquid-exchange-fixture-signer',
-    network,
-    account: user,
-    accountName: name,
-    markets: [...markets],
-    ...actions,
-    remaining,
-    proofPath: 'venue-cleanup',
-  };
-}
-
-if (isDirectRun(import.meta.url)) runAdapter((input) => teardownState(input));

package/library/actions/terminal/ui/navigate.mjs

@@ -1,31 +0,0 @@
-// Navigate the terminal app tab to a product page (order/<MARKET>, portfolio)
-// or an explicit app path, and wait for the document to be ready.
-
-import { appOrigin, isDirectRun, runAdapter } from '../platform/runtime.mjs';
-import { withTerminalPage } from '../platform/page.mjs';
-
-export function pathFor(node = {}) {
-  if (typeof node.path === 'string' && node.path.startsWith('/')) return node.path;
-  const page = node.page == null ? 'order' : String(node.page);
-  if (page === 'order' || page === 'market') {
-    const market = String(node.market ?? node.symbol ?? 'BTC').toUpperCase();
-    if (!/^[A-Z0-9:_-]+$/u.test(market)) throw new Error(`unsupported market symbol ${JSON.stringify(market)}`);
-    return `/order/${market}`;
-  }
-  if (page === 'portfolio') return '/portfolio';
-  if (page === 'home') return '/';
-  throw new Error(`ui.navigate page must be order, portfolio or home (or pass path), got ${JSON.stringify(page)}.`);
-}
-
-export async function navigate(input) {
-  const node = input.node ?? {};
-  const url = `${appOrigin(input)}${pathFor(node)}`;
-  return withTerminalPage({ ...input, node: { ...node, surface: 'app' } }, async (page) => {
-    await page.navigate(url, Number(node.timeout_ms ?? 120000));
-    await page.waitForDocumentReady({ expectedUrl: url, timeoutMs: Number(node.timeout_ms ?? 120000) });
-    if (node.settle_ms) await new Promise((resolve) => setTimeout(resolve, Number(node.settle_ms)));
-    return { action: input.action, url, page: node.page ?? 'order', market: node.market ?? null };
-  });
-}
-
-if (isDirectRun(import.meta.url)) runAdapter((input) => navigate(input));

package/library/actions/terminal/wallet/_signature-log.mjs

@@ -1,177 +0,0 @@
-// Read, window and assert the terminal wallet request log the wallet host
-// writes: one JSON line per request the app sent to the main wallet (method,
-// EIP-712 primary type, domain/active chain, outcome) and, in extension mode,
-// one line per confirmation window MetaMask opened. Never holds params,
-// messages or signatures.
-
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-
-import { terminalRuntimePath } from '../platform/runtime.mjs';
-
-export const L1_PRIMARY_TYPE = 'Agent';
-export const L1_CHAIN_ID = 1337;
-
-export function signatureLogPath(projectRoot) {
-  return terminalRuntimePath(projectRoot, 'wallet-requests.jsonl');
-}
-
-export function signatureCursorPath(projectRoot) {
-  return terminalRuntimePath(projectRoot, 'wallet-requests.cursor.json');
-}
-
-export function parseLog(text) {
-  return text
-    .split('\n')
-    .filter((line) => line.trim())
-    .map((line, index) => {
-      try {
-        return { seq: index, ...JSON.parse(line) };
-      } catch {
-        return { seq: index, kind: 'unparseable' };
-      }
-    });
-}
-
-export async function readLog(projectRoot) {
-  try {
-    return parseLog(await readFile(signatureLogPath(projectRoot), 'utf8'));
-  } catch (error) {
-    if (error?.code === 'ENOENT') return [];
-    throw error;
-  }
-}
-
-export async function readCursor(projectRoot) {
-  try {
-    const cursor = JSON.parse(await readFile(signatureCursorPath(projectRoot), 'utf8'));
-    return Number.isInteger(cursor.seq) ? cursor.seq : 0;
-  } catch (error) {
-    if (error?.code === 'ENOENT') return 0;
-    throw error;
-  }
-}
-
-export async function writeCursor(projectRoot, seq) {
-  await writeFile(signatureCursorPath(projectRoot), `${JSON.stringify({ seq, at: new Date().toISOString() })}\n`, { mode: 0o600 });
-}
-
-// "HyperliquidTransaction:ApproveAgent" → "ApproveAgent".
-export function shortPrimaryType(primaryType) {
-  if (primaryType == null) return null;
-  const raw = String(primaryType);
-  return raw.includes(':') ? raw.slice(raw.lastIndexOf(':') + 1) : raw;
-}
-
-export function isTypedDataRequest(entry) {
-  return entry.kind === 'request' && /^eth_signTypedData/u.test(String(entry.method));
-}
-
-export function isL1Request(entry) {
-  return isTypedDataRequest(entry) &&
-    (shortPrimaryType(entry.primaryType) === L1_PRIMARY_TYPE || Number(entry.domainChainId) === L1_CHAIN_ID);
-}
-
-export function summarize(entries) {
-  const requests = entries.filter((entry) => entry.kind === 'request');
-  const typed = requests.filter(isTypedDataRequest);
-  const byPrimaryType = {};
-  for (const entry of typed) {
-    const key = shortPrimaryType(entry.primaryType) ?? '<none>';
-    byPrimaryType[key] ??= { requested: 0, signed: 0, rejected: 0, chainIds: [] };
-    byPrimaryType[key].requested += 1;
-    if (entry.outcome === 'signed') byPrimaryType[key].signed += 1;
-    if (entry.outcome === 'rejected' || entry.outcome === 'error') byPrimaryType[key].rejected += 1;
-    if (!byPrimaryType[key].chainIds.includes(entry.domainChainId)) byPrimaryType[key].chainIds.push(entry.domainChainId);
-  }
-  const byMethod = {};
-  for (const entry of requests) byMethod[entry.method] = (byMethod[entry.method] ?? 0) + 1;
-  return {
-    requests: requests.length,
-    typedDataRequests: typed.length,
-    l1Requests: typed.filter(isL1Request).length,
-    confirmationsShown: entries.filter((entry) => entry.kind === 'confirmation-shown').length,
-    // Testnet enforcement and evidence gaps: each one fails the assertion.
-    blockedMainnet: entries.filter((entry) => entry.kind === 'blocked-mainnet' && !entry.probe).length,
-    refusedMainnet: entries.filter((entry) => entry.kind === 'refused-mainnet').length,
-    unattributed: entries.filter((entry) => entry.kind === 'unattributed').length,
-    // Calls from an iframe, a foreign page or a blank document: refused, kept as evidence.
-    outsideAppFrame: entries.filter((entry) => entry.kind === 'outside-app-frame').length,
-    byPrimaryType,
-    byMethod,
-  };
-}
-
-function exact(label, actual, expected, failures) {
-  if (actual !== expected) failures.push(`${label}: expected ${expected}, got ${actual}`);
-}
-
-// Every expectation is optional; max_l1_requests defaults to 0 because an L1
-// (agent-signed) payload must never reach the main wallet.
-export function evaluateSignatureLog(entries, node = {}) {
-  const summary = summarize(entries);
-  const typed = entries.filter(isTypedDataRequest);
-  const failures = [];
-  if (summary.blockedMainnet > 0) failures.push(`the browser tried to reach a mainnet venue ${summary.blockedMainnet} time(s) (blocked-mainnet)`);
-  if (summary.refusedMainnet > 0) failures.push(`the app asked the wallet to sign ${summary.refusedMainnet} mainnet action(s) (refused-mainnet)`);
-  if (summary.unattributed > 0) failures.push(`${summary.unattributed} wallet log entr(y/ies) could not be attributed to the app's top frame (unattributed)`);
-  const maxL1 = node.max_l1_requests == null ? 0 : Number(node.max_l1_requests);
-  if (summary.l1Requests > maxL1) {
-    failures.push(`L1 requests reached the main wallet: ${summary.l1Requests} > ${maxL1}`);
-  }
-  if (Array.isArray(node.allowed_primary_types)) {
-    const allowed = new Set(node.allowed_primary_types.map(shortPrimaryType));
-    for (const entry of typed) {
-      const type = shortPrimaryType(entry.primaryType);
-      if (!allowed.has(type)) failures.push(`primary type ${type} (seq ${entry.seq}) is not allowed`);
-    }
-  }
-  if (node.counts && typeof node.counts === 'object') {
-    for (const [type, expected] of Object.entries(node.counts)) {
-      exact(`signed ${shortPrimaryType(type)}`, summary.byPrimaryType[shortPrimaryType(type)]?.signed ?? 0, Number(expected), failures);
-    }
-  }
-  if (node.request_counts && typeof node.request_counts === 'object') {
-    for (const [type, expected] of Object.entries(node.request_counts)) {
-      exact(`requested ${shortPrimaryType(type)}`, summary.byPrimaryType[shortPrimaryType(type)]?.requested ?? 0, Number(expected), failures);
-    }
-  }
-  if (node.methods && typeof node.methods === 'object') {
-    for (const [method, expected] of Object.entries(node.methods)) {
-      exact(`method ${method}`, summary.byMethod[method] ?? 0, Number(expected), failures);
-    }
-  }
-  if (node.max_typed_data_requests != null && summary.typedDataRequests > Number(node.max_typed_data_requests)) {
-    failures.push(`typed-data requests ${summary.typedDataRequests} > ${node.max_typed_data_requests}`);
-  }
-  if (node.expect_confirmations != null) {
-    exact('confirmations shown', summary.confirmationsShown, Number(node.expect_confirmations), failures);
-  }
-  if (node.require_active_chain === true) {
-    for (const entry of typed.filter((item) => item.outcome === 'signed')) {
-      if (Number(entry.domainChainId) !== Number(entry.activeChainId)) {
-        failures.push(`seq ${entry.seq} ${shortPrimaryType(entry.primaryType)} signed with domain chainId ${entry.domainChainId} while the wallet was on ${entry.activeChainId}`);
-      }
-    }
-  }
-  if (node.max_rejected != null) {
-    const rejected = typed.filter((entry) => entry.outcome === 'rejected' || entry.outcome === 'error').length;
-    if (rejected > Number(node.max_rejected)) failures.push(`rejected typed-data requests ${rejected} > ${node.max_rejected}`);
-  }
-  return { ok: failures.length === 0, failures, summary };
-}
-
-export async function windowSinceCursor(projectRoot) {
-  const [entries, cursor] = await Promise.all([readLog(projectRoot), readCursor(projectRoot)]);
-  return { cursor, entries: entries.filter((entry) => entry.seq >= cursor), total: entries.length };
-}
-
-export async function writeLogArtifact(input, payload) {
-  const artifactsDir = input.context?.artifactsDir;
-  if (!artifactsDir) return [];
-  const nodeId = String(input.context?.nodeId ?? input.action).replaceAll('/', '__');
-  const relative = `terminal-wallet/${nodeId}-signature-log.json`;
-  await mkdir(path.join(artifactsDir, 'terminal-wallet'), { recursive: true });
-  await writeFile(path.join(artifactsDir, relative), `${JSON.stringify(payload, null, 2)}\n`);
-  return [{ path: relative, type: 'report', nodeId: String(input.context?.nodeId ?? input.action) }];
-}

package/library/actions/terminal/wallet/read_signatures.mjs

@@ -1,37 +0,0 @@
-// Return the wallet request log since the last reset and retain it as run
-// evidence. reset=true moves the window start to the end of the log so the next
-// read covers only what follows (an explicit setup step, recorded in the trace).
-
-import { isDirectRun, runAdapter } from '../platform/runtime.mjs';
-import { readLog, summarize, windowSinceCursor, writeCursor, writeLogArtifact } from './_signature-log.mjs';
-
-export async function readSignatures(input) {
-  const projectRoot = input.context?.projectRoot;
-  if (input.node?.reset === true) {
-    const entries = await readLog(projectRoot);
-    await writeCursor(projectRoot, entries.length);
-    return {
-      action: input.action,
-      source: 'terminal-wallet-request-log',
-      reset: true,
-      cursor: entries.length,
-      previousEntries: entries.length,
-      proofPath: 'terminal-wallet-request-log',
-    };
-  }
-  const { cursor, entries, total } = await windowSinceCursor(projectRoot);
-  const summary = summarize(entries);
-  const artifacts = await writeLogArtifact(input, { cursor, total, summary, entries });
-  return {
-    action: input.action,
-    source: 'terminal-wallet-request-log',
-    cursor,
-    count: entries.length,
-    summary,
-    entries,
-    artifacts,
-    proofPath: 'terminal-wallet-request-log',
-  };
-}
-
-if (isDirectRun(import.meta.url)) runAdapter((input) => readSignatures(input));