@metamask/snaps-utils 6.1.0 → 7.0.0

package/dist/chunk-GK4IJQVW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/manifest/manifest.ts","../src/npm.ts"],"names":["manifest"],"mappings":"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","sourcesContent":["import { getErrorMessage } from '@metamask/snaps-sdk';\nimport type { Json } from '@metamask/utils';\nimport { assertExhaustive, assert, isPlainObject } from '@metamask/utils';\nimport deepEqual from 'fast-deep-equal';\nimport { promises as fs } from 'fs';\nimport pathUtils from 'path';\n\nimport { deepClone } from '../deep-clone';\nimport { readJsonFile } from '../fs';\nimport { getSvgDimensions } from '../icon';\nimport { validateNpmSnap } from '../npm';\nimport {\n  getSnapChecksum,\n  ProgrammaticallyFixableSnapError,\n  validateSnapShasum,\n} from '../snaps';\nimport type { SnapFiles, UnvalidatedSnapFiles } from '../types';\nimport { NpmSnapFileNames, SnapValidationFailureReason } from '../types';\nimport { readVirtualFile, VirtualFile } from '../virtual-file/node';\nimport type { SnapManifest } from './validation';\n\nconst MANIFEST_SORT_ORDER: Record<keyof SnapManifest, number> = {\n  $schema: 1,\n  version: 2,\n  description: 3,\n  proposedName: 4,\n  repository: 5,\n  source: 6,\n  initialConnections: 7,\n  initialPermissions: 8,\n  manifestVersion: 9,\n};\n\n/**\n * The result from the `checkManifest` function.\n *\n * @property manifest - The fixed manifest object.\n * @property updated - Whether the manifest was updated.\n * @property warnings - An array of warnings that were encountered during\n * processing of the manifest files. These warnings are not logged to the\n * console automatically, so depending on the environment the function is called\n * in, a different method for logging can be used.\n * @property errors - An array of errors that were encountered during\n * processing of the manifest files. These errors are not logged to the\n * console automatically, so depending on the environment the function is called\n * in, a different method for logging can be used.\n */\nexport type CheckManifestResult = {\n  manifest: SnapManifest;\n  updated?: boolean;\n  warnings: string[];\n  errors: string[];\n};\n\nexport type WriteFileFunction = (path: string, data: string) => Promise<void>;\n\n/**\n * Validates a snap.manifest.json file. Attempts to fix the manifest and write\n * the fixed version to disk if `writeManifest` is true. Throws if validation\n * fails.\n *\n * @param basePath - The path to the folder with the manifest files.\n * @param writeManifest - Whether to write the fixed manifest to disk.\n * @param sourceCode - The source code of the Snap.\n * @param writeFileFn - The function to use to write the manifest to disk.\n * @returns Whether the manifest was updated, and an array of warnings that\n * were encountered during processing of the manifest files.\n */\nexport async function checkManifest(\n  basePath: string,\n  writeManifest = true,\n  sourceCode?: string,\n  writeFileFn: WriteFileFunction = fs.writeFile,\n): Promise<CheckManifestResult> {\n  const warnings: string[] = [];\n  const errors: string[] = [];\n\n  let updated = false;\n\n  const manifestPath = pathUtils.join(basePath, NpmSnapFileNames.Manifest);\n  const manifestFile = await readJsonFile(manifestPath);\n  const unvalidatedManifest = manifestFile.result;\n\n  const packageFile = await readJsonFile(\n    pathUtils.join(basePath, NpmSnapFileNames.PackageJson),\n  );\n\n  const auxiliaryFilePaths = getSnapFilePaths(\n    unvalidatedManifest,\n    (manifest) => manifest?.source?.files,\n  );\n\n  const localizationFilePaths = getSnapFilePaths(\n    unvalidatedManifest,\n    (manifest) => manifest?.source?.locales,\n  );\n\n  const snapFiles: UnvalidatedSnapFiles = {\n    manifest: manifestFile,\n    packageJson: packageFile,\n    sourceCode: await getSnapSourceCode(\n      basePath,\n      unvalidatedManifest,\n      sourceCode,\n    ),\n    svgIcon: await getSnapIcon(basePath, unvalidatedManifest),\n    // Intentionally pass null as the encoding here since the files may be binary\n    auxiliaryFiles:\n      (await getSnapFiles(basePath, auxiliaryFilePaths, null)) ?? [],\n    localizationFiles:\n      (await getSnapFiles(basePath, localizationFilePaths)) ?? [],\n  };\n\n  let manifest: VirtualFile<SnapManifest> | undefined;\n  try {\n    ({ manifest } = await validateNpmSnap(snapFiles));\n  } catch (error) {\n    if (error instanceof ProgrammaticallyFixableSnapError) {\n      errors.push(error.message);\n\n      // If we get here, the files at least have the correct shape.\n      const partiallyValidatedFiles = snapFiles as SnapFiles;\n\n      let isInvalid = true;\n      let currentError = error;\n      const maxAttempts = Object.keys(SnapValidationFailureReason).length;\n\n      // Attempt to fix all fixable validation failure reasons. All such reasons\n      // are enumerated by the `SnapValidationFailureReason` enum, so we only\n      // attempt to fix the manifest the same amount of times as there are\n      // reasons in the enum.\n      for (let attempts = 1; isInvalid && attempts <= maxAttempts; attempts++) {\n        manifest = await fixManifest(\n          manifest\n            ? { ...partiallyValidatedFiles, manifest }\n            : partiallyValidatedFiles,\n          currentError,\n        );\n\n        try {\n          await validateNpmSnapManifest({\n            ...partiallyValidatedFiles,\n            manifest,\n          });\n\n          isInvalid = false;\n        } catch (nextValidationError) {\n          currentError = nextValidationError;\n          /* istanbul ignore next: this should be impossible */\n          if (\n            !(\n              nextValidationError instanceof ProgrammaticallyFixableSnapError\n            ) ||\n            (attempts === maxAttempts && !isInvalid)\n          ) {\n            throw new Error(\n              `Internal error: Failed to fix manifest. This is a bug, please report it. Reason:\\n${error.message}`,\n            );\n          }\n\n          errors.push(currentError.message);\n        }\n      }\n\n      updated = true;\n    } else {\n      throw error;\n    }\n  }\n\n  // TypeScript assumes `manifest` can still be undefined, that is not the case.\n  // But we assert to keep TypeScript happy.\n  assert(manifest);\n\n  const validatedManifest = manifest.result;\n\n  // Check presence of recommended keys\n  const recommendedFields = ['repository'] as const;\n\n  const missingRecommendedFields = recommendedFields.filter(\n    (key) => !validatedManifest[key],\n  );\n\n  if (missingRecommendedFields.length > 0) {\n    warnings.push(\n      `Missing recommended package.json properties:\\n${missingRecommendedFields.reduce(\n        (allMissing, currentField) => {\n          return `${allMissing}\\t${currentField}\\n`;\n        },\n        '',\n      )}`,\n    );\n  }\n\n  if (!snapFiles.svgIcon) {\n    warnings.push(\n      'No icon found in the Snap manifest. It is recommended to include an icon for the Snap. See https://docs.metamask.io/snaps/how-to/design-a-snap/#guidelines-at-a-glance for more information.',\n    );\n  }\n\n  const iconDimensions =\n    snapFiles.svgIcon && getSvgDimensions(snapFiles.svgIcon.toString());\n  if (iconDimensions && iconDimensions.height !== iconDimensions.width) {\n    warnings.push(\n      'The icon in the Snap manifest is not square. It is recommended to use a square icon for the Snap.',\n    );\n  }\n\n  if (writeManifest) {\n    try {\n      const newManifest = `${JSON.stringify(\n        getWritableManifest(validatedManifest),\n        null,\n        2,\n      )}\\n`;\n\n      if (updated || newManifest !== manifestFile.value) {\n        await writeFileFn(\n          pathUtils.join(basePath, NpmSnapFileNames.Manifest),\n          newManifest,\n        );\n      }\n    } catch (error) {\n      // Note: This error isn't pushed to the errors array, because it's not an\n      // error in the manifest itself.\n      throw new Error(`Failed to update snap.manifest.json: ${error.message}`);\n    }\n  }\n\n  return { manifest: validatedManifest, updated, warnings, errors };\n}\n\n/**\n * Given the relevant Snap files (manifest, `package.json`, and bundle) and a\n * Snap manifest validation error, fixes the fault in the manifest that caused\n * the error.\n *\n * @param snapFiles - The contents of all Snap files.\n * @param error - The {@link ProgrammaticallyFixableSnapError} that was thrown.\n * @returns A copy of the manifest file where the cause of the error is fixed.\n */\nexport async function fixManifest(\n  snapFiles: SnapFiles,\n  error: ProgrammaticallyFixableSnapError,\n): Promise<VirtualFile<SnapManifest>> {\n  const { manifest, packageJson } = snapFiles;\n  const clonedFile = manifest.clone();\n  const manifestCopy = clonedFile.result;\n\n  switch (error.reason) {\n    case SnapValidationFailureReason.NameMismatch:\n      manifestCopy.source.location.npm.packageName = packageJson.result.name;\n      break;\n\n    case SnapValidationFailureReason.VersionMismatch:\n      manifestCopy.version = packageJson.result.version;\n      break;\n\n    case SnapValidationFailureReason.RepositoryMismatch:\n      manifestCopy.repository = packageJson.result.repository\n        ? deepClone(packageJson.result.repository)\n        : undefined;\n      break;\n\n    case SnapValidationFailureReason.ShasumMismatch:\n      manifestCopy.source.shasum = await getSnapChecksum(snapFiles);\n      break;\n\n    /* istanbul ignore next */\n    default:\n      assertExhaustive(error.reason);\n  }\n\n  clonedFile.result = manifestCopy;\n  clonedFile.value = JSON.stringify(manifestCopy);\n  return clonedFile;\n}\n\n/**\n * Given an unvalidated Snap manifest, attempts to extract the location of the\n * bundle source file location and read the file.\n *\n * @param basePath - The path to the folder with the manifest files.\n * @param manifest - The unvalidated Snap manifest file contents.\n * @param sourceCode - Override source code for plugins.\n * @returns The contents of the bundle file, if any.\n */\nexport async function getSnapSourceCode(\n  basePath: string,\n  manifest: Json,\n  sourceCode?: string,\n): Promise<VirtualFile | undefined> {\n  if (!isPlainObject(manifest)) {\n    return undefined;\n  }\n\n  const sourceFilePath = (manifest as Partial<SnapManifest>).source?.location\n    ?.npm?.filePath;\n\n  if (!sourceFilePath) {\n    return undefined;\n  }\n\n  if (sourceCode) {\n    return new VirtualFile({\n      path: pathUtils.join(basePath, sourceFilePath),\n      value: sourceCode,\n    });\n  }\n\n  try {\n    const virtualFile = await readVirtualFile(\n      pathUtils.join(basePath, sourceFilePath),\n      'utf8',\n    );\n    return virtualFile;\n  } catch (error) {\n    throw new Error(\n      `Failed to read snap bundle file: ${getErrorMessage(error)}`,\n    );\n  }\n}\n\n/**\n * Given an unvalidated Snap manifest, attempts to extract the location of the\n * icon and read the file.\n *\n * @param basePath - The path to the folder with the manifest files.\n * @param manifest - The unvalidated Snap manifest file contents.\n * @returns The contents of the icon, if any.\n */\nexport async function getSnapIcon(\n  basePath: string,\n  manifest: Json,\n): Promise<VirtualFile | undefined> {\n  if (!isPlainObject(manifest)) {\n    return undefined;\n  }\n\n  const iconPath = (manifest as Partial<SnapManifest>).source?.location?.npm\n    ?.iconPath;\n\n  if (!iconPath) {\n    return undefined;\n  }\n\n  try {\n    const virtualFile = await readVirtualFile(\n      pathUtils.join(basePath, iconPath),\n      'utf8',\n    );\n    return virtualFile;\n  } catch (error) {\n    throw new Error(`Failed to read snap icon file: ${getErrorMessage(error)}`);\n  }\n}\n\n/**\n * Get an array of paths from an unvalidated Snap manifest.\n *\n * @param manifest - The unvalidated Snap manifest file contents.\n * @param selector - A function that returns the paths to the files.\n * @returns The paths to the files, if any.\n */\nexport function getSnapFilePaths(\n  manifest: Json,\n  selector: (manifest: Partial<SnapManifest>) => string[] | undefined,\n) {\n  if (!isPlainObject(manifest)) {\n    return undefined;\n  }\n\n  const snapManifest = manifest as Partial<SnapManifest>;\n  const paths = selector(snapManifest);\n\n  if (!Array.isArray(paths)) {\n    return undefined;\n  }\n\n  return paths;\n}\n\n/**\n * Given an unvalidated Snap manifest, attempts to extract the files with the\n * given paths and read them.\n *\n * @param basePath - The path to the folder with the manifest files.\n * @param paths - The paths to the files.\n * @param encoding - An optional encoding to pass down to readVirtualFile.\n * @returns A list of auxiliary files and their contents, if any.\n */\nexport async function getSnapFiles(\n  basePath: string,\n  paths: string[] | undefined,\n  encoding: BufferEncoding | null = 'utf8',\n): Promise<VirtualFile[] | undefined> {\n  if (!paths) {\n    return undefined;\n  }\n\n  try {\n    return await Promise.all(\n      paths.map(async (filePath) =>\n        readVirtualFile(pathUtils.join(basePath, filePath), encoding),\n      ),\n    );\n  } catch (error) {\n    throw new Error(`Failed to read snap files: ${getErrorMessage(error)}`);\n  }\n}\n\n/**\n * Sorts the given manifest in our preferred sort order and removes the\n * `repository` field if it is falsy (it may be `null`).\n *\n * @param manifest - The manifest to sort and modify.\n * @returns The disk-ready manifest.\n */\nexport function getWritableManifest(manifest: SnapManifest): SnapManifest {\n  const { repository, ...remaining } = manifest;\n\n  const keys = Object.keys(\n    repository ? { ...remaining, repository } : remaining,\n  ) as (keyof SnapManifest)[];\n\n  const writableManifest = keys\n    .sort((a, b) => MANIFEST_SORT_ORDER[a] - MANIFEST_SORT_ORDER[b])\n    .reduce<Partial<SnapManifest>>(\n      (result, key) => ({\n        ...result,\n        [key]: manifest[key],\n      }),\n      {},\n    );\n\n  return writableManifest as SnapManifest;\n}\n\n/**\n * Validates the fields of an NPM Snap manifest that has already passed JSON\n * Schema validation.\n *\n * @param snapFiles - The relevant snap files to validate.\n * @param snapFiles.manifest - The npm Snap manifest to validate.\n * @param snapFiles.packageJson - The npm Snap's `package.json`.\n * @param snapFiles.sourceCode - The Snap's source code.\n * @param snapFiles.svgIcon - The Snap's optional icon.\n * @param snapFiles.auxiliaryFiles - Any auxiliary files required by the snap at runtime.\n * @param snapFiles.localizationFiles - The Snap's localization files.\n */\nexport async function validateNpmSnapManifest({\n  manifest,\n  packageJson,\n  sourceCode,\n  svgIcon,\n  auxiliaryFiles,\n  localizationFiles,\n}: SnapFiles) {\n  const packageJsonName = packageJson.result.name;\n  const packageJsonVersion = packageJson.result.version;\n  const packageJsonRepository = packageJson.result.repository;\n\n  const manifestPackageName = manifest.result.source.location.npm.packageName;\n  const manifestPackageVersion = manifest.result.version;\n  const manifestRepository = manifest.result.repository;\n\n  if (packageJsonName !== manifestPackageName) {\n    throw new ProgrammaticallyFixableSnapError(\n      `\"${NpmSnapFileNames.Manifest}\" npm package name (\"${manifestPackageName}\") does not match the \"${NpmSnapFileNames.PackageJson}\" \"name\" field (\"${packageJsonName}\").`,\n      SnapValidationFailureReason.NameMismatch,\n    );\n  }\n\n  if (packageJsonVersion !== manifestPackageVersion) {\n    throw new ProgrammaticallyFixableSnapError(\n      `\"${NpmSnapFileNames.Manifest}\" npm package version (\"${manifestPackageVersion}\") does not match the \"${NpmSnapFileNames.PackageJson}\" \"version\" field (\"${packageJsonVersion}\").`,\n      SnapValidationFailureReason.VersionMismatch,\n    );\n  }\n\n  if (\n    // The repository may be `undefined` in package.json but can only be defined\n    // or `null` in the Snap manifest due to TS@<4.4 issues.\n    (packageJsonRepository || manifestRepository) &&\n    !deepEqual(packageJsonRepository, manifestRepository)\n  ) {\n    throw new ProgrammaticallyFixableSnapError(\n      `\"${NpmSnapFileNames.Manifest}\" \"repository\" field does not match the \"${NpmSnapFileNames.PackageJson}\" \"repository\" field.`,\n      SnapValidationFailureReason.RepositoryMismatch,\n    );\n  }\n\n  await validateSnapShasum(\n    { manifest, sourceCode, svgIcon, auxiliaryFiles, localizationFiles },\n    `\"${NpmSnapFileNames.Manifest}\" \"shasum\" field does not match computed shasum.`,\n  );\n}\n","import { assertIsSnapIcon } from './icon';\nimport {\n  getValidatedLocalizationFiles,\n  validateSnapManifestLocalizations,\n} from './localization';\nimport { validateNpmSnapManifest } from './manifest/manifest';\nimport { assertIsSnapManifest } from './manifest/validation';\nimport type { SnapFiles, UnvalidatedSnapFiles } from './types';\nimport { assertIsNpmSnapPackageJson, NpmSnapFileNames } from './types';\n\nexport const EXPECTED_SNAP_FILES = [\n  'manifest',\n  'packageJson',\n  'sourceCode',\n] as const;\n\nexport const SnapFileNameFromKey = {\n  manifest: NpmSnapFileNames.Manifest,\n  packageJson: NpmSnapFileNames.PackageJson,\n  sourceCode: 'source code bundle',\n} as const;\n\n// TODO: Refactor this to be more shared with other validation.\n\n/**\n * Validates the files extracted from an npm Snap package tarball by ensuring\n * that they're non-empty and that the Json files match their respective schemas\n * and the Snaps publishing specification.\n *\n * @param snapFiles - The object containing the expected Snap file contents,\n * if any.\n * @param errorPrefix - The prefix of the error message.\n * @returns A tuple of the Snap manifest object and the Snap source code.\n */\nexport async function validateNpmSnap(\n  snapFiles: UnvalidatedSnapFiles,\n  errorPrefix?: `${string}: `,\n): Promise<SnapFiles> {\n  EXPECTED_SNAP_FILES.forEach((key) => {\n    if (!snapFiles[key]) {\n      throw new Error(\n        `${errorPrefix ?? ''}Missing file \"${SnapFileNameFromKey[key]}\".`,\n      );\n    }\n  });\n\n  // Typecast: We are assured that the required files exist if we get here.\n  const {\n    manifest,\n    packageJson,\n    sourceCode,\n    svgIcon,\n    auxiliaryFiles,\n    localizationFiles,\n  } = snapFiles as SnapFiles;\n\n  try {\n    assertIsSnapManifest(manifest.result);\n  } catch (error) {\n    throw new Error(`${errorPrefix ?? ''}${error.message}`);\n  }\n  const validatedManifest = manifest;\n\n  const { iconPath } = validatedManifest.result.source.location.npm;\n  if (iconPath && !svgIcon) {\n    throw new Error(`Missing file \"${iconPath}\".`);\n  }\n\n  try {\n    assertIsNpmSnapPackageJson(packageJson.result);\n  } catch (error) {\n    throw new Error(`${errorPrefix ?? ''}${error.message}`);\n  }\n\n  const validatedPackageJson = packageJson;\n  await validateNpmSnapManifest({\n    manifest: validatedManifest,\n    packageJson: validatedPackageJson,\n    sourceCode,\n    svgIcon,\n    auxiliaryFiles,\n    localizationFiles,\n  });\n\n  if (svgIcon) {\n    try {\n      assertIsSnapIcon(svgIcon);\n    } catch (error) {\n      throw new Error(`${errorPrefix ?? ''}${error.message}`);\n    }\n  }\n\n  if (localizationFiles) {\n    try {\n      // This function validates and returns the localization files. We don't\n      // use the return value here, but we do want to validate the files.\n      getValidatedLocalizationFiles(localizationFiles);\n\n      validateSnapManifestLocalizations(\n        manifest.result,\n        localizationFiles.map((file) => file.result),\n      );\n    } catch (error) {\n      throw new Error(`${errorPrefix ?? ''}${error.message}`);\n    }\n  }\n\n  return {\n    manifest: validatedManifest,\n    packageJson: validatedPackageJson,\n    sourceCode,\n    svgIcon,\n    auxiliaryFiles,\n    localizationFiles,\n  };\n}\n"]}

package/dist/chunk-GMC2A3D7.js

@@ -0,0 +1,211 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk6WBLB5BXjs = require('./chunk-6WBLB5BX.js');
+
+// src/structs.ts
+var _snapssdk = require('@metamask/snaps-sdk');
+var _utils = require('@metamask/utils');
+var _chalk = require('chalk');
+
+
+
+
+
+
+
+var _superstruct = require('superstruct');
+function color(value, colorFunction, enabled) {
+  if (enabled) {
+    return colorFunction(value);
+  }
+  return value;
+}
+function named(name, struct) {
+  return new (0, _superstruct.Struct)({
+    ...struct,
+    type: name
+  });
+}
+var SnapsStructError = class extends _superstruct.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 _superstruct.create.call(void 0, value, struct);
+  } catch (error) {
+    if (error instanceof _superstruct.StructError) {
+      throw getError({ struct, prefix, suffix, error });
+    }
+    throw error;
+  }
+}
+function getStructFromPath(struct, path) {
+  return path.reduce((result, key) => {
+    if (_utils.isObject.call(void 0, 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, _chalk.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("."), _chalk.bold, colorize)} \u2014 `;
+}
+function getStructFailureMessage(struct, failure, colorize = true) {
+  const received = color(JSON.stringify(failure.value), _chalk.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", _chalk.green, colorize)}\`,`
+    ).replace(
+      /, but received: (.+)/u,
+      `, but received: ${color("$1", _chalk.red, colorize)}`
+    );
+    return `${prefix}${message}.`;
+  }
+  if (failure.type === "never") {
+    return `Unknown key: ${color(
+      failure.path.join("."),
+      _chalk.bold,
+      colorize
+    )}, received: ${received}.`;
+  }
+  if (failure.refinement === "size") {
+    const message = failure.message.replace(
+      /length between `(\d+)` and `(\d+)`/u,
+      `length between ${color("$1", _chalk.green, colorize)} and ${color(
+        "$2",
+        _chalk.green,
+        colorize
+      )},`
+    ).replace(/length of `(\d+)`/u, `length of ${color("$1", _chalk.red, colorize)}`).replace(/a array/u, "an array");
+    return `${prefix}${message}.`;
+  }
+  return `${prefix}Expected a value of type ${color(
+    failure.type,
+    _chalk.green,
+    colorize
+  )}, but received: ${received}.`;
+}
+function getStructErrorMessage(struct, failures, colorize = true) {
+  const formattedFailures = failures.map(
+    (failure) => _chunk6WBLB5BXjs.indent.call(void 0, `\u2022 ${getStructFailureMessage(struct, failure, colorize)}`)
+  );
+  return formattedFailures.join("\n");
+}
+function validateUnion(value, struct, structKey, coerce = false) {
+  _utils.assert.call(void 0, 
+    struct.schema,
+    "Expected a struct with a schema. Make sure to use `union` from `@metamask/snaps-sdk`."
+  );
+  _utils.assert.call(void 0, 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 = _superstruct.type.call(void 0, {
+    [structKey]: _snapssdk.union.call(void 0, keyUnion)
+  });
+  const [keyError] = _superstruct.validate.call(void 0, value, key, { coerce });
+  if (keyError) {
+    throw new Error(
+      getStructFailureMessage(key, keyError.failures()[0], false)
+    );
+  }
+  const objectValue = value;
+  const objectStructs = struct.schema.filter(
+    (innerStruct) => _superstruct.is.call(void 0, objectValue[structKey], innerStruct.schema[structKey])
+  );
+  _utils.assert.call(void 0, objectStructs.length > 0, "Expected a struct to match the value.");
+  const validationResults = objectStructs.map(
+    (objectStruct) => _superstruct.validate.call(void 0, objectValue, objectStruct, { coerce })
+  );
+  const validatedValue = validationResults.find(([error]) => !error);
+  if (validatedValue) {
+    return validatedValue[1];
+  }
+  _utils.assert.call(void 0, validationResults[0][0], "Expected at least one error.");
+  const validationError = validationResults.reduce((error, [innerError]) => {
+    _utils.assert.call(void 0, 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);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.named = named; exports.SnapsStructError = SnapsStructError; exports.arrayToGenerator = arrayToGenerator; exports.getError = getError; exports.createFromStruct = createFromStruct; exports.getStructFromPath = getStructFromPath; exports.getUnionStructNames = getUnionStructNames; exports.getStructErrorPrefix = getStructErrorPrefix; exports.getStructFailureMessage = getStructFailureMessage; exports.getStructErrorMessage = getStructErrorMessage; exports.validateUnion = validateUnion; exports.createUnion = createUnion;
+//# sourceMappingURL=chunk-GMC2A3D7.js.map

package/dist/chunk-GMC2A3D7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/structs.ts"],"names":[],"mappings":"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","sourcesContent":["import { union } from '@metamask/snaps-sdk';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assert, isObject } from '@metamask/utils';\nimport { bold, green, red } from 'chalk';\nimport type { Failure } from 'superstruct';\nimport {\n  is,\n  validate,\n  type as superstructType,\n  Struct,\n  StructError,\n  create,\n} from 'superstruct';\nimport type { AnyStruct } from 'superstruct/dist/utils';\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  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"]}

package/dist/chunk-GW5NQXN4.mjs

@@ -0,0 +1,151 @@
+import {
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk-4GBOSMF7.mjs";
+
+// src/errors.ts
+import {
+  errorCodes,
+  JsonRpcError as RpcError,
+  serializeCause
+} from "@metamask/rpc-errors";
+import {
+  getErrorMessage,
+  getErrorStack,
+  SNAP_ERROR_CODE,
+  SNAP_ERROR_MESSAGE
+} from "@metamask/snaps-sdk";
+import { isObject, isJsonRpcError } from "@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 = getErrorMessage(error);
+    super(message);
+    __privateAdd(this, _error, void 0);
+    __privateAdd(this, _message, void 0);
+    __privateAdd(this, _stack, void 0);
+    __privateSet(this, _error, error);
+    __privateSet(this, _message, message);
+    __privateSet(this, _stack, getErrorStack(error));
+  }
+  /**
+   * The error name.
+   *
+   * @returns The error name.
+   */
+  get name() {
+    return "WrappedSnapError";
+  }
+  /**
+   * The error message.
+   *
+   * @returns The error message.
+   */
+  get message() {
+    return __privateGet(this, _message);
+  }
+  /**
+   * The error stack.
+   *
+   * @returns The error stack.
+   */
+  get stack() {
+    return __privateGet(this, _stack);
+  }
+  /**
+   * Convert the error to a JSON object.
+   *
+   * @returns The JSON object.
+   */
+  toJSON() {
+    const cause = isSnapError(__privateGet(this, _error)) ? __privateGet(this, _error).serialize() : serializeCause(__privateGet(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 (isObject(error) && "serialize" in error && typeof error.serialize === "function") {
+    const serialized = error.serialize();
+    return isJsonRpcError(serialized) && isSerializedSnapError(serialized);
+  }
+  return false;
+}
+function isSerializedSnapError(error) {
+  return error.code === SNAP_ERROR_CODE && error.message === SNAP_ERROR_MESSAGE;
+}
+function isWrappedSnapError(error) {
+  return isJsonRpcError(error) && error.code === SNAP_ERROR_WRAPPER_CODE && error.message === SNAP_ERROR_WRAPPER_MESSAGE;
+}
+function getJsonRpcError(code, message, stack, data) {
+  const error = new RpcError(code, message, data);
+  error.stack = stack;
+  return error;
+}
+function unwrapError(error) {
+  if (isWrappedSnapError(error)) {
+    if (isJsonRpcError(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(
+        errorCodes.rpc.internal,
+        getErrorMessage(error.data.cause),
+        getErrorStack(error.data.cause)
+      ),
+      false
+    ];
+  }
+  if (isJsonRpcError(error)) {
+    const { code, message, stack, data } = error;
+    return [getJsonRpcError(code, message, stack, data), false];
+  }
+  return [
+    getJsonRpcError(
+      errorCodes.rpc.internal,
+      getErrorMessage(error),
+      getErrorStack(error)
+    ),
+    false
+  ];
+}
+
+export {
+  SNAP_ERROR_WRAPPER_CODE,
+  SNAP_ERROR_WRAPPER_MESSAGE,
+  WrappedSnapError,
+  isSnapError,
+  isSerializedSnapError,
+  isWrappedSnapError,
+  unwrapError
+};
+//# sourceMappingURL=chunk-GW5NQXN4.mjs.map

package/dist/chunk-GW5NQXN4.mjs.map

@@ -0,0 +1 @@
+{"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"],"mappings":"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","names":["code","message","stack","data"]}

package/dist/chunk-H34N3OWO.mjs

@@ -0,0 +1,169 @@
+import {
+  isEqual
+} from "./chunk-XKXHM3PC.mjs";
+
+// src/derivation-paths.ts
+import slip44 from "@metamask/slip44";
+var SNAPS_DERIVATION_PATHS = [
+  {
+    path: ["m", `44'`, `0'`],
+    curve: "ed25519",
+    name: "Test BIP-32 Path (ed25519)"
+  },
+  {
+    path: ["m", `44'`, `1'`],
+    curve: "secp256k1",
+    name: "Testnet"
+  },
+  {
+    path: ["m", `44'`, `0'`],
+    curve: "secp256k1",
+    name: "Bitcoin Legacy"
+  },
+  {
+    path: ["m", `49'`, `0'`],
+    curve: "secp256k1",
+    name: "Bitcoin Nested SegWit"
+  },
+  {
+    path: ["m", `49'`, `1'`],
+    curve: "secp256k1",
+    name: "Bitcoin Testnet Nested SegWit"
+  },
+  {
+    path: ["m", `84'`, `0'`],
+    curve: "secp256k1",
+    name: "Bitcoin Native SegWit"
+  },
+  {
+    path: ["m", `84'`, `1'`],
+    curve: "secp256k1",
+    name: "Bitcoin Testnet Native SegWit"
+  },
+  {
+    path: ["m", `44'`, `501'`],
+    curve: "ed25519",
+    name: "Solana"
+  },
+  {
+    path: ["m", `44'`, `501'`, "0'", "0'"],
+    curve: "ed25519",
+    name: "Solana"
+  },
+  {
+    path: ["m", `44'`, `2'`],
+    curve: "secp256k1",
+    name: "Litecoin"
+  },
+  {
+    path: ["m", `44'`, `3'`],
+    curve: "secp256k1",
+    name: "Dogecoin"
+  },
+  {
+    path: ["m", `44'`, `60'`],
+    curve: "secp256k1",
+    name: "Ethereum"
+  },
+  {
+    path: ["m", `44'`, `118'`],
+    curve: "secp256k1",
+    name: "Atom"
+  },
+  {
+    path: ["m", `44'`, `145'`],
+    curve: "secp256k1",
+    name: "Bitcoin Cash"
+  },
+  {
+    path: ["m", `44'`, `637'`],
+    curve: "ed25519",
+    name: "Aptos"
+  },
+  {
+    path: ["m", `44'`, `714'`],
+    curve: "secp256k1",
+    name: "Binance (BNB)"
+  },
+  {
+    path: ["m", `44'`, `784'`],
+    curve: "ed25519",
+    name: "Sui"
+  },
+  {
+    path: ["m", `44'`, `931'`],
+    curve: "secp256k1",
+    name: "THORChain (RUNE)"
+  },
+  {
+    path: ["m", `44'`, `330'`],
+    curve: "secp256k1",
+    name: "Terra (LUNA)"
+  },
+  {
+    path: ["m", `44'`, `459'`],
+    curve: "secp256k1",
+    name: "Kava"
+  },
+  {
+    path: ["m", `44'`, `529'`],
+    curve: "secp256k1",
+    name: "Secret Network"
+  },
+  {
+    path: ["m", `44'`, `397'`, `0'`],
+    curve: "ed25519",
+    name: "NEAR Protocol"
+  },
+  {
+    path: ["m", `44'`, `1'`, `0'`],
+    curve: "ed25519",
+    name: "Testnet"
+  },
+  {
+    path: ["m", `44'`, `472'`],
+    curve: "ed25519",
+    name: "Arweave"
+  },
+  {
+    path: ["m", `44'`, `12586'`],
+    curve: "secp256k1",
+    name: "Mina"
+  },
+  {
+    path: ["m", `44'`, `1729'`, `0'`, `0'`],
+    curve: "ed25519",
+    name: "Tezos"
+  },
+  {
+    path: ["m", `1789'`, `0'`],
+    curve: "ed25519",
+    name: "Vega"
+  }
+];
+function getSnapDerivationPathName(path, curve) {
+  const pathMetadata = SNAPS_DERIVATION_PATHS.find(
+    (derivationPath) => derivationPath.curve === curve && isEqual(derivationPath.path, path)
+  );
+  if (pathMetadata) {
+    return pathMetadata.name;
+  }
+  if (curve === "secp256k1" && path[0] === "m" && path[1] === `44'` && path[2].endsWith(`'`)) {
+    const coinType = path[2].slice(0, -1);
+    return getSlip44ProtocolName(coinType) ?? null;
+  }
+  return null;
+}
+function getSlip44ProtocolName(coinType) {
+  if (String(coinType) === "1") {
+    return "Test Networks";
+  }
+  return slip44[coinType]?.name ?? null;
+}
+
+export {
+  SNAPS_DERIVATION_PATHS,
+  getSnapDerivationPathName,
+  getSlip44ProtocolName
+};
+//# sourceMappingURL=chunk-H34N3OWO.mjs.map