Merge branch 'main' into hm/update-notification-example

Author: hmalik88

package.json

@@ -37,6 +37,7 @@
     "test:clean": "yarn workspaces foreach --all --parallel --verbose run test:clean",
     "test:verbose": "yarn workspaces foreach --all --parallel --verbose run test:verbose",
     "test:watch": "yarn workspaces foreach --all --parallel --verbose run test:watch",
+    "update-chrome": "./scripts/update-chrome.sh",
     "update-readme-content": "tsx ./scripts/update-readme-content.mts"
   },
   "simple-git-hooks": {
@@ -88,7 +89,7 @@
     "@typescript-eslint/eslint-plugin": "^5.42.1",
     "@typescript-eslint/parser": "^6.21.0",
     "@yarnpkg/types": "^4.0.0",
-    "chromedriver": "^129.0.2",
+    "chromedriver": "^131.0.5",
     "depcheck": "^1.4.7",
     "eslint": "^8.27.0",
     "eslint-config-prettier": "^8.5.0",

packages/examples/packages/browserify-plugin/snap.manifest.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/MetaMask/snaps.git"
   },
   "source": {
-    "shasum": "hy0TMeQeqznNQRX2j7DnxRt1Nn5Z+v0rjaWNpe1fEWE=",
+    "shasum": "nWxYWnUSrrm7uZeqQoIaP3l1hbk2ZWRKGULlxodyuhw=",
     "location": {
       "npm": {
         "filePath": "dist/bundle.js",

packages/examples/packages/browserify/snap.manifest.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/MetaMask/snaps.git"
   },
   "source": {
-    "shasum": "VR3Zwjo0yqKLkuKHGDfS9AmuyW3KMbXSmi9Nh9JgCMw=",
+    "shasum": "WnX2s+XAfT18c6WH1hAniRAIgDEe7VyAieuRXFEDIEY=",
     "location": {
       "npm": {
         "filePath": "dist/bundle.js",

packages/snaps-rpc-methods/jest.config.js

@@ -10,10 +10,10 @@ module.exports = deepmerge(baseConfig, {
   ],
   coverageThreshold: {
     global: {
-      branches: 93.91,
-      functions: 98.02,
-      lines: 98.65,
-      statements: 98.24,
+      branches: 93.97,
+      functions: 98.05,
+      lines: 98.67,
+      statements: 98.25,
     },
   },
 });

packages/snaps-rpc-methods/src/permitted/scheduleBackgroundEvent.test.ts

@@ -120,6 +120,105 @@ describe('snap_scheduleBackgroundEvent', () => {
       });
     });
 
+    it('schedules a background event using duration', async () => {
+      const { implementation } = scheduleBackgroundEventHandler;
+
+      const scheduleBackgroundEvent = jest.fn();
+      const hasPermission = jest.fn().mockImplementation(() => true);
+
+      const hooks = {
+        scheduleBackgroundEvent,
+        hasPermission,
+      };
+
+      const engine = new JsonRpcEngine();
+
+      engine.push(createOriginMiddleware(MOCK_SNAP_ID));
+      engine.push((request, response, next, end) => {
+        const result = implementation(
+          request as JsonRpcRequest<ScheduleBackgroundEventParams>,
+          response as PendingJsonRpcResponse<ScheduleBackgroundEventResult>,
+          next,
+          end,
+          hooks,
+        );
+
+        result?.catch(end);
+      });
+
+      await engine.handle({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'snap_scheduleBackgroundEvent',
+        params: {
+          duration: 'PT30S',
+          request: {
+            method: 'handleExport',
+            params: ['p1'],
+          },
+        },
+      });
+
+      expect(scheduleBackgroundEvent).toHaveBeenCalledWith({
+        date: expect.any(String),
+        request: {
+          method: 'handleExport',
+          params: ['p1'],
+        },
+      });
+    });
+
+    it('throws on an invalid duration', async () => {
+      const { implementation } = scheduleBackgroundEventHandler;
+
+      const scheduleBackgroundEvent = jest.fn();
+      const hasPermission = jest.fn().mockImplementation(() => true);
+
+      const hooks = {
+        scheduleBackgroundEvent,
+        hasPermission,
+      };
+
+      const engine = new JsonRpcEngine();
+
+      engine.push(createOriginMiddleware(MOCK_SNAP_ID));
+      engine.push((request, response, next, end) => {
+        const result = implementation(
+          request as JsonRpcRequest<ScheduleBackgroundEventParams>,
+          response as PendingJsonRpcResponse<ScheduleBackgroundEventResult>,
+          next,
+          end,
+          hooks,
+        );
+
+        result?.catch(end);
+      });
+
+      const response = await engine.handle({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'snap_scheduleBackgroundEvent',
+        params: {
+          duration: 'PQ30S',
+          request: {
+            method: 'handleExport',
+            params: ['p1'],
+          },
+        },
+      });
+
+      expect(response).toStrictEqual({
+        error: {
+          code: -32602,
+          message:
+            'Invalid params: At path: duration -- Not a valid ISO 8601 duration.',
+          stack: expect.any(String),
+        },
+        id: 1,
+        jsonrpc: '2.0',
+      });
+    });
+
     it('throws if a snap does not have the "endowment:cronjob" permission', async () => {
       const { implementation } = scheduleBackgroundEventHandler;
 
@@ -171,7 +270,7 @@ describe('snap_scheduleBackgroundEvent', () => {
       });
     });
 
-    it('throws if no timezone information is provided in the ISO8601 string', async () => {
+    it('throws if no timezone information is provided in the ISO 8601 date', async () => {
       const { implementation } = scheduleBackgroundEventHandler;
 
       const scheduleBackgroundEvent = jest.fn();
@@ -214,7 +313,7 @@ describe('snap_scheduleBackgroundEvent', () => {
         error: {
           code: -32602,
           message:
-            'Invalid params: At path: date -- ISO 8601 string must have timezone information.',
+            'Invalid params: At path: date -- ISO 8601 date must have timezone information.',
           stack: expect.any(String),
         },
         id: 1,
@@ -265,7 +364,7 @@ describe('snap_scheduleBackgroundEvent', () => {
         error: {
           code: -32602,
           message:
-            'Invalid params: At path: date -- Not a valid ISO 8601 string.',
+            'Invalid params: At path: date -- Not a valid ISO 8601 date.',
           stack: expect.any(String),
         },
         id: 1,

packages/snaps-rpc-methods/src/permitted/scheduleBackgroundEvent.ts

@@ -1,10 +1,11 @@
 import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';
 import type { PermittedHandlerExport } from '@metamask/permission-controller';
 import { providerErrors, rpcErrors } from '@metamask/rpc-errors';
-import type {
-  JsonRpcRequest,
-  ScheduleBackgroundEventParams,
-  ScheduleBackgroundEventResult,
+import {
+  selectiveUnion,
+  type JsonRpcRequest,
+  type ScheduleBackgroundEventParams,
+  type ScheduleBackgroundEventResult,
 } from '@metamask/snaps-sdk';
 import type { CronjobRpcRequest } from '@metamask/snaps-utils';
 import {
@@ -18,8 +19,12 @@ import {
   refine,
   string,
 } from '@metamask/superstruct';
-import { assert, type PendingJsonRpcResponse } from '@metamask/utils';
-import { DateTime } from 'luxon';
+import {
+  assert,
+  hasProperty,
+  type PendingJsonRpcResponse,
+} from '@metamask/utils';
+import { DateTime, Duration } from 'luxon';
 
 import { SnapEndowments } from '../endowments';
 import type { MethodHooksObject } from '../utils';
@@ -55,26 +60,61 @@ export const scheduleBackgroundEventHandler: PermittedHandlerExport<
 };
 
 const offsetRegex = /Z|([+-]\d{2}:?\d{2})$/u;
-const ScheduleBackgroundEventsParametersStruct = object({
+
+const ScheduleBackgroundEventParametersWithDateStruct = object({
   date: refine(string(), 'date', (val) => {
     const date = DateTime.fromISO(val);
     if (date.isValid) {
       // Luxon doesn't have a reliable way to check if timezone info was not provided
       if (!offsetRegex.test(val)) {
-        return 'ISO 8601 string must have timezone information';
+        return 'ISO 8601 date must have timezone information';
       }
       return true;
     }
-    return 'Not a valid ISO 8601 string';
+    return 'Not a valid ISO 8601 date';
+  }),
+  request: CronjobRpcRequestStruct,
+});
+
+const ScheduleBackgroundEventParametersWithDurationStruct = object({
+  duration: refine(string(), 'duration', (val) => {
+    const duration = Duration.fromISO(val);
+    if (!duration.isValid) {
+      return 'Not a valid ISO 8601 duration';
+    }
+    return true;
   }),
   request: CronjobRpcRequestStruct,
 });
 
+const ScheduleBackgroundEventParametersStruct = selectiveUnion((val) => {
+  if (hasProperty(val, 'date')) {
+    return ScheduleBackgroundEventParametersWithDateStruct;
+  }
+  return ScheduleBackgroundEventParametersWithDurationStruct;
+});
+
 export type ScheduleBackgroundEventParameters = InferMatching<
-  typeof ScheduleBackgroundEventsParametersStruct,
+  typeof ScheduleBackgroundEventParametersStruct,
   ScheduleBackgroundEventParams
 >;
 
+/**
+ * Generates a `DateTime` object based on if a duration or date is provided.
+ *
+ * @param params - The validated params from the `snap_scheduleBackgroundEvent` call.
+ * @returns A `DateTime` object.
+ */
+function getStartDate(params: ScheduleBackgroundEventParams) {
+  if ('duration' in params) {
+    return DateTime.fromJSDate(new Date())
+      .toUTC()
+      .plus(Duration.fromISO(params.duration));
+  }
+
+  return DateTime.fromISO(params.date, { setZone: true });
+}
+
 /**
  * The `snap_scheduleBackgroundEvent` method implementation.
  *
@@ -107,14 +147,14 @@ async function getScheduleBackgroundEventImplementation(
   try {
     const validatedParams = getValidatedParams(params);
 
-    const { date, request } = validatedParams;
+    const { request } = validatedParams;
+
+    const date = getStartDate(validatedParams);
 
     // Make sure any millisecond precision is removed.
-    const truncatedDate = DateTime.fromISO(date, { setZone: true })
-      .startOf('second')
-      .toISO({
-        suppressMilliseconds: true,
-      });
+    const truncatedDate = date.startOf('second').toISO({
+      suppressMilliseconds: true,
+    });
 
     assert(truncatedDate);
 
@@ -138,7 +178,7 @@ function getValidatedParams(
   params: unknown,
 ): ScheduleBackgroundEventParameters {
   try {
-    return create(params, ScheduleBackgroundEventsParametersStruct);
+    return create(params, ScheduleBackgroundEventParametersStruct);
   } catch (error) {
     if (error instanceof StructError) {
       throw rpcErrors.invalidParams({

packages/snaps-rpc-methods/src/restricted/getPreferences.test.ts

@@ -26,9 +26,11 @@ describe('snap_getPreferences', () => {
   describe('getImplementation', () => {
     it('returns the preferences', async () => {
       const methodHooks = {
-        getPreferences: jest
-          .fn()
-          .mockReturnValue({ locale: 'en', currency: 'usd' }),
+        getPreferences: jest.fn().mockReturnValue({
+          locale: 'en',
+          currency: 'usd',
+          hideBalances: false,
+        }),
       };
 
       const implementation = getImplementation(methodHooks);
@@ -40,7 +42,7 @@ describe('snap_getPreferences', () => {
           },
           method: 'snap_getPreferences',
         }),
-      ).toStrictEqual({ locale: 'en', currency: 'usd' });
+      ).toStrictEqual({ locale: 'en', currency: 'usd', hideBalances: false });
     });
   });
 });

packages/snaps-sdk/src/jsx/components/Value.test.tsx

@@ -1,3 +1,4 @@
+import { Text } from './Text';
 import { Value } from './Value';
 
 describe('Value', () => {
@@ -13,4 +14,36 @@ describe('Value', () => {
       },
     });
   });
+
+  it('renders with text elements', () => {
+    const result = (
+      <Value
+        value={<Text color="error">0.05 ETH</Text>}
+        extra={<Text color="error">$200</Text>}
+      />
+    );
+
+    expect(result).toStrictEqual({
+      type: 'Value',
+      key: null,
+      props: {
+        extra: {
+          type: 'Text',
+          key: null,
+          props: {
+            children: '$200',
+            color: 'error',
+          },
+        },
+        value: {
+          type: 'Text',
+          key: null,
+          props: {
+            children: '0.05 ETH',
+            color: 'error',
+          },
+        },
+      },
+    });
+  });
 });