feat: Add onAssetHistoricalPrice handler

packages/snaps-controllers/coverage.json

@@ -1,6 +1,6 @@
 {
-  "branches": 93.41,
+  "branches": 93.42,
   "functions": 97.38,
   "lines": 98.34,
-  "statements": 98.07
+  "statements": 98.08
 }

packages/snaps-controllers/src/snaps/SnapController.test.tsx

@@ -4354,6 +4354,145 @@ describe('SnapController', () => {
     });
   });
 
+  describe('onAssetHistoricalPrice', () => {
+    it('throws if `onAssetHistoricalPrice` handler returns an invalid response', async () => {
+      const rootMessenger = getControllerMessenger();
+      const messenger = getSnapControllerMessenger(rootMessenger);
+      const snapController = getSnapController(
+        getSnapControllerOptions({
+          messenger,
+          state: {
+            snaps: getPersistedSnapsState(),
+          },
+        }),
+      );
+
+      rootMessenger.registerActionHandler(
+        'PermissionController:getPermissions',
+        () => ({
+          [SnapEndowments.Assets]: {
+            caveats: [
+              {
+                type: SnapCaveatType.ChainIds,
+                value: ['bip122:000000000019d6689c085ae165831e93'],
+              },
+            ],
+            date: 1664187844588,
+            id: 'izn0WGUO8cvq_jqvLQuQP',
+            invoker: MOCK_SNAP_ID,
+            parentCapability: SnapEndowments.Assets,
+          },
+        }),
+      );
+
+      rootMessenger.registerActionHandler(
+        'SubjectMetadataController:getSubjectMetadata',
+        () => MOCK_SNAP_SUBJECT_METADATA,
+      );
+
+      rootMessenger.registerActionHandler(
+        'ExecutionService:handleRpcRequest',
+        async () =>
+          Promise.resolve({
+            historicalPrice: { foo: {} },
+          }),
+      );
+
+      await expect(
+        snapController.handleRequest({
+          snapId: MOCK_SNAP_ID,
+          origin: MOCK_ORIGIN,
+          handler: HandlerType.OnAssetHistoricalPrice,
+          request: {
+            jsonrpc: '2.0',
+            method: ' ',
+            params: {},
+            id: 1,
+          },
+        }),
+      ).rejects.toThrow(
+        `Assertion failed: At path: historicalPrice.intervals -- Expected an object, but received: undefined.`,
+      );
+
+      snapController.destroy();
+    });
+
+    it('returns the value when `onAssetHistoricalPrice` returns a valid response', async () => {
+      const rootMessenger = getControllerMessenger();
+      const messenger = getSnapControllerMessenger(rootMessenger);
+      const snapController = getSnapController(
+        getSnapControllerOptions({
+          messenger,
+          state: {
+            snaps: getPersistedSnapsState(),
+          },
+        }),
+      );
+
+      rootMessenger.registerActionHandler(
+        'PermissionController:getPermissions',
+        () => ({
+          [SnapEndowments.Assets]: {
+            caveats: [
+              {
+                type: SnapCaveatType.ChainIds,
+                value: ['bip122:000000000019d6689c085ae165831e93'],
+              },
+            ],
+            date: 1664187844588,
+            id: 'izn0WGUO8cvq_jqvLQuQP',
+            invoker: MOCK_SNAP_ID,
+            parentCapability: SnapEndowments.Assets,
+          },
+        }),
+      );
+
+      rootMessenger.registerActionHandler(
+        'SubjectMetadataController:getSubjectMetadata',
+        () => MOCK_SNAP_SUBJECT_METADATA,
+      );
+
+      rootMessenger.registerActionHandler(
+        'ExecutionService:handleRpcRequest',
+        async () =>
+          Promise.resolve({
+            historicalPrice: {
+              intervals: {
+                P1D: [[1737548790, '400']],
+              },
+              updateTime: 1737548790,
+            },
+          }),
+      );
+
+      expect(
+        await snapController.handleRequest({
+          snapId: MOCK_SNAP_ID,
+          origin: MOCK_ORIGIN,
+          handler: HandlerType.OnAssetHistoricalPrice,
+          request: {
+            jsonrpc: '2.0',
+            method: ' ',
+            params: {
+              from: 'bip122:000000000019d6689c085ae165831e93/slip44:0',
+              to: 'swift:0/iso4217:USD',
+            },
+            id: 1,
+          },
+        }),
+      ).toStrictEqual({
+        historicalPrice: {
+          intervals: {
+            P1D: [[1737548790, '400']],
+          },
+          updateTime: 1737548790,
+        },
+      });
+
+      snapController.destroy();
+    });
+  });
+
   describe('getRpcRequestHandler', () => {
     it('handlers populate the "jsonrpc" property if missing', async () => {
       const rootMessenger = getControllerMessenger();

packages/snaps-controllers/src/snaps/SnapController.ts

@@ -104,6 +104,7 @@ import {
   MAX_FILE_SIZE,
   OnSettingsPageResponseStruct,
   isValidUrl,
+  OnAssetHistoricalPriceResponseStruct,
 } from '@metamask/snaps-utils';
 import type {
   Json,
@@ -3820,6 +3821,9 @@ export class SnapController extends BaseController<
       case HandlerType.OnAssetsConversion:
         assertStruct(result, OnAssetsConversionResponseStruct);
         break;
+      case HandlerType.OnAssetHistoricalPrice:
+        assertStruct(result, OnAssetHistoricalPriceResponseStruct);
+        break;
       default:
         break;
     }

packages/snaps-execution-environments/coverage.json

@@ -1,6 +1,6 @@
 {
-  "branches": 80.53,
-  "functions": 88.96,
-  "lines": 90.69,
-  "statements": 89.74
+  "branches": 80.66,
+  "functions": 89.1,
+  "lines": 90.78,
+  "statements": 89.72
 }

packages/snaps-execution-environments/src/common/BaseSnapExecutor.test.browser.ts

@@ -1473,6 +1473,60 @@ describe('BaseSnapExecutor', () => {
     });
   });
 
+  it('supports `onAssetHistoricalPrice` export', async () => {
+    const CODE = `
+      module.exports.onAssetHistoricalPrice = () => ({ historicalPrice: {
+        intervals: {
+          'P1D': [
+            [1635724800000, "1"],
+          ]
+        },
+        updateTime: 1635724800000,
+      } });
+    `;
+
+    const executor = new TestSnapExecutor();
+    await executor.executeSnap(1, MOCK_SNAP_ID, CODE, []);
+
+    expect(await executor.readCommand()).toStrictEqual({
+      jsonrpc: '2.0',
+      id: 1,
+      result: 'OK',
+    });
+
+    await executor.writeCommand({
+      jsonrpc: '2.0',
+      id: 2,
+      method: 'snapRpc',
+      params: [
+        MOCK_SNAP_ID,
+        HandlerType.OnAssetHistoricalPrice,
+        MOCK_ORIGIN,
+        {
+          jsonrpc: '2.0',
+          method: '',
+          params: {
+            from: 'bip122:000000000019d6689c085ae165831e93/slip44:0',
+            to: 'swift:0/iso4217:USD',
+          },
+        },
+      ],
+    });
+
+    expect(await executor.readCommand()).toStrictEqual({
+      id: 2,
+      jsonrpc: '2.0',
+      result: {
+        historicalPrice: {
+          intervals: {
+            P1D: [[1635724800000, '1']],
+          },
+          updateTime: 1635724800000,
+        },
+      },
+    });
+  });
+
   it('supports `onAssetsLookup` export', async () => {
     const CODE = `
       module.exports.onAssetsLookup = () => ({ assets: {} });

packages/snaps-execution-environments/src/common/commands.test.ts

@@ -41,6 +41,17 @@ describe('getHandlerArguments', () => {
     ).toThrow('Invalid request params');
   });
 
+  it('validates the request params for the OnAssetHistoricalPrice handler', () => {
+    expect(() =>
+      getHandlerArguments(MOCK_ORIGIN, HandlerType.OnAssetHistoricalPrice, {
+        id: 1,
+        jsonrpc: '2.0',
+        method: 'foo',
+        params: {},
+      }),
+    ).toThrow('Invalid request params');
+  });
+
   it('throws for invalid handler types', () => {
     expect(() =>
       // @ts-expect-error Invalid handler type.

packages/snaps-execution-environments/src/common/commands.ts

@@ -18,6 +18,7 @@ import {
   assertIsOnAssetsLookupRequestArguments,
   assertIsOnAssetsConversionRequestArguments,
   assertIsOnProtocolRequestArguments,
+  assertIsOnAssetHistoricalPriceRequestArguments,
 } from './validation';
 
 export type CommandMethodsMapping = {
@@ -59,6 +60,13 @@ export function getHandlerArguments(
       const { signature, signatureOrigin } = request.params;
       return { signature, signatureOrigin };
     }
+
+    case HandlerType.OnAssetHistoricalPrice: {
+      assertIsOnAssetHistoricalPriceRequestArguments(request.params);
+      const { from, to } = request.params;
+      return { from, to };
+    }
+
     case HandlerType.OnAssetsLookup: {
       assertIsOnAssetsLookupRequestArguments(request.params);
       const { assets } = request.params;

packages/snaps-execution-environments/src/common/validation.test.ts

@@ -1,6 +1,7 @@
 import { UserInputEventType } from '@metamask/snaps-sdk';
 
 import {
+  assertIsOnAssetHistoricalPriceRequestArguments,
   assertIsOnAssetsConversionRequestArguments,
   assertIsOnAssetsLookupRequestArguments,
   assertIsOnNameLookupRequestArguments,
@@ -378,3 +379,48 @@ describe('assertIsOnProtocolRequestArguments', () => {
     },
   );
 });
+
+describe('assertIsOnAssetHistoricalPriceRequestArguments', () => {
+  it.each([
+    {
+      from: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/slip44:501',
+      to: 'swift:0/iso4217:USD',
+    },
+  ])(
+    'does not throw for a valid asset historical price request object',
+    (args) => {
+      expect(() =>
+        assertIsOnAssetHistoricalPriceRequestArguments(args),
+      ).not.toThrow();
+    },
+  );
+
+  it.each([
+    true,
+    false,
+    null,
+    undefined,
+    0,
+    1,
+    '',
+    'foo',
+    [],
+    {},
+    { from: [], to: 'swift:0/iso4217:USD' },
+    { to: 'swift:0/iso4217:USD', from: 'foo' },
+    { from: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/slip44:501' },
+    { to: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/slip44:501' },
+    {
+      from: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/slip44:501',
+      to: 'swift:0/iso4217:USD',
+      foo: 'bar',
+    },
+  ])(
+    'throws if the value is not a valid asset historical price request object',
+    (value) => {
+      expect(() =>
+        assertIsOnAssetHistoricalPriceRequestArguments(value as any),
+      ).toThrow('Invalid request params:');
+    },
+  );
+});