@metamask/snaps-utils 6.0.0 → 7.0.0

package/dist/esm/json-rpc.js

@@ -1,79 +0,0 @@
-import { SubjectType } from '@metamask/permission-controller';
-import { assertStruct, isJsonRpcFailure, isJsonRpcSuccess } from '@metamask/utils';
-import { array, boolean, object, optional, refine, string } from 'superstruct';
-export const RpcOriginsStruct = refine(object({
-    dapps: optional(boolean()),
-    snaps: optional(boolean()),
-    allowedOrigins: optional(array(string()))
-}), 'RPC origins', (value)=>{
-    const hasOrigins = Boolean(value.snaps === true || value.dapps === true || value.allowedOrigins && value.allowedOrigins.length > 0);
-    if (hasOrigins) {
-        return true;
-    }
-    return 'Must specify at least one JSON-RPC origin.';
-});
-/**
- * Asserts that the given value is a valid {@link RpcOrigins} object.
- *
- * @param value - The value to assert.
- * @param ErrorWrapper - An optional error wrapper to use. Defaults to
- * {@link AssertionError}.
- * @throws If the value is not a valid {@link RpcOrigins} object.
- */ export function assertIsRpcOrigins(value, // eslint-disable-next-line @typescript-eslint/naming-convention
-ErrorWrapper) {
-    assertStruct(value, RpcOriginsStruct, 'Invalid JSON-RPC origins', ErrorWrapper);
-}
-export const KeyringOriginsStruct = object({
-    allowedOrigins: optional(array(string()))
-});
-/**
- * Assert that the given value is a valid {@link KeyringOrigins} object.
- *
- * @param value - The value to assert.
- * @param ErrorWrapper - An optional error wrapper to use. Defaults to
- * {@link AssertionError}.
- * @throws If the value is not a valid {@link KeyringOrigins} object.
- */ export function assertIsKeyringOrigins(value, // eslint-disable-next-line @typescript-eslint/naming-convention
-ErrorWrapper) {
-    assertStruct(value, KeyringOriginsStruct, 'Invalid keyring origins', ErrorWrapper);
-}
-/**
- * Check if the given origin is allowed by the given JSON-RPC origins object.
- *
- * @param origins - The JSON-RPC origins object.
- * @param subjectType - The type of the origin.
- * @param origin - The origin to check.
- * @returns Whether the origin is allowed.
- */ export function isOriginAllowed(origins, subjectType, origin) {
-    // The MetaMask client is always allowed.
-    if (origin === 'metamask') {
-        return true;
-    }
-    // If the origin is in the `allowedOrigins` list, it is allowed.
-    if (origins.allowedOrigins?.includes(origin)) {
-        return true;
-    }
-    // If the origin is a website and `dapps` is true, it is allowed.
-    if (subjectType === SubjectType.Website && origins.dapps) {
-        return true;
-    }
-    // If the origin is a snap and `snaps` is true, it is allowed.
-    return Boolean(subjectType === SubjectType.Snap && origins.snaps);
-}
-/**
- * Assert that the given value is a successful JSON-RPC response. If the value
- * is not a success response, an error is thrown. If the value is an JSON-RPC
- * error, the error message is included in the thrown error.
- *
- * @param value - The value to check.
- * @throws If the value is not a JSON-RPC success response.
- */ export function assertIsJsonRpcSuccess(value) {
-    if (!isJsonRpcSuccess(value)) {
-        if (isJsonRpcFailure(value)) {
-            throw new Error(`JSON-RPC request failed: ${value.error.message}`);
-        }
-        throw new Error('Invalid JSON-RPC response.');
-    }
-}
-
-//# sourceMappingURL=json-rpc.js.map

package/dist/esm/json-rpc.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/json-rpc.ts"],"sourcesContent":["import { SubjectType } from '@metamask/permission-controller';\nimport type {\n  AssertionErrorConstructor,\n  Json,\n  JsonRpcSuccess,\n} from '@metamask/utils';\nimport {\n  assertStruct,\n  isJsonRpcFailure,\n  isJsonRpcSuccess,\n} from '@metamask/utils';\nimport type { Infer } from 'superstruct';\nimport { array, boolean, object, optional, refine, string } from 'superstruct';\n\nexport const RpcOriginsStruct = refine(\n  object({\n    dapps: optional(boolean()),\n    snaps: optional(boolean()),\n    allowedOrigins: optional(array(string())),\n  }),\n  'RPC origins',\n  (value) => {\n    const hasOrigins = Boolean(\n      value.snaps === true ||\n        value.dapps === true ||\n        (value.allowedOrigins && value.allowedOrigins.length > 0),\n    );\n\n    if (hasOrigins) {\n      return true;\n    }\n\n    return 'Must specify at least one JSON-RPC origin.';\n  },\n);\n\nexport type RpcOrigins = Infer<typeof RpcOriginsStruct>;\n\n/**\n * Asserts that the given value is a valid {@link RpcOrigins} object.\n *\n * @param value - The value to assert.\n * @param ErrorWrapper - An optional error wrapper to use. Defaults to\n * {@link AssertionError}.\n * @throws If the value is not a valid {@link RpcOrigins} object.\n */\nexport function assertIsRpcOrigins(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is RpcOrigins {\n  assertStruct(\n    value,\n    RpcOriginsStruct,\n    'Invalid JSON-RPC origins',\n    ErrorWrapper,\n  );\n}\n\nexport const KeyringOriginsStruct = object({\n  allowedOrigins: optional(array(string())),\n});\n\nexport type KeyringOrigins = Infer<typeof KeyringOriginsStruct>;\n\n/**\n * Assert that the given value is a valid {@link KeyringOrigins} object.\n *\n * @param value - The value to assert.\n * @param ErrorWrapper - An optional error wrapper to use. Defaults to\n * {@link AssertionError}.\n * @throws If the value is not a valid {@link KeyringOrigins} object.\n */\nexport function assertIsKeyringOrigins(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is KeyringOrigins {\n  assertStruct(\n    value,\n    KeyringOriginsStruct,\n    'Invalid keyring origins',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given origin is allowed by the given JSON-RPC origins object.\n *\n * @param origins - The JSON-RPC origins object.\n * @param subjectType - The type of the origin.\n * @param origin - The origin to check.\n * @returns Whether the origin is allowed.\n */\nexport function isOriginAllowed(\n  origins: RpcOrigins,\n  subjectType: SubjectType,\n  origin: string,\n) {\n  // The MetaMask client is always allowed.\n  if (origin === 'metamask') {\n    return true;\n  }\n\n  // If the origin is in the `allowedOrigins` list, it is allowed.\n  if (origins.allowedOrigins?.includes(origin)) {\n    return true;\n  }\n\n  // If the origin is a website and `dapps` is true, it is allowed.\n  if (subjectType === SubjectType.Website && origins.dapps) {\n    return true;\n  }\n\n  // If the origin is a snap and `snaps` is true, it is allowed.\n  return Boolean(subjectType === SubjectType.Snap && origins.snaps);\n}\n\n/**\n * Assert that the given value is a successful JSON-RPC response. If the value\n * is not a success response, an error is thrown. If the value is an JSON-RPC\n * error, the error message is included in the thrown error.\n *\n * @param value - The value to check.\n * @throws If the value is not a JSON-RPC success response.\n */\nexport function assertIsJsonRpcSuccess(\n  value: unknown,\n): asserts value is JsonRpcSuccess<Json> {\n  if (!isJsonRpcSuccess(value)) {\n    if (isJsonRpcFailure(value)) {\n      throw new Error(`JSON-RPC request failed: ${value.error.message}`);\n    }\n\n    throw new Error('Invalid JSON-RPC response.');\n  }\n}\n"],"names":["SubjectType","assertStruct","isJsonRpcFailure","isJsonRpcSuccess","array","boolean","object","optional","refine","string","RpcOriginsStruct","dapps","snaps","allowedOrigins","value","hasOrigins","Boolean","length","assertIsRpcOrigins","ErrorWrapper","KeyringOriginsStruct","assertIsKeyringOrigins","isOriginAllowed","origins","subjectType","origin","includes","Website","Snap","assertIsJsonRpcSuccess","Error","error","message"],"mappings":"AAAA,SAASA,WAAW,QAAQ,kCAAkC;AAM9D,SACEC,YAAY,EACZC,gBAAgB,EAChBC,gBAAgB,QACX,kBAAkB;AAEzB,SAASC,KAAK,EAAEC,OAAO,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,MAAM,EAAEC,MAAM,QAAQ,cAAc;AAE/E,OAAO,MAAMC,mBAAmBF,OAC9BF,OAAO;IACLK,OAAOJ,SAASF;IAChBO,OAAOL,SAASF;IAChBQ,gBAAgBN,SAASH,MAAMK;AACjC,IACA,eACA,CAACK;IACC,MAAMC,aAAaC,QACjBF,MAAMF,KAAK,KAAK,QACdE,MAAMH,KAAK,KAAK,QACfG,MAAMD,cAAc,IAAIC,MAAMD,cAAc,CAACI,MAAM,GAAG;IAG3D,IAAIF,YAAY;QACd,OAAO;IACT;IAEA,OAAO;AACT,GACA;AAIF;;;;;;;CAOC,GACD,OAAO,SAASG,mBACdJ,KAAc,EACd,gEAAgE;AAChEK,YAAwC;IAExClB,aACEa,OACAJ,kBACA,4BACAS;AAEJ;AAEA,OAAO,MAAMC,uBAAuBd,OAAO;IACzCO,gBAAgBN,SAASH,MAAMK;AACjC,GAAG;AAIH;;;;;;;CAOC,GACD,OAAO,SAASY,uBACdP,KAAc,EACd,gEAAgE;AAChEK,YAAwC;IAExClB,aACEa,OACAM,sBACA,2BACAD;AAEJ;AAEA;;;;;;;CAOC,GACD,OAAO,SAASG,gBACdC,OAAmB,EACnBC,WAAwB,EACxBC,MAAc;IAEd,yCAAyC;IACzC,IAAIA,WAAW,YAAY;QACzB,OAAO;IACT;IAEA,gEAAgE;IAChE,IAAIF,QAAQV,cAAc,EAAEa,SAASD,SAAS;QAC5C,OAAO;IACT;IAEA,iEAAiE;IACjE,IAAID,gBAAgBxB,YAAY2B,OAAO,IAAIJ,QAAQZ,KAAK,EAAE;QACxD,OAAO;IACT;IAEA,8DAA8D;IAC9D,OAAOK,QAAQQ,gBAAgBxB,YAAY4B,IAAI,IAAIL,QAAQX,KAAK;AAClE;AAEA;;;;;;;CAOC,GACD,OAAO,SAASiB,uBACdf,KAAc;IAEd,IAAI,CAACX,iBAAiBW,QAAQ;QAC5B,IAAIZ,iBAAiBY,QAAQ;YAC3B,MAAM,IAAIgB,MAAM,CAAC,yBAAyB,EAAEhB,MAAMiB,KAAK,CAACC,OAAO,CAAC,CAAC;QACnE;QAEA,MAAM,IAAIF,MAAM;IAClB;AACF"}

package/dist/esm/json.js

@@ -1,17 +0,0 @@
-import { getSafeJson } from '@metamask/utils';
-// TODO: Upstream this to @metamask/utils
-/**
- * Parse JSON safely.
- *
- * Does multiple kinds of validation and strips unwanted properties like
- * `__proto__` and `constructor`.
- *
- * @param json - A JSON string to be parsed.
- * @returns The parsed JSON object.
- * @template Type - The type of the JSON object. The type is not actually
- * checked, but it is used to infer the return type.
- */ export function parseJson(json) {
-    return getSafeJson(JSON.parse(json));
-}
-
-//# sourceMappingURL=json.js.map

package/dist/esm/json.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/json.ts"],"sourcesContent":["import type { Json } from '@metamask/utils';\nimport { getSafeJson } from '@metamask/utils';\n\n// TODO: Upstream this to @metamask/utils\n\n/**\n * Parse JSON safely.\n *\n * Does multiple kinds of validation and strips unwanted properties like\n * `__proto__` and `constructor`.\n *\n * @param json - A JSON string to be parsed.\n * @returns The parsed JSON object.\n * @template Type - The type of the JSON object. The type is not actually\n * checked, but it is used to infer the return type.\n */\nexport function parseJson<Type extends Json = Json>(json: string) {\n  return getSafeJson<Type>(JSON.parse(json));\n}\n"],"names":["getSafeJson","parseJson","json","JSON","parse"],"mappings":"AACA,SAASA,WAAW,QAAQ,kBAAkB;AAE9C,yCAAyC;AAEzC;;;;;;;;;;CAUC,GACD,OAAO,SAASC,UAAoCC,IAAY;IAC9D,OAAOF,YAAkBG,KAAKC,KAAK,CAACF;AACtC"}

package/dist/esm/localization.js

@@ -1,115 +0,0 @@
-import { getErrorMessage } from '@metamask/snaps-sdk';
-import { create, object, optional, record, string, StructError } from 'superstruct';
-import { parseJson } from './json';
-export const LOCALIZABLE_FIELDS = [
-    'description',
-    'proposedName'
-];
-export const LocalizationFileStruct = object({
-    locale: string(),
-    messages: record(string(), object({
-        message: string(),
-        description: optional(string())
-    }))
-});
-/**
- * Validate a list of localization files.
- *
- * @param localizationFiles - The localization files to validate.
- * @returns The validated localization files.
- * @throws If any of the files are considered invalid.
- */ export function getValidatedLocalizationFiles(localizationFiles) {
-    for (const file of localizationFiles){
-        try {
-            file.result = create(parseJson(file.toString()), LocalizationFileStruct);
-        } catch (error) {
-            if (error instanceof StructError) {
-                throw new Error(`Failed to validate localization file "${file.path}": ${error.message}.`);
-            }
-            if (error instanceof SyntaxError) {
-                throw new Error(`Failed to parse localization file "${file.path}" as JSON.`);
-            }
-            throw error;
-        }
-    }
-    return localizationFiles;
-}
-/**
- * Get the localization file for a given locale. If the locale is not found,
- * the English localization file will be returned.
- *
- * @param locale - The locale to use.
- * @param localizationFiles - The localization files to use.
- * @returns The localization file, or `undefined` if no localization file was
- * found.
- */ export function getLocalizationFile(locale, localizationFiles) {
-    const file = localizationFiles.find((localizationFile)=>localizationFile.locale === locale);
-    if (!file) {
-        return localizationFiles.find((localizationFile)=>localizationFile.locale === 'en');
-    }
-    return file;
-}
-export const TRANSLATION_REGEX = /\{\{\s?([a-zA-Z0-9-_\s]+)\s?\}\}/gu;
-/**
- * Translate a string using a localization file. This will replace all instances
- * of `{{key}}` with the localized version of `key`.
- *
- * @param value - The string to translate.
- * @param file - The localization file to use, or `undefined` if no localization
- * file was found.
- * @returns The translated string.
- * @throws If the string contains a key that is not present in the localization
- * file, or if no localization file was found.
- */ export function translate(value, file) {
-    const matches = value.matchAll(TRANSLATION_REGEX);
-    const array = Array.from(matches);
-    return array.reduce((result, [match, key])=>{
-        if (!file) {
-            throw new Error(`Failed to translate "${value}": No localization file found.`);
-        }
-        const translation = file.messages[key.trim()];
-        if (!translation) {
-            throw new Error(`Failed to translate "${value}": No translation found for "${key.trim()}" in "${file.locale}" file.`);
-        }
-        return result.replace(match, translation.message);
-    }, value);
-}
-/**
- * Get the localized Snap manifest for a given locale. This will replace all
- * localized strings in the manifest with the localized version.
- *
- * @param snapManifest - The Snap manifest to localize.
- * @param locale - The locale to use.
- * @param localizationFiles - The localization files to use.
- * @returns The localized Snap manifest.
- */ export function getLocalizedSnapManifest(snapManifest, locale, localizationFiles) {
-    const file = getLocalizationFile(locale, localizationFiles);
-    return LOCALIZABLE_FIELDS.reduce((manifest, field)=>{
-        const translation = translate(manifest[field], file);
-        return {
-            ...manifest,
-            [field]: translation
-        };
-    }, snapManifest);
-}
-/**
- * Validate the localization files for a Snap manifest.
- *
- * @param snapManifest - The Snap manifest to validate.
- * @param localizationFiles - The localization files to validate.
- * @throws If the manifest cannot be localized.
- */ export function validateSnapManifestLocalizations(snapManifest, localizationFiles) {
-    try {
-        // `translate` throws if the manifest cannot be localized, so we just attempt
-        // to translate the manifest using all localization files.
-        localizationFiles.filter((file)=>file.locale !== 'en').forEach((file)=>{
-            getLocalizedSnapManifest(snapManifest, file.locale, localizationFiles);
-        });
-        // The manifest must be localizable in English.
-        getLocalizedSnapManifest(snapManifest, 'en', localizationFiles);
-    } catch (error) {
-        throw new Error(`Failed to localize Snap manifest: ${getErrorMessage(error)}`);
-    }
-}
-
-//# sourceMappingURL=localization.js.map

package/dist/esm/localization.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/localization.ts"],"sourcesContent":["import { getErrorMessage } from '@metamask/snaps-sdk';\nimport type { Infer } from 'superstruct';\nimport {\n  create,\n  object,\n  optional,\n  record,\n  string,\n  StructError,\n} from 'superstruct';\n\nimport { parseJson } from './json';\nimport type { SnapManifest } from './manifest';\nimport type { VirtualFile } from './virtual-file';\n\nexport const LOCALIZABLE_FIELDS = ['description', 'proposedName'] as const;\n\nexport const LocalizationFileStruct = object({\n  locale: string(),\n  messages: record(\n    string(),\n    object({\n      message: string(),\n      description: optional(string()),\n    }),\n  ),\n});\n\nexport type LocalizationFile = Infer<typeof LocalizationFileStruct>;\n\n/**\n * Validate a list of localization files.\n *\n * @param localizationFiles - The localization files to validate.\n * @returns The validated localization files.\n * @throws If any of the files are considered invalid.\n */\nexport function getValidatedLocalizationFiles(\n  localizationFiles: VirtualFile[],\n): VirtualFile<LocalizationFile>[] {\n  for (const file of localizationFiles) {\n    try {\n      file.result = create(parseJson(file.toString()), LocalizationFileStruct);\n    } catch (error) {\n      if (error instanceof StructError) {\n        throw new Error(\n          `Failed to validate localization file \"${file.path}\": ${error.message}.`,\n        );\n      }\n\n      if (error instanceof SyntaxError) {\n        throw new Error(\n          `Failed to parse localization file \"${file.path}\" as JSON.`,\n        );\n      }\n\n      throw error;\n    }\n  }\n\n  return localizationFiles as VirtualFile<LocalizationFile>[];\n}\n\n/**\n * Get the localization file for a given locale. If the locale is not found,\n * the English localization file will be returned.\n *\n * @param locale - The locale to use.\n * @param localizationFiles - The localization files to use.\n * @returns The localization file, or `undefined` if no localization file was\n * found.\n */\nexport function getLocalizationFile(\n  locale: string,\n  localizationFiles: LocalizationFile[],\n) {\n  const file = localizationFiles.find(\n    (localizationFile) => localizationFile.locale === locale,\n  );\n\n  if (!file) {\n    return localizationFiles.find(\n      (localizationFile) => localizationFile.locale === 'en',\n    );\n  }\n\n  return file;\n}\n\nexport const TRANSLATION_REGEX = /\\{\\{\\s?([a-zA-Z0-9-_\\s]+)\\s?\\}\\}/gu;\n\n/**\n * Translate a string using a localization file. This will replace all instances\n * of `{{key}}` with the localized version of `key`.\n *\n * @param value - The string to translate.\n * @param file - The localization file to use, or `undefined` if no localization\n * file was found.\n * @returns The translated string.\n * @throws If the string contains a key that is not present in the localization\n * file, or if no localization file was found.\n */\nexport function translate(value: string, file: LocalizationFile | undefined) {\n  const matches = value.matchAll(TRANSLATION_REGEX);\n  const array = Array.from(matches);\n\n  return array.reduce<string>((result, [match, key]) => {\n    if (!file) {\n      throw new Error(\n        `Failed to translate \"${value}\": No localization file found.`,\n      );\n    }\n\n    const translation = file.messages[key.trim()];\n    if (!translation) {\n      throw new Error(\n        `Failed to translate \"${value}\": No translation found for \"${key.trim()}\" in \"${\n          file.locale\n        }\" file.`,\n      );\n    }\n\n    return result.replace(match, translation.message);\n  }, value);\n}\n\n/**\n * Get the localized Snap manifest for a given locale. This will replace all\n * localized strings in the manifest with the localized version.\n *\n * @param snapManifest - The Snap manifest to localize.\n * @param locale - The locale to use.\n * @param localizationFiles - The localization files to use.\n * @returns The localized Snap manifest.\n */\nexport function getLocalizedSnapManifest(\n  snapManifest: SnapManifest,\n  locale: string,\n  localizationFiles: LocalizationFile[],\n) {\n  const file = getLocalizationFile(locale, localizationFiles);\n\n  return LOCALIZABLE_FIELDS.reduce((manifest, field) => {\n    const translation = translate(manifest[field], file);\n    return {\n      ...manifest,\n      [field]: translation,\n    };\n  }, snapManifest);\n}\n\n/**\n * Validate the localization files for a Snap manifest.\n *\n * @param snapManifest - The Snap manifest to validate.\n * @param localizationFiles - The localization files to validate.\n * @throws If the manifest cannot be localized.\n */\nexport function validateSnapManifestLocalizations(\n  snapManifest: SnapManifest,\n  localizationFiles: LocalizationFile[],\n) {\n  try {\n    // `translate` throws if the manifest cannot be localized, so we just attempt\n    // to translate the manifest using all localization files.\n    localizationFiles\n      .filter((file) => file.locale !== 'en')\n      .forEach((file) => {\n        getLocalizedSnapManifest(snapManifest, file.locale, localizationFiles);\n      });\n\n    // The manifest must be localizable in English.\n    getLocalizedSnapManifest(snapManifest, 'en', localizationFiles);\n  } catch (error) {\n    throw new Error(\n      `Failed to localize Snap manifest: ${getErrorMessage(error)}`,\n    );\n  }\n}\n"],"names":["getErrorMessage","create","object","optional","record","string","StructError","parseJson","LOCALIZABLE_FIELDS","LocalizationFileStruct","locale","messages","message","description","getValidatedLocalizationFiles","localizationFiles","file","result","toString","error","Error","path","SyntaxError","getLocalizationFile","find","localizationFile","TRANSLATION_REGEX","translate","value","matches","matchAll","array","Array","from","reduce","match","key","translation","trim","replace","getLocalizedSnapManifest","snapManifest","manifest","field","validateSnapManifestLocalizations","filter","forEach"],"mappings":"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"}

package/dist/esm/logging.js

@@ -1,59 +0,0 @@
-import { createProjectLogger } from '@metamask/utils';
-// The global logger used across the monorepo. Other projects should use this
-// to create a module logger.
-export const snapsLogger = createProjectLogger('snaps');
-/**
- * Log a message. Currently, this is just a wrapper around `console.log`, but
- * the implementation may change in the future. These logs will be included in
- * production builds, so they should be used sparingly, and not contain any
- * sensitive information.
- *
- * This function makes it easy to swap out the logging implementation in all
- * files at once.
- *
- * @param message - The message to log.
- * @param optionalParams - Additional parameters to pass to the logging.
- */ export function logInfo(message, ...optionalParams) {
-    // eslint-disable-next-line no-console
-    console.log(message, ...optionalParams);
-}
-/**
- * Log an error. Currently, this is just a wrapper around `console.error`, but
- * the implementation may change in the future. These logs will be included in
- * production builds, so they should be used sparingly, and not contain any
- * sensitive information.
- *
- * These logs should always be visible, without requiring the user to enable
- * verbose logging (like setting a `DEBUG` environment variable), as they are
- * important for debugging snaps.
- *
- * This function makes it easy to swap out the logging implementation in all
- * files at once.
- *
- * @param error - The error to log.
- * @param optionalParams - Additional parameters to pass to the logging.
- */ export function logError(error, ...optionalParams) {
-    // eslint-disable-next-line no-console
-    console.error(error, ...optionalParams);
-}
-/**
- * Log a warning. Currently, this is just a wrapper around `console.warn`, but
- * the implementation may change in the future. These logs will be included in
- * production builds, so they should be used sparingly, and not contain any
- * sensitive information.
- *
- * These logs should always be visible, without requiring the user to enable
- * verbose logging (like setting a `DEBUG` environment variable), as they are
- * important for debugging snaps.
- *
- * This function makes it easy to swap out the logging implementation in all
- * files at once.
- *
- * @param message - The message to log.
- * @param optionalParams - Additional parameters to pass to the logging.
- */ export function logWarning(message, ...optionalParams) {
-    // eslint-disable-next-line no-console
-    console.warn(message, ...optionalParams);
-}
-
-//# sourceMappingURL=logging.js.map

package/dist/esm/logging.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/logging.ts"],"sourcesContent":["import { createProjectLogger } from '@metamask/utils';\n\n// The global logger used across the monorepo. Other projects should use this\n// to create a module logger.\nexport const snapsLogger = createProjectLogger('snaps');\n\n/**\n * Log a message. Currently, this is just a wrapper around `console.log`, but\n * the implementation may change in the future. These logs will be included in\n * production builds, so they should be used sparingly, and not contain any\n * sensitive information.\n *\n * This function makes it easy to swap out the logging implementation in all\n * files at once.\n *\n * @param message - The message to log.\n * @param optionalParams - Additional parameters to pass to the logging.\n */\nexport function logInfo(message: string, ...optionalParams: unknown[]): void {\n  // eslint-disable-next-line no-console\n  console.log(message, ...optionalParams);\n}\n\n/**\n * Log an error. Currently, this is just a wrapper around `console.error`, but\n * the implementation may change in the future. These logs will be included in\n * production builds, so they should be used sparingly, and not contain any\n * sensitive information.\n *\n * These logs should always be visible, without requiring the user to enable\n * verbose logging (like setting a `DEBUG` environment variable), as they are\n * important for debugging snaps.\n *\n * This function makes it easy to swap out the logging implementation in all\n * files at once.\n *\n * @param error - The error to log.\n * @param optionalParams - Additional parameters to pass to the logging.\n */\nexport function logError(error: unknown, ...optionalParams: unknown[]): void {\n  // eslint-disable-next-line no-console\n  console.error(error, ...optionalParams);\n}\n\n/**\n * Log a warning. Currently, this is just a wrapper around `console.warn`, but\n * the implementation may change in the future. These logs will be included in\n * production builds, so they should be used sparingly, and not contain any\n * sensitive information.\n *\n * These logs should always be visible, without requiring the user to enable\n * verbose logging (like setting a `DEBUG` environment variable), as they are\n * important for debugging snaps.\n *\n * This function makes it easy to swap out the logging implementation in all\n * files at once.\n *\n * @param message - The message to log.\n * @param optionalParams - Additional parameters to pass to the logging.\n */\nexport function logWarning(\n  message: string,\n  ...optionalParams: unknown[]\n): void {\n  // eslint-disable-next-line no-console\n  console.warn(message, ...optionalParams);\n}\n"],"names":["createProjectLogger","snapsLogger","logInfo","message","optionalParams","console","log","logError","error","logWarning","warn"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ,kBAAkB;AAEtD,6EAA6E;AAC7E,6BAA6B;AAC7B,OAAO,MAAMC,cAAcD,oBAAoB,SAAS;AAExD;;;;;;;;;;;CAWC,GACD,OAAO,SAASE,QAAQC,OAAe,EAAE,GAAGC,cAAyB;IACnE,sCAAsC;IACtCC,QAAQC,GAAG,CAACH,YAAYC;AAC1B;AAEA;;;;;;;;;;;;;;;CAeC,GACD,OAAO,SAASG,SAASC,KAAc,EAAE,GAAGJ,cAAyB;IACnE,sCAAsC;IACtCC,QAAQG,KAAK,CAACA,UAAUJ;AAC1B;AAEA;;;;;;;;;;;;;;;CAeC,GACD,OAAO,SAASK,WACdN,OAAe,EACf,GAAGC,cAAyB;IAE5B,sCAAsC;IACtCC,QAAQK,IAAI,CAACP,YAAYC;AAC3B"}

package/dist/esm/manifest/index.browser.js

@@ -1,3 +0,0 @@
-export * from './validation';
-
-//# sourceMappingURL=index.browser.js.map

package/dist/esm/manifest/index.browser.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/manifest/index.browser.ts"],"sourcesContent":["export * from './validation';\n"],"names":[],"mappings":"AAAA,cAAc,eAAe"}

package/dist/esm/manifest/index.js

@@ -1,4 +0,0 @@
-export * from './manifest';
-export * from './validation';
-
-//# sourceMappingURL=index.js.map

package/dist/esm/manifest/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/manifest/index.ts"],"sourcesContent":["export * from './manifest';\nexport * from './validation';\n"],"names":[],"mappings":"AAAA,cAAc,aAAa;AAC3B,cAAc,eAAe"}

package/dist/esm/manifest/manifest.js

@@ -1,299 +0,0 @@
-import { getErrorMessage } from '@metamask/snaps-sdk';
-import { assertExhaustive, assert, isPlainObject } from '@metamask/utils';
-import deepEqual from 'fast-deep-equal';
-import { promises as fs } from 'fs';
-import pathUtils from 'path';
-import { deepClone } from '../deep-clone';
-import { readJsonFile } from '../fs';
-import { validateNpmSnap } from '../npm';
-import { getSnapChecksum, ProgrammaticallyFixableSnapError, validateSnapShasum } from '../snaps';
-import { NpmSnapFileNames, SnapValidationFailureReason } from '../types';
-import { readVirtualFile, VirtualFile } from '../virtual-file';
-const MANIFEST_SORT_ORDER = {
-    $schema: 1,
-    version: 2,
-    description: 3,
-    proposedName: 4,
-    repository: 5,
-    source: 6,
-    initialConnections: 7,
-    initialPermissions: 8,
-    manifestVersion: 9
-};
-/**
- * Validates a snap.manifest.json file. Attempts to fix the manifest and write
- * the fixed version to disk if `writeManifest` is true. Throws if validation
- * fails.
- *
- * @param basePath - The path to the folder with the manifest files.
- * @param writeManifest - Whether to write the fixed manifest to disk.
- * @param sourceCode - The source code of the Snap.
- * @param writeFileFn - The function to use to write the manifest to disk.
- * @returns Whether the manifest was updated, and an array of warnings that
- * were encountered during processing of the manifest files.
- */ export async function checkManifest(basePath, writeManifest = true, sourceCode, writeFileFn = fs.writeFile) {
-    const warnings = [];
-    const errors = [];
-    let updated = false;
-    const manifestPath = pathUtils.join(basePath, NpmSnapFileNames.Manifest);
-    const manifestFile = await readJsonFile(manifestPath);
-    const unvalidatedManifest = manifestFile.result;
-    const packageFile = await readJsonFile(pathUtils.join(basePath, NpmSnapFileNames.PackageJson));
-    const auxiliaryFilePaths = getSnapFilePaths(unvalidatedManifest, (manifest)=>manifest?.source?.files);
-    const localizationFilePaths = getSnapFilePaths(unvalidatedManifest, (manifest)=>manifest?.source?.locales);
-    const snapFiles = {
-        manifest: manifestFile,
-        packageJson: packageFile,
-        sourceCode: await getSnapSourceCode(basePath, unvalidatedManifest, sourceCode),
-        svgIcon: await getSnapIcon(basePath, unvalidatedManifest),
-        // Intentionally pass null as the encoding here since the files may be binary
-        auxiliaryFiles: await getSnapFiles(basePath, auxiliaryFilePaths, null) ?? [],
-        localizationFiles: await getSnapFiles(basePath, localizationFilePaths) ?? []
-    };
-    let manifest;
-    try {
-        ({ manifest } = await validateNpmSnap(snapFiles));
-    } catch (error) {
-        if (error instanceof ProgrammaticallyFixableSnapError) {
-            errors.push(error.message);
-            // If we get here, the files at least have the correct shape.
-            const partiallyValidatedFiles = snapFiles;
-            let isInvalid = true;
-            let currentError = error;
-            const maxAttempts = Object.keys(SnapValidationFailureReason).length;
-            // Attempt to fix all fixable validation failure reasons. All such reasons
-            // are enumerated by the `SnapValidationFailureReason` enum, so we only
-            // attempt to fix the manifest the same amount of times as there are
-            // reasons in the enum.
-            for(let attempts = 1; isInvalid && attempts <= maxAttempts; attempts++){
-                manifest = await fixManifest(manifest ? {
-                    ...partiallyValidatedFiles,
-                    manifest
-                } : partiallyValidatedFiles, currentError);
-                try {
-                    await validateNpmSnapManifest({
-                        ...partiallyValidatedFiles,
-                        manifest
-                    });
-                    isInvalid = false;
-                } catch (nextValidationError) {
-                    currentError = nextValidationError;
-                    /* istanbul ignore next: this should be impossible */ if (!(nextValidationError instanceof ProgrammaticallyFixableSnapError) || attempts === maxAttempts && !isInvalid) {
-                        throw new Error(`Internal error: Failed to fix manifest. This is a bug, please report it. Reason:\n${error.message}`);
-                    }
-                    errors.push(currentError.message);
-                }
-            }
-            updated = true;
-        } else {
-            throw error;
-        }
-    }
-    // TypeScript assumes `manifest` can still be undefined, that is not the case.
-    // But we assert to keep TypeScript happy.
-    assert(manifest);
-    const validatedManifest = manifest.result;
-    // Check presence of recommended keys
-    const recommendedFields = [
-        'repository'
-    ];
-    const missingRecommendedFields = recommendedFields.filter((key)=>!validatedManifest[key]);
-    if (missingRecommendedFields.length > 0) {
-        warnings.push(`Missing recommended package.json properties:\n${missingRecommendedFields.reduce((allMissing, currentField)=>{
-            return `${allMissing}\t${currentField}\n`;
-        }, '')}`);
-    }
-    if (writeManifest) {
-        try {
-            const newManifest = `${JSON.stringify(getWritableManifest(validatedManifest), null, 2)}\n`;
-            if (updated || newManifest !== manifestFile.value) {
-                await writeFileFn(pathUtils.join(basePath, NpmSnapFileNames.Manifest), newManifest);
-            }
-        } catch (error) {
-            // Note: This error isn't pushed to the errors array, because it's not an
-            // error in the manifest itself.
-            throw new Error(`Failed to update snap.manifest.json: ${error.message}`);
-        }
-    }
-    return {
-        manifest: validatedManifest,
-        updated,
-        warnings,
-        errors
-    };
-}
-/**
- * Given the relevant Snap files (manifest, `package.json`, and bundle) and a
- * Snap manifest validation error, fixes the fault in the manifest that caused
- * the error.
- *
- * @param snapFiles - The contents of all Snap files.
- * @param error - The {@link ProgrammaticallyFixableSnapError} that was thrown.
- * @returns A copy of the manifest file where the cause of the error is fixed.
- */ export async function fixManifest(snapFiles, error) {
-    const { manifest, packageJson } = snapFiles;
-    const clonedFile = manifest.clone();
-    const manifestCopy = clonedFile.result;
-    switch(error.reason){
-        case SnapValidationFailureReason.NameMismatch:
-            manifestCopy.source.location.npm.packageName = packageJson.result.name;
-            break;
-        case SnapValidationFailureReason.VersionMismatch:
-            manifestCopy.version = packageJson.result.version;
-            break;
-        case SnapValidationFailureReason.RepositoryMismatch:
-            manifestCopy.repository = packageJson.result.repository ? deepClone(packageJson.result.repository) : undefined;
-            break;
-        case SnapValidationFailureReason.ShasumMismatch:
-            manifestCopy.source.shasum = await getSnapChecksum(snapFiles);
-            break;
-        /* istanbul ignore next */ default:
-            assertExhaustive(error.reason);
-    }
-    clonedFile.result = manifestCopy;
-    clonedFile.value = JSON.stringify(manifestCopy);
-    return clonedFile;
-}
-/**
- * Given an unvalidated Snap manifest, attempts to extract the location of the
- * bundle source file location and read the file.
- *
- * @param basePath - The path to the folder with the manifest files.
- * @param manifest - The unvalidated Snap manifest file contents.
- * @param sourceCode - Override source code for plugins.
- * @returns The contents of the bundle file, if any.
- */ export async function getSnapSourceCode(basePath, manifest, sourceCode) {
-    if (!isPlainObject(manifest)) {
-        return undefined;
-    }
-    const sourceFilePath = manifest.source?.location?.npm?.filePath;
-    if (!sourceFilePath) {
-        return undefined;
-    }
-    if (sourceCode) {
-        return new VirtualFile({
-            path: pathUtils.join(basePath, sourceFilePath),
-            value: sourceCode
-        });
-    }
-    try {
-        const virtualFile = await readVirtualFile(pathUtils.join(basePath, sourceFilePath), 'utf8');
-        return virtualFile;
-    } catch (error) {
-        throw new Error(`Failed to read snap bundle file: ${getErrorMessage(error)}`);
-    }
-}
-/**
- * Given an unvalidated Snap manifest, attempts to extract the location of the
- * icon and read the file.
- *
- * @param basePath - The path to the folder with the manifest files.
- * @param manifest - The unvalidated Snap manifest file contents.
- * @returns The contents of the icon, if any.
- */ export async function getSnapIcon(basePath, manifest) {
-    if (!isPlainObject(manifest)) {
-        return undefined;
-    }
-    const iconPath = manifest.source?.location?.npm?.iconPath;
-    if (!iconPath) {
-        return undefined;
-    }
-    try {
-        const virtualFile = await readVirtualFile(pathUtils.join(basePath, iconPath), 'utf8');
-        return virtualFile;
-    } catch (error) {
-        throw new Error(`Failed to read snap icon file: ${getErrorMessage(error)}`);
-    }
-}
-/**
- * Get an array of paths from an unvalidated Snap manifest.
- *
- * @param manifest - The unvalidated Snap manifest file contents.
- * @param selector - A function that returns the paths to the files.
- * @returns The paths to the files, if any.
- */ export function getSnapFilePaths(manifest, selector) {
-    if (!isPlainObject(manifest)) {
-        return undefined;
-    }
-    const snapManifest = manifest;
-    const paths = selector(snapManifest);
-    if (!Array.isArray(paths)) {
-        return undefined;
-    }
-    return paths;
-}
-/**
- * Given an unvalidated Snap manifest, attempts to extract the files with the
- * given paths and read them.
- *
- * @param basePath - The path to the folder with the manifest files.
- * @param paths - The paths to the files.
- * @param encoding - An optional encoding to pass down to readVirtualFile.
- * @returns A list of auxiliary files and their contents, if any.
- */ export async function getSnapFiles(basePath, paths, encoding = 'utf8') {
-    if (!paths) {
-        return undefined;
-    }
-    try {
-        return await Promise.all(paths.map(async (filePath)=>readVirtualFile(pathUtils.join(basePath, filePath), encoding)));
-    } catch (error) {
-        throw new Error(`Failed to read snap files: ${getErrorMessage(error)}`);
-    }
-}
-/**
- * Sorts the given manifest in our preferred sort order and removes the
- * `repository` field if it is falsy (it may be `null`).
- *
- * @param manifest - The manifest to sort and modify.
- * @returns The disk-ready manifest.
- */ export function getWritableManifest(manifest) {
-    const { repository, ...remaining } = manifest;
-    const keys = Object.keys(repository ? {
-        ...remaining,
-        repository
-    } : remaining);
-    const writableManifest = keys.sort((a, b)=>MANIFEST_SORT_ORDER[a] - MANIFEST_SORT_ORDER[b]).reduce((result, key)=>({
-            ...result,
-            [key]: manifest[key]
-        }), {});
-    return writableManifest;
-}
-/**
- * Validates the fields of an NPM Snap manifest that has already passed JSON
- * Schema validation.
- *
- * @param snapFiles - The relevant snap files to validate.
- * @param snapFiles.manifest - The npm Snap manifest to validate.
- * @param snapFiles.packageJson - The npm Snap's `package.json`.
- * @param snapFiles.sourceCode - The Snap's source code.
- * @param snapFiles.svgIcon - The Snap's optional icon.
- * @param snapFiles.auxiliaryFiles - Any auxiliary files required by the snap at runtime.
- * @param snapFiles.localizationFiles - The Snap's localization files.
- */ export async function validateNpmSnapManifest({ manifest, packageJson, sourceCode, svgIcon, auxiliaryFiles, localizationFiles }) {
-    const packageJsonName = packageJson.result.name;
-    const packageJsonVersion = packageJson.result.version;
-    const packageJsonRepository = packageJson.result.repository;
-    const manifestPackageName = manifest.result.source.location.npm.packageName;
-    const manifestPackageVersion = manifest.result.version;
-    const manifestRepository = manifest.result.repository;
-    if (packageJsonName !== manifestPackageName) {
-        throw new ProgrammaticallyFixableSnapError(`"${NpmSnapFileNames.Manifest}" npm package name ("${manifestPackageName}") does not match the "${NpmSnapFileNames.PackageJson}" "name" field ("${packageJsonName}").`, SnapValidationFailureReason.NameMismatch);
-    }
-    if (packageJsonVersion !== manifestPackageVersion) {
-        throw new ProgrammaticallyFixableSnapError(`"${NpmSnapFileNames.Manifest}" npm package version ("${manifestPackageVersion}") does not match the "${NpmSnapFileNames.PackageJson}" "version" field ("${packageJsonVersion}").`, SnapValidationFailureReason.VersionMismatch);
-    }
-    if (// The repository may be `undefined` in package.json but can only be defined
-    // or `null` in the Snap manifest due to TS@<4.4 issues.
-    (packageJsonRepository || manifestRepository) && !deepEqual(packageJsonRepository, manifestRepository)) {
-        throw new ProgrammaticallyFixableSnapError(`"${NpmSnapFileNames.Manifest}" "repository" field does not match the "${NpmSnapFileNames.PackageJson}" "repository" field.`, SnapValidationFailureReason.RepositoryMismatch);
-    }
-    await validateSnapShasum({
-        manifest,
-        sourceCode,
-        svgIcon,
-        auxiliaryFiles,
-        localizationFiles
-    }, `"${NpmSnapFileNames.Manifest}" "shasum" field does not match computed shasum.`);
-}
-
-//# sourceMappingURL=manifest.js.map