refactor: add confirmation refresher

Author: stanleyyconsensys

packages/snap/src/context.ts

@@ -14,6 +14,10 @@ import { ComputeFeeHandler } from './handlers/clientRequest/computeFee';
 import { SignAndSendTransactionHandler } from './handlers/clientRequest/signAndSendTransaction';
 import type { ICronjobRequestHandler } from './handlers/cronjob/api';
 import { BackgroundEventMethod } from './handlers/cronjob/api';
+import {
+  ConfirmationPriceRefresher,
+  RefreshConfirmationContextHandler,
+} from './handlers/cronjob/refreshConfirmationContext';
 import { RefreshConfirmationPricesHandler } from './handlers/cronjob/refreshConfirmationPrices';
 import { SyncAccountsHandler } from './handlers/cronjob/syncAccounts';
 import { TrackTransactionHandler } from './handlers/cronjob/trackTransaction';
@@ -166,6 +170,19 @@ const refreshConfirmationPricesHandler = new RefreshConfirmationPricesHandler({
   confirmationUIController,
 });
 
+const confirmationPriceRefresher = new ConfirmationPriceRefresher({
+  logger,
+  priceService,
+});
+
+const refreshConfirmationContextHandler = new RefreshConfirmationContextHandler(
+  {
+    logger,
+    confirmationUIController,
+    refreshers: [confirmationPriceRefresher],
+  },
+);
+
 const trackTransactionHandler = new TrackTransactionHandler({
   logger,
   networkService,
@@ -186,6 +203,8 @@ const cronjobMethodHandlers: Record<
 > = {
   [BackgroundEventMethod.RefreshConfirmationPrices]:
     refreshConfirmationPricesHandler,
+  [BackgroundEventMethod.RefreshConfirmationContext]:
+    refreshConfirmationContextHandler,
   [BackgroundEventMethod.TrackTransaction]: trackTransactionHandler,
   [BackgroundEventMethod.SynchronizeAccounts]: syncAccountsHandler,
 };

packages/snap/src/handlers/cronjob/api.test.ts

@@ -4,6 +4,7 @@ import {
   BackgroundEventMethod,
   BackgroundEventMethodStruct,
   CronjobJsonRpcRequestStruct,
+  RefreshConfirmationContextJsonRpcRequestStruct,
   RefreshConfirmationPricesJsonRpcRequestStruct,
   SyncAccountJsonRpcRequestStruct,
   SyncAccountParamsStruct,
@@ -150,6 +151,32 @@ describe('Cronjob API structs', () => {
     });
   });
 
+  describe('RefreshConfirmationContextJsonRpcRequestStruct', () => {
+    it('accepts refresh confirmation context requests', () => {
+      const value = {
+        ...jsonRpcBase,
+        method: BackgroundEventMethod.RefreshConfirmationContext,
+        params: {
+          scope: KnownCaip2ChainId.Mainnet,
+          interfaceId: 'interface-id',
+          interfaceKey: ConfirmationInterfaceKey.SignTransaction,
+          refresherKeys: ['prices'],
+        },
+      };
+      assert(value, RefreshConfirmationContextJsonRpcRequestStruct);
+      expect(value).toStrictEqual({
+        ...jsonRpcBase,
+        method: BackgroundEventMethod.RefreshConfirmationContext,
+        params: {
+          scope: KnownCaip2ChainId.Mainnet,
+          interfaceId: 'interface-id',
+          interfaceKey: ConfirmationInterfaceKey.SignTransaction,
+          refresherKeys: ['prices'],
+        },
+      });
+    });
+  });
+
   describe('TrackTransactionJsonRpcRequestStruct', () => {
     it('accepts track transaction requests', () => {
       const value = {

packages/snap/src/handlers/cronjob/api.ts

@@ -21,6 +21,7 @@ import {
   KnownCaip2ChainIdStruct,
   UuidStruct,
 } from '../../api';
+import { ConfirmationContextRefresherKeyStruct } from './refreshConfirmationContext/api';
 import { ConfirmationInterfaceKeyStruct } from '../../ui/confirmation/api';
 
 /**
@@ -34,6 +35,7 @@ export enum BackgroundEventMethod {
   SynchronizeAccounts = 'synchronizeAccounts',
   RefreshConfirmationPrices = 'refreshConfirmationPrices',
   TrackTransaction = 'trackTransaction',
+  RefreshConfirmationContext = 'refreshConfirmationContext',
 }
 
 export const BackgroundEventMethodStruct = enums(
@@ -46,6 +48,22 @@ export const RefreshConfirmationPricesParamsStruct = type({
   interfaceKey: ConfirmationInterfaceKeyStruct,
 });
 
+export const RefreshConfirmationContextParamsStruct = type({
+  scope: KnownCaip2ChainIdStruct,
+  interfaceId: nonempty(string()),
+  interfaceKey: ConfirmationInterfaceKeyStruct,
+  /** Refresher keys to run; omitted keys are skipped for this cycle. */
+  refresherKeys: nonempty(array(ConfirmationContextRefresherKeyStruct)),
+});
+
+export const RefreshConfirmationContextJsonRpcRequestStruct = assign(
+  JsonRpcRequestStruct,
+  object({
+    method: literal(BackgroundEventMethod.RefreshConfirmationContext),
+    params: RefreshConfirmationContextParamsStruct,
+  }),
+);
+
 export const TrackTransactionParamsStruct = type({
   txId: nonempty(string()),
   scope: KnownCaip2ChainIdStruct,
@@ -112,3 +130,11 @@ export type SyncAccountJsonRpcRequest = Infer<
 >;
 
 export type SyncAccountParams = Infer<typeof SyncAccountParamsStruct>;
+
+export type RefreshConfirmationContextJsonRpcRequest = Infer<
+  typeof RefreshConfirmationContextJsonRpcRequestStruct
+>;
+
+export type RefreshConfirmationContextParams = Infer<
+  typeof RefreshConfirmationContextParamsStruct
+>;

packages/snap/src/handlers/cronjob/refreshConfirmationContext/__fixtures__/context.fixtures.ts

@@ -0,0 +1,43 @@
+import { KnownCaip2ChainId } from '../../../../api';
+import {
+  ConfirmationInterfaceKey,
+  type ContextWithPrices,
+  FetchStatus,
+} from '../../../../ui/confirmation/api';
+import { getSlip44AssetId } from '../../../../utils';
+import type { RefreshConfirmationContextParams } from '../../api';
+import {
+  ConfirmationContextRefresherKey,
+  type ConfirmationDataContext,
+} from '../api';
+
+const scope = KnownCaip2ChainId.Testnet;
+const nativeAssetId = getSlip44AssetId(scope);
+
+export const confirmationContextRequestParams: RefreshConfirmationContextParams =
+  {
+    scope,
+    interfaceId: 'interface-id-1',
+    interfaceKey: ConfirmationInterfaceKey.SignTransaction,
+    refresherKeys: [ConfirmationContextRefresherKey.Prices],
+  };
+
+/**
+ * Builds a valid confirmation refresh context for tests.
+ *
+ * @param overrides - Partial fields to override on the default context.
+ * @returns A context that satisfies {@link ContextWithPricesStruct}.
+ */
+export function createConfirmationDataContext(
+  overrides: Partial<ConfirmationDataContext> = {},
+): ConfirmationDataContext {
+  return {
+    tokenPrices: {
+      [nativeAssetId]: null,
+    } as ContextWithPrices['tokenPrices'],
+    tokenPricesFetchStatus: FetchStatus.Fetching,
+    currency: 'usd',
+    preferences: { useExternalPricingData: true },
+    ...overrides,
+  };
+}

packages/snap/src/handlers/cronjob/refreshConfirmationContext/api.ts

@@ -0,0 +1,65 @@
+import { enums } from '@metamask/superstruct';
+import type { Json } from '@metamask/utils';
+
+import type { ContextWithPrices } from '../../../ui/confirmation/api';
+
+/** Identifies which confirmation context refreshers to run for a cron cycle. */
+export enum ConfirmationContextRefresherKey {
+  Prices = 'prices',
+  /** TODO: Reserved for security scan; wire in context when implemented. */
+  Scan = 'scan',
+}
+
+export const ConfirmationContextRefresherKeyStruct = enums(
+  Object.values(ConfirmationContextRefresherKey),
+);
+
+/**
+ * Context the handler passes to refreshers.
+ */
+export type ConfirmationDataContext = Record<string, Json> & ContextWithPrices;
+
+/** Outcome of one refresher cycle. `null` means no work was needed. */
+export type ConfirmationContextRefreshResult = {
+  result: Record<string, Json>;
+  reschedule: boolean;
+} | null;
+
+/**
+ * Contract for a single background data source (prices, security scan, …).
+ */
+export type IConfirmationContextRefresher = {
+  /** Stable id used in cron params to select this refresher. */
+  readonly key: ConfirmationContextRefresherKey;
+
+  /**
+   * Returns whether this cycle should call.
+   * When false, the handler uses {@link IConfirmationContextRefresher.recoveryResult} instead.
+   */
+  shouldFetch: (ctx: ConfirmationDataContext) => boolean;
+
+  /**
+   * Patch applied when {@link IConfirmationContextRefresher.shouldFetch} is false
+   * (e.g. clear a stuck loading state). Return `null` when the context is already settled.
+   */
+  recoveryResult: (
+    ctx: ConfirmationDataContext,
+  ) => ConfirmationContextRefreshResult;
+
+  /**
+   * Fetches fresh data when {@link IConfirmationContextRefresher.shouldFetch} is true.
+   */
+  refresh: (
+    ctx: ConfirmationDataContext,
+  ) => Promise<ConfirmationContextRefreshResult>;
+
+  /**
+   * Returns false when this refresher cannot safely read `ctx` (missing or
+   * malformed fields). Only enabled refreshers (by key) are validated and run.
+   */
+  isValidContext: (ctx: Record<string, Json>) => boolean;
+};
+
+/** Composed refreshers passed into the confirmation context handler. */
+export type ConfirmationContextRefreshers =
+  readonly IConfirmationContextRefresher[];