@metamask/snaps-utils 3.0.0 → 3.2.0

package/CHANGELOG.md

@@ -6,6 +6,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.2.0]
+### Added
+- Add support for links in custom UI and notifications ([#1814](https://github.com/MetaMask/snaps/pull/1814))
+
+## [3.1.0]
+### Added
+- Add static file API ([#1836](https://github.com/MetaMask/snaps/pull/1836), [#1858](https://github.com/MetaMask/snaps/pull/1858))
+
+### Changed
+- Update multiple MetaMask dependencies ([#1841](https://github.com/MetaMask/snaps/pull/1841))
+- Bump Babel packages from `^7.20.12` to `^7.23.2` ([#1862](https://github.com/MetaMask/snaps/pull/1862))
+
 ## [3.0.0]
 ### Added
 - Add keyring export and endowment ([#1787](https://github.com/MetaMask/snaps/pull/1787))
@@ -59,7 +71,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - The version of the package no longer needs to match the version of all other
     MetaMask Snaps packages.
 
-[Unreleased]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-utils@3.0.0...HEAD
+[Unreleased]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-utils@3.2.0...HEAD
+[3.2.0]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-utils@3.1.0...@metamask/snaps-utils@3.2.0
+[3.1.0]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-utils@3.0.0...@metamask/snaps-utils@3.1.0
 [3.0.0]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-utils@2.0.1...@metamask/snaps-utils@3.0.0
 [2.0.1]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-utils@2.0.0...@metamask/snaps-utils@2.0.1
 [2.0.0]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-utils@0.38.4-flask.1...@metamask/snaps-utils@2.0.0

package/dist/cjs/auxiliary-files.js

@@ -0,0 +1,40 @@
+"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, {
+    AuxiliaryFileEncoding: function() {
+        return AuxiliaryFileEncoding;
+    },
+    encodeAuxiliaryFile: function() {
+        return encodeAuxiliaryFile;
+    }
+});
+const _utils = require("@metamask/utils");
+const _base = require("@scure/base");
+var AuxiliaryFileEncoding;
+(function(AuxiliaryFileEncoding) {
+    AuxiliaryFileEncoding["Base64"] = 'base64';
+    AuxiliaryFileEncoding["Hex"] = 'hex';
+    AuxiliaryFileEncoding["Utf8"] = 'utf8';
+})(AuxiliaryFileEncoding || (AuxiliaryFileEncoding = {}));
+function encodeAuxiliaryFile(value, encoding) {
+    // Input is assumed to be the stored file in base64.
+    if (encoding === AuxiliaryFileEncoding.Base64) {
+        return value;
+    }
+    // TODO: Use @metamask/utils for this
+    const decoded = _base.base64.decode(value);
+    if (encoding === AuxiliaryFileEncoding.Utf8) {
+        return (0, _utils.bytesToString)(decoded);
+    }
+    return (0, _utils.bytesToHex)(decoded);
+}
+
+//# sourceMappingURL=auxiliary-files.js.map

package/dist/cjs/auxiliary-files.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/auxiliary-files.ts"],"sourcesContent":["import { bytesToHex, bytesToString } from '@metamask/utils';\nimport { base64 } from '@scure/base';\n\nexport enum AuxiliaryFileEncoding {\n  Base64 = 'base64',\n  Hex = 'hex',\n  Utf8 = 'utf8',\n}\n\n/**\n * Re-encodes an auxiliary file if needed depending on the requested file encoding.\n *\n * @param value - The base64 value stored for the auxiliary file.\n * @param encoding - The chosen encoding.\n * @returns The file encoded in the requested encoding.\n */\nexport function encodeAuxiliaryFile(\n  value: string,\n  encoding: AuxiliaryFileEncoding,\n) {\n  // Input is assumed to be the stored file in base64.\n  if (encoding === AuxiliaryFileEncoding.Base64) {\n    return value;\n  }\n\n  // TODO: Use @metamask/utils for this\n  const decoded = base64.decode(value);\n  if (encoding === AuxiliaryFileEncoding.Utf8) {\n    return bytesToString(decoded);\n  }\n\n  return bytesToHex(decoded);\n}\n"],"names":["encodeAuxiliaryFile","AuxiliaryFileEncoding","Base64","Hex","Utf8","value","encoding","decoded","base64","decode","bytesToString","bytesToHex"],"mappings":";;;;;;;;;;;;;;IAgBgBA,mBAAmB;eAAnBA;;;uBAhB0B;sBACnB;IAEhB;UAAKC,qBAAqB;IAArBA,sBACVC,YAAS;IADCD,sBAEVE,SAAM;IAFIF,sBAGVG,UAAO;GAHGH,0BAAAA;AAaL,SAASD,oBACdK,KAAa,EACbC,QAA+B;IAE/B,oDAAoD;IACpD,IAAIA,aAAaL,sBAAsBC,MAAM,EAAE;QAC7C,OAAOG;IACT;IAEA,qCAAqC;IACrC,MAAME,UAAUC,YAAM,CAACC,MAAM,CAACJ;IAC9B,IAAIC,aAAaL,sBAAsBG,IAAI,EAAE;QAC3C,OAAOM,IAAAA,oBAAa,EAACH;IACvB;IAEA,OAAOI,IAAAA,iBAAU,EAACJ;AACpB"}

package/dist/cjs/errors.js

@@ -2,18 +2,368 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "getErrorMessage", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getErrorMessage: function() {
         return getErrorMessage;
+    },
+    getErrorStack: function() {
+        return getErrorStack;
+    },
+    getErrorCode: function() {
+        return getErrorCode;
+    },
+    getErrorData: function() {
+        return getErrorData;
+    },
+    SNAP_ERROR_WRAPPER_CODE: function() {
+        return SNAP_ERROR_WRAPPER_CODE;
+    },
+    SNAP_ERROR_WRAPPER_MESSAGE: function() {
+        return SNAP_ERROR_WRAPPER_MESSAGE;
+    },
+    SNAP_ERROR_CODE: function() {
+        return SNAP_ERROR_CODE;
+    },
+    SNAP_ERROR_MESSAGE: function() {
+        return SNAP_ERROR_MESSAGE;
+    },
+    WrappedSnapError: function() {
+        return WrappedSnapError;
+    },
+    SnapError: function() {
+        return SnapError;
+    },
+    isSnapError: function() {
+        return isSnapError;
+    },
+    isSerializedSnapError: function() {
+        return isSerializedSnapError;
+    },
+    isWrappedSnapError: function() {
+        return isWrappedSnapError;
+    },
+    unwrapError: function() {
+        return unwrapError;
     }
 });
+const _rpcerrors = require("@metamask/rpc-errors");
 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;
+}
 function getErrorMessage(error) {
     if ((0, _utils.isObject)(error) && (0, _utils.hasProperty)(error, 'message') && typeof error.message === 'string') {
         return error.message;
     }
     return String(error);
 }
+function getErrorStack(error) {
+    if ((0, _utils.isObject)(error) && (0, _utils.hasProperty)(error, 'stack') && typeof error.stack === 'string') {
+        return error.stack;
+    }
+    return undefined;
+}
+function getErrorCode(error) {
+    if ((0, _utils.isObject)(error) && (0, _utils.hasProperty)(error, 'code') && typeof error.code === 'number' && Number.isInteger(error.code)) {
+        return error.code;
+    }
+    return _rpcerrors.errorCodes.rpc.internal;
+}
+function getErrorData(error) {
+    if ((0, _utils.isObject)(error) && (0, _utils.hasProperty)(error, 'data') && typeof error.data === 'object' && error.data !== null && (0, _utils.isValidJson)(error.data) && !Array.isArray(error.data)) {
+        return error.data;
+    }
+    return {};
+}
+const SNAP_ERROR_WRAPPER_CODE = -31001;
+const SNAP_ERROR_WRAPPER_MESSAGE = 'Wrapped Snap Error';
+const SNAP_ERROR_CODE = -31002;
+const SNAP_ERROR_MESSAGE = '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 = 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, getErrorStack(error));
+    }
+}
+var _code = /*#__PURE__*/ new WeakMap(), _message1 = /*#__PURE__*/ new WeakMap(), _data = /*#__PURE__*/ new WeakMap(), _stack1 = /*#__PURE__*/ new WeakMap();
+class SnapError extends Error {
+    /**
+   * The error name.
+   *
+   * @returns The error name.
+   */ get name() {
+        return 'SnapError';
+    }
+    /**
+   * The error code.
+   *
+   * @returns The error code.
+   */ get code() {
+        return _class_private_field_get(this, _code);
+    }
+    /**
+   * The error message.
+   *
+   * @returns The error message.
+   */ get message() {
+        return _class_private_field_get(this, _message1);
+    }
+    /**
+   * Additional data for the error.
+   *
+   * @returns Additional data for the error.
+   */ get data() {
+        return _class_private_field_get(this, _data);
+    }
+    /**
+   * The error stack.
+   *
+   * @returns The error stack.
+   */ get stack() {
+        return _class_private_field_get(this, _stack1);
+    }
+    /**
+   * Convert the error to a JSON object.
+   *
+   * @returns The JSON object.
+   */ toJSON() {
+        return {
+            code: SNAP_ERROR_CODE,
+            message: SNAP_ERROR_MESSAGE,
+            data: {
+                cause: {
+                    code: this.code,
+                    message: this.message,
+                    stack: this.stack,
+                    data: this.data
+                }
+            }
+        };
+    }
+    /**
+   * 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 `SnapError`.
+   *
+   * @param error - The error to create the `SnapError` from. If this is a
+   * `string`, it will be used as the error message. If this is an `Error`, its
+   * `message` property will be used as the error message. If this is a
+   * `JsonRpcError`, its `message` property will be used as the error message
+   * and its `code` property will be used as the error code. Otherwise, the
+   * error will be converted to a string and used as the error message.
+   * @param data - Additional data to include in the error. This will be merged
+   * with the error data, if any.
+   */ constructor(error, data = {}){
+        const message = getErrorMessage(error);
+        super(message);
+        _class_private_field_init(this, _code, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _message1, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _data, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _stack1, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _message1, message);
+        _class_private_field_set(this, _code, getErrorCode(error));
+        _class_private_field_set(this, _data, {
+            ...getErrorData(error),
+            ...data
+        });
+        _class_private_field_set(this, _stack1, super.stack);
+    }
+}
+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 === SNAP_ERROR_CODE && error.message === 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, getErrorMessage(error.data.cause), 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, getErrorMessage(error), getErrorStack(error)),
+        false
+    ];
+}
 
 //# sourceMappingURL=errors.js.map

package/dist/cjs/errors.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/errors.ts"],"sourcesContent":["import { hasProperty, isObject } from '@metamask/utils';\n\n/**\n * Get the error message from an unknown error type.\n *\n * - If the error is an object with a `message` property, return the message.\n * - Otherwise, return the error converted to a string.\n *\n * @param error - The error to get the message from.\n * @returns The error message.\n */\nexport function getErrorMessage(error: unknown) {\n  if (\n    isObject(error) &&\n    hasProperty(error, 'message') &&\n    typeof error.message === 'string'\n  ) {\n    return error.message;\n  }\n\n  return String(error);\n}\n"],"names":["getErrorMessage","error","isObject","hasProperty","message","String"],"mappings":";;;;+BAWgBA;;;eAAAA;;;uBAXsB;AAW/B,SAASA,gBAAgBC,KAAc;IAC5C,IACEC,IAAAA,eAAQ,EAACD,UACTE,IAAAA,kBAAW,EAACF,OAAO,cACnB,OAAOA,MAAMG,OAAO,KAAK,UACzB;QACA,OAAOH,MAAMG,OAAO;IACtB;IAEA,OAAOC,OAAOJ;AAChB"}
+{"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 { Json, JsonRpcError } from '@metamask/utils';\nimport {\n  hasProperty,\n  isJsonRpcError,\n  isObject,\n  isValidJson,\n} from '@metamask/utils';\n\n/**\n * Get the error message from an unknown error type.\n *\n * - If the error is an object with a `message` property, return the message.\n * - Otherwise, return the error converted to a string.\n *\n * @param error - The error to get the message from.\n * @returns The error message.\n */\nexport function getErrorMessage(error: unknown) {\n  if (\n    isObject(error) &&\n    hasProperty(error, 'message') &&\n    typeof error.message === 'string'\n  ) {\n    return error.message;\n  }\n\n  return String(error);\n}\n\n/**\n * Get the error stack from an unknown error type.\n *\n * @param error - The error to get the stack from.\n * @returns The error stack, or undefined if the error does not have a valid\n * stack.\n */\nexport function getErrorStack(error: unknown) {\n  if (\n    isObject(error) &&\n    hasProperty(error, 'stack') &&\n    typeof error.stack === 'string'\n  ) {\n    return error.stack;\n  }\n\n  return undefined;\n}\n\n/**\n * Get the error code from an unknown error type.\n *\n * @param error - The error to get the code from.\n * @returns The error code, or `-32603` if the error does not have a valid code.\n */\nexport function getErrorCode(error: unknown) {\n  if (\n    isObject(error) &&\n    hasProperty(error, 'code') &&\n    typeof error.code === 'number' &&\n    Number.isInteger(error.code)\n  ) {\n    return error.code;\n  }\n\n  return errorCodes.rpc.internal;\n}\n\n/**\n * Get the error data from an unknown error type.\n *\n * @param error - The error to get the data from.\n * @returns The error data, or an empty object if the error does not have valid\n * data.\n */\nexport function getErrorData(error: unknown) {\n  if (\n    isObject(error) &&\n    hasProperty(error, 'data') &&\n    typeof error.data === 'object' &&\n    error.data !== null &&\n    isValidJson(error.data) &&\n    !Array.isArray(error.data)\n  ) {\n    return error.data;\n  }\n\n  return {};\n}\n\nexport const SNAP_ERROR_WRAPPER_CODE = -31001;\nexport const SNAP_ERROR_WRAPPER_MESSAGE = 'Wrapped Snap Error';\n\nexport const SNAP_ERROR_CODE = -31002;\nexport const SNAP_ERROR_MESSAGE = '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 type SerializedSnapError = {\n  code: typeof SNAP_ERROR_CODE;\n  message: typeof SNAP_ERROR_MESSAGE;\n  data: {\n    cause: JsonRpcError & {\n      data: Record<string, Json>;\n    };\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 * A generic error which can be thrown by a Snap, without it causing the Snap to\n * crash.\n */\nexport class SnapError extends Error {\n  readonly #code: number;\n\n  readonly #message: string;\n\n  readonly #data: Record<string, Json>;\n\n  readonly #stack?: string;\n\n  /**\n   * Create a new `SnapError`.\n   *\n   * @param error - The error to create the `SnapError` from. If this is a\n   * `string`, it will be used as the error message. If this is an `Error`, its\n   * `message` property will be used as the error message. If this is a\n   * `JsonRpcError`, its `message` property will be used as the error message\n   * and its `code` property will be used as the error code. Otherwise, the\n   * error will be converted to a string and used as the error message.\n   * @param data - Additional data to include in the error. This will be merged\n   * with the error data, if any.\n   */\n  constructor(\n    error: string | Error | JsonRpcError,\n    data: Record<string, Json> = {},\n  ) {\n    const message = getErrorMessage(error);\n    super(message);\n\n    this.#message = message;\n    this.#code = getErrorCode(error);\n    this.#data = { ...getErrorData(error), ...data };\n    this.#stack = super.stack;\n  }\n\n  /**\n   * The error name.\n   *\n   * @returns The error name.\n   */\n  get name() {\n    return 'SnapError';\n  }\n\n  /**\n   * The error code.\n   *\n   * @returns The error code.\n   */\n  get code() {\n    return this.#code;\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   * Additional data for the error.\n   *\n   * @returns Additional data for the error.\n   */\n  get data() {\n    return this.#data;\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(): SerializedSnapError {\n    return {\n      code: SNAP_ERROR_CODE,\n      message: SNAP_ERROR_MESSAGE,\n      data: {\n        cause: {\n          code: this.code,\n          message: this.message,\n          stack: this.stack,\n          data: this.data,\n        },\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":["getErrorMessage","getErrorStack","getErrorCode","getErrorData","SNAP_ERROR_WRAPPER_CODE","SNAP_ERROR_WRAPPER_MESSAGE","SNAP_ERROR_CODE","SNAP_ERROR_MESSAGE","WrappedSnapError","SnapError","isSnapError","isSerializedSnapError","isWrappedSnapError","unwrapError","error","isObject","hasProperty","message","String","stack","undefined","code","Number","isInteger","errorCodes","rpc","internal","data","isValidJson","Array","isArray","Error","name","toJSON","cause","serialize","serializeCause","constructor","serialized","isJsonRpcError","getJsonRpcError","RpcError"],"mappings":"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"}

package/dist/cjs/eval-worker.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 require("ses/lockdown");
 const _fs = require("fs");
+const _handlertypes = require("./handler-types");
 const _mock = require("./mock");
-const _types = require("./types");
 lockdown({
     consoleTaming: 'unsafe',
     errorTaming: 'unsafe',
@@ -41,7 +41,7 @@ new Compartment({
     module: snapModule,
     exports: snapModule.exports
 }).evaluate((0, _fs.readFileSync)(snapFilePath, 'utf8'));
-const invalidExports = Object.keys(snapModule.exports).filter((snapExport)=>!_types.SNAP_EXPORT_NAMES.includes(snapExport));
+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')}`);

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

@@ -1 +1 @@
-{"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 './handlers';\nimport { generateMockEndowments } from './mock';\nimport { SNAP_EXPORT_NAMES } from './types';\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\n/**\n * Get mock endowments that don't do anything. This is useful for running the\n * eval, for snaps that try to communicate with the extension on initialisation,\n * for example.\n *\n * @returns The mock endowments.\n */\nfunction getMockEndowments() {\n  const endowments = generateMockEndowments();\n  return {\n    ...endowments,\n    window: endowments,\n    self: endowments,\n  };\n}\n\nconst snapFilePath = process.argv[2];\n\nconst snapModule: { exports?: any } = { exports: {} };\n\nnew Compartment({\n  ...getMockEndowments(),\n  module: snapModule,\n  exports: snapModule.exports,\n}).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\nsetTimeout(() => process.exit(0), 1000); // Hack to ensure worker exits\n"],"names":["lockdown","consoleTaming","errorTaming","mathTaming","dateTaming","overrideTaming","domainTaming","getMockEndowments","endowments","generateMockEndowments","window","self","snapFilePath","process","argv","snapModule","exports","Compartment","module","evaluate","readFileSync","invalidExports","Object","keys","filter","snapExport","SNAP_EXPORT_NAMES","includes","length","console","warn","join","setTimeout","exit"],"mappings":"AAAA,uDAAuD;;;;;QAChD;oBAEsB;sBAGU;uBACL;AAIlCA,SAAS;IACPC,eAAe;IACfC,aAAa;IACbC,YAAY;IACZC,YAAY;IACZC,gBAAgB;IAEhB,2EAA2E;IAC3E,yEAAyE;IACzE,kCAAkC;IAClCC,cAAc;AAChB;AAEA;;;;;;CAMC,GACD,SAASC;IACP,MAAMC,aAAaC,IAAAA,4BAAsB;IACzC,OAAO;QACL,GAAGD,UAAU;QACbE,QAAQF;QACRG,MAAMH;IACR;AACF;AAEA,MAAMI,eAAeC,QAAQC,IAAI,CAAC,EAAE;AAEpC,MAAMC,aAAgC;IAAEC,SAAS,CAAC;AAAE;AAEpD,IAAIC,YAAY;IACd,GAAGV,mBAAmB;IACtBW,QAAQH;IACRC,SAASD,WAAWC,OAAO;AAC7B,GAAGG,QAAQ,CAACC,IAAAA,gBAAY,EAACR,cAAc;AAEvC,MAAMS,iBAAiBC,OAAOC,IAAI,CAACR,WAAWC,OAAO,EAAEQ,MAAM,CAC3D,CAACC,aAAe,CAACC,wBAAiB,CAACC,QAAQ,CAACF;AAG9C,IAAIJ,eAAeO,MAAM,GAAG,GAAG;IAC7B,sCAAsC;IACtCC,QAAQC,IAAI,CAAC,CAAC,gCAAgC,EAAET,eAAeU,IAAI,CAAC,MAAM,CAAC;AAC7E;AAEAC,WAAW,IAAMnB,QAAQoB,IAAI,CAAC,IAAI,OAAO,8BAA8B"}
+{"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\n/**\n * Get mock endowments that don't do anything. This is useful for running the\n * eval, for snaps that try to communicate with the extension on initialisation,\n * for example.\n *\n * @returns The mock endowments.\n */\nfunction getMockEndowments() {\n  const endowments = generateMockEndowments();\n  return {\n    ...endowments,\n    window: endowments,\n    self: endowments,\n  };\n}\n\nconst snapFilePath = process.argv[2];\n\nconst snapModule: { exports?: any } = { exports: {} };\n\nnew Compartment({\n  ...getMockEndowments(),\n  module: snapModule,\n  exports: snapModule.exports,\n}).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\nsetTimeout(() => process.exit(0), 1000); // Hack to ensure worker exits\n"],"names":["lockdown","consoleTaming","errorTaming","mathTaming","dateTaming","overrideTaming","domainTaming","getMockEndowments","endowments","generateMockEndowments","window","self","snapFilePath","process","argv","snapModule","exports","Compartment","module","evaluate","readFileSync","invalidExports","Object","keys","filter","snapExport","SNAP_EXPORT_NAMES","includes","length","console","warn","join","setTimeout","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;;;;;;CAMC,GACD,SAASC;IACP,MAAMC,aAAaC,IAAAA,4BAAsB;IACzC,OAAO;QACL,GAAGD,UAAU;QACbE,QAAQF;QACRG,MAAMH;IACR;AACF;AAEA,MAAMI,eAAeC,QAAQC,IAAI,CAAC,EAAE;AAEpC,MAAMC,aAAgC;IAAEC,SAAS,CAAC;AAAE;AAEpD,IAAIC,YAAY;IACd,GAAGV,mBAAmB;IACtBW,QAAQH;IACRC,SAASD,WAAWC,OAAO;AAC7B,GAAGG,QAAQ,CAACC,IAAAA,gBAAY,EAACR,cAAc;AAEvC,MAAMS,iBAAiBC,OAAOC,IAAI,CAACR,WAAWC,OAAO,EAAEQ,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;AAEAC,WAAW,IAAMnB,QAAQoB,IAAI,CAAC,IAAI,OAAO,8BAA8B"}

package/dist/cjs/handler-types.js

@@ -0,0 +1,31 @@
+"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["OnTransaction"] = 'onTransaction';
+    HandlerType["OnCronjob"] = 'onCronjob';
+    HandlerType["OnInstall"] = 'onInstall';
+    HandlerType["OnUpdate"] = 'onUpdate';
+    HandlerType["OnNameLookup"] = 'onNameLookup';
+    HandlerType["OnKeyringRequest"] = 'onKeyringRequest';
+})(HandlerType || (HandlerType = {}));
+const SNAP_EXPORT_NAMES = Object.values(HandlerType);
+
+//# sourceMappingURL=handler-types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/handler-types.ts"],"sourcesContent":["export enum HandlerType {\n  OnRpcRequest = 'onRpcRequest',\n  OnTransaction = 'onTransaction',\n  OnCronjob = 'onCronjob',\n  OnInstall = 'onInstall',\n  OnUpdate = 'onUpdate',\n  OnNameLookup = 'onNameLookup',\n  OnKeyringRequest = 'onKeyringRequest',\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","OnTransaction","OnCronjob","OnInstall","OnUpdate","OnNameLookup","OnKeyringRequest","Object","values"],"mappings":";;;;;;;;;;;;;;IAkCaA,iBAAiB;eAAjBA;;;IAlCN;UAAKC,WAAW;IAAXA,YACVC,kBAAe;IADLD,YAEVE,mBAAgB;IAFNF,YAGVG,eAAY;IAHFH,YAIVI,eAAY;IAJFJ,YAKVK,cAAW;IALDL,YAMVM,kBAAe;IANLN,YAOVO,sBAAmB;GAPTP,gBAAAA;AAkCL,MAAMD,oBAAoBS,OAAOC,MAAM,CAACT"}

package/dist/cjs/handlers.js

@@ -9,71 +9,64 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    HandlerType: function() {
-        return HandlerType;
-    },
     SeverityLevel: function() {
         return SeverityLevel;
     },
     SNAP_EXPORTS: function() {
         return SNAP_EXPORTS;
+    },
+    OnTransactionResponseStruct: function() {
+        return OnTransactionResponseStruct;
     }
 });
-var HandlerType;
-(function(HandlerType) {
-    HandlerType["OnRpcRequest"] = 'onRpcRequest';
-    HandlerType["OnTransaction"] = 'onTransaction';
-    HandlerType["OnCronjob"] = 'onCronjob';
-    HandlerType["OnInstall"] = 'onInstall';
-    HandlerType["OnUpdate"] = 'onUpdate';
-    HandlerType["OnNameLookup"] = 'onNameLookup';
-    HandlerType["OnKeyringRequest"] = 'onKeyringRequest';
-})(HandlerType || (HandlerType = {}));
+const _snapsui = require("@metamask/snaps-ui");
+const _superstruct = require("superstruct");
+const _handlertypes = require("./handler-types");
 const SNAP_EXPORTS = {
-    [HandlerType.OnRpcRequest]: {
-        type: HandlerType.OnRpcRequest,
+    [_handlertypes.HandlerType.OnRpcRequest]: {
+        type: _handlertypes.HandlerType.OnRpcRequest,
         required: true,
         validator: (snapExport)=>{
             return typeof snapExport === 'function';
         }
     },
-    [HandlerType.OnTransaction]: {
-        type: HandlerType.OnTransaction,
+    [_handlertypes.HandlerType.OnTransaction]: {
+        type: _handlertypes.HandlerType.OnTransaction,
         required: true,
         validator: (snapExport)=>{
             return typeof snapExport === 'function';
         }
     },
-    [HandlerType.OnCronjob]: {
-        type: HandlerType.OnCronjob,
+    [_handlertypes.HandlerType.OnCronjob]: {
+        type: _handlertypes.HandlerType.OnCronjob,
         required: true,
         validator: (snapExport)=>{
             return typeof snapExport === 'function';
         }
     },
-    [HandlerType.OnNameLookup]: {
-        type: HandlerType.OnNameLookup,
+    [_handlertypes.HandlerType.OnNameLookup]: {
+        type: _handlertypes.HandlerType.OnNameLookup,
         required: true,
         validator: (snapExport)=>{
             return typeof snapExport === 'function';
         }
     },
-    [HandlerType.OnInstall]: {
-        type: HandlerType.OnInstall,
+    [_handlertypes.HandlerType.OnInstall]: {
+        type: _handlertypes.HandlerType.OnInstall,
         required: false,
         validator: (snapExport)=>{
             return typeof snapExport === 'function';
         }
     },
-    [HandlerType.OnUpdate]: {
-        type: HandlerType.OnUpdate,
+    [_handlertypes.HandlerType.OnUpdate]: {
+        type: _handlertypes.HandlerType.OnUpdate,
         required: false,
         validator: (snapExport)=>{
             return typeof snapExport === 'function';
         }
     },
-    [HandlerType.OnKeyringRequest]: {
-        type: HandlerType.OnKeyringRequest,
+    [_handlertypes.HandlerType.OnKeyringRequest]: {
+        type: _handlertypes.HandlerType.OnKeyringRequest,
         required: true,
         validator: (snapExport)=>{
             return typeof snapExport === 'function';
@@ -84,5 +77,9 @@ var SeverityLevel;
 (function(SeverityLevel) {
     SeverityLevel["Critical"] = 'critical';
 })(SeverityLevel || (SeverityLevel = {}));
+const OnTransactionResponseStruct = (0, _superstruct.object)({
+    content: _snapsui.ComponentStruct,
+    severity: (0, _superstruct.optional)((0, _superstruct.literal)(SeverityLevel.Critical))
+});
 
 //# sourceMappingURL=handlers.js.map