@deeeed/metamask-harness 0.38.1 → 0.40.0

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

@@ -1,34 +1,142 @@
-import { dataTestId, marketSymbol, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import {
+  assertTrustedExternalMutationTarget,
+  externalMutationNotDispatched,
+  readExternalMutationReceipt,
+  readPriorMutationReceipt,
+  runGuardedExternalMutation,
+  trustedExternalMutationIdentity,
+  withExternalMutationRecovery,
+} from './mutation-receipt.mjs';
+import { requireCurrentVisibleFundingBalance, requirePerpsTradingContext } from './perps.mjs';
+import {
+  absoluteDelta,
+  normalizePositionSizeIdentity,
+  normalizedNumericInputMatches,
+  parsePositionDetail,
+  parseUsdBaseUnits,
+  positionIdentityMatches,
+  waitForStableGlobalPerpsHome,
+} from './visible-mutation-identity.mjs';
 
-runAdapter(async (input) => withExtensionPage(input, async (page) => {
-  const market = marketSymbol(input);
-  const mode = String(input.node?.margin_action ?? 'add').trim().toLowerCase();
-  const amount = Number(input.node?.amount);
-  if (!market) throw new Error('metamask.perps.edit_margin requires market=<symbol>.');
-  if (mode !== 'add' && mode !== 'remove') {
-    throw new Error(`metamask.perps.edit_margin received unsupported margin_action ${JSON.stringify(mode)}.`);
-  }
-  if (!Number.isFinite(amount) || amount <= 0) {
-    throw new Error('metamask.perps.edit_margin requires a positive amount.');
+function marketSymbol(value) {
+  const market = String(value ?? '').trim().toUpperCase();
+  if (!/^[A-Z0-9:_-]{2,20}$/u.test(market)) {
+    throw new Error('metamask.perps.edit_margin requires market=<symbol>.');
   }
-  if (input.node?.confirm_live !== true) {
-    throw new Error('metamask.perps.edit_margin requires confirm_live=true for live submission.');
+  return market;
+}
+
+function decimalBaseUnits(value) {
+  const units = parseUsdBaseUnits(value);
+  if (!/^[1-9][0-9]{0,29}$/u.test(String(units ?? ''))) {
+    throw new Error('metamask.perps.edit_margin requires a positive amount with at most six decimals.');
   }
+  return units;
+}
 
+async function readPosition(page, market) {
   await page.navigateHash(`#/perps/market/${encodeURIComponent(market)}`);
-  await page.waitForSelector(dataTestId('perps-position-margin-value'), { timeoutMs: 20_000 });
-  const before = await page.evaluate(`(() => ({
-    margin: String(document.querySelector('[data-testid="perps-position-margin-value"]')?.textContent || '').trim(),
-    liquidation: String(document.querySelector('[data-testid="perps-position-liquidation-value"]')?.textContent || '').trim(),
-  }))()`);
+  await page.waitForSelector(dataTestId('perps-position-size-value'), { timeoutMs: 20_000 });
+  const raw = await page.evaluate(`(() => {
+    const read = (testId) => String(document.querySelector('[data-testid="' + testId + '"]')?.innerText || '')
+      .replace(/\\s+/gu, ' ')
+      .trim()
+      .slice(0, 500);
+    return {
+      route: String(location.hash),
+      pair: read('perps-market-detail-pair'),
+      direction: read('perps-position-leverage'),
+      size: read('perps-position-size-value'),
+      margin: read('perps-position-margin-value'),
+      liquidation: read('perps-position-liquidation-value'),
+    };
+  })()`);
+  const parsed = parsePositionDetail(raw);
+  if (!parsed || !raw.route.includes('/perps/market/') || !raw.pair.toUpperCase().startsWith(`${market}-`)) {
+    throw new Error('Visible Perps position identity is unavailable or does not match the requested market.');
+  }
+  return { ...raw, ...parsed };
+}
+
+function exactTarget(facts) {
+  const baseline = facts?.positionBefore;
+  const amountBaseUnits = String(facts?.amountBaseUnits ?? '');
+  const mode = String(facts?.marginAction ?? '');
+  if (!baseline || !/^[1-9][0-9]{0,29}$/u.test(amountBaseUnits) || !/^(?:add|remove)$/u.test(mode)) {
+    throw new Error('Margin receipt has no valid exact baseline.');
+  }
+  const target = BigInt(baseline.marginBaseUnits) + (mode === 'add' ? 1n : -1n) * BigInt(amountBaseUnits);
+  if (target <= 0n) throw new Error('Margin receipt target is invalid.');
+  return `${target}`;
+}
+
+async function observeMargin(page, identity, facts, balanceTarget, balanceToleranceBaseUnits, timeoutMs) {
+  const targetMarginBaseUnits = exactTarget(facts);
+  const deadline = Date.now() + timeoutMs;
+  let stable = null;
+  let stableSince = 0;
+  let after;
+  while (Date.now() <= deadline) {
+    after = await readPosition(page, identity.market);
+    const exact = after.marginBaseUnits === targetMarginBaseUnits
+      && after.size === facts.positionBefore.size
+      && after.direction === facts.positionBefore.direction
+      && after.liquidation !== facts.positionBefore.liquidation
+      && positionIdentityMatches(after, {
+        market: identity.market,
+        side: identity.side,
+        leverage: identity.leverage,
+        matchMargin: false,
+      });
+    if (exact) {
+      const key = JSON.stringify(after);
+      if (key !== stable) {
+        stable = key;
+        stableSince = Date.now();
+      } else if (Date.now() - stableSince >= 1_000) break;
+    } else {
+      stable = null;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  if (!stable) throw new Error('exact margin, liquidation, size, and leverage postcondition was not visible');
+  await page.navigateHash('#/perps-home');
+  const home = await waitForStableGlobalPerpsHome(page, { timeoutMs, requireZero: false });
+  const balanceDeltaBaseUnits = balanceTarget == null
+    ? null
+    : absoluteDelta(home.balanceBaseUnits, balanceTarget);
+  if (balanceDeltaBaseUnits != null && BigInt(balanceDeltaBaseUnits) > BigInt(balanceToleranceBaseUnits)) {
+    throw new Error('Margin cleanup did not reconcile the visible Perps balance.');
+  }
+  return {
+    success: true,
+    positionBefore: facts.positionBefore,
+    positionAfter: after,
+    targetMarginBaseUnits,
+    balanceBeforeBaseUnits: String(facts.balanceBeforeBaseUnits),
+    balanceAfterBaseUnits: home.balanceBaseUnits,
+    balanceReconciliationTargetBaseUnits: balanceTarget,
+    balanceDeltaBaseUnits,
+    balanceToleranceBaseUnits,
+  };
+}
+
+async function prepareMarginModal(page, mode, amount) {
   await page.click(dataTestId('perps-margin-card'));
   const menuItem = mode === 'add' ? 'perps-margin-menu-add' : 'perps-margin-menu-remove';
   await page.waitForSelector(dataTestId(menuItem), { timeoutMs: 10_000 });
   await page.click(dataTestId(menuItem));
   const modal = mode === 'add' ? 'perps-add-margin-modal' : 'perps-decrease-margin-modal';
   await page.waitForSelector(dataTestId(modal), { timeoutMs: 10_000 });
-  await page.setInput(`${dataTestId('perps-edit-margin-amount-input')} input`, String(amount));
-
+  const amountSelector = `${dataTestId('perps-edit-margin-amount-input')} input`;
+  try {
+    await page.setInput(amountSelector, amount);
+  } catch (error) {
+    if (!/Input did not retain the supplied value length/u.test(String(error?.message ?? error))) throw error;
+    const retained = await page.evaluate(`document.querySelector(${JSON.stringify(amountSelector)})?.value ?? null`);
+    if (!normalizedNumericInputMatches(retained, amount)) throw error;
+  }
   const saveDeadline = Date.now() + 10_000;
   let ready;
   while (Date.now() <= saveDeadline) {
@@ -42,41 +150,174 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
         liquidation: String(document.querySelector('[data-testid="perps-edit-margin-liquidation-price-value"]')?.textContent || '').trim(),
       };
     })()`);
-    if (ready.saveEnabled) break;
+    if (Number(ready.amount) === Number(amount) && ready.saveEnabled) break;
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
-  if (Number(ready?.amount) !== amount || !ready?.saveEnabled) {
+  if (!ready?.saveEnabled || Number(ready.amount) !== Number(amount)) {
     throw new Error(`Perps margin update is not ready: ${JSON.stringify(ready)}.`);
   }
-  await page.click(dataTestId('perps-edit-margin-modal-save'));
+  return ready;
+}
 
-  const resultDeadline = Date.now() + Number(input.node?.timeout_ms ?? 30_000);
-  let after;
-  while (Date.now() <= resultDeadline) {
-    after = await page.evaluate(`(() => ({
-      modalVisible: Boolean(document.querySelector(${JSON.stringify(dataTestId(modal))})),
-      margin: String(document.querySelector('[data-testid="perps-position-margin-value"]')?.textContent || '').trim(),
-      liquidation: String(document.querySelector('[data-testid="perps-position-liquidation-value"]')?.textContent || '').trim(),
-      errors: [...document.querySelectorAll('[role="alert"]')]
-        .map((element) => String(element.innerText || '').replace(/\\s+/gu, ' ').trim())
-        .filter(Boolean)
-        .slice(0, 20),
-    }))()`);
-    if (!after.modalVisible && after.margin && after.margin !== before.margin) break;
-    if (after.errors.length > 0) throw new Error(`Perps margin update failed: ${after.errors.join(' | ')}`);
-    await new Promise((resolve) => setTimeout(resolve, 200));
+export async function editMargin(input) {
+  return withExtensionPage(input, async (page) => {
+  const market = marketSymbol(input.node?.market);
+  const mode = String(input.node?.margin_action ?? 'add').trim().toLowerCase();
+  const amount = String(input.node?.amount ?? '');
+  const amountBaseUnits = decimalBaseUnits(amount);
+  const fundingSide = String(input.node?.funding_side ?? '').trim().toLowerCase();
+  const fundingAmountBaseUnits = decimalBaseUnits(input.node?.funding_amount);
+  const fundingPositionSize = normalizePositionSizeIdentity(input.node?.funding_position_size);
+  const leverage = Number(input.node?.leverage);
+  const balanceToleranceBaseUnits = String(input.node?.balance_reconciliation_tolerance_base_units ?? '1000000');
+  if (!/^(?:add|remove)$/u.test(mode) || !/^(?:long|short)$/u.test(fundingSide)
+    || fundingPositionSize == null
+    || !Number.isInteger(leverage) || leverage < 1 || leverage > 100
+    || !/^(?:0|[1-9][0-9]{0,6})$/u.test(balanceToleranceBaseUnits)
+    || BigInt(balanceToleranceBaseUnits) > 1_000_000n) {
+    throw new Error('metamask.perps.edit_margin received invalid funded position inputs.');
+  }
+  if (input.node?.confirm_live !== true) {
+    throw new Error('metamask.perps.edit_margin requires confirm_live=true for live submission.');
+  }
+  const identity = trustedExternalMutationIdentity(input, page, {
+    operation: 'perps-margin-adjust',
+    authorizationCount: 2,
+    provider: input.node?.provider,
+    network: input.node?.network,
+    market,
+    side: fundingSide,
+    amount,
+    leverage,
+    orderType: 'margin',
+    positionMode: 'modify',
+    marginAction: mode,
+    positionAmountBaseUnits: fundingAmountBaseUnits,
+    positionSize: fundingPositionSize,
+    roundingToleranceBaseUnits: '0',
+  });
+  const existingReceipt = await readExternalMutationReceipt(input, identity);
+  let balanceTarget = null;
+  if (mode === 'remove') {
+    const addReceipt = await readPriorMutationReceipt(
+      input,
+      identity,
+      'metamask.perps.edit_margin',
+      { marginAction: 'add' },
+    );
+    if (addReceipt.record?.identity?.marginAction !== 'add' || addReceipt.record?.state !== 'succeeded') {
+      throw new Error('Margin removal requires one succeeded receipt-bound add operation.');
+    }
+    balanceTarget = String(addReceipt.record?.facts?.balanceBeforeBaseUnits ?? '');
+    if (!/^(?:0|[1-9][0-9]{0,29})$/u.test(balanceTarget)) {
+      throw new Error('Prior margin receipt has no valid balance baseline.');
+    }
+  }
+  if (existingReceipt) {
+    return withExternalMutationRecovery(existingReceipt, async () => {
+      const mutation = await runGuardedExternalMutation({
+        input,
+        identity,
+        dispatch: async () => { throw new Error('resumed margin mutation must not dispatch'); },
+        observe: async ({ receipt }) => observeMargin(
+          page,
+          identity,
+          receipt.facts,
+          balanceTarget,
+          balanceToleranceBaseUnits,
+          Number(input.node?.timeout_ms ?? 45_000),
+        ),
+      });
+      return {
+        action: input.action,
+        market,
+        marginAction: mode,
+        amount,
+        receipt: mutation.receipt,
+        resumed: true,
+        outcome: mutation.observation,
+        proofPath: 'trusted-pointer-visible-ui',
+      };
+    });
   }
-  if (!after || after.modalVisible || after.margin === before.margin) {
-    throw new Error(`Perps margin did not reconcile after submission: ${JSON.stringify({ before, after })}.`);
+
+  const timeoutMs = Number(input.node?.timeout_ms ?? 45_000);
+  const fundingBalance = await requireCurrentVisibleFundingBalance(input, page, timeoutMs);
+  const tradingContext = await requirePerpsTradingContext(input, page);
+  const before = await readPosition(page, market);
+  if (!positionIdentityMatches(before, { market, side: fundingSide, leverage, matchMargin: false })
+    || normalizePositionSizeIdentity(before.size) !== fundingPositionSize) {
+    throw new Error('Visible Perps position does not match the funded market/side/leverage/size identity.');
   }
+  const ready = await prepareMarginModal(page, mode, amount);
+  const facts = {
+    marginAction: mode,
+    amountBaseUnits,
+    balanceBeforeBaseUnits: fundingBalance.observedBaseUnits,
+    positionBefore: before,
+    fundingBalance,
+    tradingContext,
+  };
+  const mutation = await runGuardedExternalMutation({
+    input,
+    identity,
+    publicationFacts: facts,
+    dispatch: async () => {
+      let dispatchTarget;
+      try {
+        await requireCurrentVisibleFundingBalance(input, page, timeoutMs, fundingBalance.observedBaseUnits);
+        await requirePerpsTradingContext(input, page);
+        assertTrustedExternalMutationTarget(input, page, identity);
+        const current = await readPosition(page, market);
+        if (current.marginBaseUnits !== before.marginBaseUnits || current.size !== before.size
+          || current.direction !== before.direction
+          || normalizePositionSizeIdentity(current.size) !== fundingPositionSize
+          || !positionIdentityMatches(current, { market, side: fundingSide, leverage, matchMargin: false })) {
+          throw new Error('Visible Perps position changed before margin dispatch.');
+        }
+        await prepareMarginModal(page, mode, amount);
+        dispatchTarget = await page.evaluate(`(() => {
+          const element = document.querySelector('[data-testid="perps-edit-margin-modal-save"]');
+          if (!element || element.disabled || element.getAttribute('aria-disabled') === 'true') {
+            throw new Error('Visible Perps margin submit control is unavailable.');
+          }
+          const rect = element.getBoundingClientRect();
+          return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+        })()`);
+        assertTrustedExternalMutationTarget(input, page, identity);
+      } catch (error) {
+        throw externalMutationNotDispatched(error instanceof Error ? error.message : String(error));
+      }
+      await page.session.call('Input.dispatchMouseEvent', {
+        type: 'mousePressed', x: dispatchTarget.x, y: dispatchTarget.y,
+        button: 'left', buttons: 1, clickCount: 1,
+      });
+      await page.session.call('Input.dispatchMouseEvent', {
+        type: 'mouseReleased', x: dispatchTarget.x, y: dispatchTarget.y,
+        button: 'left', buttons: 0, clickCount: 1,
+      });
+    },
+    observe: async ({ receipt }) => observeMargin(
+      page,
+      identity,
+      receipt.facts,
+      balanceTarget,
+      balanceToleranceBaseUnits,
+      Number(input.node?.timeout_ms ?? 45_000),
+    ),
+  });
   return {
     action: input.action,
     market,
     marginAction: mode,
     amount,
-    before,
     ready,
-    after,
-    proofPath: 'visible-product-controls',
+    receipt: mutation.receipt,
+    resumed: mutation.resumed,
+    outcome: mutation.observation,
+    proofPath: 'trusted-pointer-visible-ui',
   };
-}));
+  });
+}
+
+runAdapter(editMargin);