@metamask/snaps-utils 6.1.0 → 7.0.1

package/dist/cjs/errors.js

@@ -1,221 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    SNAP_ERROR_WRAPPER_CODE: function() {
-        return SNAP_ERROR_WRAPPER_CODE;
-    },
-    SNAP_ERROR_WRAPPER_MESSAGE: function() {
-        return SNAP_ERROR_WRAPPER_MESSAGE;
-    },
-    WrappedSnapError: function() {
-        return WrappedSnapError;
-    },
-    isSnapError: function() {
-        return isSnapError;
-    },
-    isSerializedSnapError: function() {
-        return isSerializedSnapError;
-    },
-    isWrappedSnapError: function() {
-        return isWrappedSnapError;
-    },
-    unwrapError: function() {
-        return unwrapError;
-    }
-});
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapssdk = require("@metamask/snaps-sdk");
-const _utils = require("@metamask/utils");
-function _check_private_redeclaration(obj, privateCollection) {
-    if (privateCollection.has(obj)) {
-        throw new TypeError("Cannot initialize the same private elements twice on an object");
-    }
-}
-function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
-    return descriptor.value;
-}
-function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
-        if (!descriptor.writable) {
-            throw new TypeError("attempted to set read only private field");
-        }
-        descriptor.value = value;
-    }
-}
-function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
-    return privateMap.get(receiver);
-}
-function _class_private_field_get(receiver, privateMap) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
-    return _class_apply_descriptor_get(receiver, descriptor);
-}
-function _class_private_field_init(obj, privateMap, value) {
-    _check_private_redeclaration(obj, privateMap);
-    privateMap.set(obj, value);
-}
-function _class_private_field_set(receiver, privateMap, value) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
-    _class_apply_descriptor_set(receiver, descriptor, value);
-    return value;
-}
-const SNAP_ERROR_WRAPPER_CODE = -31001;
-const SNAP_ERROR_WRAPPER_MESSAGE = 'Wrapped Snap Error';
-var _error = /*#__PURE__*/ new WeakMap(), _message = /*#__PURE__*/ new WeakMap(), _stack = /*#__PURE__*/ new WeakMap();
-class WrappedSnapError extends Error {
-    /**
-   * The error name.
-   *
-   * @returns The error name.
-   */ get name() {
-        return 'WrappedSnapError';
-    }
-    /**
-   * The error message.
-   *
-   * @returns The error message.
-   */ get message() {
-        return _class_private_field_get(this, _message);
-    }
-    /**
-   * The error stack.
-   *
-   * @returns The error stack.
-   */ get stack() {
-        return _class_private_field_get(this, _stack);
-    }
-    /**
-   * Convert the error to a JSON object.
-   *
-   * @returns The JSON object.
-   */ toJSON() {
-        const cause = isSnapError(_class_private_field_get(this, _error)) ? _class_private_field_get(this, _error).serialize() : (0, _rpcerrors.serializeCause)(_class_private_field_get(this, _error));
-        return {
-            code: SNAP_ERROR_WRAPPER_CODE,
-            message: SNAP_ERROR_WRAPPER_MESSAGE,
-            data: {
-                cause
-            }
-        };
-    }
-    /**
-   * Serialize the error to a JSON object. This is called by
-   * `@metamask/rpc-errors` when serializing the error.
-   *
-   * @returns The JSON object.
-   */ serialize() {
-        return this.toJSON();
-    }
-    /**
-   * Create a new `WrappedSnapError`.
-   *
-   * @param error - The error to create the `WrappedSnapError` from.
-   */ constructor(error){
-        const message = (0, _snapssdk.getErrorMessage)(error);
-        super(message);
-        _class_private_field_init(this, _error, {
-            writable: true,
-            value: void 0
-        });
-        _class_private_field_init(this, _message, {
-            writable: true,
-            value: void 0
-        });
-        _class_private_field_init(this, _stack, {
-            writable: true,
-            value: void 0
-        });
-        _class_private_field_set(this, _error, error);
-        _class_private_field_set(this, _message, message);
-        _class_private_field_set(this, _stack, (0, _snapssdk.getErrorStack)(error));
-    }
-}
-function isSnapError(error) {
-    if ((0, _utils.isObject)(error) && 'serialize' in error && typeof error.serialize === 'function') {
-        const serialized = error.serialize();
-        return (0, _utils.isJsonRpcError)(serialized) && isSerializedSnapError(serialized);
-    }
-    return false;
-}
-function isSerializedSnapError(error) {
-    return error.code === _snapssdk.SNAP_ERROR_CODE && error.message === _snapssdk.SNAP_ERROR_MESSAGE;
-}
-function isWrappedSnapError(error) {
-    return (0, _utils.isJsonRpcError)(error) && error.code === SNAP_ERROR_WRAPPER_CODE && error.message === SNAP_ERROR_WRAPPER_MESSAGE;
-}
-/**
- * Get a JSON-RPC error with the given code, message, stack, and data.
- *
- * @param code - The error code.
- * @param message - The error message.
- * @param stack - The error stack.
- * @param data - Additional data for the error.
- * @returns The JSON-RPC error.
- */ function getJsonRpcError(code, message, stack, data) {
-    const error = new _rpcerrors.JsonRpcError(code, message, data);
-    error.stack = stack;
-    return error;
-}
-function unwrapError(error) {
-    // This logic is a bit complicated, but it's necessary to handle all the
-    // different types of errors that can be thrown by a Snap.
-    // If the error is a wrapped Snap error, unwrap it.
-    if (isWrappedSnapError(error)) {
-        // The wrapped error can be a JSON-RPC error, or an unknown error. If it's
-        // a JSON-RPC error, we can unwrap it further.
-        if ((0, _utils.isJsonRpcError)(error.data.cause)) {
-            // If the JSON-RPC error is a wrapped Snap error, unwrap it further.
-            if (isSerializedSnapError(error.data.cause)) {
-                const { code, message, stack, data } = error.data.cause.data.cause;
-                return [
-                    getJsonRpcError(code, message, stack, data),
-                    true
-                ];
-            }
-            // Otherwise, we use the original JSON-RPC error.
-            const { code, message, stack, data } = error.data.cause;
-            return [
-                getJsonRpcError(code, message, stack, data),
-                false
-            ];
-        }
-        // Otherwise, we throw an internal error with the wrapped error as the
-        // message.
-        return [
-            getJsonRpcError(_rpcerrors.errorCodes.rpc.internal, (0, _snapssdk.getErrorMessage)(error.data.cause), (0, _snapssdk.getErrorStack)(error.data.cause)),
-            false
-        ];
-    }
-    // The error can be a non-wrapped JSON-RPC error, in which case we can just
-    // re-throw it with the same code, message, and data.
-    if ((0, _utils.isJsonRpcError)(error)) {
-        const { code, message, stack, data } = error;
-        return [
-            getJsonRpcError(code, message, stack, data),
-            false
-        ];
-    }
-    // If the error is not a wrapped error, we don't know how to handle it, so we
-    // throw an internal error with the error as the message.
-    return [
-        getJsonRpcError(_rpcerrors.errorCodes.rpc.internal, (0, _snapssdk.getErrorMessage)(error), (0, _snapssdk.getErrorStack)(error)),
-        false
-    ];
-}
-
-//# sourceMappingURL=errors.js.map

package/dist/cjs/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/errors.ts"],"sourcesContent":["import {\n  errorCodes,\n  JsonRpcError as RpcError,\n  serializeCause,\n} from '@metamask/rpc-errors';\nimport type { DataWithOptionalCause } from '@metamask/rpc-errors';\nimport type { SerializedSnapError, SnapError } from '@metamask/snaps-sdk';\nimport {\n  getErrorMessage,\n  getErrorStack,\n  SNAP_ERROR_CODE,\n  SNAP_ERROR_MESSAGE,\n} from '@metamask/snaps-sdk';\nimport type { Json, JsonRpcError } from '@metamask/utils';\nimport { isObject, isJsonRpcError } from '@metamask/utils';\n\nexport const SNAP_ERROR_WRAPPER_CODE = -31001;\nexport const SNAP_ERROR_WRAPPER_MESSAGE = 'Wrapped Snap Error';\n\nexport type SerializedSnapErrorWrapper = {\n  code: typeof SNAP_ERROR_WRAPPER_CODE;\n  message: typeof SNAP_ERROR_WRAPPER_MESSAGE;\n  data: {\n    cause: Json;\n  };\n};\n\nexport class WrappedSnapError extends Error {\n  readonly #error: unknown;\n\n  readonly #message: string;\n\n  readonly #stack?: string;\n\n  /**\n   * Create a new `WrappedSnapError`.\n   *\n   * @param error - The error to create the `WrappedSnapError` from.\n   */\n  constructor(error: unknown) {\n    const message = getErrorMessage(error);\n    super(message);\n\n    this.#error = error;\n    this.#message = message;\n    this.#stack = getErrorStack(error);\n  }\n\n  /**\n   * The error name.\n   *\n   * @returns The error name.\n   */\n  get name() {\n    return 'WrappedSnapError';\n  }\n\n  /**\n   * The error message.\n   *\n   * @returns The error message.\n   */\n  get message() {\n    return this.#message;\n  }\n\n  /**\n   * The error stack.\n   *\n   * @returns The error stack.\n   */\n  get stack() {\n    return this.#stack;\n  }\n\n  /**\n   * Convert the error to a JSON object.\n   *\n   * @returns The JSON object.\n   */\n  toJSON(): SerializedSnapErrorWrapper {\n    const cause = isSnapError(this.#error)\n      ? this.#error.serialize()\n      : serializeCause(this.#error);\n\n    return {\n      code: SNAP_ERROR_WRAPPER_CODE,\n      message: SNAP_ERROR_WRAPPER_MESSAGE,\n      data: {\n        cause,\n      },\n    };\n  }\n\n  /**\n   * Serialize the error to a JSON object. This is called by\n   * `@metamask/rpc-errors` when serializing the error.\n   *\n   * @returns The JSON object.\n   */\n  serialize() {\n    return this.toJSON();\n  }\n}\n\n/**\n * Check if an object is a `SnapError`.\n *\n * @param error - The object to check.\n * @returns Whether the object is a `SnapError`.\n */\nexport function isSnapError(error: unknown): error is SnapError {\n  if (\n    isObject(error) &&\n    'serialize' in error &&\n    typeof error.serialize === 'function'\n  ) {\n    const serialized = error.serialize();\n    return isJsonRpcError(serialized) && isSerializedSnapError(serialized);\n  }\n\n  return false;\n}\n\n/**\n * Check if a JSON-RPC error is a `SnapError`.\n *\n * @param error - The object to check.\n * @returns Whether the object is a `SnapError`.\n */\nexport function isSerializedSnapError(\n  error: JsonRpcError,\n): error is SerializedSnapError {\n  return error.code === SNAP_ERROR_CODE && error.message === SNAP_ERROR_MESSAGE;\n}\n\n/**\n * Check if a JSON-RPC error is a `WrappedSnapError`.\n *\n * @param error - The object to check.\n * @returns Whether the object is a `WrappedSnapError`.\n */\nexport function isWrappedSnapError(\n  error: unknown,\n): error is SerializedSnapErrorWrapper {\n  return (\n    isJsonRpcError(error) &&\n    error.code === SNAP_ERROR_WRAPPER_CODE &&\n    error.message === SNAP_ERROR_WRAPPER_MESSAGE\n  );\n}\n\n/**\n * Get a JSON-RPC error with the given code, message, stack, and data.\n *\n * @param code - The error code.\n * @param message - The error message.\n * @param stack - The error stack.\n * @param data - Additional data for the error.\n * @returns The JSON-RPC error.\n */\nfunction getJsonRpcError(\n  code: number,\n  message: string,\n  stack?: string,\n  data?: Json,\n) {\n  const error = new RpcError(code, message, data);\n  error.stack = stack;\n\n  return error;\n}\n\n/**\n * Attempt to unwrap an unknown error to a `JsonRpcError`. This function will\n * try to get the error code, message, and data from the error, and return a\n * `JsonRpcError` with those properties.\n *\n * @param error - The error to unwrap.\n * @returns A tuple containing the unwrapped error and a boolean indicating\n * whether the error was handled.\n */\nexport function unwrapError(\n  error: unknown,\n): [error: RpcError<DataWithOptionalCause>, isHandled: boolean] {\n  // This logic is a bit complicated, but it's necessary to handle all the\n  // different types of errors that can be thrown by a Snap.\n\n  // If the error is a wrapped Snap error, unwrap it.\n  if (isWrappedSnapError(error)) {\n    // The wrapped error can be a JSON-RPC error, or an unknown error. If it's\n    // a JSON-RPC error, we can unwrap it further.\n    if (isJsonRpcError(error.data.cause)) {\n      // If the JSON-RPC error is a wrapped Snap error, unwrap it further.\n      if (isSerializedSnapError(error.data.cause)) {\n        const { code, message, stack, data } = error.data.cause.data.cause;\n        return [getJsonRpcError(code, message, stack, data), true];\n      }\n\n      // Otherwise, we use the original JSON-RPC error.\n      const { code, message, stack, data } = error.data.cause;\n      return [getJsonRpcError(code, message, stack, data), false];\n    }\n\n    // Otherwise, we throw an internal error with the wrapped error as the\n    // message.\n    return [\n      getJsonRpcError(\n        errorCodes.rpc.internal,\n        getErrorMessage(error.data.cause),\n        getErrorStack(error.data.cause),\n      ),\n      false,\n    ];\n  }\n\n  // The error can be a non-wrapped JSON-RPC error, in which case we can just\n  // re-throw it with the same code, message, and data.\n  if (isJsonRpcError(error)) {\n    const { code, message, stack, data } = error;\n    return [getJsonRpcError(code, message, stack, data), false];\n  }\n\n  // If the error is not a wrapped error, we don't know how to handle it, so we\n  // throw an internal error with the error as the message.\n  return [\n    getJsonRpcError(\n      errorCodes.rpc.internal,\n      getErrorMessage(error),\n      getErrorStack(error),\n    ),\n    false,\n  ];\n}\n"],"names":["SNAP_ERROR_WRAPPER_CODE","SNAP_ERROR_WRAPPER_MESSAGE","WrappedSnapError","isSnapError","isSerializedSnapError","isWrappedSnapError","unwrapError","Error","name","message","stack","toJSON","cause","error","serialize","serializeCause","code","data","constructor","getErrorMessage","getErrorStack","isObject","serialized","isJsonRpcError","SNAP_ERROR_CODE","SNAP_ERROR_MESSAGE","getJsonRpcError","RpcError","errorCodes","rpc","internal"],"mappings":"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"}

package/dist/cjs/eval-worker.js

@@ -1,44 +0,0 @@
-// eslint-disable-next-line import/no-unassigned-import
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-require("ses/lockdown");
-const _fs = require("fs");
-const _handlertypes = require("./handler-types");
-const _mock = require("./mock");
-lockdown({
-    consoleTaming: 'unsafe',
-    errorTaming: 'unsafe',
-    mathTaming: 'unsafe',
-    dateTaming: 'unsafe',
-    overrideTaming: 'severe',
-    // We disable domain taming, because it does not work in certain cases when
-    // running tests. This is unlikely to be a problem in production, because
-    // Node.js domains are deprecated.
-    domainTaming: 'unsafe'
-});
-const snapFilePath = process.argv[2];
-const snapModule = {
-    exports: {}
-};
-const compartment = new Compartment({
-    ...(0, _mock.generateMockEndowments)(),
-    module: snapModule,
-    exports: snapModule.exports
-});
-// Mirror BaseSnapExecutor
-compartment.globalThis.self = compartment.globalThis;
-compartment.globalThis.global = compartment.globalThis;
-compartment.globalThis.window = compartment.globalThis;
-compartment.evaluate((0, _fs.readFileSync)(snapFilePath, 'utf8'));
-const invalidExports = Object.keys(snapModule.exports).filter((snapExport)=>!_handlertypes.SNAP_EXPORT_NAMES.includes(snapExport));
-if (invalidExports.length > 0) {
-    // eslint-disable-next-line no-console
-    console.warn(`Invalid snap exports detected:\n${invalidExports.join('\n')}`);
-}
-// To ensure the worker exits we explicitly call exit here
-// If we didn't the eval would wait for timers set during Compartment eval
-process.exit(0);
-
-//# sourceMappingURL=eval-worker.js.map

package/dist/cjs/eval-worker.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/eval-worker.ts"],"sourcesContent":["// eslint-disable-next-line import/no-unassigned-import\nimport 'ses/lockdown';\n\nimport { readFileSync } from 'fs';\n\nimport type { HandlerType } from './handler-types';\nimport { SNAP_EXPORT_NAMES } from './handler-types';\nimport { generateMockEndowments } from './mock';\n\ndeclare let lockdown: any, Compartment: any;\n\nlockdown({\n  consoleTaming: 'unsafe',\n  errorTaming: 'unsafe',\n  mathTaming: 'unsafe',\n  dateTaming: 'unsafe',\n  overrideTaming: 'severe',\n\n  // We disable domain taming, because it does not work in certain cases when\n  // running tests. This is unlikely to be a problem in production, because\n  // Node.js domains are deprecated.\n  domainTaming: 'unsafe',\n});\n\nconst snapFilePath = process.argv[2];\n\nconst snapModule: { exports?: any } = { exports: {} };\n\nconst compartment = new Compartment({\n  ...generateMockEndowments(),\n  module: snapModule,\n  exports: snapModule.exports,\n});\n\n// Mirror BaseSnapExecutor\ncompartment.globalThis.self = compartment.globalThis;\ncompartment.globalThis.global = compartment.globalThis;\ncompartment.globalThis.window = compartment.globalThis;\n\ncompartment.evaluate(readFileSync(snapFilePath, 'utf8'));\n\nconst invalidExports = Object.keys(snapModule.exports).filter(\n  (snapExport) => !SNAP_EXPORT_NAMES.includes(snapExport as HandlerType),\n);\n\nif (invalidExports.length > 0) {\n  // eslint-disable-next-line no-console\n  console.warn(`Invalid snap exports detected:\\n${invalidExports.join('\\n')}`);\n}\n\n// To ensure the worker exits we explicitly call exit here\n// If we didn't the eval would wait for timers set during Compartment eval\nprocess.exit(0);\n"],"names":["lockdown","consoleTaming","errorTaming","mathTaming","dateTaming","overrideTaming","domainTaming","snapFilePath","process","argv","snapModule","exports","compartment","Compartment","generateMockEndowments","module","globalThis","self","global","window","evaluate","readFileSync","invalidExports","Object","keys","filter","snapExport","SNAP_EXPORT_NAMES","includes","length","console","warn","join","exit"],"mappings":"AAAA,uDAAuD;;;;;QAChD;oBAEsB;8BAGK;sBACK;AAIvCA,SAAS;IACPC,eAAe;IACfC,aAAa;IACbC,YAAY;IACZC,YAAY;IACZC,gBAAgB;IAEhB,2EAA2E;IAC3E,yEAAyE;IACzE,kCAAkC;IAClCC,cAAc;AAChB;AAEA,MAAMC,eAAeC,QAAQC,IAAI,CAAC,EAAE;AAEpC,MAAMC,aAAgC;IAAEC,SAAS,CAAC;AAAE;AAEpD,MAAMC,cAAc,IAAIC,YAAY;IAClC,GAAGC,IAAAA,4BAAsB,GAAE;IAC3BC,QAAQL;IACRC,SAASD,WAAWC,OAAO;AAC7B;AAEA,0BAA0B;AAC1BC,YAAYI,UAAU,CAACC,IAAI,GAAGL,YAAYI,UAAU;AACpDJ,YAAYI,UAAU,CAACE,MAAM,GAAGN,YAAYI,UAAU;AACtDJ,YAAYI,UAAU,CAACG,MAAM,GAAGP,YAAYI,UAAU;AAEtDJ,YAAYQ,QAAQ,CAACC,IAAAA,gBAAY,EAACd,cAAc;AAEhD,MAAMe,iBAAiBC,OAAOC,IAAI,CAACd,WAAWC,OAAO,EAAEc,MAAM,CAC3D,CAACC,aAAe,CAACC,+BAAiB,CAACC,QAAQ,CAACF;AAG9C,IAAIJ,eAAeO,MAAM,GAAG,GAAG;IAC7B,sCAAsC;IACtCC,QAAQC,IAAI,CAAC,CAAC,gCAAgC,EAAET,eAAeU,IAAI,CAAC,MAAM,CAAC;AAC7E;AAEA,0DAA0D;AAC1D,0EAA0E;AAC1ExB,QAAQyB,IAAI,CAAC"}

package/dist/cjs/eval.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    SnapEvalError: function() {
-        return SnapEvalError;
-    },
-    evalBundle: function() {
-        return evalBundle;
-    }
-});
-const _utils = require("@metamask/utils");
-const _child_process = require("child_process");
-const _path = require("path");
-const _fs = require("./fs");
-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;
-}
-class SnapEvalError extends Error {
-    constructor(message, output){
-        super(message);
-        _define_property(this, "output", void 0);
-        this.name = 'SnapEvalError';
-        this.output = output;
-    }
-}
-async function evalBundle(bundlePath) {
-    await (0, _fs.validateFilePath)(bundlePath);
-    return new Promise((resolve, reject)=>{
-        const worker = (0, _child_process.fork)((0, _path.join)(__dirname, 'eval-worker.js'), [
-            bundlePath
-        ], {
-            // To avoid printing the output of the worker to the console, we set
-            // `stdio` to `pipe` and handle the output ourselves.
-            stdio: 'pipe'
-        });
-        let stdout = '';
-        let stderr = '';
-        (0, _utils.assert)(worker.stdout, '`stdout` should be defined.');
-        (0, _utils.assert)(worker.stderr, '`stderr` should be defined.');
-        worker.stdout.on('data', (data)=>{
-            stdout += data.toString();
-        });
-        worker.stderr.on('data', (data)=>{
-            stderr += data.toString();
-        });
-        worker.on('exit', (exitCode)=>{
-            const output = {
-                stdout,
-                stderr
-            };
-            if (exitCode === 0) {
-                return resolve(output);
-            }
-            return reject(new SnapEvalError(`Process exited with non-zero exit code: ${exitCode}.`, output));
-        });
-    });
-}
-
-//# sourceMappingURL=eval.js.map

package/dist/cjs/eval.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/eval.ts"],"sourcesContent":["import { assert } from '@metamask/utils';\nimport { fork } from 'child_process';\nimport { join } from 'path';\n\nimport { validateFilePath } from './fs';\n\nexport type EvalOutput = {\n  stdout: string;\n  stderr: string;\n};\n\nexport class SnapEvalError extends Error {\n  readonly output: EvalOutput;\n\n  constructor(message: string, output: EvalOutput) {\n    super(message);\n\n    this.name = 'SnapEvalError';\n    this.output = output;\n  }\n}\n\n/**\n * Spawn a new process to run the provided bundle in.\n *\n * @param bundlePath - The path to the bundle to run.\n * @returns `null` if the worker ran successfully.\n * @throws If the worker failed to run successfully.\n */\nexport async function evalBundle(bundlePath: string): Promise<EvalOutput> {\n  await validateFilePath(bundlePath);\n\n  return new Promise((resolve, reject) => {\n    const worker = fork(join(__dirname, 'eval-worker.js'), [bundlePath], {\n      // To avoid printing the output of the worker to the console, we set\n      // `stdio` to `pipe` and handle the output ourselves.\n      stdio: 'pipe',\n    });\n\n    let stdout = '';\n    let stderr = '';\n\n    assert(worker.stdout, '`stdout` should be defined.');\n    assert(worker.stderr, '`stderr` should be defined.');\n\n    worker.stdout.on('data', (data: Buffer) => {\n      stdout += data.toString();\n    });\n\n    worker.stderr.on('data', (data: Buffer) => {\n      stderr += data.toString();\n    });\n\n    worker.on('exit', (exitCode: number) => {\n      const output = {\n        stdout,\n        stderr,\n      };\n\n      if (exitCode === 0) {\n        return resolve(output);\n      }\n\n      return reject(\n        new SnapEvalError(\n          `Process exited with non-zero exit code: ${exitCode}.`,\n          output,\n        ),\n      );\n    });\n  });\n}\n"],"names":["SnapEvalError","evalBundle","Error","constructor","message","output","name","bundlePath","validateFilePath","Promise","resolve","reject","worker","fork","join","__dirname","stdio","stdout","stderr","assert","on","data","toString","exitCode"],"mappings":";;;;;;;;;;;IAWaA,aAAa;eAAbA;;IAkBSC,UAAU;eAAVA;;;uBA7BC;+BACF;sBACA;oBAEY;;;;;;;;;;;;;;AAO1B,MAAMD,sBAAsBE;IAGjCC,YAAYC,OAAe,EAAEC,MAAkB,CAAE;QAC/C,KAAK,CAACD;QAHR,uBAASC,UAAT,KAAA;QAKE,IAAI,CAACC,IAAI,GAAG;QACZ,IAAI,CAACD,MAAM,GAAGA;IAChB;AACF;AASO,eAAeJ,WAAWM,UAAkB;IACjD,MAAMC,IAAAA,oBAAgB,EAACD;IAEvB,OAAO,IAAIE,QAAQ,CAACC,SAASC;QAC3B,MAAMC,SAASC,IAAAA,mBAAI,EAACC,IAAAA,UAAI,EAACC,WAAW,mBAAmB;YAACR;SAAW,EAAE;YACnE,oEAAoE;YACpE,qDAAqD;YACrDS,OAAO;QACT;QAEA,IAAIC,SAAS;QACb,IAAIC,SAAS;QAEbC,IAAAA,aAAM,EAACP,OAAOK,MAAM,EAAE;QACtBE,IAAAA,aAAM,EAACP,OAAOM,MAAM,EAAE;QAEtBN,OAAOK,MAAM,CAACG,EAAE,CAAC,QAAQ,CAACC;YACxBJ,UAAUI,KAAKC,QAAQ;QACzB;QAEAV,OAAOM,MAAM,CAACE,EAAE,CAAC,QAAQ,CAACC;YACxBH,UAAUG,KAAKC,QAAQ;QACzB;QAEAV,OAAOQ,EAAE,CAAC,QAAQ,CAACG;YACjB,MAAMlB,SAAS;gBACbY;gBACAC;YACF;YAEA,IAAIK,aAAa,GAAG;gBAClB,OAAOb,QAAQL;YACjB;YAEA,OAAOM,OACL,IAAIX,cACF,CAAC,wCAAwC,EAAEuB,SAAS,CAAC,CAAC,EACtDlB;QAGN;IACF;AACF"}

package/dist/cjs/fs.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    isDirectory: function() {
-        return isDirectory;
-    },
-    isFile: function() {
-        return isFile;
-    },
-    readJsonFile: function() {
-        return readJsonFile;
-    },
-    getOutfilePath: function() {
-        return getOutfilePath;
-    },
-    validateOutfileName: function() {
-        return validateOutfileName;
-    },
-    validateFilePath: function() {
-        return validateFilePath;
-    },
-    validateDirPath: function() {
-        return validateDirPath;
-    },
-    useTemporaryFile: function() {
-        return useTemporaryFile;
-    }
-});
-const _fs = require("fs");
-const _os = /*#__PURE__*/ _interop_require_default(require("os"));
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _json = require("./json");
-const _virtualfile = require("./virtual-file");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-async function isDirectory(pathString, createDir) {
-    try {
-        const stats = await _fs.promises.stat(pathString);
-        return stats.isDirectory();
-    } catch (error) {
-        if (error.code === 'ENOENT') {
-            if (!createDir) {
-                return false;
-            }
-            await _fs.promises.mkdir(pathString, {
-                recursive: true
-            });
-            return true;
-        }
-        return false;
-    }
-}
-async function isFile(pathString) {
-    try {
-        const stats = await _fs.promises.stat(pathString);
-        return stats.isFile();
-    } catch (error) {
-        return false;
-    }
-}
-async function readJsonFile(pathString) {
-    if (!pathString.endsWith('.json')) {
-        throw new Error('The specified file must be a ".json" file.');
-    }
-    let file;
-    try {
-        file = await (0, _virtualfile.readVirtualFile)(pathString, 'utf8');
-    } catch (error) {
-        if (error.code === 'ENOENT') {
-            throw new Error(`Could not find '${pathString}'. Please ensure that the file exists.`);
-        }
-        throw error;
-    }
-    file.result = (0, _json.parseJson)(file.toString());
-    return file;
-}
-function getOutfilePath(outDir, outFileName) {
-    return _path.default.join(outDir, outFileName || 'bundle.js');
-}
-function validateOutfileName(filename) {
-    if (!filename.endsWith('.js') || filename === '.js' || _path.default.basename(filename) !== filename) {
-        throw new Error(`Invalid outfile name: ${filename}. Must be a .js file`);
-    }
-    return true;
-}
-async function validateFilePath(filePath) {
-    const exists = await isFile(filePath);
-    if (!exists) {
-        throw new Error(`Invalid params: '${filePath}' is not a file or does not exist.`);
-    }
-    return true;
-}
-async function validateDirPath(dirPath, createDir) {
-    const exists = await isDirectory(dirPath, createDir);
-    if (!exists) {
-        throw new Error(`Invalid params: '${dirPath}' is not a directory or could not be created.`);
-    }
-    return true;
-}
-async function useTemporaryFile(fileName, fileContents, fn) {
-    const filePath = _path.default.join(_os.default.tmpdir(), fileName);
-    await _fs.promises.mkdir(_path.default.dirname(filePath), {
-        recursive: true
-    });
-    await _fs.promises.writeFile(filePath, fileContents);
-    try {
-        await fn(filePath);
-    } finally{
-        if (await isFile(filePath)) {
-            await _fs.promises.unlink(filePath);
-        }
-    }
-}
-
-//# sourceMappingURL=fs.js.map

package/dist/cjs/fs.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/fs.ts"],"sourcesContent":["import type { Json } from '@metamask/utils';\nimport { promises as fs } from 'fs';\nimport os from 'os';\nimport pathUtils from 'path';\n\nimport { parseJson } from './json';\nimport type { VirtualFile } from './virtual-file';\nimport { readVirtualFile } from './virtual-file';\n\n/**\n * Checks whether the given path string resolves to an existing directory, and\n * optionally creates the directory if it doesn't exist.\n *\n * @param pathString - The path string to check.\n * @param createDir - Whether to create the directory if it doesn't exist.\n * @returns Whether the given path is an existing directory.\n */\nexport async function isDirectory(\n  pathString: string,\n  createDir: boolean,\n): Promise<boolean> {\n  try {\n    const stats = await fs.stat(pathString);\n    return stats.isDirectory();\n  } catch (error) {\n    if (error.code === 'ENOENT') {\n      if (!createDir) {\n        return false;\n      }\n\n      await fs.mkdir(pathString, { recursive: true });\n      return true;\n    }\n\n    return false;\n  }\n}\n\n/**\n * Checks whether the given path string resolves to an existing file.\n *\n * @param pathString - The path string to check.\n * @returns Whether the given path is an existing file.\n */\nexport async function isFile(pathString: string): Promise<boolean> {\n  try {\n    const stats = await fs.stat(pathString);\n    return stats.isFile();\n  } catch (error) {\n    return false;\n  }\n}\n\n/**\n * Reads a `.json` file, parses its contents, and returns them.\n *\n * @param pathString - The path to the JSON file.\n * @returns The parsed contents of the JSON file.\n */\nexport async function readJsonFile<Type extends Json = Json>(\n  pathString: string,\n): Promise<VirtualFile<Type>> {\n  if (!pathString.endsWith('.json')) {\n    throw new Error('The specified file must be a \".json\" file.');\n  }\n\n  let file;\n  try {\n    file = await readVirtualFile(pathString, 'utf8');\n  } catch (error) {\n    if (error.code === 'ENOENT') {\n      throw new Error(\n        `Could not find '${pathString}'. Please ensure that the file exists.`,\n      );\n    }\n\n    throw error;\n  }\n  file.result = parseJson(file.toString());\n  return file as VirtualFile<Type>;\n}\n\n/**\n * Gets the complete out file path from an output file name and parent\n * directory path.\n *\n * @param outDir - The path to the out file's parent directory.\n * @param outFileName - The out file's name.\n * @returns The complete path to the out file.\n */\nexport function getOutfilePath(outDir: string, outFileName: string): string {\n  return pathUtils.join(outDir, outFileName || 'bundle.js');\n}\n\n/**\n * Ensures that the outfile name is just a `.js` file name.\n * Throws on validation failure.\n *\n * @param filename - The file name to validate.\n * @returns `true` if validation succeeded.\n * @throws If the file name is invalid.\n */\nexport function validateOutfileName(filename: string): boolean {\n  if (\n    !filename.endsWith('.js') ||\n    filename === '.js' ||\n    pathUtils.basename(filename) !== filename\n  ) {\n    throw new Error(`Invalid outfile name: ${filename}. Must be a .js file`);\n  }\n  return true;\n}\n\n/**\n * Validates a file path. Throws on validation failure.\n *\n * @param filePath - The file path to validate.\n * @returns `true` if validation succeeded.\n * @throws If the path does not resolve to a file.\n */\nexport async function validateFilePath(filePath: string): Promise<boolean> {\n  const exists = await isFile(filePath);\n  if (!exists) {\n    throw new Error(\n      `Invalid params: '${filePath}' is not a file or does not exist.`,\n    );\n  }\n  return true;\n}\n\n/**\n * Validates a directory path. Throws on validation failure.\n *\n * @param dirPath - The directory path to validate.\n * @param createDir - Whether to create the directory if it doesn't exist.\n * @returns `true` if validation succeeded or the directory was created.\n * @throws If the directory does not exist or could not be created.\n */\nexport async function validateDirPath(\n  dirPath: string,\n  createDir: boolean,\n): Promise<boolean> {\n  const exists = await isDirectory(dirPath, createDir);\n  if (!exists) {\n    throw new Error(\n      `Invalid params: '${dirPath}' is not a directory or could not be created.`,\n    );\n  }\n  return true;\n}\n\n/**\n * Creates a temporary file with a given name and content, writes it to disk and calls the provided function.\n * This function handles deletion of the temporary file after usage.\n *\n * @param fileName - The name of the temporary file.\n * @param fileContents - The content of the temporary file.\n * @param fn - The callback function to call when the temporary file has been created.\n */\nexport async function useTemporaryFile(\n  fileName: string,\n  fileContents: string,\n  fn: (path: string) => Promise<unknown>,\n): Promise<void> {\n  const filePath = pathUtils.join(os.tmpdir(), fileName);\n  await fs.mkdir(pathUtils.dirname(filePath), { recursive: true });\n  await fs.writeFile(filePath, fileContents);\n  try {\n    await fn(filePath);\n  } finally {\n    if (await isFile(filePath)) {\n      await fs.unlink(filePath);\n    }\n  }\n}\n"],"names":["isDirectory","isFile","readJsonFile","getOutfilePath","validateOutfileName","validateFilePath","validateDirPath","useTemporaryFile","pathString","createDir","stats","fs","stat","error","code","mkdir","recursive","endsWith","Error","file","readVirtualFile","result","parseJson","toString","outDir","outFileName","pathUtils","join","filename","basename","filePath","exists","dirPath","fileName","fileContents","fn","os","tmpdir","dirname","writeFile","unlink"],"mappings":";;;;;;;;;;;IAiBsBA,WAAW;eAAXA;;IA2BAC,MAAM;eAANA;;IAeAC,YAAY;eAAZA;;IA+BNC,cAAc;eAAdA;;IAYAC,mBAAmB;eAAnBA;;IAkBMC,gBAAgB;eAAhBA;;IAkBAC,eAAe;eAAfA;;IAqBAC,gBAAgB;eAAhBA;;;oBA9JS;2DAChB;6DACO;sBAEI;6BAEM;;;;;;AAUzB,eAAeP,YACpBQ,UAAkB,EAClBC,SAAkB;IAElB,IAAI;QACF,MAAMC,QAAQ,MAAMC,YAAE,CAACC,IAAI,CAACJ;QAC5B,OAAOE,MAAMV,WAAW;IAC1B,EAAE,OAAOa,OAAO;QACd,IAAIA,MAAMC,IAAI,KAAK,UAAU;YAC3B,IAAI,CAACL,WAAW;gBACd,OAAO;YACT;YAEA,MAAME,YAAE,CAACI,KAAK,CAACP,YAAY;gBAAEQ,WAAW;YAAK;YAC7C,OAAO;QACT;QAEA,OAAO;IACT;AACF;AAQO,eAAef,OAAOO,UAAkB;IAC7C,IAAI;QACF,MAAME,QAAQ,MAAMC,YAAE,CAACC,IAAI,CAACJ;QAC5B,OAAOE,MAAMT,MAAM;IACrB,EAAE,OAAOY,OAAO;QACd,OAAO;IACT;AACF;AAQO,eAAeX,aACpBM,UAAkB;IAElB,IAAI,CAACA,WAAWS,QAAQ,CAAC,UAAU;QACjC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAIC;IACJ,IAAI;QACFA,OAAO,MAAMC,IAAAA,4BAAe,EAACZ,YAAY;IAC3C,EAAE,OAAOK,OAAO;QACd,IAAIA,MAAMC,IAAI,KAAK,UAAU;YAC3B,MAAM,IAAII,MACR,CAAC,gBAAgB,EAAEV,WAAW,sCAAsC,CAAC;QAEzE;QAEA,MAAMK;IACR;IACAM,KAAKE,MAAM,GAAGC,IAAAA,eAAS,EAACH,KAAKI,QAAQ;IACrC,OAAOJ;AACT;AAUO,SAAShB,eAAeqB,MAAc,EAAEC,WAAmB;IAChE,OAAOC,aAAS,CAACC,IAAI,CAACH,QAAQC,eAAe;AAC/C;AAUO,SAASrB,oBAAoBwB,QAAgB;IAClD,IACE,CAACA,SAASX,QAAQ,CAAC,UACnBW,aAAa,SACbF,aAAS,CAACG,QAAQ,CAACD,cAAcA,UACjC;QACA,MAAM,IAAIV,MAAM,CAAC,sBAAsB,EAAEU,SAAS,oBAAoB,CAAC;IACzE;IACA,OAAO;AACT;AASO,eAAevB,iBAAiByB,QAAgB;IACrD,MAAMC,SAAS,MAAM9B,OAAO6B;IAC5B,IAAI,CAACC,QAAQ;QACX,MAAM,IAAIb,MACR,CAAC,iBAAiB,EAAEY,SAAS,kCAAkC,CAAC;IAEpE;IACA,OAAO;AACT;AAUO,eAAexB,gBACpB0B,OAAe,EACfvB,SAAkB;IAElB,MAAMsB,SAAS,MAAM/B,YAAYgC,SAASvB;IAC1C,IAAI,CAACsB,QAAQ;QACX,MAAM,IAAIb,MACR,CAAC,iBAAiB,EAAEc,QAAQ,6CAA6C,CAAC;IAE9E;IACA,OAAO;AACT;AAUO,eAAezB,iBACpB0B,QAAgB,EAChBC,YAAoB,EACpBC,EAAsC;IAEtC,MAAML,WAAWJ,aAAS,CAACC,IAAI,CAACS,WAAE,CAACC,MAAM,IAAIJ;IAC7C,MAAMtB,YAAE,CAACI,KAAK,CAACW,aAAS,CAACY,OAAO,CAACR,WAAW;QAAEd,WAAW;IAAK;IAC9D,MAAML,YAAE,CAAC4B,SAAS,CAACT,UAAUI;IAC7B,IAAI;QACF,MAAMC,GAAGL;IACX,SAAU;QACR,IAAI,MAAM7B,OAAO6B,WAAW;YAC1B,MAAMnB,YAAE,CAAC6B,MAAM,CAACV;QAClB;IACF;AACF"}

package/dist/cjs/handler-types.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    HandlerType: function() {
-        return HandlerType;
-    },
-    SNAP_EXPORT_NAMES: function() {
-        return SNAP_EXPORT_NAMES;
-    }
-});
-var HandlerType;
-(function(HandlerType) {
-    HandlerType["OnRpcRequest"] = 'onRpcRequest';
-    HandlerType["OnSignature"] = 'onSignature';
-    HandlerType["OnTransaction"] = 'onTransaction';
-    HandlerType["OnCronjob"] = 'onCronjob';
-    HandlerType["OnInstall"] = 'onInstall';
-    HandlerType["OnUpdate"] = 'onUpdate';
-    HandlerType["OnNameLookup"] = 'onNameLookup';
-    HandlerType["OnKeyringRequest"] = 'onKeyringRequest';
-    HandlerType["OnHomePage"] = 'onHomePage';
-    HandlerType["OnUserInput"] = 'onUserInput';
-})(HandlerType || (HandlerType = {}));
-const SNAP_EXPORT_NAMES = Object.values(HandlerType);
-
-//# sourceMappingURL=handler-types.js.map

package/dist/cjs/handler-types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/handler-types.ts"],"sourcesContent":["export enum HandlerType {\n  OnRpcRequest = 'onRpcRequest',\n  OnSignature = 'onSignature',\n  OnTransaction = 'onTransaction',\n  OnCronjob = 'onCronjob',\n  OnInstall = 'onInstall',\n  OnUpdate = 'onUpdate',\n  OnNameLookup = 'onNameLookup',\n  OnKeyringRequest = 'onKeyringRequest',\n  OnHomePage = 'onHomePage',\n  OnUserInput = 'onUserInput',\n}\n\nexport type SnapHandler = {\n  /**\n   * The type of handler.\n   */\n  type: HandlerType;\n\n  /**\n   * Whether the handler is required, i.e., whether the request will fail if the\n   * handler is called, but the snap does not export it.\n   *\n   * This is primarily used for the lifecycle handlers, which are optional.\n   */\n  required: boolean;\n\n  /**\n   * Validate the given snap export. This should return a type guard for the\n   * handler type.\n   *\n   * @param snapExport - The export to validate.\n   * @returns Whether the export is valid.\n   */\n  validator: (snapExport: unknown) => boolean;\n};\n\nexport const SNAP_EXPORT_NAMES = Object.values(HandlerType);\n"],"names":["SNAP_EXPORT_NAMES","HandlerType","OnRpcRequest","OnSignature","OnTransaction","OnCronjob","OnInstall","OnUpdate","OnNameLookup","OnKeyringRequest","OnHomePage","OnUserInput","Object","values"],"mappings":";;;;;;;;;;;;;;IAqCaA,iBAAiB;eAAjBA;;;IArCN;UAAKC,WAAW;IAAXA,YACVC,kBAAe;IADLD,YAEVE,iBAAc;IAFJF,YAGVG,mBAAgB;IAHNH,YAIVI,eAAY;IAJFJ,YAKVK,eAAY;IALFL,YAMVM,cAAW;IANDN,YAOVO,kBAAe;IAPLP,YAQVQ,sBAAmB;IARTR,YASVS,gBAAa;IATHT,YAUVU,iBAAc;GAVJV,gBAAAA;AAqCL,MAAMD,oBAAoBY,OAAOC,MAAM,CAACZ"}