@metamask/snaps-jest 0.35.1-flask.1

package/dist/cjs/internals/network.js

@@ -0,0 +1,146 @@
+"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, {
+    MockOptionsStruct: function() {
+        return MockOptionsStruct;
+    },
+    mock: function() {
+        return mock;
+    },
+    mockJsonRpc: function() {
+        return mockJsonRpc;
+    }
+});
+const _snapssimulator = require("@metamask/snaps-simulator");
+const _utils = require("@metamask/utils");
+const _superstruct = require("superstruct");
+const _logger = require("./logger");
+/**
+ * The default headers to use for mocked responses. These headers are used to
+ * enable CORS.
+ */ const DEFAULT_HEADERS = {
+    /* eslint-disable @typescript-eslint/naming-convention */ 'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Credentials': 'true',
+    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+    'Access-Control-Allow-Headers': 'Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, Access-Control-Request-Method, Access-Control-Request-Headers'
+};
+const log = (0, _utils.createModuleLogger)(_logger.rootLogger, 'network');
+const MockOptionsBaseStruct = (0, _superstruct.object)({
+    response: (0, _superstruct.defaulted)((0, _superstruct.object)({
+        status: (0, _superstruct.defaulted)((0, _superstruct.number)(), 200),
+        headers: (0, _superstruct.defaulted)((0, _superstruct.record)((0, _superstruct.string)(), (0, _superstruct.unknown)()), DEFAULT_HEADERS),
+        contentType: (0, _superstruct.defaulted)((0, _superstruct.string)(), 'text/plain'),
+        body: (0, _superstruct.defaulted)((0, _superstruct.string)(), '')
+    }), {})
+});
+const MockOptionsUrlStruct = (0, _superstruct.object)({
+    url: (0, _superstruct.union)([
+        (0, _superstruct.string)(),
+        (0, _superstruct.regexp)()
+    ]),
+    partial: (0, _superstruct.optional)((0, _superstruct.boolean)())
+});
+const MockOptionsConditionStruct = (0, _superstruct.object)({
+    condition: (0, _superstruct.func)()
+});
+const MockOptionsStruct = (0, _superstruct.union)([
+    (0, _superstruct.assign)(MockOptionsBaseStruct, MockOptionsUrlStruct),
+    (0, _superstruct.assign)(MockOptionsBaseStruct, MockOptionsConditionStruct)
+]);
+/**
+ * Check if the given URL matches the given request, or if the condition
+ * function returns `true`.
+ *
+ * @param request - The request to check.
+ * @param options - The options for the network mocking.
+ * @returns Whether the URL matches the request.
+ */ function matches(request, options) {
+    if ('url' in options) {
+        const { url, partial } = options;
+        if (typeof url === 'string') {
+            if (partial) {
+                return request.url().startsWith(url);
+            }
+            return url === request.url();
+        }
+        return url.test(request.url());
+    }
+    const { condition } = options;
+    return condition(request);
+}
+async function mock(page, options) {
+    await page.setRequestInterception(true);
+    const parsedOptions = (0, _superstruct.create)(options, MockOptionsStruct);
+    /**
+   * The mock handler.
+   *
+   * @param request - The request to handle.
+   */ function handler(request) {
+        // If the request is already handled, Puppeteer will throw an error if we
+        // try to continue the request.
+        if (request.isInterceptResolutionHandled()) {
+            return;
+        }
+        if (!matches(request, parsedOptions)) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            request.continue();
+            return;
+        }
+        log('Mocking request to %s', request.url());
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        request.respond(parsedOptions.response);
+    }
+    /**
+   * Unmock the page.
+   */ async function unmock() {
+        await page.setRequestInterception(false);
+        page.off('request', handler);
+    }
+    page.on('request', handler);
+    return {
+        unmock
+    };
+}
+const MockJsonRpcOptionsStruct = (0, _superstruct.object)({
+    method: (0, _superstruct.string)(),
+    result: _utils.UnsafeJsonStruct
+});
+async function mockJsonRpc(page, { method, result }) {
+    return await mock(page, {
+        condition: (request)=>{
+            if (request.url() !== _snapssimulator.JSON_RPC_ENDPOINT) {
+                return false;
+            }
+            const body = request.postData();
+            if (!body) {
+                return false;
+            }
+            try {
+                const json = JSON.parse(body);
+                return json.method === method;
+            } catch (error) {
+                log(`Unable to mock "${method}" request to Ethereum provider: %s`, error.message);
+                return false;
+            }
+        },
+        response: {
+            status: 200,
+            contentType: 'application/json',
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                result
+            })
+        }
+    });
+}
+
+//# sourceMappingURL=network.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/internals/network.ts"],"sourcesContent":["import { JSON_RPC_ENDPOINT } from '@metamask/snaps-simulator';\nimport { createModuleLogger, UnsafeJsonStruct } from '@metamask/utils';\nimport { Page, HTTPRequest } from 'puppeteer';\nimport {\n  assign,\n  boolean,\n  create,\n  defaulted,\n  Infer,\n  number,\n  object,\n  optional,\n  record,\n  regexp,\n  string,\n  Struct,\n  union,\n  unknown,\n  func,\n} from 'superstruct';\n\nimport { DeepPartial } from '../types';\nimport { rootLogger } from './logger';\n\n/**\n * The default headers to use for mocked responses. These headers are used to\n * enable CORS.\n */\nconst DEFAULT_HEADERS = {\n  /* eslint-disable @typescript-eslint/naming-convention */\n  'Access-Control-Allow-Origin': '*',\n  'Access-Control-Allow-Credentials': 'true',\n  'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',\n  'Access-Control-Allow-Headers':\n    'Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, Access-Control-Request-Method, Access-Control-Request-Headers',\n  /* eslint-enable @typescript-eslint/naming-convention */\n};\n\nconst log = createModuleLogger(rootLogger, 'network');\n\nexport type Unmock = () => Promise<void>;\n\nexport type Mock = {\n  /**\n   * A function that can be used to unmock the URL.\n   */\n  unmock: Unmock;\n};\n\n/**\n * A function that can return `true` if the given request should be mocked, or\n * false if not.\n *\n * @param request - The request to check.\n * @returns Whether to mock the request.\n */\nexport type ConditionFunction = (request: HTTPRequest) => boolean;\n\nconst MockOptionsBaseStruct = object({\n  response: defaulted(\n    object({\n      status: defaulted(number(), 200),\n      headers: defaulted(record(string(), unknown()), DEFAULT_HEADERS),\n      contentType: defaulted(string(), 'text/plain'),\n      body: defaulted(string(), ''),\n    }),\n    {},\n  ),\n});\n\nconst MockOptionsUrlStruct = object({\n  url: union([string(), regexp()]),\n  partial: optional(boolean()),\n});\n\nconst MockOptionsConditionStruct = object({\n  condition: func() as unknown as Struct<ConditionFunction, null>,\n});\n\nexport const MockOptionsStruct = union([\n  assign(MockOptionsBaseStruct, MockOptionsUrlStruct),\n  assign(MockOptionsBaseStruct, MockOptionsConditionStruct),\n]);\n\n/**\n * The options for the network mocking.\n *\n * @property url - The URL to mock. If a string is provided, the URL will be\n * matched exactly. If a RegExp is provided, the URL will be matched against it.\n * This option is incompatible with the `condition` option.\n * @property partial - If enabled, the request will be mocked if the URL starts\n * with the given URL. This option is ignored if a RegExp is provided to the\n * `url` option. This option is incompatible with the `condition` option.\n * @property condition - A function which gets the {@link HTTPRequest} as\n * parameter and returns a boolean to indicate whether the response should be\n * mocked or not. This option is incompatible with the `url` and `partial`\n * options.\n * @property response - The response to send for the request.\n * @property response.status - The status code to send for the response.\n * Defaults to `200`.\n * @property response.headers - The headers to send for the response. Defaults\n * to headers that enable CORS.\n * @property response.contentType - The content type to send for the response.\n * Defaults to `text/plain`.\n */\nexport type MockOptions = Infer<typeof MockOptionsStruct>;\n\n/**\n * Check if the given URL matches the given request, or if the condition\n * function returns `true`.\n *\n * @param request - The request to check.\n * @param options - The options for the network mocking.\n * @returns Whether the URL matches the request.\n */\nfunction matches(request: HTTPRequest, options: MockOptions) {\n  if ('url' in options) {\n    const { url, partial } = options;\n    if (typeof url === 'string') {\n      if (partial) {\n        return request.url().startsWith(url);\n      }\n\n      return url === request.url();\n    }\n\n    return url.test(request.url());\n  }\n\n  const { condition } = options;\n  return condition(request);\n}\n\n/**\n * Enable network mocking for the given page, and all its sub-frames.\n *\n * @param page - The page to enable network mocking on.\n * @param options - The options for the network mocking.\n * @returns A {@link Mock} object, with an `unmock` function.\n */\nexport async function mock(\n  page: Page,\n  options: DeepPartial<MockOptions>,\n): Promise<Mock> {\n  await page.setRequestInterception(true);\n\n  const parsedOptions = create(options, MockOptionsStruct);\n\n  /**\n   * The mock handler.\n   *\n   * @param request - The request to handle.\n   */\n  function handler(request: HTTPRequest) {\n    // If the request is already handled, Puppeteer will throw an error if we\n    // try to continue the request.\n    if (request.isInterceptResolutionHandled()) {\n      return;\n    }\n\n    if (!matches(request, parsedOptions)) {\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      request.continue();\n      return;\n    }\n\n    log('Mocking request to %s', request.url());\n\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    request.respond(parsedOptions.response);\n  }\n\n  /**\n   * Unmock the page.\n   */\n  async function unmock() {\n    await page.setRequestInterception(false);\n    page.off('request', handler);\n  }\n\n  page.on('request', handler);\n\n  return {\n    unmock,\n  };\n}\n\nconst MockJsonRpcOptionsStruct = object({\n  method: string(),\n  result: UnsafeJsonStruct,\n});\n\nexport type MockJsonRpcOptions = Infer<typeof MockJsonRpcOptionsStruct>;\n\n/**\n * Mock an Ethereum JSON-RPC request. This intercepts all requests to the\n * Ethereum provider, and returns the `result` instead.\n *\n * @param page - The page to enable network JSON-RPC mocking on.\n * @param options - The options for the JSON-RPC mock.\n * @param options.method - The JSON-RPC method to mock. Any other methods will be\n * forwarded to the provider.\n * @param options.result - The JSON response to return.\n * @returns A {@link Mock} object, with an `unmock` function.\n */\nexport async function mockJsonRpc(\n  page: Page,\n  { method, result }: MockJsonRpcOptions,\n) {\n  return await mock(page, {\n    condition: (request: HTTPRequest) => {\n      if (request.url() !== JSON_RPC_ENDPOINT) {\n        return false;\n      }\n\n      const body = request.postData();\n      if (!body) {\n        return false;\n      }\n\n      try {\n        const json = JSON.parse(body);\n        return json.method === method;\n      } catch (error) {\n        log(\n          `Unable to mock \"${method}\" request to Ethereum provider: %s`,\n          error.message,\n        );\n        return false;\n      }\n    },\n    response: {\n      status: 200,\n      contentType: 'application/json',\n      body: JSON.stringify({\n        jsonrpc: '2.0',\n        id: 1,\n        result,\n      }),\n    },\n  });\n}\n"],"names":["MockOptionsStruct","mock","mockJsonRpc","DEFAULT_HEADERS","log","createModuleLogger","rootLogger","MockOptionsBaseStruct","object","response","defaulted","status","number","headers","record","string","unknown","contentType","body","MockOptionsUrlStruct","url","union","regexp","partial","optional","boolean","MockOptionsConditionStruct","condition","func","assign","matches","request","options","startsWith","test","page","setRequestInterception","parsedOptions","create","handler","isInterceptResolutionHandled","continue","respond","unmock","off","on","MockJsonRpcOptionsStruct","method","result","UnsafeJsonStruct","JSON_RPC_ENDPOINT","postData","json","JSON","parse","error","message","stringify","jsonrpc","id"],"mappings":"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"}

package/dist/cjs/internals/request.js

@@ -0,0 +1,121 @@
+"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, {
+    request: function() {
+        return request;
+    },
+    sendTransaction: function() {
+        return sendTransaction;
+    },
+    runCronjob: function() {
+        return runCronjob;
+    }
+});
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+const _pptrtestinglibrary = require("pptr-testing-library");
+const _superstruct = require("superstruct");
+const _interface = require("./interface");
+const _logger = require("./logger");
+const _structs = require("./structs");
+const _waitfor = require("./wait-for");
+const log = (0, _utils.createModuleLogger)(_logger.rootLogger, 'request');
+/**
+ * Send a request to the snap.
+ *
+ * @param page - The page to send the request from.
+ * @param args - The request arguments.
+ * @returns The request ID.
+ */ async function sendRequest(page, args) {
+    const document = await (0, _pptrtestinglibrary.getDocument)(page);
+    const button = await _pptrtestinglibrary.queries.getByTestId(document, `navigation-${args.handler}`);
+    // Navigate to the request handler page.
+    await button.click();
+    return await page.evaluate((payload)=>{
+        window.__SIMULATOR_API__.dispatch({
+            type: 'simulation/sendRequest',
+            payload
+        });
+        return window.__SIMULATOR_API__.getRequestId();
+    }, args);
+}
+function request(page, { origin = 'metamask.io', ...options }, handler = _snapsutils.HandlerType.OnRpcRequest) {
+    const doRequest = async ()=>{
+        const args = {
+            origin,
+            handler,
+            request: {
+                jsonrpc: '2.0',
+                id: 1,
+                ...options
+            }
+        };
+        log('Sending request %o', args);
+        const promise = (0, _waitfor.waitForResponse)(page, handler);
+        const id = await sendRequest(page, args);
+        const response = await promise;
+        log('Received response %o', response);
+        const notifications = await (0, _interface.getNotifications)(page, id);
+        return {
+            id,
+            response,
+            notifications
+        };
+    };
+    // This is a bit hacky, but it allows us to add the `getInterface` method
+    // to the response promise.
+    const response = doRequest();
+    response.getInterface = async (getInterfaceOptions)=>{
+        return await (0, _interface.getInterface)(page, getInterfaceOptions);
+    };
+    return response;
+}
+async function sendTransaction(page, options) {
+    const { origin: transactionOrigin, chainId, ...transaction } = (0, _superstruct.create)(options, _structs.TransactionOptionsStruct);
+    const args = {
+        origin: '',
+        handler: _snapsutils.HandlerType.OnTransaction,
+        request: {
+            jsonrpc: '2.0',
+            method: '',
+            params: {
+                chainId,
+                transaction,
+                transactionOrigin
+            }
+        }
+    };
+    log('Sending transaction %o', args);
+    const promise = (0, _waitfor.waitForResponse)(page, _snapsutils.HandlerType.OnTransaction);
+    const id = await sendRequest(page, args);
+    const response = await promise;
+    log('Received response %o', response);
+    if ((0, _utils.hasProperty)(response, 'error')) {
+        return {
+            id,
+            response,
+            notifications: []
+        };
+    }
+    (0, _utils.assert)((0, _utils.isPlainObject)(response.result));
+    (0, _utils.assert)((0, _utils.hasProperty)(response.result, 'content'));
+    return {
+        id,
+        response,
+        notifications: [],
+        content: response.result.content
+    };
+}
+function runCronjob(page, options) {
+    return request(page, options, _snapsutils.HandlerType.OnCronjob);
+}
+
+//# sourceMappingURL=request.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/internals/request.ts"],"sourcesContent":["import { Component } from '@metamask/snaps-ui';\nimport { HandlerType, SnapRpcHookArgs } from '@metamask/snaps-utils';\nimport {\n  assert,\n  createModuleLogger,\n  hasProperty,\n  isPlainObject,\n} from '@metamask/utils';\nimport { getDocument, queries } from 'pptr-testing-library';\nimport { Page } from 'puppeteer';\nimport { create } from 'superstruct';\n\nimport {\n  CronjobOptions,\n  RequestOptions,\n  SnapRequest,\n  SnapResponse,\n  TransactionOptions,\n} from '../types';\nimport { getInterface, getNotifications } from './interface';\nimport { rootLogger } from './logger';\nimport { TransactionOptionsStruct } from './structs';\nimport { waitForResponse } from './wait-for';\n\nconst log = createModuleLogger(rootLogger, 'request');\n\n/**\n * Send a request to the snap.\n *\n * @param page - The page to send the request from.\n * @param args - The request arguments.\n * @returns The request ID.\n */\nasync function sendRequest(page: Page, args: SnapRpcHookArgs) {\n  const document = await getDocument(page);\n  const button = await queries.getByTestId(\n    document,\n    `navigation-${args.handler}`,\n  );\n\n  // Navigate to the request handler page.\n  await button.click();\n\n  return await page.evaluate((payload) => {\n    window.__SIMULATOR_API__.dispatch({\n      type: 'simulation/sendRequest',\n      payload,\n    });\n\n    return window.__SIMULATOR_API__.getRequestId();\n  }, args);\n}\n\n/**\n * Send a request to the snap.\n *\n * @param page - The page to send the request from.\n * @param options - The request options.\n * @param options.origin - The origin of the request. Defaults to `metamask.io`.\n * @param handler - The handler to use. Defaults to `onRpcRequest`.\n * @returns The response.\n */\nexport function request(\n  page: Page,\n  { origin = 'metamask.io', ...options }: RequestOptions,\n  handler:\n    | HandlerType.OnRpcRequest\n    | HandlerType.OnCronjob = HandlerType.OnRpcRequest,\n) {\n  const doRequest = async (): Promise<SnapResponse> => {\n    const args: SnapRpcHookArgs = {\n      origin,\n      handler,\n      request: {\n        jsonrpc: '2.0',\n        id: 1,\n        ...options,\n      },\n    };\n\n    log('Sending request %o', args);\n\n    const promise = waitForResponse(page, handler);\n    const id = await sendRequest(page, args);\n    const response = await promise;\n\n    log('Received response %o', response);\n\n    const notifications = await getNotifications(page, id);\n\n    return { id, response, notifications };\n  };\n\n  // This is a bit hacky, but it allows us to add the `getInterface` method\n  // to the response promise.\n  const response = doRequest() as SnapRequest;\n\n  response.getInterface = async (getInterfaceOptions) => {\n    return await getInterface(page, getInterfaceOptions);\n  };\n\n  return response;\n}\n\n/**\n * Send a transaction to the snap.\n *\n * @param page - The page to send the transaction from.\n * @param options - The transaction options.\n * @returns The response.\n */\nexport async function sendTransaction(\n  page: Page,\n  options: Partial<TransactionOptions>,\n) {\n  const {\n    origin: transactionOrigin,\n    chainId,\n    ...transaction\n  } = create(options, TransactionOptionsStruct);\n\n  const args: SnapRpcHookArgs = {\n    origin: '',\n    handler: HandlerType.OnTransaction,\n    request: {\n      jsonrpc: '2.0',\n      method: '',\n      params: {\n        chainId,\n        transaction,\n        transactionOrigin,\n      },\n    },\n  };\n\n  log('Sending transaction %o', args);\n\n  const promise = waitForResponse(page, HandlerType.OnTransaction);\n  const id = await sendRequest(page, args);\n  const response = await promise;\n\n  log('Received response %o', response);\n\n  if (hasProperty(response, 'error')) {\n    return { id, response, notifications: [] };\n  }\n\n  assert(isPlainObject(response.result));\n  assert(hasProperty(response.result, 'content'));\n\n  return {\n    id,\n    response,\n    notifications: [],\n    content: response.result.content as Component,\n  };\n}\n\n/**\n * Run a cronjob.\n *\n * @param page - The page to run the cronjob from.\n * @param options - The request options.\n * @returns The response.\n */\nexport function runCronjob(page: Page, options: CronjobOptions) {\n  return request(page, options, HandlerType.OnCronjob);\n}\n"],"names":["request","sendTransaction","runCronjob","log","createModuleLogger","rootLogger","sendRequest","page","args","document","getDocument","button","queries","getByTestId","handler","click","evaluate","payload","window","__SIMULATOR_API__","dispatch","type","getRequestId","origin","options","HandlerType","OnRpcRequest","doRequest","jsonrpc","id","promise","waitForResponse","response","notifications","getNotifications","getInterface","getInterfaceOptions","transactionOrigin","chainId","transaction","create","TransactionOptionsStruct","OnTransaction","method","params","hasProperty","assert","isPlainObject","result","content","OnCronjob"],"mappings":";;;;;;;;;;;IA8DgBA,OAAO;eAAPA;;IAiDMC,eAAe;eAAfA;;IAsDNC,UAAU;eAAVA;;;4BApK6B;uBAMtC;oCAC8B;6BAEd;2BASwB;wBACpB;yBACc;yBACT;AAEhC,MAAMC,MAAMC,IAAAA,yBAAkB,EAACC,kBAAU,EAAE;AAE3C;;;;;;CAMC,GACD,eAAeC,YAAYC,IAAU,EAAEC,IAAqB;IAC1D,MAAMC,WAAW,MAAMC,IAAAA,+BAAW,EAACH;IACnC,MAAMI,SAAS,MAAMC,2BAAO,CAACC,WAAW,CACtCJ,UACA,CAAC,WAAW,EAAED,KAAKM,OAAO,CAAC,CAAC;IAG9B,wCAAwC;IACxC,MAAMH,OAAOI,KAAK;IAElB,OAAO,MAAMR,KAAKS,QAAQ,CAAC,CAACC;QAC1BC,OAAOC,iBAAiB,CAACC,QAAQ,CAAC;YAChCC,MAAM;YACNJ;QACF;QAEA,OAAOC,OAAOC,iBAAiB,CAACG,YAAY;IAC9C,GAAGd;AACL;AAWO,SAASR,QACdO,IAAU,EACV,EAAEgB,SAAS,aAAa,EAAE,GAAGC,SAAyB,EACtDV,UAE4BW,uBAAW,CAACC,YAAY;IAEpD,MAAMC,YAAY;QAChB,MAAMnB,OAAwB;YAC5Be;YACAT;YACAd,SAAS;gBACP4B,SAAS;gBACTC,IAAI;gBACJ,GAAGL,OAAO;YACZ;QACF;QAEArB,IAAI,sBAAsBK;QAE1B,MAAMsB,UAAUC,IAAAA,wBAAe,EAACxB,MAAMO;QACtC,MAAMe,KAAK,MAAMvB,YAAYC,MAAMC;QACnC,MAAMwB,WAAW,MAAMF;QAEvB3B,IAAI,wBAAwB6B;QAE5B,MAAMC,gBAAgB,MAAMC,IAAAA,2BAAgB,EAAC3B,MAAMsB;QAEnD,OAAO;YAAEA;YAAIG;YAAUC;QAAc;IACvC;IAEA,yEAAyE;IACzE,2BAA2B;IAC3B,MAAMD,WAAWL;IAEjBK,SAASG,YAAY,GAAG,OAAOC;QAC7B,OAAO,MAAMD,IAAAA,uBAAY,EAAC5B,MAAM6B;IAClC;IAEA,OAAOJ;AACT;AASO,eAAe/B,gBACpBM,IAAU,EACViB,OAAoC;IAEpC,MAAM,EACJD,QAAQc,iBAAiB,EACzBC,OAAO,EACP,GAAGC,aACJ,GAAGC,IAAAA,mBAAM,EAAChB,SAASiB,iCAAwB;IAE5C,MAAMjC,OAAwB;QAC5Be,QAAQ;QACRT,SAASW,uBAAW,CAACiB,aAAa;QAClC1C,SAAS;YACP4B,SAAS;YACTe,QAAQ;YACRC,QAAQ;gBACNN;gBACAC;gBACAF;YACF;QACF;IACF;IAEAlC,IAAI,0BAA0BK;IAE9B,MAAMsB,UAAUC,IAAAA,wBAAe,EAACxB,MAAMkB,uBAAW,CAACiB,aAAa;IAC/D,MAAMb,KAAK,MAAMvB,YAAYC,MAAMC;IACnC,MAAMwB,WAAW,MAAMF;IAEvB3B,IAAI,wBAAwB6B;IAE5B,IAAIa,IAAAA,kBAAW,EAACb,UAAU,UAAU;QAClC,OAAO;YAAEH;YAAIG;YAAUC,eAAe,EAAE;QAAC;IAC3C;IAEAa,IAAAA,aAAM,EAACC,IAAAA,oBAAa,EAACf,SAASgB,MAAM;IACpCF,IAAAA,aAAM,EAACD,IAAAA,kBAAW,EAACb,SAASgB,MAAM,EAAE;IAEpC,OAAO;QACLnB;QACAG;QACAC,eAAe,EAAE;QACjBgB,SAASjB,SAASgB,MAAM,CAACC,OAAO;IAClC;AACF;AASO,SAAS/C,WAAWK,IAAU,EAAEiB,OAAuB;IAC5D,OAAOxB,QAAQO,MAAMiB,SAASC,uBAAW,CAACyB,SAAS;AACrD"}

package/dist/cjs/internals/server.js

@@ -0,0 +1,75 @@
+"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
+    };
+}
+const SNAPS_EXECUTION_ENVIRONMENTS_PATH = (0, _path.resolve)((0, _path.dirname)(require.resolve('@metamask/snaps-execution-environments/package.json')), 'dist', 'browserify', 'iframe');
+const SNAPS_SIMULATOR_PATH = (0, _path.resolve)((0, _path.dirname)(require.resolve('@metamask/snaps-simulator/package.json')), 'dist', 'webpack', 'test');
+/**
+ * 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('/environment', _express.default.static(SNAPS_EXECUTION_ENVIRONMENTS_PATH));
+    app.use('/simulator', _express.default.static(SNAPS_SIMULATOR_PATH));
+    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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/internals/server.ts"],"sourcesContent":["import {\n  assertIsSnapManifest,\n  isDirectory,\n  isFile,\n  SnapManifest,\n} from '@metamask/snaps-utils';\nimport { createModuleLogger } from '@metamask/utils';\nimport express from 'express';\nimport { promises as fs } from 'fs';\nimport { createServer, Server } from 'http';\nimport { resolve as pathResolve, dirname } from 'path';\n\nimport { SnapsEnvironmentOptions } from '../options';\nimport { rootLogger } from './logger';\n\nconst SNAPS_EXECUTION_ENVIRONMENTS_PATH = pathResolve(\n  dirname(\n    require.resolve('@metamask/snaps-execution-environments/package.json'),\n  ),\n  'dist',\n  'browserify',\n  'iframe',\n);\n\nconst SNAPS_SIMULATOR_PATH = pathResolve(\n  dirname(require.resolve('@metamask/snaps-simulator/package.json')),\n  'dist',\n  'webpack',\n  'test',\n);\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('/environment', express.static(SNAPS_EXECUTION_ENVIRONMENTS_PATH));\n  app.use('/simulator', express.static(SNAPS_SIMULATOR_PATH));\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","SNAPS_EXECUTION_ENVIRONMENTS_PATH","pathResolve","dirname","require","resolve","SNAPS_SIMULATOR_PATH","assertRoot","root","Error","isDirectory","manifestPath","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","reject","listen","port","on","error"],"mappings":";;;;+BA+EsBA;;;eAAAA;;;4BA1Ef;uBAC4B;gEACf;oBACW;sBACM;sBACW;wBAGrB;;;;;;AAE3B,MAAMC,oCAAoCC,IAAAA,aAAW,EACnDC,IAAAA,aAAO,EACLC,QAAQC,OAAO,CAAC,yDAElB,QACA,cACA;AAGF,MAAMC,uBAAuBJ,IAAAA,aAAW,EACtCC,IAAAA,aAAO,EAACC,QAAQC,OAAO,CAAC,4CACxB,QACA,WACA;AAQF;;;;;;;;;CASC,GACD,eAAeE,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,eAAeT,IAAAA,aAAW,EAACM,MAAM;IACvC,MAAMI,WAAyB,MAAMC,YAAE,CACpCC,QAAQ,CAACH,cAAc,QACvBI,IAAI,CAACC,KAAKC,KAAK;IAElBC,IAAAA,gCAAoB,EAACN;IACrB,MAAMO,WAAWjB,IAAAA,aAAW,EAACM,MAAMI,SAASQ,MAAM,CAACC,QAAQ,CAACC,GAAG,CAACH,QAAQ;IAExE,IAAI,CAAE,MAAMI,IAAAA,kBAAM,EAACJ,WAAY;QAC7B,MAAM,IAAIV,MACR,CAAC,MAAM,EAAEU,SAAS,sEAAsE,CAAC;IAE7F;AACF;AAWO,eAAenB,YAAYwB,OAAsB;IACtD,MAAMjB,WAAWiB,QAAQhB,IAAI;IAE7B,MAAMiB,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,CAAC,gBAAgBD,gBAAO,CAACM,MAAM,CAAClC;IACvC2B,IAAIE,GAAG,CAAC,cAAcD,gBAAO,CAACM,MAAM,CAAC7B;IACrCsB,IAAIE,GAAG,CAACD,gBAAO,CAACM,MAAM,CAACjC,IAAAA,aAAW,EAACkC,QAAQC,GAAG,IAAIb,QAAQhB,IAAI;IAE9D,MAAM8B,SAASC,IAAAA,kBAAY,EAACX;IAC5B,OAAO,MAAM,IAAIY,QAAgB,CAACnC,SAASoC;QACzCH,OAAOI,MAAM,CAAClB,QAAQmB,IAAI,EAAE;YAC1BtC,QAAQiC;QACV;QAEAA,OAAOM,EAAE,CAAC,SAAS,CAACC;YAClBpB,IAAIoB;YACJJ,OAAOI;QACT;IACF;AACF"}

package/dist/cjs/internals/structs.js

@@ -0,0 +1,124 @@
+"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, {
+    TransactionOptionsStruct: function() {
+        return TransactionOptionsStruct;
+    },
+    SnapOptionsStruct: function() {
+        return SnapOptionsStruct;
+    },
+    InterfaceStruct: function() {
+        return InterfaceStruct;
+    },
+    SnapResponseStruct: function() {
+        return SnapResponseStruct;
+    }
+});
+const _rpcmethods = require("@metamask/rpc-methods");
+const _snapsui = require("@metamask/snaps-ui");
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+const _crypto = require("crypto");
+const _superstruct = require("superstruct");
+// TODO: Export this from `@metamask/utils` instead.
+const BytesLikeStruct = (0, _superstruct.union)([
+    (0, _superstruct.bigint)(),
+    (0, _superstruct.number)(),
+    (0, _superstruct.string)(),
+    (0, _superstruct.instance)(Uint8Array)
+]);
+const TransactionOptionsStruct = (0, _superstruct.object)({
+    /**
+   * The CAIP-2 chain ID to send the transaction on. Defaults to `eip155:1`.
+   */ chainId: (0, _superstruct.defaulted)((0, _superstruct.string)(), 'eip155:1'),
+    /**
+   * The origin to send the transaction from. Defaults to `metamask.io`.
+   */ origin: (0, _superstruct.defaulted)((0, _superstruct.string)(), 'metamask.io'),
+    /**
+   * The address to send the transaction from. Defaults to a randomly generated
+   * address.
+   */ // TODO: Move this coercer to `@metamask/utils`.
+    from: (0, _superstruct.coerce)(_utils.StrictHexStruct, (0, _superstruct.optional)(BytesLikeStruct), (value)=>{
+        if (value) {
+            return (0, _utils.valueToBytes)(value);
+        }
+        return (0, _utils.bytesToHex)((0, _crypto.randomBytes)(20));
+    }),
+    /**
+   * The address to send the transaction to. Defaults to a randomly generated
+   * address.
+   */ // TODO: Move this coercer to `@metamask/utils`.
+    to: (0, _superstruct.coerce)(_utils.StrictHexStruct, (0, _superstruct.optional)(BytesLikeStruct), (value)=>{
+        if (value) {
+            return (0, _utils.valueToBytes)(value);
+        }
+        return (0, _utils.bytesToHex)((0, _crypto.randomBytes)(20));
+    }),
+    /**
+   * The value to send with the transaction. The value may be specified as a
+   * `number`, `bigint`, `string`, or `Uint8Array`. Defaults to `0`.
+   */ value: (0, _superstruct.defaulted)((0, _superstruct.coerce)(_utils.StrictHexStruct, BytesLikeStruct, (value)=>(0, _utils.bytesToHex)((0, _utils.valueToBytes)(value))), '0x0'),
+    /**
+   * The gas limit to use for the transaction. The gas limit may be specified
+   * as a `number`, `bigint`, `string`, or `Uint8Array`. Defaults to `21_000`.
+   */ gasLimit: (0, _superstruct.defaulted)((0, _superstruct.coerce)(_utils.StrictHexStruct, BytesLikeStruct, (value)=>(0, _utils.bytesToHex)((0, _utils.valueToBytes)(value))), (0, _utils.valueToBytes)(21000)),
+    /**
+   * The max fee per gas (in Wei) to use for the transaction. The max fee per
+   * gas may be specified as a `number`, `bigint`, `string`, or `Uint8Array`.
+   * Defaults to `1`.
+   */ maxFeePerGas: (0, _superstruct.defaulted)((0, _superstruct.coerce)(_utils.StrictHexStruct, BytesLikeStruct, (value)=>(0, _utils.bytesToHex)((0, _utils.valueToBytes)(value))), (0, _utils.valueToBytes)(1)),
+    /**
+   * The max priority fee per gas (in Wei) to use for the transaction. The max
+   * priority fee per gas may be specified as a `number`, `bigint`, `string`,
+   * or `Uint8Array`. Defaults to `1`.
+   */ maxPriorityFeePerGas: (0, _superstruct.defaulted)((0, _superstruct.coerce)(_utils.StrictHexStruct, BytesLikeStruct, (value)=>(0, _utils.bytesToHex)((0, _utils.valueToBytes)(value))), (0, _utils.valueToBytes)(1)),
+    /**
+   * The nonce to use for the transaction. The nonce may be specified as a
+   * `number`, `bigint`, `string`, or `Uint8Array`. Defaults to `0`.
+   */ nonce: (0, _superstruct.defaulted)((0, _superstruct.coerce)(_utils.StrictHexStruct, BytesLikeStruct, (value)=>(0, _utils.bytesToHex)((0, _utils.valueToBytes)(value))), (0, _utils.valueToBytes)(0)),
+    /**
+   * The data to send with the transaction. The data may be specified as a
+   * `number`, `bigint`, `string`, or `Uint8Array`. Defaults to `0x`.
+   */ data: (0, _superstruct.defaulted)((0, _superstruct.coerce)((0, _superstruct.union)([
+        _utils.StrictHexStruct,
+        (0, _superstruct.literal)('0x')
+    ]), BytesLikeStruct, (value)=>(0, _utils.bytesToHex)((0, _utils.valueToBytes)(value))), '0x')
+});
+const SnapOptionsStruct = (0, _superstruct.object)({
+    /**
+   * The timeout in milliseconds to use for requests to the snap. Defaults to
+   * `1000`.
+   */ timeout: (0, _superstruct.defaulted)((0, _superstruct.optional)((0, _superstruct.number)()), 1000)
+});
+const InterfaceStruct = (0, _superstruct.type)({
+    content: (0, _superstruct.optional)(_snapsui.ComponentStruct)
+});
+const SnapResponseStruct = (0, _superstruct.assign)(InterfaceStruct, (0, _superstruct.object)({
+    id: (0, _superstruct.string)(),
+    response: (0, _superstruct.union)([
+        (0, _superstruct.object)({
+            result: _utils.JsonStruct
+        }),
+        (0, _superstruct.object)({
+            error: _utils.JsonStruct
+        })
+    ]),
+    notifications: (0, _superstruct.array)((0, _superstruct.object)({
+        id: (0, _superstruct.string)(),
+        message: (0, _superstruct.string)(),
+        type: (0, _superstruct.union)([
+            (0, _snapsutils.enumValue)(_rpcmethods.NotificationType.InApp),
+            (0, _snapsutils.enumValue)(_rpcmethods.NotificationType.Native)
+        ])
+    }))
+}));
+
+//# sourceMappingURL=structs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/internals/structs.ts"],"sourcesContent":["import { NotificationType } from '@metamask/rpc-methods';\nimport { ComponentStruct } from '@metamask/snaps-ui';\nimport { enumValue } from '@metamask/snaps-utils';\nimport {\n  bytesToHex,\n  JsonStruct,\n  StrictHexStruct,\n  valueToBytes,\n} from '@metamask/utils';\nimport { randomBytes } from 'crypto';\nimport {\n  array,\n  assign,\n  bigint,\n  coerce,\n  defaulted,\n  instance,\n  literal,\n  number,\n  object,\n  optional,\n  string,\n  type,\n  union,\n} from 'superstruct';\n\n// TODO: Export this from `@metamask/utils` instead.\nconst BytesLikeStruct = union([\n  bigint(),\n  number(),\n  string(),\n  instance(Uint8Array),\n]);\n\nexport const TransactionOptionsStruct = object({\n  /**\n   * The CAIP-2 chain ID to send the transaction on. Defaults to `eip155:1`.\n   */\n  chainId: defaulted(string(), 'eip155:1'),\n\n  /**\n   * The origin to send the transaction from. Defaults to `metamask.io`.\n   */\n  origin: defaulted(string(), 'metamask.io'),\n\n  /**\n   * The address to send the transaction from. Defaults to a randomly generated\n   * address.\n   */\n  // TODO: Move this coercer to `@metamask/utils`.\n  from: coerce(StrictHexStruct, optional(BytesLikeStruct), (value) => {\n    if (value) {\n      return valueToBytes(value);\n    }\n\n    return bytesToHex(randomBytes(20));\n  }),\n\n  /**\n   * The address to send the transaction to. Defaults to a randomly generated\n   * address.\n   */\n  // TODO: Move this coercer to `@metamask/utils`.\n  to: coerce(StrictHexStruct, optional(BytesLikeStruct), (value) => {\n    if (value) {\n      return valueToBytes(value);\n    }\n\n    return bytesToHex(randomBytes(20));\n  }),\n\n  /**\n   * The value to send with the transaction. The value may be specified as a\n   * `number`, `bigint`, `string`, or `Uint8Array`. Defaults to `0`.\n   */\n  value: defaulted(\n    coerce(StrictHexStruct, BytesLikeStruct, (value) =>\n      bytesToHex(valueToBytes(value)),\n    ),\n    '0x0',\n  ),\n\n  /**\n   * The gas limit to use for the transaction. The gas limit may be specified\n   * as a `number`, `bigint`, `string`, or `Uint8Array`. Defaults to `21_000`.\n   */\n  gasLimit: defaulted(\n    coerce(StrictHexStruct, BytesLikeStruct, (value) =>\n      bytesToHex(valueToBytes(value)),\n    ),\n    valueToBytes(21_000),\n  ),\n\n  /**\n   * The max fee per gas (in Wei) to use for the transaction. The max fee per\n   * gas may be specified as a `number`, `bigint`, `string`, or `Uint8Array`.\n   * Defaults to `1`.\n   */\n  maxFeePerGas: defaulted(\n    coerce(StrictHexStruct, BytesLikeStruct, (value) =>\n      bytesToHex(valueToBytes(value)),\n    ),\n    valueToBytes(1),\n  ),\n\n  /**\n   * The max priority fee per gas (in Wei) to use for the transaction. The max\n   * priority fee per gas may be specified as a `number`, `bigint`, `string`,\n   * or `Uint8Array`. Defaults to `1`.\n   */\n  maxPriorityFeePerGas: defaulted(\n    coerce(StrictHexStruct, BytesLikeStruct, (value) =>\n      bytesToHex(valueToBytes(value)),\n    ),\n    valueToBytes(1),\n  ),\n\n  /**\n   * The nonce to use for the transaction. The nonce may be specified as a\n   * `number`, `bigint`, `string`, or `Uint8Array`. Defaults to `0`.\n   */\n  nonce: defaulted(\n    coerce(StrictHexStruct, BytesLikeStruct, (value) =>\n      bytesToHex(valueToBytes(value)),\n    ),\n    valueToBytes(0),\n  ),\n\n  /**\n   * The data to send with the transaction. The data may be specified as a\n   * `number`, `bigint`, `string`, or `Uint8Array`. Defaults to `0x`.\n   */\n  data: defaulted(\n    coerce(union([StrictHexStruct, literal('0x')]), BytesLikeStruct, (value) =>\n      bytesToHex(valueToBytes(value)),\n    ),\n    '0x',\n  ),\n});\n\nexport const SnapOptionsStruct = object({\n  /**\n   * The timeout in milliseconds to use for requests to the snap. Defaults to\n   * `1000`.\n   */\n  timeout: defaulted(optional(number()), 1000),\n});\n\nexport const InterfaceStruct = type({\n  content: optional(ComponentStruct),\n});\n\nexport const SnapResponseStruct = assign(\n  InterfaceStruct,\n  object({\n    id: string(),\n\n    response: union([\n      object({\n        result: JsonStruct,\n      }),\n      object({\n        error: JsonStruct,\n      }),\n    ]),\n\n    notifications: array(\n      object({\n        id: string(),\n        message: string(),\n        type: union([\n          enumValue(NotificationType.InApp),\n          enumValue(NotificationType.Native),\n        ]),\n      }),\n    ),\n  }),\n);\n"],"names":["TransactionOptionsStruct","SnapOptionsStruct","InterfaceStruct","SnapResponseStruct","BytesLikeStruct","union","bigint","number","string","instance","Uint8Array","object","chainId","defaulted","origin","from","coerce","StrictHexStruct","optional","value","valueToBytes","bytesToHex","randomBytes","to","gasLimit","maxFeePerGas","maxPriorityFeePerGas","nonce","data","literal","timeout","type","content","ComponentStruct","assign","id","response","result","JsonStruct","error","notifications","array","message","enumValue","NotificationType","InApp","Native"],"mappings":"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"}

package/dist/cjs/internals/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/internals/types.ts"],"names":[],"mappings":""}

package/dist/cjs/internals/wait-for.js

@@ -0,0 +1,63 @@
+"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, {
+    waitFor: function() {
+        return waitFor;
+    },
+    waitForResponse: function() {
+        return waitForResponse;
+    }
+});
+const _utils = require("@metamask/utils");
+const _pptrtestinglibrary = require("pptr-testing-library");
+const _logger = require("./logger");
+const log = (0, _utils.createModuleLogger)(_logger.rootLogger, 'wait-for');
+async function waitFor(fn, { timeout = 3000, message } = {}) {
+    try {
+        let result;
+        await (0, _pptrtestinglibrary.waitFor)(// eslint-disable-next-line @typescript-eslint/no-misused-promises
+        async ()=>{
+            // Puppeteer's `waitFor` function does not support returning a value
+            // from the condition function, so we need to use a variable outside
+            // the scope of the function.
+            result = await fn();
+        }, {
+            timeout
+        });
+        (0, _utils.assert)(result !== undefined);
+        return result;
+    } catch (error) {
+        if (message) {
+            throw new Error(message);
+        }
+        throw error;
+    }
+}
+async function waitForResponse(page, type) {
+    log('Waiting for response of type %s.', type);
+    return await page.evaluate(async (_type)=>{
+        return new Promise((resolve)=>{
+            window.__SIMULATOR_API__.dispatch({
+                type: `${_type}/clearResponse`
+            });
+            const unsubscribe = window.__SIMULATOR_API__.subscribe(()=>{
+                const state = window.__SIMULATOR_API__.getState();
+                const { pending, response } = state[_type];
+                if (!pending && response) {
+                    unsubscribe();
+                    resolve(response);
+                }
+            });
+        });
+    }, type);
+}
+
+//# sourceMappingURL=wait-for.js.map

package/dist/cjs/internals/wait-for.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/internals/wait-for.ts"],"sourcesContent":["import { HandlerType } from '@metamask/snaps-utils';\nimport { assert, createModuleLogger } from '@metamask/utils';\nimport { waitFor as waitForPuppeteer } from 'pptr-testing-library';\nimport { Page } from 'puppeteer';\n\nimport { SnapResponse } from '../types';\nimport { rootLogger } from './logger';\n\nexport type WaitForOptions = {\n  /**\n   * The timeout in milliseconds.\n   */\n  timeout?: number;\n\n  /**\n   * The error message to throw if the condition is not met.\n   */\n  message?: string;\n};\n\nconst log = createModuleLogger(rootLogger, 'wait-for');\n\n/**\n * Wait for a condition to be true. This is a wrapper around\n * `pptr-testing-library`'s `waitFor` function, with the addition of a custom\n * error message.\n *\n * @param fn - The condition to wait for.\n * @param options - The options.\n * @param options.timeout - The timeout in milliseconds.\n * @param options.message - The error message to throw if the condition is not\n * met.\n * @returns A promise that resolves when the condition is met. The promise\n * resolves to the return value of the condition function.\n */\nexport async function waitFor<Result>(\n  fn: () => Promise<Result>,\n  { timeout = 3000, message }: WaitForOptions = {},\n) {\n  try {\n    let result: Result | undefined;\n\n    await waitForPuppeteer(\n      // eslint-disable-next-line @typescript-eslint/no-misused-promises\n      async () => {\n        // Puppeteer's `waitFor` function does not support returning a value\n        // from the condition function, so we need to use a variable outside\n        // the scope of the function.\n        result = await fn();\n      },\n      {\n        timeout,\n      },\n    );\n\n    assert(result !== undefined);\n    return result;\n  } catch (error) {\n    if (message) {\n      throw new Error(message);\n    }\n\n    throw error;\n  }\n}\n\n/**\n * Wait for a JSON-RPC response.\n *\n * @param page - The page to wait for the response on.\n * @param type - The type of response to wait for.\n * @returns The JSON-RPC response.\n */\nexport async function waitForResponse(\n  page: Page,\n  type:\n    | HandlerType.OnTransaction\n    | HandlerType.OnRpcRequest\n    | HandlerType.OnCronjob,\n) {\n  log('Waiting for response of type %s.', type);\n\n  return await page.evaluate(async (_type) => {\n    return new Promise<SnapResponse['response']>((resolve) => {\n      window.__SIMULATOR_API__.dispatch({\n        type: `${_type}/clearResponse`,\n      });\n\n      const unsubscribe = window.__SIMULATOR_API__.subscribe(() => {\n        const state = window.__SIMULATOR_API__.getState();\n        const { pending, response } = state[_type];\n\n        if (!pending && response) {\n          unsubscribe();\n\n          resolve(response);\n        }\n      });\n    });\n  }, type);\n}\n"],"names":["waitFor","waitForResponse","log","createModuleLogger","rootLogger","fn","timeout","message","result","waitForPuppeteer","assert","undefined","error","Error","page","type","evaluate","_type","Promise","resolve","window","__SIMULATOR_API__","dispatch","unsubscribe","subscribe","state","getState","pending","response"],"mappings":";;;;;;;;;;;IAmCsBA,OAAO;eAAPA;;IAsCAC,eAAe;eAAfA;;;uBAxEqB;oCACC;wBAIjB;AAc3B,MAAMC,MAAMC,IAAAA,yBAAkB,EAACC,kBAAU,EAAE;AAepC,eAAeJ,QACpBK,EAAyB,EACzB,EAAEC,UAAU,IAAI,EAAEC,OAAO,EAAkB,GAAG,CAAC,CAAC;IAEhD,IAAI;QACF,IAAIC;QAEJ,MAAMC,IAAAA,2BAAgB,EACpB,kEAAkE;QAClE;YACE,oEAAoE;YACpE,oEAAoE;YACpE,6BAA6B;YAC7BD,SAAS,MAAMH;QACjB,GACA;YACEC;QACF;QAGFI,IAAAA,aAAM,EAACF,WAAWG;QAClB,OAAOH;IACT,EAAE,OAAOI,OAAO;QACd,IAAIL,SAAS;YACX,MAAM,IAAIM,MAAMN;QAClB;QAEA,MAAMK;IACR;AACF;AASO,eAAeX,gBACpBa,IAAU,EACVC,IAGyB;IAEzBb,IAAI,oCAAoCa;IAExC,OAAO,MAAMD,KAAKE,QAAQ,CAAC,OAAOC;QAChC,OAAO,IAAIC,QAAkC,CAACC;YAC5CC,OAAOC,iBAAiB,CAACC,QAAQ,CAAC;gBAChCP,MAAM,CAAC,EAAEE,MAAM,cAAc,CAAC;YAChC;YAEA,MAAMM,cAAcH,OAAOC,iBAAiB,CAACG,SAAS,CAAC;gBACrD,MAAMC,QAAQL,OAAOC,iBAAiB,CAACK,QAAQ;gBAC/C,MAAM,EAAEC,OAAO,EAAEC,QAAQ,EAAE,GAAGH,KAAK,CAACR,MAAM;gBAE1C,IAAI,CAACU,WAAWC,UAAU;oBACxBL;oBAEAJ,QAAQS;gBACV;YACF;QACF;IACF,GAAGb;AACL"}