@metamask/snaps-jest 5.0.0 → 6.0.1

package/dist/chunk-HNH5UAKZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/request.ts"],"names":[],"mappings":";;;;;;;;;AAGA,SAAS,mBAAmB;AAC5B,SAAS,aAAa,aAAa,qBAAqB;AACxD,SAAS,cAAc;AAyChB,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,CAAC,WAAW;AAChB,UAAM,gBAAgB,iBAAiB,MAAM,SAAS,CAAC;AACvD,UAAM,SAAS,mBAAmB,CAAC;AAEnC,UAAM,UAAU,qBAAqB,QAAQ,QAAQ,mBAAmB;AAExE,WAAO;AAAA,MACL,IAAI,OAAO,EAAE;AAAA,MACb,UAAU;AAAA,QACR,QAAQ,YAAY,MAAM;AAAA,MAC5B;AAAA,MACA;AAAA,MACA;AAAA,IACF;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;AAUO,SAAS,qBACd,QACA,QACA,qBACuB;AACvB,MAAI,cAAc,MAAM,KAAK,YAAY,QAAQ,IAAI,GAAG;AACtD,WAAO,oBAAoB;AAAA,MACzB;AAAA,MACA;AAAA,MACA,OAAO;AAAA,IACT,EAAE;AAAA,EACJ;AAEA,MAAI,cAAc,MAAM,KAAK,YAAY,QAAQ,SAAS,GAAG;AAC3D,WAAO,OAAO;AAAA,EAChB;AAEA,SAAO;AACT","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 { RequestOptions, SnapRequest } from '../types';\nimport {\n  clearNotifications,\n  getInterface,\n  getNotifications,\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((result) => {\n      const notifications = getNotifications(store.getState());\n      store.dispatch(clearNotifications());\n\n      const content = getContentFromResult(result, snapId, controllerMessenger);\n\n      return {\n        id: String(id),\n        response: {\n          result: getSafeJson(result),\n        },\n        notifications,\n        content,\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 response content either from the SnapInterfaceController or the response object if there is one.\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 function getContentFromResult(\n  result: unknown,\n  snapId: SnapId,\n  controllerMessenger: RootControllerMessenger,\n): Component | undefined {\n  if (isPlainObject(result) && hasProperty(result, 'id')) {\n    return controllerMessenger.call(\n      'SnapInterfaceController:getInterface',\n      snapId,\n      result.id as string,\n    ).content;\n  }\n\n  if (isPlainObject(result) && hasProperty(result, 'content')) {\n    return result.content as Component;\n  }\n\n  return undefined;\n}\n"]}

package/dist/chunk-HROOL3VI.js

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

package/dist/chunk-HROOL3VI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/dist/chunk-IH7UNS5A.mjs

@@ -0,0 +1,36 @@
+import {
+  DEFAULT_LOCALE,
+  DEFAULT_SRP
+} from "./chunk-6KXCBUNZ.mjs";
+
+// src/internals/simulation/options.ts
+import { JsonStruct } from "@metamask/utils";
+import {
+  create,
+  defaulted,
+  nullable,
+  object,
+  optional,
+  record,
+  string
+} from "superstruct";
+var SimulationOptionsStruct = object({
+  secretRecoveryPhrase: defaulted(optional(string()), DEFAULT_SRP),
+  locale: defaulted(optional(string()), DEFAULT_LOCALE),
+  state: defaulted(optional(nullable(record(string(), JsonStruct))), null),
+  unencryptedState: defaulted(
+    optional(nullable(record(string(), JsonStruct))),
+    null
+  )
+});
+function getOptions(options) {
+  return create(
+    options,
+    SimulationOptionsStruct
+  );
+}
+
+export {
+  getOptions
+};
+//# sourceMappingURL=chunk-IH7UNS5A.mjs.map

package/dist/chunk-IH7UNS5A.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/options.ts"],"sourcesContent":["import { JsonStruct } from '@metamask/utils';\nimport type { Infer } from 'superstruct';\nimport {\n  create,\n  defaulted,\n  nullable,\n  object,\n  optional,\n  record,\n  string,\n} from 'superstruct';\n\nimport { DEFAULT_LOCALE, DEFAULT_SRP } from './constants';\n\nconst SimulationOptionsStruct = object({\n  secretRecoveryPhrase: defaulted(optional(string()), DEFAULT_SRP),\n  locale: defaulted(optional(string()), DEFAULT_LOCALE),\n  state: defaulted(optional(nullable(record(string(), JsonStruct))), null),\n  unencryptedState: defaulted(\n    optional(nullable(record(string(), JsonStruct))),\n    null,\n  ),\n});\n\n/**\n * Options for the simulation.\n *\n * @property secretRecoveryPhrase - The secret recovery phrase to use. This is\n * used to derive addresses and private keys. Defaults to a test recovery\n * phrase.\n * @property locale - The locale to use. Defaults to `en`.\n * @property state - The initial state of the Snap, if any. Defaults to `null`.\n */\nexport type SimulationUserOptions = Infer<typeof SimulationOptionsStruct>;\n\n/**\n * Options for the simulation, with defaults filled in.\n *\n * See {@link SimulationUserOptions} for documentation.\n */\nexport type SimulationOptions = Required<SimulationUserOptions>;\n\n/**\n * Get the options for the simulation.\n *\n * @param options - The user options. Any options not specified will be filled\n * in with default values.\n * @returns The simulation options.\n */\nexport function getOptions(options: SimulationUserOptions): SimulationOptions {\n  return create(\n    options,\n    SimulationOptionsStruct,\n  ) as Required<SimulationUserOptions>;\n}\n"],"mappings":";;;;;;AAAA,SAAS,kBAAkB;AAE3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAIP,IAAM,0BAA0B,OAAO;AAAA,EACrC,sBAAsB,UAAU,SAAS,OAAO,CAAC,GAAG,WAAW;AAAA,EAC/D,QAAQ,UAAU,SAAS,OAAO,CAAC,GAAG,cAAc;AAAA,EACpD,OAAO,UAAU,SAAS,SAAS,OAAO,OAAO,GAAG,UAAU,CAAC,CAAC,GAAG,IAAI;AAAA,EACvE,kBAAkB;AAAA,IAChB,SAAS,SAAS,OAAO,OAAO,GAAG,UAAU,CAAC,CAAC;AAAA,IAC/C;AAAA,EACF;AACF,CAAC;AA2BM,SAAS,WAAW,SAAmD;AAC5E,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-ISWZ7XZ5.js

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkLBC2OGSNjs = require('./chunk-LBC2OGSN.js');
+
+// src/internals/simulation/methods/hooks/state.ts
+var _effects = require('redux-saga/effects');
+function* getSnapStateImplementation(_snapId, encrypted = true) {
+  return yield _effects.select.call(void 0, _chunkLBC2OGSNjs.getState.call(void 0, encrypted));
+}
+function getGetSnapStateMethodImplementation(runSaga) {
+  return (...args) => {
+    return runSaga(getSnapStateImplementation, ...args).result();
+  };
+}
+function* updateSnapStateImplementation(_snapId, newState, encrypted = true) {
+  yield _effects.put.call(void 0, _chunkLBC2OGSNjs.setState.call(void 0, { state: newState, encrypted }));
+}
+function getUpdateSnapStateMethodImplementation(runSaga) {
+  return (...args) => {
+    runSaga(updateSnapStateImplementation, ...args).result();
+  };
+}
+function* clearSnapStateImplementation(_snapId, encrypted = true) {
+  yield _effects.put.call(void 0, _chunkLBC2OGSNjs.clearState.call(void 0, { encrypted }));
+}
+function getClearSnapStateMethodImplementation(runSaga) {
+  return async (...args) => {
+    runSaga(clearSnapStateImplementation, ...args).result();
+  };
+}
+
+
+
+
+
+exports.getGetSnapStateMethodImplementation = getGetSnapStateMethodImplementation; exports.getUpdateSnapStateMethodImplementation = getUpdateSnapStateMethodImplementation; exports.getClearSnapStateMethodImplementation = getClearSnapStateMethodImplementation;
+//# sourceMappingURL=chunk-ISWZ7XZ5.js.map

package/dist/chunk-ISWZ7XZ5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/methods/hooks/state.ts"],"names":[],"mappings":";;;;;;;AACA,SAAS,KAAK,cAAc;AAe5B,UAAU,2BACR,SACA,YAAY,MACU;AACtB,SAAO,MAAM,OAAO,SAAS,SAAS,CAAC;AACzC;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;AACpB,QAAM,IAAI,SAAS,EAAE,OAAO,UAAU,UAAU,CAAC,CAAC;AACpD;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 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  return yield select(getState(encrypted));\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: string,\n  encrypted = true,\n): SagaIterator<void> {\n  yield put(setState({ state: 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-IXKO6X55.mjs

@@ -0,0 +1,15 @@
+// src/internals/simulation/middleware/internal-methods/provider-state.ts
+async function getProviderStateHandler(_request, response, _next, end) {
+  response.result = {
+    isUnlocked: true,
+    chainId: "0x01",
+    networkVersion: "0x01",
+    accounts: []
+  };
+  return end();
+}
+
+export {
+  getProviderStateHandler
+};
+//# sourceMappingURL=chunk-IXKO6X55.mjs.map

package/dist/chunk-IXKO6X55.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/middleware/internal-methods/provider-state.ts"],"sourcesContent":["import type {\n  JsonRpcEngineEndCallback,\n  JsonRpcEngineNextCallback,\n} from '@metamask/json-rpc-engine';\nimport type {\n  Json,\n  JsonRpcRequest,\n  PendingJsonRpcResponse,\n} from '@metamask/utils';\n\n/**\n * A mock handler for metamask_getProviderState that always returns a specific\n * hardcoded result.\n *\n * @param _request - Incoming JSON-RPC request. Ignored for this specific\n * handler.\n * @param response - The outgoing JSON-RPC response, modified to return the\n * result.\n * @param _next - The `json-rpc-engine` middleware next handler.\n * @param end - The `json-rpc-engine` middleware end handler.\n */\nexport async function getProviderStateHandler(\n  _request: JsonRpcRequest,\n  response: PendingJsonRpcResponse<Json>,\n  _next: JsonRpcEngineNextCallback,\n  end: JsonRpcEngineEndCallback,\n) {\n  // For now this will return a mocked result, this should probably match\n  // whatever network the simulation is using.\n  response.result = {\n    isUnlocked: true,\n    chainId: '0x01',\n    networkVersion: '0x01',\n    accounts: [],\n  };\n\n  return end();\n}\n"],"mappings":";AAqBA,eAAsB,wBACpB,UACA,UACA,OACA,KACA;AAGA,WAAS,SAAS;AAAA,IAChB,YAAY;AAAA,IACZ,SAAS;AAAA,IACT,gBAAgB;AAAA,IAChB,UAAU,CAAC;AAAA,EACb;AAEA,SAAO,IAAI;AACb;","names":[]}

package/dist/chunk-J4ZPUCLX.mjs

@@ -0,0 +1,8 @@
+// src/internals/logger.ts
+import { createProjectLogger } from "@metamask/utils";
+var rootLogger = createProjectLogger("snaps-jest");
+
+export {
+  rootLogger
+};
+//# sourceMappingURL=chunk-J4ZPUCLX.mjs.map

package/dist/chunk-J4ZPUCLX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/logger.ts"],"sourcesContent":["import { createProjectLogger } from '@metamask/utils';\n\nexport const rootLogger = createProjectLogger('snaps-jest');\n"],"mappings":";AAAA,SAAS,2BAA2B;AAE7B,IAAM,aAAa,oBAAoB,YAAY;","names":[]}

package/dist/chunk-JMDSN227.mjs

@@ -0,0 +1,25 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+export {
+  __privateGet,
+  __privateAdd,
+  __privateSet
+};
+//# sourceMappingURL=chunk-JMDSN227.mjs.map

package/dist/chunk-JMDSN227.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-JUNUGLG4.js

@@ -0,0 +1,104 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkT2PHS5FYjs = require('./chunk-T2PHS5FY.js');
+
+
+var _chunkSQJOQ7AFjs = require('./chunk-SQJOQ7AF.js');
+
+
+var _chunkN6MAO223js = require('./chunk-N6MAO223.js');
+
+
+var _chunkTZB4LBT7js = require('./chunk-TZB4LBT7.js');
+
+
+
+
+var _chunkPHUTP7NBjs = require('./chunk-PHUTP7NB.js');
+
+// src/environment.ts
+var _utils = require('@metamask/utils');
+var _jestenvironmentnode = require('jest-environment-node'); var _jestenvironmentnode2 = _interopRequireDefault(_jestenvironmentnode);
+var log = _utils.createModuleLogger.call(void 0, _chunkTZB4LBT7js.rootLogger, "environment");
+var _options, _server, _instance;
+var SnapsEnvironment = class extends _jestenvironmentnode2.default {
+  /**
+   * Constructor.
+   *
+   * @param options - The environment options.
+   * @param context - The environment context.
+   */
+  constructor(options, context) {
+    super(options, context);
+    _chunkPHUTP7NBjs.__privateAdd.call(void 0, this, _options, void 0);
+    _chunkPHUTP7NBjs.__privateAdd.call(void 0, this, _server, void 0);
+    _chunkPHUTP7NBjs.__privateAdd.call(void 0, this, _instance, void 0);
+    _chunkPHUTP7NBjs.__privateSet.call(void 0, this, _options, _chunkT2PHS5FYjs.getOptions.call(void 0, options.projectConfig.testEnvironmentOptions));
+  }
+  /**
+   * Set up the environment. This starts the built-in HTTP server, and creates a
+   * new browser instance.
+   */
+  async setup() {
+    await super.setup();
+    if (_chunkPHUTP7NBjs.__privateGet.call(void 0, this, _options).server.enabled) {
+      log("Starting server.");
+      _chunkPHUTP7NBjs.__privateSet.call(void 0, this, _server, await _chunkN6MAO223js.startServer.call(void 0, _chunkPHUTP7NBjs.__privateGet.call(void 0, this, _options).server));
+    }
+    this.global.snapsEnvironment = this;
+  }
+  /**
+   * Tear down the environment. This closes the browser, and stops the built-in
+   * HTTP server.
+   */
+  async teardown() {
+    await _chunkPHUTP7NBjs.__privateGet.call(void 0, this, _instance)?.executionService.terminateAllSnaps();
+    _chunkPHUTP7NBjs.__privateGet.call(void 0, this, _server)?.close();
+    await super.teardown();
+  }
+  /**
+   * Install a Snap in the environment. This will terminate any previously
+   * installed Snaps, and run the Snap code in a new execution service.
+   *
+   * @param snapId - The ID of the Snap to install.
+   * @param options - The options to use when installing the Snap.
+   * @param options.executionService - The execution service to use.
+   * @param options.executionServiceOptions - The options to use when creating the
+   * execution service, if any. This should only include options specific to the
+   * provided execution service.
+   * @param options.options - The simulation options.
+   * @template Service - The type of the execution service.
+   * @returns The installed Snap.
+   */
+  async installSnap(snapId = this.snapId, options = {}) {
+    await _chunkPHUTP7NBjs.__privateGet.call(void 0, this, _instance)?.executionService.terminateAllSnaps();
+    _chunkPHUTP7NBjs.__privateSet.call(void 0, this, _instance, await _chunkSQJOQ7AFjs.handleInstallSnap.call(void 0, snapId, options));
+    return _chunkPHUTP7NBjs.__privateGet.call(void 0, this, _instance);
+  }
+  /**
+   * Get the snap ID for the current environment, which is used if no snap ID is
+   * passed to {@link installSnap}. This assumes that the built-in server is
+   * running.
+   *
+   * @returns The snap ID.
+   * @throws If the server is not running.
+   */
+  get snapId() {
+    _utils.assert.call(void 0, 
+      _chunkPHUTP7NBjs.__privateGet.call(void 0, this, _server),
+      "You must specify a snap ID, because the built-in server is not running."
+    );
+    const { port } = _chunkPHUTP7NBjs.__privateGet.call(void 0, this, _server).address();
+    return `local:http://localhost:${port}`;
+  }
+};
+_options = new WeakMap();
+_server = new WeakMap();
+_instance = new WeakMap();
+var environment_default = SnapsEnvironment;
+
+
+
+
+exports.SnapsEnvironment = SnapsEnvironment; exports.environment_default = environment_default;
+//# sourceMappingURL=chunk-JUNUGLG4.js.map

package/dist/chunk-JUNUGLG4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/environment.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAMA,SAAS,QAAQ,0BAA0B;AAE3C,OAAO,qBAAqB;AAc5B,IAAM,MAAM,mBAAmB,YAAY,aAAa;AAtBxD;AAwBO,IAAM,mBAAN,cAA+B,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAapD,YAAY,SAAgC,SAA6B;AACvE,UAAM,SAAS,OAAO;AAbxB;AAEA;AAEA;AAUE,uBAAK,UAAW,WAAW,QAAQ,cAAc,sBAAsB;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,QAAQ;AACZ,UAAM,MAAM,MAAM;AAElB,QAAI,mBAAK,UAAS,OAAO,SAAS;AAChC,UAAI,kBAAkB;AACtB,yBAAK,SAAU,MAAM,YAAY,mBAAK,UAAS,MAAM;AAAA,IACvD;AAEA,SAAK,OAAO,mBAAmB;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,WAAW;AACf,UAAM,mBAAK,YAAW,iBAAiB,kBAAkB;AACzD,uBAAK,UAAS,MAAM;AACpB,UAAM,MAAM,SAAS;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBA,MAAM,YAKJ,SAAiB,KAAK,QACtB,UAAgD,CAAC,GACjD;AACA,UAAM,mBAAK,YAAW,iBAAiB,kBAAkB;AACzD,uBAAK,WAAY,MAAM,kBAAkB,QAAkB,OAAO;AAClE,WAAO,mBAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,IAAI,SAAS;AACX;AAAA,MACE,mBAAK;AAAA,MACL;AAAA,IACF;AAEA,UAAM,EAAE,KAAK,IAAI,mBAAK,SAAQ,QAAQ;AACtC,WAAO,0BAA0B,IAAI;AAAA,EACvC;AACF;AAtFE;AAEA;AAEA;AAoFF,IAAO,sBAAQ","sourcesContent":["import type {\n  EnvironmentContext,\n  JestEnvironmentConfig,\n} from '@jest/environment';\nimport type { AbstractExecutionService } from '@metamask/snaps-controllers';\nimport type { SnapId } from '@metamask/snaps-sdk';\nimport { assert, createModuleLogger } from '@metamask/utils';\nimport type { Server } from 'http';\nimport NodeEnvironment from 'jest-environment-node';\nimport type { AddressInfo } from 'net';\n\nimport type { InstalledSnap, InstallSnapOptions } from './internals';\nimport { handleInstallSnap, rootLogger, startServer } from './internals';\nimport type { SnapsEnvironmentOptions } from './options';\nimport { getOptions } from './options';\n\n/* eslint-disable */\ndeclare global {\n  const snapsEnvironment: SnapsEnvironment;\n}\n/* eslint-enable */\n\nconst log = createModuleLogger(rootLogger, 'environment');\n\nexport class SnapsEnvironment extends NodeEnvironment {\n  #options: SnapsEnvironmentOptions;\n\n  #server: Server | undefined;\n\n  #instance: InstalledSnap | undefined;\n\n  /**\n   * Constructor.\n   *\n   * @param options - The environment options.\n   * @param context - The environment context.\n   */\n  constructor(options: JestEnvironmentConfig, context: EnvironmentContext) {\n    super(options, context);\n    this.#options = getOptions(options.projectConfig.testEnvironmentOptions);\n  }\n\n  /**\n   * Set up the environment. This starts the built-in HTTP server, and creates a\n   * new browser instance.\n   */\n  async setup() {\n    await super.setup();\n\n    if (this.#options.server.enabled) {\n      log('Starting server.');\n      this.#server = await startServer(this.#options.server);\n    }\n\n    this.global.snapsEnvironment = this;\n  }\n\n  /**\n   * Tear down the environment. This closes the browser, and stops the built-in\n   * HTTP server.\n   */\n  async teardown() {\n    await this.#instance?.executionService.terminateAllSnaps();\n    this.#server?.close();\n    await super.teardown();\n  }\n\n  /**\n   * Install a Snap in the environment. This will terminate any previously\n   * installed Snaps, and run the Snap code in a new 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   * @returns The installed Snap.\n   */\n  async installSnap<\n    Service extends new (...args: any[]) => InstanceType<\n      typeof AbstractExecutionService\n    >,\n  >(\n    snapId: string = this.snapId,\n    options: Partial<InstallSnapOptions<Service>> = {},\n  ) {\n    await this.#instance?.executionService.terminateAllSnaps();\n    this.#instance = await handleInstallSnap(snapId as SnapId, options);\n    return this.#instance;\n  }\n\n  /**\n   * Get the snap ID for the current environment, which is used if no snap ID is\n   * passed to {@link installSnap}. This assumes that the built-in server is\n   * running.\n   *\n   * @returns The snap ID.\n   * @throws If the server is not running.\n   */\n  get snapId() {\n    assert(\n      this.#server,\n      'You must specify a snap ID, because the built-in server is not running.',\n    );\n\n    const { port } = this.#server.address() as AddressInfo;\n    return `local:http://localhost:${port}`;\n  }\n}\n\nexport default SnapsEnvironment;\n"]}

package/dist/chunk-KIQOUUEZ.mjs

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

package/dist/chunk-KIQOUUEZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-KNJNL723.mjs

@@ -0,0 +1,39 @@
+import {
+  createInternalMethodsMiddleware
+} from "./chunk-Q2OQXAUM.mjs";
+import {
+  createMockMiddleware
+} from "./chunk-FP4H3ADT.mjs";
+import {
+  DEFAULT_JSON_RPC_ENDPOINT
+} from "./chunk-6KXCBUNZ.mjs";
+
+// src/internals/simulation/middleware/engine.ts
+import { createFetchMiddleware } from "@metamask/eth-json-rpc-middleware";
+import { JsonRpcEngine } from "@metamask/json-rpc-engine";
+import { createSnapsMethodMiddleware } from "@metamask/snaps-rpc-methods";
+function createJsonRpcEngine({
+  store,
+  hooks,
+  permissionMiddleware,
+  endpoint = DEFAULT_JSON_RPC_ENDPOINT
+}) {
+  const engine = new JsonRpcEngine();
+  engine.push(createMockMiddleware(store));
+  engine.push(createInternalMethodsMiddleware(hooks));
+  engine.push(createSnapsMethodMiddleware(true, hooks));
+  engine.push(permissionMiddleware);
+  engine.push(
+    createFetchMiddleware({
+      btoa: globalThis.btoa,
+      fetch: globalThis.fetch,
+      rpcUrl: endpoint
+    })
+  );
+  return engine;
+}
+
+export {
+  createJsonRpcEngine
+};
+//# sourceMappingURL=chunk-KNJNL723.mjs.map

package/dist/chunk-KNJNL723.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/middleware/engine.ts"],"sourcesContent":["import { createFetchMiddleware } from '@metamask/eth-json-rpc-middleware';\nimport type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';\nimport { JsonRpcEngine } from '@metamask/json-rpc-engine';\nimport type { RestrictedMethodParameters } from '@metamask/permission-controller';\nimport { createSnapsMethodMiddleware } from '@metamask/snaps-rpc-methods';\nimport type { Json } from '@metamask/utils';\n\nimport { DEFAULT_JSON_RPC_ENDPOINT } from '../constants';\nimport type { MiddlewareHooks } from '../simulation';\nimport type { Store } from '../store';\nimport { createInternalMethodsMiddleware } from './internal-methods';\nimport { createMockMiddleware } from './mock';\n\nexport type CreateJsonRpcEngineOptions = {\n  store: Store;\n  hooks: MiddlewareHooks;\n  permissionMiddleware: JsonRpcMiddleware<RestrictedMethodParameters, Json>;\n  endpoint?: string;\n};\n\n/**\n * Create a JSON-RPC engine for use in a simulated environment. This engine\n * should be used to handle all JSON-RPC requests. It is set up to handle\n * requests that would normally be handled internally by the MetaMask client, as\n * well as Snap-specific requests.\n *\n * @param options - The options to use when creating the engine.\n * @param options.store - The Redux store to use.\n * @param options.hooks - Any hooks used by the middleware handlers.\n * @param options.permissionMiddleware - The permission middleware to use.\n * @param options.endpoint - The JSON-RPC endpoint to use for Ethereum requests.\n * @returns A JSON-RPC engine.\n */\nexport function createJsonRpcEngine({\n  store,\n  hooks,\n  permissionMiddleware,\n  endpoint = DEFAULT_JSON_RPC_ENDPOINT,\n}: CreateJsonRpcEngineOptions) {\n  const engine = new JsonRpcEngine();\n  engine.push(createMockMiddleware(store));\n  engine.push(createInternalMethodsMiddleware(hooks));\n  engine.push(createSnapsMethodMiddleware(true, hooks));\n  engine.push(permissionMiddleware);\n  engine.push(\n    createFetchMiddleware({\n      btoa: globalThis.btoa,\n      fetch: globalThis.fetch,\n      rpcUrl: endpoint,\n    }),\n  );\n\n  return engine;\n}\n"],"mappings":";;;;;;;;;;;AAAA,SAAS,6BAA6B;AAEtC,SAAS,qBAAqB;AAE9B,SAAS,mCAAmC;AA6BrC,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AAAA,EACA,WAAW;AACb,GAA+B;AAC7B,QAAM,SAAS,IAAI,cAAc;AACjC,SAAO,KAAK,qBAAqB,KAAK,CAAC;AACvC,SAAO,KAAK,gCAAgC,KAAK,CAAC;AAClD,SAAO,KAAK,4BAA4B,MAAM,KAAK,CAAC;AACpD,SAAO,KAAK,oBAAoB;AAChC,SAAO;AAAA,IACL,sBAAsB;AAAA,MACpB,MAAM,WAAW;AAAA,MACjB,OAAO,WAAW;AAAA,MAClB,QAAQ;AAAA,IACV,CAAC;AAAA,EACH;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-KSIBNOB2.mjs

@@ -0,0 +1,13 @@
+// src/internals/simulation/methods/hooks/get-locale.ts
+function getGetLocaleMethodImplementation({
+  locale
+}) {
+  return async () => {
+    return locale;
+  };
+}
+
+export {
+  getGetLocaleMethodImplementation
+};
+//# sourceMappingURL=chunk-KSIBNOB2.mjs.map

package/dist/chunk-KSIBNOB2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/methods/hooks/get-locale.ts"],"sourcesContent":["import type { SimulationOptions } from '../../options';\n\n/**\n * Get the implementation of the `getLocale` hook.\n *\n * @param options - The simulation options.\n * @param options.locale - The locale to use.\n * @returns The implementation of the `getLocale` hook.\n */\nexport function getGetLocaleMethodImplementation({\n  locale,\n}: SimulationOptions) {\n  return async () => {\n    return locale;\n  };\n}\n"],"mappings":";AASO,SAAS,iCAAiC;AAAA,EAC/C;AACF,GAAsB;AACpB,SAAO,YAAY;AACjB,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/chunk-LACTK6EO.js

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/internals/simulation/store/mocks.ts
+var _toolkit = require('@reduxjs/toolkit');
+var INITIAL_STATE = {
+  jsonRpc: {}
+};
+var mocksSlice = _toolkit.createSlice.call(void 0, {
+  name: "mocks",
+  initialState: INITIAL_STATE,
+  reducers: {
+    addJsonRpcMock: (state, action) => {
+      state.jsonRpc[action.payload.method] = action.payload.result;
+    },
+    removeJsonRpcMock: (state, action) => {
+      delete state.jsonRpc[action.payload];
+    }
+  }
+});
+var { addJsonRpcMock, removeJsonRpcMock } = mocksSlice.actions;
+var getJsonRpcMocks = (state) => state.mocks.jsonRpc;
+var getJsonRpcMock = _toolkit.createSelector.call(void 0, 
+  getJsonRpcMocks,
+  (_, method) => method,
+  (jsonRpcMocks, method) => jsonRpcMocks[method]
+);
+
+
+
+
+
+
+
+exports.mocksSlice = mocksSlice; exports.addJsonRpcMock = addJsonRpcMock; exports.removeJsonRpcMock = removeJsonRpcMock; exports.getJsonRpcMocks = getJsonRpcMocks; exports.getJsonRpcMock = getJsonRpcMock;
+//# sourceMappingURL=chunk-LACTK6EO.js.map

package/dist/chunk-LACTK6EO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/store/mocks.ts"],"names":[],"mappings":";AAEA,SAAS,gBAAgB,mBAAmB;AAgB5C,IAAM,gBAA4B;AAAA,EAChC,SAAS,CAAC;AACZ;AAEO,IAAM,aAAa,YAAY;AAAA,EACpC,MAAM;AAAA,EACN,cAAc;AAAA,EACd,UAAU;AAAA,IACR,gBAAgB,CAAC,OAAO,WAAuC;AAG7D,YAAM,QAAQ,OAAO,QAAQ,MAAM,IAAI,OAAO,QAAQ;AAAA,IACxD;AAAA,IACA,mBAAmB,CAAC,OAAO,WAAkC;AAC3D,aAAO,MAAM,QAAQ,OAAO,OAAO;AAAA,IACrC;AAAA,EACF;AACF,CAAC;AAEM,IAAM,EAAE,gBAAgB,kBAAkB,IAAI,WAAW;AAQzD,IAAM,kBAAkB,CAAC,UAA4B,MAAM,MAAM;AAKjE,IAAM,iBAAiB;AAAA,EAC5B;AAAA,EACA,CAAC,GAAY,WAAmB;AAAA,EAChC,CAAC,cAAc,WAAW,aAAa,MAAM;AAC/C","sourcesContent":["import type { Json } from '@metamask/utils';\nimport type { PayloadAction } from '@reduxjs/toolkit';\nimport { createSelector, createSlice } from '@reduxjs/toolkit';\n\nimport type { ApplicationState } from './store';\n\nexport type JsonRpcMock = {\n  method: string;\n  result: Json;\n};\n\nexport type MocksState = {\n  jsonRpc: Record<string, Json>;\n};\n\n/**\n * The initial notifications state.\n */\nconst INITIAL_STATE: MocksState = {\n  jsonRpc: {},\n};\n\nexport const mocksSlice = createSlice({\n  name: 'mocks',\n  initialState: INITIAL_STATE,\n  reducers: {\n    addJsonRpcMock: (state, action: PayloadAction<JsonRpcMock>) => {\n      // @ts-expect-error - TS2589: Type instantiation is excessively deep and\n      // possibly infinite.\n      state.jsonRpc[action.payload.method] = action.payload.result;\n    },\n    removeJsonRpcMock: (state, action: PayloadAction<string>) => {\n      delete state.jsonRpc[action.payload];\n    },\n  },\n});\n\nexport const { addJsonRpcMock, removeJsonRpcMock } = mocksSlice.actions;\n\n/**\n * Get the JSON-RPC mocks from the state.\n *\n * @param state - The application state.\n * @returns The JSON-RPC mocks.\n */\nexport const getJsonRpcMocks = (state: ApplicationState) => state.mocks.jsonRpc;\n\n/**\n * Get the JSON-RPC mock for a given method from the state.\n */\nexport const getJsonRpcMock = createSelector(\n  getJsonRpcMocks,\n  (_: unknown, method: string) => method,\n  (jsonRpcMocks, method) => jsonRpcMocks[method],\n);\n"]}

package/dist/chunk-LB4R3BUA.mjs

@@ -0,0 +1,36 @@
+// src/internals/simulation/store/notifications.ts
+import { createSelector, createSlice } from "@reduxjs/toolkit";
+var INITIAL_STATE = {
+  notifications: []
+};
+var notificationsSlice = createSlice({
+  name: "notifications",
+  initialState: INITIAL_STATE,
+  reducers: {
+    addNotification: (state, action) => {
+      state.notifications.push(action.payload);
+    },
+    removeNotification: (state, action) => {
+      state.notifications = state.notifications.filter(
+        (notification) => notification.id !== action.payload
+      );
+    },
+    clearNotifications: (state) => {
+      state.notifications = [];
+    }
+  }
+});
+var { addNotification, removeNotification, clearNotifications } = notificationsSlice.actions;
+var getNotifications = createSelector(
+  (state) => state.notifications,
+  ({ notifications }) => notifications
+);
+
+export {
+  notificationsSlice,
+  addNotification,
+  removeNotification,
+  clearNotifications,
+  getNotifications
+};
+//# sourceMappingURL=chunk-LB4R3BUA.mjs.map

package/dist/chunk-LB4R3BUA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/store/notifications.ts"],"sourcesContent":["import type { NotificationType } from '@metamask/snaps-sdk';\nimport type { PayloadAction } from '@reduxjs/toolkit';\nimport { createSelector, createSlice } from '@reduxjs/toolkit';\n\nimport type { ApplicationState } from './store';\n\n/**\n * A notification object.\n *\n * @property id - A unique ID for the notification.\n * @property message - The notification message.\n * @property type - The notification type.\n */\nexport type Notification = {\n  id: string;\n  message: string;\n  type: NotificationType;\n};\n\n/**\n * The notifications state.\n *\n * @property notifications - An array of notifications.\n */\nexport type NotificationsState = {\n  notifications: Notification[];\n};\n\n/**\n * The initial notifications state.\n */\nconst INITIAL_STATE: NotificationsState = {\n  notifications: [],\n};\n\nexport const notificationsSlice = createSlice({\n  name: 'notifications',\n  initialState: INITIAL_STATE,\n  reducers: {\n    addNotification: (state, action: PayloadAction<Notification>) => {\n      state.notifications.push(action.payload);\n    },\n    removeNotification: (state, action: PayloadAction<string>) => {\n      state.notifications = state.notifications.filter(\n        (notification) => notification.id !== action.payload,\n      );\n    },\n    clearNotifications: (state) => {\n      state.notifications = [];\n    },\n  },\n});\n\nexport const { addNotification, removeNotification, clearNotifications } =\n  notificationsSlice.actions;\n\n/**\n * Get the notifications from the state.\n *\n * @param state - The application state.\n * @returns An array of notifications.\n */\nexport const getNotifications = createSelector(\n  (state: ApplicationState) => state.notifications,\n  ({ notifications }) => notifications,\n);\n"],"mappings":";AAEA,SAAS,gBAAgB,mBAAmB;AA6B5C,IAAM,gBAAoC;AAAA,EACxC,eAAe,CAAC;AAClB;AAEO,IAAM,qBAAqB,YAAY;AAAA,EAC5C,MAAM;AAAA,EACN,cAAc;AAAA,EACd,UAAU;AAAA,IACR,iBAAiB,CAAC,OAAO,WAAwC;AAC/D,YAAM,cAAc,KAAK,OAAO,OAAO;AAAA,IACzC;AAAA,IACA,oBAAoB,CAAC,OAAO,WAAkC;AAC5D,YAAM,gBAAgB,MAAM,cAAc;AAAA,QACxC,CAAC,iBAAiB,aAAa,OAAO,OAAO;AAAA,MAC/C;AAAA,IACF;AAAA,IACA,oBAAoB,CAAC,UAAU;AAC7B,YAAM,gBAAgB,CAAC;AAAA,IACzB;AAAA,EACF;AACF,CAAC;AAEM,IAAM,EAAE,iBAAiB,oBAAoB,mBAAmB,IACrE,mBAAmB;AAQd,IAAM,mBAAmB;AAAA,EAC9B,CAAC,UAA4B,MAAM;AAAA,EACnC,CAAC,EAAE,cAAc,MAAM;AACzB;","names":[]}

package/dist/chunk-LBC2OGSN.js

@@ -0,0 +1,48 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/internals/simulation/store/state.ts
+var _toolkit = require('@reduxjs/toolkit');
+var INITIAL_STATE = {
+  encrypted: null,
+  unencrypted: null
+};
+var stateSlice = _toolkit.createSlice.call(void 0, {
+  name: "state",
+  initialState: INITIAL_STATE,
+  reducers: {
+    setState: (state, action) => {
+      if (action.payload.encrypted) {
+        state.encrypted = action.payload.state;
+        return state;
+      }
+      state.unencrypted = action.payload.state;
+      return state;
+    },
+    clearState: (state, action) => {
+      if (action.payload.encrypted) {
+        state.encrypted = null;
+        return state;
+      }
+      state.unencrypted = null;
+      return state;
+    }
+  }
+});
+var { setState, clearState } = stateSlice.actions;
+function getState(encrypted) {
+  return _toolkit.createSelector.call(void 0, 
+    (state) => state,
+    ({ state }) => {
+      if (encrypted) {
+        return state.encrypted;
+      }
+      return state.unencrypted;
+    }
+  );
+}
+
+
+
+
+
+
+exports.stateSlice = stateSlice; exports.setState = setState; exports.clearState = clearState; exports.getState = getState;
+//# sourceMappingURL=chunk-LBC2OGSN.js.map

package/dist/chunk-LBC2OGSN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/store/state.ts"],"names":[],"mappings":";AACA,SAAS,gBAAgB,mBAAmB;AAoB5C,IAAM,gBAAuB;AAAA,EAC3B,WAAW;AAAA,EACX,aAAa;AACf;AAKO,IAAM,aAAa,YAAY;AAAA,EACpC,MAAM;AAAA,EACN,cAAc;AAAA,EACd,UAAU;AAAA,IACR,UAAU,CACR,OACA,WACG;AACH,UAAI,OAAO,QAAQ,WAAW;AAC5B,cAAM,YAAY,OAAO,QAAQ;AACjC,eAAO;AAAA,MACT;AAEA,YAAM,cAAc,OAAO,QAAQ;AACnC,aAAO;AAAA,IACT;AAAA,IACA,YAAY,CAAC,OAAO,WAAkD;AACpE,UAAI,OAAO,QAAQ,WAAW;AAC5B,cAAM,YAAY;AAClB,eAAO;AAAA,MACT;AAEA,YAAM,cAAc;AACpB,aAAO;AAAA,IACT;AAAA,EACF;AACF,CAAC;AAEM,IAAM,EAAE,UAAU,WAAW,IAAI,WAAW;AAQ5C,SAAS,SAAS,WAAoB;AAC3C,SAAO;AAAA,IACL,CAAC,UAA4B;AAAA,IAC7B,CAAC,EAAE,MAAM,MAAM;AACb,UAAI,WAAW;AACb,eAAO,MAAM;AAAA,MACf;AAEA,aAAO,MAAM;AAAA,IACf;AAAA,EACF;AACF","sourcesContent":["import type { PayloadAction } from '@reduxjs/toolkit';\nimport { createSelector, createSlice } from '@reduxjs/toolkit';\n\nimport type { ApplicationState } from './store';\n\n/**\n * The Snap state object.\n *\n * @property encrypted - The encrypted state. Can be null if the Snap does not\n * have an encrypted state.\n * @property unencrypted - The unencrypted state. Can be null if the Snap does\n * not have an unencrypted state.\n */\nexport type State = {\n  encrypted: string | null;\n  unencrypted: string | null;\n};\n\n/**\n * The initial state.\n */\nconst INITIAL_STATE: State = {\n  encrypted: null,\n  unencrypted: null,\n};\n\n/**\n * The state slice, which stores the state of the Snap.\n */\nexport const stateSlice = createSlice({\n  name: 'state',\n  initialState: INITIAL_STATE,\n  reducers: {\n    setState: (\n      state,\n      action: PayloadAction<{ state: string | null; encrypted: boolean }>,\n    ) => {\n      if (action.payload.encrypted) {\n        state.encrypted = action.payload.state;\n        return state;\n      }\n\n      state.unencrypted = action.payload.state;\n      return state;\n    },\n    clearState: (state, action: PayloadAction<{ encrypted: boolean }>) => {\n      if (action.payload.encrypted) {\n        state.encrypted = null;\n        return state;\n      }\n\n      state.unencrypted = null;\n      return state;\n    },\n  },\n});\n\nexport const { setState, clearState } = stateSlice.actions;\n\n/**\n * Get the state from the store.\n *\n * @param encrypted - Whether to get the encrypted or unencrypted state.\n * @returns A selector that returns the state.\n */\nexport function getState(encrypted: boolean) {\n  return createSelector(\n    (state: ApplicationState) => state,\n    ({ state }) => {\n      if (encrypted) {\n        return state.encrypted;\n      }\n\n      return state.unencrypted;\n    },\n  );\n}\n"]}

package/dist/chunk-LHU3EHLI.mjs

@@ -0,0 +1,137 @@
+import {
+  createJsonRpcEngine
+} from "./chunk-KNJNL723.mjs";
+import {
+  getOptions
+} from "./chunk-IH7UNS5A.mjs";
+import {
+  getControllers,
+  registerSnap
+} from "./chunk-CCYBLBVL.mjs";
+import {
+  getEndowments
+} from "./chunk-HBLJOACO.mjs";
+import {
+  createStore
+} from "./chunk-7YD4IW43.mjs";
+import {
+  getSnapFile
+} from "./chunk-TBDYQSRT.mjs";
+
+// src/internals/simulation/simulation.ts
+import { ControllerMessenger } from "@metamask/base-controller";
+import { createEngineStream } from "@metamask/json-rpc-middleware-stream";
+import { mnemonicPhraseToBytes } from "@metamask/key-tree";
+import {
+  fetchSnap,
+  detectSnapLocation,
+  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, {
+  executionService,
+  executionServiceOptions,
+  options: rawOptions = {}
+} = {}) {
+  const options = getOptions(rawOptions);
+  const location = detectSnapLocation(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 controllerMessenger = new ControllerMessenger();
+  registerActions(controllerMessenger);
+  const hooks = getHooks(options, snapFiles, snapId, controllerMessenger);
+  const { subjectMetadataController, permissionController } = getControllers({
+    controllerMessenger,
+    hooks,
+    runSaga,
+    options
+  });
+  const engine = createJsonRpcEngine({
+    store,
+    hooks,
+    permissionMiddleware: permissionController.createPermissionMiddleware({
+      origin: snapId
+    })
+  });
+  const ExecutionService = executionService ?? NodeThreadExecutionService;
+  const service = new ExecutionService({
+    ...executionServiceOptions,
+    messenger: controllerMessenger.getRestricted({
+      name: "ExecutionService"
+    }),
+    setupSnapProvider: (_snapId, rpcStream) => {
+      const mux = setupMultiplex(rpcStream, "snapStream");
+      const stream = mux.createStream("metamask-provider");
+      const providerStream = createEngineStream({ engine });
+      pipeline(stream, providerStream, stream, (error) => {
+        if (error) {
+          logError(`Provider stream failure.`, error);
+        }
+      });
+    }
+  });
+  await registerSnap(snapId, snapFiles.manifest.result, {
+    permissionController,
+    subjectMetadataController
+  });
+  await service.executeSnap({
+    snapId,
+    sourceCode: snapFiles.sourceCode.toString("utf8"),
+    endowments: await getEndowments(permissionController, snapId)
+  });
+  return {
+    snapId,
+    store,
+    executionService: service,
+    controllerMessenger,
+    runSaga
+  };
+}
+function getHooks(options, snapFiles, snapId, controllerMessenger) {
+  return {
+    getMnemonic: async () => Promise.resolve(mnemonicPhraseToBytes(options.secretRecoveryPhrase)),
+    getSnapFile: async (path, encoding) => await getSnapFile(snapFiles.auxiliaryFiles, path, encoding),
+    getIsLocked: () => false,
+    createInterface: async (...args) => controllerMessenger.call(
+      "SnapInterfaceController:createInterface",
+      snapId,
+      ...args
+    ),
+    updateInterface: async (...args) => controllerMessenger.call(
+      "SnapInterfaceController:updateInterface",
+      snapId,
+      ...args
+    ),
+    getInterfaceState: (...args) => controllerMessenger.call(
+      "SnapInterfaceController:getInterface",
+      snapId,
+      ...args
+    ).state
+  };
+}
+function registerActions(controllerMessenger) {
+  controllerMessenger.registerActionHandler(
+    "PhishingController:maybeUpdateState",
+    async () => Promise.resolve()
+  );
+  controllerMessenger.registerActionHandler(
+    "PhishingController:testOrigin",
+    () => ({ result: false, type: "all" })
+  );
+}
+
+export {
+  handleInstallSnap,
+  getHooks,
+  registerActions
+};
+//# sourceMappingURL=chunk-LHU3EHLI.mjs.map