@deeeed/metamask-harness 0.38.1 → 0.40.0

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

@@ -1,4 +1,23 @@
 import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import {
+  assertTrustedExternalMutationTarget,
+  externalMutationNotDispatched,
+  readExternalMutationReceipt,
+  readPriorMutationReceipt,
+  runGuardedExternalMutation,
+  trustedExternalMutationBudget,
+  trustedExternalMutationIdentity,
+  trustedExternalMutationPlanIsExact,
+  withExternalMutationRecovery,
+} from './mutation-receipt.mjs';
+import { requireCurrentVisibleFundingBalance, requirePerpsTradingContext } from './perps.mjs';
+import {
+  absoluteDelta,
+  parsePositionDetail,
+  parseUsdBaseUnits,
+  positionIdentityMatches,
+  waitForStableGlobalPerpsHome,
+} from './visible-mutation-identity.mjs';
 
 function marketSymbol(value) {
   const result = String(value ?? '').trim().toUpperCase();
@@ -8,18 +27,10 @@ function marketSymbol(value) {
   return result;
 }
 
-runAdapter(async (input) => withExtensionPage(input, async (page) => {
-  const market = marketSymbol(input.node?.market);
-  const partialAmount = input.node?.amount == null ? null : Number(input.node.amount);
-  if (partialAmount != null && (!Number.isFinite(partialAmount) || partialAmount <= 0)) {
-    throw new Error('metamask.perps.close_visible_position amount must be positive.');
-  }
-  if (input.node?.confirm_live !== true) {
-    throw new Error('metamask.perps.close_visible_position requires confirm_live=true.');
-  }
+async function readVisibleClosePosition(page, market) {
   await page.navigateHash(`#/perps/market/${encodeURIComponent(market)}`);
   await page.waitForSelector(dataTestId('perps-position-size-value'), { timeoutMs: 20_000 });
-  const before = await page.evaluate(`(() => {
+  return page.evaluate(`(() => {
     const market = ${JSON.stringify(market)};
     const route = String(location.hash);
     const symbol = String(document.querySelector('[data-testid="perps-market-detail-pair"]')?.innerText || '')
@@ -42,8 +53,12 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
       margin: read('perps-position-margin-value'),
       entryPrice: read('perps-position-entry-value'),
       liquidationPrice: read('perps-position-liquidation-value'),
+      currentPrice: read('perps-market-detail-price'),
     };
   })()`);
+}
+
+async function prepareCloseModal(page, partialAmount) {
   let confirmation;
   for (let attempt = 0; attempt < 3 && !confirmation; attempt += 1) {
     await page.click(dataTestId('perps-close-cta-button'));
@@ -94,40 +109,287 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
     }
   }
   if (!confirmation.submitEnabled) throw new Error('Perps close confirmation is not submit-ready.');
-  await page.click(dataTestId('perps-close-position-modal-submit'));
-  const closeDeadline = Date.now() + 45_000;
-  let finalState;
-  while (Date.now() <= closeDeadline) {
-    finalState = await page.evaluate(`(() => ({
-      route: String(location.hash),
-      positionVisible: Boolean(document.querySelector('[data-testid="perps-position-size-value"]')),
-      positionSize: String(document.querySelector('[data-testid="perps-position-size-value"]')?.innerText || '').trim(),
-      modalVisible: Boolean(document.querySelector('[data-testid="perps-close-position-modal"]')),
-      error: String(document.querySelector('[data-testid="perps-order-submit-error"]')?.innerText || '').trim(),
-      activity: [...document.querySelectorAll('[data-testid^="transaction-card-"]')]
-        .slice(0, 5)
-        .map((element) => String(element.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500)),
-    }))()`);
-    if (finalState.error) throw new Error(`Perps close failed: ${finalState.error}`);
-    if (partialAmount != null) {
-      if (!finalState.modalVisible && finalState.positionVisible && finalState.positionSize !== before.size) break;
-    } else if (!finalState.positionVisible && !finalState.modalVisible) break;
-    await new Promise((resolve) => setTimeout(resolve, 250));
-  }
-  const incomplete = partialAmount != null
-    ? finalState?.modalVisible || !finalState?.positionVisible || finalState?.positionSize === before.size
-    : finalState?.positionVisible || finalState?.modalVisible;
-  if (incomplete) {
-    throw new Error('Perps position did not reach the requested close state after the timeout.');
+  return confirmation;
+}
+
+async function proveGlobalCleanup(page, balanceBeforeBaseUnits, toleranceBaseUnits, timeoutMs = 20_000) {
+  await page.navigateHash('#/perps-home');
+  const state = await waitForStableGlobalPerpsHome(page, { timeoutMs, requireZero: true });
+  const balanceDeltaBaseUnits = absoluteDelta(state.balanceBaseUnits, balanceBeforeBaseUnits);
+  if (BigInt(balanceDeltaBaseUnits) > BigInt(toleranceBaseUnits)) {
+    throw new Error('Final visible Perps balance exceeds the authorized reconciliation tolerance.');
   }
+  return {
+    positionCount: 0,
+    orderCount: 0,
+    balanceBeforeBaseUnits,
+    balanceAfterBaseUnits: state.balanceBaseUnits,
+    balanceDeltaBaseUnits,
+    toleranceBaseUnits,
+  };
+}
+
+export async function closeVisiblePosition(input) {
+  return withExtensionPage(input, async (page) => {
+  const market = marketSymbol(input.node?.market);
+  const partialAmount = input.node?.amount == null ? null : Number(input.node.amount);
+  if (partialAmount != null && (!Number.isFinite(partialAmount) || partialAmount <= 0)) {
+    throw new Error('metamask.perps.close_visible_position amount must be positive.');
+  }
+  if (input.node?.confirm_live !== true) {
+    throw new Error('metamask.perps.close_visible_position requires confirm_live=true.');
+  }
+  const fundingSide = String(input.node?.funding_side ?? '').toLowerCase();
+  const fundingAmount = String(input.node?.funding_amount ?? '');
+  const fundingPositionSize = String(input.node?.funding_position_size ?? '');
+  const leverage = Number(input.node?.leverage);
+  const cleanupOnly = input.node?.cleanup_only === true;
+  if (cleanupOnly && !trustedExternalMutationPlanIsExact(input, 'perps-close-position', 1)) {
+    throw new Error('Cleanup-only close requires an exact runner-verified close-only request and plan.');
+  }
+  if (cleanupOnly && (!/^[0-9]+(?:\.[0-9]+)? [A-Z0-9:_-]{2,20}$/u.test(fundingPositionSize)
+    || Number.parseFloat(fundingPositionSize) <= 0 || partialAmount != null)) {
+    throw new Error('Cleanup-only close requires one exact positive full-position size identity.');
+  }
+  const roundingToleranceBaseUnits = String(input.node?.identity_rounding_tolerance_base_units ?? '10000');
+  const balanceToleranceBaseUnits = String(input.node?.balance_reconciliation_tolerance_base_units ?? '1000000');
+  if (!Number.isInteger(leverage) || leverage < 1 || leverage > 100
+    || !/^(?:0|[1-9][0-9]{0,6})$/u.test(roundingToleranceBaseUnits)
+    || !/^(?:0|[1-9][0-9]{0,6})$/u.test(balanceToleranceBaseUnits)
+    || BigInt(roundingToleranceBaseUnits) > 1_000_000n
+    || BigInt(balanceToleranceBaseUnits) > 1_000_000n) {
+    throw new Error('metamask.perps.close_visible_position leverage/tolerance inputs are invalid.');
+  }
+  const identity = trustedExternalMutationIdentity(input, page, {
+    operation: 'perps-close-position',
+    provider: input.node?.provider,
+    network: input.node?.network,
+    market,
+    side: fundingSide,
+    amount: fundingAmount,
+    leverage,
+    orderType: 'close',
+    positionMode: 'close',
+    limitPrice: null,
+    offsetPct: null,
+    partialCloseAmount: partialAmount == null ? null : String(input.node.amount),
+    roundingToleranceBaseUnits,
+    ...(cleanupOnly ? { positionSize: fundingPositionSize, cleanupOnly: true } : {}),
+  });
+  const existingReceipt = await readExternalMutationReceipt(input, identity);
+  if (existingReceipt) {
+    return withExternalMutationRecovery(existingReceipt, async () => {
+      await page.navigateHash(`#/perps/market/${encodeURIComponent(market)}`);
+      await page.waitForSelector(dataTestId('perps-market-detail-pair'), { timeoutMs: 20_000 });
+      const mutation = await runGuardedExternalMutation({
+        input,
+        identity,
+        dispatch: async () => {
+          throw new Error('resumed close must not dispatch');
+        },
+        observe: async () => {
+          const deadline = Date.now() + 45_000;
+          let finalState;
+          let absentSince = null;
+          while (Date.now() <= deadline) {
+            finalState = await page.evaluate(`(() => ({
+              route: String(location.hash),
+              positionVisible: Boolean(document.querySelector('[data-testid="perps-position-size-value"]')),
+              positionSize: String(document.querySelector('[data-testid="perps-position-size-value"]')?.innerText || '').trim(),
+              modalVisible: Boolean(document.querySelector('[data-testid="perps-close-position-modal"]')),
+              loading: Boolean(document.querySelector('[data-testid="perps-detail-page-skeleton"], [data-testid="perps-section-skeleton"]')),
+            }))()`);
+            if (partialAmount != null && finalState.positionVisible && !finalState.modalVisible
+              && finalState.positionSize !== existingReceipt.record?.facts?.positionBeforeSize) {
+              absentSince ??= Date.now();
+              if (Date.now() - absentSince >= 1_000) return { success: true, finalState, cleanup: null };
+            } else if (!finalState.positionVisible && !finalState.modalVisible && !finalState.loading) {
+              absentSince ??= Date.now();
+              if (Date.now() - absentSince >= 1_000) {
+                if (partialAmount != null) return { success: true, finalState, cleanup: null };
+                const balanceBeforeBaseUnits = String(existingReceipt.record?.facts?.balanceBeforeBaseUnits ?? '');
+                if (!/^(?:0|[1-9][0-9]{0,29})$/u.test(balanceBeforeBaseUnits)) {
+                  throw new Error('Resumed close receipt has no valid pre-order balance.');
+                }
+                const cleanup = await proveGlobalCleanup(
+                  page,
+                  balanceBeforeBaseUnits,
+                  balanceToleranceBaseUnits,
+                );
+                return {
+                  success: true,
+                  finalState,
+                  cleanup,
+                };
+              }
+            } else {
+              absentSince = null;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 250));
+          }
+          throw new Error('matching closed-position postcondition was not visible before timeout');
+        },
+      });
+      return {
+        action: input.action,
+        market,
+        closed: true,
+        partial: false,
+        receipt: mutation.receipt,
+        resumed: true,
+        recovery: mutation.recovery,
+        finalState: mutation.observation.finalState,
+        cleanup: mutation.observation.cleanup ?? null,
+        proofPath: 'trusted-pointer-visible-ui',
+      };
+    });
+  }
+  let cleanupHomeBefore = null;
+  if (cleanupOnly) {
+    await page.navigateHash('#/perps-home');
+    cleanupHomeBefore = await waitForStableGlobalPerpsHome(page, { timeoutMs: 20_000, requireZero: false });
+    if (cleanupHomeBefore.positionCount !== 1 || cleanupHomeBefore.orderCount !== 0) {
+      throw new Error('Cleanup-only close requires exactly one primary position and globally zero orders.');
+    }
+  }
+  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 readVisibleClosePosition(page, market);
+  const exactBefore = parsePositionDetail({ pair: `${market}-USD`, ...before });
+  if (!positionIdentityMatches(exactBefore, {
+    market,
+    side: fundingSide,
+    leverage,
+    amountBaseUnits: identity.amountBaseUnits,
+    roundingToleranceBaseUnits,
+    matchMargin: false,
+  })) {
+    throw new Error('Visible Perps position does not match the funded market/side/leverage identity.');
+  }
+  if (cleanupOnly && exactBefore.size !== fundingPositionSize) {
+    throw new Error('Cleanup-only close visible position size does not match the authorized exact identity.');
+  }
+  const sizeMatch = /^([0-9]+(?:\.[0-9]+)?) ([A-Z0-9:_-]{2,20})$/u.exec(String(exactBefore.size ?? ''));
+  const priceBaseUnits = parseUsdBaseUnits(before.currentPrice);
+  const observedNotionalBaseUnits = sizeMatch && sizeMatch[2] === market && priceBaseUnits != null
+    ? `${Math.round(Number(sizeMatch[1]) * Number(priceBaseUnits))}`
+    : null;
+  const closeBudget = trustedExternalMutationBudget(input, 'perps-close-position');
+  if (!/^[1-9][0-9]{0,29}$/u.test(String(observedNotionalBaseUnits ?? ''))
+    || BigInt(observedNotionalBaseUnits) > BigInt(closeBudget.maxBaseUnits)) {
+    throw new Error('Visible Perps position notional is unavailable or exceeds the authorized close cap.');
+  }
+  if (!cleanupOnly) {
+    await readPriorMutationReceipt(input, identity, 'metamask.perps.place_order');
+  }
+  const balanceBeforeBaseUnits = fundingBalance.observedBaseUnits;
+  if (!/^(?:0|[1-9][0-9]{0,29})$/u.test(balanceBeforeBaseUnits)) {
+    throw new Error('Prior order receipt has no valid visible pre-order balance.');
+  }
+  const confirmation = await prepareCloseModal(page, partialAmount);
+  const mutation = await runGuardedExternalMutation({
+    input,
+    identity,
+    publicationFacts: {
+      balanceBeforeBaseUnits,
+      positionBeforeSize: before.size,
+      observedNotionalBaseUnits,
+      cleanupOnly,
+      fundingBalance,
+      tradingContext,
+    },
+    dispatch: async () => {
+      let dispatchTarget;
+      try {
+        await requireCurrentVisibleFundingBalance(input, page, timeoutMs, fundingBalance.observedBaseUnits);
+        await requirePerpsTradingContext(input, page);
+        assertTrustedExternalMutationTarget(input, page, identity);
+        const current = await readVisibleClosePosition(page, market);
+        const currentPosition = parsePositionDetail({ pair: `${market}-USD`, ...current });
+        if (!positionIdentityMatches(currentPosition, {
+          market, side: fundingSide, leverage, amountBaseUnits: identity.amountBaseUnits,
+          roundingToleranceBaseUnits, matchMargin: false,
+        }) || currentPosition.size !== exactBefore.size) {
+          throw new Error('Visible Perps position changed before close dispatch.');
+        }
+        await prepareCloseModal(page, partialAmount);
+        dispatchTarget = await page.evaluate(`(() => {
+          const element = document.querySelector('[data-testid="perps-close-position-modal-submit"]');
+          if (!element || element.disabled || element.getAttribute('aria-disabled') === 'true') {
+            throw new Error('Visible Perps close 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 () => {
+      const closeDeadline = Date.now() + 45_000;
+      let finalState;
+      while (Date.now() <= closeDeadline) {
+        finalState = await page.evaluate(`(() => ({
+          route: String(location.hash),
+          positionVisible: Boolean(document.querySelector('[data-testid="perps-position-size-value"]')),
+          positionSize: String(document.querySelector('[data-testid="perps-position-size-value"]')?.innerText || '').trim(),
+          modalVisible: Boolean(document.querySelector('[data-testid="perps-close-position-modal"]')),
+          error: String(document.querySelector('[data-testid="perps-order-submit-error"]')?.innerText || '').trim(),
+        }))()`);
+        if (finalState.error) throw new Error('visible Perps close error');
+        if (partialAmount != null) {
+          if (!finalState.modalVisible && finalState.positionVisible && finalState.positionSize !== before.size) {
+            return { success: true, finalState };
+          }
+        } else if (!finalState.positionVisible && !finalState.modalVisible) {
+          await new Promise((resolve) => setTimeout(resolve, 1_000));
+          const exactAbsent = !await page.evaluate(
+            `Boolean(document.querySelector('[data-testid="perps-position-size-value"]'))`,
+          );
+          if (exactAbsent) {
+            const cleanup = await proveGlobalCleanup(
+              page,
+              balanceBeforeBaseUnits,
+              balanceToleranceBaseUnits,
+            );
+            return {
+              success: true,
+              finalState,
+              cleanup,
+            };
+          }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+      }
+      throw new Error('matching closed-position postcondition was not visible before timeout');
+    },
+  });
   return {
     action: input.action,
     market,
     closed: partialAmount == null,
     partial: partialAmount != null,
     positionBefore: before,
+    observedNotionalBaseUnits,
     confirmation,
-    finalState,
+    finalState: mutation.observation.finalState,
+    cleanup: mutation.observation.cleanup ?? null,
+    receipt: mutation.receipt,
+    resumed: mutation.resumed,
+    recovery: mutation.recovery,
     proofPath: 'trusted-pointer-visible-ui',
   };
-}));
+  });
+}
+
+runAdapter(closeVisiblePosition);

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

@@ -18,6 +18,42 @@ function relativeDifference(actual, expected) {
   return Math.abs(actual - expected) / Math.max(Math.abs(expected), 1e-12);
 }
 
+function countdownSeconds(value) {
+  const match = String(value ?? '').match(/^(\d{2}):(\d{2}):(\d{2})$/u);
+  if (!match) return null;
+  return Number(match[1]) * 3600 + Number(match[2]) * 60 + Number(match[3]);
+}
+
+async function readChartSample(page) {
+  return page.evaluate(`(() => {
+    const root = document.querySelector('[data-testid="perps-market-detail-chart"]');
+    const chart = root?.querySelector('[data-testid="perps-candlestick-chart"]');
+    const text = String(root?.innerText || '').replace(/\\s+/gu, ' ').trim();
+    const canvases = chart ? [...chart.querySelectorAll('canvas')] : [];
+    const samples = canvases.map((canvas) => {
+      const context = canvas.getContext('2d');
+      if (!context || canvas.width <= 0 || canvas.height <= 0) return { width: canvas.width, height: canvas.height, colors: 0 };
+      const pixels = context.getImageData(0, 0, canvas.width, canvas.height).data;
+      const colors = new Set();
+      const stride = Math.max(4, Math.floor(pixels.length / 4000 / 4) * 4);
+      for (let offset = 0; offset < pixels.length; offset += stride) {
+        colors.add(pixels[offset] + ',' + pixels[offset + 1] + ',' + pixels[offset + 2] + ',' + pixels[offset + 3]);
+        if (colors.size >= 16) break;
+      }
+      return { width: canvas.width, height: canvas.height, colors: colors.size };
+    });
+    const rect = chart?.getBoundingClientRect();
+    return {
+      loading: Boolean(root && !chart && !/failed to load chart data/iu.test(text)),
+      error: /failed to load chart data/iu.test(text),
+      visible: Boolean(rect && rect.width > 0 && rect.height > 0),
+      canvasCount: canvases.length,
+      nonblankCanvasCount: samples.filter((sample) => sample.colors >= 4).length,
+      samples,
+    };
+  })()`);
+}
+
 runAdapter(async (input) => {
   const market = marketSymbol(input);
   if (!market) throw new Error('metamask.perps.compare_provider_market requires market=<symbol>.');
@@ -45,6 +81,23 @@ runAdapter(async (input) => {
   return withExtensionPage(input, async (page) => {
     await page.navigateHash(`#/perps/market/${encodeURIComponent(market)}`);
     await page.waitForSelector(dataTestId('perps-market-detail-pair'), { timeoutMs: 20_000 });
+    const chartSamples = [];
+    const chartDeadline = Date.now() + 15_000;
+    let loadingObserved = false;
+    while (true) {
+      const sample = await readChartSample(page);
+      loadingObserved ||= sample.loading;
+      if (sample.visible && sample.canvasCount > 0 && sample.nonblankCanvasCount > 0) {
+        chartSamples.push(sample);
+        break;
+      }
+      if (sample.error || Date.now() >= chartDeadline) {
+        throw new Error('Visible market chart did not resolve to a nonblank canvas.');
+      }
+      await page.evaluate('new Promise((resolve) => setTimeout(resolve, 200))');
+    }
+    await page.evaluate('new Promise((resolve) => setTimeout(resolve, 1100))');
+    chartSamples.push(await readChartSample(page));
     const visible = await page.evaluate(`(() => {
       const read = (testId) => String(document.querySelector('[data-testid="' + testId + '"]')?.innerText || '').replace(/\\s+/gu, ' ').trim();
       const text = read('perps-market-detail-page');
@@ -55,17 +108,26 @@ runAdapter(async (input) => {
         pair: read('perps-market-detail-pair'),
         maxLeverage: read('perps-market-max-leverage'),
         price: read('perps-market-detail-price'),
+        change24h: read('perps-market-detail-change'),
         volume: after('24h Volume'),
         openInterest: after('Open interest'),
         fundingRate: after('Funding rate'),
+        fundingCountdown: text.match(/Funding rate\\s+[^\\s]+\\s+\\((\\d{2}:\\d{2}:\\d{2})\\)/u)?.[1] ?? null,
         oraclePrice: read('perps-market-detail-oracle-price'),
         favoriteLabel: String(document.querySelector('[data-testid="perps-market-detail-favorite-button"]')?.getAttribute('aria-label') || '').trim(),
       };
     })()`);
+    await page.evaluate('new Promise((resolve) => setTimeout(resolve, 1100))');
+    const nextFundingCountdown = await page.evaluate(`(() => {
+      const text = String(document.querySelector('[data-testid="perps-market-detail-page"]')?.innerText || '').replace(/\\s+/gu, ' ').trim();
+      return text.match(/Funding rate\\s+[^\\s]+\\s+\\((\\d{2}:\\d{2}:\\d{2})\\)/u)?.[1] ?? null;
+    })()`);
     const provider = {
       symbol: metadata.name,
       maxLeverage: Number(metadata.maxLeverage),
       markPrice: Number(context.markPx),
+      change24hPercent:
+        ((Number(context.markPx) - Number(context.prevDayPx)) / Number(context.prevDayPx)) * 100,
       oraclePrice: Number(context.oraclePx),
       volume24hUsd: Number(context.dayNtlVlm),
       openInterestUsd: Number(context.openInterest) * Number(context.markPx),
@@ -73,6 +135,7 @@ runAdapter(async (input) => {
     };
     const observed = {
       price: numeric(visible.price),
+      change24hPercent: numeric(visible.change24h),
       oraclePrice: numeric(visible.oraclePrice),
       volume24hUsd: compactUsd(visible.volume),
       openInterestUsd: compactUsd(visible.openInterest),
@@ -85,11 +148,23 @@ runAdapter(async (input) => {
       name: visible.name.length > 0,
       maxLeverage: observed.maxLeverage === provider.maxLeverage,
       price: observed.price != null && relativeDifference(observed.price, provider.markPrice) <= 0.02,
+      change24h:
+        observed.change24hPercent != null &&
+        Number.isFinite(provider.change24hPercent) &&
+        Math.abs(observed.change24hPercent - provider.change24hPercent) <= 0.15,
       oraclePrice: observed.oraclePrice != null && relativeDifference(observed.oraclePrice, provider.oraclePrice) <= 0.02,
       volume24hUsd: observed.volume24hUsd != null && relativeDifference(observed.volume24hUsd, provider.volume24hUsd) <= 0.05,
       openInterestUsd: observed.openInterestUsd != null && relativeDifference(observed.openInterestUsd, provider.openInterestUsd) <= 0.05,
       fundingRate: observed.fundingRate != null && Math.abs(observed.fundingRate - provider.fundingRate) <= 0.00001,
+      fundingCountdown:
+        countdownSeconds(visible.fundingCountdown) != null &&
+        countdownSeconds(nextFundingCountdown) != null &&
+        ((countdownSeconds(visible.fundingCountdown) - countdownSeconds(nextFundingCountdown) + 3600) % 3600) >= 1 &&
+        ((countdownSeconds(visible.fundingCountdown) - countdownSeconds(nextFundingCountdown) + 3600) % 3600) <= 3,
       favoriteState: /favorites?/iu.test(visible.favoriteLabel),
+      chartNonblank:
+        chartSamples.length === 2 &&
+        chartSamples.every((sample) => sample.error === false && sample.visible && sample.nonblankCanvasCount > 0),
     };
     const failed = Object.entries(checks).filter(([, passed]) => !passed).map(([name]) => name);
     if (failed.length > 0) {
@@ -102,6 +177,8 @@ runAdapter(async (input) => {
       visible,
       observed,
       provider,
+      chart: { loadingObserved, samples: chartSamples },
+      nextFundingCountdown,
       checks,
       proofPath: 'visible-ui-plus-live-provider',
     };