@metamask/snaps-jest 4.0.0 → 5.0.0

package/dist/cjs/options.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/options.ts"],"sourcesContent":["import type { Infer } from 'superstruct';\nimport {\n  boolean,\n  create,\n  defaulted,\n  number,\n  object,\n  optional,\n  string,\n  type,\n} from 'superstruct';\n\nconst SnapsEnvironmentOptionsStruct = type({\n  executionEnvironmentUrl: optional(string()),\n  simulatorUrl: optional(string()),\n  keepAlive: defaulted(boolean(), false),\n\n  server: defaulted(\n    object({\n      enabled: defaulted(boolean(), true),\n      port: defaulted(number(), 0),\n      root: defaulted(string(), process.cwd()),\n    }),\n    {},\n  ),\n\n  browser: defaulted(\n    object({\n      headless: defaulted(boolean(), true),\n    }),\n    {},\n  ),\n});\n\n/**\n * The options for the environment. These can be specified in the Jest\n * configuration under `testEnvironmentOptions`.\n *\n * @example\n * ```json\n * {\n *   \"testEnvironment\": \"@metamask/snaps-jest\",\n *   \"testEnvironmentOptions\": {\n *     \"executionEnvironmentUrl\": \"http://localhost:8080\",\n *     \"server\": {\n *       \"port\": 8080,\n *       /* ... *\\/\n *     }\n *   }\n * }\n * ```\n * @property executionEnvironmentUrl - The URL of the execution environment. If\n * this is not provided, the execution environment will be served from the\n * built-in HTTP server.\n * @property simulatorUrl - The URL of the simulator. If this is not provided,\n * the simulator will be served from the built-in HTTP server.\n * @property keepAlive - Whether to keep the browser open after the tests have\n * finished. This is useful for debugging. Defaults to `false`.\n * @property server - The options for the built-in HTTP server.\n * @property server.enabled - Whether to run the built-in HTTP server. Defaults\n * to `true`.\n * @property server.port - The port to use for the built-in HTTP server. If this\n * is not provided, a random available port will be used.\n * @property server.root - The root directory to serve from the built-in HTTP\n * server. Defaults to the current working directory. This is assumed to be the\n * directory containing the snap manifest and `dist` files. If this is a\n * relative path, it will be resolved relative to the current working directory.\n * @property browser - The options for the browser.\n * @property browser.headless - Whether to run the browser in headless mode.\n * Defaults to `true`.\n */\nexport type SnapsEnvironmentOptions = Infer<\n  typeof SnapsEnvironmentOptionsStruct\n>;\n\n/**\n * Get the environment options. This validates the options, and returns the\n * default options if none are provided.\n *\n * @param testEnvironmentOptions - The test environment options as defined in\n * the Jest configuration.\n * @returns The environment options.\n */\nexport function getOptions(testEnvironmentOptions: Record<string, unknown>) {\n  return create(testEnvironmentOptions, SnapsEnvironmentOptionsStruct);\n}\n"],"names":["getOptions","SnapsEnvironmentOptionsStruct","type","executionEnvironmentUrl","optional","string","simulatorUrl","keepAlive","defaulted","boolean","server","object","enabled","port","number","root","process","cwd","browser","headless","testEnvironmentOptions","create"],"mappings":";;;;+BAmFgBA;;;eAAAA;;;6BAzET;AAEP,MAAMC,gCAAgCC,IAAAA,iBAAI,EAAC;IACzCC,yBAAyBC,IAAAA,qBAAQ,EAACC,IAAAA,mBAAM;IACxCC,cAAcF,IAAAA,qBAAQ,EAACC,IAAAA,mBAAM;IAC7BE,WAAWC,IAAAA,sBAAS,EAACC,IAAAA,oBAAO,KAAI;IAEhCC,QAAQF,IAAAA,sBAAS,EACfG,IAAAA,mBAAM,EAAC;QACLC,SAASJ,IAAAA,sBAAS,EAACC,IAAAA,oBAAO,KAAI;QAC9BI,MAAML,IAAAA,sBAAS,EAACM,IAAAA,mBAAM,KAAI;QAC1BC,MAAMP,IAAAA,sBAAS,EAACH,IAAAA,mBAAM,KAAIW,QAAQC,GAAG;IACvC,IACA,CAAC;IAGHC,SAASV,IAAAA,sBAAS,EAChBG,IAAAA,mBAAM,EAAC;QACLQ,UAAUX,IAAAA,sBAAS,EAACC,IAAAA,oBAAO,KAAI;IACjC,IACA,CAAC;AAEL;AAmDO,SAAST,WAAWoB,sBAA+C;IACxE,OAAOC,IAAAA,mBAAM,EAACD,wBAAwBnB;AACxC"}
+{"version":3,"sources":["../../src/options.ts"],"sourcesContent":["import type { Infer } from 'superstruct';\nimport {\n  boolean,\n  create,\n  defaulted,\n  number,\n  object,\n  string,\n  type,\n} from 'superstruct';\n\nconst SnapsEnvironmentOptionsStruct = type({\n  server: defaulted(\n    object({\n      enabled: defaulted(boolean(), true),\n      port: defaulted(number(), 0),\n      root: defaulted(string(), process.cwd()),\n    }),\n    {},\n  ),\n});\n\n/**\n * The options for the environment. These can be specified in the Jest\n * configuration under `testEnvironmentOptions`.\n *\n * @example\n * {\n *   \"testEnvironment\": \"@metamask/snaps-jest\",\n *   \"testEnvironmentOptions\": {\n *     \"executionEnvironmentUrl\": \"http://localhost:8080\",\n *     \"server\": {\n *       \"port\": 8080,\n *       /* ... *\\/\n *     }\n *   }\n * }\n * @property server - The options for the built-in HTTP server.\n * @property server.enabled - Whether to run the built-in HTTP server. Defaults\n * to `true`.\n * @property server.port - The port to use for the built-in HTTP server. If this\n * is not provided, a random available port will be used.\n * @property server.root - The root directory to serve from the built-in HTTP\n * server. Defaults to the current working directory. This is assumed to be the\n * directory containing the snap manifest and `dist` files. If this is a\n * relative path, it will be resolved relative to the current working directory.\n */\nexport type SnapsEnvironmentOptions = Infer<\n  typeof SnapsEnvironmentOptionsStruct\n>;\n\n/**\n * Get the environment options. This validates the options, and returns the\n * default options if none are provided.\n *\n * @param testEnvironmentOptions - The test environment options as defined in\n * the Jest configuration.\n * @returns The environment options.\n */\nexport function getOptions(testEnvironmentOptions: Record<string, unknown>) {\n  return create(testEnvironmentOptions, SnapsEnvironmentOptionsStruct);\n}\n"],"names":["getOptions","SnapsEnvironmentOptionsStruct","type","server","defaulted","object","enabled","boolean","port","number","root","string","process","cwd","testEnvironmentOptions","create"],"mappings":";;;;+BA2DgBA;;;eAAAA;;;6BAlDT;AAEP,MAAMC,gCAAgCC,IAAAA,iBAAI,EAAC;IACzCC,QAAQC,IAAAA,sBAAS,EACfC,IAAAA,mBAAM,EAAC;QACLC,SAASF,IAAAA,sBAAS,EAACG,IAAAA,oBAAO,KAAI;QAC9BC,MAAMJ,IAAAA,sBAAS,EAACK,IAAAA,mBAAM,KAAI;QAC1BC,MAAMN,IAAAA,sBAAS,EAACO,IAAAA,mBAAM,KAAIC,QAAQC,GAAG;IACvC,IACA,CAAC;AAEL;AAuCO,SAASb,WAAWc,sBAA+C;IACxE,OAAOC,IAAAA,mBAAM,EAACD,wBAAwBb;AACxC"}

package/dist/esm/environment.js

@@ -38,26 +38,12 @@ function _class_private_field_set(receiver, privateMap, value) {
     _class_apply_descriptor_set(receiver, descriptor, value);
     return value;
 }
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
 import { assert, createModuleLogger } from '@metamask/utils';
 import NodeEnvironment from 'jest-environment-node';
-import { remote } from 'webdriverio';
-import { rootLogger, startServer } from './internals';
+import { handleInstallSnap, rootLogger, startServer } from './internals';
 import { getOptions } from './options';
 /* eslint-enable */ const log = createModuleLogger(rootLogger, 'environment');
-var _options = /*#__PURE__*/ new WeakMap(), _server = /*#__PURE__*/ new WeakMap();
+var _options = /*#__PURE__*/ new WeakMap(), _server = /*#__PURE__*/ new WeakMap(), _instance = /*#__PURE__*/ new WeakMap();
 export class SnapsEnvironment extends NodeEnvironment {
     /**
    * Set up the environment. This starts the built-in HTTP server, and creates a
@@ -68,48 +54,33 @@ export class SnapsEnvironment extends NodeEnvironment {
             log('Starting server.');
             _class_private_field_set(this, _server, await startServer(_class_private_field_get(this, _options).server));
         }
-        const args = [];
-        if (_class_private_field_get(this, _options).browser.headless) {
-            args.push('--headless', '--disable-gpu');
-        }
-        log('Starting browser.');
-        this.browser = await remote({
-            logLevel: 'error',
-            capabilities: {
-                browserName: 'chrome',
-                // eslint-disable-next-line @typescript-eslint/naming-convention
-                'goog:chromeOptions': {
-                    args
-                }
-            }
-        });
-        this.global.browser = this.browser;
         this.global.snapsEnvironment = this;
     }
     /**
    * Tear down the environment. This closes the browser, and stops the built-in
    * HTTP server.
    */ async teardown() {
-        if (_class_private_field_get(this, _options).keepAlive) {
-            log('Not tearing down environment because keepAlive is enabled.');
-            return;
-        }
-        log('Closing browser, and stopping server.');
-        await this.browser?.deleteSession();
+        await _class_private_field_get(this, _instance)?.executionService.terminateAllSnaps();
         _class_private_field_get(this, _server)?.close();
         await super.teardown();
     }
     /**
-   * Get the URL to the simulator, including the environment URL.
+   * Install a Snap in the environment. This will terminate any previously
+   * installed Snaps, and run the Snap code in a new execution service.
    *
-   * @returns The simulator URL.
-   * @throws If the server is not running.
-   */ get url() {
-        assert(_class_private_field_get(this, _server), 'Server is not running.');
-        const { port } = _class_private_field_get(this, _server).address();
-        const simulatorUrl = _class_private_field_get(this, _options).simulatorUrl ?? `http://localhost:${port}/simulator/`;
-        const executionEnvironmentUrl = _class_private_field_get(this, _options).executionEnvironmentUrl ?? `http://localhost:${port}/environment/`;
-        return `${simulatorUrl}?environment=${encodeURIComponent(executionEnvironmentUrl)}`;
+   * @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 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
@@ -124,48 +95,12 @@ export class SnapsEnvironment extends NodeEnvironment {
         return `local:http://localhost:${port}`;
     }
     /**
-   * Create a new page, and attach logging handlers.
-   *
-   * @param url - The page URL. Defaults to the specified Snaps Simulator URL,
-   * or the default simulator URL if none is specified.
-   * @param timeout - The page timeout, in milliseconds.
-   * @returns The new page.
-   */ async createPage(url = this.url, timeout = 10000) {
-        const puppeteer = await this.browser.getPuppeteer();
-        const page = await puppeteer.newPage();
-        page.setDefaultTimeout(timeout);
-        page.setDefaultNavigationTimeout(timeout);
-        // Give the page permission to show notifications. This is required for
-        // testing `snap_notify`.
-        await page.browserContext().overridePermissions(url, [
-            'notifications'
-        ]);
-        // `networkidle0` is used to ensure that the page is fully loaded. This
-        // makes it wait for no requests to be made, which guarantees that the page
-        // is ready.
-        await page.goto(url, {
-            waitUntil: 'networkidle0'
-        });
-        const browserLog = createModuleLogger(rootLogger, 'browser');
-        page// This is fired when the page calls `console.log` or similar.
-        .on('console', (message)=>{
-            browserLog(`[${message.type()}] ${message.text()}`);
-        })// This is fired when the page throws an error.
-        .on('pageerror', ({ message })=>{
-            browserLog(`[page error] ${message}`);
-        });
-        return page;
-    }
-    /**
    * Constructor.
    *
    * @param options - The environment options.
    * @param context - The environment context.
    */ constructor(options, context){
         super(options, context);
-        // `browser` is always set in the environment setup function. To avoid needing
-        // to check for `undefined` everywhere, we use a type assertion here.
-        _define_property(this, "browser", void 0);
         _class_private_field_init(this, _options, {
             writable: true,
             value: void 0
@@ -174,6 +109,10 @@ export class SnapsEnvironment extends NodeEnvironment {
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _instance, {
+            writable: true,
+            value: void 0
+        });
         _class_private_field_set(this, _options, getOptions(options.projectConfig.testEnvironmentOptions));
     }
 }

package/dist/esm/environment.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/environment.ts"],"sourcesContent":["import type {\n  EnvironmentContext,\n  JestEnvironmentConfig,\n} from '@jest/environment';\nimport { assert, createModuleLogger } from '@metamask/utils';\nimport type { Server } from 'http';\nimport NodeEnvironment from 'jest-environment-node';\nimport type { AddressInfo } from 'net';\nimport type { Browser } from 'puppeteer';\nimport { remote } from 'webdriverio';\n\nimport { rootLogger, startServer } from './internals';\nimport type { SnapsEnvironmentOptions } from './options';\nimport { getOptions } from './options';\n\n/* eslint-disable */\ndeclare global {\n  const browser: WebdriverIO.Browser;\n  const snapsEnvironment: SnapsEnvironment;\n}\n/* eslint-enable */\n\nconst log = createModuleLogger(rootLogger, 'environment');\n\nexport class SnapsEnvironment extends NodeEnvironment {\n  // `browser` is always set in the environment setup function. To avoid needing\n  // to check for `undefined` everywhere, we use a type assertion here.\n  browser!: WebdriverIO.Browser;\n\n  #options: SnapsEnvironmentOptions;\n\n  #server: Server | 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    const args = [];\n    if (this.#options.browser.headless) {\n      args.push('--headless', '--disable-gpu');\n    }\n\n    log('Starting browser.');\n    this.browser = await remote({\n      logLevel: 'error',\n      capabilities: {\n        browserName: 'chrome',\n        // eslint-disable-next-line @typescript-eslint/naming-convention\n        'goog:chromeOptions': {\n          args,\n        },\n      },\n    });\n\n    this.global.browser = this.browser;\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    if (this.#options.keepAlive) {\n      log('Not tearing down environment because keepAlive is enabled.');\n      return;\n    }\n\n    log('Closing browser, and stopping server.');\n    await this.browser?.deleteSession();\n    this.#server?.close();\n\n    await super.teardown();\n  }\n\n  /**\n   * Get the URL to the simulator, including the environment URL.\n   *\n   * @returns The simulator URL.\n   * @throws If the server is not running.\n   */\n  get url() {\n    assert(this.#server, 'Server is not running.');\n\n    const { port } = this.#server.address() as AddressInfo;\n    const simulatorUrl =\n      this.#options.simulatorUrl ?? `http://localhost:${port}/simulator/`;\n\n    const executionEnvironmentUrl =\n      this.#options.executionEnvironmentUrl ??\n      `http://localhost:${port}/environment/`;\n\n    return `${simulatorUrl}?environment=${encodeURIComponent(\n      executionEnvironmentUrl,\n    )}`;\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  /**\n   * Create a new page, and attach logging handlers.\n   *\n   * @param url - The page URL. Defaults to the specified Snaps Simulator URL,\n   * or the default simulator URL if none is specified.\n   * @param timeout - The page timeout, in milliseconds.\n   * @returns The new page.\n   */\n  async createPage(url: string = this.url, timeout = 10000) {\n    const puppeteer = (await this.browser.getPuppeteer()) as unknown as Browser;\n    const page = await puppeteer.newPage();\n\n    page.setDefaultTimeout(timeout);\n    page.setDefaultNavigationTimeout(timeout);\n\n    // Give the page permission to show notifications. This is required for\n    // testing `snap_notify`.\n    await page.browserContext().overridePermissions(url, ['notifications']);\n\n    // `networkidle0` is used to ensure that the page is fully loaded. This\n    // makes it wait for no requests to be made, which guarantees that the page\n    // is ready.\n    await page.goto(url, { waitUntil: 'networkidle0' });\n\n    const browserLog = createModuleLogger(rootLogger, 'browser');\n\n    page\n      // This is fired when the page calls `console.log` or similar.\n      .on('console', (message) => {\n        browserLog(`[${message.type()}] ${message.text()}`);\n      })\n\n      // This is fired when the page throws an error.\n      .on('pageerror', ({ message }) => {\n        browserLog(`[page error] ${message}`);\n      });\n\n    return page;\n  }\n}\n\nexport default SnapsEnvironment;\n"],"names":["assert","createModuleLogger","NodeEnvironment","remote","rootLogger","startServer","getOptions","log","SnapsEnvironment","setup","options","server","enabled","args","browser","headless","push","logLevel","capabilities","browserName","global","snapsEnvironment","teardown","keepAlive","deleteSession","close","url","port","address","simulatorUrl","executionEnvironmentUrl","encodeURIComponent","snapId","createPage","timeout","puppeteer","getPuppeteer","page","newPage","setDefaultTimeout","setDefaultNavigationTimeout","browserContext","overridePermissions","goto","waitUntil","browserLog","on","message","type","text","constructor","context","projectConfig","testEnvironmentOptions"],"mappings":"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"}
+{"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":["assert","createModuleLogger","NodeEnvironment","handleInstallSnap","rootLogger","startServer","getOptions","log","SnapsEnvironment","setup","options","server","enabled","global","snapsEnvironment","teardown","instance","executionService","terminateAllSnaps","close","installSnap","snapId","port","address","constructor","context","projectConfig","testEnvironmentOptions"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,SAASA,MAAM,EAAEC,kBAAkB,QAAQ,kBAAkB;AAE7D,OAAOC,qBAAqB,wBAAwB;AAIpD,SAASC,iBAAiB,EAAEC,UAAU,EAAEC,WAAW,QAAQ,cAAc;AAEzE,SAASC,UAAU,QAAQ,YAAY;AAMvC,iBAAiB,GAEjB,MAAMC,MAAMN,mBAAmBG,YAAY;IAGzC,wCAEA,uCAEA;AALF,OAAO,MAAMI,yBAAyBN;IAkBpC;;;GAGC,GACD,MAAMO,QAAQ;QACZ,MAAM,KAAK,CAACA;QAEZ,IAAI,yBAAA,IAAI,EAAEC,UAAQC,MAAM,CAACC,OAAO,EAAE;YAChCL,IAAI;2CACEI,SAAS,MAAMN,YAAY,yBAAA,IAAI,EAAEK,UAAQC,MAAM;QACvD;QAEA,IAAI,CAACE,MAAM,CAACC,gBAAgB,GAAG,IAAI;IACrC;IAEA;;;GAGC,GACD,MAAMC,WAAW;QACf,+BAAM,IAAI,EAAEC,YAAUC,iBAAiBC;iCACvC,IAAI,EAAEP,UAAQQ;QACd,MAAM,KAAK,CAACJ;IACd;IAEA;;;;;;;;;;;;;GAaC,GACD,MAAMK,YAKJC,SAAiB,IAAI,CAACA,MAAM,EAC5BX,UAAgD,CAAC,CAAC,EAClD;QACA,+BAAM,IAAI,EAAEM,YAAUC,iBAAiBC;uCACjCF,WAAW,MAAMb,kBAAkBkB,QAAkBX;QAC3D,gCAAO,IAAI,EAAEM;IACf;IAEA;;;;;;;GAOC,GACD,IAAIK,SAAS;QACXrB,gCACE,IAAI,EAAEW,UACN;QAGF,MAAM,EAAEW,IAAI,EAAE,GAAG,yBAAA,IAAI,EAAEX,SAAOY,OAAO;QACrC,OAAO,CAAC,uBAAuB,EAAED,KAAK,CAAC;IACzC;IA/EA;;;;;GAKC,GACDE,YAAYd,OAA8B,EAAEe,OAA2B,CAAE;QACvE,KAAK,CAACf,SAASe;QAbjB,gCAAA;;mBAAA,KAAA;;QAEA,gCAAA;;mBAAA,KAAA;;QAEA,gCAAA;;mBAAA,KAAA;;uCAUQf,UAAUJ,WAAWI,QAAQgB,aAAa,CAACC,sBAAsB;IACzE;AAuEF;AAEA,eAAenB,iBAAiB"}

package/dist/esm/helpers.js

@@ -1,16 +1,33 @@
+import { HandlerType, logInfo } from '@metamask/snaps-utils';
 import { createModuleLogger } from '@metamask/utils';
-import { getDocument, queries } from 'pptr-testing-library';
-import { getEnvironment, mock, waitFor, request, sendTransaction, runCronjob, mockJsonRpc, rootLogger } from './internals';
-// eslint-disable-next-line @typescript-eslint/unbound-method
-const { getByTestId } = queries;
+import { create } from 'superstruct';
+import { rootLogger, handleRequest, TransactionOptionsStruct, getEnvironment, JsonRpcMockOptionsStruct, SignatureOptionsStruct } from './internals';
+import { addJsonRpcMock, removeJsonRpcMock } from './internals/simulation/store/mocks';
 const log = createModuleLogger(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
+    ];
+}
 /**
  * Load a snap into the environment. This is the main entry point for testing
  * snaps: It returns a {@link Snap} object that can be used to interact with the
  * snap.
  *
  * @example
- * ```ts
  * import { installSnap } from '@metamask/snaps-jest';
  *
  * describe('My Snap', () => {
@@ -23,58 +40,122 @@ const log = createModuleLogger(rootLogger, 'helpers');
  *     expect(response).toRespondWith('bar');
  *   });
  * });
- * ```
  * @param snapId - The ID of the snap, including the prefix (`local:`). Defaults
  * to the URL of the built-in server, if it is running. This supports both
  * local snap IDs and NPM snap IDs.
+ * @param options - The options to use.
+ * @param options.executionService - The execution service to use. Defaults to
+ * {@link NodeThreadExecutionService}. You do not need to provide this unless
+ * you are testing a custom execution service.
+ * @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.
  * @returns The snap.
  * @throws If the built-in server is not running, and no snap ID is provided.
- */ export async function installSnap(snapId = getEnvironment().snapId) {
-    const environment = getEnvironment();
-    log('Installing snap %s.', snapId);
-    const page = await environment.createPage();
-    const document = await getDocument(page);
-    log('Setting snap ID to %s.', snapId);
-    await page.evaluate((payload)=>{
-        window.__SIMULATOR_API__.dispatch({
-            type: 'configuration/setSnapId',
-            payload
+ */ export async function installSnap(snapId, options = {}) {
+    const resolvedOptions = getOptions(snapId, options);
+    const { snapId: installedSnapId, store, executionService, runSaga, controllerMessenger } = await getEnvironment().installSnap(...resolvedOptions);
+    const onTransaction = async (request)=>{
+        log('Sending transaction %o.', request);
+        const { origin: transactionOrigin, chainId, ...transaction } = create(request, TransactionOptionsStruct);
+        return handleRequest({
+            snapId: installedSnapId,
+            store,
+            executionService,
+            runSaga,
+            controllerMessenger,
+            handler: HandlerType.OnTransaction,
+            request: {
+                method: '',
+                params: {
+                    chainId,
+                    transaction,
+                    transactionOrigin
+                }
+            }
+        });
+    };
+    const onCronjob = (request)=>{
+        log('Running cronjob %o.', options);
+        return handleRequest({
+            snapId: installedSnapId,
+            store,
+            executionService,
+            controllerMessenger,
+            runSaga,
+            handler: HandlerType.OnCronjob,
+            request
         });
-    }, snapId);
-    log('Waiting for snap to install.');
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    await waitFor(async ()=>await getByTestId(document, 'status-ok'), {
-        timeout: 10000,
-        message: `Timed out waiting for snap to install. Make sure the snap ID ("${snapId}") is correct, and the server is running.`
-    });
+    };
     return {
-        request: (options)=>{
-            log('Sending request %o.', options);
-            // Note: This function is intentionally not async, so that we can access
-            // the `getInterface` method on the response.
-            return request(page, options);
-        },
-        sendTransaction: async (options = {})=>{
-            log('Sending transaction %o.', options);
-            return await sendTransaction(page, options);
+        request: (request)=>{
+            log('Sending request %o.', request);
+            return handleRequest({
+                snapId: installedSnapId,
+                store,
+                executionService,
+                controllerMessenger,
+                runSaga,
+                handler: HandlerType.OnRpcRequest,
+                request
+            });
         },
-        runCronjob: (options)=>{
-            log('Running cronjob %o.', options);
-            // Note: This function is intentionally not async, so that we can access
-            // the `getInterface` method on the response.
-            return runCronjob(page, options);
+        onTransaction,
+        sendTransaction: onTransaction,
+        onSignature: async (request)=>{
+            log('Requesting signature %o.', request);
+            const { origin: signatureOrigin, ...signature } = create(request, SignatureOptionsStruct);
+            return handleRequest({
+                snapId: installedSnapId,
+                store,
+                executionService,
+                controllerMessenger,
+                runSaga,
+                handler: HandlerType.OnSignature,
+                request: {
+                    method: '',
+                    params: {
+                        signature,
+                        signatureOrigin
+                    }
+                }
+            });
         },
-        close: async ()=>{
-            log('Closing page.');
-            await page.close();
+        onCronjob,
+        runCronjob: onCronjob,
+        onHomePage: async ()=>{
+            log('Rendering home page.');
+            return handleRequest({
+                snapId: installedSnapId,
+                store,
+                executionService,
+                controllerMessenger,
+                runSaga,
+                handler: HandlerType.OnHomePage,
+                request: {
+                    method: ''
+                }
+            });
         },
-        mock: async (options)=>{
-            log('Mocking %o.', options);
-            return await mock(page, options);
+        mockJsonRpc (mock) {
+            log('Mocking JSON-RPC request %o.', mock);
+            const { method, result } = create(mock, JsonRpcMockOptionsStruct);
+            store.dispatch(addJsonRpcMock({
+                method,
+                result
+            }));
+            return {
+                unmock () {
+                    log('Unmocking JSON-RPC request %o.', mock);
+                    store.dispatch(removeJsonRpcMock(method));
+                }
+            };
         },
-        mockJsonRpc: async (options)=>{
-            log('Mocking JSON-RPC %o.', options);
-            return await mockJsonRpc(page, options);
+        close: async ()=>{
+            log('Closing execution service.');
+            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();
         }
     };
 }

package/dist/esm/helpers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/helpers.ts"],"sourcesContent":["import { createModuleLogger } from '@metamask/utils';\nimport { getDocument, queries } from 'pptr-testing-library';\n\nimport {\n  getEnvironment,\n  mock,\n  waitFor,\n  request,\n  sendTransaction,\n  runCronjob,\n  mockJsonRpc,\n  rootLogger,\n} from './internals';\nimport type { Snap, SnapResponse } from './types';\n\n// eslint-disable-next-line @typescript-eslint/unbound-method\nconst { getByTestId } = queries;\n\nconst log = createModuleLogger(rootLogger, 'helpers');\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 * ```ts\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 * ```\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 * @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  snapId: string = getEnvironment().snapId,\n): Promise<Snap> {\n  const environment = getEnvironment();\n\n  log('Installing snap %s.', snapId);\n\n  const page = await environment.createPage();\n  const document = await getDocument(page);\n\n  log('Setting snap ID to %s.', snapId);\n  await page.evaluate((payload) => {\n    window.__SIMULATOR_API__.dispatch({\n      type: 'configuration/setSnapId',\n      payload,\n    });\n  }, snapId);\n\n  log('Waiting for snap to install.');\n  // eslint-disable-next-line @typescript-eslint/no-misused-promises\n  await waitFor(async () => await getByTestId(document, 'status-ok'), {\n    timeout: 10000,\n    message: `Timed out waiting for snap to install. Make sure the snap ID (\"${snapId}\") is correct, and the server is running.`,\n  });\n\n  return {\n    request: (options) => {\n      log('Sending request %o.', options);\n\n      // Note: This function is intentionally not async, so that we can access\n      // the `getInterface` method on the response.\n      return request(page, options);\n    },\n\n    sendTransaction: async (options = {}): Promise<SnapResponse> => {\n      log('Sending transaction %o.', options);\n\n      return await sendTransaction(page, options);\n    },\n\n    runCronjob: (options) => {\n      log('Running cronjob %o.', options);\n\n      // Note: This function is intentionally not async, so that we can access\n      // the `getInterface` method on the response.\n      return runCronjob(page, options);\n    },\n\n    close: async () => {\n      log('Closing page.');\n\n      await page.close();\n    },\n\n    mock: async (options) => {\n      log('Mocking %o.', options);\n\n      return await mock(page, options);\n    },\n\n    mockJsonRpc: async (options) => {\n      log('Mocking JSON-RPC %o.', options);\n\n      return await mockJsonRpc(page, options);\n    },\n  };\n}\n"],"names":["createModuleLogger","getDocument","queries","getEnvironment","mock","waitFor","request","sendTransaction","runCronjob","mockJsonRpc","rootLogger","getByTestId","log","installSnap","snapId","environment","page","createPage","document","evaluate","payload","window","__SIMULATOR_API__","dispatch","type","timeout","message","options","close"],"mappings":"AAAA,SAASA,kBAAkB,QAAQ,kBAAkB;AACrD,SAASC,WAAW,EAAEC,OAAO,QAAQ,uBAAuB;AAE5D,SACEC,cAAc,EACdC,IAAI,EACJC,OAAO,EACPC,OAAO,EACPC,eAAe,EACfC,UAAU,EACVC,WAAW,EACXC,UAAU,QACL,cAAc;AAGrB,6DAA6D;AAC7D,MAAM,EAAEC,WAAW,EAAE,GAAGT;AAExB,MAAMU,MAAMZ,mBAAmBU,YAAY;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;CAyBC,GACD,OAAO,eAAeG,YACpBC,SAAiBX,iBAAiBW,MAAM;IAExC,MAAMC,cAAcZ;IAEpBS,IAAI,uBAAuBE;IAE3B,MAAME,OAAO,MAAMD,YAAYE,UAAU;IACzC,MAAMC,WAAW,MAAMjB,YAAYe;IAEnCJ,IAAI,0BAA0BE;IAC9B,MAAME,KAAKG,QAAQ,CAAC,CAACC;QACnBC,OAAOC,iBAAiB,CAACC,QAAQ,CAAC;YAChCC,MAAM;YACNJ;QACF;IACF,GAAGN;IAEHF,IAAI;IACJ,kEAAkE;IAClE,MAAMP,QAAQ,UAAY,MAAMM,YAAYO,UAAU,cAAc;QAClEO,SAAS;QACTC,SAAS,CAAC,+DAA+D,EAAEZ,OAAO,yCAAyC,CAAC;IAC9H;IAEA,OAAO;QACLR,SAAS,CAACqB;YACRf,IAAI,uBAAuBe;YAE3B,wEAAwE;YACxE,6CAA6C;YAC7C,OAAOrB,QAAQU,MAAMW;QACvB;QAEApB,iBAAiB,OAAOoB,UAAU,CAAC,CAAC;YAClCf,IAAI,2BAA2Be;YAE/B,OAAO,MAAMpB,gBAAgBS,MAAMW;QACrC;QAEAnB,YAAY,CAACmB;YACXf,IAAI,uBAAuBe;YAE3B,wEAAwE;YACxE,6CAA6C;YAC7C,OAAOnB,WAAWQ,MAAMW;QAC1B;QAEAC,OAAO;YACLhB,IAAI;YAEJ,MAAMI,KAAKY,KAAK;QAClB;QAEAxB,MAAM,OAAOuB;YACXf,IAAI,eAAee;YAEnB,OAAO,MAAMvB,KAAKY,MAAMW;QAC1B;QAEAlB,aAAa,OAAOkB;YAClBf,IAAI,wBAAwBe;YAE5B,OAAO,MAAMlB,YAAYO,MAAMW;QACjC;IACF;AACF"}
+{"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":["HandlerType","logInfo","createModuleLogger","create","rootLogger","handleRequest","TransactionOptionsStruct","getEnvironment","JsonRpcMockOptionsStruct","SignatureOptionsStruct","addJsonRpcMock","removeJsonRpcMock","log","getOptions","snapId","options","undefined","installSnap","resolvedOptions","installedSnapId","store","executionService","runSaga","controllerMessenger","onTransaction","request","origin","transactionOrigin","chainId","transaction","handler","OnTransaction","method","params","onCronjob","OnCronjob","OnRpcRequest","sendTransaction","onSignature","signatureOrigin","signature","OnSignature","runCronjob","onHomePage","OnHomePage","mockJsonRpc","mock","result","dispatch","unmock","close","terminateAllSnaps"],"mappings":"AAEA,SAASA,WAAW,EAAEC,OAAO,QAAQ,wBAAwB;AAC7D,SAASC,kBAAkB,QAAQ,kBAAkB;AACrD,SAASC,MAAM,QAAQ,cAAc;AAErC,SACEC,UAAU,EACVC,aAAa,EACbC,wBAAwB,EACxBC,cAAc,EACdC,wBAAwB,EACxBC,sBAAsB,QACjB,cAAc;AAErB,SACEC,cAAc,EACdC,iBAAiB,QACZ,qCAAqC;AAS5C,MAAMC,MAAMV,mBAAmBE,YAAY;AAE3C;;;;;;CAMC,GACD,SAASS,WAKPC,MAAiE,EACjEC,OAA6C;IAE7C,IAAI,OAAOD,WAAW,UAAU;QAC9B,OAAO;YAACE;YAAWF;SAAO;IAC5B;IAEA,OAAO;QAACA;QAAQC;KAAQ;AAC1B;AAqGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BC,GACD,OAAO,eAAeE,YAKpBH,MAAsD,EACtDC,UAAgD,CAAC,CAAC;IAElD,MAAMG,kBAAkBL,WAAWC,QAAQC;IAC3C,MAAM,EACJD,QAAQK,eAAe,EACvBC,KAAK,EACLC,gBAAgB,EAChBC,OAAO,EACPC,mBAAmB,EACpB,GAAG,MAAMhB,iBAAiBU,WAAW,IAAIC;IAE1C,MAAMM,gBAAgB,OACpBC;QAEAb,IAAI,2BAA2Ba;QAE/B,MAAM,EACJC,QAAQC,iBAAiB,EACzBC,OAAO,EACP,GAAGC,aACJ,GAAG1B,OAAOsB,SAASnB;QAEpB,OAAOD,cAAc;YACnBS,QAAQK;YACRC;YACAC;YACAC;YACAC;YACAO,SAAS9B,YAAY+B,aAAa;YAClCN,SAAS;gBACPO,QAAQ;gBACRC,QAAQ;oBACNL;oBACAC;oBACAF;gBACF;YACF;QACF;IACF;IAEA,MAAMO,YAAY,CAACT;QACjBb,IAAI,uBAAuBG;QAE3B,OAAOV,cAAc;YACnBS,QAAQK;YACRC;YACAC;YACAE;YACAD;YACAQ,SAAS9B,YAAYmC,SAAS;YAC9BV;QACF;IACF;IAEA,OAAO;QACLA,SAAS,CAACA;YACRb,IAAI,uBAAuBa;YAE3B,OAAOpB,cAAc;gBACnBS,QAAQK;gBACRC;gBACAC;gBACAE;gBACAD;gBACAQ,SAAS9B,YAAYoC,YAAY;gBACjCX;YACF;QACF;QAEAD;QACAa,iBAAiBb;QAEjBc,aAAa,OAAOb;YAClBb,IAAI,4BAA4Ba;YAEhC,MAAM,EAAEC,QAAQa,eAAe,EAAE,GAAGC,WAAW,GAAGrC,OAChDsB,SACAhB;YAGF,OAAOJ,cAAc;gBACnBS,QAAQK;gBACRC;gBACAC;gBACAE;gBACAD;gBACAQ,SAAS9B,YAAYyC,WAAW;gBAChChB,SAAS;oBACPO,QAAQ;oBACRC,QAAQ;wBACNO;wBACAD;oBACF;gBACF;YACF;QACF;QAEAL;QACAQ,YAAYR;QAEZS,YAAY;YACV/B,IAAI;YAEJ,OAAOP,cAAc;gBACnBS,QAAQK;gBACRC;gBACAC;gBACAE;gBACAD;gBACAQ,SAAS9B,YAAY4C,UAAU;gBAC/BnB,SAAS;oBACPO,QAAQ;gBACV;YACF;QACF;QAEAa,aAAYC,IAAwB;YAClClC,IAAI,gCAAgCkC;YAEpC,MAAM,EAAEd,MAAM,EAAEe,MAAM,EAAE,GAAG5C,OAAO2C,MAAMtC;YACxCY,MAAM4B,QAAQ,CAACtC,eAAe;gBAAEsB;gBAAQe;YAAO;YAE/C,OAAO;gBACLE;oBACErC,IAAI,kCAAkCkC;oBAEtC1B,MAAM4B,QAAQ,CAACrC,kBAAkBqB;gBACnC;YACF;QACF;QAEAkB,OAAO;YACLtC,IAAI;YACJX,QACE;YAGF,MAAMoB,iBAAiB8B,iBAAiB;QAC1C;IACF;AACF"}

package/dist/esm/internals/environment.js

@@ -7,7 +7,7 @@ import { assert } from '@metamask/utils';
  */ export function getEnvironment() {
     // `snapsEnvironment` is a global variable that is set by the Jest
     // environment.
-    assert(snapsEnvironment, 'Snaps environment not found. Make sure you have configured the environment correctly.');
+    assert(typeof snapsEnvironment !== 'undefined', 'Snaps environment not found. Make sure you have configured the environment correctly.');
     return snapsEnvironment;
 }
 

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

@@ -1 +1 @@
-{"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    snapsEnvironment,\n    'Snaps environment not found. Make sure you have configured the environment correctly.',\n  );\n\n  return snapsEnvironment;\n}\n"],"names":["assert","getEnvironment","snapsEnvironment"],"mappings":"AAAA,SAASA,MAAM,QAAQ,kBAAkB;AAEzC;;;;;CAKC,GACD,OAAO,SAASC;IACd,kEAAkE;IAClE,eAAe;IACfD,OACEE,kBACA;IAGF,OAAOA;AACT"}
+{"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":["assert","getEnvironment","snapsEnvironment"],"mappings":"AAAA,SAASA,MAAM,QAAQ,kBAAkB;AAEzC;;;;;CAKC,GACD,OAAO,SAASC;IACd,kEAAkE;IAClE,eAAe;IACfD,OACE,OAAOE,qBAAqB,aAC5B;IAGF,OAAOA;AACT"}

package/dist/esm/internals/index.js

@@ -1,12 +1,8 @@
 export * from './environment';
-export * from './interface';
 export * from './logger';
-export * from './network';
 export * from './request';
 export * from './server';
+export * from './simulation';
 export * from './structs';
-// eslint-disable-next-line import/export
-export * from './types';
-export * from './wait-for';
 
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/internals/index.ts"],"sourcesContent":["export * from './environment';\nexport * from './interface';\nexport * from './logger';\nexport * from './network';\nexport * from './request';\nexport * from './server';\nexport * from './structs';\n// eslint-disable-next-line import/export\nexport * from './types';\nexport * from './wait-for';\n"],"names":[],"mappings":"AAAA,cAAc,gBAAgB;AAC9B,cAAc,cAAc;AAC5B,cAAc,WAAW;AACzB,cAAc,YAAY;AAC1B,cAAc,YAAY;AAC1B,cAAc,WAAW;AACzB,cAAc,YAAY;AAC1B,yCAAyC;AACzC,cAAc,UAAU;AACxB,cAAc,aAAa"}
+{"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":"AAAA,cAAc,gBAAgB;AAC9B,cAAc,WAAW;AACzB,cAAc,YAAY;AAC1B,cAAc,WAAW;AACzB,cAAc,eAAe;AAC7B,cAAc,YAAY"}