@metamask/snaps-rpc-methods 15.1.0 → 16.0.0

package/dist/permitted/middleware.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.cjs","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":";;;AACA,qDAAiD;AACjD,uDAAiD;AAGjD,6CAA4C;AAC5C,wCAAuC;AAEvC;;;;;;GAMG;AACH,SAAgB,2BAA2B,CACzC,MAAe,EACf,KAA8B;IAE9B,iEAAiE;IACjE,kEAAkE;IAClE,OAAO,KAAK,UAAU,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG;QACjE,MAAM,OAAO,GACX,yBAAc,CAAC,OAAO,CAAC,MAAqC,CAAC,CAAC;QAChE,IAAI,OAAO,EAAE,CAAC;YACZ,IACE,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC;gBACzD,CAAC,MAAM,EACP,CAAC;gBACD,OAAO,GAAG,CAAC,sBAAS,CAAC,cAAc,EAAE,CAAC,CAAC;YACzC,CAAC;YAED,iFAAiF;YACjF,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,GAAG,OAAc,CAAC;YACrD,IAAI,CAAC;gBACH,kEAAkE;gBAClE,OAAO,MAAM,cAAc,CACzB,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,GAAG,EACH,IAAA,mBAAW,EAAC,KAAK,EAAE,SAAS,CAAC,CAC9B,CAAC;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAA,sBAAQ,EAAC,KAAK,CAAC,CAAC;gBAChB,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;QAED,OAAO,IAAI,EAAE,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC;AApCD,kEAoCC","sourcesContent":["import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { logError } from '@metamask/snaps-utils';\nimport type { Json, JsonRpcParams } from '@metamask/utils';\n\nimport { methodHandlers } from './handlers';\nimport { selectHooks } from '../utils';\n\n/**\n * Creates a middleware that handles permitted snap RPC methods.\n *\n * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.\n * @param hooks - An object containing the hooks made available to the permitted RPC methods.\n * @returns The middleware.\n */\nexport function createSnapsMethodMiddleware(\n  isSnap: boolean,\n  hooks: Record<string, unknown>,\n): JsonRpcMiddleware<JsonRpcParams, Json> {\n  // This is not actually a misused promise, the type is just wrong\n  // eslint-disable-next-line @typescript-eslint/no-misused-promises\n  return async function methodMiddleware(request, response, next, end) {\n    const handler =\n      methodHandlers[request.method as keyof typeof methodHandlers];\n    if (handler) {\n      if (\n        String.prototype.startsWith.call(request.method, 'snap_') &&\n        !isSnap\n      ) {\n        return end(rpcErrors.methodNotFound());\n      }\n\n      // TODO: Once json-rpc-engine types are up to date, we should type this correctly\n      const { implementation, hookNames } = handler as any;\n      try {\n        // Implementations may or may not be async, so we must await them.\n        return await implementation(\n          request,\n          response,\n          next,\n          end,\n          selectHooks(hooks, hookNames),\n        );\n      } catch (error) {\n        logError(error);\n        return end(error);\n      }\n    }\n\n    return next();\n  };\n}\n"]}
+{"version":3,"file":"middleware.cjs","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":";;;AAAA,+DAGmC;AAEnC,qDAAiD;AACjD,uDAAiD;AAIjD,uEAAuE;AACvE,iDAAiD;AACjD,yDAAyD;AACzD,2DAA2D;AAC3D,6CAA6C;AAC7C,mDAAmD;AACnD,mEAAmE;AACnE,2DAA2D;AAC3D,2CAA2C;AAC3C,mEAAmE;AACnE,+DAA+D;AAC/D,6CAA6C;AAC7C,6CAA6C;AAC7C,uDAAuD;AACvD,uDAAuD;AACvD,2DAA2D;AAC3D,iEAAiE;AACjE,uDAAuD;AACvD,qDAAqD;AACrD,6DAA6D;AAC7D,2EAA2E;AAC3E,qEAAqE;AACrE,6CAA6C;AAC7C,iDAAiD;AACjD,iDAAiD;AACjD,iDAAiD;AACjD,2DAA2D;AAE3D,yDAAyD;AACzD,MAAM,cAAc,GAAG;IACrB,kBAAkB,EAAE,gCAAkB;IACtC,eAAe,EAAE,0BAAe;IAChC,mBAAmB,EAAE,kCAAmB;IACxC,iBAAiB,EAAE,wCAAsB;IACzC,oBAAoB,EAAE,oCAAoB;IAC1C,eAAe,EAAE,8BAAiB;IAClC,oBAAoB,EAAE,wCAAsB;IAC5C,YAAY,EAAE,wBAAc;IAC5B,aAAa,EAAE,0BAAe;IAC9B,oBAAoB,EAAE,wCAAsB;IAC5C,oBAAoB,EAAE,wCAAsB;IAC5C,sBAAsB,EAAE,4CAAwB;IAChD,wBAAwB,EAAE,gDAA0B;IACpD,uBAAuB,EAAE,8CAAyB;IAClD,qBAAqB,EAAE,0CAAuB;IAC9C,4BAA4B,EAAE,wDAA8B;IAC5D,0BAA0B,EAAE,oDAA4B;IACxD,wBAAwB,EAAE,gDAA0B;IACpD,aAAa,EAAE,0BAAe;IAC9B,eAAe,EAAE,8BAAiB;IAClC,eAAe,EAAE,8BAAiB;IAClC,kBAAkB,EAAE,oCAAoB;IACxC,mBAAmB,EAAE,sCAAqB;IAC1C,yBAAyB,EAAE,kDAA2B;IACtD,kBAAkB,EAAE,oCAAoB;IACxC,eAAe,EAAE,8BAAiB;IAClC,aAAa,EAAE,0BAAe;CAC/B,CAAC;AACF,wDAAwD;AAExD;;;;;;;GAOG;AACH,SAAgB,2BAA2B,CACzC,MAAe,EACf,KAA8B,EAC9B,SAAuD;IAEvD,MAAM,gBAAgB,GAAG,IAAA,wCAAsB,EAAC;QAC9C,QAAQ,EAAE,cAAc;QACxB,KAAK;QACL,SAAS;QACT,OAAO,EAAE,sBAAQ;KAClB,CAAC,CAAC;IAEH,iEAAiE;IACjE,kEAAkE;IAClE,OAAO,KAAK,UAAU,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG;QACjE,IAAI,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACzE,OAAO,GAAG,CAAC,sBAAS,CAAC,cAAc,EAAE,CAAC,CAAC;QACzC,CAAC;QAED,OAAO,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;IACxD,CAAC,CAAC;AACJ,CAAC;AArBD,kEAqBC","sourcesContent":["import {\n  createMethodMiddleware,\n  type JsonRpcMiddleware,\n} from '@metamask/json-rpc-engine';\nimport type { Messenger } from '@metamask/messenger';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { logError } from '@metamask/snaps-utils';\nimport type { Json, JsonRpcParams } from '@metamask/utils';\n\nimport type { PermittedRpcMethodActions, PermittedRpcMethodHooks } from '.';\nimport { cancelBackgroundEventHandler } from './cancelBackgroundEvent';\nimport { clearStateHandler } from './clearState';\nimport { closeWebSocketHandler } from './closeWebSocket';\nimport { createInterfaceHandler } from './createInterface';\nimport { endTraceHandler } from './endTrace';\nimport { getAllSnapsHandler } from './getAllSnaps';\nimport { getBackgroundEventsHandler } from './getBackgroundEvents';\nimport { getClientStatusHandler } from './getClientStatus';\nimport { getFileHandler } from './getFile';\nimport { getInterfaceContextHandler } from './getInterfaceContext';\nimport { getInterfaceStateHandler } from './getInterfaceState';\nimport { getSnapsHandler } from './getSnaps';\nimport { getStateHandler } from './getState';\nimport { getWebSocketsHandler } from './getWebSockets';\nimport { invokeKeyringHandler } from './invokeKeyring';\nimport { invokeSnapSugarHandler } from './invokeSnapSugar';\nimport { listEntropySourcesHandler } from './listEntropySources';\nimport { openWebSocketHandler } from './openWebSocket';\nimport { requestSnapsHandler } from './requestSnaps';\nimport { resolveInterfaceHandler } from './resolveInterface';\nimport { scheduleBackgroundEventHandler } from './scheduleBackgroundEvent';\nimport { sendWebSocketMessageHandler } from './sendWebSocketMessage';\nimport { setStateHandler } from './setState';\nimport { startTraceHandler } from './startTrace';\nimport { trackErrorHandler } from './trackError';\nimport { trackEventHandler } from './trackEvent';\nimport { updateInterfaceHandler } from './updateInterface';\n\n/* eslint-disable @typescript-eslint/naming-convention */\nconst methodHandlers = {\n  wallet_getAllSnaps: getAllSnapsHandler,\n  wallet_getSnaps: getSnapsHandler,\n  wallet_requestSnaps: requestSnapsHandler,\n  wallet_invokeSnap: invokeSnapSugarHandler,\n  wallet_invokeKeyring: invokeKeyringHandler,\n  snap_clearState: clearStateHandler,\n  snap_getClientStatus: getClientStatusHandler,\n  snap_getFile: getFileHandler,\n  snap_getState: getStateHandler,\n  snap_createInterface: createInterfaceHandler,\n  snap_updateInterface: updateInterfaceHandler,\n  snap_getInterfaceState: getInterfaceStateHandler,\n  snap_getInterfaceContext: getInterfaceContextHandler,\n  snap_listEntropySources: listEntropySourcesHandler,\n  snap_resolveInterface: resolveInterfaceHandler,\n  snap_scheduleBackgroundEvent: scheduleBackgroundEventHandler,\n  snap_cancelBackgroundEvent: cancelBackgroundEventHandler,\n  snap_getBackgroundEvents: getBackgroundEventsHandler,\n  snap_setState: setStateHandler,\n  snap_trackError: trackErrorHandler,\n  snap_trackEvent: trackEventHandler,\n  snap_openWebSocket: openWebSocketHandler,\n  snap_closeWebSocket: closeWebSocketHandler,\n  snap_sendWebSocketMessage: sendWebSocketMessageHandler,\n  snap_getWebSockets: getWebSocketsHandler,\n  snap_startTrace: startTraceHandler,\n  snap_endTrace: endTraceHandler,\n};\n/* eslint-enable @typescript-eslint/naming-convention */\n\n/**\n * Creates a middleware that handles permitted snap RPC methods.\n *\n * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.\n * @param hooks - An object containing the hooks made available to the permitted RPC methods.\n * @param messenger - The messenger.\n * @returns The middleware.\n */\nexport function createSnapsMethodMiddleware(\n  isSnap: boolean,\n  hooks: PermittedRpcMethodHooks,\n  messenger: Messenger<string, PermittedRpcMethodActions>,\n): JsonRpcMiddleware<JsonRpcParams, Json> {\n  const nestedMiddleware = createMethodMiddleware({\n    handlers: methodHandlers,\n    hooks,\n    messenger,\n    onError: logError,\n  });\n\n  // This is not actually a misused promise, the type is just wrong\n  // eslint-disable-next-line @typescript-eslint/no-misused-promises\n  return async function methodMiddleware(request, response, next, end) {\n    if (String.prototype.startsWith.call(request.method, 'snap_') && !isSnap) {\n      return end(rpcErrors.methodNotFound());\n    }\n\n    return nestedMiddleware(request, response, next, end);\n  };\n}\n"]}

package/dist/permitted/middleware.d.cts

@@ -1,11 +1,14 @@
-import type { JsonRpcMiddleware } from "@metamask/json-rpc-engine";
+import { type JsonRpcMiddleware } from "@metamask/json-rpc-engine";
+import type { Messenger } from "@metamask/messenger";
 import type { Json, JsonRpcParams } from "@metamask/utils";
+import type { PermittedRpcMethodActions, PermittedRpcMethodHooks } from "./index.cjs";
 /**
  * Creates a middleware that handles permitted snap RPC methods.
  *
  * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.
  * @param hooks - An object containing the hooks made available to the permitted RPC methods.
+ * @param messenger - The messenger.
  * @returns The middleware.
  */
-export declare function createSnapsMethodMiddleware(isSnap: boolean, hooks: Record<string, unknown>): JsonRpcMiddleware<JsonRpcParams, Json>;
+export declare function createSnapsMethodMiddleware(isSnap: boolean, hooks: PermittedRpcMethodHooks, messenger: Messenger<string, PermittedRpcMethodActions>): JsonRpcMiddleware<JsonRpcParams, Json>;
 //# sourceMappingURL=middleware.d.cts.map

package/dist/permitted/middleware.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.cts","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kCAAkC;AAGnE,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,wBAAwB;AAK3D;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAiCxC"}
+{"version":3,"file":"middleware.d.cts","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACvB,kCAAkC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,4BAA4B;AAGrD,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,wBAAwB;AAE3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,oBAAU;AA6D5E;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,uBAAuB,EAC9B,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,yBAAyB,CAAC,GACtD,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAiBxC"}

package/dist/permitted/middleware.d.mts

@@ -1,11 +1,14 @@
-import type { JsonRpcMiddleware } from "@metamask/json-rpc-engine";
+import { type JsonRpcMiddleware } from "@metamask/json-rpc-engine";
+import type { Messenger } from "@metamask/messenger";
 import type { Json, JsonRpcParams } from "@metamask/utils";
+import type { PermittedRpcMethodActions, PermittedRpcMethodHooks } from "./index.mjs";
 /**
  * Creates a middleware that handles permitted snap RPC methods.
  *
  * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.
  * @param hooks - An object containing the hooks made available to the permitted RPC methods.
+ * @param messenger - The messenger.
  * @returns The middleware.
  */
-export declare function createSnapsMethodMiddleware(isSnap: boolean, hooks: Record<string, unknown>): JsonRpcMiddleware<JsonRpcParams, Json>;
+export declare function createSnapsMethodMiddleware(isSnap: boolean, hooks: PermittedRpcMethodHooks, messenger: Messenger<string, PermittedRpcMethodActions>): JsonRpcMiddleware<JsonRpcParams, Json>;
 //# sourceMappingURL=middleware.d.mts.map

package/dist/permitted/middleware.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.mts","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kCAAkC;AAGnE,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,wBAAwB;AAK3D;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAiCxC"}
+{"version":3,"file":"middleware.d.mts","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACvB,kCAAkC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,4BAA4B;AAGrD,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,wBAAwB;AAE3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,oBAAU;AA6D5E;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,uBAAuB,EAC9B,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,yBAAyB,CAAC,GACtD,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAiBxC"}

package/dist/permitted/middleware.mjs

@@ -1,36 +1,86 @@
+import { createMethodMiddleware } from "@metamask/json-rpc-engine";
 import { rpcErrors } from "@metamask/rpc-errors";
 import { logError } from "@metamask/snaps-utils";
-import { methodHandlers } from "./handlers.mjs";
-import { selectHooks } from "../utils.mjs";
+import { cancelBackgroundEventHandler } from "./cancelBackgroundEvent.mjs";
+import { clearStateHandler } from "./clearState.mjs";
+import { closeWebSocketHandler } from "./closeWebSocket.mjs";
+import { createInterfaceHandler } from "./createInterface.mjs";
+import { endTraceHandler } from "./endTrace.mjs";
+import { getAllSnapsHandler } from "./getAllSnaps.mjs";
+import { getBackgroundEventsHandler } from "./getBackgroundEvents.mjs";
+import { getClientStatusHandler } from "./getClientStatus.mjs";
+import { getFileHandler } from "./getFile.mjs";
+import { getInterfaceContextHandler } from "./getInterfaceContext.mjs";
+import { getInterfaceStateHandler } from "./getInterfaceState.mjs";
+import { getSnapsHandler } from "./getSnaps.mjs";
+import { getStateHandler } from "./getState.mjs";
+import { getWebSocketsHandler } from "./getWebSockets.mjs";
+import { invokeKeyringHandler } from "./invokeKeyring.mjs";
+import { invokeSnapSugarHandler } from "./invokeSnapSugar.mjs";
+import { listEntropySourcesHandler } from "./listEntropySources.mjs";
+import { openWebSocketHandler } from "./openWebSocket.mjs";
+import { requestSnapsHandler } from "./requestSnaps.mjs";
+import { resolveInterfaceHandler } from "./resolveInterface.mjs";
+import { scheduleBackgroundEventHandler } from "./scheduleBackgroundEvent.mjs";
+import { sendWebSocketMessageHandler } from "./sendWebSocketMessage.mjs";
+import { setStateHandler } from "./setState.mjs";
+import { startTraceHandler } from "./startTrace.mjs";
+import { trackErrorHandler } from "./trackError.mjs";
+import { trackEventHandler } from "./trackEvent.mjs";
+import { updateInterfaceHandler } from "./updateInterface.mjs";
+/* eslint-disable @typescript-eslint/naming-convention */
+const methodHandlers = {
+    wallet_getAllSnaps: getAllSnapsHandler,
+    wallet_getSnaps: getSnapsHandler,
+    wallet_requestSnaps: requestSnapsHandler,
+    wallet_invokeSnap: invokeSnapSugarHandler,
+    wallet_invokeKeyring: invokeKeyringHandler,
+    snap_clearState: clearStateHandler,
+    snap_getClientStatus: getClientStatusHandler,
+    snap_getFile: getFileHandler,
+    snap_getState: getStateHandler,
+    snap_createInterface: createInterfaceHandler,
+    snap_updateInterface: updateInterfaceHandler,
+    snap_getInterfaceState: getInterfaceStateHandler,
+    snap_getInterfaceContext: getInterfaceContextHandler,
+    snap_listEntropySources: listEntropySourcesHandler,
+    snap_resolveInterface: resolveInterfaceHandler,
+    snap_scheduleBackgroundEvent: scheduleBackgroundEventHandler,
+    snap_cancelBackgroundEvent: cancelBackgroundEventHandler,
+    snap_getBackgroundEvents: getBackgroundEventsHandler,
+    snap_setState: setStateHandler,
+    snap_trackError: trackErrorHandler,
+    snap_trackEvent: trackEventHandler,
+    snap_openWebSocket: openWebSocketHandler,
+    snap_closeWebSocket: closeWebSocketHandler,
+    snap_sendWebSocketMessage: sendWebSocketMessageHandler,
+    snap_getWebSockets: getWebSocketsHandler,
+    snap_startTrace: startTraceHandler,
+    snap_endTrace: endTraceHandler,
+};
+/* eslint-enable @typescript-eslint/naming-convention */
 /**
  * Creates a middleware that handles permitted snap RPC methods.
  *
  * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.
  * @param hooks - An object containing the hooks made available to the permitted RPC methods.
+ * @param messenger - The messenger.
  * @returns The middleware.
  */
-export function createSnapsMethodMiddleware(isSnap, hooks) {
+export function createSnapsMethodMiddleware(isSnap, hooks, messenger) {
+    const nestedMiddleware = createMethodMiddleware({
+        handlers: methodHandlers,
+        hooks,
+        messenger,
+        onError: logError,
+    });
     // This is not actually a misused promise, the type is just wrong
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     return async function methodMiddleware(request, response, next, end) {
-        const handler = methodHandlers[request.method];
-        if (handler) {
-            if (String.prototype.startsWith.call(request.method, 'snap_') &&
-                !isSnap) {
-                return end(rpcErrors.methodNotFound());
-            }
-            // TODO: Once json-rpc-engine types are up to date, we should type this correctly
-            const { implementation, hookNames } = handler;
-            try {
-                // Implementations may or may not be async, so we must await them.
-                return await implementation(request, response, next, end, selectHooks(hooks, hookNames));
-            }
-            catch (error) {
-                logError(error);
-                return end(error);
-            }
+        if (String.prototype.startsWith.call(request.method, 'snap_') && !isSnap) {
+            return end(rpcErrors.methodNotFound());
         }
-        return next();
+        return nestedMiddleware(request, response, next, end);
     };
 }
 //# sourceMappingURL=middleware.mjs.map

package/dist/permitted/middleware.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.mjs","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,6BAA6B;AACjD,OAAO,EAAE,QAAQ,EAAE,8BAA8B;AAGjD,OAAO,EAAE,cAAc,EAAE,uBAAmB;AAC5C,OAAO,EAAE,WAAW,EAAE,qBAAiB;AAEvC;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CACzC,MAAe,EACf,KAA8B;IAE9B,iEAAiE;IACjE,kEAAkE;IAClE,OAAO,KAAK,UAAU,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG;QACjE,MAAM,OAAO,GACX,cAAc,CAAC,OAAO,CAAC,MAAqC,CAAC,CAAC;QAChE,IAAI,OAAO,EAAE,CAAC;YACZ,IACE,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC;gBACzD,CAAC,MAAM,EACP,CAAC;gBACD,OAAO,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC,CAAC;YACzC,CAAC;YAED,iFAAiF;YACjF,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,GAAG,OAAc,CAAC;YACrD,IAAI,CAAC;gBACH,kEAAkE;gBAClE,OAAO,MAAM,cAAc,CACzB,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,GAAG,EACH,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,CAC9B,CAAC;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,QAAQ,CAAC,KAAK,CAAC,CAAC;gBAChB,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;QAED,OAAO,IAAI,EAAE,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { logError } from '@metamask/snaps-utils';\nimport type { Json, JsonRpcParams } from '@metamask/utils';\n\nimport { methodHandlers } from './handlers';\nimport { selectHooks } from '../utils';\n\n/**\n * Creates a middleware that handles permitted snap RPC methods.\n *\n * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.\n * @param hooks - An object containing the hooks made available to the permitted RPC methods.\n * @returns The middleware.\n */\nexport function createSnapsMethodMiddleware(\n  isSnap: boolean,\n  hooks: Record<string, unknown>,\n): JsonRpcMiddleware<JsonRpcParams, Json> {\n  // This is not actually a misused promise, the type is just wrong\n  // eslint-disable-next-line @typescript-eslint/no-misused-promises\n  return async function methodMiddleware(request, response, next, end) {\n    const handler =\n      methodHandlers[request.method as keyof typeof methodHandlers];\n    if (handler) {\n      if (\n        String.prototype.startsWith.call(request.method, 'snap_') &&\n        !isSnap\n      ) {\n        return end(rpcErrors.methodNotFound());\n      }\n\n      // TODO: Once json-rpc-engine types are up to date, we should type this correctly\n      const { implementation, hookNames } = handler as any;\n      try {\n        // Implementations may or may not be async, so we must await them.\n        return await implementation(\n          request,\n          response,\n          next,\n          end,\n          selectHooks(hooks, hookNames),\n        );\n      } catch (error) {\n        logError(error);\n        return end(error);\n      }\n    }\n\n    return next();\n  };\n}\n"]}
+{"version":3,"file":"middleware.mjs","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EAEvB,kCAAkC;AAEnC,OAAO,EAAE,SAAS,EAAE,6BAA6B;AACjD,OAAO,EAAE,QAAQ,EAAE,8BAA8B;AAIjD,OAAO,EAAE,4BAA4B,EAAE,oCAAgC;AACvE,OAAO,EAAE,iBAAiB,EAAE,yBAAqB;AACjD,OAAO,EAAE,qBAAqB,EAAE,6BAAyB;AACzD,OAAO,EAAE,sBAAsB,EAAE,8BAA0B;AAC3D,OAAO,EAAE,eAAe,EAAE,uBAAmB;AAC7C,OAAO,EAAE,kBAAkB,EAAE,0BAAsB;AACnD,OAAO,EAAE,0BAA0B,EAAE,kCAA8B;AACnE,OAAO,EAAE,sBAAsB,EAAE,8BAA0B;AAC3D,OAAO,EAAE,cAAc,EAAE,sBAAkB;AAC3C,OAAO,EAAE,0BAA0B,EAAE,kCAA8B;AACnE,OAAO,EAAE,wBAAwB,EAAE,gCAA4B;AAC/D,OAAO,EAAE,eAAe,EAAE,uBAAmB;AAC7C,OAAO,EAAE,eAAe,EAAE,uBAAmB;AAC7C,OAAO,EAAE,oBAAoB,EAAE,4BAAwB;AACvD,OAAO,EAAE,oBAAoB,EAAE,4BAAwB;AACvD,OAAO,EAAE,sBAAsB,EAAE,8BAA0B;AAC3D,OAAO,EAAE,yBAAyB,EAAE,iCAA6B;AACjE,OAAO,EAAE,oBAAoB,EAAE,4BAAwB;AACvD,OAAO,EAAE,mBAAmB,EAAE,2BAAuB;AACrD,OAAO,EAAE,uBAAuB,EAAE,+BAA2B;AAC7D,OAAO,EAAE,8BAA8B,EAAE,sCAAkC;AAC3E,OAAO,EAAE,2BAA2B,EAAE,mCAA+B;AACrE,OAAO,EAAE,eAAe,EAAE,uBAAmB;AAC7C,OAAO,EAAE,iBAAiB,EAAE,yBAAqB;AACjD,OAAO,EAAE,iBAAiB,EAAE,yBAAqB;AACjD,OAAO,EAAE,iBAAiB,EAAE,yBAAqB;AACjD,OAAO,EAAE,sBAAsB,EAAE,8BAA0B;AAE3D,yDAAyD;AACzD,MAAM,cAAc,GAAG;IACrB,kBAAkB,EAAE,kBAAkB;IACtC,eAAe,EAAE,eAAe;IAChC,mBAAmB,EAAE,mBAAmB;IACxC,iBAAiB,EAAE,sBAAsB;IACzC,oBAAoB,EAAE,oBAAoB;IAC1C,eAAe,EAAE,iBAAiB;IAClC,oBAAoB,EAAE,sBAAsB;IAC5C,YAAY,EAAE,cAAc;IAC5B,aAAa,EAAE,eAAe;IAC9B,oBAAoB,EAAE,sBAAsB;IAC5C,oBAAoB,EAAE,sBAAsB;IAC5C,sBAAsB,EAAE,wBAAwB;IAChD,wBAAwB,EAAE,0BAA0B;IACpD,uBAAuB,EAAE,yBAAyB;IAClD,qBAAqB,EAAE,uBAAuB;IAC9C,4BAA4B,EAAE,8BAA8B;IAC5D,0BAA0B,EAAE,4BAA4B;IACxD,wBAAwB,EAAE,0BAA0B;IACpD,aAAa,EAAE,eAAe;IAC9B,eAAe,EAAE,iBAAiB;IAClC,eAAe,EAAE,iBAAiB;IAClC,kBAAkB,EAAE,oBAAoB;IACxC,mBAAmB,EAAE,qBAAqB;IAC1C,yBAAyB,EAAE,2BAA2B;IACtD,kBAAkB,EAAE,oBAAoB;IACxC,eAAe,EAAE,iBAAiB;IAClC,aAAa,EAAE,eAAe;CAC/B,CAAC;AACF,wDAAwD;AAExD;;;;;;;GAOG;AACH,MAAM,UAAU,2BAA2B,CACzC,MAAe,EACf,KAA8B,EAC9B,SAAuD;IAEvD,MAAM,gBAAgB,GAAG,sBAAsB,CAAC;QAC9C,QAAQ,EAAE,cAAc;QACxB,KAAK;QACL,SAAS;QACT,OAAO,EAAE,QAAQ;KAClB,CAAC,CAAC;IAEH,iEAAiE;IACjE,kEAAkE;IAClE,OAAO,KAAK,UAAU,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG;QACjE,IAAI,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACzE,OAAO,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC,CAAC;QACzC,CAAC;QAED,OAAO,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;IACxD,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {\n  createMethodMiddleware,\n  type JsonRpcMiddleware,\n} from '@metamask/json-rpc-engine';\nimport type { Messenger } from '@metamask/messenger';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { logError } from '@metamask/snaps-utils';\nimport type { Json, JsonRpcParams } from '@metamask/utils';\n\nimport type { PermittedRpcMethodActions, PermittedRpcMethodHooks } from '.';\nimport { cancelBackgroundEventHandler } from './cancelBackgroundEvent';\nimport { clearStateHandler } from './clearState';\nimport { closeWebSocketHandler } from './closeWebSocket';\nimport { createInterfaceHandler } from './createInterface';\nimport { endTraceHandler } from './endTrace';\nimport { getAllSnapsHandler } from './getAllSnaps';\nimport { getBackgroundEventsHandler } from './getBackgroundEvents';\nimport { getClientStatusHandler } from './getClientStatus';\nimport { getFileHandler } from './getFile';\nimport { getInterfaceContextHandler } from './getInterfaceContext';\nimport { getInterfaceStateHandler } from './getInterfaceState';\nimport { getSnapsHandler } from './getSnaps';\nimport { getStateHandler } from './getState';\nimport { getWebSocketsHandler } from './getWebSockets';\nimport { invokeKeyringHandler } from './invokeKeyring';\nimport { invokeSnapSugarHandler } from './invokeSnapSugar';\nimport { listEntropySourcesHandler } from './listEntropySources';\nimport { openWebSocketHandler } from './openWebSocket';\nimport { requestSnapsHandler } from './requestSnaps';\nimport { resolveInterfaceHandler } from './resolveInterface';\nimport { scheduleBackgroundEventHandler } from './scheduleBackgroundEvent';\nimport { sendWebSocketMessageHandler } from './sendWebSocketMessage';\nimport { setStateHandler } from './setState';\nimport { startTraceHandler } from './startTrace';\nimport { trackErrorHandler } from './trackError';\nimport { trackEventHandler } from './trackEvent';\nimport { updateInterfaceHandler } from './updateInterface';\n\n/* eslint-disable @typescript-eslint/naming-convention */\nconst methodHandlers = {\n  wallet_getAllSnaps: getAllSnapsHandler,\n  wallet_getSnaps: getSnapsHandler,\n  wallet_requestSnaps: requestSnapsHandler,\n  wallet_invokeSnap: invokeSnapSugarHandler,\n  wallet_invokeKeyring: invokeKeyringHandler,\n  snap_clearState: clearStateHandler,\n  snap_getClientStatus: getClientStatusHandler,\n  snap_getFile: getFileHandler,\n  snap_getState: getStateHandler,\n  snap_createInterface: createInterfaceHandler,\n  snap_updateInterface: updateInterfaceHandler,\n  snap_getInterfaceState: getInterfaceStateHandler,\n  snap_getInterfaceContext: getInterfaceContextHandler,\n  snap_listEntropySources: listEntropySourcesHandler,\n  snap_resolveInterface: resolveInterfaceHandler,\n  snap_scheduleBackgroundEvent: scheduleBackgroundEventHandler,\n  snap_cancelBackgroundEvent: cancelBackgroundEventHandler,\n  snap_getBackgroundEvents: getBackgroundEventsHandler,\n  snap_setState: setStateHandler,\n  snap_trackError: trackErrorHandler,\n  snap_trackEvent: trackEventHandler,\n  snap_openWebSocket: openWebSocketHandler,\n  snap_closeWebSocket: closeWebSocketHandler,\n  snap_sendWebSocketMessage: sendWebSocketMessageHandler,\n  snap_getWebSockets: getWebSocketsHandler,\n  snap_startTrace: startTraceHandler,\n  snap_endTrace: endTraceHandler,\n};\n/* eslint-enable @typescript-eslint/naming-convention */\n\n/**\n * Creates a middleware that handles permitted snap RPC methods.\n *\n * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.\n * @param hooks - An object containing the hooks made available to the permitted RPC methods.\n * @param messenger - The messenger.\n * @returns The middleware.\n */\nexport function createSnapsMethodMiddleware(\n  isSnap: boolean,\n  hooks: PermittedRpcMethodHooks,\n  messenger: Messenger<string, PermittedRpcMethodActions>,\n): JsonRpcMiddleware<JsonRpcParams, Json> {\n  const nestedMiddleware = createMethodMiddleware({\n    handlers: methodHandlers,\n    hooks,\n    messenger,\n    onError: logError,\n  });\n\n  // This is not actually a misused promise, the type is just wrong\n  // eslint-disable-next-line @typescript-eslint/no-misused-promises\n  return async function methodMiddleware(request, response, next, end) {\n    if (String.prototype.startsWith.call(request.method, 'snap_') && !isSnap) {\n      return end(rpcErrors.methodNotFound());\n    }\n\n    return nestedMiddleware(request, response, next, end);\n  };\n}\n"]}

package/dist/permitted/openWebSocket.cjs

@@ -6,11 +6,6 @@ const snaps_sdk_1 = require("@metamask/snaps-sdk");
 const snaps_utils_1 = require("@metamask/snaps-utils");
 const superstruct_1 = require("@metamask/superstruct");
 const endowments_1 = require("../endowments/index.cjs");
-const methodName = 'snap_openWebSocket';
-const hookNames = {
-    hasPermission: true,
-    openWebSocket: true,
-};
 const OpenWebSocketParametersStruct = (0, superstruct_1.object)({
     url: (0, snaps_utils_1.uri)({ protocol: (0, snaps_sdk_1.union)([(0, snaps_sdk_1.literal)('wss:'), (0, snaps_sdk_1.literal)('ws:')]) }),
     protocols: (0, superstruct_1.optional)((0, superstruct_1.array)((0, superstruct_1.string)())),
@@ -62,9 +57,8 @@ const OpenWebSocketParametersStruct = (0, superstruct_1.object)({
  * ```
  */
 exports.openWebSocketHandler = {
-    methodNames: [methodName],
     implementation: openWebSocketImplementation,
-    hookNames,
+    actionNames: ['PermissionController:hasPermission', 'WebSocketService:open'],
 };
 /**
  * The `snap_openWebSocket` method implementation.
@@ -73,19 +67,18 @@ exports.openWebSocketHandler = {
  * @param res - 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.hasPermission - The function to check if a snap has the `endowment:network-access` permission.
- * @param hooks.openWebSocket - The function to open a WebSocket.
+ * @param _hooks - The RPC method hooks. Not used by this function.
+ * @param messenger - The messenger used to call controller actions.
  * @returns Nothing.
  */
-async function openWebSocketImplementation(req, res, _next, end, { hasPermission, openWebSocket }) {
-    if (!hasPermission(endowments_1.SnapEndowments.NetworkAccess)) {
+async function openWebSocketImplementation(req, res, _next, end, _hooks, messenger) {
+    const { params, origin } = req;
+    if (!messenger.call('PermissionController:hasPermission', origin, endowments_1.SnapEndowments.NetworkAccess)) {
         return end(rpc_errors_1.providerErrors.unauthorized());
     }
-    const { params } = req;
     try {
         const { url, protocols } = getValidatedParams(params);
-        res.result = await openWebSocket(url, protocols);
+        res.result = await messenger.call('WebSocketService:open', origin, url, protocols);
     }
     catch (error) {
         return end(error);

package/dist/permitted/openWebSocket.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"openWebSocket.cjs","sourceRoot":"","sources":["../../src/permitted/openWebSocket.ts"],"names":[],"mappings":";;;AAEA,qDAAiE;AACjE,mDAM6B;AAC7B,uDAAgE;AAChE,uDAO+B;AAG/B,wDAA+C;AAG/C,MAAM,UAAU,GAAG,oBAAoB,CAAC;AAExC,MAAM,SAAS,GAAgD;IAC7D,aAAa,EAAE,IAAI;IACnB,aAAa,EAAE,IAAI;CACpB,CAAC;AAOF,MAAM,6BAA6B,GAAG,IAAA,oBAAM,EAAC;IAC3C,GAAG,EAAE,IAAA,iBAAG,EAAC,EAAE,QAAQ,EAAE,IAAA,iBAAK,EAAC,CAAC,IAAA,mBAAO,EAAC,MAAM,CAAC,EAAE,IAAA,mBAAO,EAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;IAChE,SAAS,EAAE,IAAA,sBAAQ,EAAC,IAAA,mBAAK,EAAC,IAAA,oBAAM,GAAE,CAAC,CAAC;CACrC,CAAC,CAAC;AAOH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACU,QAAA,oBAAoB,GAAG;IAClC,WAAW,EAAE,CAAC,UAAU,CAAU;IAClC,cAAc,EAAE,2BAA2B;IAC3C,SAAS;CAKV,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,KAAK,UAAU,2BAA2B,CACxC,GAA4C,EAC5C,GAAgD,EAChD,KAAc,EACd,GAA6B,EAC7B,EAAE,aAAa,EAAE,aAAa,EAA4B;IAE1D,IAAI,CAAC,aAAa,CAAC,2BAAc,CAAC,aAAa,CAAC,EAAE,CAAC;QACjD,OAAO,GAAG,CAAC,2BAAc,CAAC,YAAY,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAEvB,IAAI,CAAC;QACH,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACtD,GAAG,CAAC,MAAM,GAAG,MAAM,aAAa,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IACnD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IAED,OAAO,GAAG,EAAE,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,SAAS,kBAAkB,CAAC,MAAe;IACzC,IAAI,CAAC;QACH,OAAO,IAAA,oBAAM,EAAC,MAAM,EAAE,6BAA6B,CAAC,CAAC;IACvD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,yBAAW,EAAE,CAAC;YACjC,MAAM,sBAAS,CAAC,aAAa,CAAC;gBAC5B,OAAO,EAAE,mBAAmB,KAAK,CAAC,OAAO,GAAG;aAC7C,CAAC,CAAC;QACL,CAAC;QACD,0BAA0B;QAC1B,MAAM,sBAAS,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;AACH,CAAC","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\nimport {\n  literal,\n  union,\n  type JsonRpcRequest,\n  type OpenWebSocketParams,\n  type OpenWebSocketResult,\n} from '@metamask/snaps-sdk';\nimport { uri, type InferMatching } from '@metamask/snaps-utils';\nimport {\n  create,\n  object,\n  array,\n  string,\n  optional,\n  StructError,\n} from '@metamask/superstruct';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\n\nimport { SnapEndowments } from '../endowments';\nimport type { MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_openWebSocket';\n\nconst hookNames: MethodHooksObject<OpenWebSocketMethodHooks> = {\n  hasPermission: true,\n  openWebSocket: true,\n};\n\nexport type OpenWebSocketMethodHooks = {\n  hasPermission: (permissionName: string) => boolean;\n  openWebSocket: (url: string, protocols?: string[]) => Promise<string>;\n};\n\nconst OpenWebSocketParametersStruct = object({\n  url: uri({ protocol: union([literal('wss:'), literal('ws:')]) }),\n  protocols: optional(array(string())),\n});\n\nexport type OpenWebSocketParameters = InferMatching<\n  typeof OpenWebSocketParametersStruct,\n  OpenWebSocketParams\n>;\n\n/**\n * Open a WebSocket connection to the specified URL with optional protocols.\n *\n * Note: This method is only available to snaps that have the\n * [`endowment:network-access`](https://docs.metamask.io/snaps/features/network-access/)\n * permission.\n *\n * @example\n * ```json name=\"Manifest\"\n * {\n *   \"initialPermissions\": {\n *     \"endowment:network-access\": {}\n *   }\n * }\n * ```\n * ```ts name=\"Usage\"\n * // Open a connection to a WebSocket server, e.g., in the JSON-RPC handler of\n * // the Snap:\n * snap.request({\n *   method: 'snap_openWebSocket',\n *   params: {\n *     url: 'wss://example.com/socket',\n *     protocols: ['protocol1', 'protocol2'], // Optional\n *   },\n * });\n *\n * // Listen for events from the WebSocket connection in the `onWebSocketEvent`\n * // handler of the Snap:\n * export const onWebSocketEvent: OnWebSocketEventHandler = async ({ event }) => {\n *   switch (event.type) {\n *     case 'open':\n *       console.log(`WebSocket connection opened with origin ${event.origin}`);\n *       break;\n *     case 'message':\n *       console.log(`WebSocket message received from origin ${event.origin}:`, event.data);\n *       break;\n *     case 'close':\n *       console.log(`WebSocket connection closed with origin ${event.origin}`);\n *       break;\n *     case 'error':\n *       console.error(`WebSocket error from origin ${event.origin}:`, event.error);\n *       break;\n *   }\n * };\n * ```\n */\nexport const openWebSocketHandler = {\n  methodNames: [methodName] as const,\n  implementation: openWebSocketImplementation,\n  hookNames,\n} satisfies PermittedHandlerExport<\n  OpenWebSocketMethodHooks,\n  OpenWebSocketParams,\n  OpenWebSocketResult\n>;\n\n/**\n * The `snap_openWebSocket` method implementation.\n *\n * @param req - The JSON-RPC request object.\n * @param res - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.hasPermission - The function to check if a snap has the `endowment:network-access` permission.\n * @param hooks.openWebSocket - The function to open a WebSocket.\n * @returns Nothing.\n */\nasync function openWebSocketImplementation(\n  req: JsonRpcRequest<OpenWebSocketParameters>,\n  res: PendingJsonRpcResponse<OpenWebSocketResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { hasPermission, openWebSocket }: OpenWebSocketMethodHooks,\n): Promise<void> {\n  if (!hasPermission(SnapEndowments.NetworkAccess)) {\n    return end(providerErrors.unauthorized());\n  }\n\n  const { params } = req;\n\n  try {\n    const { url, protocols } = getValidatedParams(params);\n    res.result = await openWebSocket(url, protocols);\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validates the parameters for the snap_openWebSocket method.\n *\n * @param params - Parameters to validate.\n * @returns Validated parameters.\n * @throws Throws RPC error if validation fails.\n */\nfunction getValidatedParams(params: unknown): OpenWebSocketParameters {\n  try {\n    return create(params, OpenWebSocketParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"]}
+{"version":3,"file":"openWebSocket.cjs","sourceRoot":"","sources":["../../src/permitted/openWebSocket.ts"],"names":[],"mappings":";;;AAMA,qDAAiE;AACjE,mDAK6B;AAC7B,uDAAgE;AAChE,uDAO+B;AAG/B,wDAA+C;AAU/C,MAAM,6BAA6B,GAAG,IAAA,oBAAM,EAAC;IAC3C,GAAG,EAAE,IAAA,iBAAG,EAAC,EAAE,QAAQ,EAAE,IAAA,iBAAK,EAAC,CAAC,IAAA,mBAAO,EAAC,MAAM,CAAC,EAAE,IAAA,mBAAO,EAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;IAChE,SAAS,EAAE,IAAA,sBAAQ,EAAC,IAAA,mBAAK,EAAC,IAAA,oBAAM,GAAE,CAAC,CAAC;CACrC,CAAC,CAAC;AAOH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACU,QAAA,oBAAoB,GAAG;IAClC,cAAc,EAAE,2BAA2B;IAC3C,WAAW,EAAE,CAAC,oCAAoC,EAAE,uBAAuB,CAAC;CAO7E,CAAC;AAEF;;;;;;;;;;GAUG;AACH,KAAK,UAAU,2BAA2B,CACxC,GAAsD,EACtD,GAAgD,EAChD,KAAc,EACd,GAA6B,EAC7B,MAAa,EACb,SAAwD;IAExD,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAE/B,IACE,CAAC,SAAS,CAAC,IAAI,CACb,oCAAoC,EACpC,MAAM,EACN,2BAAc,CAAC,aAAa,CAC7B,EACD,CAAC;QACD,OAAO,GAAG,CAAC,2BAAc,CAAC,YAAY,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,IAAI,CAAC;QACH,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACtD,GAAG,CAAC,MAAM,GAAG,MAAM,SAAS,CAAC,IAAI,CAC/B,uBAAuB,EACvB,MAAM,EACN,GAAG,EACH,SAAS,CACV,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IAED,OAAO,GAAG,EAAE,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,SAAS,kBAAkB,CAAC,MAAe;IACzC,IAAI,CAAC;QACH,OAAO,IAAA,oBAAM,EAAC,MAAM,EAAE,6BAA6B,CAAC,CAAC;IACvD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,yBAAW,EAAE,CAAC;YACjC,MAAM,sBAAS,CAAC,aAAa,CAAC;gBAC5B,OAAO,EAAE,mBAAmB,KAAK,CAAC,OAAO,GAAG;aAC7C,CAAC,CAAC;QACL,CAAC;QACD,0BAA0B;QAC1B,MAAM,sBAAS,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;AACH,CAAC","sourcesContent":["import type {\n  JsonRpcEngineEndCallback,\n  MethodHandler,\n} from '@metamask/json-rpc-engine';\nimport type { Messenger } from '@metamask/messenger';\nimport type { PermissionControllerHasPermissionAction } from '@metamask/permission-controller';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\nimport {\n  literal,\n  union,\n  type OpenWebSocketParams,\n  type OpenWebSocketResult,\n} from '@metamask/snaps-sdk';\nimport { uri, type InferMatching } from '@metamask/snaps-utils';\nimport {\n  create,\n  object,\n  array,\n  string,\n  optional,\n  StructError,\n} from '@metamask/superstruct';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\n\nimport { SnapEndowments } from '../endowments';\nimport type {\n  JsonRpcRequestWithOrigin,\n  WebSocketServiceOpenAction,\n} from '../types';\n\nexport type OpenWebSocketMethodActions =\n  | PermissionControllerHasPermissionAction\n  | WebSocketServiceOpenAction;\n\nconst OpenWebSocketParametersStruct = object({\n  url: uri({ protocol: union([literal('wss:'), literal('ws:')]) }),\n  protocols: optional(array(string())),\n});\n\nexport type OpenWebSocketParameters = InferMatching<\n  typeof OpenWebSocketParametersStruct,\n  OpenWebSocketParams\n>;\n\n/**\n * Open a WebSocket connection to the specified URL with optional protocols.\n *\n * Note: This method is only available to snaps that have the\n * [`endowment:network-access`](https://docs.metamask.io/snaps/features/network-access/)\n * permission.\n *\n * @example\n * ```json name=\"Manifest\"\n * {\n *   \"initialPermissions\": {\n *     \"endowment:network-access\": {}\n *   }\n * }\n * ```\n * ```ts name=\"Usage\"\n * // Open a connection to a WebSocket server, e.g., in the JSON-RPC handler of\n * // the Snap:\n * snap.request({\n *   method: 'snap_openWebSocket',\n *   params: {\n *     url: 'wss://example.com/socket',\n *     protocols: ['protocol1', 'protocol2'], // Optional\n *   },\n * });\n *\n * // Listen for events from the WebSocket connection in the `onWebSocketEvent`\n * // handler of the Snap:\n * export const onWebSocketEvent: OnWebSocketEventHandler = async ({ event }) => {\n *   switch (event.type) {\n *     case 'open':\n *       console.log(`WebSocket connection opened with origin ${event.origin}`);\n *       break;\n *     case 'message':\n *       console.log(`WebSocket message received from origin ${event.origin}:`, event.data);\n *       break;\n *     case 'close':\n *       console.log(`WebSocket connection closed with origin ${event.origin}`);\n *       break;\n *     case 'error':\n *       console.error(`WebSocket error from origin ${event.origin}:`, event.error);\n *       break;\n *   }\n * };\n * ```\n */\nexport const openWebSocketHandler = {\n  implementation: openWebSocketImplementation,\n  actionNames: ['PermissionController:hasPermission', 'WebSocketService:open'],\n} satisfies MethodHandler<\n  never,\n  OpenWebSocketMethodActions,\n  OpenWebSocketParams,\n  OpenWebSocketResult,\n  { origin: string }\n>;\n\n/**\n * The `snap_openWebSocket` method implementation.\n *\n * @param req - The JSON-RPC request object.\n * @param res - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param _hooks - The RPC method hooks. Not used by this function.\n * @param messenger - The messenger used to call controller actions.\n * @returns Nothing.\n */\nasync function openWebSocketImplementation(\n  req: JsonRpcRequestWithOrigin<OpenWebSocketParameters>,\n  res: PendingJsonRpcResponse<OpenWebSocketResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  _hooks: never,\n  messenger: Messenger<string, OpenWebSocketMethodActions>,\n): Promise<void> {\n  const { params, origin } = req;\n\n  if (\n    !messenger.call(\n      'PermissionController:hasPermission',\n      origin,\n      SnapEndowments.NetworkAccess,\n    )\n  ) {\n    return end(providerErrors.unauthorized());\n  }\n\n  try {\n    const { url, protocols } = getValidatedParams(params);\n    res.result = await messenger.call(\n      'WebSocketService:open',\n      origin,\n      url,\n      protocols,\n    );\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validates the parameters for the snap_openWebSocket method.\n *\n * @param params - Parameters to validate.\n * @returns Validated parameters.\n * @throws Throws RPC error if validation fails.\n */\nfunction getValidatedParams(params: unknown): OpenWebSocketParameters {\n  try {\n    return create(params, OpenWebSocketParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"]}

package/dist/permitted/openWebSocket.d.cts

@@ -1,12 +1,11 @@
 import type { JsonRpcEngineEndCallback } from "@metamask/json-rpc-engine";
-import { type JsonRpcRequest, type OpenWebSocketParams, type OpenWebSocketResult } from "@metamask/snaps-sdk";
+import type { Messenger } from "@metamask/messenger";
+import type { PermissionControllerHasPermissionAction } from "@metamask/permission-controller";
+import { type OpenWebSocketParams, type OpenWebSocketResult } from "@metamask/snaps-sdk";
 import { type InferMatching } from "@metamask/snaps-utils";
 import type { PendingJsonRpcResponse } from "@metamask/utils";
-import type { MethodHooksObject } from "../utils.cjs";
-export type OpenWebSocketMethodHooks = {
-    hasPermission: (permissionName: string) => boolean;
-    openWebSocket: (url: string, protocols?: string[]) => Promise<string>;
-};
+import type { JsonRpcRequestWithOrigin, WebSocketServiceOpenAction } from "../types.cjs";
+export type OpenWebSocketMethodActions = PermissionControllerHasPermissionAction | WebSocketServiceOpenAction;
 declare const OpenWebSocketParametersStruct: import("@metamask/superstruct").Struct<{
     url: string;
     protocols?: string[] | undefined;
@@ -62,9 +61,8 @@ export type OpenWebSocketParameters = InferMatching<typeof OpenWebSocketParamete
  * ```
  */
 export declare const openWebSocketHandler: {
-    methodNames: ["snap_openWebSocket"];
     implementation: typeof openWebSocketImplementation;
-    hookNames: MethodHooksObject<OpenWebSocketMethodHooks>;
+    actionNames: ("WebSocketService:open" | "PermissionController:hasPermission")[];
 };
 /**
  * The `snap_openWebSocket` method implementation.
@@ -73,11 +71,10 @@ export declare const openWebSocketHandler: {
  * @param res - 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.hasPermission - The function to check if a snap has the `endowment:network-access` permission.
- * @param hooks.openWebSocket - The function to open a WebSocket.
+ * @param _hooks - The RPC method hooks. Not used by this function.
+ * @param messenger - The messenger used to call controller actions.
  * @returns Nothing.
  */
-declare function openWebSocketImplementation(req: JsonRpcRequest<OpenWebSocketParameters>, res: PendingJsonRpcResponse<OpenWebSocketResult>, _next: unknown, end: JsonRpcEngineEndCallback, { hasPermission, openWebSocket }: OpenWebSocketMethodHooks): Promise<void>;
+declare function openWebSocketImplementation(req: JsonRpcRequestWithOrigin<OpenWebSocketParameters>, res: PendingJsonRpcResponse<OpenWebSocketResult>, _next: unknown, end: JsonRpcEngineEndCallback, _hooks: never, messenger: Messenger<string, OpenWebSocketMethodActions>): Promise<void>;
 export {};
 //# sourceMappingURL=openWebSocket.d.cts.map

package/dist/permitted/openWebSocket.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"openWebSocket.d.cts","sourceRoot":"","sources":["../../src/permitted/openWebSocket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,kCAAkC;AAG1E,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACzB,4BAA4B;AAC7B,OAAO,EAAO,KAAK,aAAa,EAAE,8BAA8B;AAShE,OAAO,KAAK,EAAE,sBAAsB,EAAE,wBAAwB;AAG9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAiB;AASlD,MAAM,MAAM,wBAAwB,GAAG;IACrC,aAAa,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC;IACnD,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACvE,CAAC;AAEF,QAAA,MAAM,6BAA6B;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,aAAa,CACjD,OAAO,6BAA6B,EACpC,mBAAmB,CACpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,oBAAoB;;;;CAQhC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,iBAAe,2BAA2B,CACxC,GAAG,EAAE,cAAc,CAAC,uBAAuB,CAAC,EAC5C,GAAG,EAAE,sBAAsB,CAAC,mBAAmB,CAAC,EAChD,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,wBAAwB,EAC7B,EAAE,aAAa,EAAE,aAAa,EAAE,EAAE,wBAAwB,GACzD,OAAO,CAAC,IAAI,CAAC,CAef"}
+{"version":3,"file":"openWebSocket.d.cts","sourceRoot":"","sources":["../../src/permitted/openWebSocket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EAEzB,kCAAkC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,4BAA4B;AACrD,OAAO,KAAK,EAAE,uCAAuC,EAAE,wCAAwC;AAE/F,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACzB,4BAA4B;AAC7B,OAAO,EAAO,KAAK,aAAa,EAAE,8BAA8B;AAShE,OAAO,KAAK,EAAE,sBAAsB,EAAE,wBAAwB;AAG9D,OAAO,KAAK,EACV,wBAAwB,EACxB,0BAA0B,EAC3B,qBAAiB;AAElB,MAAM,MAAM,0BAA0B,GAClC,uCAAuC,GACvC,0BAA0B,CAAC;AAE/B,QAAA,MAAM,6BAA6B;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,aAAa,CACjD,OAAO,6BAA6B,EACpC,mBAAmB,CACpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,oBAAoB;;;CAShC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,iBAAe,2BAA2B,CACxC,GAAG,EAAE,wBAAwB,CAAC,uBAAuB,CAAC,EACtD,GAAG,EAAE,sBAAsB,CAAC,mBAAmB,CAAC,EAChD,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,wBAAwB,EAC7B,MAAM,EAAE,KAAK,EACb,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,0BAA0B,CAAC,GACvD,OAAO,CAAC,IAAI,CAAC,CA0Bf"}

package/dist/permitted/openWebSocket.d.mts

@@ -1,12 +1,11 @@
 import type { JsonRpcEngineEndCallback } from "@metamask/json-rpc-engine";
-import { type JsonRpcRequest, type OpenWebSocketParams, type OpenWebSocketResult } from "@metamask/snaps-sdk";
+import type { Messenger } from "@metamask/messenger";
+import type { PermissionControllerHasPermissionAction } from "@metamask/permission-controller";
+import { type OpenWebSocketParams, type OpenWebSocketResult } from "@metamask/snaps-sdk";
 import { type InferMatching } from "@metamask/snaps-utils";
 import type { PendingJsonRpcResponse } from "@metamask/utils";
-import type { MethodHooksObject } from "../utils.mjs";
-export type OpenWebSocketMethodHooks = {
-    hasPermission: (permissionName: string) => boolean;
-    openWebSocket: (url: string, protocols?: string[]) => Promise<string>;
-};
+import type { JsonRpcRequestWithOrigin, WebSocketServiceOpenAction } from "../types.mjs";
+export type OpenWebSocketMethodActions = PermissionControllerHasPermissionAction | WebSocketServiceOpenAction;
 declare const OpenWebSocketParametersStruct: import("@metamask/superstruct").Struct<{
     url: string;
     protocols?: string[] | undefined;
@@ -62,9 +61,8 @@ export type OpenWebSocketParameters = InferMatching<typeof OpenWebSocketParamete
  * ```
  */
 export declare const openWebSocketHandler: {
-    methodNames: ["snap_openWebSocket"];
     implementation: typeof openWebSocketImplementation;
-    hookNames: MethodHooksObject<OpenWebSocketMethodHooks>;
+    actionNames: ("WebSocketService:open" | "PermissionController:hasPermission")[];
 };
 /**
  * The `snap_openWebSocket` method implementation.
@@ -73,11 +71,10 @@ export declare const openWebSocketHandler: {
  * @param res - 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.hasPermission - The function to check if a snap has the `endowment:network-access` permission.
- * @param hooks.openWebSocket - The function to open a WebSocket.
+ * @param _hooks - The RPC method hooks. Not used by this function.
+ * @param messenger - The messenger used to call controller actions.
  * @returns Nothing.
  */
-declare function openWebSocketImplementation(req: JsonRpcRequest<OpenWebSocketParameters>, res: PendingJsonRpcResponse<OpenWebSocketResult>, _next: unknown, end: JsonRpcEngineEndCallback, { hasPermission, openWebSocket }: OpenWebSocketMethodHooks): Promise<void>;
+declare function openWebSocketImplementation(req: JsonRpcRequestWithOrigin<OpenWebSocketParameters>, res: PendingJsonRpcResponse<OpenWebSocketResult>, _next: unknown, end: JsonRpcEngineEndCallback, _hooks: never, messenger: Messenger<string, OpenWebSocketMethodActions>): Promise<void>;
 export {};
 //# sourceMappingURL=openWebSocket.d.mts.map

package/dist/permitted/openWebSocket.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"openWebSocket.d.mts","sourceRoot":"","sources":["../../src/permitted/openWebSocket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,kCAAkC;AAG1E,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACzB,4BAA4B;AAC7B,OAAO,EAAO,KAAK,aAAa,EAAE,8BAA8B;AAShE,OAAO,KAAK,EAAE,sBAAsB,EAAE,wBAAwB;AAG9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAiB;AASlD,MAAM,MAAM,wBAAwB,GAAG;IACrC,aAAa,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC;IACnD,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACvE,CAAC;AAEF,QAAA,MAAM,6BAA6B;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,aAAa,CACjD,OAAO,6BAA6B,EACpC,mBAAmB,CACpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,oBAAoB;;;;CAQhC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,iBAAe,2BAA2B,CACxC,GAAG,EAAE,cAAc,CAAC,uBAAuB,CAAC,EAC5C,GAAG,EAAE,sBAAsB,CAAC,mBAAmB,CAAC,EAChD,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,wBAAwB,EAC7B,EAAE,aAAa,EAAE,aAAa,EAAE,EAAE,wBAAwB,GACzD,OAAO,CAAC,IAAI,CAAC,CAef"}
+{"version":3,"file":"openWebSocket.d.mts","sourceRoot":"","sources":["../../src/permitted/openWebSocket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EAEzB,kCAAkC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,4BAA4B;AACrD,OAAO,KAAK,EAAE,uCAAuC,EAAE,wCAAwC;AAE/F,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACzB,4BAA4B;AAC7B,OAAO,EAAO,KAAK,aAAa,EAAE,8BAA8B;AAShE,OAAO,KAAK,EAAE,sBAAsB,EAAE,wBAAwB;AAG9D,OAAO,KAAK,EACV,wBAAwB,EACxB,0BAA0B,EAC3B,qBAAiB;AAElB,MAAM,MAAM,0BAA0B,GAClC,uCAAuC,GACvC,0BAA0B,CAAC;AAE/B,QAAA,MAAM,6BAA6B;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,aAAa,CACjD,OAAO,6BAA6B,EACpC,mBAAmB,CACpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,oBAAoB;;;CAShC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,iBAAe,2BAA2B,CACxC,GAAG,EAAE,wBAAwB,CAAC,uBAAuB,CAAC,EACtD,GAAG,EAAE,sBAAsB,CAAC,mBAAmB,CAAC,EAChD,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,wBAAwB,EAC7B,MAAM,EAAE,KAAK,EACb,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,0BAA0B,CAAC,GACvD,OAAO,CAAC,IAAI,CAAC,CA0Bf"}

package/dist/permitted/openWebSocket.mjs

@@ -3,11 +3,6 @@ import { literal, union } from "@metamask/snaps-sdk";
 import { uri } from "@metamask/snaps-utils";
 import { create, object, array, string, optional, StructError } from "@metamask/superstruct";
 import { SnapEndowments } from "../endowments/index.mjs";
-const methodName = 'snap_openWebSocket';
-const hookNames = {
-    hasPermission: true,
-    openWebSocket: true,
-};
 const OpenWebSocketParametersStruct = object({
     url: uri({ protocol: union([literal('wss:'), literal('ws:')]) }),
     protocols: optional(array(string())),
@@ -59,9 +54,8 @@ const OpenWebSocketParametersStruct = object({
  * ```
  */
 export const openWebSocketHandler = {
-    methodNames: [methodName],
     implementation: openWebSocketImplementation,
-    hookNames,
+    actionNames: ['PermissionController:hasPermission', 'WebSocketService:open'],
 };
 /**
  * The `snap_openWebSocket` method implementation.
@@ -70,19 +64,18 @@ export const openWebSocketHandler = {
  * @param res - 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.hasPermission - The function to check if a snap has the `endowment:network-access` permission.
- * @param hooks.openWebSocket - The function to open a WebSocket.
+ * @param _hooks - The RPC method hooks. Not used by this function.
+ * @param messenger - The messenger used to call controller actions.
  * @returns Nothing.
  */
-async function openWebSocketImplementation(req, res, _next, end, { hasPermission, openWebSocket }) {
-    if (!hasPermission(SnapEndowments.NetworkAccess)) {
+async function openWebSocketImplementation(req, res, _next, end, _hooks, messenger) {
+    const { params, origin } = req;
+    if (!messenger.call('PermissionController:hasPermission', origin, SnapEndowments.NetworkAccess)) {
         return end(providerErrors.unauthorized());
     }
-    const { params } = req;
     try {
         const { url, protocols } = getValidatedParams(params);
-        res.result = await openWebSocket(url, protocols);
+        res.result = await messenger.call('WebSocketService:open', origin, url, protocols);
     }
     catch (error) {
         return end(error);

package/dist/permitted/openWebSocket.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"openWebSocket.mjs","sourceRoot":"","sources":["../../src/permitted/openWebSocket.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,6BAA6B;AACjE,OAAO,EACL,OAAO,EACP,KAAK,EAIN,4BAA4B;AAC7B,OAAO,EAAE,GAAG,EAAsB,8BAA8B;AAChE,OAAO,EACL,MAAM,EACN,MAAM,EACN,KAAK,EACL,MAAM,EACN,QAAQ,EACR,WAAW,EACZ,8BAA8B;AAG/B,OAAO,EAAE,cAAc,EAAE,gCAAsB;AAG/C,MAAM,UAAU,GAAG,oBAAoB,CAAC;AAExC,MAAM,SAAS,GAAgD;IAC7D,aAAa,EAAE,IAAI;IACnB,aAAa,EAAE,IAAI;CACpB,CAAC;AAOF,MAAM,6BAA6B,GAAG,MAAM,CAAC;IAC3C,GAAG,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;IAChE,SAAS,EAAE,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;CACrC,CAAC,CAAC;AAOH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,WAAW,EAAE,CAAC,UAAU,CAAU;IAClC,cAAc,EAAE,2BAA2B;IAC3C,SAAS;CAKV,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,KAAK,UAAU,2BAA2B,CACxC,GAA4C,EAC5C,GAAgD,EAChD,KAAc,EACd,GAA6B,EAC7B,EAAE,aAAa,EAAE,aAAa,EAA4B;IAE1D,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,aAAa,CAAC,EAAE,CAAC;QACjD,OAAO,GAAG,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAEvB,IAAI,CAAC;QACH,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACtD,GAAG,CAAC,MAAM,GAAG,MAAM,aAAa,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IACnD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IAED,OAAO,GAAG,EAAE,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,SAAS,kBAAkB,CAAC,MAAe;IACzC,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,MAAM,EAAE,6BAA6B,CAAC,CAAC;IACvD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,WAAW,EAAE,CAAC;YACjC,MAAM,SAAS,CAAC,aAAa,CAAC;gBAC5B,OAAO,EAAE,mBAAmB,KAAK,CAAC,OAAO,GAAG;aAC7C,CAAC,CAAC;QACL,CAAC;QACD,0BAA0B;QAC1B,MAAM,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;AACH,CAAC","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\nimport {\n  literal,\n  union,\n  type JsonRpcRequest,\n  type OpenWebSocketParams,\n  type OpenWebSocketResult,\n} from '@metamask/snaps-sdk';\nimport { uri, type InferMatching } from '@metamask/snaps-utils';\nimport {\n  create,\n  object,\n  array,\n  string,\n  optional,\n  StructError,\n} from '@metamask/superstruct';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\n\nimport { SnapEndowments } from '../endowments';\nimport type { MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_openWebSocket';\n\nconst hookNames: MethodHooksObject<OpenWebSocketMethodHooks> = {\n  hasPermission: true,\n  openWebSocket: true,\n};\n\nexport type OpenWebSocketMethodHooks = {\n  hasPermission: (permissionName: string) => boolean;\n  openWebSocket: (url: string, protocols?: string[]) => Promise<string>;\n};\n\nconst OpenWebSocketParametersStruct = object({\n  url: uri({ protocol: union([literal('wss:'), literal('ws:')]) }),\n  protocols: optional(array(string())),\n});\n\nexport type OpenWebSocketParameters = InferMatching<\n  typeof OpenWebSocketParametersStruct,\n  OpenWebSocketParams\n>;\n\n/**\n * Open a WebSocket connection to the specified URL with optional protocols.\n *\n * Note: This method is only available to snaps that have the\n * [`endowment:network-access`](https://docs.metamask.io/snaps/features/network-access/)\n * permission.\n *\n * @example\n * ```json name=\"Manifest\"\n * {\n *   \"initialPermissions\": {\n *     \"endowment:network-access\": {}\n *   }\n * }\n * ```\n * ```ts name=\"Usage\"\n * // Open a connection to a WebSocket server, e.g., in the JSON-RPC handler of\n * // the Snap:\n * snap.request({\n *   method: 'snap_openWebSocket',\n *   params: {\n *     url: 'wss://example.com/socket',\n *     protocols: ['protocol1', 'protocol2'], // Optional\n *   },\n * });\n *\n * // Listen for events from the WebSocket connection in the `onWebSocketEvent`\n * // handler of the Snap:\n * export const onWebSocketEvent: OnWebSocketEventHandler = async ({ event }) => {\n *   switch (event.type) {\n *     case 'open':\n *       console.log(`WebSocket connection opened with origin ${event.origin}`);\n *       break;\n *     case 'message':\n *       console.log(`WebSocket message received from origin ${event.origin}:`, event.data);\n *       break;\n *     case 'close':\n *       console.log(`WebSocket connection closed with origin ${event.origin}`);\n *       break;\n *     case 'error':\n *       console.error(`WebSocket error from origin ${event.origin}:`, event.error);\n *       break;\n *   }\n * };\n * ```\n */\nexport const openWebSocketHandler = {\n  methodNames: [methodName] as const,\n  implementation: openWebSocketImplementation,\n  hookNames,\n} satisfies PermittedHandlerExport<\n  OpenWebSocketMethodHooks,\n  OpenWebSocketParams,\n  OpenWebSocketResult\n>;\n\n/**\n * The `snap_openWebSocket` method implementation.\n *\n * @param req - The JSON-RPC request object.\n * @param res - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.hasPermission - The function to check if a snap has the `endowment:network-access` permission.\n * @param hooks.openWebSocket - The function to open a WebSocket.\n * @returns Nothing.\n */\nasync function openWebSocketImplementation(\n  req: JsonRpcRequest<OpenWebSocketParameters>,\n  res: PendingJsonRpcResponse<OpenWebSocketResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { hasPermission, openWebSocket }: OpenWebSocketMethodHooks,\n): Promise<void> {\n  if (!hasPermission(SnapEndowments.NetworkAccess)) {\n    return end(providerErrors.unauthorized());\n  }\n\n  const { params } = req;\n\n  try {\n    const { url, protocols } = getValidatedParams(params);\n    res.result = await openWebSocket(url, protocols);\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validates the parameters for the snap_openWebSocket method.\n *\n * @param params - Parameters to validate.\n * @returns Validated parameters.\n * @throws Throws RPC error if validation fails.\n */\nfunction getValidatedParams(params: unknown): OpenWebSocketParameters {\n  try {\n    return create(params, OpenWebSocketParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"]}
+{"version":3,"file":"openWebSocket.mjs","sourceRoot":"","sources":["../../src/permitted/openWebSocket.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,6BAA6B;AACjE,OAAO,EACL,OAAO,EACP,KAAK,EAGN,4BAA4B;AAC7B,OAAO,EAAE,GAAG,EAAsB,8BAA8B;AAChE,OAAO,EACL,MAAM,EACN,MAAM,EACN,KAAK,EACL,MAAM,EACN,QAAQ,EACR,WAAW,EACZ,8BAA8B;AAG/B,OAAO,EAAE,cAAc,EAAE,gCAAsB;AAU/C,MAAM,6BAA6B,GAAG,MAAM,CAAC;IAC3C,GAAG,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;IAChE,SAAS,EAAE,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;CACrC,CAAC,CAAC;AAOH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,cAAc,EAAE,2BAA2B;IAC3C,WAAW,EAAE,CAAC,oCAAoC,EAAE,uBAAuB,CAAC;CAO7E,CAAC;AAEF;;;;;;;;;;GAUG;AACH,KAAK,UAAU,2BAA2B,CACxC,GAAsD,EACtD,GAAgD,EAChD,KAAc,EACd,GAA6B,EAC7B,MAAa,EACb,SAAwD;IAExD,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAE/B,IACE,CAAC,SAAS,CAAC,IAAI,CACb,oCAAoC,EACpC,MAAM,EACN,cAAc,CAAC,aAAa,CAC7B,EACD,CAAC;QACD,OAAO,GAAG,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,IAAI,CAAC;QACH,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACtD,GAAG,CAAC,MAAM,GAAG,MAAM,SAAS,CAAC,IAAI,CAC/B,uBAAuB,EACvB,MAAM,EACN,GAAG,EACH,SAAS,CACV,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IAED,OAAO,GAAG,EAAE,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,SAAS,kBAAkB,CAAC,MAAe;IACzC,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,MAAM,EAAE,6BAA6B,CAAC,CAAC;IACvD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,WAAW,EAAE,CAAC;YACjC,MAAM,SAAS,CAAC,aAAa,CAAC;gBAC5B,OAAO,EAAE,mBAAmB,KAAK,CAAC,OAAO,GAAG;aAC7C,CAAC,CAAC;QACL,CAAC;QACD,0BAA0B;QAC1B,MAAM,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;AACH,CAAC","sourcesContent":["import type {\n  JsonRpcEngineEndCallback,\n  MethodHandler,\n} from '@metamask/json-rpc-engine';\nimport type { Messenger } from '@metamask/messenger';\nimport type { PermissionControllerHasPermissionAction } from '@metamask/permission-controller';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\nimport {\n  literal,\n  union,\n  type OpenWebSocketParams,\n  type OpenWebSocketResult,\n} from '@metamask/snaps-sdk';\nimport { uri, type InferMatching } from '@metamask/snaps-utils';\nimport {\n  create,\n  object,\n  array,\n  string,\n  optional,\n  StructError,\n} from '@metamask/superstruct';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\n\nimport { SnapEndowments } from '../endowments';\nimport type {\n  JsonRpcRequestWithOrigin,\n  WebSocketServiceOpenAction,\n} from '../types';\n\nexport type OpenWebSocketMethodActions =\n  | PermissionControllerHasPermissionAction\n  | WebSocketServiceOpenAction;\n\nconst OpenWebSocketParametersStruct = object({\n  url: uri({ protocol: union([literal('wss:'), literal('ws:')]) }),\n  protocols: optional(array(string())),\n});\n\nexport type OpenWebSocketParameters = InferMatching<\n  typeof OpenWebSocketParametersStruct,\n  OpenWebSocketParams\n>;\n\n/**\n * Open a WebSocket connection to the specified URL with optional protocols.\n *\n * Note: This method is only available to snaps that have the\n * [`endowment:network-access`](https://docs.metamask.io/snaps/features/network-access/)\n * permission.\n *\n * @example\n * ```json name=\"Manifest\"\n * {\n *   \"initialPermissions\": {\n *     \"endowment:network-access\": {}\n *   }\n * }\n * ```\n * ```ts name=\"Usage\"\n * // Open a connection to a WebSocket server, e.g., in the JSON-RPC handler of\n * // the Snap:\n * snap.request({\n *   method: 'snap_openWebSocket',\n *   params: {\n *     url: 'wss://example.com/socket',\n *     protocols: ['protocol1', 'protocol2'], // Optional\n *   },\n * });\n *\n * // Listen for events from the WebSocket connection in the `onWebSocketEvent`\n * // handler of the Snap:\n * export const onWebSocketEvent: OnWebSocketEventHandler = async ({ event }) => {\n *   switch (event.type) {\n *     case 'open':\n *       console.log(`WebSocket connection opened with origin ${event.origin}`);\n *       break;\n *     case 'message':\n *       console.log(`WebSocket message received from origin ${event.origin}:`, event.data);\n *       break;\n *     case 'close':\n *       console.log(`WebSocket connection closed with origin ${event.origin}`);\n *       break;\n *     case 'error':\n *       console.error(`WebSocket error from origin ${event.origin}:`, event.error);\n *       break;\n *   }\n * };\n * ```\n */\nexport const openWebSocketHandler = {\n  implementation: openWebSocketImplementation,\n  actionNames: ['PermissionController:hasPermission', 'WebSocketService:open'],\n} satisfies MethodHandler<\n  never,\n  OpenWebSocketMethodActions,\n  OpenWebSocketParams,\n  OpenWebSocketResult,\n  { origin: string }\n>;\n\n/**\n * The `snap_openWebSocket` method implementation.\n *\n * @param req - The JSON-RPC request object.\n * @param res - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param _hooks - The RPC method hooks. Not used by this function.\n * @param messenger - The messenger used to call controller actions.\n * @returns Nothing.\n */\nasync function openWebSocketImplementation(\n  req: JsonRpcRequestWithOrigin<OpenWebSocketParameters>,\n  res: PendingJsonRpcResponse<OpenWebSocketResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  _hooks: never,\n  messenger: Messenger<string, OpenWebSocketMethodActions>,\n): Promise<void> {\n  const { params, origin } = req;\n\n  if (\n    !messenger.call(\n      'PermissionController:hasPermission',\n      origin,\n      SnapEndowments.NetworkAccess,\n    )\n  ) {\n    return end(providerErrors.unauthorized());\n  }\n\n  try {\n    const { url, protocols } = getValidatedParams(params);\n    res.result = await messenger.call(\n      'WebSocketService:open',\n      origin,\n      url,\n      protocols,\n    );\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validates the parameters for the snap_openWebSocket method.\n *\n * @param params - Parameters to validate.\n * @returns Validated parameters.\n * @throws Throws RPC error if validation fails.\n */\nfunction getValidatedParams(params: unknown): OpenWebSocketParameters {\n  try {\n    return create(params, OpenWebSocketParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"]}

package/dist/permitted/requestSnaps.cjs

@@ -6,12 +6,6 @@ const snaps_utils_1 = require("@metamask/snaps-utils");
 const utils_1 = require("@metamask/utils");
 const async_mutex_1 = require("async-mutex");
 const invokeSnap_1 = require("../restricted/invokeSnap.cjs");
-const methodName = 'wallet_requestSnaps';
-const hookNames = {
-    installSnaps: true,
-    requestPermissions: true,
-    getPermissions: true,
-};
 /**
  * Request permission for a dapp to communicate with the specified Snaps and
  * attempt to install them if they're not already installed.
@@ -38,9 +32,12 @@ const hookNames = {
  * ```
  */
 exports.requestSnapsHandler = {
-    methodNames: [methodName],
     implementation: requestSnapsImplementation,
-    hookNames,
+    actionNames: [
+        'SnapController:installSnaps',
+        'PermissionController:requestPermissions',
+        'PermissionController:getPermissions',
+    ],
 };
 /**
  * Checks whether an origin has existing `wallet_snap` permission and
@@ -110,15 +107,12 @@ function getMutex(origin) {
  * @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.installSnaps - A function that tries to install a given snap, prompting the user if necessary.
- * @param hooks.requestPermissions - A function that requests permissions on
- * behalf of a subject.
- * @param hooks.getPermissions - A function that gets the current permissions.
+ * @param _hooks - The RPC method hooks. Not used by this function.
+ * @param messenger - The messenger used to call controller actions.
  * @returns A promise that resolves once the JSON-RPC response has been modified.
  * @throws If the params are invalid.
  */
-async function requestSnapsImplementation(req, res, _next, end, { installSnaps, requestPermissions, getPermissions }) {
+async function requestSnapsImplementation(req, res, _next, end, _hooks, messenger) {
     const requestedSnaps = req.params;
     if (!(0, utils_1.isObject)(requestedSnaps)) {
         return end(rpc_errors_1.rpcErrors.invalidParams({
@@ -130,7 +124,6 @@ async function requestSnapsImplementation(req, res, _next, end, { installSnaps,
             message: 'Request must have at least one requested snap.',
         }));
     }
-    // We expect the MM middleware stack to always add the origin to requests
     const { origin } = req;
     const mutex = getMutex(origin);
     // Process requests sequentially for each origin as permissions need to be merged
@@ -142,17 +135,19 @@ async function requestSnapsImplementation(req, res, _next, end, { installSnaps,
                     caveats: [{ type: snaps_utils_1.SnapCaveatType.SnapIds, value: requestedSnaps }],
                 },
             };
-            const existingPermissions = await getPermissions();
+            const existingPermissions = messenger.call('PermissionController:getPermissions', origin);
             if (!existingPermissions) {
-                const [, metadata] = await requestPermissions(requestedPermissions);
+                const [, metadata] = await messenger.call('PermissionController:requestPermissions', { origin }, requestedPermissions);
+                (0, utils_1.assert)(metadata.data);
                 res.result = metadata.data[invokeSnap_1.WALLET_SNAP_PERMISSION_KEY];
             }
             else if (hasRequestedSnaps(existingPermissions, requestedSnaps)) {
-                res.result = await installSnaps(requestedSnaps);
+                res.result = await messenger.call('SnapController:installSnaps', origin, requestedSnaps);
             }
             else {
                 const mergedPermissionsRequest = getSnapPermissionsRequest(existingPermissions, requestedPermissions);
-                const [, metadata] = await requestPermissions(mergedPermissionsRequest);
+                const [, metadata] = await messenger.call('PermissionController:requestPermissions', { origin }, mergedPermissionsRequest);
+                (0, utils_1.assert)(metadata.data);
                 res.result = metadata.data[invokeSnap_1.WALLET_SNAP_PERMISSION_KEY];
             }
         }