@metamask/snaps-jest 6.0.1 → 7.0.0

package/dist/chunk-PVMIH6OB.mjs

@@ -0,0 +1,127 @@
+import {
+  clickElement,
+  getInterface,
+  typeInField
+} from "./chunk-I5P52IMF.mjs";
+import {
+  clearNotifications,
+  getNotifications
+} from "./chunk-LB4R3BUA.mjs";
+
+// src/internals/request.ts
+import { unwrapError } from "@metamask/snaps-utils";
+import { getSafeJson, hasProperty, isPlainObject } from "@metamask/utils";
+import { nanoid } from "@reduxjs/toolkit";
+function handleRequest({
+  snapId,
+  store,
+  executionService,
+  handler,
+  controllerMessenger,
+  runSaga,
+  request: { id = nanoid(), origin = "https://metamask.io", ...options }
+}) {
+  const promise = executionService.handleRpcRequest(snapId, {
+    origin,
+    handler,
+    request: {
+      jsonrpc: "2.0",
+      id: 1,
+      ...options
+    }
+  }).then(async (result) => {
+    const notifications = getNotifications(store.getState());
+    store.dispatch(clearNotifications());
+    const getInterfaceFn = await getInterfaceApi(
+      result,
+      snapId,
+      controllerMessenger
+    );
+    return {
+      id: String(id),
+      response: {
+        result: getSafeJson(result)
+      },
+      notifications,
+      ...getInterfaceFn ? { getInterface: getInterfaceFn } : {}
+    };
+  }).catch((error) => {
+    const [unwrappedError] = unwrapError(error);
+    return {
+      id: String(id),
+      response: {
+        error: unwrappedError.serialize()
+      },
+      notifications: []
+    };
+  });
+  promise.getInterface = async () => {
+    return await runSaga(
+      getInterface,
+      runSaga,
+      snapId,
+      controllerMessenger
+    ).toPromise();
+  };
+  return promise;
+}
+async function getInterfaceFromResult(result, snapId, controllerMessenger) {
+  if (isPlainObject(result) && hasProperty(result, "id")) {
+    return result.id;
+  }
+  if (isPlainObject(result) && hasProperty(result, "content")) {
+    const id = await controllerMessenger.call(
+      "SnapInterfaceController:createInterface",
+      snapId,
+      result.content
+    );
+    return id;
+  }
+  return void 0;
+}
+async function getInterfaceApi(result, snapId, controllerMessenger) {
+  const interfaceId = await getInterfaceFromResult(
+    result,
+    snapId,
+    controllerMessenger
+  );
+  if (interfaceId) {
+    return () => {
+      const { content } = controllerMessenger.call(
+        "SnapInterfaceController:getInterface",
+        snapId,
+        interfaceId
+      );
+      return {
+        content,
+        clickElement: async (name) => {
+          await clickElement(
+            controllerMessenger,
+            interfaceId,
+            content,
+            snapId,
+            name
+          );
+        },
+        typeInField: async (name, value) => {
+          await typeInField(
+            controllerMessenger,
+            interfaceId,
+            content,
+            snapId,
+            name,
+            value
+          );
+        }
+      };
+    };
+  }
+  return void 0;
+}
+
+export {
+  handleRequest,
+  getInterfaceFromResult,
+  getInterfaceApi
+};
+//# sourceMappingURL=chunk-PVMIH6OB.mjs.map

package/dist/chunk-PVMIH6OB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/request.ts"],"sourcesContent":["import type { AbstractExecutionService } from '@metamask/snaps-controllers';\nimport type { SnapId, Component } from '@metamask/snaps-sdk';\nimport type { HandlerType } from '@metamask/snaps-utils';\nimport { unwrapError } from '@metamask/snaps-utils';\nimport { getSafeJson, hasProperty, isPlainObject } from '@metamask/utils';\nimport { nanoid } from '@reduxjs/toolkit';\n\nimport type {\n  RequestOptions,\n  SnapHandlerInterface,\n  SnapRequest,\n} from '../types';\nimport {\n  clearNotifications,\n  clickElement,\n  getInterface,\n  getNotifications,\n  typeInField,\n} from './simulation';\nimport type { RunSagaFunction, Store } from './simulation';\nimport type { RootControllerMessenger } from './simulation/controllers';\n\nexport type HandleRequestOptions = {\n  snapId: SnapId;\n  store: Store;\n  executionService: AbstractExecutionService<unknown>;\n  handler: HandlerType;\n  controllerMessenger: RootControllerMessenger;\n  runSaga: RunSagaFunction;\n  request: RequestOptions;\n};\n\n/**\n * Send a JSON-RPC request to the Snap, and wrap the response in a\n * {@link SnapResponse} object.\n *\n * @param options - The request options.\n * @param options.snapId - The ID of the Snap to send the request to.\n * @param options.store - The Redux store.\n * @param options.executionService - The execution service to use to send the\n * request.\n * @param options.handler - The handler to use to send the request.\n * @param options.controllerMessenger - The controller messenger used to call actions.\n * @param options.runSaga - A function to run a saga outside the usual Redux\n * flow.\n * @param options.request - The request to send.\n * @param options.request.id - The ID of the request. If not provided, a random\n * ID will be generated.\n * @param options.request.origin - The origin of the request. Defaults to\n * `https://metamask.io`.\n * @returns The response, wrapped in a {@link SnapResponse} object.\n */\nexport function handleRequest({\n  snapId,\n  store,\n  executionService,\n  handler,\n  controllerMessenger,\n  runSaga,\n  request: { id = nanoid(), origin = 'https://metamask.io', ...options },\n}: HandleRequestOptions): SnapRequest {\n  const promise = executionService\n    .handleRpcRequest(snapId, {\n      origin,\n      handler,\n      request: {\n        jsonrpc: '2.0',\n        id: 1,\n        ...options,\n      },\n    })\n    .then(async (result) => {\n      const notifications = getNotifications(store.getState());\n      store.dispatch(clearNotifications());\n\n      const getInterfaceFn = await getInterfaceApi(\n        result,\n        snapId,\n        controllerMessenger,\n      );\n\n      return {\n        id: String(id),\n        response: {\n          result: getSafeJson(result),\n        },\n        notifications,\n        ...(getInterfaceFn ? { getInterface: getInterfaceFn } : {}),\n      };\n    })\n    .catch((error) => {\n      const [unwrappedError] = unwrapError(error);\n\n      return {\n        id: String(id),\n        response: {\n          error: unwrappedError.serialize(),\n        },\n        notifications: [],\n      };\n    }) as unknown as SnapRequest;\n\n  promise.getInterface = async () => {\n    return await runSaga(\n      getInterface,\n      runSaga,\n      snapId,\n      controllerMessenger,\n    ).toPromise();\n  };\n\n  return promise;\n}\n\n/**\n * Get the interface ID from the result if it's available or create a new interface if the result contains static components.\n *\n * @param result - The handler result object.\n * @param snapId - The Snap ID.\n * @param controllerMessenger - The controller messenger.\n * @returns The interface ID or undefined if the result doesn't include content.\n */\nexport async function getInterfaceFromResult(\n  result: unknown,\n  snapId: SnapId,\n  controllerMessenger: RootControllerMessenger,\n) {\n  if (isPlainObject(result) && hasProperty(result, 'id')) {\n    return result.id as string;\n  }\n\n  if (isPlainObject(result) && hasProperty(result, 'content')) {\n    const id = await controllerMessenger.call(\n      'SnapInterfaceController:createInterface',\n      snapId,\n      result.content as Component,\n    );\n\n    return id;\n  }\n\n  return undefined;\n}\n\n/**\n * Get the response content from the SnapInterfaceController and include the interaction methods.\n *\n * @param result - The handler result object.\n * @param snapId - The Snap ID.\n * @param controllerMessenger - The controller messenger.\n * @returns The content components if any.\n */\nexport async function getInterfaceApi(\n  result: unknown,\n  snapId: SnapId,\n  controllerMessenger: RootControllerMessenger,\n): Promise<(() => SnapHandlerInterface) | undefined> {\n  const interfaceId = await getInterfaceFromResult(\n    result,\n    snapId,\n    controllerMessenger,\n  );\n\n  if (interfaceId) {\n    return () => {\n      const { content } = controllerMessenger.call(\n        'SnapInterfaceController:getInterface',\n        snapId,\n        interfaceId,\n      );\n\n      return {\n        content,\n        clickElement: async (name) => {\n          await clickElement(\n            controllerMessenger,\n            interfaceId,\n            content,\n            snapId,\n            name,\n          );\n        },\n        typeInField: async (name, value) => {\n          await typeInField(\n            controllerMessenger,\n            interfaceId,\n            content,\n            snapId,\n            name,\n            value,\n          );\n        },\n      };\n    };\n  }\n\n  return undefined;\n}\n"],"mappings":";;;;;;;;;;;AAGA,SAAS,mBAAmB;AAC5B,SAAS,aAAa,aAAa,qBAAqB;AACxD,SAAS,cAAc;AA+ChB,SAAS,cAAc;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,SAAS,EAAE,KAAK,OAAO,GAAG,SAAS,uBAAuB,GAAG,QAAQ;AACvE,GAAsC;AACpC,QAAM,UAAU,iBACb,iBAAiB,QAAQ;AAAA,IACxB;AAAA,IACA;AAAA,IACA,SAAS;AAAA,MACP,SAAS;AAAA,MACT,IAAI;AAAA,MACJ,GAAG;AAAA,IACL;AAAA,EACF,CAAC,EACA,KAAK,OAAO,WAAW;AACtB,UAAM,gBAAgB,iBAAiB,MAAM,SAAS,CAAC;AACvD,UAAM,SAAS,mBAAmB,CAAC;AAEnC,UAAM,iBAAiB,MAAM;AAAA,MAC3B;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,WAAO;AAAA,MACL,IAAI,OAAO,EAAE;AAAA,MACb,UAAU;AAAA,QACR,QAAQ,YAAY,MAAM;AAAA,MAC5B;AAAA,MACA;AAAA,MACA,GAAI,iBAAiB,EAAE,cAAc,eAAe,IAAI,CAAC;AAAA,IAC3D;AAAA,EACF,CAAC,EACA,MAAM,CAAC,UAAU;AAChB,UAAM,CAAC,cAAc,IAAI,YAAY,KAAK;AAE1C,WAAO;AAAA,MACL,IAAI,OAAO,EAAE;AAAA,MACb,UAAU;AAAA,QACR,OAAO,eAAe,UAAU;AAAA,MAClC;AAAA,MACA,eAAe,CAAC;AAAA,IAClB;AAAA,EACF,CAAC;AAEH,UAAQ,eAAe,YAAY;AACjC,WAAO,MAAM;AAAA,MACX;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,EAAE,UAAU;AAAA,EACd;AAEA,SAAO;AACT;AAUA,eAAsB,uBACpB,QACA,QACA,qBACA;AACA,MAAI,cAAc,MAAM,KAAK,YAAY,QAAQ,IAAI,GAAG;AACtD,WAAO,OAAO;AAAA,EAChB;AAEA,MAAI,cAAc,MAAM,KAAK,YAAY,QAAQ,SAAS,GAAG;AAC3D,UAAM,KAAK,MAAM,oBAAoB;AAAA,MACnC;AAAA,MACA;AAAA,MACA,OAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAUA,eAAsB,gBACpB,QACA,QACA,qBACmD;AACnD,QAAM,cAAc,MAAM;AAAA,IACxB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,MAAI,aAAa;AACf,WAAO,MAAM;AACX,YAAM,EAAE,QAAQ,IAAI,oBAAoB;AAAA,QACtC;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAEA,aAAO;AAAA,QACL;AAAA,QACA,cAAc,OAAO,SAAS;AAC5B,gBAAM;AAAA,YACJ;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UACF;AAAA,QACF;AAAA,QACA,aAAa,OAAO,MAAM,UAAU;AAClC,gBAAM;AAAA,YACJ;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-S2HLITUN.js

@@ -0,0 +1 @@
+"use strict";//# sourceMappingURL=chunk-S2HLITUN.js.map

package/dist/{chunk-ISWZ7XZ5.js → chunk-SB5EPHE3.js}

@@ -5,9 +5,11 @@
 var _chunkLBC2OGSNjs = require('./chunk-LBC2OGSN.js');
 
 // src/internals/simulation/methods/hooks/state.ts
+var _snapsutils = require('@metamask/snaps-utils');
 var _effects = require('redux-saga/effects');
 function* getSnapStateImplementation(_snapId, encrypted = true) {
-  return yield _effects.select.call(void 0, _chunkLBC2OGSNjs.getState.call(void 0, encrypted));
+  const state = yield _effects.select.call(void 0, _chunkLBC2OGSNjs.getState.call(void 0, encrypted));
+  return _snapsutils.parseJson.call(void 0, state);
 }
 function getGetSnapStateMethodImplementation(runSaga) {
   return (...args) => {
@@ -15,7 +17,7 @@ function getGetSnapStateMethodImplementation(runSaga) {
   };
 }
 function* updateSnapStateImplementation(_snapId, newState, encrypted = true) {
-  yield _effects.put.call(void 0, _chunkLBC2OGSNjs.setState.call(void 0, { state: newState, encrypted }));
+  yield _effects.put.call(void 0, _chunkLBC2OGSNjs.setState.call(void 0, { state: JSON.stringify(newState), encrypted }));
 }
 function getUpdateSnapStateMethodImplementation(runSaga) {
   return (...args) => {
@@ -36,4 +38,4 @@ function getClearSnapStateMethodImplementation(runSaga) {
 
 
 exports.getGetSnapStateMethodImplementation = getGetSnapStateMethodImplementation; exports.getUpdateSnapStateMethodImplementation = getUpdateSnapStateMethodImplementation; exports.getClearSnapStateMethodImplementation = getClearSnapStateMethodImplementation;
-//# sourceMappingURL=chunk-ISWZ7XZ5.js.map
+//# sourceMappingURL=chunk-SB5EPHE3.js.map

package/dist/chunk-SB5EPHE3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/methods/hooks/state.ts"],"names":[],"mappings":";;;;;;;AAAA,SAAS,iBAAiB;AAG1B,SAAS,KAAK,cAAc;AAe5B,UAAU,2BACR,SACA,YAAY,MACU;AACtB,QAAM,QAAQ,MAAM,OAAO,SAAS,SAAS,CAAC;AAE9C,SAAO,UAAU,KAAK;AACxB;AAQO,SAAS,oCAAoC,SAA0B;AAC5E,SAAO,IAAI,SAAwD;AACjE,WAAO,QAAQ,4BAA4B,GAAG,IAAI,EAAE,OAAO;AAAA,EAC7D;AACF;AAYA,UAAU,8BACR,SACA,UACA,YAAY,MACQ;AAEpB,QAAM,IAAI,SAAS,EAAE,OAAO,KAAK,UAAU,QAAQ,GAAG,UAAU,CAAC,CAAC;AACpE;AAQO,SAAS,uCACd,SACA;AACA,SAAO,IAAI,SAA2D;AACpE,YAAQ,+BAA+B,GAAG,IAAI,EAAE,OAAO;AAAA,EACzD;AACF;AAWA,UAAU,6BACR,SACA,YAAY,MACQ;AACpB,QAAM,IAAI,WAAW,EAAE,UAAU,CAAC,CAAC;AACrC;AAQO,SAAS,sCACd,SACA;AACA,SAAO,UAAU,SAA0D;AACzE,YAAQ,8BAA8B,GAAG,IAAI,EAAE,OAAO;AAAA,EACxD;AACF","sourcesContent":["import { parseJson } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\nimport type { SagaIterator } from 'redux-saga';\nimport { put, select } from 'redux-saga/effects';\n\nimport type { RunSagaFunction } from '../../store';\nimport { clearState, getState, setState } from '../../store';\n\n/**\n * Get the Snap state from the store.\n *\n * @param _snapId - The ID of the Snap to get the state for. This is ignored\n * because the simulator only supports one Snap.\n * @param encrypted - Whether to get the encrypted or unencrypted state.\n * Defaults to encrypted state.\n * @returns The state of the Snap.\n * @yields Selects the state from the store.\n */\nfunction* getSnapStateImplementation(\n  _snapId: string,\n  encrypted = true,\n): SagaIterator<string> {\n  const state = yield select(getState(encrypted));\n  // TODO: Use actual decryption implementation\n  return parseJson(state);\n}\n\n/**\n * Get the implementation of the `getSnapState` hook.\n *\n * @param runSaga - The function to run a saga outside the usual Redux flow.\n * @returns The implementation of the `getSnapState` hook.\n */\nexport function getGetSnapStateMethodImplementation(runSaga: RunSagaFunction) {\n  return (...args: Parameters<typeof getSnapStateImplementation>) => {\n    return runSaga(getSnapStateImplementation, ...args).result();\n  };\n}\n\n/**\n * Update the Snap state in the store.\n *\n * @param _snapId - The ID of the Snap to update the state for. This is ignored\n * because the simulator only supports one Snap.\n * @param newState - The new state.\n * @param encrypted - Whether to update the encrypted or unencrypted state.\n * Defaults to encrypted state.\n * @yields Puts the new state in the store.\n */\nfunction* updateSnapStateImplementation(\n  _snapId: string,\n  newState: Record<string, Json>,\n  encrypted = true,\n): SagaIterator<void> {\n  // TODO: Use actual encryption implementation\n  yield put(setState({ state: JSON.stringify(newState), encrypted }));\n}\n\n/**\n * Get the implementation of the `updateSnapState` hook.\n *\n * @param runSaga - The function to run a saga outside the usual Redux flow.\n * @returns The implementation of the `updateSnapState` hook.\n */\nexport function getUpdateSnapStateMethodImplementation(\n  runSaga: RunSagaFunction,\n) {\n  return (...args: Parameters<typeof updateSnapStateImplementation>) => {\n    runSaga(updateSnapStateImplementation, ...args).result();\n  };\n}\n\n/**\n * Clear the Snap state in the store.\n *\n * @param _snapId - The ID of the Snap to clear the state for. This is ignored\n * because the simulator only supports one Snap.\n * @param encrypted - Whether to clear the encrypted or unencrypted state.\n * Defaults to encrypted state.\n * @yields Puts the new state in the store.\n */\nfunction* clearSnapStateImplementation(\n  _snapId: string,\n  encrypted = true,\n): SagaIterator<void> {\n  yield put(clearState({ encrypted }));\n}\n\n/**\n * Get the implementation of the `clearSnapState` hook.\n *\n * @param runSaga - The function to run a saga outside the usual Redux flow.\n * @returns The implementation of the `clearSnapState` hook.\n */\nexport function getClearSnapStateMethodImplementation(\n  runSaga: RunSagaFunction,\n) {\n  return async (...args: Parameters<typeof clearSnapStateImplementation>) => {\n    runSaga(clearSnapStateImplementation, ...args).result();\n  };\n}\n"]}

package/dist/{chunk-HBLJOACO.mjs → chunk-TAIJXTLU.mjs}

@@ -1,7 +1,3 @@
-import {
-  decryptImplementation,
-  encryptImplementation
-} from "./chunk-2X23DUDP.mjs";
 import {
   getGetLocaleMethodImplementation
 } from "./chunk-KSIBNOB2.mjs";
@@ -20,7 +16,7 @@ import {
   getClearSnapStateMethodImplementation,
   getGetSnapStateMethodImplementation,
   getUpdateSnapStateMethodImplementation
-} from "./chunk-7BFTEFLS.mjs";
+} from "./chunk-5U5WB3SM.mjs";
 import {
   EXCLUDED_SNAP_ENDOWMENTS,
   EXCLUDED_SNAP_PERMISSIONS
@@ -50,10 +46,6 @@ function getPermissionSpecifications({
     ...buildSnapRestrictedMethodSpecifications(EXCLUDED_SNAP_PERMISSIONS, {
       // Shared hooks.
       ...hooks,
-      // Encryption and decryption hooks.
-      // TODO: Swap these out for the real implementations.
-      encrypt: encryptImplementation,
-      decrypt: decryptImplementation,
       // Snaps-specific hooks.
       clearSnapState: getClearSnapStateMethodImplementation(runSaga),
       getLocale: getGetLocaleMethodImplementation(options),
@@ -94,4 +86,4 @@ export {
   getPermissionSpecifications,
   getEndowments
 };
-//# sourceMappingURL=chunk-HBLJOACO.mjs.map
+//# sourceMappingURL=chunk-TAIJXTLU.mjs.map

package/dist/chunk-TAIJXTLU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/methods/specifications.ts"],"sourcesContent":["import type { GenericPermissionController } from '@metamask/permission-controller';\nimport {\n  endowmentPermissionBuilders,\n  buildSnapEndowmentSpecifications,\n  buildSnapRestrictedMethodSpecifications,\n} from '@metamask/snaps-rpc-methods';\nimport type { SnapId } from '@metamask/snaps-sdk';\nimport { DEFAULT_ENDOWMENTS } from '@metamask/snaps-utils';\n\nimport type { RootControllerMessenger } from '../controllers';\nimport type { SimulationOptions } from '../options';\nimport type { RunSagaFunction } from '../store';\nimport {\n  EXCLUDED_SNAP_ENDOWMENTS,\n  EXCLUDED_SNAP_PERMISSIONS,\n} from './constants';\nimport {\n  getGetLocaleMethodImplementation,\n  getClearSnapStateMethodImplementation,\n  getGetSnapStateMethodImplementation,\n  getUpdateSnapStateMethodImplementation,\n  getShowDialogImplementation,\n  getShowInAppNotificationImplementation,\n  getShowNativeNotificationImplementation,\n  getCreateInterfaceImplementation,\n  getGetInterfaceImplementation,\n} from './hooks';\n\nexport type PermissionSpecificationsHooks = {\n  /**\n   * A hook that returns the user's secret recovery phrase.\n   *\n   * @returns The user's secret recovery phrase.\n   */\n  getMnemonic: () => Promise<Uint8Array>;\n};\n\nexport type GetPermissionSpecificationsOptions = {\n  controllerMessenger: RootControllerMessenger;\n  hooks: PermissionSpecificationsHooks;\n  runSaga: RunSagaFunction;\n  options: SimulationOptions;\n};\n\n/**\n * Get a function which resolves with the specified result.\n *\n * @param result - The result to return.\n * @returns The function implementation.\n */\nexport function resolve(result: unknown) {\n  return () => result;\n}\n\n/**\n * Get a function which resolves with the specified result.\n *\n * @param result - The result to return. If not specified, the function will\n * resolve with `undefined`.\n * @returns The function implementation.\n */\nexport function asyncResolve(result?: unknown) {\n  return async () => result;\n}\n\n/**\n * Get the permission specifications for the Snap.\n *\n * @param options - The options.\n * @param options.controllerMessenger - The controller messenger.\n * @param options.hooks - The hooks.\n * @param options.runSaga - The function to run a saga outside the usual Redux\n * flow.\n * @param options.options - The simulation options.\n * @returns The permission specifications for the Snap.\n */\nexport function getPermissionSpecifications({\n  controllerMessenger,\n  hooks,\n  runSaga,\n  options,\n}: GetPermissionSpecificationsOptions) {\n  return {\n    ...buildSnapEndowmentSpecifications(EXCLUDED_SNAP_ENDOWMENTS),\n    ...buildSnapRestrictedMethodSpecifications(EXCLUDED_SNAP_PERMISSIONS, {\n      // Shared hooks.\n      ...hooks,\n\n      // Snaps-specific hooks.\n      clearSnapState: getClearSnapStateMethodImplementation(runSaga),\n      getLocale: getGetLocaleMethodImplementation(options),\n      getSnapState: getGetSnapStateMethodImplementation(runSaga),\n      getUnlockPromise: asyncResolve(true),\n\n      // TODO: Allow the user to specify the result of this function.\n      isOnPhishingList: resolve(false),\n\n      maybeUpdatePhishingList: asyncResolve(),\n      showDialog: getShowDialogImplementation(runSaga),\n      showInAppNotification: getShowInAppNotificationImplementation(runSaga),\n      showNativeNotification: getShowNativeNotificationImplementation(runSaga),\n      updateSnapState: getUpdateSnapStateMethodImplementation(runSaga),\n      createInterface: getCreateInterfaceImplementation(controllerMessenger),\n      getInterface: getGetInterfaceImplementation(controllerMessenger),\n    }),\n  };\n}\n\n/**\n * Get the endowments for the Snap.\n *\n * @param permissionController - The permission controller.\n * @param snapId - The ID of the Snap.\n * @returns The endowments for the Snap.\n */\nexport async function getEndowments(\n  permissionController: GenericPermissionController,\n  snapId: SnapId,\n) {\n  const allEndowments = await Object.keys(endowmentPermissionBuilders).reduce<\n    Promise<string[]>\n  >(async (promise, permissionName) => {\n    const accumulator = await promise;\n    if (permissionController.hasPermission(snapId, permissionName)) {\n      const endowments = await permissionController.getEndowments(\n        snapId,\n        permissionName,\n      );\n\n      if (endowments) {\n        return accumulator.concat(endowments as string[]);\n      }\n    }\n\n    return accumulator;\n  }, Promise.resolve([]));\n\n  return [...new Set([...DEFAULT_ENDOWMENTS, ...allEndowments])];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,0BAA0B;AA2C5B,SAAS,QAAQ,QAAiB;AACvC,SAAO,MAAM;AACf;AASO,SAAS,aAAa,QAAkB;AAC7C,SAAO,YAAY;AACrB;AAaO,SAAS,4BAA4B;AAAA,EAC1C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAAuC;AACrC,SAAO;AAAA,IACL,GAAG,iCAAiC,wBAAwB;AAAA,IAC5D,GAAG,wCAAwC,2BAA2B;AAAA;AAAA,MAEpE,GAAG;AAAA;AAAA,MAGH,gBAAgB,sCAAsC,OAAO;AAAA,MAC7D,WAAW,iCAAiC,OAAO;AAAA,MACnD,cAAc,oCAAoC,OAAO;AAAA,MACzD,kBAAkB,aAAa,IAAI;AAAA;AAAA,MAGnC,kBAAkB,QAAQ,KAAK;AAAA,MAE/B,yBAAyB,aAAa;AAAA,MACtC,YAAY,4BAA4B,OAAO;AAAA,MAC/C,uBAAuB,uCAAuC,OAAO;AAAA,MACrE,wBAAwB,wCAAwC,OAAO;AAAA,MACvE,iBAAiB,uCAAuC,OAAO;AAAA,MAC/D,iBAAiB,iCAAiC,mBAAmB;AAAA,MACrE,cAAc,8BAA8B,mBAAmB;AAAA,IACjE,CAAC;AAAA,EACH;AACF;AASA,eAAsB,cACpB,sBACA,QACA;AACA,QAAM,gBAAgB,MAAM,OAAO,KAAK,2BAA2B,EAAE,OAEnE,OAAO,SAAS,mBAAmB;AACnC,UAAM,cAAc,MAAM;AAC1B,QAAI,qBAAqB,cAAc,QAAQ,cAAc,GAAG;AAC9D,YAAM,aAAa,MAAM,qBAAqB;AAAA,QAC5C;AAAA,QACA;AAAA,MACF;AAEA,UAAI,YAAY;AACd,eAAO,YAAY,OAAO,UAAsB;AAAA,MAClD;AAAA,IACF;AAEA,WAAO;AAAA,EACT,GAAG,QAAQ,QAAQ,CAAC,CAAC,CAAC;AAEtB,SAAO,CAAC,GAAG,oBAAI,IAAI,CAAC,GAAG,oBAAoB,GAAG,aAAa,CAAC,CAAC;AAC/D;","names":[]}

package/dist/chunk-TGZ7WOTJ.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-TGZ7WOTJ.mjs.map

package/dist/chunk-UDOXICJK.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-UDOXICJK.mjs.map

package/dist/{chunk-LHU3EHLI.mjs → chunk-VSUNWJMQ.mjs}

@@ -1,22 +1,22 @@
 import {
   createJsonRpcEngine
 } from "./chunk-KNJNL723.mjs";
+import {
+  getSnapFile
+} from "./chunk-TBDYQSRT.mjs";
 import {
   getOptions
 } from "./chunk-IH7UNS5A.mjs";
 import {
   getControllers,
   registerSnap
-} from "./chunk-CCYBLBVL.mjs";
+} from "./chunk-LG3VKXGH.mjs";
 import {
   getEndowments
-} from "./chunk-HBLJOACO.mjs";
+} from "./chunk-TAIJXTLU.mjs";
 import {
   createStore
-} from "./chunk-7YD4IW43.mjs";
-import {
-  getSnapFile
-} from "./chunk-TBDYQSRT.mjs";
+} from "./chunk-3M4GRUMH.mjs";
 
 // src/internals/simulation/simulation.ts
 import { ControllerMessenger } from "@metamask/base-controller";
@@ -28,7 +28,6 @@ import {
   NodeThreadExecutionService,
   setupMultiplex
 } from "@metamask/snaps-controllers/node";
-import { getEncryptionKey } from "@metamask/snaps-rpc-methods";
 import { logError } from "@metamask/snaps-utils";
 import { pipeline } from "readable-stream";
 async function handleInstallSnap(snapId, {
@@ -41,11 +40,7 @@ async function handleInstallSnap(snapId, {
     allowLocal: true
   });
   const snapFiles = await fetchSnap(snapId, location);
-  const password = await getEncryptionKey({
-    mnemonicPhrase: mnemonicPhraseToBytes(options.secretRecoveryPhrase),
-    snapId
-  });
-  const { store, runSaga } = createStore(password, options);
+  const { store, runSaga } = createStore(options);
   const controllerMessenger = new ControllerMessenger();
   registerActions(controllerMessenger);
   const hooks = getHooks(options, snapFiles, snapId, controllerMessenger);
@@ -66,7 +61,9 @@ async function handleInstallSnap(snapId, {
   const service = new ExecutionService({
     ...executionServiceOptions,
     messenger: controllerMessenger.getRestricted({
-      name: "ExecutionService"
+      name: "ExecutionService",
+      allowedActions: [],
+      allowedEvents: []
     }),
     setupSnapProvider: (_snapId, rpcStream) => {
       const mux = setupMultiplex(rpcStream, "snapStream");
@@ -134,4 +131,4 @@ export {
   getHooks,
   registerActions
 };
-//# sourceMappingURL=chunk-LHU3EHLI.mjs.map
+//# sourceMappingURL=chunk-VSUNWJMQ.mjs.map

package/dist/chunk-VSUNWJMQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/simulation.ts"],"sourcesContent":["import type {\n  ActionConstraint,\n  EventConstraint,\n} from '@metamask/base-controller';\nimport { ControllerMessenger } from '@metamask/base-controller';\nimport { createEngineStream } from '@metamask/json-rpc-middleware-stream';\nimport { mnemonicPhraseToBytes } from '@metamask/key-tree';\nimport type { AbstractExecutionService } from '@metamask/snaps-controllers';\nimport {\n  fetchSnap,\n  detectSnapLocation,\n  NodeThreadExecutionService,\n  setupMultiplex,\n} from '@metamask/snaps-controllers/node';\nimport type {\n  SnapId,\n  AuxiliaryFileEncoding,\n  Component,\n  InterfaceState,\n} from '@metamask/snaps-sdk';\nimport type { FetchedSnapFiles } from '@metamask/snaps-utils';\nimport { logError } from '@metamask/snaps-utils';\nimport type { Duplex } from 'readable-stream';\nimport { pipeline } from 'readable-stream';\n\nimport type { RootControllerMessenger } from './controllers';\nimport { getControllers, registerSnap } from './controllers';\nimport { getSnapFile } from './files';\nimport { getEndowments } from './methods';\nimport { createJsonRpcEngine } from './middleware';\nimport type { SimulationOptions, SimulationUserOptions } from './options';\nimport { getOptions } from './options';\nimport type { RunSagaFunction, Store } from './store';\nimport { createStore } from './store';\n\n/**\n * Options for the execution service, without the options that are shared\n * between all execution services.\n *\n * @template Service - The type of the execution service, i.e., the class that\n * creates the execution service.\n */\nexport type ExecutionServiceOptions<\n  Service extends new (...args: any[]) => any,\n> = Omit<\n  ConstructorParameters<Service>[0],\n  keyof ConstructorParameters<typeof AbstractExecutionService<unknown>>[0]\n>;\n\n/**\n * The options for running a Snap in a simulated environment.\n *\n * @property executionService - The execution service to use.\n * @property executionServiceOptions - The options to use when creating the\n * execution service, if any. This should only include options specific to the\n * provided execution service.\n * @property options - The simulation options.\n * @template Service - The type of the execution service.\n */\nexport type InstallSnapOptions<\n  Service extends new (...args: any[]) => InstanceType<\n    typeof AbstractExecutionService<unknown>\n  >,\n> = ExecutionServiceOptions<Service> extends Record<string, never>\n  ? {\n      executionService: Service;\n      executionServiceOptions?: ExecutionServiceOptions<Service>;\n      options?: SimulationUserOptions;\n    }\n  : {\n      executionService: Service;\n      executionServiceOptions: ExecutionServiceOptions<Service>;\n      options?: SimulationUserOptions;\n    };\n\nexport type InstalledSnap = {\n  snapId: SnapId;\n  store: Store;\n  executionService: InstanceType<typeof AbstractExecutionService>;\n  controllerMessenger: ControllerMessenger<ActionConstraint, EventConstraint>;\n  runSaga: RunSagaFunction;\n};\n\nexport type MiddlewareHooks = {\n  /**\n   * A hook that returns the user's secret recovery phrase.\n   *\n   * @returns The user's secret recovery phrase.\n   */\n  getMnemonic: () => Promise<Uint8Array>;\n\n  /**\n   * A hook that returns the Snap's auxiliary file for the given path.\n   *\n   * @param path - The path of the auxiliary file to get.\n   * @param encoding - The encoding to use when returning the file.\n   * @returns The Snap's auxiliary file for the given path.\n   */\n  getSnapFile: (\n    path: string,\n    encoding: AuxiliaryFileEncoding,\n  ) => Promise<string | null>;\n\n  /**\n   * A hook that returns whether the client is locked or not.\n   *\n   * @returns A boolean flag signaling whether the client is locked.\n   */\n  getIsLocked: () => boolean;\n  createInterface: (content: Component) => Promise<string>;\n  updateInterface: (id: string, content: Component) => Promise<void>;\n  getInterfaceState: (id: string) => InterfaceState;\n};\n\n/**\n * Install a Snap in a simulated environment. This will fetch the Snap files,\n * create a Redux store, set up the controllers and JSON-RPC stack, register the\n * Snap, and run the Snap code in the execution service.\n *\n * @param snapId - The ID of the Snap to install.\n * @param options - The options to use when installing the Snap.\n * @param options.executionService - The execution service to use.\n * @param options.executionServiceOptions - The options to use when creating the\n * execution service, if any. This should only include options specific to the\n * provided execution service.\n * @param options.options - The simulation options.\n * @template Service - The type of the execution service.\n */\nexport async function handleInstallSnap<\n  Service extends new (...args: any[]) => InstanceType<\n    typeof AbstractExecutionService\n  >,\n>(\n  snapId: SnapId,\n  {\n    executionService,\n    executionServiceOptions,\n    options: rawOptions = {},\n  }: Partial<InstallSnapOptions<Service>> = {},\n): Promise<InstalledSnap> {\n  const options = getOptions(rawOptions);\n\n  // Fetch Snap files.\n  const location = detectSnapLocation(snapId, {\n    allowLocal: true,\n  });\n\n  const snapFiles = await fetchSnap(snapId, location);\n\n  // Create Redux store.\n  const { store, runSaga } = createStore(options);\n\n  const controllerMessenger = new ControllerMessenger<any, any>();\n\n  registerActions(controllerMessenger);\n\n  // Set up controllers and JSON-RPC stack.\n  const hooks = getHooks(options, snapFiles, snapId, controllerMessenger);\n\n  const { subjectMetadataController, permissionController } = getControllers({\n    controllerMessenger,\n    hooks,\n    runSaga,\n    options,\n  });\n\n  const engine = createJsonRpcEngine({\n    store,\n    hooks,\n    permissionMiddleware: permissionController.createPermissionMiddleware({\n      origin: snapId,\n    }),\n  });\n\n  // Create execution service.\n  const ExecutionService = executionService ?? NodeThreadExecutionService;\n  const service = new ExecutionService({\n    ...executionServiceOptions,\n    messenger: controllerMessenger.getRestricted({\n      name: 'ExecutionService',\n      allowedActions: [],\n      allowedEvents: [],\n    }),\n    setupSnapProvider: (_snapId: string, rpcStream: Duplex) => {\n      const mux = setupMultiplex(rpcStream, 'snapStream');\n      const stream = mux.createStream('metamask-provider');\n      const providerStream = createEngineStream({ engine });\n\n      // Error function is difficult to test, so we ignore it.\n      /* istanbul ignore next 2 */\n      pipeline(stream, providerStream, stream, (error: unknown) => {\n        if (error) {\n          logError(`Provider stream failure.`, error);\n        }\n      });\n    },\n  });\n\n  // Register the Snap. This sets up the Snap's permissions and subject\n  // metadata.\n  await registerSnap(snapId, snapFiles.manifest.result, {\n    permissionController,\n    subjectMetadataController,\n  });\n\n  // Run the Snap code in the execution service.\n  await service.executeSnap({\n    snapId,\n    sourceCode: snapFiles.sourceCode.toString('utf8'),\n    endowments: await getEndowments(permissionController, snapId),\n  });\n\n  return {\n    snapId,\n    store,\n    executionService: service,\n    controllerMessenger,\n    runSaga,\n  };\n}\n\n/**\n * Get the hooks for the simulation.\n *\n * @param options - The simulation options.\n * @param snapFiles - The Snap files.\n * @param snapId - The Snap ID.\n * @param controllerMessenger - The controller messenger.\n * @returns The hooks for the simulation.\n */\nexport function getHooks(\n  options: SimulationOptions,\n  snapFiles: FetchedSnapFiles,\n  snapId: SnapId,\n  controllerMessenger: RootControllerMessenger,\n): MiddlewareHooks {\n  return {\n    getMnemonic: async () =>\n      Promise.resolve(mnemonicPhraseToBytes(options.secretRecoveryPhrase)),\n    getSnapFile: async (path: string, encoding: AuxiliaryFileEncoding) =>\n      await getSnapFile(snapFiles.auxiliaryFiles, path, encoding),\n    getIsLocked: () => false,\n    createInterface: async (...args) =>\n      controllerMessenger.call(\n        'SnapInterfaceController:createInterface',\n        snapId,\n        ...args,\n      ),\n    updateInterface: async (...args) =>\n      controllerMessenger.call(\n        'SnapInterfaceController:updateInterface',\n        snapId,\n        ...args,\n      ),\n    getInterfaceState: (...args) =>\n      controllerMessenger.call(\n        'SnapInterfaceController:getInterface',\n        snapId,\n        ...args,\n      ).state,\n  };\n}\n\n/**\n * Register mocked action handlers.\n *\n * @param controllerMessenger - The controller messenger.\n */\nexport function registerActions(controllerMessenger: RootControllerMessenger) {\n  controllerMessenger.registerActionHandler(\n    'PhishingController:maybeUpdateState',\n    async () => Promise.resolve(),\n  );\n\n  controllerMessenger.registerActionHandler(\n    'PhishingController:testOrigin',\n    () => ({ result: false, type: 'all' }),\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-TO46ICOZ.js → chunk-WMLSD6B5.js}

@@ -15,7 +15,7 @@ var _chunkLBC2OGSNjs = require('./chunk-LBC2OGSN.js');
 // src/internals/simulation/store/store.ts
 var _toolkit = require('@reduxjs/toolkit');
 var _reduxsaga = require('redux-saga'); var _reduxsaga2 = _interopRequireDefault(_reduxsaga);
-function createStore(password, { state, unencryptedState }) {
+function createStore({ state, unencryptedState }) {
   const sagaMiddleware = _reduxsaga2.default.call(void 0, );
   const store = _toolkit.configureStore.call(void 0, {
     reducer: {
@@ -29,10 +29,7 @@ function createStore(password, { state, unencryptedState }) {
   if (state) {
     store.dispatch(
       _chunkLBC2OGSNjs.setState.call(void 0, {
-        state: JSON.stringify({
-          password,
-          value: state
-        }),
+        state: JSON.stringify(state),
         encrypted: true
       })
     );
@@ -54,4 +51,4 @@ function createStore(password, { state, unencryptedState }) {
 
 
 exports.createStore = createStore;
-//# sourceMappingURL=chunk-TO46ICOZ.js.map
+//# sourceMappingURL=chunk-WMLSD6B5.js.map

package/dist/chunk-WMLSD6B5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/store/store.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,SAAS,sBAAsB;AAC/B,OAAO,0BAA0B;AAgB1B,SAAS,YAAY,EAAE,OAAO,iBAAiB,GAAsB;AAC1E,QAAM,iBAAiB,qBAAqB;AAC5C,QAAM,QAAQ,eAAe;AAAA,IAC3B,SAAS;AAAA,MACP,OAAO,WAAW;AAAA,MAClB,eAAe,mBAAmB;AAAA,MAClC,OAAO,WAAW;AAAA,MAClB,IAAI,QAAQ;AAAA,IACd;AAAA,IACA,YAAY,CAAC,yBACX,qBAAqB,EAAE,OAAO,MAAM,CAAC,EAAE,OAAO,cAAc;AAAA,EAChE,CAAC;AAGD,MAAI,OAAO;AACT,UAAM;AAAA,MACJ,SAAS;AAAA,QACP,OAAO,KAAK,UAAU,KAAK;AAAA,QAC3B,WAAW;AAAA,MACb,CAAC;AAAA,IACH;AAAA,EACF;AAEA,MAAI,kBAAkB;AACpB,UAAM;AAAA,MACJ,SAAS;AAAA,QACP,OAAO,KAAK,UAAU,gBAAgB;AAAA,QACtC,WAAW;AAAA,MACb,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA,SAAS,eAAe,IAAI,KAAK,cAAc;AAAA,EACjD;AACF","sourcesContent":["import { configureStore } from '@reduxjs/toolkit';\nimport createSagaMiddleware from 'redux-saga';\n\nimport type { SimulationOptions } from '../options';\nimport { mocksSlice } from './mocks';\nimport { notificationsSlice } from './notifications';\nimport { setState, stateSlice } from './state';\nimport { uiSlice } from './ui';\n\n/**\n * Create a Redux store.\n *\n * @param options - The simulation options.\n * @param options.state - The initial state for the Snap.\n * @param options.unencryptedState - The initial unencrypted state for the Snap.\n * @returns A Redux store with the default state.\n */\nexport function createStore({ state, unencryptedState }: SimulationOptions) {\n  const sagaMiddleware = createSagaMiddleware();\n  const store = configureStore({\n    reducer: {\n      mocks: mocksSlice.reducer,\n      notifications: notificationsSlice.reducer,\n      state: stateSlice.reducer,\n      ui: uiSlice.reducer,\n    },\n    middleware: (getDefaultMiddleware) =>\n      getDefaultMiddleware({ thunk: false }).concat(sagaMiddleware),\n  });\n\n  // Set initial state for the Snap.\n  if (state) {\n    store.dispatch(\n      setState({\n        state: JSON.stringify(state),\n        encrypted: true,\n      }),\n    );\n  }\n\n  if (unencryptedState) {\n    store.dispatch(\n      setState({\n        state: JSON.stringify(unencryptedState),\n        encrypted: false,\n      }),\n    );\n  }\n\n  return {\n    store,\n    runSaga: sagaMiddleware.run.bind(sagaMiddleware),\n  };\n}\n\nexport type Store = ReturnType<typeof createStore>['store'];\nexport type ApplicationState = ReturnType<Store['getState']>;\nexport type RunSagaFunction = ReturnType<typeof createStore>['runSaga'];\n"]}

package/dist/{chunk-4SC3HVI5.mjs → chunk-X5IPMTHO.mjs}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-B73P64TE.mjs";
 import {
   handleInstallSnap
-} from "./chunk-LHU3EHLI.mjs";
+} from "./chunk-VSUNWJMQ.mjs";
 import {
   startServer
 } from "./chunk-SLU4FNKX.mjs";
@@ -101,4 +101,4 @@ export {
   SnapsEnvironment,
   environment_default
 };
-//# sourceMappingURL=chunk-4SC3HVI5.mjs.map
+//# sourceMappingURL=chunk-X5IPMTHO.mjs.map

package/dist/chunk-Y4DKEF7Y.js

@@ -0,0 +1,223 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkPZDTZGSIjs = require('./chunk-PZDTZGSI.js');
+
+// src/internals/simulation/interface.ts
+
+
+
+
+
+
+var _snapssdk = require('@metamask/snaps-sdk');
+var _snapsutils = require('@metamask/snaps-utils');
+var _effects = require('redux-saga/effects');
+function getInterfaceResponse(runSaga, type, content, interfaceActions) {
+  switch (type) {
+    case _snapssdk.DialogType.Alert:
+      return {
+        ...interfaceActions,
+        type,
+        content,
+        ok: resolveWith(runSaga, null)
+      };
+    case _snapssdk.DialogType.Confirmation:
+      return {
+        ...interfaceActions,
+        type,
+        content,
+        ok: resolveWith(runSaga, true),
+        cancel: resolveWith(runSaga, false)
+      };
+    case _snapssdk.DialogType.Prompt:
+      return {
+        ...interfaceActions,
+        type,
+        content,
+        ok: resolveWithInput(runSaga),
+        cancel: resolveWith(runSaga, null)
+      };
+    default:
+      throw new Error(`Unknown or unsupported dialog type: "${String(type)}".`);
+  }
+}
+function resolveWith(runSaga, value) {
+  function* resolveWithSaga() {
+    yield _effects.put.call(void 0, _chunkPZDTZGSIjs.resolveInterface.call(void 0, value));
+  }
+  return async () => {
+    await runSaga(resolveWithSaga).toPromise();
+  };
+}
+function resolveWithInput(runSaga) {
+  function* resolveWithSaga(value) {
+    yield _effects.put.call(void 0, _chunkPZDTZGSIjs.resolveInterface.call(void 0, value));
+  }
+  return async (value = "") => {
+    await runSaga(resolveWithSaga, value).toPromise();
+  };
+}
+function* getStoredInterface(controllerMessenger, snapId) {
+  const currentInterface = yield _effects.select.call(void 0, _chunkPZDTZGSIjs.getCurrentInterface);
+  if (currentInterface) {
+    const { content: content2 } = controllerMessenger.call(
+      "SnapInterfaceController:getInterface",
+      snapId,
+      currentInterface.id
+    );
+    return { ...currentInterface, content: content2 };
+  }
+  const { payload } = yield _effects.take.call(void 0, _chunkPZDTZGSIjs.setInterface.type);
+  const { content } = controllerMessenger.call(
+    "SnapInterfaceController:getInterface",
+    snapId,
+    payload.id
+  );
+  return { ...payload, content };
+}
+function getElement(content, name) {
+  const { type } = content;
+  if ((type === _snapssdk.NodeType.Button || type === _snapssdk.NodeType.Input) && content.name === name) {
+    return { element: content };
+  }
+  if (_snapsutils.hasChildren.call(void 0, content)) {
+    for (const element of content.children) {
+      const result = getElement(element, name);
+      const form = type === _snapssdk.NodeType.Form ? content.name : result?.form;
+      if (result) {
+        return { element: result.element, form };
+      }
+    }
+  }
+  return void 0;
+}
+async function clickElement(controllerMessenger, id, content, snapId, name) {
+  const result = getElement(content, name);
+  _snapssdk.assert.call(void 0, 
+    result !== void 0 && result.element.type === _snapssdk.NodeType.Button,
+    "No button found in the interface."
+  );
+  if (result.form && result.element.buttonType === _snapssdk.ButtonType.Submit) {
+    const { state } = controllerMessenger.call(
+      "SnapInterfaceController:getInterface",
+      snapId,
+      id
+    );
+    await controllerMessenger.call(
+      "ExecutionService:handleRpcRequest",
+      snapId,
+      {
+        origin: "",
+        handler: _snapsutils.HandlerType.OnUserInput,
+        request: {
+          jsonrpc: "2.0",
+          method: " ",
+          params: {
+            event: {
+              type: _snapssdk.UserInputEventType.FormSubmitEvent,
+              name: result.form,
+              value: state[result.form]
+            },
+            id
+          }
+        }
+      }
+    );
+    return;
+  }
+  if (result.element.buttonType !== _snapssdk.ButtonType.Submit) {
+    await controllerMessenger.call(
+      "ExecutionService:handleRpcRequest",
+      snapId,
+      {
+        origin: "",
+        handler: _snapsutils.HandlerType.OnUserInput,
+        request: {
+          jsonrpc: "2.0",
+          method: " ",
+          params: {
+            event: {
+              type: _snapssdk.UserInputEventType.ButtonClickEvent,
+              name: result.element.name
+            },
+            id
+          }
+        }
+      }
+    );
+  }
+}
+function mergeValue(state, name, value, form) {
+  if (form) {
+    return {
+      ...state,
+      [form]: {
+        ...state[form],
+        [name]: value
+      }
+    };
+  }
+  return { ...state, [name]: value };
+}
+async function typeInField(controllerMessenger, id, content, snapId, name, value) {
+  const result = getElement(content, name);
+  _snapssdk.assert.call(void 0, 
+    result !== void 0 && result.element.type === _snapssdk.NodeType.Input,
+    "No input found in the interface."
+  );
+  const { state } = controllerMessenger.call(
+    "SnapInterfaceController:getInterface",
+    snapId,
+    id
+  );
+  const newState = mergeValue(state, name, value, result.form);
+  controllerMessenger.call(
+    "SnapInterfaceController:updateInterfaceState",
+    id,
+    newState
+  );
+  await controllerMessenger.call("ExecutionService:handleRpcRequest", snapId, {
+    origin: "",
+    handler: _snapsutils.HandlerType.OnUserInput,
+    request: {
+      jsonrpc: "2.0",
+      method: " ",
+      params: {
+        event: {
+          type: _snapssdk.UserInputEventType.InputChangeEvent,
+          name: result.element.name,
+          value
+        },
+        id
+      }
+    }
+  });
+}
+function* getInterface(runSaga, snapId, controllerMessenger) {
+  const { type, id, content } = yield _effects.call.call(void 0, 
+    getStoredInterface,
+    controllerMessenger,
+    snapId
+  );
+  const interfaceActions = {
+    clickElement: async (name) => {
+      await clickElement(controllerMessenger, id, content, snapId, name);
+    },
+    typeInField: async (name, value) => {
+      await typeInField(controllerMessenger, id, content, snapId, name, value);
+    }
+  };
+  return getInterfaceResponse(runSaga, type, content, interfaceActions);
+}
+
+
+
+
+
+
+
+
+exports.getInterfaceResponse = getInterfaceResponse; exports.getElement = getElement; exports.clickElement = clickElement; exports.mergeValue = mergeValue; exports.typeInField = typeInField; exports.getInterface = getInterface;
+//# sourceMappingURL=chunk-Y4DKEF7Y.js.map

package/dist/chunk-Y4DKEF7Y.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/interface.ts"],"names":["content"],"mappings":"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","sourcesContent":["import type {\n  Button,\n  Component,\n  FormState,\n  Input,\n  InterfaceState,\n  SnapId,\n} from '@metamask/snaps-sdk';\nimport {\n  ButtonType,\n  DialogType,\n  NodeType,\n  UserInputEventType,\n  assert,\n} from '@metamask/snaps-sdk';\nimport { HandlerType, hasChildren } from '@metamask/snaps-utils';\nimport type { PayloadAction } from '@reduxjs/toolkit';\nimport { type SagaIterator } from 'redux-saga';\nimport { call, put, select, take } from 'redux-saga/effects';\n\nimport type { SnapInterface, SnapInterfaceActions } from '../../types';\nimport type { RootControllerMessenger } from './controllers';\nimport type { Interface, RunSagaFunction } from './store';\nimport { getCurrentInterface, resolveInterface, setInterface } from './store';\n\n/**\n * Get a user interface object from a type and content object.\n *\n * @param runSaga - A function to run a saga outside the usual Redux flow.\n * @param type - The type of the interface.\n * @param content - The content to show in the interface.\n * @param interfaceActions - The actions to interact with the interface.\n * @returns The user interface object.\n */\nexport function getInterfaceResponse(\n  runSaga: RunSagaFunction,\n  type: DialogType,\n  content: Component,\n  interfaceActions: SnapInterfaceActions,\n): SnapInterface {\n  switch (type) {\n    case DialogType.Alert:\n      return {\n        ...interfaceActions,\n        type,\n        content,\n        ok: resolveWith(runSaga, null),\n      };\n\n    case DialogType.Confirmation:\n      return {\n        ...interfaceActions,\n        type,\n        content,\n\n        ok: resolveWith(runSaga, true),\n        cancel: resolveWith(runSaga, false),\n      };\n\n    case DialogType.Prompt:\n      return {\n        ...interfaceActions,\n        type,\n        content,\n\n        ok: resolveWithInput(runSaga),\n        cancel: resolveWith(runSaga, null),\n      };\n\n    default:\n      throw new Error(`Unknown or unsupported dialog type: \"${String(type)}\".`);\n  }\n}\n\n/**\n * Resolve the current user interface with the given value. This returns a\n * function that can be used to resolve the user interface.\n *\n * @param runSaga - A function to run a saga outside the usual Redux flow.\n * @param value - The value to resolve the user interface with.\n * @returns A function that can be used to resolve the user interface.\n */\nfunction resolveWith(runSaga: RunSagaFunction, value: unknown) {\n  /**\n   * Resolve the current user interface with the given value.\n   *\n   * @yields Puts the resolve user interface action.\n   */\n  function* resolveWithSaga(): SagaIterator {\n    yield put(resolveInterface(value));\n  }\n\n  return async () => {\n    await runSaga(resolveWithSaga).toPromise();\n  };\n}\n\n/**\n * Resolve the current user interface with the provided input. This returns a\n * function that can be used to resolve the user interface.\n *\n * @param runSaga - A function to run a saga outside the usual Redux flow.\n * @returns A function that can be used to resolve the user interface.\n */\nfunction resolveWithInput(runSaga: RunSagaFunction) {\n  /**\n   * Resolve the current user interface with the given value.\n   *\n   * @param value - The value to resolve the user interface with.\n   * @yields Puts the resolve user interface action.\n   */\n  function* resolveWithSaga(value: string): SagaIterator {\n    yield put(resolveInterface(value));\n  }\n\n  return async (value = '') => {\n    await runSaga(resolveWithSaga, value).toPromise();\n  };\n}\n\n/**\n * Get the stored user interface from the store.\n *\n * @param controllerMessenger - The controller messenger used to call actions.\n * @param snapId - The Snap ID.\n * @yields Takes the set interface action.\n * @returns The user interface object.\n */\nfunction* getStoredInterface(\n  controllerMessenger: RootControllerMessenger,\n  snapId: SnapId,\n): SagaIterator<Interface & { content: Component }> {\n  const currentInterface: Interface | null = yield select(getCurrentInterface);\n\n  if (currentInterface) {\n    const { content } = controllerMessenger.call(\n      'SnapInterfaceController:getInterface',\n      snapId,\n      currentInterface.id,\n    );\n\n    return { ...currentInterface, content };\n  }\n\n  const { payload }: PayloadAction<Interface> = yield take(setInterface.type);\n\n  const { content } = controllerMessenger.call(\n    'SnapInterfaceController:getInterface',\n    snapId,\n    payload.id,\n  );\n\n  return { ...payload, content };\n}\n\n/**\n * Get a Button or an Input from an interface.\n *\n * @param content - The interface content.\n * @param name - The element name.\n * @returns An object containing the element and the form name if it's contained in a form, otherwise undefined.\n */\nexport function getElement(\n  content: Component,\n  name: string,\n):\n  | {\n      element: Button | Input;\n      form?: string;\n    }\n  | undefined {\n  const { type } = content;\n\n  if (\n    (type === NodeType.Button || type === NodeType.Input) &&\n    content.name === name\n  ) {\n    return { element: content };\n  }\n\n  if (hasChildren(content)) {\n    for (const element of content.children) {\n      const result = getElement(element, name);\n      const form = type === NodeType.Form ? content.name : result?.form;\n\n      if (result) {\n        return { element: result.element, form };\n      }\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Click on an element of the Snap interface.\n *\n * @param controllerMessenger - The controller messenger used to call actions.\n * @param id - The interface ID.\n * @param content - The interface content.\n * @param snapId - The Snap ID.\n * @param name - The element name.\n */\nexport async function clickElement(\n  controllerMessenger: RootControllerMessenger,\n  id: string,\n  content: Component,\n  snapId: SnapId,\n  name: string,\n): Promise<void> {\n  const result = getElement(content, name);\n  assert(\n    result !== undefined && result.element.type === NodeType.Button,\n    'No button found in the interface.',\n  );\n\n  if (result.form && result.element.buttonType === ButtonType.Submit) {\n    const { state } = controllerMessenger.call(\n      'SnapInterfaceController:getInterface',\n      snapId,\n      id,\n    );\n\n    await controllerMessenger.call(\n      'ExecutionService:handleRpcRequest',\n      snapId,\n      {\n        origin: '',\n        handler: HandlerType.OnUserInput,\n        request: {\n          jsonrpc: '2.0',\n          method: ' ',\n          params: {\n            event: {\n              type: UserInputEventType.FormSubmitEvent,\n              name: result.form,\n              value: state[result.form],\n            },\n            id,\n          },\n        },\n      },\n    );\n\n    return;\n  }\n\n  if (result.element.buttonType !== ButtonType.Submit) {\n    await controllerMessenger.call(\n      'ExecutionService:handleRpcRequest',\n      snapId,\n      {\n        origin: '',\n        handler: HandlerType.OnUserInput,\n        request: {\n          jsonrpc: '2.0',\n          method: ' ',\n          params: {\n            event: {\n              type: UserInputEventType.ButtonClickEvent,\n              name: result.element.name,\n            },\n            id,\n          },\n        },\n      },\n    );\n  }\n}\n\n/**\n * Merge a value in the interface state.\n *\n * @param state - The actual interface state.\n * @param name - The component name that changed value.\n * @param value - The new value.\n * @param form - The form name if the element is in one.\n * @returns The state with the merged value.\n */\nexport function mergeValue(\n  state: InterfaceState,\n  name: string,\n  value: string | null,\n  form?: string,\n): InterfaceState {\n  if (form) {\n    return {\n      ...state,\n      [form]: {\n        ...(state[form] as FormState),\n        [name]: value,\n      },\n    };\n  }\n\n  return { ...state, [name]: value };\n}\n\n/**\n * Type a value in an interface element.\n *\n * @param controllerMessenger - The controller messenger used to call actions.\n * @param id - The interface ID.\n * @param content - The interface Components.\n * @param snapId - The Snap ID.\n * @param name - The element name.\n * @param value - The value to type in the element.\n */\nexport async function typeInField(\n  controllerMessenger: RootControllerMessenger,\n  id: string,\n  content: Component,\n  snapId: SnapId,\n  name: string,\n  value: string,\n) {\n  const result = getElement(content, name);\n\n  assert(\n    result !== undefined && result.element.type === NodeType.Input,\n    'No input found in the interface.',\n  );\n\n  const { state } = controllerMessenger.call(\n    'SnapInterfaceController:getInterface',\n    snapId,\n    id,\n  );\n\n  const newState = mergeValue(state, name, value, result.form);\n\n  controllerMessenger.call(\n    'SnapInterfaceController:updateInterfaceState',\n    id,\n    newState,\n  );\n\n  await controllerMessenger.call('ExecutionService:handleRpcRequest', snapId, {\n    origin: '',\n    handler: HandlerType.OnUserInput,\n    request: {\n      jsonrpc: '2.0',\n      method: ' ',\n      params: {\n        event: {\n          type: UserInputEventType.InputChangeEvent,\n          name: result.element.name,\n          value,\n        },\n        id,\n      },\n    },\n  });\n}\n\n/**\n * Get a user interface object from a Snap.\n *\n * @param runSaga - A function to run a saga outside the usual Redux flow.\n * @param snapId - The Snap ID.\n * @param controllerMessenger - The controller messenger used to call actions.\n * @yields Takes the set interface action.\n * @returns The user interface object.\n */\nexport function* getInterface(\n  runSaga: RunSagaFunction,\n  snapId: SnapId,\n  controllerMessenger: RootControllerMessenger,\n): SagaIterator<SnapInterface> {\n  const { type, id, content } = yield call(\n    getStoredInterface,\n    controllerMessenger,\n    snapId,\n  );\n\n  const interfaceActions = {\n    clickElement: async (name: string) => {\n      await clickElement(controllerMessenger, id, content, snapId, name);\n    },\n    typeInField: async (name: string, value: string) => {\n      await typeInField(controllerMessenger, id, content, snapId, name, value);\n    },\n  };\n\n  return getInterfaceResponse(runSaga, type, content, interfaceActions);\n}\n"]}