@metamask/snaps-utils 8.0.1 → 8.1.0

package/dist/chunk-3N27GIUS.mjs

@@ -1,229 +0,0 @@
-import {
-  indent
-} from "./chunk-IV3FSWZ7.mjs";
-
-// src/structs.ts
-import { union } from "@metamask/snaps-sdk";
-import {
-  assign,
-  is,
-  validate,
-  type as superstructType,
-  Struct,
-  StructError,
-  create
-} from "@metamask/superstruct";
-import { assert, isObject } from "@metamask/utils";
-import { bold, green, red } from "chalk";
-function color(value, colorFunction, enabled) {
-  if (enabled) {
-    return colorFunction(value);
-  }
-  return value;
-}
-function named(name, struct) {
-  return new Struct({
-    ...struct,
-    type: name
-  });
-}
-var SnapsStructError = class extends StructError {
-  constructor(struct, prefix, suffix, failure, failures, colorize = true) {
-    super(failure, failures);
-    this.name = "SnapsStructError";
-    this.message = `${prefix}.
-
-${getStructErrorMessage(
-      struct,
-      [...failures()],
-      colorize
-    )}${suffix ? `
-
-${suffix}` : ""}`;
-  }
-};
-function* arrayToGenerator(array) {
-  for (const item of array) {
-    yield item;
-  }
-}
-function getError({
-  struct,
-  prefix,
-  suffix = "",
-  error,
-  colorize
-}) {
-  return new SnapsStructError(
-    struct,
-    prefix,
-    suffix,
-    error,
-    () => arrayToGenerator(error.failures()),
-    colorize
-  );
-}
-function createFromStruct(value, struct, prefix, suffix = "") {
-  try {
-    return create(value, struct);
-  } catch (error) {
-    if (error instanceof StructError) {
-      throw getError({ struct, prefix, suffix, error });
-    }
-    throw error;
-  }
-}
-function getStructFromPath(struct, path) {
-  return path.reduce((result, key) => {
-    if (isObject(struct.schema) && struct.schema[key]) {
-      return struct.schema[key];
-    }
-    return result;
-  }, struct);
-}
-function getUnionStructNames(struct, colorize = true) {
-  if (Array.isArray(struct.schema)) {
-    return struct.schema.map(({ type }) => color(type, green, colorize));
-  }
-  return null;
-}
-function getStructErrorPrefix(failure, colorize = true) {
-  if (failure.type === "never" || failure.path.length === 0) {
-    return "";
-  }
-  return `At path: ${color(failure.path.join("."), bold, colorize)} \u2014 `;
-}
-function getStructFailureMessage(struct, failure, colorize = true) {
-  const received = color(JSON.stringify(failure.value), red, colorize);
-  const prefix = getStructErrorPrefix(failure, colorize);
-  if (failure.type === "union") {
-    const childStruct = getStructFromPath(struct, failure.path);
-    const unionNames = getUnionStructNames(childStruct, colorize);
-    if (unionNames) {
-      return `${prefix}Expected the value to be one of: ${unionNames.join(
-        ", "
-      )}, but received: ${received}.`;
-    }
-    return `${prefix}${failure.message}.`;
-  }
-  if (failure.type === "literal") {
-    const message = failure.message.replace(
-      /the literal `(.+)`,/u,
-      `the value to be \`${color("$1", green, colorize)}\`,`
-    ).replace(
-      /, but received: (.+)/u,
-      `, but received: ${color("$1", red, colorize)}`
-    );
-    return `${prefix}${message}.`;
-  }
-  if (failure.type === "never") {
-    return `Unknown key: ${color(
-      failure.path.join("."),
-      bold,
-      colorize
-    )}, received: ${received}.`;
-  }
-  if (failure.refinement === "size") {
-    const message = failure.message.replace(
-      /length between `(\d+)` and `(\d+)`/u,
-      `length between ${color("$1", green, colorize)} and ${color(
-        "$2",
-        green,
-        colorize
-      )},`
-    ).replace(/length of `(\d+)`/u, `length of ${color("$1", red, colorize)}`).replace(/a array/u, "an array");
-    return `${prefix}${message}.`;
-  }
-  if (failure.refinement !== void 0) {
-    return `${prefix}${failure.message}.`;
-  }
-  return `${prefix}Expected a value of type ${color(
-    failure.type,
-    green,
-    colorize
-  )}, but received: ${received}.`;
-}
-function getStructErrorMessage(struct, failures, colorize = true) {
-  const formattedFailures = failures.map(
-    (failure) => indent(`\u2022 ${getStructFailureMessage(struct, failure, colorize)}`)
-  );
-  return formattedFailures.join("\n");
-}
-function validateUnion(value, struct, structKey, coerce = false) {
-  assert(
-    struct.schema,
-    "Expected a struct with a schema. Make sure to use `union` from `@metamask/snaps-sdk`."
-  );
-  assert(struct.schema.length > 0, "Expected a non-empty array of structs.");
-  const keyUnion = struct.schema.map(
-    (innerStruct) => innerStruct.schema[structKey]
-    // This is guaranteed to be a non-empty array by the assertion above. We
-    // need to cast it since `superstruct` requires a non-empty array of structs
-    // for the `union` struct.
-  );
-  const key = superstructType({
-    [structKey]: union(keyUnion)
-  });
-  const [keyError] = validate(value, key, { coerce });
-  if (keyError) {
-    throw new Error(
-      getStructFailureMessage(key, keyError.failures()[0], false)
-    );
-  }
-  const objectValue = value;
-  const objectStructs = struct.schema.filter(
-    (innerStruct) => is(objectValue[structKey], innerStruct.schema[structKey])
-  );
-  assert(objectStructs.length > 0, "Expected a struct to match the value.");
-  const validationResults = objectStructs.map(
-    (objectStruct) => validate(objectValue, objectStruct, { coerce })
-  );
-  const validatedValue = validationResults.find(([error]) => !error);
-  if (validatedValue) {
-    return validatedValue[1];
-  }
-  assert(validationResults[0][0], "Expected at least one error.");
-  const validationError = validationResults.reduce((error, [innerError]) => {
-    assert(innerError, "Expected an error.");
-    if (innerError.failures().length < error.failures().length) {
-      return innerError;
-    }
-    return error;
-  }, validationResults[0][0]);
-  throw new Error(
-    getStructFailureMessage(struct, validationError.failures()[0], false)
-  );
-}
-function createUnion(value, struct, structKey) {
-  return validateUnion(value, struct, structKey, true);
-}
-function mergeStructs(...structs) {
-  const mergedStruct = assign(
-    ...structs
-  );
-  return new Struct({
-    ...mergedStruct,
-    *refiner(value, ctx) {
-      for (const struct of structs) {
-        yield* struct.refiner(value, ctx);
-      }
-    }
-  });
-}
-
-export {
-  named,
-  SnapsStructError,
-  arrayToGenerator,
-  getError,
-  createFromStruct,
-  getStructFromPath,
-  getUnionStructNames,
-  getStructErrorPrefix,
-  getStructFailureMessage,
-  getStructErrorMessage,
-  validateUnion,
-  createUnion,
-  mergeStructs
-};
-//# sourceMappingURL=chunk-3N27GIUS.mjs.map

package/dist/chunk-3N27GIUS.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/structs.ts"],"sourcesContent":["import { union } from '@metamask/snaps-sdk';\nimport type {\n  AnyStruct,\n  Assign,\n  Failure,\n  ObjectSchema,\n  ObjectType,\n} from '@metamask/superstruct';\nimport {\n  assign,\n  is,\n  validate,\n  type as superstructType,\n  Struct,\n  StructError,\n  create,\n} from '@metamask/superstruct';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assert, isObject } from '@metamask/utils';\nimport { bold, green, red } from 'chalk';\n\nimport { indent } from './strings';\n\n/**\n * Infer a struct type, only if it matches the specified type. This is useful\n * for defining types and structs that are related to each other in separate\n * files.\n *\n * @example\n * ```typescript\n * // In file A\n * export type GetFileArgs = {\n *   path: string;\n *   encoding?: EnumToUnion<AuxiliaryFileEncoding>;\n * };\n *\n * // In file B\n * export const GetFileArgsStruct = object(...);\n *\n * // If the type and struct are in the same file, this will return the type.\n * // Otherwise, it will return `never`.\n * export type GetFileArgs =\n *   InferMatching<typeof GetFileArgsStruct, GetFileArgs>;\n * ```\n */\nexport type InferMatching<\n  StructType extends Struct<any, any>,\n  Type,\n> = StructType['TYPE'] extends Type ? Type : never;\n\n/**\n * Colorize a value with a color function. This is useful for colorizing values\n * in error messages. If colorization is disabled, the original value is\n * returned.\n *\n * @param value - The value to colorize.\n * @param colorFunction - The color function to use.\n * @param enabled - Whether to colorize the value.\n * @returns The colorized value, or the original value if colorization is\n * disabled.\n */\nfunction color(\n  value: string,\n  colorFunction: (value: string) => string,\n  enabled: boolean,\n) {\n  if (enabled) {\n    return colorFunction(value);\n  }\n\n  return value;\n}\n\n/**\n * Define a struct, and also define the name of the struct as the given name.\n *\n * This is useful for improving the error messages returned by `superstruct`.\n *\n * @param name - The name of the struct.\n * @param struct - The struct.\n * @returns The struct.\n */\nexport function named<Type, Schema>(\n  name: string,\n  struct: Struct<Type, Schema>,\n) {\n  return new Struct({\n    ...struct,\n    type: name,\n  });\n}\n\nexport class SnapsStructError<Type, Schema> extends StructError {\n  constructor(\n    struct: Struct<Type, Schema>,\n    prefix: string,\n    suffix: string,\n    failure: StructError,\n    failures: () => Generator<Failure>,\n    colorize = true,\n  ) {\n    super(failure, failures);\n\n    this.name = 'SnapsStructError';\n    this.message = `${prefix}.\\n\\n${getStructErrorMessage(\n      struct,\n      [...failures()],\n      colorize,\n    )}${suffix ? `\\n\\n${suffix}` : ''}`;\n  }\n}\n\ntype GetErrorOptions<Type, Schema> = {\n  struct: Struct<Type, Schema>;\n  prefix: string;\n  suffix?: string;\n  error: StructError;\n  colorize?: boolean;\n};\n\n/**\n * Converts an array to a generator function that yields the items in the\n * array.\n *\n * @param array - The array.\n * @returns A generator function.\n * @yields The items in the array.\n */\nexport function* arrayToGenerator<Type>(\n  array: Type[],\n): Generator<Type, void, undefined> {\n  for (const item of array) {\n    yield item;\n  }\n}\n\n/**\n * Returns a `SnapsStructError` with the given prefix and suffix.\n *\n * @param options - The options.\n * @param options.struct - The struct that caused the error.\n * @param options.prefix - The prefix to add to the error message.\n * @param options.suffix - The suffix to add to the error message. Defaults to\n * an empty string.\n * @param options.error - The `superstruct` error to wrap.\n * @param options.colorize - Whether to colorize the value. Defaults to `true`.\n * @returns The `SnapsStructError`.\n */\nexport function getError<Type, Schema>({\n  struct,\n  prefix,\n  suffix = '',\n  error,\n  colorize,\n}: GetErrorOptions<Type, Schema>) {\n  return new SnapsStructError(\n    struct,\n    prefix,\n    suffix,\n    error,\n    () => arrayToGenerator(error.failures()),\n    colorize,\n  );\n}\n\n/**\n * A wrapper of `superstruct`'s `create` function that throws a\n * `SnapsStructError` instead of a `StructError`. This is useful for improving\n * the error messages returned by `superstruct`.\n *\n * @param value - The value to validate.\n * @param struct - The `superstruct` struct to validate the value against.\n * @param prefix - The prefix to add to the error message.\n * @param suffix - The suffix to add to the error message. Defaults to an empty\n * string.\n * @returns The validated value.\n */\nexport function createFromStruct<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  prefix: string,\n  suffix = '',\n) {\n  try {\n    return create(value, struct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw getError({ struct, prefix, suffix, error });\n    }\n\n    throw error;\n  }\n}\n\n/**\n * Get a struct from a failure path.\n *\n * @param struct - The struct.\n * @param path - The failure path.\n * @returns The struct at the failure path.\n */\nexport function getStructFromPath<Type, Schema>(\n  struct: Struct<Type, Schema>,\n  path: string[],\n) {\n  return path.reduce<AnyStruct>((result, key) => {\n    if (isObject(struct.schema) && struct.schema[key]) {\n      return struct.schema[key] as AnyStruct;\n    }\n\n    return result;\n  }, struct);\n}\n\n/**\n * Get the union struct names from a struct.\n *\n * @param struct - The struct.\n * @param colorize - Whether to colorize the value. Defaults to `true`.\n * @returns The union struct names, or `null` if the struct is not a union\n * struct.\n */\nexport function getUnionStructNames<Type, Schema>(\n  struct: Struct<Type, Schema>,\n  colorize = true,\n) {\n  if (Array.isArray(struct.schema)) {\n    return struct.schema.map(({ type }) => color(type, green, colorize));\n  }\n\n  return null;\n}\n\n/**\n * Get an error prefix from a `superstruct` failure. This is useful for\n * formatting the error message returned by `superstruct`.\n *\n * @param failure - The `superstruct` failure.\n * @param colorize - Whether to colorize the value. Defaults to `true`.\n * @returns The error prefix.\n */\nexport function getStructErrorPrefix(failure: Failure, colorize = true) {\n  if (failure.type === 'never' || failure.path.length === 0) {\n    return '';\n  }\n\n  return `At path: ${color(failure.path.join('.'), bold, colorize)} — `;\n}\n\n/**\n * Get a string describing the failure. This is similar to the `message`\n * property of `superstruct`'s `Failure` type, but formats the value in a more\n * readable way.\n *\n * @param struct - The struct that caused the failure.\n * @param failure - The `superstruct` failure.\n * @param colorize - Whether to colorize the value. Defaults to `true`.\n * @returns A string describing the failure.\n */\nexport function getStructFailureMessage<Type, Schema>(\n  struct: Struct<Type, Schema>,\n  failure: Failure,\n  colorize = true,\n) {\n  const received = color(JSON.stringify(failure.value), red, colorize);\n  const prefix = getStructErrorPrefix(failure, colorize);\n\n  if (failure.type === 'union') {\n    const childStruct = getStructFromPath(struct, failure.path);\n    const unionNames = getUnionStructNames(childStruct, colorize);\n\n    if (unionNames) {\n      return `${prefix}Expected the value to be one of: ${unionNames.join(\n        ', ',\n      )}, but received: ${received}.`;\n    }\n\n    return `${prefix}${failure.message}.`;\n  }\n\n  if (failure.type === 'literal') {\n    // Superstruct's failure does not provide information about which literal\n    // value was expected, so we need to parse the message to get the literal.\n    const message = failure.message\n      .replace(\n        /the literal `(.+)`,/u,\n        `the value to be \\`${color('$1', green, colorize)}\\`,`,\n      )\n      .replace(\n        /, but received: (.+)/u,\n        `, but received: ${color('$1', red, colorize)}`,\n      );\n\n    return `${prefix}${message}.`;\n  }\n\n  if (failure.type === 'never') {\n    return `Unknown key: ${color(\n      failure.path.join('.'),\n      bold,\n      colorize,\n    )}, received: ${received}.`;\n  }\n\n  if (failure.refinement === 'size') {\n    const message = failure.message\n      .replace(\n        /length between `(\\d+)` and `(\\d+)`/u,\n        `length between ${color('$1', green, colorize)} and ${color(\n          '$2',\n          green,\n          colorize,\n        )},`,\n      )\n      .replace(/length of `(\\d+)`/u, `length of ${color('$1', red, colorize)}`)\n      .replace(/a array/u, 'an array');\n\n    return `${prefix}${message}.`;\n  }\n\n  // Refinements we built ourselves have nice error messages\n  if (failure.refinement !== undefined) {\n    return `${prefix}${failure.message}.`;\n  }\n\n  return `${prefix}Expected a value of type ${color(\n    failure.type,\n    green,\n    colorize,\n  )}, but received: ${received}.`;\n}\n\n/**\n * Get a string describing the errors. This formats all the errors in a\n * human-readable way.\n *\n * @param struct - The struct that caused the failures.\n * @param failures - The `superstruct` failures.\n * @param colorize - Whether to colorize the value. Defaults to `true`.\n * @returns A string describing the errors.\n */\nexport function getStructErrorMessage<Type, Schema>(\n  struct: Struct<Type, Schema>,\n  failures: Failure[],\n  colorize = true,\n) {\n  const formattedFailures = failures.map((failure) =>\n    indent(`• ${getStructFailureMessage(struct, failure, colorize)}`),\n  );\n\n  return formattedFailures.join('\\n');\n}\n\n/**\n * Validate a union struct, and throw readable errors if the value does not\n * satisfy the struct. This is useful for improving the error messages returned\n * by `superstruct`.\n *\n * @param value - The value to validate.\n * @param struct - The `superstruct` union struct to validate the value against.\n * This struct must be a union of object structs, and must have at least one\n * shared key to validate against.\n * @param structKey - The key to validate against. This key must be present in\n * all the object structs in the union struct, and is expected to be a literal\n * value.\n * @param coerce - Whether to coerce the value to satisfy the struct. Defaults\n * to `false`.\n * @returns The validated value.\n * @throws If the value does not satisfy the struct.\n * @example\n * const struct = union([\n *   object({ type: literal('a'), value: string() }),\n *   object({ type: literal('b'), value: number() }),\n *   object({ type: literal('c'), value: boolean() }),\n *   // ...\n * ]);\n *\n * // At path: type — Expected the value to be one of: \"a\", \"b\", \"c\", but received: \"d\".\n * validateUnion({ type: 'd', value: 'foo' }, struct, 'type');\n *\n * // At path: value — Expected a value of type string, but received: 42.\n * validateUnion({ type: 'a', value: 42 }, struct, 'value');\n */\nexport function validateUnion<Type, Schema extends readonly Struct<any, any>[]>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  structKey: keyof Type,\n  coerce = false,\n) {\n  assert(\n    struct.schema,\n    'Expected a struct with a schema. Make sure to use `union` from `@metamask/snaps-sdk`.',\n  );\n  assert(struct.schema.length > 0, 'Expected a non-empty array of structs.');\n\n  const keyUnion = struct.schema.map(\n    (innerStruct) => innerStruct.schema[structKey],\n    // This is guaranteed to be a non-empty array by the assertion above. We\n    // need to cast it since `superstruct` requires a non-empty array of structs\n    // for the `union` struct.\n  ) as NonEmptyArray<Struct>;\n\n  const key = superstructType({\n    [structKey]: union(keyUnion),\n  });\n\n  const [keyError] = validate(value, key, { coerce });\n  if (keyError) {\n    throw new Error(\n      getStructFailureMessage(key, keyError.failures()[0], false),\n    );\n  }\n\n  // At this point it's guaranteed that the value is an object, so we can safely\n  // cast it to a Record.\n  const objectValue = value as Record<PropertyKey, unknown>;\n  const objectStructs = struct.schema.filter((innerStruct) =>\n    is(objectValue[structKey], innerStruct.schema[structKey]),\n  );\n\n  assert(objectStructs.length > 0, 'Expected a struct to match the value.');\n\n  // We need to validate the value against all the object structs that match the\n  // struct key, and return the first validated value.\n  const validationResults = objectStructs.map((objectStruct) =>\n    validate(objectValue, objectStruct, { coerce }),\n  );\n\n  const validatedValue = validationResults.find(([error]) => !error);\n  if (validatedValue) {\n    return validatedValue[1];\n  }\n\n  assert(validationResults[0][0], 'Expected at least one error.');\n\n  // If there is no validated value, we need to find the error with the least\n  // number of failures (with the assumption that it's the most specific error).\n  const validationError = validationResults.reduce((error, [innerError]) => {\n    assert(innerError, 'Expected an error.');\n    if (innerError.failures().length < error.failures().length) {\n      return innerError;\n    }\n\n    return error;\n  }, validationResults[0][0]);\n\n  throw new Error(\n    getStructFailureMessage(struct, validationError.failures()[0], false),\n  );\n}\n\n/**\n * Create a value with the coercion logic of a union struct, and throw readable\n * errors if the value does not satisfy the struct. This is useful for improving\n * the error messages returned by `superstruct`.\n *\n * @param value - The value to validate.\n * @param struct - The `superstruct` union struct to validate the value against.\n * This struct must be a union of object structs, and must have at least one\n * shared key to validate against.\n * @param structKey - The key to validate against. This key must be present in\n * all the object structs in the union struct, and is expected to be a literal\n * value.\n * @returns The validated value.\n * @throws If the value does not satisfy the struct.\n * @see validateUnion\n */\nexport function createUnion<Type, Schema extends readonly Struct<any, any>[]>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  structKey: keyof Type,\n) {\n  return validateUnion(value, struct, structKey, true);\n}\n\n// These types are copied from Superstruct, to mirror `assign`.\nexport function mergeStructs<\n  ObjectA extends ObjectSchema,\n  ObjectB extends ObjectSchema,\n>(\n  A: Struct<ObjectType<ObjectA>, ObjectA>,\n  B: Struct<ObjectType<ObjectB>, ObjectB>,\n): Struct<ObjectType<Assign<ObjectA, ObjectB>>, Assign<ObjectA, ObjectB>>;\nexport function mergeStructs<\n  ObjectA extends ObjectSchema,\n  ObjectB extends ObjectSchema,\n  ObjectC extends ObjectSchema,\n>(\n  A: Struct<ObjectType<ObjectA>, ObjectA>,\n  B: Struct<ObjectType<ObjectB>, ObjectB>,\n  C: Struct<ObjectType<ObjectC>, ObjectC>,\n): Struct<\n  ObjectType<Assign<Assign<ObjectA, ObjectB>, ObjectC>>,\n  Assign<Assign<ObjectA, ObjectB>, ObjectC>\n>;\nexport function mergeStructs<\n  ObjectA extends ObjectSchema,\n  ObjectB extends ObjectSchema,\n  ObjectC extends ObjectSchema,\n  ObjectD extends ObjectSchema,\n>(\n  A: Struct<ObjectType<ObjectA>, ObjectA>,\n  B: Struct<ObjectType<ObjectB>, ObjectB>,\n  C: Struct<ObjectType<ObjectC>, ObjectC>,\n  D: Struct<ObjectType<ObjectD>, ObjectD>,\n): Struct<\n  ObjectType<Assign<Assign<Assign<ObjectA, ObjectB>, ObjectC>, ObjectD>>,\n  Assign<Assign<Assign<ObjectA, ObjectB>, ObjectC>, ObjectD>\n>;\nexport function mergeStructs<\n  ObjectA extends ObjectSchema,\n  ObjectB extends ObjectSchema,\n  ObjectC extends ObjectSchema,\n  ObjectD extends ObjectSchema,\n  ObjectE extends ObjectSchema,\n>(\n  A: Struct<ObjectType<ObjectA>, ObjectA>,\n  B: Struct<ObjectType<ObjectB>, ObjectB>,\n  C: Struct<ObjectType<ObjectC>, ObjectC>,\n  D: Struct<ObjectType<ObjectD>, ObjectD>,\n  E: Struct<ObjectType<ObjectE>, ObjectE>,\n): Struct<\n  ObjectType<\n    Assign<Assign<Assign<Assign<ObjectA, ObjectB>, ObjectC>, ObjectD>, ObjectE>\n  >,\n  Assign<Assign<Assign<Assign<ObjectA, ObjectB>, ObjectC>, ObjectD>, ObjectE>\n>;\n\n/**\n * Merge multiple structs into one, using superstruct `assign`.\n *\n * Differently from plain `assign`, this function also copies over refinements from each struct.\n *\n * @param structs - The `superstruct` structs to merge.\n * @returns The merged struct.\n */\nexport function mergeStructs(...structs: Struct<any>[]): Struct<any> {\n  const mergedStruct = (assign as (...structs: Struct<any>[]) => Struct)(\n    ...structs,\n  );\n  return new Struct({\n    ...mergedStruct,\n    *refiner(value, ctx) {\n      for (const struct of structs) {\n        yield* struct.refiner(value, ctx);\n      }\n    },\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-3OXW5H4F.js

@@ -1,30 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunk37EUH3KZjs = require('./chunk-37EUH3KZ.js');
-
-
-var _chunkTAMKWZ4Ejs = require('./chunk-TAMKWZ4E.js');
-
-
-var _chunkB5GNTDE2js = require('./chunk-B5GNTDE2.js');
-
-
-var _chunkW7KRIAIXjs = require('./chunk-W7KRIAIX.js');
-
-// src/validation.ts
-async function validateFetchedSnap(files) {
-  _chunk37EUH3KZjs.assertIsSnapManifest.call(void 0, files.manifest.result);
-  await _chunkTAMKWZ4Ejs.validateSnapShasum.call(void 0, files);
-  _chunkB5GNTDE2js.validateSnapManifestLocalizations.call(void 0, 
-    files.manifest.result,
-    files.localizationFiles.map((file) => file.result)
-  );
-  if (files.svgIcon) {
-    _chunkW7KRIAIXjs.assertIsSnapIcon.call(void 0, files.svgIcon);
-  }
-}
-
-
-
-exports.validateFetchedSnap = validateFetchedSnap;
-//# sourceMappingURL=chunk-3OXW5H4F.js.map

package/dist/chunk-3OXW5H4F.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/validation.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAYA,eAAsB,oBACpB,OACe;AACf,uBAAqB,MAAM,SAAS,MAAM;AAC1C,QAAM,mBAAmB,KAAK;AAC9B;AAAA,IACE,MAAM,SAAS;AAAA,IACf,MAAM,kBAAkB,IAAI,CAAC,SAAS,KAAK,MAAM;AAAA,EACnD;AAEA,MAAI,MAAM,SAAS;AACjB,qBAAiB,MAAM,OAAO;AAAA,EAChC;AACF","sourcesContent":["import { assertIsSnapIcon } from './icon';\nimport { validateSnapManifestLocalizations } from './localization';\nimport { assertIsSnapManifest } from './manifest/validation';\nimport { validateSnapShasum } from './snaps';\nimport type { FetchedSnapFiles } from './types';\n\n/**\n * Validates the files contained in a fetched snap.\n *\n * @param files - All potentially included files in a fetched snap.\n * @throws If any of the files are considered invalid.\n */\nexport async function validateFetchedSnap(\n  files: FetchedSnapFiles,\n): Promise<void> {\n  assertIsSnapManifest(files.manifest.result);\n  await validateSnapShasum(files);\n  validateSnapManifestLocalizations(\n    files.manifest.result,\n    files.localizationFiles.map((file) => file.result),\n  );\n\n  if (files.svgIcon) {\n    assertIsSnapIcon(files.svgIcon);\n  }\n}\n"]}

package/dist/chunk-3RFGTBEP.js

@@ -1,151 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-var _chunkS3BWTUTZjs = require('./chunk-S3BWTUTZ.js');
-
-// src/errors.ts
-
-
-
-
-var _rpcerrors = require('@metamask/rpc-errors');
-
-
-
-
-
-var _snapssdk = require('@metamask/snaps-sdk');
-var _utils = require('@metamask/utils');
-var SNAP_ERROR_WRAPPER_CODE = -31001;
-var SNAP_ERROR_WRAPPER_MESSAGE = "Wrapped Snap Error";
-var _error, _message, _stack;
-var WrappedSnapError = class extends Error {
-  /**
-   * Create a new `WrappedSnapError`.
-   *
-   * @param error - The error to create the `WrappedSnapError` from.
-   */
-  constructor(error) {
-    const message = _snapssdk.getErrorMessage.call(void 0, error);
-    super(message);
-    _chunkS3BWTUTZjs.__privateAdd.call(void 0, this, _error, void 0);
-    _chunkS3BWTUTZjs.__privateAdd.call(void 0, this, _message, void 0);
-    _chunkS3BWTUTZjs.__privateAdd.call(void 0, this, _stack, void 0);
-    _chunkS3BWTUTZjs.__privateSet.call(void 0, this, _error, error);
-    _chunkS3BWTUTZjs.__privateSet.call(void 0, this, _message, message);
-    _chunkS3BWTUTZjs.__privateSet.call(void 0, this, _stack, _snapssdk.getErrorStack.call(void 0, error));
-  }
-  /**
-   * The error name.
-   *
-   * @returns The error name.
-   */
-  get name() {
-    return "WrappedSnapError";
-  }
-  /**
-   * The error message.
-   *
-   * @returns The error message.
-   */
-  get message() {
-    return _chunkS3BWTUTZjs.__privateGet.call(void 0, this, _message);
-  }
-  /**
-   * The error stack.
-   *
-   * @returns The error stack.
-   */
-  get stack() {
-    return _chunkS3BWTUTZjs.__privateGet.call(void 0, this, _stack);
-  }
-  /**
-   * Convert the error to a JSON object.
-   *
-   * @returns The JSON object.
-   */
-  toJSON() {
-    const cause = isSnapError(_chunkS3BWTUTZjs.__privateGet.call(void 0, this, _error)) ? _chunkS3BWTUTZjs.__privateGet.call(void 0, this, _error).serialize() : _rpcerrors.serializeCause.call(void 0, _chunkS3BWTUTZjs.__privateGet.call(void 0, 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();
-  }
-};
-_error = new WeakMap();
-_message = new WeakMap();
-_stack = new WeakMap();
-function isSnapError(error) {
-  if (_utils.isObject.call(void 0, error) && "serialize" in error && typeof error.serialize === "function") {
-    const serialized = error.serialize();
-    return _utils.isJsonRpcError.call(void 0, 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 _utils.isJsonRpcError.call(void 0, error) && error.code === SNAP_ERROR_WRAPPER_CODE && error.message === SNAP_ERROR_WRAPPER_MESSAGE;
-}
-function getJsonRpcError(code, message, stack, data) {
-  const error = new (0, _rpcerrors.JsonRpcError)(code, message, data);
-  error.stack = stack;
-  return error;
-}
-function unwrapError(error) {
-  if (isWrappedSnapError(error)) {
-    if (_utils.isJsonRpcError.call(void 0, error.data.cause)) {
-      if (isSerializedSnapError(error.data.cause)) {
-        const { code: code2, message: message2, stack: stack2, data: data2 } = error.data.cause.data.cause;
-        return [getJsonRpcError(code2, message2, stack2, data2), true];
-      }
-      const { code, message, stack, data } = error.data.cause;
-      return [getJsonRpcError(code, message, stack, data), false];
-    }
-    return [
-      getJsonRpcError(
-        _rpcerrors.errorCodes.rpc.internal,
-        _snapssdk.getErrorMessage.call(void 0, error.data.cause),
-        _snapssdk.getErrorStack.call(void 0, error.data.cause)
-      ),
-      false
-    ];
-  }
-  if (_utils.isJsonRpcError.call(void 0, error)) {
-    const { code, message, stack, data } = error;
-    return [getJsonRpcError(code, message, stack, data), false];
-  }
-  return [
-    getJsonRpcError(
-      _rpcerrors.errorCodes.rpc.internal,
-      _snapssdk.getErrorMessage.call(void 0, error),
-      _snapssdk.getErrorStack.call(void 0, error)
-    ),
-    false
-  ];
-}
-
-
-
-
-
-
-
-
-
-exports.SNAP_ERROR_WRAPPER_CODE = SNAP_ERROR_WRAPPER_CODE; exports.SNAP_ERROR_WRAPPER_MESSAGE = SNAP_ERROR_WRAPPER_MESSAGE; exports.WrappedSnapError = WrappedSnapError; exports.isSnapError = isSnapError; exports.isSerializedSnapError = isSerializedSnapError; exports.isWrappedSnapError = isWrappedSnapError; exports.unwrapError = unwrapError;
-//# sourceMappingURL=chunk-3RFGTBEP.js.map

package/dist/chunk-3RFGTBEP.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/errors.ts"],"names":["code","message","stack","data"],"mappings":"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","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"]}

package/dist/chunk-3RUWAMJT.mjs

@@ -1,31 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-
-export {
-  __export,
-  __privateGet,
-  __privateAdd,
-  __privateSet
-};
-//# sourceMappingURL=chunk-3RUWAMJT.mjs.map

package/dist/chunk-3RUWAMJT.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-3S4INAGA.mjs

@@ -1,18 +0,0 @@
-import {
-  VirtualFile
-} from "./chunk-DE22V5AO.mjs";
-
-// src/bytes.ts
-import { stringToBytes } from "@metamask/utils";
-function getBytes(bytes) {
-  const unwrapped = bytes instanceof VirtualFile ? bytes.value : bytes;
-  if (typeof unwrapped === "string") {
-    return stringToBytes(unwrapped);
-  }
-  return unwrapped;
-}
-
-export {
-  getBytes
-};
-//# sourceMappingURL=chunk-3S4INAGA.mjs.map

package/dist/chunk-3S4INAGA.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/bytes.ts"],"sourcesContent":["import { stringToBytes } from '@metamask/utils';\n\nimport { VirtualFile } from './virtual-file/VirtualFile';\n\n/**\n * Convert a bytes-like input value to a Uint8Array.\n *\n * @param bytes - A bytes-like value.\n * @returns The input value converted to a Uint8Array if necessary.\n */\nexport function getBytes(bytes: VirtualFile | Uint8Array | string): Uint8Array {\n  // Unwrap VirtualFiles to extract the content\n  // The content is then either a string or Uint8Array\n  const unwrapped = bytes instanceof VirtualFile ? bytes.value : bytes;\n\n  if (typeof unwrapped === 'string') {\n    return stringToBytes(unwrapped);\n  }\n\n  return unwrapped;\n}\n"],"mappings":";;;;;AAAA,SAAS,qBAAqB;AAUvB,SAAS,SAAS,OAAsD;AAG7E,QAAM,YAAY,iBAAiB,cAAc,MAAM,QAAQ;AAE/D,MAAI,OAAO,cAAc,UAAU;AACjC,WAAO,cAAc,SAAS;AAAA,EAChC;AAEA,SAAO;AACT;","names":[]}