@metamask/snaps-utils 1.0.1 → 2.0.0

package/dist/esm/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 type { 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":["assertIsSnapIcon","assertIsSnapManifest","validateSnapShasum","validateFetchedSnap","files","manifest","result","svgIcon"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,SAAS;AAC1C,SAASC,oBAAoB,QAAQ,wBAAwB;AAC7D,SAASC,kBAAkB,QAAQ,UAAU;AAG7C;;;;;CAKC,GACD,OAAO,SAASC,oBACdC,KAA6D;IAE7DH,qBAAqBG,MAAMC,QAAQ,CAACC,MAAM;IAC1CJ,mBAAmBE;IAEnB,IAAIA,MAAMG,OAAO,EAAE;QACjBP,iBAAiBI,MAAMG,OAAO;IAChC;AACF"}

package/dist/{versions.js → esm/versions.js}

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveVersionRange = exports.getTargetVersion = exports.DEFAULT_REQUESTED_SNAP_VERSION = void 0;
-const utils_1 = require("@metamask/utils");
-const semver_1 = require("semver");
-const superstruct_1 = require("superstruct");
-exports.DEFAULT_REQUESTED_SNAP_VERSION = '*';
+import { VersionRangeStruct } from '@metamask/utils';
+import { maxSatisfying as maxSatisfyingSemver } from 'semver';
+import { validate } from 'superstruct';
+export const DEFAULT_REQUESTED_SNAP_VERSION = '*';
 /**
  * Return the highest version in the list that satisfies the range, or `null` if
  * none of them do. For the satisfaction check, pre-release versions will only
@@ -14,31 +11,31 @@ exports.DEFAULT_REQUESTED_SNAP_VERSION = '*';
  * @param versionRange - The SemVer version range to check against.
  * @returns The highest version in the list that satisfies the range,
  * or `null` if none of them do.
- */
-function getTargetVersion(versions, versionRange) {
-    const maxSatisfyingNonPreRelease = (0, semver_1.maxSatisfying)(versions, versionRange);
+ */ export function getTargetVersion(versions, versionRange) {
+    const maxSatisfyingNonPreRelease = maxSatisfyingSemver(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_1.maxSatisfying)(versions, versionRange, {
-        includePrerelease: true,
+    return maxSatisfyingSemver(versions, versionRange, {
+        includePrerelease: true
     });
 }
-exports.getTargetVersion = getTargetVersion;
 /**
  * Parse a version received by some subject attempting to access a snap.
  *
  * @param version - The received version value.
  * @returns `*` if the version is `undefined` or `latest", otherwise returns
  * the specified version.
- */
-function resolveVersionRange(version) {
+ */ export function resolveVersionRange(version) {
     if (version === undefined || version === 'latest') {
-        return [undefined, exports.DEFAULT_REQUESTED_SNAP_VERSION];
+        return [
+            undefined,
+            DEFAULT_REQUESTED_SNAP_VERSION
+        ];
     }
-    return (0, superstruct_1.validate)(version, utils_1.VersionRangeStruct);
+    return validate(version, VersionRangeStruct);
 }
-exports.resolveVersionRange = resolveVersionRange;
+
 //# sourceMappingURL=versions.js.map

package/dist/esm/versions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/versions.ts"],"sourcesContent":["import type { Json, SemVerVersion, SemVerRange } from '@metamask/utils';\nimport { VersionRangeStruct } 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":["VersionRangeStruct","maxSatisfying","maxSatisfyingSemver","validate","DEFAULT_REQUESTED_SNAP_VERSION","getTargetVersion","versions","versionRange","maxSatisfyingNonPreRelease","includePrerelease","resolveVersionRange","version","undefined"],"mappings":"AACA,SAASA,kBAAkB,QAAQ,kBAAkB;AACrD,SAASC,iBAAiBC,mBAAmB,QAAQ,SAAS;AAC9D,SAASC,QAAQ,QAAQ,cAAc;AAEvC,OAAO,MAAMC,iCAAiC,IAAmB;AAEjE;;;;;;;;;CASC,GACD,OAAO,SAASC,iBACdC,QAAyB,EACzBC,YAAyB;IAEzB,MAAMC,6BAA6BN,oBACjCI,UACAC;IAGF,4CAA4C;IAC5C,IAAIC,4BAA4B;QAC9B,OAAOA;IACT;IAEA,iFAAiF;IACjF,OAAON,oBAAoBI,UAAUC,cAAc;QACjDE,mBAAmB;IACrB;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,oBACdC,OAAc;IAEd,IAAIA,YAAYC,aAAaD,YAAY,UAAU;QACjD,OAAO;YAACC;YAAWR;SAA+B;IACpD;IACA,OAAOD,SAASQ,SAASX;AAC3B"}

package/dist/{virtual-file → esm/virtual-file}/VirtualFile.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VirtualFile = void 0;
 // 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
@@ -9,34 +6,25 @@ exports.VirtualFile = void 0;
 // 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.
-const utils_1 = require("@metamask/utils");
-const deep_clone_1 = require("../deep-clone");
-class VirtualFile {
-    constructor(value) {
-        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 ?? '/';
+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;
+}
+import { assert } from '@metamask/utils';
+import { deepClone } from '../deep-clone';
+export class VirtualFile {
     toString(encoding) {
         if (typeof this.value === 'string') {
-            (0, utils_1.assert)(encoding === undefined, 'Tried to encode string.');
+            assert(encoding === undefined, 'Tried to encode string.');
             return this.value;
         }
         const decoder = new TextDecoder(encoding);
@@ -46,16 +34,42 @@ class VirtualFile {
         const vfile = new VirtualFile();
         if (typeof this.value === 'string') {
             vfile.value = this.value;
-        }
-        else {
+        } 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, deep_clone_1.deepClone)(this.result);
-        vfile.data = (0, deep_clone_1.deepClone)(this.data);
+        vfile.result = deepClone(this.result);
+        vfile.data = 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 ?? '/';
+    }
 }
-exports.VirtualFile = VirtualFile;
+
 //# sourceMappingURL=VirtualFile.js.map

package/dist/esm/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":["assert","deepClone","VirtualFile","toString","encoding","value","undefined","decoder","TextDecoder","decode","clone","vfile","slice","result","data","path","constructor","options","Uint8Array"],"mappings":"AAAA,0HAA0H;AAC1H,iEAAiE;AACjE,2FAA2F;AAC3F,wFAAwF;AACxF,EAAE;AACF,oHAAoH;AACpH,qGAAqG;AACrG,sDAAsD;;;;;;;;;;;;;;AACtD,SAASA,MAAM,QAAQ,kBAAkB;AAEzC,SAASC,SAAS,QAAQ,gBAAgB;AA+B1C,OAAO,MAAMC;IAgCXC,SAASC,QAAiB,EAAE;QAC1B,IAAI,OAAO,IAAI,CAACC,KAAK,KAAK,UAAU;YAClCL,OAAOI,aAAaE,WAAW;YAC/B,OAAO,IAAI,CAACD,KAAK;QACnB;QACA,MAAME,UAAU,IAAIC,YAAYJ;QAChC,OAAOG,QAAQE,MAAM,CAAC,IAAI,CAACJ,KAAK;IAClC;IAEAK,QAAQ;QACN,MAAMC,QAAQ,IAAIT;QAClB,IAAI,OAAO,IAAI,CAACG,KAAK,KAAK,UAAU;YAClCM,MAAMN,KAAK,GAAG,IAAI,CAACA,KAAK;QAC1B,OAAO;YACL,mFAAmF;YACnFM,MAAMN,KAAK,GAAG,IAAI,CAACA,KAAK,CAACO,KAAK,CAAC;QACjC;QACAD,MAAME,MAAM,GAAGZ,UAAU,IAAI,CAACY,MAAM;QACpCF,MAAMG,IAAI,GAAGb,UAAU,IAAI,CAACa,IAAI;QAChCH,MAAMI,IAAI,GAAG,IAAI,CAACA,IAAI;QACtB,OAAOJ;IACT;IApDAK,YAAYX,KAA0B,CAAE;QAuBxCA,uBAAAA,SAAAA,KAAAA;QAEAQ,uBAAAA,UAAAA,KAAAA;QAEAC,uBAAAA,QAAAA,KAAAA;QAEAC,uBAAAA,QAAAA,KAAAA;QA5BE,IAAIE;QACJ,IAAI,OAAOZ,UAAU,YAAYA,iBAAiBa,YAAY;YAC5DD,UAAU;gBAAEZ;YAAM;QACpB,OAAO;YACLY,UAAUZ;QACZ;QAEA,IAAI,CAACA,KAAK,GAAGY,SAASZ,SAAS;QAC/B,wDAAwD;QACxD,gEAAgE;QAChE,4DAA4D;QAC5D,EAAE;QACF,wEAAwE;QACxE,4EAA4E;QAC5E,8EAA8E;QAC9E,EAAE;QACF,iDAAiD;QACjD,IAAI,CAACQ,MAAM,GAAGI,SAASJ,UAAWP;QAClC,IAAI,CAACQ,IAAI,GAAGG,SAASH,QAAQ,CAAC;QAC9B,IAAI,CAACC,IAAI,GAAGE,SAASF,QAAQ;IAC/B;AAgCF"}

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

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

package/dist/esm/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":"AAAA,cAAc,gBAAgB"}

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

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

package/dist/esm/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":"AAAA,cAAc,kBAAkB;AAChC,cAAc,gBAAgB"}

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

@@ -0,0 +1,26 @@
+import { promises as fsPromises } from 'fs';
+import { VirtualFile } from './VirtualFile';
+/**
+ * Reads a file from filesystem and creates a vfile.
+ *
+ * @param path - Filesystem path to load the contents from.
+ * @param encoding - Optional encoding to pass down to fs.readFile.
+ * @returns Promise returning VFile with loaded file contents.
+ */ export async function readVirtualFile(path, encoding = null) {
+    return new VirtualFile({
+        path,
+        value: await fsPromises.readFile(path, {
+            encoding
+        })
+    });
+}
+/**
+ * Writes vfile to filesystem.
+ *
+ * @param vfile - The vfile to write.
+ * @param options - Options to pass down to fs.writeFile.
+ */ export async function writeVirtualFile(vfile, options) {
+    return fsPromises.writeFile(vfile.path, vfile.value, options);
+}
+
+//# sourceMappingURL=toVirtualFile.js.map

package/dist/esm/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":["promises","fsPromises","VirtualFile","readVirtualFile","path","encoding","value","readFile","writeVirtualFile","vfile","options","writeFile"],"mappings":"AAAA,SAASA,YAAYC,UAAU,QAAQ,KAAK;AAE5C,SAASC,WAAW,QAAQ,gBAAgB;AAE5C;;;;;;CAMC,GACD,OAAO,eAAeC,gBACpBC,IAAY,EACZC,WAAkC,IAAI;IAEtC,OAAO,IAAIH,YAAY;QACrBE;QACAE,OAAO,MAAML,WAAWM,QAAQ,CAACH,MAAM;YAAEC;QAAS;IACpD;AACF;AAOA;;;;;CAKC,GACD,OAAO,eAAeG,iBACpBC,KAAkB,EAClBC,OAA2B;IAE3B,OAAOT,WAAWU,SAAS,CAACF,MAAML,IAAI,EAAEK,MAAMH,KAAK,EAAEI;AACvD"}

package/dist/{caveats.d.ts → types/caveats.d.ts}

@@ -7,10 +7,6 @@ export declare enum SnapCaveatType {
      * Permitted coin types, used by `snap_getBip44Entropy`.
      */
     PermittedCoinTypes = "permittedCoinTypes",
-    /**
-     * Permission to use the Snap keyring API.
-     */
-    SnapKeyring = "snapKeyring",
     /**
      * Caveat specifying a snap cronjob.
      */
@@ -26,5 +22,9 @@ export declare enum SnapCaveatType {
     /**
      * Caveat specifying the snap IDs that can be interacted with.
      */
-    SnapIds = "snapIds"
+    SnapIds = "snapIds",
+    /**
+     * Caveat specifying the CAIP-2 chain IDs that a snap can service, currently limited to `endowment:name-lookup`.
+     */
+    ChainIds = "chainIds"
 }

package/dist/{cronjob.d.ts → types/cronjob.d.ts}

@@ -1,4 +1,4 @@
-import { Infer } from 'superstruct';
+import type { Infer } from 'superstruct';
 export declare const CronjobRpcRequestStruct: import("superstruct").Struct<{
     method: string;
     params?: Record<string, import("@metamask/utils").Json> | import("@metamask/utils").Json[] | undefined;

package/dist/types/enum.d.ts

@@ -0,0 +1,30 @@
+import type { Struct } from 'superstruct';
+/**
+ * Get the enum values as union type. This allows using both the enum string
+ * values and the enum itself as values.
+ *
+ * Note: This only works for string enums.
+ *
+ * @example
+ * ```typescript
+ * enum Foo {
+ *   Bar = 'bar',
+ *   Baz = 'baz',
+ * }
+ *
+ * type FooValue = EnumToUnion<Foo>;
+ * // FooValue is 'bar' | 'baz'
+ *
+ * const foo: FooValue = Foo.Bar; // Works
+ * const foo: FooValue = 'bar'; // Also works
+ * ```
+ */
+export declare type EnumToUnion<Type extends string> = `${Type}`;
+/**
+ * Superstruct struct for validating an enum value. This allows using both the
+ * enum string values and the enum itself as values.
+ *
+ * @param constant - The enum to validate against.
+ * @returns The superstruct struct.
+ */
+export declare function enumValue<Type extends string>(constant: Type): Struct<EnumToUnion<Type>, null>;

package/dist/types/errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get the error message from an unknown error type.
+ *
+ * - If the error is an object with a `message` property, return the message.
+ * - Otherwise, return the error converted to a string.
+ *
+ * @param error - The error to get the message from.
+ * @returns The error message.
+ */
+export declare function getErrorMessage(error: unknown): string;

package/dist/{eval.d.ts → types/eval.d.ts}

@@ -1,3 +1,11 @@
+export declare type EvalOutput = {
+    stdout: string;
+    stderr: string;
+};
+export declare class SnapEvalError extends Error {
+    readonly output: EvalOutput;
+    constructor(message: string, output: EvalOutput);
+}
 /**
  * Spawn a new process to run the provided bundle in.
  *
@@ -5,4 +13,4 @@
  * @returns `null` if the worker ran successfully.
  * @throws If the worker failed to run successfully.
  */
-export declare function evalBundle(bundlePath: string): Promise<null>;
+export declare function evalBundle(bundlePath: string): Promise<EvalOutput>;

package/dist/{fs.d.ts → types/fs.d.ts}

@@ -1,5 +1,5 @@
-import { Json } from '@metamask/utils';
-import { VirtualFile } from './virtual-file';
+import type { Json } from '@metamask/utils';
+import type { VirtualFile } from './virtual-file';
 /**
  * Checks whether the given path string resolves to an existing directory, and
  * optionally creates the directory if it doesn't exist.

package/dist/types/handlers.d.ts

@@ -0,0 +1,196 @@
+import type { Component } from '@metamask/snaps-ui';
+import type { Json, JsonRpcParams, JsonRpcRequest } from '@metamask/utils';
+import type { EnumToUnion } from './enum';
+import type { AccountAddress, Caip2ChainId } from './namespace';
+export declare enum HandlerType {
+    OnRpcRequest = "onRpcRequest",
+    OnTransaction = "onTransaction",
+    OnCronjob = "onCronjob",
+    OnInstall = "onInstall",
+    OnUpdate = "onUpdate",
+    OnNameLookup = "onNameLookup"
+}
+declare type SnapHandler = {
+    /**
+     * The type of handler.
+     */
+    type: HandlerType;
+    /**
+     * Whether the handler is required, i.e., whether the request will fail if the
+     * handler is called, but the snap does not export it.
+     *
+     * This is primarily used for the lifecycle handlers, which are optional.
+     */
+    required: boolean;
+    /**
+     * Validate the given snap export. This should return a type guard for the
+     * handler type.
+     *
+     * @param snapExport - The export to validate.
+     * @returns Whether the export is valid.
+     */
+    validator: (snapExport: unknown) => boolean;
+};
+export declare const SNAP_EXPORTS: {
+    readonly onRpcRequest: {
+        readonly type: HandlerType.OnRpcRequest;
+        readonly required: true;
+        readonly validator: (snapExport: unknown) => snapExport is OnRpcRequestHandler<JsonRpcParams>;
+    };
+    readonly onTransaction: {
+        readonly type: HandlerType.OnTransaction;
+        readonly required: true;
+        readonly validator: (snapExport: unknown) => snapExport is OnTransactionHandler;
+    };
+    readonly onCronjob: {
+        readonly type: HandlerType.OnCronjob;
+        readonly required: true;
+        readonly validator: (snapExport: unknown) => snapExport is OnCronjobHandler<JsonRpcParams>;
+    };
+    readonly onNameLookup: {
+        readonly type: HandlerType.OnNameLookup;
+        readonly required: true;
+        readonly validator: (snapExport: unknown) => snapExport is OnNameLookupHandler;
+    };
+    readonly onInstall: {
+        readonly type: HandlerType.OnInstall;
+        readonly required: false;
+        readonly validator: (snapExport: unknown) => snapExport is LifecycleEventHandler;
+    };
+    readonly onUpdate: {
+        readonly type: HandlerType.OnUpdate;
+        readonly required: false;
+        readonly validator: (snapExport: unknown) => snapExport is LifecycleEventHandler;
+    };
+};
+/**
+ * The `onRpcRequest` handler. This is called whenever a JSON-RPC request is
+ * made to the snap.
+ *
+ * @param args - The request arguments.
+ * @param args.origin - The origin of the request. This can be the ID of another
+ * snap, or the URL of a dapp.
+ * @param args.request - The JSON-RPC request sent to the snap.
+ * @returns The JSON-RPC response. This must be a JSON-serializable value.
+ */
+export declare type OnRpcRequestHandler<Params extends JsonRpcParams = JsonRpcParams> = (args: {
+    origin: string;
+    request: JsonRpcRequest<Params>;
+}) => Promise<unknown>;
+/**
+ * Enum used to specify the severity level of content being returned from a transaction insight.
+ */
+export declare enum SeverityLevel {
+    Critical = "critical"
+}
+/**
+ * The response from a snap's `onTransaction` handler.
+ *
+ * @property content - A custom UI component, that will be shown in MetaMask. Can be created using `@metamask/snaps-ui`.
+ *
+ * If the snap has no insights about the transaction, this should be `null`.
+ */
+export declare type OnTransactionResponse = {
+    content: Component | null;
+    severity?: EnumToUnion<SeverityLevel>;
+};
+/**
+ * The `onTransaction` handler. This is called whenever a transaction is
+ * submitted to the snap. It can return insights about the transaction, which
+ * will be displayed to the user.
+ *
+ * @param args - The request arguments.
+ * @param args.transaction - The transaction object.
+ * @param args.chainId - The CAIP-2 chain ID of the network the transaction is
+ * being submitted to.
+ * @param args.transactionOrigin - The origin of the transaction. This is the
+ * URL of the dapp that submitted the transaction.
+ * @returns Insights about the transaction. See {@link OnTransactionResponse}.
+ */
+export declare type OnTransactionHandler = (args: {
+    transaction: {
+        [key: string]: Json;
+    };
+    chainId: string;
+    transactionOrigin?: string;
+}) => Promise<OnTransactionResponse>;
+/**
+ * The `onCronjob` handler. This is called on a regular interval, as defined by
+ * the snap's manifest.
+ *
+ * @param args - The request arguments.
+ * @param args.request - The JSON-RPC request sent to the snap.
+ */
+export declare type OnCronjobHandler<Params extends JsonRpcParams = JsonRpcParams> = (args: {
+    request: JsonRpcRequest<Params>;
+}) => Promise<unknown>;
+/**
+ * A handler that can be used for the lifecycle hooks.
+ */
+export declare type LifecycleEventHandler = (args: {
+    request: JsonRpcRequest;
+}) => Promise<unknown>;
+/**
+ * The `onInstall` handler. This is called after the snap is installed.
+ *
+ * This type is an alias for {@link LifecycleEventHandler}.
+ */
+export declare type OnInstallHandler = LifecycleEventHandler;
+/**
+ * The `onUpdate` handler. This is called after the snap is updated.
+ *
+ * This type is an alias for {@link LifecycleEventHandler}.
+ */
+export declare type OnUpdateHandler = LifecycleEventHandler;
+/**
+ * Utility type for getting the handler function type from a handler type.
+ */
+export declare type HandlerFunction<Type extends SnapHandler> = Type['validator'] extends (snapExport: unknown) => snapExport is infer Handler ? Handler : never;
+/**
+ * The response from a snap's `onNameLookup` handler.
+ *
+ * @property resolvedAddress - The resolved address for a given domain.
+ * @property resolvedDomain - The resolved domain for a given address.
+ *
+ *
+ * If the snap has no resolved address/domain from its lookup, this should be `null`.
+ */
+export declare type OnNameLookupResponse = {
+    resolvedAddress: AccountAddress;
+    resolvedDomain?: never;
+} | {
+    resolvedDomain: string;
+    resolvedAddress?: never;
+} | null;
+export declare type OnNameLookupArgs = {
+    chainId: Caip2ChainId;
+} & ({
+    domain: string;
+    address?: never;
+} | {
+    address: string;
+    domain?: never;
+});
+/**
+ * The `onNameLookup` handler. This is called whenever content is entered
+ * into the send to field for sending assets to an EOA address.
+ *
+ * @param args - The request arguments.
+ * @param args.domain - The human-readable address that is to be resolved.
+ * @param args.chainId - The CAIP-2 chain ID of the network the transaction is
+ * being submitted to.
+ * @param args.address - The address that is to be resolved.
+ * @returns Resolved address/domain from the lookup. See {@link OnNameLookupResponse}.
+ */
+export declare type OnNameLookupHandler = (args: OnNameLookupArgs) => Promise<OnNameLookupResponse>;
+/**
+ * All the function-based handlers that a snap can implement.
+ */
+export declare type SnapFunctionExports = {
+    [Key in keyof typeof SNAP_EXPORTS]?: HandlerFunction<typeof SNAP_EXPORTS[Key]>;
+};
+/**
+ * All handlers that a snap can implement.
+ */
+export declare type SnapExports = SnapFunctionExports;
+export {};

package/dist/types/icon.d.ts

@@ -0,0 +1,4 @@
+import type { VirtualFile } from './virtual-file';
+export declare const SVG_MAX_BYTE_SIZE = 100000;
+export declare const SVG_MAX_BYTE_SIZE_TEXT: string;
+export declare const assertIsSnapIcon: (icon: VirtualFile) => void;

package/dist/{iframe.d.ts → types/iframe.d.ts}

@@ -4,7 +4,8 @@
  * an initialization timeout in the SnapController.
  *
  * @param uri - The iframe URI.
- * @param jobId - The job id.
+ * @param id - The ID to assign to the iframe.
+ * @param sandbox - Whether to enable the sandbox attribute.
  * @returns A promise that resolves to the contentWindow of the iframe.
  */
-export declare function createWindow(uri: string, jobId: string): Promise<Window>;
+export declare function createWindow(uri: string, id: string, sandbox?: boolean): Promise<Window>;

package/dist/{index.browser.d.ts → types/index.browser.d.ts}

@@ -5,6 +5,8 @@ export * from './cronjob';
 export * from './deep-clone';
 export * from './default-endowments';
 export * from './entropy';
+export * from './enum';
+export * from './errors';
 export * from './handlers';
 export * from './iframe';
 export * from './json';
@@ -12,9 +14,11 @@ export * from './json-rpc';
 export * from './logging';
 export * from './manifest/index.browser';
 export * from './namespace';
-export * from './notification';
 export * from './path';
 export * from './snaps';
+export * from './strings';
+export * from './structs';
 export * from './types';
+export * from './validation';
 export * from './versions';
 export * from './virtual-file/index.browser';

package/dist/{index.d.ts → types/index.d.ts}

@@ -5,7 +5,9 @@ export * from './checksum';
 export * from './deep-clone';
 export * from './default-endowments';
 export * from './entropy';
+export * from './enum';
 export * from './eval';
+export * from './errors';
 export * from './fs';
 export * from './handlers';
 export * from './iframe';
@@ -15,11 +17,13 @@ export * from './logging';
 export * from './manifest';
 export * from './mock';
 export * from './namespace';
-export * from './notification';
 export * from './npm';
 export * from './path';
 export * from './post-process';
 export * from './snaps';
+export * from './strings';
+export * from './structs';
 export * from './types';
+export * from './validation';
 export * from './versions';
 export * from './virtual-file';

package/dist/{json-rpc.d.ts → types/json-rpc.d.ts}

@@ -1,5 +1,5 @@
-import { Json, JsonRpcSuccess, AssertionErrorConstructor } from '@metamask/utils';
-import { Infer } from 'superstruct';
+import type { Json, JsonRpcSuccess, AssertionErrorConstructor } from '@metamask/utils';
+import type { Infer } from 'superstruct';
 export declare const RpcOriginsStruct: import("superstruct").Struct<{
     dapps?: boolean | undefined;
     snaps?: boolean | undefined;

package/dist/types/json.d.ts

@@ -0,0 +1,13 @@
+import type { Json } from '@metamask/utils';
+/**
+ * Parse JSON safely.
+ *
+ * Does multiple kinds of validation and strips unwanted properties like
+ * `__proto__` and `constructor`.
+ *
+ * @param json - A JSON string to be parsed.
+ * @returns The parsed JSON object.
+ * @template Type - The type of the JSON object. The type is not actually
+ * checked, but it is used to infer the return type.
+ */
+export declare function parseJson<Type extends Json = Json>(json: string): Type;