Add snap_getState, snap_setState, snap_clearState methods

Author: Mrtenz

packages/examples/packages/manage-state/src/index.test.ts

@@ -20,13 +20,13 @@ describe('onRpcRequest', () => {
     });
   });
 
-  describe('setState', () => {
+  describe('legacy_legacy_setState', () => {
     it('sets the state to the params', async () => {
       const { request } = await installSnap();
 
       expect(
         await request({
-          method: 'setState',
+          method: 'legacy_legacy_setState',
           params: {
             items: ['foo'],
           },
@@ -35,7 +35,7 @@ describe('onRpcRequest', () => {
 
       expect(
         await request({
-          method: 'getState',
+          method: 'legacy_getState',
         }),
       ).toRespondWith({
         items: ['foo'],
@@ -47,7 +47,7 @@ describe('onRpcRequest', () => {
 
       expect(
         await request({
-          method: 'setState',
+          method: 'legacy_legacy_setState',
           params: {
             items: ['foo'],
             encrypted: false,
@@ -57,15 +57,15 @@ describe('onRpcRequest', () => {
 
       expect(
         await request({
-          method: 'getState',
+          method: 'legacy_getState',
         }),
       ).toRespondWith({
         items: [],
       });
 
       expect(
         await request({
-          method: 'getState',
+          method: 'legacy_getState',
           params: {
             encrypted: false,
           },
@@ -76,12 +76,12 @@ describe('onRpcRequest', () => {
     });
   });
 
-  describe('getState', () => {
+  describe('legacy_getState', () => {
     it('returns the state if no state has been set', async () => {
       const { request } = await installSnap();
 
       const response = await request({
-        method: 'getState',
+        method: 'legacy_getState',
       });
 
       expect(response).toRespondWith({
@@ -93,14 +93,14 @@ describe('onRpcRequest', () => {
       const { request } = await installSnap();
 
       await request({
-        method: 'setState',
+        method: 'legacy_setState',
         params: {
           items: ['foo'],
         },
       });
 
       const response = await request({
-        method: 'getState',
+        method: 'legacy_getState',
       });
 
       expect(response).toRespondWith({
@@ -118,7 +118,7 @@ describe('onRpcRequest', () => {
       });
 
       const response = await request({
-        method: 'getState',
+        method: 'legacy_getState',
         params: {
           encrypted: false,
         },
@@ -130,26 +130,26 @@ describe('onRpcRequest', () => {
     });
   });
 
-  describe('clearState', () => {
+  describe('legacy_clearState', () => {
     it('clears the state', async () => {
       const { request } = await installSnap();
 
       await request({
-        method: 'setState',
+        method: 'legacy_setState',
         params: {
           items: ['foo'],
         },
       });
 
       expect(
         await request({
-          method: 'clearState',
+          method: 'legacy_clearState',
         }),
       ).toRespondWith(true);
 
       expect(
         await request({
-          method: 'getState',
+          method: 'legacy_getState',
         }),
       ).toRespondWith({
         items: [],
@@ -160,7 +160,7 @@ describe('onRpcRequest', () => {
       const { request } = await installSnap();
 
       await request({
-        method: 'setState',
+        method: 'legacy_setState',
         params: {
           items: ['foo'],
           encrypted: false,
@@ -169,7 +169,7 @@ describe('onRpcRequest', () => {
 
       expect(
         await request({
-          method: 'clearState',
+          method: 'legacy_clearState',
           params: {
             encrypted: false,
           },
@@ -178,7 +178,7 @@ describe('onRpcRequest', () => {
 
       expect(
         await request({
-          method: 'getState',
+          method: 'legacy_getState',
           params: {
             encrypted: false,
           },

packages/examples/packages/manage-state/src/index.ts

@@ -3,7 +3,7 @@ import {
   type OnRpcRequestHandler,
 } from '@metamask/snaps-sdk';
 
-import type { BaseParams, SetStateParams } from './types';
+import type { BaseParams, LegacySetStateParams, SetStateParams } from './types';
 import { clearState, getState, setState } from './utils';
 
 /**
@@ -34,21 +34,55 @@ export const onRpcRequest: OnRpcRequestHandler = async ({ request }) => {
   switch (request.method) {
     case 'setState': {
       const params = request.params as SetStateParams;
+      return await snap.request({
+        method: 'snap_setState',
+        params: {
+          key: params?.key,
+          value: params?.value,
+          encrypted: params?.encrypted,
+        },
+      });
+    }
 
+    case 'getState': {
+      const params = request.params as BaseParams;
+      return await snap.request({
+        method: 'snap_getState',
+        params: {
+          key: params?.key,
+          encrypted: params?.encrypted,
+        },
+      });
+    }
+
+    case 'clearState': {
+      const params = request.params as BaseParams;
+      return await snap.request({
+        method: 'snap_clearState',
+        params: {
+          encrypted: params?.encrypted,
+        },
+      });
+    }
+
+    case 'legacy_setState': {
+      const params = request.params as LegacySetStateParams;
       if (params.items) {
         await setState({ items: params.items }, params.encrypted);
       }
+
       return true;
     }
 
-    case 'getState': {
+    case 'legacy_getState': {
       const params = request.params as BaseParams;
-      return await getState(params?.encrypted);
+      return await getState(params.encrypted);
     }
 
-    case 'clearState': {
+    case 'legacy_clearState': {
       const params = request.params as BaseParams;
       await clearState(params?.encrypted);
+
       return true;
     }
 

packages/examples/packages/manage-state/src/types.ts

@@ -1,10 +1,17 @@
+import type { Json } from '@metamask/utils';
+
 import type { State } from './utils';
 
-export type BaseParams = { encrypted?: boolean };
+export type BaseParams = { key?: string; encrypted?: boolean };
 
 /**
  * The parameters for the `setState` JSON-RPC method.
- *
- * The current state will be merged with the new state.
  */
-export type SetStateParams = BaseParams & Partial<State>;
+export type SetStateParams = BaseParams & {
+  value: Json;
+};
+
+/**
+ * The parameters for the `legacy_setState` JSON-RPC method.
+ */
+export type LegacySetStateParams = BaseParams & Partial<State>;

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

@@ -0,0 +1,121 @@
+import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';
+import type { PermittedHandlerExport } from '@metamask/permission-controller';
+import { providerErrors, rpcErrors } from '@metamask/rpc-errors';
+import type { ClearStateParams, ClearStateResult } from '@metamask/snaps-sdk';
+import { type InferMatching } from '@metamask/snaps-utils';
+import {
+  boolean,
+  create,
+  object,
+  optional,
+  StructError,
+} from '@metamask/superstruct';
+import type { PendingJsonRpcResponse, JsonRpcRequest } from '@metamask/utils';
+
+import type { MethodHooksObject } from '../utils';
+
+const hookNames: MethodHooksObject<ClearStateHooks> = {
+  clearSnapState: true,
+  hasPermission: true,
+};
+
+/**
+ * `snap_clearState` clears the state of the Snap.
+ */
+export const clearStateHandler: PermittedHandlerExport<
+  ClearStateHooks,
+  ClearStateParameters,
+  ClearStateResult
+> = {
+  methodNames: ['snap_clearState'],
+  implementation: clearStateImplementation,
+  hookNames,
+};
+
+export type ClearStateHooks = {
+  /**
+   * A function that clears the state of the requesting Snap.
+   */
+  clearSnapState: (snapId: string, encrypted: boolean) => void;
+
+  /**
+   * Check if the requesting origin has a given permission.
+   *
+   * @param permissionName - The name of the permission to check.
+   * @returns Whether the origin has the permission.
+   */
+  hasPermission: (permissionName: string) => boolean;
+};
+
+const ClearStateParametersStruct = object({
+  encrypted: optional(boolean()),
+});
+
+export type ClearStateParameters = InferMatching<
+  typeof ClearStateParametersStruct,
+  ClearStateParams
+>;
+
+/**
+ * The `snap_clearState` method implementation.
+ *
+ * @param request - The JSON-RPC request object.
+ * @param response - The JSON-RPC response object.
+ * @param _next - The `json-rpc-engine` "next" callback. Not used by this
+ * function.
+ * @param end - The `json-rpc-engine` "end" callback.
+ * @param hooks - The RPC method hooks.
+ * @param hooks.clearSnapState - A function that clears the state of the
+ * requesting Snap.
+ * @param hooks.hasPermission - Check whether a given origin has a given
+ * permission.
+ * @returns Nothing.
+ */
+async function clearStateImplementation(
+  request: JsonRpcRequest<ClearStateParameters>,
+  response: PendingJsonRpcResponse<ClearStateResult>,
+  _next: unknown,
+  end: JsonRpcEngineEndCallback,
+  { clearSnapState, hasPermission }: ClearStateHooks,
+): Promise<void> {
+  const { params } = request;
+
+  if (!hasPermission('snap_manageState')) {
+    return end(providerErrors.unauthorized());
+  }
+
+  try {
+    const validatedParams = getValidatedParams(params);
+    const { encrypted = true } = validatedParams;
+
+    // We expect the MM middleware stack to always add the origin to requests
+    const { origin } = request as JsonRpcRequest & { origin: string };
+    clearSnapState(origin, encrypted);
+
+    response.result = null;
+  } catch (error) {
+    return end(error);
+  }
+
+  return end();
+}
+
+/**
+ * Validate the parameters of the `snap_clearState` method.
+ *
+ * @param params - The parameters to validate.
+ * @returns The validated parameters.
+ */
+function getValidatedParams(params?: unknown) {
+  try {
+    return create(params, ClearStateParametersStruct);
+  } catch (error) {
+    if (error instanceof StructError) {
+      throw rpcErrors.invalidParams({
+        message: `Invalid params: ${error.message}.`,
+      });
+    }
+
+    throw error;
+  }
+}