@metamask/snaps-utils 0.34.1-flask.1 → 0.35.0-flask.1

package/dist/cjs/snaps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/snaps.ts"],"sourcesContent":["import {\n  Caveat,\n  SubjectPermissions,\n  PermissionConstraint,\n} from '@metamask/permission-controller';\nimport { BlockReason } from '@metamask/snaps-registry';\nimport {\n  assert,\n  Json,\n  SemVerVersion,\n  isObject,\n  Opaque,\n  assertStruct,\n} from '@metamask/utils';\nimport { base64 } from '@scure/base';\nimport { SerializedEthereumRpcError } from 'eth-rpc-errors/dist/classes';\nimport stableStringify from 'fast-json-stable-stringify';\nimport {\n  empty,\n  enums,\n  intersection,\n  literal,\n  pattern,\n  refine,\n  string,\n  Struct,\n  union,\n  validate,\n} from 'superstruct';\nimport validateNPMPackage from 'validate-npm-package-name';\n\nimport { SnapCaveatType } from './caveats';\nimport { checksumFiles } from './checksum';\nimport { SnapManifest, SnapPermissions } from './manifest/validation';\nimport {\n  SnapFiles,\n  SnapId,\n  SnapIdPrefixes,\n  SnapsPermissionRequest,\n  SnapValidationFailureReason,\n  uri,\n} from './types';\nimport { VirtualFile } from './virtual-file';\n\n// This RegEx matches valid npm package names (with some exceptions) and space-\n// separated alphanumerical words, optionally with dashes and underscores.\n// The RegEx consists of two parts. The first part matches space-separated\n// words. It is based on the following Stackoverflow answer:\n// https://stackoverflow.com/a/34974982\n// The second part, after the pipe operator, is the same RegEx used for the\n// `name` field of the official package.json JSON Schema, except that we allow\n// mixed-case letters. It was originally copied from:\n// https://github.com/SchemaStore/schemastore/blob/81a16897c1dabfd98c72242a5fd62eb080ff76d8/src/schemas/json/package.json#L132-L138\nexport const PROPOSED_NAME_REGEX =\n  /^(?:[A-Za-z0-9-_]+( [A-Za-z0-9-_]+)*)|(?:(?:@[A-Za-z0-9-*~][A-Za-z0-9-*._~]*\\/)?[A-Za-z0-9-~][A-Za-z0-9-._~]*)$/u;\n\n/**\n * wallet_enable / wallet_installSnaps permission typing.\n *\n * @deprecated This type is confusing and not descriptive, people confused it with typing initialPermissions, remove when removing wallet_enable.\n */\nexport type RequestedSnapPermissions = {\n  [permission: string]: Record<string, Json>;\n};\n\nexport enum SnapStatus {\n  Installing = 'installing',\n  Updating = 'updating',\n  Running = 'running',\n  Stopped = 'stopped',\n  Crashed = 'crashed',\n}\n\nexport enum SnapStatusEvents {\n  Start = 'START',\n  Stop = 'STOP',\n  Crash = 'CRASH',\n  Update = 'UPDATE',\n}\n\nexport type StatusContext = { snapId: ValidatedSnapId };\nexport type StatusEvents = { type: SnapStatusEvents };\nexport type StatusStates = {\n  value: SnapStatus;\n  context: StatusContext;\n};\nexport type Status = StatusStates['value'];\n\nexport type VersionHistory = {\n  origin: string;\n  version: string;\n  // Unix timestamp\n  date: number;\n};\n\nexport type PersistedSnap = Snap & {\n  /**\n   * The source code of the Snap.\n   */\n  sourceCode: string;\n};\n\n/**\n * A Snap as it exists in {@link SnapController} state.\n */\nexport type Snap = {\n  /**\n   * Whether the Snap is enabled, which determines if it can be started.\n   */\n  enabled: boolean;\n\n  /**\n   * The ID of the Snap.\n   */\n  id: ValidatedSnapId;\n\n  /**\n   * The initial permissions of the Snap, which will be requested when it is\n   * installed.\n   */\n  initialPermissions: SnapPermissions;\n\n  /**\n   * The Snap's manifest file.\n   */\n  manifest: SnapManifest;\n\n  /**\n   * Whether the Snap is blocked.\n   */\n  blocked: boolean;\n\n  /**\n   * Information detailing why the snap is blocked.\n   */\n  blockInformation?: BlockReason;\n\n  /**\n   * The current status of the Snap, e.g. whether it's running or stopped.\n   */\n  status: Status;\n\n  /**\n   * The version of the Snap.\n   */\n  version: SemVerVersion;\n\n  /**\n   * The version history of the Snap.\n   * Can be used to derive when the Snap was installed, when it was updated to a certain version and who requested the change.\n   */\n  versionHistory: VersionHistory[];\n};\n\nexport type TruncatedSnapFields =\n  | 'id'\n  | 'initialPermissions'\n  | 'version'\n  | 'enabled'\n  | 'blocked';\n\n/**\n * A {@link Snap} object with the fields that are relevant to an external\n * caller.\n */\nexport type TruncatedSnap = Pick<Snap, TruncatedSnapFields>;\n\nexport type ProcessSnapResult =\n  | TruncatedSnap\n  | { error: SerializedEthereumRpcError };\n\nexport type InstallSnapsResult = Record<SnapId, ProcessSnapResult>;\n\n/**\n * An error indicating that a Snap validation failure is programmatically\n * fixable during development.\n */\nexport class ProgrammaticallyFixableSnapError extends Error {\n  reason: SnapValidationFailureReason;\n\n  constructor(message: string, reason: SnapValidationFailureReason) {\n    super(message);\n    this.reason = reason;\n  }\n}\n\n/**\n * Gets a checksummable manifest by removing the shasum property and reserializing the JSON using a deterministic algorithm.\n *\n * @param manifest - The manifest itself.\n * @returns A virtual file containing the checksummable manifest.\n */\nfunction getChecksummableManifest(\n  manifest: VirtualFile<SnapManifest>,\n): VirtualFile {\n  const manifestCopy = manifest.clone() as VirtualFile<any>;\n  delete manifestCopy.result.source.shasum;\n\n  // We use fast-json-stable-stringify to deterministically serialize the JSON\n  // This is required before checksumming so we get reproducible checksums across platforms etc\n  manifestCopy.value = stableStringify(manifestCopy.result);\n  return manifestCopy;\n}\n\n/**\n * Calculates the Base64-encoded SHA-256 digest of all required Snap files.\n *\n * @param files - All required Snap files to be included in the checksum.\n * @returns The Base64-encoded SHA-256 digest of the source code.\n */\nexport function getSnapChecksum(\n  files: Pick<SnapFiles, 'manifest' | 'sourceCode' | 'svgIcon'>,\n): string {\n  const { manifest, sourceCode, svgIcon } = files;\n  const all = [getChecksummableManifest(manifest), sourceCode, svgIcon].filter(\n    (file) => file !== undefined,\n  );\n  return base64.encode(checksumFiles(all as VirtualFile[]));\n}\n\n/**\n * Checks whether the `source.shasum` property of a Snap manifest matches the\n * shasum of the snap.\n *\n * @param files - All required Snap files to be included in the checksum.\n * @param errorMessage - The error message to throw if validation fails.\n */\nexport function validateSnapShasum(\n  files: Pick<SnapFiles, 'manifest' | 'sourceCode' | 'svgIcon'>,\n  errorMessage = 'Invalid Snap manifest: manifest shasum does not match computed shasum.',\n): void {\n  if (files.manifest.result.source.shasum !== getSnapChecksum(files)) {\n    throw new ProgrammaticallyFixableSnapError(\n      errorMessage,\n      SnapValidationFailureReason.ShasumMismatch,\n    );\n  }\n}\n\nexport const LOCALHOST_HOSTNAMES = ['localhost', '127.0.0.1', '[::1]'] as const;\n\n// Require snap ids to only consist of printable ASCII characters\nexport const BaseSnapIdStruct = pattern(string(), /^[\\x21-\\x7E]*$/u);\n\nconst LocalSnapIdSubUrlStruct = uri({\n  protocol: enums(['http:', 'https:']),\n  hostname: enums(LOCALHOST_HOSTNAMES),\n  hash: empty(string()),\n  search: empty(string()),\n});\nexport const LocalSnapIdStruct = refine(\n  BaseSnapIdStruct,\n  'local Snap Id',\n  (value) => {\n    if (!value.startsWith(SnapIdPrefixes.local)) {\n      return `Expected local snap ID, got \"${value}\".`;\n    }\n\n    const [error] = validate(\n      value.slice(SnapIdPrefixes.local.length),\n      LocalSnapIdSubUrlStruct,\n    );\n    return error ?? true;\n  },\n);\nexport const NpmSnapIdStruct = intersection([\n  BaseSnapIdStruct,\n  uri({\n    protocol: literal(SnapIdPrefixes.npm),\n    pathname: refine(string(), 'package name', function* (value) {\n      const normalized = value.startsWith('/') ? value.slice(1) : value;\n      const { errors, validForNewPackages, warnings } =\n        validateNPMPackage(normalized);\n      if (!validForNewPackages) {\n        if (errors === undefined) {\n          assert(warnings !== undefined);\n          yield* warnings;\n        } else {\n          yield* errors;\n        }\n      }\n      return true;\n    }),\n    search: empty(string()),\n    hash: empty(string()),\n  }),\n]) as unknown as Struct<string, null>;\n\nexport const HttpSnapIdStruct = intersection([\n  BaseSnapIdStruct,\n  uri({\n    protocol: enums(['http:', 'https:']),\n    search: empty(string()),\n    hash: empty(string()),\n  }),\n]) as unknown as Struct<string, null>;\n\nexport const SnapIdStruct = union([NpmSnapIdStruct, LocalSnapIdStruct]);\n\nexport type ValidatedSnapId = Opaque<string, typeof snapIdSymbol>;\ndeclare const snapIdSymbol: unique symbol;\n\n/**\n * Extracts the snap prefix from a snap ID.\n *\n * @param snapId - The snap ID to extract the prefix from.\n * @returns The snap prefix from a snap id, e.g. `npm:`.\n */\nexport function getSnapPrefix(snapId: string): SnapIdPrefixes {\n  const prefix = Object.values(SnapIdPrefixes).find((possiblePrefix) =>\n    snapId.startsWith(possiblePrefix),\n  );\n  if (prefix !== undefined) {\n    return prefix;\n  }\n  throw new Error(`Invalid or no prefix found for \"${snapId}\"`);\n}\n\n/**\n * Strips snap prefix from a full snap ID.\n *\n * @param snapId - The snap ID to strip.\n * @returns The stripped snap ID.\n */\nexport function stripSnapPrefix(snapId: string): string {\n  return snapId.replace(getSnapPrefix(snapId), '');\n}\n\n/**\n * Assert that the given value is a valid snap ID.\n *\n * @param value - The value to check.\n * @throws If the value is not a valid snap ID.\n */\nexport function assertIsValidSnapId(\n  value: unknown,\n): asserts value is ValidatedSnapId {\n  assertStruct(value, SnapIdStruct, 'Invalid snap ID');\n}\n\n/**\n * Typeguard to ensure a chainId follows the CAIP-2 standard.\n *\n * @param chainId - The chainId being tested.\n * @returns `true` if the value is a valid CAIP chain id, and `false` otherwise.\n */\nexport function isCaipChainId(chainId: unknown): chainId is string {\n  return (\n    typeof chainId === 'string' &&\n    /^(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-a-zA-Z0-9]{1,32})$/u.test(\n      chainId,\n    )\n  );\n}\n\n/**\n * Utility function to check if an origin has permission (and caveat) for a particular snap.\n *\n * @param permissions - An origin's permissions object.\n * @param snapId - The id of the snap.\n * @returns A boolean based on if an origin has the specified snap.\n */\nexport function isSnapPermitted(\n  permissions: SubjectPermissions<PermissionConstraint>,\n  snapId: SnapId,\n) {\n  return Boolean(\n    (\n      (\n        (permissions?.wallet_snap?.caveats?.find(\n          (caveat) => caveat.type === SnapCaveatType.SnapIds,\n        ) ?? {}) as Caveat<string, Json>\n      ).value as Record<string, unknown>\n    )?.[snapId],\n  );\n}\n\n/**\n * Checks whether the passed in requestedPermissions is a valid\n * permission request for a `wallet_snap` permission.\n *\n * @param requestedPermissions - The requested permissions.\n * @throws If the criteria is not met.\n */\nexport function verifyRequestedSnapPermissions(\n  requestedPermissions: unknown,\n): asserts requestedPermissions is SnapsPermissionRequest {\n  assert(\n    isObject(requestedPermissions),\n    'Requested permissions must be an object.',\n  );\n\n  const { wallet_snap: walletSnapPermission } = requestedPermissions;\n\n  assert(\n    isObject(walletSnapPermission),\n    'wallet_snap is missing from the requested permissions.',\n  );\n\n  const { caveats } = walletSnapPermission;\n\n  assert(\n    Array.isArray(caveats) && caveats.length === 1,\n    'wallet_snap must have a caveat property with a single-item array value.',\n  );\n\n  const [caveat] = caveats;\n\n  assert(\n    isObject(caveat) &&\n      caveat.type === SnapCaveatType.SnapIds &&\n      isObject(caveat.value),\n    `The requested permissions do not have a valid ${SnapCaveatType.SnapIds} caveat.`,\n  );\n}\n"],"names":["PROPOSED_NAME_REGEX","ProgrammaticallyFixableSnapError","getSnapChecksum","validateSnapShasum","LOCALHOST_HOSTNAMES","BaseSnapIdStruct","LocalSnapIdStruct","NpmSnapIdStruct","HttpSnapIdStruct","SnapIdStruct","getSnapPrefix","stripSnapPrefix","assertIsValidSnapId","isCaipChainId","isSnapPermitted","verifyRequestedSnapPermissions","SnapStatus","Installing","Updating","Running","Stopped","Crashed","SnapStatusEvents","Start","Stop","Crash","Update","Error","constructor","message","reason","getChecksummableManifest","manifest","manifestCopy","clone","result","source","shasum","value","stableStringify","files","sourceCode","svgIcon","all","filter","file","undefined","base64","encode","checksumFiles","errorMessage","SnapValidationFailureReason","ShasumMismatch","pattern","string","LocalSnapIdSubUrlStruct","uri","protocol","enums","hostname","hash","empty","search","refine","startsWith","SnapIdPrefixes","local","error","validate","slice","length","intersection","literal","npm","pathname","normalized","errors","validForNewPackages","warnings","validateNPMPackage","assert","union","snapId","prefix","Object","values","find","possiblePrefix","replace","assertStruct","chainId","test","permissions","Boolean","wallet_snap","caveats","caveat","type","SnapCaveatType","SnapIds","requestedPermissions","isObject","walletSnapPermission","Array","isArray"],"mappings":"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"}

package/dist/cjs/types.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NpmSnapFileNames: function() {
+        return NpmSnapFileNames;
+    },
+    SnapIdPrefixes: function() {
+        return SnapIdPrefixes;
+    },
+    SnapValidationFailureReason: function() {
+        return SnapValidationFailureReason;
+    },
+    SNAP_STREAM_NAMES: function() {
+        return SNAP_STREAM_NAMES;
+    },
+    HandlerType: function() {
+        return HandlerType;
+    },
+    NameStruct: function() {
+        return NameStruct;
+    },
+    NpmSnapPackageJsonStruct: function() {
+        return NpmSnapPackageJsonStruct;
+    },
+    isNpmSnapPackageJson: function() {
+        return isNpmSnapPackageJson;
+    },
+    assertIsNpmSnapPackageJson: function() {
+        return assertIsNpmSnapPackageJson;
+    },
+    SNAP_EXPORT_NAMES: function() {
+        return SNAP_EXPORT_NAMES;
+    },
+    uri: function() {
+        return uri;
+    },
+    isValidUrl: function() {
+        return isValidUrl;
+    },
+    WALLET_SNAP_PERMISSION_KEY: function() {
+        return WALLET_SNAP_PERMISSION_KEY;
+    }
+});
+const _utils = require("@metamask/utils");
+const _superstruct = require("superstruct");
+var NpmSnapFileNames;
+(function(NpmSnapFileNames) {
+    NpmSnapFileNames["PackageJson"] = 'package.json';
+    NpmSnapFileNames["Manifest"] = 'snap.manifest.json';
+})(NpmSnapFileNames || (NpmSnapFileNames = {}));
+const NameStruct = (0, _superstruct.size)((0, _superstruct.pattern)((0, _superstruct.string)(), /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/u), 1, 214);
+const NpmSnapPackageJsonStruct = (0, _superstruct.type)({
+    version: _utils.VersionStruct,
+    name: NameStruct,
+    main: (0, _superstruct.optional)((0, _superstruct.size)((0, _superstruct.string)(), 1, Infinity)),
+    repository: (0, _superstruct.optional)((0, _superstruct.object)({
+        type: (0, _superstruct.size)((0, _superstruct.string)(), 1, Infinity),
+        url: (0, _superstruct.size)((0, _superstruct.string)(), 1, Infinity)
+    }))
+});
+function isNpmSnapPackageJson(value) {
+    return (0, _superstruct.is)(value, NpmSnapPackageJsonStruct);
+}
+function assertIsNpmSnapPackageJson(value) {
+    (0, _utils.assertStruct)(value, NpmSnapPackageJsonStruct, `"${NpmSnapFileNames.PackageJson}" is invalid`);
+}
+var SnapIdPrefixes;
+(function(SnapIdPrefixes) {
+    SnapIdPrefixes["npm"] = 'npm:';
+    SnapIdPrefixes["local"] = 'local:';
+})(SnapIdPrefixes || (SnapIdPrefixes = {}));
+var SnapValidationFailureReason;
+(function(SnapValidationFailureReason) {
+    SnapValidationFailureReason["NameMismatch"] = '"name" field mismatch';
+    SnapValidationFailureReason["VersionMismatch"] = '"version" field mismatch';
+    SnapValidationFailureReason["RepositoryMismatch"] = '"repository" field mismatch';
+    SnapValidationFailureReason["ShasumMismatch"] = '"shasum" field mismatch';
+})(SnapValidationFailureReason || (SnapValidationFailureReason = {}));
+var SNAP_STREAM_NAMES;
+(function(SNAP_STREAM_NAMES) {
+    SNAP_STREAM_NAMES["JSON_RPC"] = 'jsonRpc';
+    SNAP_STREAM_NAMES["COMMAND"] = 'command';
+})(SNAP_STREAM_NAMES || (SNAP_STREAM_NAMES = {}));
+var HandlerType;
+(function(HandlerType) {
+    HandlerType["OnRpcRequest"] = 'onRpcRequest';
+    HandlerType["OnTransaction"] = 'onTransaction';
+    HandlerType["OnCronjob"] = 'onCronjob';
+})(HandlerType || (HandlerType = {}));
+const SNAP_EXPORT_NAMES = Object.values(HandlerType);
+const uri = (opts = {})=>(0, _superstruct.refine)((0, _superstruct.union)([
+        (0, _superstruct.string)(),
+        (0, _superstruct.instance)(URL)
+    ]), 'uri', (value)=>{
+        try {
+            const url = new URL(value);
+            const UrlStruct = (0, _superstruct.type)(opts);
+            (0, _superstruct.assert)(url, UrlStruct);
+            return true;
+        } catch  {
+            return `Expected URL, got "${value.toString()}".`;
+        }
+    });
+function isValidUrl(url, opts = {}) {
+    return (0, _superstruct.is)(url, uri(opts));
+}
+const WALLET_SNAP_PERMISSION_KEY = 'wallet_snap';
+
+//# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types.ts"],"sourcesContent":["import { assertStruct, Json, VersionStruct } from '@metamask/utils';\nimport {\n  Infer,\n  instance,\n  is,\n  object,\n  optional,\n  pattern,\n  refine,\n  size,\n  string,\n  Struct,\n  type,\n  union,\n  assert as assertSuperstruct,\n} from 'superstruct';\n\nimport { SnapCaveatType } from './caveats';\nimport { SnapFunctionExports } from './handlers';\nimport { SnapManifest } from './manifest';\nimport { VirtualFile } from './virtual-file';\n\nexport enum NpmSnapFileNames {\n  PackageJson = 'package.json',\n  Manifest = 'snap.manifest.json',\n}\n\nexport const NameStruct = size(\n  pattern(\n    string(),\n    /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\\/)?[a-z0-9-~][a-z0-9-._~]*$/u,\n  ),\n  1,\n  214,\n);\n\n// Note we use `type` instead of `object` here, because the latter does not\n// allow unknown keys.\nexport const NpmSnapPackageJsonStruct = type({\n  version: VersionStruct,\n  name: NameStruct,\n  main: optional(size(string(), 1, Infinity)),\n  repository: optional(\n    object({\n      type: size(string(), 1, Infinity),\n      url: size(string(), 1, Infinity),\n    }),\n  ),\n});\n\nexport type NpmSnapPackageJson = Infer<typeof NpmSnapPackageJsonStruct> &\n  Record<string, any>;\n\n/**\n * Check if the given value is a valid {@link NpmSnapPackageJson} object.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid {@link NpmSnapPackageJson} object.\n */\nexport function isNpmSnapPackageJson(\n  value: unknown,\n): value is NpmSnapPackageJson {\n  return is(value, NpmSnapPackageJsonStruct);\n}\n\n/**\n * Asserts that the given value is a valid {@link NpmSnapPackageJson} object.\n *\n * @param value - The value to check.\n * @throws If the value is not a valid {@link NpmSnapPackageJson} object.\n */\nexport function assertIsNpmSnapPackageJson(\n  value: unknown,\n): asserts value is NpmSnapPackageJson {\n  assertStruct(\n    value,\n    NpmSnapPackageJsonStruct,\n    `\"${NpmSnapFileNames.PackageJson}\" is invalid`,\n  );\n}\n\n/**\n * An object for storing parsed but unvalidated Snap file contents.\n */\nexport type UnvalidatedSnapFiles = {\n  manifest?: VirtualFile<Json>;\n  packageJson?: VirtualFile<Json>;\n  sourceCode?: VirtualFile;\n  svgIcon?: VirtualFile;\n};\n\n/**\n * An object for storing the contents of Snap files that have passed JSON\n * Schema validation, or are non-empty if they are strings.\n */\nexport type SnapFiles = {\n  manifest: VirtualFile<SnapManifest>;\n  packageJson: VirtualFile<NpmSnapPackageJson>;\n  sourceCode: VirtualFile;\n  svgIcon?: VirtualFile;\n};\n\n/**\n * The possible prefixes for snap ids.\n */\n/* eslint-disable @typescript-eslint/naming-convention */\nexport enum SnapIdPrefixes {\n  npm = 'npm:',\n  local = 'local:',\n}\n/* eslint-enable @typescript-eslint/naming-convention */\n\nexport type SnapId = string;\n\n/**\n * Snap validation failure reason codes that are programmatically fixable\n * if validation occurs during development.\n */\nexport enum SnapValidationFailureReason {\n  NameMismatch = '\"name\" field mismatch',\n  VersionMismatch = '\"version\" field mismatch',\n  RepositoryMismatch = '\"repository\" field mismatch',\n  ShasumMismatch = '\"shasum\" field mismatch',\n}\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport enum SNAP_STREAM_NAMES {\n  JSON_RPC = 'jsonRpc',\n  COMMAND = 'command',\n}\n/* eslint-enable @typescript-eslint/naming-convention */\n\nexport enum HandlerType {\n  OnRpcRequest = 'onRpcRequest',\n  OnTransaction = 'onTransaction',\n  OnCronjob = 'onCronjob',\n}\n\nexport const SNAP_EXPORT_NAMES = Object.values(HandlerType);\n\nexport type SnapRpcHookArgs = {\n  origin: string;\n  handler: HandlerType;\n  request: Record<string, unknown>;\n};\n\n// The snap is the callee\nexport type SnapRpcHook = (options: SnapRpcHookArgs) => Promise<unknown>;\n\ntype ObjectParameters<\n  Type extends Record<string, (...args: any[]) => unknown>,\n> = Parameters<Type[keyof Type]>;\n\nexport type SnapExportsParameters = ObjectParameters<SnapFunctionExports>;\n\ntype UriOptions<T extends string> = {\n  protocol?: Struct<T>;\n  hash?: Struct<T>;\n  port?: Struct<T>;\n  hostname?: Struct<T>;\n  pathname?: Struct<T>;\n  search?: Struct<T>;\n};\nexport const uri = (opts: UriOptions<any> = {}) =>\n  refine(union([string(), instance(URL)]), 'uri', (value) => {\n    try {\n      const url = new URL(value);\n\n      const UrlStruct = type(opts);\n      assertSuperstruct(url, UrlStruct);\n      return true;\n    } catch {\n      return `Expected URL, got \"${value.toString()}\".`;\n    }\n  });\n\n/**\n * Returns whether a given value is a valid URL.\n *\n * @param url - The value to check.\n * @param opts - Optional constraints for url checking.\n * @returns Whether `url` is valid URL or not.\n */\nexport function isValidUrl(\n  url: unknown,\n  opts: UriOptions<any> = {},\n): url is string | URL {\n  return is(url, uri(opts));\n}\n\n// redefining here to avoid circular dependency\nexport const WALLET_SNAP_PERMISSION_KEY = 'wallet_snap';\n\nexport type SnapsPermissionRequest = {\n  [WALLET_SNAP_PERMISSION_KEY]: {\n    caveats: [\n      {\n        type: SnapCaveatType.SnapIds;\n        value: Record<string, Json>;\n      },\n    ];\n  };\n};\n"],"names":["NameStruct","NpmSnapPackageJsonStruct","isNpmSnapPackageJson","assertIsNpmSnapPackageJson","SNAP_EXPORT_NAMES","uri","isValidUrl","WALLET_SNAP_PERMISSION_KEY","NpmSnapFileNames","PackageJson","Manifest","size","pattern","string","type","version","VersionStruct","name","main","optional","Infinity","repository","object","url","value","is","assertStruct","SnapIdPrefixes","npm","local","SnapValidationFailureReason","NameMismatch","VersionMismatch","RepositoryMismatch","ShasumMismatch","SNAP_STREAM_NAMES","JSON_RPC","COMMAND","HandlerType","OnRpcRequest","OnTransaction","OnCronjob","Object","values","opts","refine","union","instance","URL","UrlStruct","assertSuperstruct","toString"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;IA2BaA,UAAU;eAAVA;;IAWAC,wBAAwB;eAAxBA;;IAqBGC,oBAAoB;eAApBA;;IAYAC,0BAA0B;eAA1BA;;IAmEHC,iBAAiB;eAAjBA;;IAyBAC,GAAG;eAAHA;;IAoBGC,UAAU;eAAVA;;IAQHC,0BAA0B;eAA1BA;;;uBA/LqC;6BAe3C;IAOA;UAAKC,gBAAgB;IAAhBA,iBACVC,iBAAc;IADJD,iBAEVE,cAAW;GAFDF,qBAAAA;AAKL,MAAMR,aAAaW,IAAAA,iBAAI,EAC5BC,IAAAA,oBAAO,EACLC,IAAAA,mBAAM,KACN,gEAEF,GACA;AAKK,MAAMZ,2BAA2Ba,IAAAA,iBAAI,EAAC;IAC3CC,SAASC,oBAAa;IACtBC,MAAMjB;IACNkB,MAAMC,IAAAA,qBAAQ,EAACR,IAAAA,iBAAI,EAACE,IAAAA,mBAAM,KAAI,GAAGO;IACjCC,YAAYF,IAAAA,qBAAQ,EAClBG,IAAAA,mBAAM,EAAC;QACLR,MAAMH,IAAAA,iBAAI,EAACE,IAAAA,mBAAM,KAAI,GAAGO;QACxBG,KAAKZ,IAAAA,iBAAI,EAACE,IAAAA,mBAAM,KAAI,GAAGO;IACzB;AAEJ;AAWO,SAASlB,qBACdsB,KAAc;IAEd,OAAOC,IAAAA,eAAE,EAACD,OAAOvB;AACnB;AAQO,SAASE,2BACdqB,KAAc;IAEdE,IAAAA,mBAAY,EACVF,OACAvB,0BACA,CAAC,CAAC,EAAEO,iBAAiBC,WAAW,CAAC,YAAY,CAAC;AAElD;IA2BO;UAAKkB,cAAc;IAAdA,eACVC,SAAM;IADID,eAEVE,WAAQ;GAFEF,mBAAAA;IAYL;UAAKG,2BAA2B;IAA3BA,4BACVC,kBAAe;IADLD,4BAEVE,qBAAkB;IAFRF,4BAGVG,wBAAqB;IAHXH,4BAIVI,oBAAiB;GAJPJ,gCAAAA;IAQL;UAAKK,iBAAiB;IAAjBA,kBACVC,cAAW;IADDD,kBAEVE,aAAU;GAFAF,sBAAAA;IAML;UAAKG,WAAW;IAAXA,YACVC,kBAAe;IADLD,YAEVE,mBAAgB;IAFNF,YAGVG,eAAY;GAHFH,gBAAAA;AAML,MAAMlC,oBAAoBsC,OAAOC,MAAM,CAACL;AAyBxC,MAAMjC,MAAM,CAACuC,OAAwB,CAAC,CAAC,GAC5CC,IAAAA,mBAAM,EAACC,IAAAA,kBAAK,EAAC;QAACjC,IAAAA,mBAAM;QAAIkC,IAAAA,qBAAQ,EAACC;KAAK,GAAG,OAAO,CAACxB;QAC/C,IAAI;YACF,MAAMD,MAAM,IAAIyB,IAAIxB;YAEpB,MAAMyB,YAAYnC,IAAAA,iBAAI,EAAC8B;YACvBM,IAAAA,mBAAiB,EAAC3B,KAAK0B;YACvB,OAAO;QACT,EAAE,OAAM;YACN,OAAO,CAAC,mBAAmB,EAAEzB,MAAM2B,QAAQ,GAAG,EAAE,CAAC;QACnD;IACF;AASK,SAAS7C,WACdiB,GAAY,EACZqB,OAAwB,CAAC,CAAC;IAE1B,OAAOnB,IAAAA,eAAE,EAACF,KAAKlB,IAAIuC;AACrB;AAGO,MAAMrC,6BAA6B"}

package/dist/cjs/validation.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "validateFetchedSnap", {
+    enumerable: true,
+    get: function() {
+        return validateFetchedSnap;
+    }
+});
+const _icon = require("./icon");
+const _validation = require("./manifest/validation");
+const _snaps = require("./snaps");
+function validateFetchedSnap(files) {
+    (0, _validation.assertIsSnapManifest)(files.manifest.result);
+    (0, _snaps.validateSnapShasum)(files);
+    if (files.svgIcon) {
+        (0, _icon.assertIsSnapIcon)(files.svgIcon);
+    }
+}
+
+//# sourceMappingURL=validation.js.map

package/dist/cjs/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/validation.ts"],"sourcesContent":["import { assertIsSnapIcon } from './icon';\nimport { assertIsSnapManifest } from './manifest/validation';\nimport { validateSnapShasum } from './snaps';\nimport { SnapFiles } from './types';\n\n/**\n * Validates the files contained in a fetched snap.\n *\n * @param files - All potentially included files in a fetched snap.\n * @throws If any of the files are considered invalid.\n */\nexport function validateFetchedSnap(\n  files: Pick<SnapFiles, 'manifest' | 'sourceCode' | 'svgIcon'>,\n): void {\n  assertIsSnapManifest(files.manifest.result);\n  validateSnapShasum(files);\n\n  if (files.svgIcon) {\n    assertIsSnapIcon(files.svgIcon);\n  }\n}\n"],"names":["validateFetchedSnap","files","assertIsSnapManifest","manifest","result","validateSnapShasum","svgIcon","assertIsSnapIcon"],"mappings":";;;;+BAWgBA;;;eAAAA;;;sBAXiB;4BACI;uBACF;AAS5B,SAASA,oBACdC,KAA6D;IAE7DC,IAAAA,gCAAoB,EAACD,MAAME,QAAQ,CAACC,MAAM;IAC1CC,IAAAA,yBAAkB,EAACJ;IAEnB,IAAIA,MAAMK,OAAO,EAAE;QACjBC,IAAAA,sBAAgB,EAACN,MAAMK,OAAO;IAChC;AACF"}

package/dist/cjs/versions.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DEFAULT_REQUESTED_SNAP_VERSION: function() {
+        return DEFAULT_REQUESTED_SNAP_VERSION;
+    },
+    getTargetVersion: function() {
+        return getTargetVersion;
+    },
+    resolveVersionRange: function() {
+        return resolveVersionRange;
+    }
+});
+const _utils = require("@metamask/utils");
+const _semver = require("semver");
+const _superstruct = require("superstruct");
+const DEFAULT_REQUESTED_SNAP_VERSION = '*';
+function getTargetVersion(versions, versionRange) {
+    const maxSatisfyingNonPreRelease = (0, _semver.maxSatisfying)(versions, versionRange);
+    // By default don't use pre-release versions
+    if (maxSatisfyingNonPreRelease) {
+        return maxSatisfyingNonPreRelease;
+    }
+    // If no satisfying release version is found by default, try pre-release versions
+    return (0, _semver.maxSatisfying)(versions, versionRange, {
+        includePrerelease: true
+    });
+}
+function resolveVersionRange(version) {
+    if (version === undefined || version === 'latest') {
+        return [
+            undefined,
+            DEFAULT_REQUESTED_SNAP_VERSION
+        ];
+    }
+    return (0, _superstruct.validate)(version, _utils.VersionRangeStruct);
+}
+
+//# sourceMappingURL=versions.js.map

package/dist/cjs/versions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/versions.ts"],"sourcesContent":["import {\n  Json,\n  SemVerVersion,\n  SemVerRange,\n  VersionRangeStruct,\n} from '@metamask/utils';\nimport { maxSatisfying as maxSatisfyingSemver } from 'semver';\nimport { validate } from 'superstruct';\n\nexport const DEFAULT_REQUESTED_SNAP_VERSION = '*' as SemVerRange;\n\n/**\n * Return the highest version in the list that satisfies the range, or `null` if\n * none of them do. For the satisfaction check, pre-release versions will only\n * be checked if no satisfactory non-prerelease version is found first.\n *\n * @param versions - The list of version to check.\n * @param versionRange - The SemVer version range to check against.\n * @returns The highest version in the list that satisfies the range,\n * or `null` if none of them do.\n */\nexport function getTargetVersion(\n  versions: SemVerVersion[],\n  versionRange: SemVerRange,\n): SemVerVersion | null {\n  const maxSatisfyingNonPreRelease = maxSatisfyingSemver(\n    versions,\n    versionRange,\n  );\n\n  // By default don't use pre-release versions\n  if (maxSatisfyingNonPreRelease) {\n    return maxSatisfyingNonPreRelease;\n  }\n\n  // If no satisfying release version is found by default, try pre-release versions\n  return maxSatisfyingSemver(versions, versionRange, {\n    includePrerelease: true,\n  });\n}\n\n/**\n * Parse a version received by some subject attempting to access a snap.\n *\n * @param version - The received version value.\n * @returns `*` if the version is `undefined` or `latest\", otherwise returns\n * the specified version.\n */\nexport function resolveVersionRange(\n  version?: Json,\n): [error: undefined, range: SemVerRange] | [error: Error, range: undefined] {\n  if (version === undefined || version === 'latest') {\n    return [undefined, DEFAULT_REQUESTED_SNAP_VERSION];\n  }\n  return validate(version, VersionRangeStruct);\n}\n"],"names":["DEFAULT_REQUESTED_SNAP_VERSION","getTargetVersion","resolveVersionRange","versions","versionRange","maxSatisfyingNonPreRelease","maxSatisfyingSemver","includePrerelease","version","undefined","validate","VersionRangeStruct"],"mappings":";;;;;;;;;;;IASaA,8BAA8B;eAA9BA;;IAYGC,gBAAgB;eAAhBA;;IA2BAC,mBAAmB;eAAnBA;;;uBA3CT;wBAC8C;6BAC5B;AAElB,MAAMF,iCAAiC;AAYvC,SAASC,iBACdE,QAAyB,EACzBC,YAAyB;IAEzB,MAAMC,6BAA6BC,IAAAA,qBAAmB,EACpDH,UACAC;IAGF,4CAA4C;IAC5C,IAAIC,4BAA4B;QAC9B,OAAOA;IACT;IAEA,iFAAiF;IACjF,OAAOC,IAAAA,qBAAmB,EAACH,UAAUC,cAAc;QACjDG,mBAAmB;IACrB;AACF;AASO,SAASL,oBACdM,OAAc;IAEd,IAAIA,YAAYC,aAAaD,YAAY,UAAU;QACjD,OAAO;YAACC;YAAWT;SAA+B;IACpD;IACA,OAAOU,IAAAA,qBAAQ,EAACF,SAASG,yBAAkB;AAC7C"}

package/dist/cjs/virtual-file/VirtualFile.js

@@ -0,0 +1,85 @@
+// TODO(ritave): Move into separate package @metamask/vfile / @metamask/utils + @metamask/to-vfile when passes code review
+// TODO(ritave): Streaming vfile contents similar to vinyl maybe?
+// TODO(ritave): Move fixing manifest in cli and bundler plugins to write messages to vfile
+//               similar to unified instead of throwing "ProgrammaticallyFixableErrors".
+//
+// Using https://github.com/vfile/vfile would be helpful, but they only support ESM and we need to support CommonJS.
+// https://github.com/gulpjs/vinyl is also good, but they normalize paths, which we can't do, because
+// we're calculating checksums based on original path.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VirtualFile", {
+    enumerable: true,
+    get: function() {
+        return VirtualFile;
+    }
+});
+const _utils = require("@metamask/utils");
+const _deepclone = require("../deep-clone");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class VirtualFile {
+    toString(encoding) {
+        if (typeof this.value === 'string') {
+            (0, _utils.assert)(encoding === undefined, 'Tried to encode string.');
+            return this.value;
+        }
+        const decoder = new TextDecoder(encoding);
+        return decoder.decode(this.value);
+    }
+    clone() {
+        const vfile = new VirtualFile();
+        if (typeof this.value === 'string') {
+            vfile.value = this.value;
+        } else {
+            // deep-clone doesn't clone Buffer properly, even if it's a sub-class of Uint8Array
+            vfile.value = this.value.slice(0);
+        }
+        vfile.result = (0, _deepclone.deepClone)(this.result);
+        vfile.data = (0, _deepclone.deepClone)(this.data);
+        vfile.path = this.path;
+        return vfile;
+    }
+    constructor(value){
+        _define_property(this, "value", void 0);
+        _define_property(this, "result", void 0);
+        _define_property(this, "data", void 0);
+        _define_property(this, "path", void 0);
+        let options;
+        if (typeof value === 'string' || value instanceof Uint8Array) {
+            options = {
+                value
+            };
+        } else {
+            options = value;
+        }
+        this.value = options?.value ?? '';
+        // This situations happens when there's no .result used,
+        // we expect the file to have default generic in that situation:
+        // VirtualFile<unknown> which will handle undefined properly
+        //
+        // While not 100% type safe, it'll be way less frustrating to work with.
+        // The alternative would be to have VirtualFile.result be Result | undefined
+        // and that would result in needing to branch out and check in all situations.
+        //
+        // In short, optimizing for most common use case.
+        this.result = options?.result ?? undefined;
+        this.data = options?.data ?? {};
+        this.path = options?.path ?? '/';
+    }
+}
+
+//# sourceMappingURL=VirtualFile.js.map

package/dist/cjs/virtual-file/VirtualFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/virtual-file/VirtualFile.ts"],"sourcesContent":["// TODO(ritave): Move into separate package @metamask/vfile / @metamask/utils + @metamask/to-vfile when passes code review\n// TODO(ritave): Streaming vfile contents similar to vinyl maybe?\n// TODO(ritave): Move fixing manifest in cli and bundler plugins to write messages to vfile\n//               similar to unified instead of throwing \"ProgrammaticallyFixableErrors\".\n//\n// Using https://github.com/vfile/vfile would be helpful, but they only support ESM and we need to support CommonJS.\n// https://github.com/gulpjs/vinyl is also good, but they normalize paths, which we can't do, because\n// we're calculating checksums based on original path.\nimport { assert } from '@metamask/utils';\n\nimport { deepClone } from '../deep-clone';\n\n/**\n * This map registers the type of the {@link VirtualFile.data} key of a {@link VirtualFile}.\n *\n * This type can be augmented to register custom `data` types.\n *\n * @example\n * declare module '@metamask/snaps-utils' {\n *   interface DataMap {\n *     // `file.data.name` is typed as `string`\n *     name: string\n *   }\n * }\n */\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions, @typescript-eslint/no-empty-interface\nexport interface DataMap {}\n\nexport type Value = string | Uint8Array;\nexport type Compatible<Result = unknown> =\n  | string\n  | Uint8Array\n  | Options<Result>;\nexport type Data = Record<string, unknown> & Partial<DataMap>;\nexport type Options<Result = unknown> = {\n  value: Value;\n  path?: string;\n  data?: Data;\n  result?: Result;\n};\n\nexport class VirtualFile<Result = unknown> {\n  constructor(value?: Compatible<Result>) {\n    let options: Options | undefined;\n    if (typeof value === 'string' || value instanceof Uint8Array) {\n      options = { value };\n    } else {\n      options = value;\n    }\n\n    this.value = options?.value ?? '';\n    // This situations happens when there's no .result used,\n    // we expect the file to have default generic in that situation:\n    // VirtualFile<unknown> which will handle undefined properly\n    //\n    // While not 100% type safe, it'll be way less frustrating to work with.\n    // The alternative would be to have VirtualFile.result be Result | undefined\n    // and that would result in needing to branch out and check in all situations.\n    //\n    // In short, optimizing for most common use case.\n    this.result = options?.result ?? (undefined as any);\n    this.data = options?.data ?? {};\n    this.path = options?.path ?? '/';\n  }\n\n  value: Value;\n\n  result: Result;\n\n  data: Data;\n\n  path: string;\n\n  toString(encoding?: string) {\n    if (typeof this.value === 'string') {\n      assert(encoding === undefined, 'Tried to encode string.');\n      return this.value;\n    }\n    const decoder = new TextDecoder(encoding);\n    return decoder.decode(this.value);\n  }\n\n  clone() {\n    const vfile = new VirtualFile<Result>();\n    if (typeof this.value === 'string') {\n      vfile.value = this.value;\n    } else {\n      // deep-clone doesn't clone Buffer properly, even if it's a sub-class of Uint8Array\n      vfile.value = this.value.slice(0);\n    }\n    vfile.result = deepClone(this.result);\n    vfile.data = deepClone(this.data);\n    vfile.path = this.path;\n    return vfile;\n  }\n}\n"],"names":["VirtualFile","toString","encoding","value","assert","undefined","decoder","TextDecoder","decode","clone","vfile","slice","result","deepClone","data","path","constructor","options","Uint8Array"],"mappings":"AAAA,0HAA0H;AAC1H,iEAAiE;AACjE,2FAA2F;AAC3F,wFAAwF;AACxF,EAAE;AACF,oHAAoH;AACpH,qGAAqG;AACrG,sDAAsD;;;;;+BAkCzCA;;;eAAAA;;;uBAjCU;2BAEG;;;;;;;;;;;;;;AA+BnB,MAAMA;IAgCXC,SAASC,QAAiB,EAAE;QAC1B,IAAI,OAAO,IAAI,CAACC,KAAK,KAAK,UAAU;YAClCC,IAAAA,aAAM,EAACF,aAAaG,WAAW;YAC/B,OAAO,IAAI,CAACF,KAAK;QACnB;QACA,MAAMG,UAAU,IAAIC,YAAYL;QAChC,OAAOI,QAAQE,MAAM,CAAC,IAAI,CAACL,KAAK;IAClC;IAEAM,QAAQ;QACN,MAAMC,QAAQ,IAAIV;QAClB,IAAI,OAAO,IAAI,CAACG,KAAK,KAAK,UAAU;YAClCO,MAAMP,KAAK,GAAG,IAAI,CAACA,KAAK;QAC1B,OAAO;YACL,mFAAmF;YACnFO,MAAMP,KAAK,GAAG,IAAI,CAACA,KAAK,CAACQ,KAAK,CAAC;QACjC;QACAD,MAAME,MAAM,GAAGC,IAAAA,oBAAS,EAAC,IAAI,CAACD,MAAM;QACpCF,MAAMI,IAAI,GAAGD,IAAAA,oBAAS,EAAC,IAAI,CAACC,IAAI;QAChCJ,MAAMK,IAAI,GAAG,IAAI,CAACA,IAAI;QACtB,OAAOL;IACT;IApDAM,YAAYb,KAA0B,CAAE;QAuBxCA,uBAAAA,SAAAA,KAAAA;QAEAS,uBAAAA,UAAAA,KAAAA;QAEAE,uBAAAA,QAAAA,KAAAA;QAEAC,uBAAAA,QAAAA,KAAAA;QA5BE,IAAIE;QACJ,IAAI,OAAOd,UAAU,YAAYA,iBAAiBe,YAAY;YAC5DD,UAAU;gBAAEd;YAAM;QACpB,OAAO;YACLc,UAAUd;QACZ;QAEA,IAAI,CAACA,KAAK,GAAGc,SAASd,SAAS;QAC/B,wDAAwD;QACxD,gEAAgE;QAChE,4DAA4D;QAC5D,EAAE;QACF,wEAAwE;QACxE,4EAA4E;QAC5E,8EAA8E;QAC9E,EAAE;QACF,iDAAiD;QACjD,IAAI,CAACS,MAAM,GAAGK,SAASL,UAAWP;QAClC,IAAI,CAACS,IAAI,GAAGG,SAASH,QAAQ,CAAC;QAC9B,IAAI,CAACC,IAAI,GAAGE,SAASF,QAAQ;IAC/B;AAgCF"}

package/dist/cjs/virtual-file/index.browser.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./VirtualFile"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.browser.js.map

package/dist/cjs/virtual-file/index.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/virtual-file/index.browser.ts"],"sourcesContent":["export * from './VirtualFile';\n"],"names":[],"mappings":";;;;qBAAc"}

package/dist/cjs/virtual-file/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./toVirtualFile"), exports);
+_export_star(require("./VirtualFile"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/virtual-file/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/virtual-file/index.ts"],"sourcesContent":["export * from './toVirtualFile';\nexport * from './VirtualFile';\n"],"names":[],"mappings":";;;;qBAAc;qBACA"}

package/dist/cjs/virtual-file/toVirtualFile.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    readVirtualFile: function() {
+        return readVirtualFile;
+    },
+    writeVirtualFile: function() {
+        return writeVirtualFile;
+    }
+});
+const _fs = require("fs");
+const _VirtualFile = require("./VirtualFile");
+async function readVirtualFile(path, encoding = null) {
+    return new _VirtualFile.VirtualFile({
+        path,
+        value: await _fs.promises.readFile(path, {
+            encoding
+        })
+    });
+}
+async function writeVirtualFile(vfile, options) {
+    return _fs.promises.writeFile(vfile.path, vfile.value, options);
+}
+
+//# sourceMappingURL=toVirtualFile.js.map

package/dist/cjs/virtual-file/toVirtualFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/virtual-file/toVirtualFile.ts"],"sourcesContent":["import { promises as fsPromises } from 'fs';\n\nimport { VirtualFile } from './VirtualFile';\n\n/**\n * Reads a file from filesystem and creates a vfile.\n *\n * @param path - Filesystem path to load the contents from.\n * @param encoding - Optional encoding to pass down to fs.readFile.\n * @returns Promise returning VFile with loaded file contents.\n */\nexport async function readVirtualFile(\n  path: string,\n  encoding: BufferEncoding | null = null,\n) {\n  return new VirtualFile({\n    path,\n    value: await fsPromises.readFile(path, { encoding }),\n  });\n}\n\ntype WriteVFileOptions = Exclude<\n  Parameters<typeof fsPromises['writeFile']>[2],\n  undefined\n>;\n\n/**\n * Writes vfile to filesystem.\n *\n * @param vfile - The vfile to write.\n * @param options - Options to pass down to fs.writeFile.\n */\nexport async function writeVirtualFile(\n  vfile: VirtualFile,\n  options?: WriteVFileOptions,\n) {\n  return fsPromises.writeFile(vfile.path, vfile.value, options);\n}\n"],"names":["readVirtualFile","writeVirtualFile","path","encoding","VirtualFile","value","fsPromises","readFile","vfile","options","writeFile"],"mappings":";;;;;;;;;;;IAWsBA,eAAe;eAAfA;;IAqBAC,gBAAgB;eAAhBA;;;oBAhCiB;6BAEX;AASrB,eAAeD,gBACpBE,IAAY,EACZC,WAAkC,IAAI;IAEtC,OAAO,IAAIC,wBAAW,CAAC;QACrBF;QACAG,OAAO,MAAMC,YAAU,CAACC,QAAQ,CAACL,MAAM;YAAEC;QAAS;IACpD;AACF;AAaO,eAAeF,iBACpBO,KAAkB,EAClBC,OAA2B;IAE3B,OAAOH,YAAU,CAACI,SAAS,CAACF,MAAMN,IAAI,EAAEM,MAAMH,KAAK,EAAEI;AACvD"}

package/dist/esm/array.js

@@ -0,0 +1,13 @@
+/**
+ * Checks if array `a` is equal to array `b`. Note that this does not do a deep
+ * equality check. It only checks if the arrays are the same length and if each
+ * element in `a` is equal to (`===`) the corresponding element in `b`.
+ *
+ * @param a - The first array to compare.
+ * @param b - The second array to compare.
+ * @returns `true` if the arrays are equal, `false` otherwise.
+ */ export function isEqual(a, b) {
+    return a.length === b.length && a.every((value, index)=>value === b[index]);
+}
+
+//# sourceMappingURL=array.js.map

package/dist/esm/array.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array.ts"],"sourcesContent":["/**\n * Checks if array `a` is equal to array `b`. Note that this does not do a deep\n * equality check. It only checks if the arrays are the same length and if each\n * element in `a` is equal to (`===`) the corresponding element in `b`.\n *\n * @param a - The first array to compare.\n * @param b - The second array to compare.\n * @returns `true` if the arrays are equal, `false` otherwise.\n */\nexport function isEqual(a: unknown[], b: unknown[]): boolean {\n  return a.length === b.length && a.every((value, index) => value === b[index]);\n}\n"],"names":["isEqual","a","b","length","every","value","index"],"mappings":"AAAA;;;;;;;;CAQC,GACD,OAAO,SAASA,QAAQC,CAAY,EAAEC,CAAY;IAChD,OAAOD,EAAEE,MAAM,KAAKD,EAAEC,MAAM,IAAIF,EAAEG,KAAK,CAAC,CAACC,OAAOC,QAAUD,UAAUH,CAAC,CAACI,MAAM;AAC9E"}

package/dist/esm/caveats.js

@@ -0,0 +1,23 @@
+export var SnapCaveatType;
+(function(SnapCaveatType) {
+    SnapCaveatType[/**
+   * Permitted derivation paths, used by `snap_getBip32Entropy`.
+   */ "PermittedDerivationPaths"] = 'permittedDerivationPaths';
+    SnapCaveatType[/**
+   * Permitted coin types, used by `snap_getBip44Entropy`.
+   */ "PermittedCoinTypes"] = 'permittedCoinTypes';
+    SnapCaveatType[/**
+   * Caveat specifying a snap cronjob.
+   */ "SnapCronjob"] = 'snapCronjob';
+    SnapCaveatType[/**
+   * Caveat specifying access to the transaction origin, used by `endowment:transaction-insight`.
+   */ "TransactionOrigin"] = 'transactionOrigin';
+    SnapCaveatType[/**
+   * The origins that a Snap can receive JSON-RPC messages from.
+   */ "RpcOrigin"] = 'rpcOrigin';
+    SnapCaveatType[/**
+   * Caveat specifying the snap IDs that can be interacted with.
+   */ "SnapIds"] = 'snapIds';
+})(SnapCaveatType || (SnapCaveatType = {}));
+
+//# sourceMappingURL=caveats.js.map

package/dist/esm/caveats.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/caveats.ts"],"sourcesContent":["export enum SnapCaveatType {\n  /**\n   * Permitted derivation paths, used by `snap_getBip32Entropy`.\n   */\n  PermittedDerivationPaths = 'permittedDerivationPaths',\n\n  /**\n   * Permitted coin types, used by `snap_getBip44Entropy`.\n   */\n  PermittedCoinTypes = 'permittedCoinTypes',\n\n  /**\n   * Caveat specifying a snap cronjob.\n   */\n  SnapCronjob = 'snapCronjob',\n\n  /**\n   * Caveat specifying access to the transaction origin, used by `endowment:transaction-insight`.\n   */\n  TransactionOrigin = 'transactionOrigin',\n\n  /**\n   * The origins that a Snap can receive JSON-RPC messages from.\n   */\n  RpcOrigin = 'rpcOrigin',\n\n  /**\n   * Caveat specifying the snap IDs that can be interacted with.\n   */\n  SnapIds = 'snapIds',\n}\n"],"names":["SnapCaveatType","PermittedDerivationPaths","PermittedCoinTypes","SnapCronjob","TransactionOrigin","RpcOrigin","SnapIds"],"mappings":"WAAO;UAAKA,cAAc;IAAdA,eACV;;GAEC,GACDC,8BAA2B;IAJjBD,eAMV;;GAEC,GACDE,wBAAqB;IATXF,eAWV;;GAEC,GACDG,iBAAc;IAdJH,eAgBV;;GAEC,GACDI,uBAAoB;IAnBVJ,eAqBV;;GAEC,GACDK,eAAY;IAxBFL,eA0BV;;GAEC,GACDM,aAAU;GA7BAN,mBAAAA"}

package/dist/esm/checksum.js

@@ -0,0 +1,36 @@
+import { assert, concatBytes } from '@metamask/utils';
+import { sha256 } from '@noble/hashes/sha256';
+import { VirtualFile } from './virtual-file/VirtualFile';
+/**
+ * Calculates checksum for a single byte array.
+ *
+ * @param bytes - The byte array to calculate the checksum for.
+ * @returns A single sha-256 checksum.
+ */ export function checksum(bytes) {
+    const value = bytes instanceof VirtualFile ? bytes.value : bytes;
+    return sha256(value);
+}
+/**
+ * Calculates checksum over multiple files in a reproducible way.
+ *
+ * 1. Sort all the files by their paths.
+ * 2. Calculate sha-256 checksum of each file separately.
+ * 3. Concatenate all the checksums into one buffer and sha-256 that buffer.
+ *
+ * The sorting of paths is done using {@link https://tc39.es/ecma262/#sec-islessthan UTF-16 Code Units}.
+ *
+ * @param files - The files over which to calculate the checksum.
+ * @returns A single sha-256 checksum.
+ */ export function checksumFiles(files) {
+    return checksum(concatBytes([
+        ...files
+    ].sort((a, b)=>{
+        assert(a.path !== b.path, 'Tried to sort files with non-unique paths.');
+        if (a.path < b.path) {
+            return -1;
+        }
+        return 1;
+    }).map((file)=>checksum(file))));
+}
+
+//# sourceMappingURL=checksum.js.map

package/dist/esm/checksum.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/checksum.ts"],"sourcesContent":["import { assert, concatBytes } from '@metamask/utils';\nimport { sha256 } from '@noble/hashes/sha256';\n\nimport { VirtualFile } from './virtual-file/VirtualFile';\n\n/**\n * Calculates checksum for a single byte array.\n *\n * @param bytes - The byte array to calculate the checksum for.\n * @returns A single sha-256 checksum.\n */\nexport function checksum(bytes: VirtualFile | Uint8Array | string): Uint8Array {\n  const value = bytes instanceof VirtualFile ? bytes.value : bytes;\n  return sha256(value);\n}\n\n/**\n * Calculates checksum over multiple files in a reproducible way.\n *\n * 1. Sort all the files by their paths.\n * 2. Calculate sha-256 checksum of each file separately.\n * 3. Concatenate all the checksums into one buffer and sha-256 that buffer.\n *\n * The sorting of paths is done using {@link https://tc39.es/ecma262/#sec-islessthan UTF-16 Code Units}.\n *\n * @param files - The files over which to calculate the checksum.\n * @returns A single sha-256 checksum.\n */\nexport function checksumFiles(files: VirtualFile[]) {\n  return checksum(\n    concatBytes(\n      [...files]\n        .sort((a, b) => {\n          assert(\n            a.path !== b.path,\n            'Tried to sort files with non-unique paths.',\n          );\n          if (a.path < b.path) {\n            return -1;\n          }\n          return 1;\n        })\n        .map((file) => checksum(file)),\n    ),\n  );\n}\n"],"names":["assert","concatBytes","sha256","VirtualFile","checksum","bytes","value","checksumFiles","files","sort","a","b","path","map","file"],"mappings":"AAAA,SAASA,MAAM,EAAEC,WAAW,QAAQ,kBAAkB;AACtD,SAASC,MAAM,QAAQ,uBAAuB;AAE9C,SAASC,WAAW,QAAQ,6BAA6B;AAEzD;;;;;CAKC,GACD,OAAO,SAASC,SAASC,KAAwC;IAC/D,MAAMC,QAAQD,iBAAiBF,cAAcE,MAAMC,KAAK,GAAGD;IAC3D,OAAOH,OAAOI;AAChB;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,SAASC,cAAcC,KAAoB;IAChD,OAAOJ,SACLH,YACE;WAAIO;KAAM,CACPC,IAAI,CAAC,CAACC,GAAGC;QACRX,OACEU,EAAEE,IAAI,KAAKD,EAAEC,IAAI,EACjB;QAEF,IAAIF,EAAEE,IAAI,GAAGD,EAAEC,IAAI,EAAE;YACnB,OAAO,CAAC;QACV;QACA,OAAO;IACT,GACCC,GAAG,CAAC,CAACC,OAASV,SAASU;AAGhC"}

package/dist/esm/cronjob.js

@@ -0,0 +1,66 @@
+import { JsonRpcRequestStruct } from '@metamask/utils';
+import { parseExpression } from 'cron-parser';
+import { array, assign, coerce, create, object, omit, optional, partial, pick, refine, string } from 'superstruct';
+export const CronjobRpcRequestStruct = assign(partial(pick(JsonRpcRequestStruct, [
+    'id',
+    'jsonrpc'
+])), omit(JsonRpcRequestStruct, [
+    'id',
+    'jsonrpc'
+]));
+export const CronExpressionStruct = refine(coerce(string(), object({
+    minute: optional(string()),
+    hour: optional(string()),
+    dayOfMonth: optional(string()),
+    month: optional(string()),
+    dayOfWeek: optional(string())
+}), (value)=>`${value.minute ?? '*'} ${value.hour ?? '*'} ${value.dayOfMonth ?? '*'} ${value.month ?? '*'} ${value.dayOfWeek ?? '*'}`), 'CronExpression', (value)=>{
+    try {
+        parseExpression(value);
+        return true;
+    } catch  {
+        return false;
+    }
+});
+/**
+ * Parses a cron expression.
+ *
+ * @param expression - Expression to parse.
+ * @returns A CronExpression class instance.
+ */ export function parseCronExpression(expression) {
+    const ensureStringExpression = create(expression, CronExpressionStruct);
+    return parseExpression(ensureStringExpression);
+}
+export const CronjobSpecificationStruct = object({
+    expression: CronExpressionStruct,
+    request: CronjobRpcRequestStruct
+});
+/**
+ * Check if the given value is a {@link CronjobSpecification} object.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a valid {@link CronjobSpecification} object.
+ */ export function isCronjobSpecification(value) {
+    try {
+        create(value, CronjobSpecificationStruct);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+export const CronjobSpecificationArrayStruct = array(CronjobSpecificationStruct);
+/**
+ * Check if the given value is an array of {@link CronjobSpecification} objects.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a valid array of {@link CronjobSpecification} objects.
+ */ export function isCronjobSpecificationArray(value) {
+    try {
+        create(value, CronjobSpecificationArrayStruct);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=cronjob.js.map

package/dist/esm/cronjob.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cronjob.ts"],"sourcesContent":["import { JsonRpcRequestStruct } from '@metamask/utils';\nimport { parseExpression } from 'cron-parser';\nimport {\n  array,\n  assign,\n  coerce,\n  create,\n  Infer,\n  object,\n  omit,\n  optional,\n  partial,\n  pick,\n  refine,\n  string,\n} from 'superstruct';\n\nexport const CronjobRpcRequestStruct = assign(\n  partial(pick(JsonRpcRequestStruct, ['id', 'jsonrpc'])),\n  omit(JsonRpcRequestStruct, ['id', 'jsonrpc']),\n);\nexport type CronjobRpcRequest = Infer<typeof CronjobRpcRequestStruct>;\n\nexport const CronExpressionStruct = refine(\n  coerce(\n    string(),\n    object({\n      minute: optional(string()),\n      hour: optional(string()),\n      dayOfMonth: optional(string()),\n      month: optional(string()),\n      dayOfWeek: optional(string()),\n    }),\n    (value) =>\n      `${value.minute ?? '*'} ${value.hour ?? '*'} ${value.dayOfMonth ?? '*'} ${\n        value.month ?? '*'\n      } ${value.dayOfWeek ?? '*'}`,\n  ),\n  'CronExpression',\n  (value) => {\n    try {\n      parseExpression(value);\n      return true;\n    } catch {\n      return false;\n    }\n  },\n);\n\nexport type CronExpression = Infer<typeof CronExpressionStruct>;\n\n/**\n * Parses a cron expression.\n *\n * @param expression - Expression to parse.\n * @returns A CronExpression class instance.\n */\nexport function parseCronExpression(expression: string | object) {\n  const ensureStringExpression = create(expression, CronExpressionStruct);\n  return parseExpression(ensureStringExpression);\n}\n\nexport const CronjobSpecificationStruct = object({\n  expression: CronExpressionStruct,\n  request: CronjobRpcRequestStruct,\n});\nexport type CronjobSpecification = Infer<typeof CronjobSpecificationStruct>;\n\n/**\n * Check if the given value is a {@link CronjobSpecification} object.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid {@link CronjobSpecification} object.\n */\nexport function isCronjobSpecification(value: unknown): boolean {\n  try {\n    create(value, CronjobSpecificationStruct);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nexport const CronjobSpecificationArrayStruct = array(\n  CronjobSpecificationStruct,\n);\n\n/**\n * Check if the given value is an array of {@link CronjobSpecification} objects.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid array of {@link CronjobSpecification} objects.\n */\nexport function isCronjobSpecificationArray(value: unknown): boolean {\n  try {\n    create(value, CronjobSpecificationArrayStruct);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"names":["JsonRpcRequestStruct","parseExpression","array","assign","coerce","create","object","omit","optional","partial","pick","refine","string","CronjobRpcRequestStruct","CronExpressionStruct","minute","hour","dayOfMonth","month","dayOfWeek","value","parseCronExpression","expression","ensureStringExpression","CronjobSpecificationStruct","request","isCronjobSpecification","CronjobSpecificationArrayStruct","isCronjobSpecificationArray"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,kBAAkB;AACvD,SAASC,eAAe,QAAQ,cAAc;AAC9C,SACEC,KAAK,EACLC,MAAM,EACNC,MAAM,EACNC,MAAM,EAENC,MAAM,EACNC,IAAI,EACJC,QAAQ,EACRC,OAAO,EACPC,IAAI,EACJC,MAAM,EACNC,MAAM,QACD,cAAc;AAErB,OAAO,MAAMC,0BAA0BV,OACrCM,QAAQC,KAAKV,sBAAsB;IAAC;IAAM;CAAU,IACpDO,KAAKP,sBAAsB;IAAC;IAAM;CAAU,GAC5C;AAGF,OAAO,MAAMc,uBAAuBH,OAClCP,OACEQ,UACAN,OAAO;IACLS,QAAQP,SAASI;IACjBI,MAAMR,SAASI;IACfK,YAAYT,SAASI;IACrBM,OAAOV,SAASI;IAChBO,WAAWX,SAASI;AACtB,IACA,CAACQ,QACC,CAAC,EAAEA,MAAML,MAAM,IAAI,IAAI,CAAC,EAAEK,MAAMJ,IAAI,IAAI,IAAI,CAAC,EAAEI,MAAMH,UAAU,IAAI,IAAI,CAAC,EACtEG,MAAMF,KAAK,IAAI,IAChB,CAAC,EAAEE,MAAMD,SAAS,IAAI,IAAI,CAAC,GAEhC,kBACA,CAACC;IACC,IAAI;QACFnB,gBAAgBmB;QAChB,OAAO;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF,GACA;AAIF;;;;;CAKC,GACD,OAAO,SAASC,oBAAoBC,UAA2B;IAC7D,MAAMC,yBAAyBlB,OAAOiB,YAAYR;IAClD,OAAOb,gBAAgBsB;AACzB;AAEA,OAAO,MAAMC,6BAA6BlB,OAAO;IAC/CgB,YAAYR;IACZW,SAASZ;AACX,GAAG;AAGH;;;;;CAKC,GACD,OAAO,SAASa,uBAAuBN,KAAc;IACnD,IAAI;QACFf,OAAOe,OAAOI;QACd,OAAO;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF;AAEA,OAAO,MAAMG,kCAAkCzB,MAC7CsB,4BACA;AAEF;;;;;CAKC,GACD,OAAO,SAASI,4BAA4BR,KAAc;IACxD,IAAI;QACFf,OAAOe,OAAOO;QACd,OAAO;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF"}

package/dist/esm/deep-clone.js

@@ -0,0 +1,7 @@
+import rfdc from 'rfdc';
+export const deepClone = rfdc({
+    proto: false,
+    circles: false
+});
+
+//# sourceMappingURL=deep-clone.js.map