@metamask/snaps-controllers 1.0.2 → 2.0.0

package/dist/cjs/snaps/location/npm.js

@@ -0,0 +1,293 @@
+"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_NPM_REGISTRY: function() {
+        return DEFAULT_NPM_REGISTRY;
+    },
+    NpmLocation: function() {
+        return NpmLocation;
+    },
+    fetchNpmMetadata: function() {
+        return fetchNpmMetadata;
+    }
+});
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+const _concatstream = /*#__PURE__*/ _interop_require_default(require("concat-stream"));
+const _gunzipmaybe = /*#__PURE__*/ _interop_require_default(require("gunzip-maybe"));
+const _readablewebtonodestream = require("readable-web-to-node-stream");
+const _stream = require("stream");
+const _tarstream = require("tar-stream");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+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;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const DEFAULT_NPM_REGISTRY = 'https://registry.npmjs.org';
+var _lazyInit = /*#__PURE__*/ new WeakSet();
+class NpmLocation {
+    async manifest() {
+        if (this.validatedManifest) {
+            return this.validatedManifest.clone();
+        }
+        const vfile = await this.fetch('snap.manifest.json');
+        const result = (0, _snapsutils.parseJson)(vfile.toString());
+        vfile.result = (0, _snapsutils.createSnapManifest)(result);
+        this.validatedManifest = vfile;
+        return this.manifest();
+    }
+    async fetch(path) {
+        const relativePath = (0, _snapsutils.normalizeRelative)(path);
+        if (!this.files) {
+            await _class_private_method_get(this, _lazyInit, lazyInit).call(this);
+            (0, _utils.assert)(this.files !== undefined);
+        }
+        const vfile = this.files.get(relativePath);
+        (0, _utils.assert)(vfile !== undefined, new TypeError(`File "${path}" not found in package.`));
+        return vfile.clone();
+    }
+    get packageName() {
+        return this.meta.packageName;
+    }
+    get version() {
+        (0, _utils.assert)(this.meta.version !== undefined, 'Tried to access version without first fetching NPM package.');
+        return this.meta.version;
+    }
+    get registry() {
+        return this.meta.registry;
+    }
+    get versionRange() {
+        return this.meta.requestedRange;
+    }
+    constructor(url, opts = {}){
+        _class_private_method_init(this, _lazyInit);
+        _define_property(this, "meta", void 0);
+        _define_property(this, "validatedManifest", void 0);
+        _define_property(this, "files", void 0);
+        const allowCustomRegistries = opts.allowCustomRegistries ?? false;
+        const fetchFunction = opts.fetch ?? globalThis.fetch.bind(globalThis);
+        const requestedRange = opts.versionRange ?? _snapsutils.DEFAULT_REQUESTED_SNAP_VERSION;
+        (0, _utils.assertStruct)(url.toString(), _snapsutils.NpmSnapIdStruct, 'Invalid Snap Id: ');
+        let registry;
+        if (url.host === '' && url.port === '' && url.username === '' && url.password === '') {
+            registry = new URL(DEFAULT_NPM_REGISTRY);
+        } else {
+            registry = 'https://';
+            if (url.username) {
+                registry += url.username;
+                if (url.password) {
+                    registry += `:${url.password}`;
+                }
+                registry += '@';
+            }
+            registry += url.host;
+            registry = new URL(registry);
+            (0, _utils.assert)(allowCustomRegistries, new TypeError(`Custom NPM registries are disabled, tried to use "${registry.toString()}".`));
+        }
+        (0, _utils.assert)(registry.pathname === '/' && registry.search === '' && registry.hash === '');
+        (0, _utils.assert)(url.pathname !== '' && url.pathname !== '/', new TypeError('The package name in NPM location is empty.'));
+        let packageName = url.pathname;
+        if (packageName.startsWith('/')) {
+            packageName = packageName.slice(1);
+        }
+        this.meta = {
+            requestedRange,
+            registry,
+            packageName,
+            fetch: fetchFunction
+        };
+    }
+}
+async function lazyInit() {
+    (0, _utils.assert)(this.files === undefined);
+    const [tarballResponse, actualVersion] = await fetchNpmTarball(this.meta.packageName, this.meta.requestedRange, this.meta.registry, this.meta.fetch);
+    this.meta.version = actualVersion;
+    let canonicalBase = 'npm://';
+    if (this.meta.registry.username !== '') {
+        canonicalBase += this.meta.registry.username;
+        if (this.meta.registry.password !== '') {
+            canonicalBase += `:${this.meta.registry.password}`;
+        }
+        canonicalBase += '@';
+    }
+    canonicalBase += this.meta.registry.host;
+    // TODO(ritave): Lazily extract files instead of up-front extracting all of them
+    //               We would need to replace tar-stream package because it requires immediate consumption of streams.
+    await new Promise((resolve, reject)=>{
+        this.files = new Map();
+        (0, _stream.pipeline)(getNodeStream(tarballResponse), // The "gz" in "tgz" stands for "gzip". The tarball needs to be decompressed
+        // before we can actually grab any files from it.
+        // To prevent recursion-based zip bombs, we set a maximum recursion depth of 1.
+        (0, _gunzipmaybe.default)(1), createTarballStream(`${canonicalBase}/${this.meta.packageName}/`, this.files), (error)=>{
+            error ? reject(error) : resolve();
+        });
+    });
+}
+// Safety limit for tarballs, 250 MB in bytes
+const TARBALL_SIZE_SAFETY_LIMIT = 262144000;
+async function fetchNpmMetadata(packageName, registryUrl, fetchFunction) {
+    const packageResponse = await fetchFunction(new URL(packageName, registryUrl).toString());
+    if (!packageResponse.ok) {
+        throw new Error(`Failed to fetch NPM registry entry. Status code: ${packageResponse.status}.`);
+    }
+    const packageMetadata = await packageResponse.json();
+    if (!(0, _utils.isObject)(packageMetadata)) {
+        throw new Error(`Failed to fetch package "${packageName}" metadata from npm.`);
+    }
+    return packageMetadata;
+}
+/**
+ * Fetches the tarball (`.tgz` file) of the specified package and version from
+ * the public npm registry.
+ *
+ * @param packageName - The name of the package whose tarball to fetch.
+ * @param versionRange - The SemVer range of the package to fetch. The highest
+ * version satisfying the range will be fetched.
+ * @param registryUrl - The URL of the npm registry to fetch the tarball from.
+ * @param fetchFunction - The fetch function to use. Defaults to the global
+ * {@link fetch}. Useful for Node.js compatibility.
+ * @returns A tuple of the {@link Response} for the package tarball and the
+ * actual version of the package.
+ * @throws If fetching the tarball fails.
+ */ async function fetchNpmTarball(packageName, versionRange, registryUrl, fetchFunction) {
+    const packageMetadata = await fetchNpmMetadata(packageName, registryUrl, fetchFunction);
+    const versions = Object.keys(packageMetadata?.versions ?? {}).map((version)=>{
+        (0, _utils.assertIsSemVerVersion)(version);
+        return version;
+    });
+    const targetVersion = (0, _snapsutils.getTargetVersion)(versions, versionRange);
+    if (targetVersion === null) {
+        throw new Error(`Failed to find a matching version in npm metadata for package "${packageName}" and requested semver range "${versionRange}".`);
+    }
+    const tarballUrlString = packageMetadata?.versions?.[targetVersion]?.dist?.tarball;
+    if (!(0, _snapsutils.isValidUrl)(tarballUrlString) || !tarballUrlString.toString().endsWith('.tgz')) {
+        throw new Error(`Failed to find valid tarball URL in NPM metadata for package "${packageName}".`);
+    }
+    // Override the tarball hostname/protocol with registryUrl hostname/protocol
+    const newRegistryUrl = new URL(registryUrl);
+    const newTarballUrl = new URL(tarballUrlString);
+    newTarballUrl.hostname = newRegistryUrl.hostname;
+    newTarballUrl.protocol = newRegistryUrl.protocol;
+    // Perform a raw fetch because we want the Response object itself.
+    const tarballResponse = await fetchFunction(newTarballUrl.toString());
+    if (!tarballResponse.ok || !tarballResponse.body) {
+        throw new Error(`Failed to fetch tarball for package "${packageName}".`);
+    }
+    // We assume that NPM is a good actor and provides us with a valid `content-length` header.
+    const tarballSizeString = tarballResponse.headers.get('content-length');
+    (0, _utils.assert)(tarballSizeString, 'Snap tarball has invalid content-length');
+    const tarballSize = parseInt(tarballSizeString, 10);
+    (0, _utils.assert)(tarballSize <= TARBALL_SIZE_SAFETY_LIMIT, 'Snap tarball exceeds size limit');
+    return [
+        tarballResponse.body,
+        targetVersion
+    ];
+}
+/**
+ * The paths of files within npm tarballs appear to always be prefixed with
+ * "package/".
+ */ const NPM_TARBALL_PATH_PREFIX = /^package\//u;
+/**
+ * Converts a {@link ReadableStream} to a Node.js {@link Readable}
+ * stream. Returns the stream directly if it is already a Node.js stream.
+ * We can't use the native Web {@link ReadableStream} directly because the
+ * other stream libraries we use expect Node.js streams.
+ *
+ * @param stream - The stream to convert.
+ * @returns The given stream as a Node.js Readable stream.
+ */ function getNodeStream(stream) {
+    if (typeof stream.getReader !== 'function') {
+        return stream;
+    }
+    return new _readablewebtonodestream.ReadableWebToNodeStream(stream);
+}
+/**
+ * Creates a `tar-stream` that will get the necessary files from an npm Snap
+ * package tarball (`.tgz` file).
+ *
+ * @param canonicalBase - A base URI as specified in {@link https://github.com/MetaMask/SIPs/blob/main/SIPS/sip-8.md SIP-8}. Starting with 'npm:'. Will be used for canonicalPath vfile argument.
+ * @param files - An object to write target file contents to.
+ * @returns The {@link Writable} tarball extraction stream.
+ */ function createTarballStream(canonicalBase, files) {
+    (0, _utils.assert)(canonicalBase.endsWith('/'), "Base needs to end with '/' for relative paths to be added as children instead of siblings.");
+    (0, _utils.assert)(canonicalBase.startsWith('npm:'), 'Protocol mismatch, expected "npm:".');
+    // `tar-stream` is pretty old-school, so we create it first and then
+    // instrument it by adding event listeners.
+    const extractStream = (0, _tarstream.extract)();
+    let totalSize = 0;
+    // "entry" is fired for every discreet entity in the tarball. This includes
+    // files and folders.
+    extractStream.on('entry', (header, entryStream, next)=>{
+        const { name: headerName, type: headerType } = header;
+        if (headerType === 'file') {
+            // The name is a path if the header type is "file".
+            const path = headerName.replace(NPM_TARBALL_PATH_PREFIX, '');
+            return entryStream.pipe((0, _concatstream.default)({
+                encoding: 'uint8array'
+            }, (data)=>{
+                try {
+                    totalSize += data.byteLength;
+                    // To prevent zip bombs, we set a safety limit for the total size of tarballs.
+                    (0, _utils.assert)(totalSize < TARBALL_SIZE_SAFETY_LIMIT, `Snap tarball exceeds limit of ${TARBALL_SIZE_SAFETY_LIMIT} bytes.`);
+                    const vfile = new _snapsutils.VirtualFile({
+                        value: data,
+                        path,
+                        data: {
+                            canonicalPath: new URL(path, canonicalBase).toString()
+                        }
+                    });
+                    // We disallow files having identical paths as it may confuse our checksum calculations.
+                    (0, _utils.assert)(!files.has(path), 'Malformed tarball, multiple files with the same path.');
+                    files.set(path, vfile);
+                    return next();
+                } catch (error) {
+                    return extractStream.destroy(error);
+                }
+            }));
+        }
+        // If we get here, the entry is not a file, and we want to ignore. The entry
+        // stream must be drained, or the extractStream will stop reading. This is
+        // effectively a no-op for the current entry.
+        entryStream.on('end', ()=>next());
+        return entryStream.resume();
+    });
+    return extractStream;
+}
+
+//# sourceMappingURL=npm.js.map

package/dist/cjs/snaps/location/npm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/snaps/location/npm.ts"],"sourcesContent":["import type { SnapManifest } from '@metamask/snaps-utils';\nimport {\n  createSnapManifest,\n  DEFAULT_REQUESTED_SNAP_VERSION,\n  getTargetVersion,\n  isValidUrl,\n  NpmSnapIdStruct,\n  VirtualFile,\n  normalizeRelative,\n  parseJson,\n} from '@metamask/snaps-utils';\nimport type { SemVerRange, SemVerVersion } from '@metamask/utils';\nimport {\n  assert,\n  assertIsSemVerVersion,\n  assertStruct,\n  isObject,\n} from '@metamask/utils';\nimport concat from 'concat-stream';\nimport createGunzipStream from 'gunzip-maybe';\nimport { ReadableWebToNodeStream } from 'readable-web-to-node-stream';\nimport { pipeline } from 'stream';\nimport type { Readable, Writable } from 'stream';\nimport { extract as tarExtract } from 'tar-stream';\n\nimport type { DetectSnapLocationOptions, SnapLocation } from './location';\n\nexport const DEFAULT_NPM_REGISTRY = 'https://registry.npmjs.org';\n\ninterface NpmMeta {\n  registry: URL;\n  packageName: string;\n  requestedRange: SemVerRange;\n  version?: string;\n  fetch: typeof fetch;\n}\nexport interface NpmOptions {\n  /**\n   * @default DEFAULT_REQUESTED_SNAP_VERSION\n   */\n  versionRange?: SemVerRange;\n  /**\n   * Whether to allow custom NPM registries outside of {@link DEFAULT_NPM_REGISTRY}.\n   *\n   * @default false\n   */\n  allowCustomRegistries?: boolean;\n}\n\nexport class NpmLocation implements SnapLocation {\n  private readonly meta: NpmMeta;\n\n  private validatedManifest?: VirtualFile<SnapManifest>;\n\n  private files?: Map<string, VirtualFile>;\n\n  constructor(url: URL, opts: DetectSnapLocationOptions = {}) {\n    const allowCustomRegistries = opts.allowCustomRegistries ?? false;\n    const fetchFunction = opts.fetch ?? globalThis.fetch.bind(globalThis);\n    const requestedRange = opts.versionRange ?? DEFAULT_REQUESTED_SNAP_VERSION;\n\n    assertStruct(url.toString(), NpmSnapIdStruct, 'Invalid Snap Id: ');\n\n    let registry: string | URL;\n    if (\n      url.host === '' &&\n      url.port === '' &&\n      url.username === '' &&\n      url.password === ''\n    ) {\n      registry = new URL(DEFAULT_NPM_REGISTRY);\n    } else {\n      registry = 'https://';\n      if (url.username) {\n        registry += url.username;\n        if (url.password) {\n          registry += `:${url.password}`;\n        }\n        registry += '@';\n      }\n      registry += url.host;\n      registry = new URL(registry);\n      assert(\n        allowCustomRegistries,\n        new TypeError(\n          `Custom NPM registries are disabled, tried to use \"${registry.toString()}\".`,\n        ),\n      );\n    }\n\n    assert(\n      registry.pathname === '/' &&\n        registry.search === '' &&\n        registry.hash === '',\n    );\n\n    assert(\n      url.pathname !== '' && url.pathname !== '/',\n      new TypeError('The package name in NPM location is empty.'),\n    );\n    let packageName = url.pathname;\n    if (packageName.startsWith('/')) {\n      packageName = packageName.slice(1);\n    }\n\n    this.meta = {\n      requestedRange,\n      registry,\n      packageName,\n      fetch: fetchFunction,\n    };\n  }\n\n  async manifest(): Promise<VirtualFile<SnapManifest>> {\n    if (this.validatedManifest) {\n      return this.validatedManifest.clone();\n    }\n\n    const vfile = await this.fetch('snap.manifest.json');\n    const result = parseJson(vfile.toString());\n    vfile.result = createSnapManifest(result);\n    this.validatedManifest = vfile as VirtualFile<SnapManifest>;\n\n    return this.manifest();\n  }\n\n  async fetch(path: string): Promise<VirtualFile> {\n    const relativePath = normalizeRelative(path);\n    if (!this.files) {\n      await this.#lazyInit();\n      assert(this.files !== undefined);\n    }\n    const vfile = this.files.get(relativePath);\n    assert(\n      vfile !== undefined,\n      new TypeError(`File \"${path}\" not found in package.`),\n    );\n    return vfile.clone();\n  }\n\n  get packageName(): string {\n    return this.meta.packageName;\n  }\n\n  get version(): string {\n    assert(\n      this.meta.version !== undefined,\n      'Tried to access version without first fetching NPM package.',\n    );\n    return this.meta.version;\n  }\n\n  get registry(): URL {\n    return this.meta.registry;\n  }\n\n  get versionRange(): SemVerRange {\n    return this.meta.requestedRange;\n  }\n\n  async #lazyInit() {\n    assert(this.files === undefined);\n    const [tarballResponse, actualVersion] = await fetchNpmTarball(\n      this.meta.packageName,\n      this.meta.requestedRange,\n      this.meta.registry,\n      this.meta.fetch,\n    );\n    this.meta.version = actualVersion;\n\n    let canonicalBase = 'npm://';\n    if (this.meta.registry.username !== '') {\n      canonicalBase += this.meta.registry.username;\n      if (this.meta.registry.password !== '') {\n        canonicalBase += `:${this.meta.registry.password}`;\n      }\n      canonicalBase += '@';\n    }\n    canonicalBase += this.meta.registry.host;\n\n    // TODO(ritave): Lazily extract files instead of up-front extracting all of them\n    //               We would need to replace tar-stream package because it requires immediate consumption of streams.\n    await new Promise<void>((resolve, reject) => {\n      this.files = new Map();\n      pipeline(\n        getNodeStream(tarballResponse),\n        // The \"gz\" in \"tgz\" stands for \"gzip\". The tarball needs to be decompressed\n        // before we can actually grab any files from it.\n        // To prevent recursion-based zip bombs, we set a maximum recursion depth of 1.\n        createGunzipStream(1),\n        createTarballStream(\n          `${canonicalBase}/${this.meta.packageName}/`,\n          this.files,\n        ),\n        (error) => {\n          error ? reject(error) : resolve();\n        },\n      );\n    });\n  }\n}\n\n// Safety limit for tarballs, 250 MB in bytes\nconst TARBALL_SIZE_SAFETY_LIMIT = 262144000;\n\n// Incomplete type\nexport type PartialNpmMetadata = {\n  versions: Record<string, { dist: { tarball: string } }>;\n};\n\n/**\n * Fetches the NPM metadata of the specified package from\n * the public npm registry.\n *\n * @param packageName - The name of the package whose metadata to fetch.\n * @param registryUrl - The URL of the npm registry to fetch the metadata from.\n * @param fetchFunction - The fetch function to use. Defaults to the global\n * {@link fetch}. Useful for Node.js compatibility.\n * @returns The NPM metadata object.\n * @throws If fetching the metadata fails.\n */\nexport async function fetchNpmMetadata(\n  packageName: string,\n  registryUrl: URL | string,\n  fetchFunction: typeof fetch,\n): Promise<PartialNpmMetadata> {\n  const packageResponse = await fetchFunction(\n    new URL(packageName, registryUrl).toString(),\n  );\n  if (!packageResponse.ok) {\n    throw new Error(\n      `Failed to fetch NPM registry entry. Status code: ${packageResponse.status}.`,\n    );\n  }\n  const packageMetadata = await packageResponse.json();\n\n  if (!isObject(packageMetadata)) {\n    throw new Error(\n      `Failed to fetch package \"${packageName}\" metadata from npm.`,\n    );\n  }\n\n  return packageMetadata as PartialNpmMetadata;\n}\n\n/**\n * Fetches the tarball (`.tgz` file) of the specified package and version from\n * the public npm registry.\n *\n * @param packageName - The name of the package whose tarball to fetch.\n * @param versionRange - The SemVer range of the package to fetch. The highest\n * version satisfying the range will be fetched.\n * @param registryUrl - The URL of the npm registry to fetch the tarball from.\n * @param fetchFunction - The fetch function to use. Defaults to the global\n * {@link fetch}. Useful for Node.js compatibility.\n * @returns A tuple of the {@link Response} for the package tarball and the\n * actual version of the package.\n * @throws If fetching the tarball fails.\n */\nasync function fetchNpmTarball(\n  packageName: string,\n  versionRange: SemVerRange,\n  registryUrl: URL | string,\n  fetchFunction: typeof fetch,\n): Promise<[ReadableStream, SemVerVersion]> {\n  const packageMetadata = await fetchNpmMetadata(\n    packageName,\n    registryUrl,\n    fetchFunction,\n  );\n\n  const versions = Object.keys(packageMetadata?.versions ?? {}).map(\n    (version) => {\n      assertIsSemVerVersion(version);\n      return version;\n    },\n  );\n\n  const targetVersion = getTargetVersion(versions, versionRange);\n\n  if (targetVersion === null) {\n    throw new Error(\n      `Failed to find a matching version in npm metadata for package \"${packageName}\" and requested semver range \"${versionRange}\".`,\n    );\n  }\n\n  const tarballUrlString =\n    packageMetadata?.versions?.[targetVersion]?.dist?.tarball;\n\n  if (\n    !isValidUrl(tarballUrlString) ||\n    !tarballUrlString.toString().endsWith('.tgz')\n  ) {\n    throw new Error(\n      `Failed to find valid tarball URL in NPM metadata for package \"${packageName}\".`,\n    );\n  }\n\n  // Override the tarball hostname/protocol with registryUrl hostname/protocol\n  const newRegistryUrl = new URL(registryUrl);\n  const newTarballUrl = new URL(tarballUrlString);\n  newTarballUrl.hostname = newRegistryUrl.hostname;\n  newTarballUrl.protocol = newRegistryUrl.protocol;\n\n  // Perform a raw fetch because we want the Response object itself.\n  const tarballResponse = await fetchFunction(newTarballUrl.toString());\n  if (!tarballResponse.ok || !tarballResponse.body) {\n    throw new Error(`Failed to fetch tarball for package \"${packageName}\".`);\n  }\n  // We assume that NPM is a good actor and provides us with a valid `content-length` header.\n  const tarballSizeString = tarballResponse.headers.get('content-length');\n  assert(tarballSizeString, 'Snap tarball has invalid content-length');\n  const tarballSize = parseInt(tarballSizeString, 10);\n  assert(\n    tarballSize <= TARBALL_SIZE_SAFETY_LIMIT,\n    'Snap tarball exceeds size limit',\n  );\n  return [tarballResponse.body, targetVersion];\n}\n\n/**\n * The paths of files within npm tarballs appear to always be prefixed with\n * \"package/\".\n */\nconst NPM_TARBALL_PATH_PREFIX = /^package\\//u;\n\n/**\n * Converts a {@link ReadableStream} to a Node.js {@link Readable}\n * stream. Returns the stream directly if it is already a Node.js stream.\n * We can't use the native Web {@link ReadableStream} directly because the\n * other stream libraries we use expect Node.js streams.\n *\n * @param stream - The stream to convert.\n * @returns The given stream as a Node.js Readable stream.\n */\nfunction getNodeStream(stream: ReadableStream): Readable {\n  if (typeof stream.getReader !== 'function') {\n    return stream as unknown as Readable;\n  }\n\n  return new ReadableWebToNodeStream(stream);\n}\n\n/**\n * Creates a `tar-stream` that will get the necessary files from an npm Snap\n * package tarball (`.tgz` file).\n *\n * @param canonicalBase - A base URI as specified in {@link https://github.com/MetaMask/SIPs/blob/main/SIPS/sip-8.md SIP-8}. Starting with 'npm:'. Will be used for canonicalPath vfile argument.\n * @param files - An object to write target file contents to.\n * @returns The {@link Writable} tarball extraction stream.\n */\nfunction createTarballStream(\n  canonicalBase: string,\n  files: Map<string, VirtualFile>,\n): Writable {\n  assert(\n    canonicalBase.endsWith('/'),\n    \"Base needs to end with '/' for relative paths to be added as children instead of siblings.\",\n  );\n\n  assert(\n    canonicalBase.startsWith('npm:'),\n    'Protocol mismatch, expected \"npm:\".',\n  );\n  // `tar-stream` is pretty old-school, so we create it first and then\n  // instrument it by adding event listeners.\n  const extractStream = tarExtract();\n\n  let totalSize = 0;\n\n  // \"entry\" is fired for every discreet entity in the tarball. This includes\n  // files and folders.\n  extractStream.on('entry', (header, entryStream, next) => {\n    const { name: headerName, type: headerType } = header;\n    if (headerType === 'file') {\n      // The name is a path if the header type is \"file\".\n      const path = headerName.replace(NPM_TARBALL_PATH_PREFIX, '');\n      return entryStream.pipe(\n        concat({ encoding: 'uint8array' }, (data) => {\n          try {\n            totalSize += data.byteLength;\n            // To prevent zip bombs, we set a safety limit for the total size of tarballs.\n            assert(\n              totalSize < TARBALL_SIZE_SAFETY_LIMIT,\n              `Snap tarball exceeds limit of ${TARBALL_SIZE_SAFETY_LIMIT} bytes.`,\n            );\n            const vfile = new VirtualFile({\n              value: data,\n              path,\n              data: {\n                canonicalPath: new URL(path, canonicalBase).toString(),\n              },\n            });\n            // We disallow files having identical paths as it may confuse our checksum calculations.\n            assert(\n              !files.has(path),\n              'Malformed tarball, multiple files with the same path.',\n            );\n            files.set(path, vfile);\n            return next();\n          } catch (error) {\n            return extractStream.destroy(error);\n          }\n        }),\n      );\n    }\n\n    // If we get here, the entry is not a file, and we want to ignore. The entry\n    // stream must be drained, or the extractStream will stop reading. This is\n    // effectively a no-op for the current entry.\n    entryStream.on('end', () => next());\n    return entryStream.resume();\n  });\n  return extractStream;\n}\n"],"names":["DEFAULT_NPM_REGISTRY","NpmLocation","fetchNpmMetadata","manifest","validatedManifest","clone","vfile","fetch","result","parseJson","toString","createSnapManifest","path","relativePath","normalizeRelative","files","lazyInit","assert","undefined","get","TypeError","packageName","meta","version","registry","versionRange","requestedRange","constructor","url","opts","allowCustomRegistries","fetchFunction","globalThis","bind","DEFAULT_REQUESTED_SNAP_VERSION","assertStruct","NpmSnapIdStruct","host","port","username","password","URL","pathname","search","hash","startsWith","slice","tarballResponse","actualVersion","fetchNpmTarball","canonicalBase","Promise","resolve","reject","Map","pipeline","getNodeStream","createGunzipStream","createTarballStream","error","TARBALL_SIZE_SAFETY_LIMIT","registryUrl","packageResponse","ok","Error","status","packageMetadata","json","isObject","versions","Object","keys","map","assertIsSemVerVersion","targetVersion","getTargetVersion","tarballUrlString","dist","tarball","isValidUrl","endsWith","newRegistryUrl","newTarballUrl","hostname","protocol","body","tarballSizeString","headers","tarballSize","parseInt","NPM_TARBALL_PATH_PREFIX","stream","getReader","ReadableWebToNodeStream","extractStream","tarExtract","totalSize","on","header","entryStream","next","name","headerName","type","headerType","replace","pipe","concat","encoding","data","byteLength","VirtualFile","value","canonicalPath","has","set","destroy","resume"],"mappings":"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"}

package/dist/cjs/snaps/permissions.js

@@ -0,0 +1,61 @@
+"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, {
+    processSnapPermissions: function() {
+        return processSnapPermissions;
+    },
+    buildSnapEndowmentSpecifications: function() {
+        return buildSnapEndowmentSpecifications;
+    },
+    buildSnapRestrictedMethodSpecifications: function() {
+        return buildSnapRestrictedMethodSpecifications;
+    }
+});
+const _rpcmethods = require("@metamask/rpc-methods");
+const _utils = require("@metamask/utils");
+const _endowments = require("./endowments");
+function processSnapPermissions(initialPermissions) {
+    return Object.fromEntries(Object.entries(initialPermissions).map(([initialPermission, value])=>{
+        if ((0, _utils.hasProperty)(_rpcmethods.caveatMappers, initialPermission)) {
+            return [
+                initialPermission,
+                _rpcmethods.caveatMappers[initialPermission](value)
+            ];
+        } else if ((0, _utils.hasProperty)(_endowments.endowmentCaveatMappers, initialPermission)) {
+            return [
+                initialPermission,
+                _endowments.endowmentCaveatMappers[initialPermission](value)
+            ];
+        }
+        // If we have no mapping, this may be a non-snap permission, return as-is
+        return [
+            initialPermission,
+            value
+        ];
+    }));
+}
+const buildSnapEndowmentSpecifications = (excludedEndowments)=>Object.values(_endowments.endowmentPermissionBuilders).reduce((allSpecifications, { targetName, specificationBuilder })=>{
+        if (!excludedEndowments.includes(targetName)) {
+            allSpecifications[targetName] = specificationBuilder({});
+        }
+        return allSpecifications;
+    }, {});
+const buildSnapRestrictedMethodSpecifications = (excludedPermissions, hooks)=>Object.values(_rpcmethods.restrictedMethodPermissionBuilders).reduce((specifications, { targetName, specificationBuilder, methodHooks })=>{
+        if (!excludedPermissions.includes(targetName)) {
+            specifications[targetName] = specificationBuilder({
+                // @ts-expect-error The selectHooks type is wonky
+                methodHooks: (0, _rpcmethods.selectHooks)(hooks, methodHooks)
+            });
+        }
+        return specifications;
+    }, {});
+
+//# sourceMappingURL=permissions.js.map

package/dist/cjs/snaps/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/snaps/permissions.ts"],"sourcesContent":["import type {\n  PermissionConstraint,\n  PermissionSpecificationConstraint,\n} from '@metamask/permission-controller';\nimport {\n  caveatMappers,\n  restrictedMethodPermissionBuilders,\n  selectHooks,\n} from '@metamask/rpc-methods';\nimport type { SnapPermissions } from '@metamask/snaps-utils';\nimport { hasProperty } from '@metamask/utils';\n\nimport {\n  endowmentCaveatMappers,\n  endowmentPermissionBuilders,\n} from './endowments';\n\n/**\n * Map initial permissions as defined in a Snap manifest to something that can\n * be processed by the PermissionsController. Each caveat mapping function\n * should return a valid permission caveat value.\n *\n * This function does not validate the caveat values, since that is done by\n * the PermissionsController itself, upon requesting the permissions.\n *\n * @param initialPermissions - The initial permissions to process.\n * @returns The processed permissions.\n */\nexport function processSnapPermissions(\n  initialPermissions: SnapPermissions,\n): Record<string, Pick<PermissionConstraint, 'caveats'>> {\n  return Object.fromEntries(\n    Object.entries(initialPermissions).map(([initialPermission, value]) => {\n      if (hasProperty(caveatMappers, initialPermission)) {\n        return [initialPermission, caveatMappers[initialPermission](value)];\n      } else if (hasProperty(endowmentCaveatMappers, initialPermission)) {\n        return [\n          initialPermission,\n          endowmentCaveatMappers[initialPermission](value),\n        ];\n      }\n\n      // If we have no mapping, this may be a non-snap permission, return as-is\n      return [\n        initialPermission,\n        value as Pick<PermissionConstraint, 'caveats'>,\n      ];\n    }),\n  );\n}\n\nexport const buildSnapEndowmentSpecifications = (\n  excludedEndowments: string[],\n) =>\n  Object.values(endowmentPermissionBuilders).reduce<\n    Record<string, PermissionSpecificationConstraint>\n  >((allSpecifications, { targetName, specificationBuilder }) => {\n    if (!excludedEndowments.includes(targetName)) {\n      allSpecifications[targetName] = specificationBuilder({});\n    }\n    return allSpecifications;\n  }, {});\n\nexport const buildSnapRestrictedMethodSpecifications = (\n  excludedPermissions: string[],\n  hooks: Record<string, unknown>,\n) =>\n  Object.values(restrictedMethodPermissionBuilders).reduce<\n    Record<string, PermissionSpecificationConstraint>\n  >((specifications, { targetName, specificationBuilder, methodHooks }) => {\n    if (!excludedPermissions.includes(targetName)) {\n      specifications[targetName] = specificationBuilder({\n        // @ts-expect-error The selectHooks type is wonky\n        methodHooks: selectHooks<typeof hooks, keyof typeof methodHooks>(\n          hooks,\n          methodHooks,\n        ) as Pick<typeof hooks, keyof typeof methodHooks>,\n      });\n    }\n    return specifications;\n  }, {});\n"],"names":["processSnapPermissions","buildSnapEndowmentSpecifications","buildSnapRestrictedMethodSpecifications","initialPermissions","Object","fromEntries","entries","map","initialPermission","value","hasProperty","caveatMappers","endowmentCaveatMappers","excludedEndowments","values","endowmentPermissionBuilders","reduce","allSpecifications","targetName","specificationBuilder","includes","excludedPermissions","hooks","restrictedMethodPermissionBuilders","specifications","methodHooks","selectHooks"],"mappings":";;;;;;;;;;;IA4BgBA,sBAAsB;eAAtBA;;IAuBHC,gCAAgC;eAAhCA;;IAYAC,uCAAuC;eAAvCA;;;4BAvDN;uBAEqB;4BAKrB;AAaA,SAASF,uBACdG,kBAAmC;IAEnC,OAAOC,OAAOC,WAAW,CACvBD,OAAOE,OAAO,CAACH,oBAAoBI,GAAG,CAAC,CAAC,CAACC,mBAAmBC,MAAM;QAChE,IAAIC,IAAAA,kBAAW,EAACC,yBAAa,EAAEH,oBAAoB;YACjD,OAAO;gBAACA;gBAAmBG,yBAAa,CAACH,kBAAkB,CAACC;aAAO;QACrE,OAAO,IAAIC,IAAAA,kBAAW,EAACE,kCAAsB,EAAEJ,oBAAoB;YACjE,OAAO;gBACLA;gBACAI,kCAAsB,CAACJ,kBAAkB,CAACC;aAC3C;QACH;QAEA,yEAAyE;QACzE,OAAO;YACLD;YACAC;SACD;IACH;AAEJ;AAEO,MAAMR,mCAAmC,CAC9CY,qBAEAT,OAAOU,MAAM,CAACC,uCAA2B,EAAEC,MAAM,CAE/C,CAACC,mBAAmB,EAAEC,UAAU,EAAEC,oBAAoB,EAAE;QACxD,IAAI,CAACN,mBAAmBO,QAAQ,CAACF,aAAa;YAC5CD,iBAAiB,CAACC,WAAW,GAAGC,qBAAqB,CAAC;QACxD;QACA,OAAOF;IACT,GAAG,CAAC;AAEC,MAAMf,0CAA0C,CACrDmB,qBACAC,QAEAlB,OAAOU,MAAM,CAACS,8CAAkC,EAAEP,MAAM,CAEtD,CAACQ,gBAAgB,EAAEN,UAAU,EAAEC,oBAAoB,EAAEM,WAAW,EAAE;QAClE,IAAI,CAACJ,oBAAoBD,QAAQ,CAACF,aAAa;YAC7CM,cAAc,CAACN,WAAW,GAAGC,qBAAqB;gBAChD,iDAAiD;gBACjDM,aAAaC,IAAAA,uBAAW,EACtBJ,OACAG;YAEJ;QACF;QACA,OAAOD;IACT,GAAG,CAAC"}

package/dist/cjs/snaps/registry/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./registry"), exports);
+_export_star(require("./json"), 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/snaps/registry/index.js.map

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