Improve execution environment type validation

packages/execution-environments/jest.config.js

@@ -6,10 +6,10 @@ module.exports = {
   coverageReporters: ['clover', 'json', 'lcov', 'text', 'json-summary'],
   coverageThreshold: {
     global: {
-      branches: 82.88,
+      branches: 83.79,
       functions: 92.48,
-      lines: 85.84,
-      statements: 86.02,
+      lines: 86.53,
+      statements: 86.7,
     },
   },
   moduleFileExtensions: ['js', 'json', 'jsx', 'ts', 'tsx', 'node'],

packages/execution-environments/package.json

@@ -23,11 +23,9 @@
     "lint": "yarn lint:eslint && yarn lint:misc --check",
     "clean": "rimraf '*.tsbuildinfo' 'dist/*' 'src/__GENERATED__/' 'coverage/*' '__test__/*'",
     "build:clean": "yarn clean && yarn build",
-    "build:pre-tsc": "yarn build:typings",
     "build:post-tsc": "webpack --mode production && concat -o ./dist/webpack/node-process/bundle.js ./dist/webpack/node-process/lockdown.umd.min.js ./dist/webpack/node-process/bundle.js && concat -o ./dist/webpack/node-thread/bundle.js ./dist/webpack/node-thread/lockdown.umd.min.js ./dist/webpack/node-thread/bundle.js",
     "build:tsc": "tsc --project tsconfig.local.json",
-    "build": "yarn build:pre-tsc && yarn build:tsc && yarn build:post-tsc",
-    "build:typings": "open-rpc-typings -d ./src/openrpc.json --output-ts=./src/__GENERATED__/ --name-ts=openrpc && ts-auto-guard ./src/__GENERATED__/openrpc.ts --export-all",
+    "build": "yarn build:tsc && yarn build:post-tsc",
     "auto-changelog-init": "auto-changelog init",
     "publish:package": "../../scripts/publish-package.sh"
   },
@@ -41,7 +39,8 @@
     "eth-rpc-errors": "^4.0.3",
     "pump": "^3.0.0",
     "ses": "^0.15.15",
-    "stream-browserify": "^3.0.0"
+    "stream-browserify": "^3.0.0",
+    "superstruct": "^0.16.5"
   },
   "devDependencies": {
     "@lavamoat/allow-scripts": "^2.0.3",
@@ -50,7 +49,6 @@
     "@metamask/eslint-config-jest": "^9.0.0",
     "@metamask/eslint-config-nodejs": "^9.0.0",
     "@metamask/eslint-config-typescript": "^9.0.1",
-    "@open-rpc/typings": "^1.12.1",
     "@types/jest": "^27.5.1",
     "@types/node": "^17.0.36",
     "concat": "^1.0.3",
@@ -72,7 +70,6 @@
     "prettier": "^2.3.2",
     "prettier-plugin-packagejson": "^2.2.11",
     "rimraf": "^3.0.2",
-    "ts-auto-guard": "^2.3.0",
     "ts-jest": "^29.0.0",
     "ts-loader": "^9.3.1",
     "typescript": "^4.4.0",

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

@@ -1,9 +1,14 @@
 // eslint-disable-next-line import/no-unassigned-import
 import 'ses';
 import { Duplex, DuplexOptions, EventEmitter, Readable } from 'stream';
-import { Json, JsonRpcResponse } from '@metamask/utils';
+import {
+  assertIsJsonRpcSuccess,
+  Json,
+  JsonRpcParams,
+  JsonRpcRequest,
+  JsonRpcResponse,
+} from '@metamask/utils';
 import { HandlerType } from '@metamask/snap-utils';
-import { JsonRpcRequest } from '../__GENERATED__/openrpc';
 import { BaseSnapExecutor } from './BaseSnapExecutor';
 
 const FAKE_ORIGIN = 'origin:foo';
@@ -106,7 +111,7 @@ class TestSnapExecutor extends BaseSnapExecutor {
     });
   }
 
-  public writeCommand(message: JsonRpcRequest): Promise<void> {
+  public writeCommand(message: JsonRpcRequest<JsonRpcParams>): Promise<void> {
     return new Promise((resolve, reject) =>
       this.commandLeft.write(message, (error) => {
         if (error) {
@@ -117,8 +122,8 @@ class TestSnapExecutor extends BaseSnapExecutor {
     );
   }
 
-  public readCommand(): Promise<JsonRpcRequest> {
-    const promise = new Promise<JsonRpcRequest>((resolve) =>
+  public readCommand(): Promise<JsonRpcRequest<JsonRpcParams>> {
+    const promise = new Promise<JsonRpcRequest<JsonRpcParams>>((resolve) =>
       this.commandListeners.push(resolve),
     );
 
@@ -153,10 +158,14 @@ class TestSnapExecutor extends BaseSnapExecutor {
     );
   }
 
-  public readRpc(): Promise<{ name: string; data: JsonRpcRequest }> {
-    const promise = new Promise<{ name: string; data: JsonRpcRequest }>(
-      (resolve) => this.rpcListeners.push(resolve),
-    );
+  public readRpc(): Promise<{
+    name: string;
+    data: JsonRpcRequest<JsonRpcParams>;
+  }> {
+    const promise = new Promise<{
+      name: string;
+      data: JsonRpcRequest<JsonRpcParams>;
+    }>((resolve) => this.rpcListeners.push(resolve));
 
     TestSnapExecutor.flushReads(this.rpcBuffer, this.rpcListeners);
 
@@ -360,8 +369,8 @@ describe('BaseSnapExecutor', () => {
           }),
         );
 
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const handle = getHandleResult!.result;
+        assertIsJsonRpcSuccess(getHandleResult);
+        const handle = getHandleResult.result;
 
         await executor.writeCommand({
           jsonrpc: '2.0',
@@ -1535,4 +1544,121 @@ describe('BaseSnapExecutor', () => {
       },
     });
   });
+
+  describe('executeSnap', () => {
+    it.each([
+      {
+        snapName: 1,
+        code: 'module.exports.onRpcRequest = () => 1;',
+        endowments: [],
+      },
+      {
+        snapName: FAKE_SNAP_NAME,
+        code: 1,
+        endowments: [],
+      },
+      {
+        snapName: FAKE_SNAP_NAME,
+        code: 'module.exports.onRpcRequest = () => 1;',
+        endowments: ['foo', 1],
+      },
+      [1, 'module.exports.onRpcRequest = () => 1;', []],
+      [FAKE_SNAP_NAME, 1, []],
+      [FAKE_SNAP_NAME, 'module.exports.onRpcRequest = () => 1;', ['foo', 1]],
+    ])(
+      'throws an error if the request arguments are invalid',
+      async (params) => {
+        const executor = new TestSnapExecutor();
+
+        await executor.writeCommand({
+          jsonrpc: '2.0',
+          id: 1,
+          method: 'executeSnap',
+          params,
+        });
+
+        expect(await executor.readCommand()).toStrictEqual({
+          jsonrpc: '2.0',
+          id: 1,
+          error: {
+            code: -32600,
+            data: expect.any(Object),
+            message: expect.any(String),
+            stack: expect.any(String),
+          },
+        });
+      },
+    );
+  });
+
+  describe('snapRpc', () => {
+    it.each([
+      {
+        snapName: 1,
+        method: ON_RPC_REQUEST,
+        origin: FAKE_ORIGIN,
+        request: { jsonrpc: '2.0', method: '', params: [] },
+      },
+      {
+        snapName: FAKE_SNAP_NAME,
+        method: 1,
+        origin: FAKE_ORIGIN,
+        request: { jsonrpc: '2.0', method: '', params: [] },
+      },
+      {
+        snapName: FAKE_SNAP_NAME,
+        method: ON_RPC_REQUEST,
+        origin: 1,
+        request: { jsonrpc: '2.0', method: '', params: [] },
+      },
+      {
+        snapName: FAKE_SNAP_NAME,
+        method: ON_RPC_REQUEST,
+        origin: FAKE_ORIGIN,
+        request: 1,
+      },
+      [
+        1,
+        ON_RPC_REQUEST,
+        FAKE_ORIGIN,
+        { jsonrpc: '2.0', method: '', params: [] },
+      ],
+      [
+        FAKE_SNAP_NAME,
+        1,
+        FAKE_ORIGIN,
+        { jsonrpc: '2.0', method: '', params: [] },
+      ],
+      [
+        FAKE_SNAP_NAME,
+        ON_RPC_REQUEST,
+        1,
+        { jsonrpc: '2.0', method: '', params: [] },
+      ],
+      [FAKE_SNAP_NAME, ON_RPC_REQUEST, FAKE_ORIGIN, 1],
+    ])(
+      'throws an error if the request arguments are invalid',
+      async (params) => {
+        const executor = new TestSnapExecutor();
+
+        await executor.writeCommand({
+          jsonrpc: '2.0',
+          id: 1,
+          method: 'snapRpc',
+          params,
+        });
+
+        expect(await executor.readCommand()).toStrictEqual({
+          jsonrpc: '2.0',
+          id: 1,
+          error: {
+            code: -32600,
+            data: expect.any(Object),
+            message: expect.any(String),
+            stack: expect.any(String),
+          },
+        });
+      },
+    );
+  });
 });