@metamask/snaps-jest 5.0.0 → 6.0.1

package/dist/cjs/environment.js

@@ -1,144 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    SnapsEnvironment: function() {
-        return SnapsEnvironment;
-    },
-    default: function() {
-        return _default;
-    }
-});
-const _utils = require("@metamask/utils");
-const _jestenvironmentnode = /*#__PURE__*/ _interop_require_default(require("jest-environment-node"));
-const _internals = require("./internals");
-const _options = require("./options");
-function _check_private_redeclaration(obj, privateCollection) {
-    if (privateCollection.has(obj)) {
-        throw new TypeError("Cannot initialize the same private elements twice on an object");
-    }
-}
-function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
-    return descriptor.value;
-}
-function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
-        if (!descriptor.writable) {
-            throw new TypeError("attempted to set read only private field");
-        }
-        descriptor.value = value;
-    }
-}
-function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
-    return privateMap.get(receiver);
-}
-function _class_private_field_get(receiver, privateMap) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
-    return _class_apply_descriptor_get(receiver, descriptor);
-}
-function _class_private_field_init(obj, privateMap, value) {
-    _check_private_redeclaration(obj, privateMap);
-    privateMap.set(obj, value);
-}
-function _class_private_field_set(receiver, privateMap, value) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
-    _class_apply_descriptor_set(receiver, descriptor, value);
-    return value;
-}
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-/* eslint-enable */ const log = (0, _utils.createModuleLogger)(_internals.rootLogger, 'environment');
-var _options1 = /*#__PURE__*/ new WeakMap(), _server = /*#__PURE__*/ new WeakMap(), _instance = /*#__PURE__*/ new WeakMap();
-class SnapsEnvironment extends _jestenvironmentnode.default {
-    /**
-   * Set up the environment. This starts the built-in HTTP server, and creates a
-   * new browser instance.
-   */ async setup() {
-        await super.setup();
-        if (_class_private_field_get(this, _options1).server.enabled) {
-            log('Starting server.');
-            _class_private_field_set(this, _server, await (0, _internals.startServer)(_class_private_field_get(this, _options1).server));
-        }
-        this.global.snapsEnvironment = this;
-    }
-    /**
-   * Tear down the environment. This closes the browser, and stops the built-in
-   * HTTP server.
-   */ async teardown() {
-        await _class_private_field_get(this, _instance)?.executionService.terminateAllSnaps();
-        _class_private_field_get(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 _class_private_field_get(this, _instance)?.executionService.terminateAllSnaps();
-        _class_private_field_set(this, _instance, await (0, _internals.handleInstallSnap)(snapId, options));
-        return _class_private_field_get(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() {
-        (0, _utils.assert)(_class_private_field_get(this, _server), 'You must specify a snap ID, because the built-in server is not running.');
-        const { port } = _class_private_field_get(this, _server).address();
-        return `local:http://localhost:${port}`;
-    }
-    /**
-   * Constructor.
-   *
-   * @param options - The environment options.
-   * @param context - The environment context.
-   */ constructor(options, context){
-        super(options, context);
-        _class_private_field_init(this, _options1, {
-            writable: true,
-            value: void 0
-        });
-        _class_private_field_init(this, _server, {
-            writable: true,
-            value: void 0
-        });
-        _class_private_field_init(this, _instance, {
-            writable: true,
-            value: void 0
-        });
-        _class_private_field_set(this, _options1, (0, _options.getOptions)(options.projectConfig.testEnvironmentOptions));
-    }
-}
-const _default = SnapsEnvironment;
-
-//# sourceMappingURL=environment.js.map

package/dist/cjs/environment.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/environment.ts"],"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"],"names":["SnapsEnvironment","log","createModuleLogger","rootLogger","NodeEnvironment","setup","options","server","enabled","startServer","global","snapsEnvironment","teardown","instance","executionService","terminateAllSnaps","close","installSnap","snapId","handleInstallSnap","assert","port","address","constructor","context","getOptions","projectConfig","testEnvironmentOptions"],"mappings":";;;;;;;;;;;IAwBaA,gBAAgB;eAAhBA;;IAyFb,OAAgC;eAAhC;;;uBA3G2C;4EAEf;2BAI+B;yBAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAM3B,iBAAiB,GAEjB,MAAMC,MAAMC,IAAAA,yBAAkB,EAACC,qBAAU,EAAE;IAGzC,yCAEA,uCAEA;AALK,MAAMH,yBAAyBI,4BAAe;IAkBnD;;;GAGC,GACD,MAAMC,QAAQ;QACZ,MAAM,KAAK,CAACA;QAEZ,IAAI,yBAAA,IAAI,EAAEC,WAAQC,MAAM,CAACC,OAAO,EAAE;YAChCP,IAAI;2CACEM,SAAS,MAAME,IAAAA,sBAAW,EAAC,yBAAA,IAAI,EAAEH,WAAQC,MAAM;QACvD;QAEA,IAAI,CAACG,MAAM,CAACC,gBAAgB,GAAG,IAAI;IACrC;IAEA;;;GAGC,GACD,MAAMC,WAAW;QACf,+BAAM,IAAI,EAAEC,YAAUC,iBAAiBC;iCACvC,IAAI,EAAER,UAAQS;QACd,MAAM,KAAK,CAACJ;IACd;IAEA;;;;;;;;;;;;;GAaC,GACD,MAAMK,YAKJC,SAAiB,IAAI,CAACA,MAAM,EAC5BZ,UAAgD,CAAC,CAAC,EAClD;QACA,+BAAM,IAAI,EAAEO,YAAUC,iBAAiBC;uCACjCF,WAAW,MAAMM,IAAAA,4BAAiB,EAACD,QAAkBZ;QAC3D,gCAAO,IAAI,EAAEO;IACf;IAEA;;;;;;;GAOC,GACD,IAAIK,SAAS;QACXE,IAAAA,aAAM,2BACJ,IAAI,EAAEb,UACN;QAGF,MAAM,EAAEc,IAAI,EAAE,GAAG,yBAAA,IAAI,EAAEd,SAAOe,OAAO;QACrC,OAAO,CAAC,uBAAuB,EAAED,KAAK,CAAC;IACzC;IA/EA;;;;;GAKC,GACDE,YAAYjB,OAA8B,EAAEkB,OAA2B,CAAE;QACvE,KAAK,CAAClB,SAASkB;QAbjB,gCAAA;;mBAAA,KAAA;;QAEA,gCAAA;;mBAAA,KAAA;;QAEA,gCAAA;;mBAAA,KAAA;;uCAUQlB,WAAUmB,IAAAA,mBAAU,EAACnB,QAAQoB,aAAa,CAACC,sBAAsB;IACzE;AAuEF;MAEA,WAAe3B"}

package/dist/cjs/helpers.js

@@ -1,142 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "installSnap", {
-    enumerable: true,
-    get: function() {
-        return installSnap;
-    }
-});
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _superstruct = require("superstruct");
-const _internals = require("./internals");
-const _mocks = require("./internals/simulation/store/mocks");
-const log = (0, _utils.createModuleLogger)(_internals.rootLogger, 'helpers');
-/**
- * Get the options for {@link installSnap}.
- *
- * @param snapId - The ID of the Snap, or the options.
- * @param options - The options, if any.
- * @returns The options.
- */ function getOptions(snapId, options) {
-    if (typeof snapId === 'object') {
-        return [
-            undefined,
-            snapId
-        ];
-    }
-    return [
-        snapId,
-        options
-    ];
-}
-async function installSnap(snapId, options = {}) {
-    const resolvedOptions = getOptions(snapId, options);
-    const { snapId: installedSnapId, store, executionService, runSaga, controllerMessenger } = await (0, _internals.getEnvironment)().installSnap(...resolvedOptions);
-    const onTransaction = async (request)=>{
-        log('Sending transaction %o.', request);
-        const { origin: transactionOrigin, chainId, ...transaction } = (0, _superstruct.create)(request, _internals.TransactionOptionsStruct);
-        return (0, _internals.handleRequest)({
-            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 (0, _internals.handleRequest)({
-            snapId: installedSnapId,
-            store,
-            executionService,
-            controllerMessenger,
-            runSaga,
-            handler: _snapsutils.HandlerType.OnCronjob,
-            request
-        });
-    };
-    return {
-        request: (request)=>{
-            log('Sending request %o.', request);
-            return (0, _internals.handleRequest)({
-                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 } = (0, _superstruct.create)(request, _internals.SignatureOptionsStruct);
-            return (0, _internals.handleRequest)({
-                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 (0, _internals.handleRequest)({
-                snapId: installedSnapId,
-                store,
-                executionService,
-                controllerMessenger,
-                runSaga,
-                handler: _snapsutils.HandlerType.OnHomePage,
-                request: {
-                    method: ''
-                }
-            });
-        },
-        mockJsonRpc (mock) {
-            log('Mocking JSON-RPC request %o.', mock);
-            const { method, result } = (0, _superstruct.create)(mock, _internals.JsonRpcMockOptionsStruct);
-            store.dispatch((0, _mocks.addJsonRpcMock)({
-                method,
-                result
-            }));
-            return {
-                unmock () {
-                    log('Unmocking JSON-RPC request %o.', mock);
-                    store.dispatch((0, _mocks.removeJsonRpcMock)(method));
-                }
-            };
-        },
-        close: async ()=>{
-            log('Closing execution service.');
-            (0, _snapsutils.logInfo)('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();
-        }
-    };
-}
-
-//# sourceMappingURL=helpers.js.map

package/dist/cjs/helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/helpers.ts"],"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"],"names":["installSnap","log","createModuleLogger","rootLogger","getOptions","snapId","options","undefined","resolvedOptions","installedSnapId","store","executionService","runSaga","controllerMessenger","getEnvironment","onTransaction","request","origin","transactionOrigin","chainId","transaction","create","TransactionOptionsStruct","handleRequest","handler","HandlerType","OnTransaction","method","params","onCronjob","OnCronjob","OnRpcRequest","sendTransaction","onSignature","signatureOrigin","signature","SignatureOptionsStruct","OnSignature","runCronjob","onHomePage","OnHomePage","mockJsonRpc","mock","result","JsonRpcMockOptionsStruct","dispatch","addJsonRpcMock","unmock","removeJsonRpcMock","close","logInfo","terminateAllSnaps"],"mappings":";;;;+BAsLsBA;;;eAAAA;;;4BApLe;uBACF;6BACZ;2BAShB;uBAKA;AASP,MAAMC,MAAMC,IAAAA,yBAAkB,EAACC,qBAAU,EAAE;AAE3C;;;;;;CAMC,GACD,SAASC,WAKPC,MAAiE,EACjEC,OAA6C;IAE7C,IAAI,OAAOD,WAAW,UAAU;QAC9B,OAAO;YAACE;YAAWF;SAAO;IAC5B;IAEA,OAAO;QAACA;QAAQC;KAAQ;AAC1B;AAqIO,eAAeN,YAKpBK,MAAsD,EACtDC,UAAgD,CAAC,CAAC;IAElD,MAAME,kBAAkBJ,WAAWC,QAAQC;IAC3C,MAAM,EACJD,QAAQI,eAAe,EACvBC,KAAK,EACLC,gBAAgB,EAChBC,OAAO,EACPC,mBAAmB,EACpB,GAAG,MAAMC,IAAAA,yBAAc,IAAGd,WAAW,IAAIQ;IAE1C,MAAMO,gBAAgB,OACpBC;QAEAf,IAAI,2BAA2Be;QAE/B,MAAM,EACJC,QAAQC,iBAAiB,EACzBC,OAAO,EACP,GAAGC,aACJ,GAAGC,IAAAA,mBAAM,EAACL,SAASM,mCAAwB;QAE5C,OAAOC,IAAAA,wBAAa,EAAC;YACnBlB,QAAQI;YACRC;YACAC;YACAC;YACAC;YACAW,SAASC,uBAAW,CAACC,aAAa;YAClCV,SAAS;gBACPW,QAAQ;gBACRC,QAAQ;oBACNT;oBACAC;oBACAF;gBACF;YACF;QACF;IACF;IAEA,MAAMW,YAAY,CAACb;QACjBf,IAAI,uBAAuBK;QAE3B,OAAOiB,IAAAA,wBAAa,EAAC;YACnBlB,QAAQI;YACRC;YACAC;YACAE;YACAD;YACAY,SAASC,uBAAW,CAACK,SAAS;YAC9Bd;QACF;IACF;IAEA,OAAO;QACLA,SAAS,CAACA;YACRf,IAAI,uBAAuBe;YAE3B,OAAOO,IAAAA,wBAAa,EAAC;gBACnBlB,QAAQI;gBACRC;gBACAC;gBACAE;gBACAD;gBACAY,SAASC,uBAAW,CAACM,YAAY;gBACjCf;YACF;QACF;QAEAD;QACAiB,iBAAiBjB;QAEjBkB,aAAa,OAAOjB;YAClBf,IAAI,4BAA4Be;YAEhC,MAAM,EAAEC,QAAQiB,eAAe,EAAE,GAAGC,WAAW,GAAGd,IAAAA,mBAAM,EACtDL,SACAoB,iCAAsB;YAGxB,OAAOb,IAAAA,wBAAa,EAAC;gBACnBlB,QAAQI;gBACRC;gBACAC;gBACAE;gBACAD;gBACAY,SAASC,uBAAW,CAACY,WAAW;gBAChCrB,SAAS;oBACPW,QAAQ;oBACRC,QAAQ;wBACNO;wBACAD;oBACF;gBACF;YACF;QACF;QAEAL;QACAS,YAAYT;QAEZU,YAAY;YACVtC,IAAI;YAEJ,OAAOsB,IAAAA,wBAAa,EAAC;gBACnBlB,QAAQI;gBACRC;gBACAC;gBACAE;gBACAD;gBACAY,SAASC,uBAAW,CAACe,UAAU;gBAC/BxB,SAAS;oBACPW,QAAQ;gBACV;YACF;QACF;QAEAc,aAAYC,IAAwB;YAClCzC,IAAI,gCAAgCyC;YAEpC,MAAM,EAAEf,MAAM,EAAEgB,MAAM,EAAE,GAAGtB,IAAAA,mBAAM,EAACqB,MAAME,mCAAwB;YAChElC,MAAMmC,QAAQ,CAACC,IAAAA,qBAAc,EAAC;gBAAEnB;gBAAQgB;YAAO;YAE/C,OAAO;gBACLI;oBACE9C,IAAI,kCAAkCyC;oBAEtChC,MAAMmC,QAAQ,CAACG,IAAAA,wBAAiB,EAACrB;gBACnC;YACF;QACF;QAEAsB,OAAO;YACLhD,IAAI;YACJiD,IAAAA,mBAAO,EACL;YAGF,MAAMvC,iBAAiBwC,iBAAiB;QAC1C;IACF;AACF"}

package/dist/cjs/index.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    default: function() {
-        return _environment.default;
-    },
-    TestEnvironment: function() {
-        return _environment.default;
-    }
-});
-const _environment = /*#__PURE__*/ _interop_require_default(require("./environment"));
-_export_star(require("./helpers"), exports);
-_export_star(require("./options"), exports);
-_export_star(require("./types"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-
-//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export { default, default as TestEnvironment } from './environment';\nexport * from './helpers';\nexport * from './options';\nexport * from './types';\n"],"names":["default","TestEnvironment"],"mappings":";;;;;;;;;;;IAASA,OAAO;eAAPA,oBAAO;;IAAaC,eAAe;eAAfA,oBAAe;;;oEAAQ;qBACtC;qBACA;qBACA"}

package/dist/cjs/internals/environment.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "getEnvironment", {
-    enumerable: true,
-    get: function() {
-        return getEnvironment;
-    }
-});
-const _utils = require("@metamask/utils");
-function getEnvironment() {
-    // `snapsEnvironment` is a global variable that is set by the Jest
-    // environment.
-    (0, _utils.assert)(typeof snapsEnvironment !== 'undefined', 'Snaps environment not found. Make sure you have configured the environment correctly.');
-    return snapsEnvironment;
-}
-
-//# sourceMappingURL=environment.js.map

package/dist/cjs/internals/environment.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/internals/environment.ts"],"sourcesContent":["import { assert } from '@metamask/utils';\n\n/**\n * Get the Snaps environment. This asserts that the environment has been\n * configured.\n *\n * @returns The Snaps environment.\n */\nexport function getEnvironment() {\n  // `snapsEnvironment` is a global variable that is set by the Jest\n  // environment.\n  assert(\n    typeof snapsEnvironment !== 'undefined',\n    'Snaps environment not found. Make sure you have configured the environment correctly.',\n  );\n\n  return snapsEnvironment;\n}\n"],"names":["getEnvironment","assert","snapsEnvironment"],"mappings":";;;;+BAQgBA;;;eAAAA;;;uBARO;AAQhB,SAASA;IACd,kEAAkE;IAClE,eAAe;IACfC,IAAAA,aAAM,EACJ,OAAOC,qBAAqB,aAC5B;IAGF,OAAOA;AACT"}

package/dist/cjs/internals/index.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./environment"), exports);
-_export_star(require("./logger"), exports);
-_export_star(require("./request"), exports);
-_export_star(require("./server"), exports);
-_export_star(require("./simulation"), exports);
-_export_star(require("./structs"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
-
-//# sourceMappingURL=index.js.map

package/dist/cjs/internals/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/internals/index.ts"],"sourcesContent":["export * from './environment';\nexport * from './logger';\nexport * from './request';\nexport * from './server';\nexport * from './simulation';\nexport * from './structs';\n"],"names":[],"mappings":";;;;qBAAc;qBACA;qBACA;qBACA;qBACA;qBACA"}

package/dist/cjs/internals/logger.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "rootLogger", {
-    enumerable: true,
-    get: function() {
-        return rootLogger;
-    }
-});
-const _utils = require("@metamask/utils");
-const rootLogger = (0, _utils.createProjectLogger)('snaps-jest');
-
-//# sourceMappingURL=logger.js.map

package/dist/cjs/internals/logger.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/internals/logger.ts"],"sourcesContent":["import { createProjectLogger } from '@metamask/utils';\n\nexport const rootLogger = createProjectLogger('snaps-jest');\n"],"names":["rootLogger","createProjectLogger"],"mappings":";;;;+BAEaA;;;eAAAA;;;uBAFuB;AAE7B,MAAMA,aAAaC,IAAAA,0BAAmB,EAAC"}

package/dist/cjs/internals/request.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    handleRequest: function() {
-        return handleRequest;
-    },
-    getContentFromResult: function() {
-        return getContentFromResult;
-    }
-});
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _toolkit = require("@reduxjs/toolkit");
-const _simulation = require("./simulation");
-function handleRequest({ snapId, store, executionService, handler, controllerMessenger, runSaga, request: { id = (0, _toolkit.nanoid)(), origin = 'https://metamask.io', ...options } }) {
-    const promise = executionService.handleRpcRequest(snapId, {
-        origin,
-        handler,
-        request: {
-            jsonrpc: '2.0',
-            id: 1,
-            ...options
-        }
-    }).then((result)=>{
-        const notifications = (0, _simulation.getNotifications)(store.getState());
-        store.dispatch((0, _simulation.clearNotifications)());
-        const content = getContentFromResult(result, snapId, controllerMessenger);
-        return {
-            id: String(id),
-            response: {
-                result: (0, _utils.getSafeJson)(result)
-            },
-            notifications,
-            content
-        };
-    }).catch((error)=>{
-        const [unwrappedError] = (0, _snapsutils.unwrapError)(error);
-        return {
-            id: String(id),
-            response: {
-                error: unwrappedError.serialize()
-            },
-            notifications: []
-        };
-    });
-    promise.getInterface = async ()=>{
-        return await runSaga(_simulation.getInterface, runSaga, snapId, controllerMessenger).toPromise();
-    };
-    return promise;
-}
-function getContentFromResult(result, snapId, controllerMessenger) {
-    if ((0, _utils.isPlainObject)(result) && (0, _utils.hasProperty)(result, 'id')) {
-        return controllerMessenger.call('SnapInterfaceController:getInterface', snapId, result.id).content;
-    }
-    if ((0, _utils.isPlainObject)(result) && (0, _utils.hasProperty)(result, 'content')) {
-        return result.content;
-    }
-    return undefined;
-}
-
-//# sourceMappingURL=request.js.map

package/dist/cjs/internals/request.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/internals/request.ts"],"sourcesContent":["import type { AbstractExecutionService } from '@metamask/snaps-controllers';\nimport type { SnapId, Component } from '@metamask/snaps-sdk';\nimport type { HandlerType } from '@metamask/snaps-utils';\nimport { unwrapError } from '@metamask/snaps-utils';\nimport { getSafeJson, hasProperty, isPlainObject } from '@metamask/utils';\nimport { nanoid } from '@reduxjs/toolkit';\n\nimport type { 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"],"names":["handleRequest","getContentFromResult","snapId","store","executionService","handler","controllerMessenger","runSaga","request","id","nanoid","origin","options","promise","handleRpcRequest","jsonrpc","then","result","notifications","getNotifications","getState","dispatch","clearNotifications","content","String","response","getSafeJson","catch","error","unwrappedError","unwrapError","serialize","getInterface","toPromise","isPlainObject","hasProperty","call","undefined"],"mappings":";;;;;;;;;;;IA8CgBA,aAAa;eAAbA;;IAkEAC,oBAAoB;eAApBA;;;4BA7GY;uBAC4B;yBACjC;4BAOhB;AAkCA,SAASD,cAAc,EAC5BE,MAAM,EACNC,KAAK,EACLC,gBAAgB,EAChBC,OAAO,EACPC,mBAAmB,EACnBC,OAAO,EACPC,SAAS,EAAEC,KAAKC,IAAAA,eAAM,GAAE,EAAEC,SAAS,qBAAqB,EAAE,GAAGC,SAAS,EACjD;IACrB,MAAMC,UAAUT,iBACbU,gBAAgB,CAACZ,QAAQ;QACxBS;QACAN;QACAG,SAAS;YACPO,SAAS;YACTN,IAAI;YACJ,GAAGG,OAAO;QACZ;IACF,GACCI,IAAI,CAAC,CAACC;QACL,MAAMC,gBAAgBC,IAAAA,4BAAgB,EAAChB,MAAMiB,QAAQ;QACrDjB,MAAMkB,QAAQ,CAACC,IAAAA,8BAAkB;QAEjC,MAAMC,UAAUtB,qBAAqBgB,QAAQf,QAAQI;QAErD,OAAO;YACLG,IAAIe,OAAOf;YACXgB,UAAU;gBACRR,QAAQS,IAAAA,kBAAW,EAACT;YACtB;YACAC;YACAK;QACF;IACF,GACCI,KAAK,CAAC,CAACC;QACN,MAAM,CAACC,eAAe,GAAGC,IAAAA,uBAAW,EAACF;QAErC,OAAO;YACLnB,IAAIe,OAAOf;YACXgB,UAAU;gBACRG,OAAOC,eAAeE,SAAS;YACjC;YACAb,eAAe,EAAE;QACnB;IACF;IAEFL,QAAQmB,YAAY,GAAG;QACrB,OAAO,MAAMzB,QACXyB,wBAAY,EACZzB,SACAL,QACAI,qBACA2B,SAAS;IACb;IAEA,OAAOpB;AACT;AAUO,SAASZ,qBACdgB,MAAe,EACff,MAAc,EACdI,mBAA4C;IAE5C,IAAI4B,IAAAA,oBAAa,EAACjB,WAAWkB,IAAAA,kBAAW,EAAClB,QAAQ,OAAO;QACtD,OAAOX,oBAAoB8B,IAAI,CAC7B,wCACAlC,QACAe,OAAOR,EAAE,EACTc,OAAO;IACX;IAEA,IAAIW,IAAAA,oBAAa,EAACjB,WAAWkB,IAAAA,kBAAW,EAAClB,QAAQ,YAAY;QAC3D,OAAOA,OAAOM,OAAO;IACvB;IAEA,OAAOc;AACT"}

package/dist/cjs/internals/server.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "startServer", {
-    enumerable: true,
-    get: function() {
-        return startServer;
-    }
-});
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _express = /*#__PURE__*/ _interop_require_default(require("express"));
-const _fs = require("fs");
-const _http = require("http");
-const _path = require("path");
-const _logger = require("./logger");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-/**
- * Check that:
- *
- * - The root directory exists.
- * - The root directory contains a `snap.manifest.json` file.
- * - The file path in the manifest exists.
- *
- * @param root - The root directory.
- * @throws If any of the checks fail.
- */ async function assertRoot(root) {
-    if (!root) {
-        throw new Error('You must specify a root directory.');
-    }
-    if (!await (0, _snapsutils.isDirectory)(root, false)) {
-        throw new Error(`Root directory "${root}" is not a directory.`);
-    }
-    const manifestPath = (0, _path.resolve)(root, 'snap.manifest.json');
-    const manifest = await _fs.promises.readFile(manifestPath, 'utf8').then(JSON.parse);
-    (0, _snapsutils.assertIsSnapManifest)(manifest);
-    const filePath = (0, _path.resolve)(root, manifest.source.location.npm.filePath);
-    if (!await (0, _snapsutils.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 = (0, _utils.createModuleLogger)(_logger.rootLogger, 'server');
-    const app = (0, _express.default)();
-    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.default.static((0, _path.resolve)(process.cwd(), options.root)));
-    const server = (0, _http.createServer)(app);
-    return await new Promise((resolve, reject)=>{
-        server.listen(options.port, ()=>{
-            resolve(server);
-        });
-        server.on('error', (error)=>{
-            log(error);
-            reject(error);
-        });
-    });
-}
-
-//# sourceMappingURL=server.js.map

package/dist/cjs/internals/server.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/internals/server.ts"],"sourcesContent":["import type { SnapManifest } from '@metamask/snaps-utils';\nimport {\n  assertIsSnapManifest,\n  isDirectory,\n  isFile,\n} from '@metamask/snaps-utils';\nimport { createModuleLogger } from '@metamask/utils';\nimport express from 'express';\nimport { promises as fs } from 'fs';\nimport type { Server } from 'http';\nimport { createServer } from 'http';\nimport { resolve as pathResolve } from 'path';\n\nimport type { SnapsEnvironmentOptions } from '../options';\nimport { rootLogger } from './logger';\n\nexport type ServerOptions = Required<\n  // We need a double `Required` for the type to be inferred correctly.\n  Required<SnapsEnvironmentOptions>['server']\n>;\n\n/**\n * Check that:\n *\n * - The root directory exists.\n * - The root directory contains a `snap.manifest.json` file.\n * - The file path in the manifest exists.\n *\n * @param root - The root directory.\n * @throws If any of the checks fail.\n */\nasync function assertRoot(root: string) {\n  if (!root) {\n    throw new Error('You must specify a root directory.');\n  }\n\n  if (!(await isDirectory(root, false))) {\n    throw new Error(`Root directory \"${root}\" is not a directory.`);\n  }\n\n  const manifestPath = pathResolve(root, 'snap.manifest.json');\n  const manifest: SnapManifest = await fs\n    .readFile(manifestPath, 'utf8')\n    .then(JSON.parse);\n\n  assertIsSnapManifest(manifest);\n  const filePath = pathResolve(root, manifest.source.location.npm.filePath);\n\n  if (!(await isFile(filePath))) {\n    throw new Error(\n      `File \"${filePath}\" does not exist, or is not a file. Did you forget to build your snap?`,\n    );\n  }\n}\n\n/**\n * Start an HTTP server on `localhost` with a random port. This is used to serve\n * the static files for the environment.\n *\n * @param options - The options to use.\n * @param options.port - The port to use for the server.\n * @param options.root - The root directory to serve from the server.\n * @returns The HTTP server.\n */\nexport async function startServer(options: ServerOptions) {\n  await assertRoot(options.root);\n\n  const log = createModuleLogger(rootLogger, 'server');\n  const app = express();\n\n  app.use((_request, response, next) => {\n    response.header('Access-Control-Allow-Origin', '*');\n    response.header('Access-Control-Allow-Credentials', 'true');\n    response.header('Access-Control-Allow-Methods', 'GET, OPTIONS');\n    response.header('Access-Control-Allow-Headers', 'Content-Type');\n\n    next();\n  });\n\n  app.use(express.static(pathResolve(process.cwd(), options.root)));\n\n  const server = createServer(app);\n  return await new Promise<Server>((resolve, reject) => {\n    server.listen(options.port, () => {\n      resolve(server);\n    });\n\n    server.on('error', (error) => {\n      log(error);\n      reject(error);\n    });\n  });\n}\n"],"names":["startServer","assertRoot","root","Error","isDirectory","manifestPath","pathResolve","manifest","fs","readFile","then","JSON","parse","assertIsSnapManifest","filePath","source","location","npm","isFile","options","log","createModuleLogger","rootLogger","app","express","use","_request","response","next","header","static","process","cwd","server","createServer","Promise","resolve","reject","listen","port","on","error"],"mappings":";;;;+BAgEsBA;;;eAAAA;;;4BA3Df;uBAC4B;gEACf;oBACW;sBAEF;sBACU;wBAGZ;;;;;;AAO3B;;;;;;;;;CASC,GACD,eAAeC,WAAWC,IAAY;IACpC,IAAI,CAACA,MAAM;QACT,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAI,CAAE,MAAMC,IAAAA,uBAAW,EAACF,MAAM,QAAS;QACrC,MAAM,IAAIC,MAAM,CAAC,gBAAgB,EAAED,KAAK,qBAAqB,CAAC;IAChE;IAEA,MAAMG,eAAeC,IAAAA,aAAW,EAACJ,MAAM;IACvC,MAAMK,WAAyB,MAAMC,YAAE,CACpCC,QAAQ,CAACJ,cAAc,QACvBK,IAAI,CAACC,KAAKC,KAAK;IAElBC,IAAAA,gCAAoB,EAACN;IACrB,MAAMO,WAAWR,IAAAA,aAAW,EAACJ,MAAMK,SAASQ,MAAM,CAACC,QAAQ,CAACC,GAAG,CAACH,QAAQ;IAExE,IAAI,CAAE,MAAMI,IAAAA,kBAAM,EAACJ,WAAY;QAC7B,MAAM,IAAIX,MACR,CAAC,MAAM,EAAEW,SAAS,sEAAsE,CAAC;IAE7F;AACF;AAWO,eAAed,YAAYmB,OAAsB;IACtD,MAAMlB,WAAWkB,QAAQjB,IAAI;IAE7B,MAAMkB,MAAMC,IAAAA,yBAAkB,EAACC,kBAAU,EAAE;IAC3C,MAAMC,MAAMC,IAAAA,gBAAO;IAEnBD,IAAIE,GAAG,CAAC,CAACC,UAAUC,UAAUC;QAC3BD,SAASE,MAAM,CAAC,+BAA+B;QAC/CF,SAASE,MAAM,CAAC,oCAAoC;QACpDF,SAASE,MAAM,CAAC,gCAAgC;QAChDF,SAASE,MAAM,CAAC,gCAAgC;QAEhDD;IACF;IAEAL,IAAIE,GAAG,CAACD,gBAAO,CAACM,MAAM,CAACxB,IAAAA,aAAW,EAACyB,QAAQC,GAAG,IAAIb,QAAQjB,IAAI;IAE9D,MAAM+B,SAASC,IAAAA,kBAAY,EAACX;IAC5B,OAAO,MAAM,IAAIY,QAAgB,CAACC,SAASC;QACzCJ,OAAOK,MAAM,CAACnB,QAAQoB,IAAI,EAAE;YAC1BH,QAAQH;QACV;QAEAA,OAAOO,EAAE,CAAC,SAAS,CAACC;YAClBrB,IAAIqB;YACJJ,OAAOI;QACT;IACF;AACF"}

package/dist/cjs/internals/simulation/constants.js

@@ -1,29 +0,0 @@
-/**
- * A secret recovery phrase that is used for testing purposes. Do not use this
- * to store any real funds!
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    DEFAULT_SRP: function() {
-        return DEFAULT_SRP;
-    },
-    DEFAULT_LOCALE: function() {
-        return DEFAULT_LOCALE;
-    },
-    DEFAULT_JSON_RPC_ENDPOINT: function() {
-        return DEFAULT_JSON_RPC_ENDPOINT;
-    }
-});
-const DEFAULT_SRP = 'test test test test test test test test test test test ball';
-const DEFAULT_LOCALE = 'en';
-const DEFAULT_JSON_RPC_ENDPOINT = 'https://cloudflare-eth.com/';
-
-//# sourceMappingURL=constants.js.map

package/dist/cjs/internals/simulation/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/internals/simulation/constants.ts"],"sourcesContent":["/**\n * A secret recovery phrase that is used for testing purposes. Do not use this\n * to store any real funds!\n */\nexport const DEFAULT_SRP =\n  'test test test test test test test test test test test ball';\n\n/**\n * The default locale.\n */\nexport const DEFAULT_LOCALE = 'en';\n\n/**\n * The default JSON-RPC endpoint for Ethereum requests.\n */\nexport const DEFAULT_JSON_RPC_ENDPOINT = 'https://cloudflare-eth.com/';\n"],"names":["DEFAULT_SRP","DEFAULT_LOCALE","DEFAULT_JSON_RPC_ENDPOINT"],"mappings":"AAAA;;;CAGC;;;;;;;;;;;IACYA,WAAW;eAAXA;;IAMAC,cAAc;eAAdA;;IAKAC,yBAAyB;eAAzBA;;;AAXN,MAAMF,cACX;AAKK,MAAMC,iBAAiB;AAKvB,MAAMC,4BAA4B"}