@metamask/snaps-jest 5.0.0 → 6.0.0

package/dist/chunk-4VCE3DRR.mjs

@@ -0,0 +1,34 @@
+// src/internals/simulation/store/ui.ts
+import { createAction, createSelector, createSlice } from "@reduxjs/toolkit";
+var INITIAL_STATE = {
+  current: null
+};
+var uiSlice = createSlice({
+  name: "ui",
+  initialState: INITIAL_STATE,
+  reducers: {
+    setInterface(state, action) {
+      state.current = action.payload;
+    },
+    closeInterface(state) {
+      state.current = null;
+    }
+  }
+});
+var resolveInterface = createAction(
+  `${uiSlice.name}/resolveInterface`
+);
+var { setInterface, closeInterface } = uiSlice.actions;
+var getCurrentInterface = createSelector(
+  (state) => state.ui,
+  (ui) => ui.current
+);
+
+export {
+  uiSlice,
+  resolveInterface,
+  setInterface,
+  closeInterface,
+  getCurrentInterface
+};
+//# sourceMappingURL=chunk-4VCE3DRR.mjs.map

package/dist/chunk-4VCE3DRR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/store/ui.ts"],"sourcesContent":["import type { DialogType } from '@metamask/snaps-sdk';\nimport type { PayloadAction } from '@reduxjs/toolkit';\nimport { createAction, createSelector, createSlice } from '@reduxjs/toolkit';\n\nimport type { ApplicationState } from './store';\n\nexport type Interface = {\n  type: DialogType;\n  id: string;\n};\n\nexport type UiState = {\n  current?: Interface | null;\n};\n\nconst INITIAL_STATE: UiState = {\n  current: null,\n};\n\nexport const uiSlice = createSlice({\n  name: 'ui',\n  initialState: INITIAL_STATE,\n  reducers: {\n    setInterface(state, action: PayloadAction<Interface>) {\n      state.current = action.payload;\n    },\n    closeInterface(state) {\n      state.current = null;\n    },\n  },\n});\n\nexport const resolveInterface = createAction<unknown>(\n  `${uiSlice.name}/resolveInterface`,\n);\n\nexport const { setInterface, closeInterface } = uiSlice.actions;\n\nexport const getCurrentInterface = createSelector(\n  (state: ApplicationState) => state.ui,\n  (ui) => ui.current,\n);\n"],"mappings":";AAEA,SAAS,cAAc,gBAAgB,mBAAmB;AAa1D,IAAM,gBAAyB;AAAA,EAC7B,SAAS;AACX;AAEO,IAAM,UAAU,YAAY;AAAA,EACjC,MAAM;AAAA,EACN,cAAc;AAAA,EACd,UAAU;AAAA,IACR,aAAa,OAAO,QAAkC;AACpD,YAAM,UAAU,OAAO;AAAA,IACzB;AAAA,IACA,eAAe,OAAO;AACpB,YAAM,UAAU;AAAA,IAClB;AAAA,EACF;AACF,CAAC;AAEM,IAAM,mBAAmB;AAAA,EAC9B,GAAG,QAAQ,IAAI;AACjB;AAEO,IAAM,EAAE,cAAc,eAAe,IAAI,QAAQ;AAEjD,IAAM,sBAAsB;AAAA,EACjC,CAAC,UAA4B,MAAM;AAAA,EACnC,CAAC,OAAO,GAAG;AACb;","names":[]}

package/dist/chunk-4WCFXE73.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-4WCFXE73.js.map

package/dist/chunk-4WCFXE73.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-5IUHGC5S.js

@@ -0,0 +1,153 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk3CC2NI7Rjs = require('./chunk-3CC2NI7R.js');
+
+
+var _chunkMNDF32ZVjs = require('./chunk-MNDF32ZV.js');
+
+
+
+
+var _chunkRQBZLDXLjs = require('./chunk-RQBZLDXL.js');
+
+
+
+var _chunk34GS3AHAjs = require('./chunk-34GS3AHA.js');
+
+
+var _chunk7JLVQJK7js = require('./chunk-7JLVQJK7.js');
+
+// src/helpers.ts
+var _snapsutils = require('@metamask/snaps-utils');
+var _utils = require('@metamask/utils');
+var _superstruct = require('superstruct');
+var log = _utils.createModuleLogger.call(void 0, _chunkMNDF32ZVjs.rootLogger, "helpers");
+function getOptions(snapId, options) {
+  if (typeof snapId === "object") {
+    return [void 0, snapId];
+  }
+  return [snapId, options];
+}
+async function installSnap(snapId, options = {}) {
+  const resolvedOptions = getOptions(snapId, options);
+  const {
+    snapId: installedSnapId,
+    store,
+    executionService,
+    runSaga,
+    controllerMessenger
+  } = await _chunk7JLVQJK7js.getEnvironment.call(void 0, ).installSnap(...resolvedOptions);
+  const onTransaction = async (request) => {
+    log("Sending transaction %o.", request);
+    const {
+      origin: transactionOrigin,
+      chainId,
+      ...transaction
+    } = _superstruct.create.call(void 0, request, _chunkRQBZLDXLjs.TransactionOptionsStruct);
+    return _chunk3CC2NI7Rjs.handleRequest.call(void 0, {
+      snapId: installedSnapId,
+      store,
+      executionService,
+      runSaga,
+      controllerMessenger,
+      handler: _snapsutils.HandlerType.OnTransaction,
+      request: {
+        method: "",
+        params: {
+          chainId,
+          transaction,
+          transactionOrigin
+        }
+      }
+    });
+  };
+  const onCronjob = (request) => {
+    log("Running cronjob %o.", options);
+    return _chunk3CC2NI7Rjs.handleRequest.call(void 0, {
+      snapId: installedSnapId,
+      store,
+      executionService,
+      controllerMessenger,
+      runSaga,
+      handler: _snapsutils.HandlerType.OnCronjob,
+      request
+    });
+  };
+  return {
+    request: (request) => {
+      log("Sending request %o.", request);
+      return _chunk3CC2NI7Rjs.handleRequest.call(void 0, {
+        snapId: installedSnapId,
+        store,
+        executionService,
+        controllerMessenger,
+        runSaga,
+        handler: _snapsutils.HandlerType.OnRpcRequest,
+        request
+      });
+    },
+    onTransaction,
+    sendTransaction: onTransaction,
+    onSignature: async (request) => {
+      log("Requesting signature %o.", request);
+      const { origin: signatureOrigin, ...signature } = _superstruct.create.call(void 0, 
+        request,
+        _chunkRQBZLDXLjs.SignatureOptionsStruct
+      );
+      return _chunk3CC2NI7Rjs.handleRequest.call(void 0, {
+        snapId: installedSnapId,
+        store,
+        executionService,
+        controllerMessenger,
+        runSaga,
+        handler: _snapsutils.HandlerType.OnSignature,
+        request: {
+          method: "",
+          params: {
+            signature,
+            signatureOrigin
+          }
+        }
+      });
+    },
+    onCronjob,
+    runCronjob: onCronjob,
+    onHomePage: async () => {
+      log("Rendering home page.");
+      return _chunk3CC2NI7Rjs.handleRequest.call(void 0, {
+        snapId: installedSnapId,
+        store,
+        executionService,
+        controllerMessenger,
+        runSaga,
+        handler: _snapsutils.HandlerType.OnHomePage,
+        request: {
+          method: ""
+        }
+      });
+    },
+    mockJsonRpc(mock) {
+      log("Mocking JSON-RPC request %o.", mock);
+      const { method, result } = _superstruct.create.call(void 0, mock, _chunkRQBZLDXLjs.JsonRpcMockOptionsStruct);
+      store.dispatch(_chunk34GS3AHAjs.addJsonRpcMock.call(void 0, { method, result }));
+      return {
+        unmock() {
+          log("Unmocking JSON-RPC request %o.", mock);
+          store.dispatch(_chunk34GS3AHAjs.removeJsonRpcMock.call(void 0, method));
+        }
+      };
+    },
+    close: async () => {
+      log("Closing execution service.");
+      _snapsutils.logInfo.call(void 0, 
+        "Calling `snap.close()` is deprecated, and will be removed in a future release. Snaps are now automatically closed when the test ends."
+      );
+      await executionService.terminateAllSnaps();
+    }
+  };
+}
+
+
+
+exports.installSnap = installSnap;
+//# sourceMappingURL=chunk-5IUHGC5S.js.map

package/dist/chunk-5IUHGC5S.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/helpers.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAEA,SAAS,aAAa,eAAe;AACrC,SAAS,0BAA0B;AACnC,SAAS,cAAc;AAuBvB,IAAM,MAAM,mBAAmB,YAAY,SAAS;AASpD,SAAS,WAKP,QACA,SAC4D;AAC5D,MAAI,OAAO,WAAW,UAAU;AAC9B,WAAO,CAAC,QAAW,MAAM;AAAA,EAC3B;AAEA,SAAO,CAAC,QAAQ,OAAO;AACzB;AAqIA,eAAsB,YAKpB,QACA,UAAgD,CAAC,GAClC;AACf,QAAM,kBAAkB,WAAW,QAAQ,OAAO;AAClD,QAAM;AAAA,IACJ,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI,MAAM,eAAe,EAAE,YAAY,GAAG,eAAe;AAEzD,QAAM,gBAAgB,OACpB,YAC0B;AAC1B,QAAI,2BAA2B,OAAO;AAEtC,UAAM;AAAA,MACJ,QAAQ;AAAA,MACR;AAAA,MACA,GAAG;AAAA,IACL,IAAI,OAAO,SAAS,wBAAwB;AAE5C,WAAO,cAAc;AAAA,MACnB,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS,YAAY;AAAA,MACrB,SAAS;AAAA,QACP,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,YAAY,CAAC,YAA4B;AAC7C,QAAI,uBAAuB,OAAO;AAElC,WAAO,cAAc;AAAA,MACnB,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS,YAAY;AAAA,MACrB;AAAA,IACF,CAAC;AAAA,EACH;AAEA,SAAO;AAAA,IACL,SAAS,CAAC,YAAY;AACpB,UAAI,uBAAuB,OAAO;AAElC,aAAO,cAAc;AAAA,QACnB,QAAQ;AAAA,QACR;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,SAAS,YAAY;AAAA,QACrB;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IAEA;AAAA,IACA,iBAAiB;AAAA,IAEjB,aAAa,OAAO,YAA4C;AAC9D,UAAI,4BAA4B,OAAO;AAEvC,YAAM,EAAE,QAAQ,iBAAiB,GAAG,UAAU,IAAI;AAAA,QAChD;AAAA,QACA;AAAA,MACF;AAEA,aAAO,cAAc;AAAA,QACnB,QAAQ;AAAA,QACR;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,SAAS,YAAY;AAAA,QACrB,SAAS;AAAA,UACP,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN;AAAA,YACA;AAAA,UACF;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IAEA;AAAA,IACA,YAAY;AAAA,IAEZ,YAAY,YAAmC;AAC7C,UAAI,sBAAsB;AAE1B,aAAO,cAAc;AAAA,QACnB,QAAQ;AAAA,QACR;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,SAAS,YAAY;AAAA,QACrB,SAAS;AAAA,UACP,QAAQ;AAAA,QACV;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IAEA,YAAY,MAA0B;AACpC,UAAI,gCAAgC,IAAI;AAExC,YAAM,EAAE,QAAQ,OAAO,IAAI,OAAO,MAAM,wBAAwB;AAChE,YAAM,SAAS,eAAe,EAAE,QAAQ,OAAO,CAAC,CAAC;AAEjD,aAAO;AAAA,QACL,SAAS;AACP,cAAI,kCAAkC,IAAI;AAE1C,gBAAM,SAAS,kBAAkB,MAAM,CAAC;AAAA,QAC1C;AAAA,MACF;AAAA,IACF;AAAA,IAEA,OAAO,YAAY;AACjB,UAAI,4BAA4B;AAChC;AAAA,QACE;AAAA,MACF;AAEA,YAAM,iBAAiB,kBAAkB;AAAA,IAC3C;AAAA,EACF;AACF","sourcesContent":["import type { AbstractExecutionService } from '@metamask/snaps-controllers';\nimport type { SnapId } from '@metamask/snaps-sdk';\nimport { HandlerType, logInfo } from '@metamask/snaps-utils';\nimport { createModuleLogger } from '@metamask/utils';\nimport { create } from 'superstruct';\n\nimport {\n  rootLogger,\n  handleRequest,\n  TransactionOptionsStruct,\n  getEnvironment,\n  JsonRpcMockOptionsStruct,\n  SignatureOptionsStruct,\n} from './internals';\nimport type { InstallSnapOptions } from './internals';\nimport {\n  addJsonRpcMock,\n  removeJsonRpcMock,\n} from './internals/simulation/store/mocks';\nimport type {\n  CronjobOptions,\n  JsonRpcMockOptions,\n  Snap,\n  SnapResponse,\n  TransactionOptions,\n} from './types';\n\nconst log = createModuleLogger(rootLogger, 'helpers');\n\n/**\n * Get the options for {@link installSnap}.\n *\n * @param snapId - The ID of the Snap, or the options.\n * @param options - The options, if any.\n * @returns The options.\n */\nfunction getOptions<\n  Service extends new (...args: any[]) => InstanceType<\n    typeof AbstractExecutionService\n  >,\n>(\n  snapId: SnapId | Partial<InstallSnapOptions<Service>> | undefined,\n  options: Partial<InstallSnapOptions<Service>>,\n): [SnapId | undefined, Partial<InstallSnapOptions<Service>>] {\n  if (typeof snapId === 'object') {\n    return [undefined, snapId];\n  }\n\n  return [snapId, options];\n}\n\n/**\n * Load a snap into the environment. This is the main entry point for testing\n * snaps: It returns a {@link Snap} object that can be used to interact with the\n * snap.\n *\n * @example\n * import { installSnap } from '@metamask/snaps-jest';\n *\n * describe('My Snap', () => {\n *   it('should do something', async () => {\n *     const { request } = await installSnap('local:my-snap');\n *     const response = await request({\n *       method: 'foo',\n *       params: ['bar'],\n *     });\n *     expect(response).toRespondWith('bar');\n *   });\n * });\n * @returns The snap.\n * @throws If the built-in server is not running, and no snap ID is provided.\n */\nexport async function installSnap(): Promise<Snap>;\n\n/**\n * Load a snap into the environment. This is the main entry point for testing\n * snaps: It returns a {@link Snap} object that can be used to interact with the\n * snap.\n *\n * @example\n * import { installSnap } from '@metamask/snaps-jest';\n *\n * describe('My Snap', () => {\n *   it('should do something', async () => {\n *     const { request } = await installSnap('local:my-snap');\n *     const response = await request({\n *       method: 'foo',\n *       params: ['bar'],\n *     });\n *     expect(response).toRespondWith('bar');\n *   });\n * });\n * @param options - The options to use.\n * @param options.executionService - The execution service to use. Defaults to\n * {@link NodeThreadExecutionService}. You do not need to provide this unless\n * you are testing a custom execution service.\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 * @returns The snap.\n * @throws If the built-in server is not running, and no snap ID is provided.\n */\nexport async function installSnap<\n  Service extends new (...args: any[]) => InstanceType<\n    typeof AbstractExecutionService\n  >,\n>(options: Partial<InstallSnapOptions<Service>>): Promise<Snap>;\n\n/**\n * Load a snap into the environment. This is the main entry point for testing\n * snaps: It returns a {@link Snap} object that can be used to interact with the\n * snap.\n *\n * @example\n * import { installSnap } from '@metamask/snaps-jest';\n *\n * describe('My Snap', () => {\n *   it('should do something', async () => {\n *     const { request } = await installSnap('local:my-snap');\n *     const response = await request({\n *       method: 'foo',\n *       params: ['bar'],\n *     });\n *     expect(response).toRespondWith('bar');\n *   });\n * });\n * @param snapId - The ID of the snap, including the prefix (`local:`). Defaults\n * to the URL of the built-in server, if it is running. This supports both\n * local snap IDs and NPM snap IDs.\n * @param options - The options to use.\n * @param options.executionService - The execution service to use. Defaults to\n * {@link NodeThreadExecutionService}. You do not need to provide this unless\n * you are testing a custom execution service.\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 * @returns The snap.\n * @throws If the built-in server is not running, and no snap ID is provided.\n */\nexport async function installSnap<\n  Service extends new (...args: any[]) => InstanceType<\n    typeof AbstractExecutionService\n  >,\n>(\n  snapId: SnapId,\n  options?: Partial<InstallSnapOptions<Service>>,\n): Promise<Snap>;\n\n/**\n * Load a snap into the environment. This is the main entry point for testing\n * snaps: It returns a {@link Snap} object that can be used to interact with the\n * snap.\n *\n * @example\n * import { installSnap } from '@metamask/snaps-jest';\n *\n * describe('My Snap', () => {\n *   it('should do something', async () => {\n *     const { request } = await installSnap('local:my-snap');\n *     const response = await request({\n *       method: 'foo',\n *       params: ['bar'],\n *     });\n *     expect(response).toRespondWith('bar');\n *   });\n * });\n * @param snapId - The ID of the snap, including the prefix (`local:`). Defaults\n * to the URL of the built-in server, if it is running. This supports both\n * local snap IDs and NPM snap IDs.\n * @param options - The options to use.\n * @param options.executionService - The execution service to use. Defaults to\n * {@link NodeThreadExecutionService}. You do not need to provide this unless\n * you are testing a custom execution service.\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 * @returns The snap.\n * @throws If the built-in server is not running, and no snap ID is provided.\n */\nexport async function installSnap<\n  Service extends new (...args: any[]) => InstanceType<\n    typeof AbstractExecutionService\n  >,\n>(\n  snapId?: SnapId | Partial<InstallSnapOptions<Service>>,\n  options: Partial<InstallSnapOptions<Service>> = {},\n): Promise<Snap> {\n  const resolvedOptions = getOptions(snapId, options);\n  const {\n    snapId: installedSnapId,\n    store,\n    executionService,\n    runSaga,\n    controllerMessenger,\n  } = await getEnvironment().installSnap(...resolvedOptions);\n\n  const onTransaction = async (\n    request: TransactionOptions,\n  ): Promise<SnapResponse> => {\n    log('Sending transaction %o.', request);\n\n    const {\n      origin: transactionOrigin,\n      chainId,\n      ...transaction\n    } = create(request, TransactionOptionsStruct);\n\n    return handleRequest({\n      snapId: installedSnapId,\n      store,\n      executionService,\n      runSaga,\n      controllerMessenger,\n      handler: HandlerType.OnTransaction,\n      request: {\n        method: '',\n        params: {\n          chainId,\n          transaction,\n          transactionOrigin,\n        },\n      },\n    });\n  };\n\n  const onCronjob = (request: CronjobOptions) => {\n    log('Running cronjob %o.', options);\n\n    return handleRequest({\n      snapId: installedSnapId,\n      store,\n      executionService,\n      controllerMessenger,\n      runSaga,\n      handler: HandlerType.OnCronjob,\n      request,\n    });\n  };\n\n  return {\n    request: (request) => {\n      log('Sending request %o.', request);\n\n      return handleRequest({\n        snapId: installedSnapId,\n        store,\n        executionService,\n        controllerMessenger,\n        runSaga,\n        handler: HandlerType.OnRpcRequest,\n        request,\n      });\n    },\n\n    onTransaction,\n    sendTransaction: onTransaction,\n\n    onSignature: async (request: unknown): Promise<SnapResponse> => {\n      log('Requesting signature %o.', request);\n\n      const { origin: signatureOrigin, ...signature } = create(\n        request,\n        SignatureOptionsStruct,\n      );\n\n      return handleRequest({\n        snapId: installedSnapId,\n        store,\n        executionService,\n        controllerMessenger,\n        runSaga,\n        handler: HandlerType.OnSignature,\n        request: {\n          method: '',\n          params: {\n            signature,\n            signatureOrigin,\n          },\n        },\n      });\n    },\n\n    onCronjob,\n    runCronjob: onCronjob,\n\n    onHomePage: async (): Promise<SnapResponse> => {\n      log('Rendering home page.');\n\n      return handleRequest({\n        snapId: installedSnapId,\n        store,\n        executionService,\n        controllerMessenger,\n        runSaga,\n        handler: HandlerType.OnHomePage,\n        request: {\n          method: '',\n        },\n      });\n    },\n\n    mockJsonRpc(mock: JsonRpcMockOptions) {\n      log('Mocking JSON-RPC request %o.', mock);\n\n      const { method, result } = create(mock, JsonRpcMockOptionsStruct);\n      store.dispatch(addJsonRpcMock({ method, result }));\n\n      return {\n        unmock() {\n          log('Unmocking JSON-RPC request %o.', mock);\n\n          store.dispatch(removeJsonRpcMock(method));\n        },\n      };\n    },\n\n    close: async () => {\n      log('Closing execution service.');\n      logInfo(\n        'Calling `snap.close()` is deprecated, and will be removed in a future release. Snaps are now automatically closed when the test ends.',\n      );\n\n      await executionService.terminateAllSnaps();\n    },\n  };\n}\n"]}

package/dist/chunk-5O6VBW42.js

@@ -0,0 +1,42 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkON6M4WG5js = require('./chunk-ON6M4WG5.js');
+
+// src/internals/simulation/methods/hooks/notifications.ts
+var _snapssdk = require('@metamask/snaps-sdk');
+var _toolkit = require('@reduxjs/toolkit');
+var _effects = require('redux-saga/effects');
+function* showNativeNotificationImplementation(_snapId, { message }) {
+  yield _effects.put.call(void 0, 
+    _chunkON6M4WG5js.addNotification.call(void 0, { id: _toolkit.nanoid.call(void 0, ), type: _snapssdk.NotificationType.Native, message })
+  );
+  return null;
+}
+function getShowNativeNotificationImplementation(runSaga) {
+  return async (...args) => {
+    return await runSaga(
+      showNativeNotificationImplementation,
+      ...args
+    ).toPromise();
+  };
+}
+function* showInAppNotificationImplementation(_snapId, { message }) {
+  yield _effects.put.call(void 0, 
+    _chunkON6M4WG5js.addNotification.call(void 0, { id: _toolkit.nanoid.call(void 0, ), type: _snapssdk.NotificationType.InApp, message })
+  );
+  return null;
+}
+function getShowInAppNotificationImplementation(runSaga) {
+  return async (...args) => {
+    return await runSaga(
+      showInAppNotificationImplementation,
+      ...args
+    ).toPromise();
+  };
+}
+
+
+
+
+exports.getShowNativeNotificationImplementation = getShowNativeNotificationImplementation; exports.getShowInAppNotificationImplementation = getShowInAppNotificationImplementation;
+//# sourceMappingURL=chunk-5O6VBW42.js.map

package/dist/chunk-5O6VBW42.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/methods/hooks/notifications.ts"],"names":[],"mappings":";;;;;AACA,SAAS,wBAAwB;AACjC,SAAS,cAAc;AAEvB,SAAS,WAAW;AAcpB,UAAU,qCACR,SACA,EAAE,QAAQ,GACI;AACd,QAAM;AAAA,IACJ,gBAAgB,EAAE,IAAI,OAAO,GAAG,MAAM,iBAAiB,QAAQ,QAAQ,CAAC;AAAA,EAC1E;AAEA,SAAO;AACT;AAQO,SAAS,wCACd,SACA;AACA,SAAO,UACF,SACA;AACH,WAAO,MAAM;AAAA,MACX;AAAA,MACA,GAAG;AAAA,IACL,EAAE,UAAU;AAAA,EACd;AACF;AAWA,UAAU,oCACR,SACA,EAAE,QAAQ,GACU;AACpB,QAAM;AAAA,IACJ,gBAAgB,EAAE,IAAI,OAAO,GAAG,MAAM,iBAAiB,OAAO,QAAQ,CAAC;AAAA,EACzE;AAEA,SAAO;AACT;AAQO,SAAS,uCACd,SACA;AACA,SAAO,UACF,SACA;AACH,WAAO,MAAM;AAAA,MACX;AAAA,MACA,GAAG;AAAA,IACL,EAAE,UAAU;AAAA,EACd;AACF","sourcesContent":["import type { NotifyParams } from '@metamask/snaps-sdk';\nimport { NotificationType } from '@metamask/snaps-sdk';\nimport { nanoid } from '@reduxjs/toolkit';\nimport type { SagaIterator } from 'redux-saga';\nimport { put } from 'redux-saga/effects';\n\nimport type { RunSagaFunction } from '../../store';\nimport { addNotification } from '../../store';\n\n/**\n * Show a native notification to the user.\n *\n * @param _snapId - The ID of the Snap that created the notification.\n * @param options - The notification options.\n * @param options.message - The message to show in the notification.\n * @yields Adds the notification to the store.\n * @returns `null`.\n */\nfunction* showNativeNotificationImplementation(\n  _snapId: string,\n  { message }: NotifyParams,\n): SagaIterator {\n  yield put(\n    addNotification({ id: nanoid(), type: NotificationType.Native, message }),\n  );\n\n  return null;\n}\n\n/**\n * Get a method that can be used to show a native notification.\n *\n * @param runSaga - A function to run a saga outside the usual Redux flow.\n * @returns A method that can be used to show a native notification.\n */\nexport function getShowNativeNotificationImplementation(\n  runSaga: RunSagaFunction,\n) {\n  return async (\n    ...args: Parameters<typeof showNativeNotificationImplementation>\n  ) => {\n    return await runSaga(\n      showNativeNotificationImplementation,\n      ...args,\n    ).toPromise();\n  };\n}\n\n/**\n * Show an in-app notification to the user.\n *\n * @param _snapId - The ID of the Snap that created the notification.\n * @param options - The notification options.\n * @param options.message - The message to show in the notification.\n * @yields Adds the notification to the store.\n * @returns `null`.\n */\nfunction* showInAppNotificationImplementation(\n  _snapId: string,\n  { message }: NotifyParams,\n): SagaIterator<null> {\n  yield put(\n    addNotification({ id: nanoid(), type: NotificationType.InApp, message }),\n  );\n\n  return null;\n}\n\n/**\n * Get a method that can be used to show an in-app notification.\n *\n * @param runSaga - A function to run a saga outside the usual Redux flow.\n * @returns A method that can be used to show an in-app notification.\n */\nexport function getShowInAppNotificationImplementation(\n  runSaga: RunSagaFunction,\n) {\n  return async (\n    ...args: Parameters<typeof showInAppNotificationImplementation>\n  ) => {\n    return await runSaga(\n      showInAppNotificationImplementation,\n      ...args,\n    ).toPromise();\n  };\n}\n"]}

package/dist/chunk-6IMEYERE.js

@@ -0,0 +1,137 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkXDZPH5WDjs = require('./chunk-XDZPH5WD.js');
+
+
+var _chunkEFB6AQPBjs = require('./chunk-EFB6AQPB.js');
+
+
+
+var _chunkKGIWSGTTjs = require('./chunk-KGIWSGTT.js');
+
+
+var _chunkVNQIROKZjs = require('./chunk-VNQIROKZ.js');
+
+
+var _chunkJGQJFYU4js = require('./chunk-JGQJFYU4.js');
+
+
+var _chunk3O5OISLUjs = require('./chunk-3O5OISLU.js');
+
+// src/internals/simulation/simulation.ts
+var _basecontroller = require('@metamask/base-controller');
+var _jsonrpcmiddlewarestream = require('@metamask/json-rpc-middleware-stream');
+var _keytree = require('@metamask/key-tree');
+
+
+
+
+
+var _node = require('@metamask/snaps-controllers/node');
+var _snapsrpcmethods = require('@metamask/snaps-rpc-methods');
+var _snapsutils = require('@metamask/snaps-utils');
+var _readablestream = require('readable-stream');
+async function handleInstallSnap(snapId, {
+  executionService,
+  executionServiceOptions,
+  options: rawOptions = {}
+} = {}) {
+  const options = _chunkEFB6AQPBjs.getOptions.call(void 0, rawOptions);
+  const location = _node.detectSnapLocation.call(void 0, snapId, {
+    allowLocal: true
+  });
+  const snapFiles = await _node.fetchSnap.call(void 0, snapId, location);
+  const password = await _snapsrpcmethods.getEncryptionKey.call(void 0, {
+    mnemonicPhrase: _keytree.mnemonicPhraseToBytes.call(void 0, options.secretRecoveryPhrase),
+    snapId
+  });
+  const { store, runSaga } = _chunkJGQJFYU4js.createStore.call(void 0, password, options);
+  const controllerMessenger = new (0, _basecontroller.ControllerMessenger)();
+  registerActions(controllerMessenger);
+  const hooks = getHooks(options, snapFiles, snapId, controllerMessenger);
+  const { subjectMetadataController, permissionController } = _chunkKGIWSGTTjs.getControllers.call(void 0, {
+    controllerMessenger,
+    hooks,
+    runSaga,
+    options
+  });
+  const engine = _chunkXDZPH5WDjs.createJsonRpcEngine.call(void 0, {
+    store,
+    hooks,
+    permissionMiddleware: permissionController.createPermissionMiddleware({
+      origin: snapId
+    })
+  });
+  const ExecutionService = _nullishCoalesce(executionService, () => ( _node.NodeThreadExecutionService));
+  const service = new ExecutionService({
+    ...executionServiceOptions,
+    messenger: controllerMessenger.getRestricted({
+      name: "ExecutionService"
+    }),
+    setupSnapProvider: (_snapId, rpcStream) => {
+      const mux = _node.setupMultiplex.call(void 0, rpcStream, "snapStream");
+      const stream = mux.createStream("metamask-provider");
+      const providerStream = _jsonrpcmiddlewarestream.createEngineStream.call(void 0, { engine });
+      _readablestream.pipeline.call(void 0, stream, providerStream, stream, (error) => {
+        if (error) {
+          _snapsutils.logError.call(void 0, `Provider stream failure.`, error);
+        }
+      });
+    }
+  });
+  await _chunkKGIWSGTTjs.registerSnap.call(void 0, snapId, snapFiles.manifest.result, {
+    permissionController,
+    subjectMetadataController
+  });
+  await service.executeSnap({
+    snapId,
+    sourceCode: snapFiles.sourceCode.toString("utf8"),
+    endowments: await _chunkVNQIROKZjs.getEndowments.call(void 0, permissionController, snapId)
+  });
+  return {
+    snapId,
+    store,
+    executionService: service,
+    controllerMessenger,
+    runSaga
+  };
+}
+function getHooks(options, snapFiles, snapId, controllerMessenger) {
+  return {
+    getMnemonic: async () => Promise.resolve(_keytree.mnemonicPhraseToBytes.call(void 0, options.secretRecoveryPhrase)),
+    getSnapFile: async (path, encoding) => await _chunk3O5OISLUjs.getSnapFile.call(void 0, 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" })
+  );
+}
+
+
+
+
+
+exports.handleInstallSnap = handleInstallSnap; exports.getHooks = getHooks; exports.registerActions = registerActions;
+//# sourceMappingURL=chunk-6IMEYERE.js.map

package/dist/chunk-6IMEYERE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/simulation.ts"],"names":[],"mappings":"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","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 { getEncryptionKey } from '@metamask/snaps-rpc-methods';\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 password = await getEncryptionKey({\n    mnemonicPhrase: mnemonicPhraseToBytes(options.secretRecoveryPhrase),\n    snapId,\n  });\n\n  const { store, runSaga } = createStore(password, 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    }),\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"]}

package/dist/chunk-6KNT4UMX.mjs

@@ -0,0 +1,35 @@
+import {
+  getAccountsHandler
+} from "./chunk-CKOGTHM4.mjs";
+import {
+  getProviderStateHandler
+} from "./chunk-O3VJYBFN.mjs";
+
+// src/internals/simulation/middleware/internal-methods/middleware.ts
+import { logError } from "@metamask/snaps-utils";
+var methodHandlers = {
+  /* eslint-disable @typescript-eslint/naming-convention */
+  metamask_getProviderState: getProviderStateHandler,
+  eth_requestAccounts: getAccountsHandler,
+  eth_accounts: getAccountsHandler
+  /* eslint-enable @typescript-eslint/naming-convention */
+};
+function createInternalMethodsMiddleware(hooks) {
+  return async function methodMiddleware(request, response, next, end) {
+    const handler = methodHandlers[request.method];
+    if (handler) {
+      try {
+        return await handler(request, response, next, end, hooks);
+      } catch (error) {
+        logError(error);
+        return end(error);
+      }
+    }
+    return next();
+  };
+}
+
+export {
+  createInternalMethodsMiddleware
+};
+//# sourceMappingURL=chunk-6KNT4UMX.mjs.map

package/dist/chunk-6KNT4UMX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/middleware/internal-methods/middleware.ts"],"sourcesContent":["import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';\nimport { logError } from '@metamask/snaps-utils';\nimport type { Json, JsonRpcParams } from '@metamask/utils';\n\nimport { getAccountsHandler } from './accounts';\nimport { getProviderStateHandler } from './provider-state';\n\nexport type InternalMethodsMiddlewareHooks = {\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\nconst methodHandlers = {\n  /* eslint-disable @typescript-eslint/naming-convention */\n  metamask_getProviderState: getProviderStateHandler,\n  eth_requestAccounts: getAccountsHandler,\n  eth_accounts: getAccountsHandler,\n  /* eslint-enable @typescript-eslint/naming-convention */\n};\n\n/**\n * Create a middleware for handling JSON-RPC methods normally handled internally\n * by the MetaMask client.\n *\n * NOTE: This middleware provides all `hooks` to all handlers and should\n * therefore NOT be used outside of the simulation environment. It is intended\n * for testing purposes only.\n *\n * @param hooks - Any hooks used by the middleware handlers.\n * @returns A middleware function.\n */\nexport function createInternalMethodsMiddleware(\n  hooks: InternalMethodsMiddlewareHooks,\n): JsonRpcMiddleware<JsonRpcParams, Json> {\n  // This should probably use createAsyncMiddleware.\n  // eslint-disable-next-line @typescript-eslint/no-misused-promises\n  return async function methodMiddleware(request, response, next, end) {\n    const handler =\n      methodHandlers[request.method as keyof typeof methodHandlers];\n    if (handler) {\n      try {\n        // Implementations may or may not be async, so we must await them.\n        return await handler(request, response, next, end, hooks);\n      } catch (error: any) {\n        logError(error);\n        return end(error);\n      }\n    }\n\n    return next();\n  };\n}\n"],"mappings":";;;;;;;;AACA,SAAS,gBAAgB;AAezB,IAAM,iBAAiB;AAAA;AAAA,EAErB,2BAA2B;AAAA,EAC3B,qBAAqB;AAAA,EACrB,cAAc;AAAA;AAEhB;AAaO,SAAS,gCACd,OACwC;AAGxC,SAAO,eAAe,iBAAiB,SAAS,UAAU,MAAM,KAAK;AACnE,UAAM,UACJ,eAAe,QAAQ,MAAqC;AAC9D,QAAI,SAAS;AACX,UAAI;AAEF,eAAO,MAAM,QAAQ,SAAS,UAAU,MAAM,KAAK,KAAK;AAAA,MAC1D,SAAS,OAAY;AACnB,iBAAS,KAAK;AACd,eAAO,IAAI,KAAK;AAAA,MAClB;AAAA,IACF;AAEA,WAAO,KAAK;AAAA,EACd;AACF;","names":[]}

package/dist/chunk-6RDNSELT.mjs

@@ -0,0 +1,39 @@
+import {
+  clearState,
+  getState,
+  setState
+} from "./chunk-VXQOXWRO.mjs";
+
+// src/internals/simulation/methods/hooks/state.ts
+import { put, select } from "redux-saga/effects";
+function* getSnapStateImplementation(_snapId, encrypted = true) {
+  return yield select(getState(encrypted));
+}
+function getGetSnapStateMethodImplementation(runSaga) {
+  return (...args) => {
+    return runSaga(getSnapStateImplementation, ...args).result();
+  };
+}
+function* updateSnapStateImplementation(_snapId, newState, encrypted = true) {
+  yield put(setState({ state: newState, encrypted }));
+}
+function getUpdateSnapStateMethodImplementation(runSaga) {
+  return (...args) => {
+    runSaga(updateSnapStateImplementation, ...args).result();
+  };
+}
+function* clearSnapStateImplementation(_snapId, encrypted = true) {
+  yield put(clearState({ encrypted }));
+}
+function getClearSnapStateMethodImplementation(runSaga) {
+  return async (...args) => {
+    runSaga(clearSnapStateImplementation, ...args).result();
+  };
+}
+
+export {
+  getGetSnapStateMethodImplementation,
+  getUpdateSnapStateMethodImplementation,
+  getClearSnapStateMethodImplementation
+};
+//# sourceMappingURL=chunk-6RDNSELT.mjs.map

package/dist/chunk-6RDNSELT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internals/simulation/methods/hooks/state.ts"],"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"],"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;","names":[]}

package/dist/chunk-72YN2D26.mjs

@@ -0,0 +1,60 @@
+import {
+  rootLogger
+} from "./chunk-WEI35OIM.mjs";
+
+// src/internals/server.ts
+import {
+  assertIsSnapManifest,
+  isDirectory,
+  isFile
+} from "@metamask/snaps-utils/node";
+import { createModuleLogger } from "@metamask/utils";
+import express from "express";
+import { promises as fs } from "fs";
+import { createServer } from "http";
+import { resolve as pathResolve } from "path";
+async function assertRoot(root) {
+  if (!root) {
+    throw new Error("You must specify a root directory.");
+  }
+  if (!await isDirectory(root, false)) {
+    throw new Error(`Root directory "${root}" is not a directory.`);
+  }
+  const manifestPath = pathResolve(root, "snap.manifest.json");
+  const manifest = await fs.readFile(manifestPath, "utf8").then(JSON.parse);
+  assertIsSnapManifest(manifest);
+  const filePath = pathResolve(root, manifest.source.location.npm.filePath);
+  if (!await isFile(filePath)) {
+    throw new Error(
+      `File "${filePath}" does not exist, or is not a file. Did you forget to build your snap?`
+    );
+  }
+}
+async function startServer(options) {
+  await assertRoot(options.root);
+  const log = createModuleLogger(rootLogger, "server");
+  const app = express();
+  app.use((_request, response, next) => {
+    response.header("Access-Control-Allow-Origin", "*");
+    response.header("Access-Control-Allow-Credentials", "true");
+    response.header("Access-Control-Allow-Methods", "GET, OPTIONS");
+    response.header("Access-Control-Allow-Headers", "Content-Type");
+    next();
+  });
+  app.use(express.static(pathResolve(process.cwd(), options.root)));
+  const server = createServer(app);
+  return await new Promise((resolve, reject) => {
+    server.listen(options.port, () => {
+      resolve(server);
+    });
+    server.on("error", (error) => {
+      log(error);
+      reject(error);
+    });
+  });
+}
+
+export {
+  startServer
+};
+//# sourceMappingURL=chunk-72YN2D26.mjs.map