@metamask-previews/eth-snap-keyring 4.3.2-672cc7b

package/dist/SnapIdMap.d.ts

@@ -0,0 +1,202 @@
+import type { SnapId } from '@metamask/snaps-sdk';
+/**
+ * Error thrown when an invalid Snap ID is encountered.
+ */
+export declare class InvalidSnapIdError extends Error {
+    /**
+     * The ID of the Snap that caused the error.
+     */
+    snapId: SnapId;
+    /**
+     * The key of the element that caused the error.
+     */
+    key: string;
+    /**
+     * Creates an instance of `InvalidSnapIdError`.
+     *
+     * @param snapId - The invalid Snap ID.
+     * @param key - The key associated with the invalid Snap ID.
+     */
+    constructor(snapId: SnapId, key: string);
+}
+/**
+ * A map that associates a string key with a value that has a `snapId`
+ * property. Note that the key is case-insensitive.
+ *
+ * The `snapId` property is used to ensure that only the Snap that added an
+ * item to the map can modify or delete it.
+ */
+export declare class SnapIdMap<Value extends {
+    snapId: SnapId;
+}> {
+    #private;
+    /**
+     * Creates a new `SnapIdMap` object.
+     *
+     * Example:
+     *
+     * ```ts
+     * const items = [
+     *   ['foo', { snapId: '1', name: 'foo' }],
+     *   ['bar', { snapId: '1', name: 'bar' }],
+     * ];
+     * const map = new SnapIdMap(items);
+     * ```
+     *
+     * @param iterable - An iterable object whose elements are key-value pairs.
+     * Each key-value pair will be added to the new map.
+     */
+    constructor(iterable?: Iterable<readonly [string, Value]>);
+    /**
+     * Returns a plain object with the same key-value pairs as this map.
+     *
+     * Example:
+     *
+     * ```ts
+     * const items = [
+     *   ['foo', { snapId: '1', name: 'foo' }],
+     *   ['bar', { snapId: '1', name: 'bar' }],
+     * ];
+     * const map = new SnapIdMap(items);
+     * map.toObject();
+     * // Returns
+     * // {
+     * //   foo: { snapId: '1', name: 'foo' },
+     * //   bar: { snapId: '1', name: 'bar' },
+     * // }
+     * ```
+     *
+     * @returns A plain object with the same key-value pairs as this map.
+     */
+    toObject(): Record<string, Value>;
+    /**
+     * Returns a new `SnapIdMap` object from an plain object.
+     *
+     * Example:
+     *
+     * ```ts
+     * const obj = {
+     *   foo: { snapId: '1', name: 'foo' },
+     *   bar: { snapId: '1', name: 'bar' },
+     * };
+     * const map = SnapIdMap.fromObject(obj);
+     * ```
+     *
+     * @param obj - A plain object whose elements will be added to the new map.
+     * @returns A new `SnapIdMap` containing the elements of the given object.
+     */
+    static fromObject<Value extends {
+        snapId: SnapId;
+    }>(obj: Record<string, Value>): SnapIdMap<Value>;
+    /**
+     * Gets a value from the map.
+     *
+     * If the given key is not present in the map or the Snap ID of the value is
+     * different from the given Snap ID, returns `undefined`.
+     *
+     * Example:
+     *
+     * ```ts
+     * const map = new SnapIdMap();
+     * map.set('foo', { snapId: '1', name: 'foo' });
+     * map.get('1', 'foo'); // Returns { snapId: '1', name: 'foo' }
+     * map.get('2', 'foo'); // Returns `undefined`
+     * map.get('1', 'bar'); // Returns `undefined`
+     * ```
+     *
+     * @param snapId - Snap ID present in the value to get.
+     * @param key - Key of the element to get.
+     * @returns The value associated with the given key and Snap ID.
+     */
+    get(snapId: SnapId, key: string): Value | undefined;
+    /**
+     * Checks if a key is present in the map.
+     *
+     * If the given key is not present in the map or the Snap ID of the value is
+     * different from the given Snap ID, returns `false`.
+     *
+     * Example:
+     *
+     * ```ts
+     * const map = new SnapIdMap();
+     * map.set('foo', { snapId: '1', name: 'foo' });
+     * map.has('1', 'foo'); // Returns `true`
+     * map.has('2', 'foo'); // Returns `false`
+     * map.has('1', 'bar'); // Returns `false`
+     * ```
+     *
+     * @param snapId - Snap ID present in the value to check.
+     * @param key - Key of the element to check.
+     * @returns `true` if the key is present in the map and the Snap ID of the
+     * value is equal to the given Snap ID, `false` otherwise.
+     */
+    has(snapId: SnapId, key: string): boolean;
+    /**
+     * Deletes a key from the map.
+     *
+     * If the given key is not present in the map or the Snap IDs don't match,
+     * returns `false` and does nothing.
+     *
+     * Example:
+     *
+     * ```ts
+     * const map = new SnapIdMap();
+     * map.set('foo', { snapId: '1', name: 'foo' });
+     * map.delete('2', 'foo'); // Returns `false`
+     * map.delete('1', 'bar'); // Returns `false`
+     * map.delete('1', 'foo'); // Returns `true`
+     * ```
+     *
+     * @param snapId - Snap ID present in the value to delete.
+     * @param key - Key of the element to delete.
+     * @returns `true` if the key was present in the map and the Snap ID of the
+     * value was equal to the given Snap ID, `false` otherwise.
+     */
+    delete(snapId: SnapId, key: string): boolean;
+    /**
+     * Adds or updates a key-value pair in the map.
+     *
+     * Note that this method has a different behavior from the `Map.set`.
+     *
+     * - If the given key is not already present in the map, this method adds the
+     *   key-value pair to the map.
+     *
+     * - If the given key is already present in the map and the Snap IDs match,
+     *   this method updates the value associated with the key.
+     *
+     * - However, if the given key is already present in the map but the Snap IDs
+     *   do not match, this method throws an error.
+     *
+     * @param key - Key of the element to add or update.
+     * @param value - Value of the element to add or update.
+     * @returns The map itself.
+     */
+    set(key: string, value: Value): this;
+    /**
+     * Returns an iterable of the values in the map.
+     *
+     * Example:
+     *
+     * ```ts
+     * const map = new SnapIdMap([
+     *   ['foo', { snapId: '1', name: 'foo' }],
+     *   ['bar', { snapId: '1', name: 'bar' }],
+     * ]);
+     * const values = [...map.values()];
+     * // Returns
+     * // [
+     * //   { snapId: '1', name: 'foo' },
+     * //   { snapId: '1', name: 'bar' },
+     * // ]
+     * ```
+     *
+     * @returns An iterable of the values in the map.
+     */
+    values(): IterableIterator<Value>;
+    /**
+     * Returns the number of key-value pairs in the map.
+     *
+     * @returns The number of key-value pairs in the map.
+     */
+    get size(): number;
+}

package/dist/SnapIdMap.js

@@ -0,0 +1,242 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SnapIdMap_map;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapIdMap = exports.InvalidSnapIdError = void 0;
+const CaseInsensitiveMap_1 = require("./CaseInsensitiveMap");
+/**
+ * Error thrown when an invalid Snap ID is encountered.
+ */
+class InvalidSnapIdError extends Error {
+    /**
+     * Creates an instance of `InvalidSnapIdError`.
+     *
+     * @param snapId - The invalid Snap ID.
+     * @param key - The key associated with the invalid Snap ID.
+     */
+    constructor(snapId, key) {
+        super(`Snap "${snapId}" is not allowed to set "${key}"`);
+        this.name = 'InvalidSnapIdError';
+        this.snapId = snapId;
+        this.key = key;
+    }
+}
+exports.InvalidSnapIdError = InvalidSnapIdError;
+/**
+ * A map that associates a string key with a value that has a `snapId`
+ * property. Note that the key is case-insensitive.
+ *
+ * The `snapId` property is used to ensure that only the Snap that added an
+ * item to the map can modify or delete it.
+ */
+class SnapIdMap {
+    /**
+     * Creates a new `SnapIdMap` object.
+     *
+     * Example:
+     *
+     * ```ts
+     * const items = [
+     *   ['foo', { snapId: '1', name: 'foo' }],
+     *   ['bar', { snapId: '1', name: 'bar' }],
+     * ];
+     * const map = new SnapIdMap(items);
+     * ```
+     *
+     * @param iterable - An iterable object whose elements are key-value pairs.
+     * Each key-value pair will be added to the new map.
+     */
+    constructor(iterable) {
+        _SnapIdMap_map.set(this, void 0);
+        __classPrivateFieldSet(this, _SnapIdMap_map, new CaseInsensitiveMap_1.CaseInsensitiveMap(iterable), "f");
+    }
+    /**
+     * Returns a plain object with the same key-value pairs as this map.
+     *
+     * Example:
+     *
+     * ```ts
+     * const items = [
+     *   ['foo', { snapId: '1', name: 'foo' }],
+     *   ['bar', { snapId: '1', name: 'bar' }],
+     * ];
+     * const map = new SnapIdMap(items);
+     * map.toObject();
+     * // Returns
+     * // {
+     * //   foo: { snapId: '1', name: 'foo' },
+     * //   bar: { snapId: '1', name: 'bar' },
+     * // }
+     * ```
+     *
+     * @returns A plain object with the same key-value pairs as this map.
+     */
+    toObject() {
+        return __classPrivateFieldGet(this, _SnapIdMap_map, "f").toObject();
+    }
+    /**
+     * Returns a new `SnapIdMap` object from an plain object.
+     *
+     * Example:
+     *
+     * ```ts
+     * const obj = {
+     *   foo: { snapId: '1', name: 'foo' },
+     *   bar: { snapId: '1', name: 'bar' },
+     * };
+     * const map = SnapIdMap.fromObject(obj);
+     * ```
+     *
+     * @param obj - A plain object whose elements will be added to the new map.
+     * @returns A new `SnapIdMap` containing the elements of the given object.
+     */
+    static fromObject(obj) {
+        return new SnapIdMap(Object.entries(obj));
+    }
+    /**
+     * Gets a value from the map.
+     *
+     * If the given key is not present in the map or the Snap ID of the value is
+     * different from the given Snap ID, returns `undefined`.
+     *
+     * Example:
+     *
+     * ```ts
+     * const map = new SnapIdMap();
+     * map.set('foo', { snapId: '1', name: 'foo' });
+     * map.get('1', 'foo'); // Returns { snapId: '1', name: 'foo' }
+     * map.get('2', 'foo'); // Returns `undefined`
+     * map.get('1', 'bar'); // Returns `undefined`
+     * ```
+     *
+     * @param snapId - Snap ID present in the value to get.
+     * @param key - Key of the element to get.
+     * @returns The value associated with the given key and Snap ID.
+     */
+    get(snapId, key) {
+        const value = __classPrivateFieldGet(this, _SnapIdMap_map, "f").get(key);
+        return value?.snapId === snapId ? value : undefined;
+    }
+    /**
+     * Checks if a key is present in the map.
+     *
+     * If the given key is not present in the map or the Snap ID of the value is
+     * different from the given Snap ID, returns `false`.
+     *
+     * Example:
+     *
+     * ```ts
+     * const map = new SnapIdMap();
+     * map.set('foo', { snapId: '1', name: 'foo' });
+     * map.has('1', 'foo'); // Returns `true`
+     * map.has('2', 'foo'); // Returns `false`
+     * map.has('1', 'bar'); // Returns `false`
+     * ```
+     *
+     * @param snapId - Snap ID present in the value to check.
+     * @param key - Key of the element to check.
+     * @returns `true` if the key is present in the map and the Snap ID of the
+     * value is equal to the given Snap ID, `false` otherwise.
+     */
+    has(snapId, key) {
+        return this.get(snapId, key) !== undefined;
+    }
+    /**
+     * Deletes a key from the map.
+     *
+     * If the given key is not present in the map or the Snap IDs don't match,
+     * returns `false` and does nothing.
+     *
+     * Example:
+     *
+     * ```ts
+     * const map = new SnapIdMap();
+     * map.set('foo', { snapId: '1', name: 'foo' });
+     * map.delete('2', 'foo'); // Returns `false`
+     * map.delete('1', 'bar'); // Returns `false`
+     * map.delete('1', 'foo'); // Returns `true`
+     * ```
+     *
+     * @param snapId - Snap ID present in the value to delete.
+     * @param key - Key of the element to delete.
+     * @returns `true` if the key was present in the map and the Snap ID of the
+     * value was equal to the given Snap ID, `false` otherwise.
+     */
+    delete(snapId, key) {
+        return this.has(snapId, key) && __classPrivateFieldGet(this, _SnapIdMap_map, "f").delete(key);
+    }
+    /* eslint-disable jsdoc/check-indentation */
+    /**
+     * Adds or updates a key-value pair in the map.
+     *
+     * Note that this method has a different behavior from the `Map.set`.
+     *
+     * - If the given key is not already present in the map, this method adds the
+     *   key-value pair to the map.
+     *
+     * - If the given key is already present in the map and the Snap IDs match,
+     *   this method updates the value associated with the key.
+     *
+     * - However, if the given key is already present in the map but the Snap IDs
+     *   do not match, this method throws an error.
+     *
+     * @param key - Key of the element to add or update.
+     * @param value - Value of the element to add or update.
+     * @returns The map itself.
+     */
+    /* eslint-enable jsdoc/check-indentation */
+    set(key, value) {
+        // If the key is present in the map but isn't associated with the given
+        // Snap ID, it means that the item was added to the map by a different
+        // Snap. In this case, throw an error.
+        if (__classPrivateFieldGet(this, _SnapIdMap_map, "f").has(key) && !this.has(value.snapId, key)) {
+            throw new InvalidSnapIdError(value.snapId, key);
+        }
+        __classPrivateFieldGet(this, _SnapIdMap_map, "f").set(key, value);
+        return this;
+    }
+    /**
+     * Returns an iterable of the values in the map.
+     *
+     * Example:
+     *
+     * ```ts
+     * const map = new SnapIdMap([
+     *   ['foo', { snapId: '1', name: 'foo' }],
+     *   ['bar', { snapId: '1', name: 'bar' }],
+     * ]);
+     * const values = [...map.values()];
+     * // Returns
+     * // [
+     * //   { snapId: '1', name: 'foo' },
+     * //   { snapId: '1', name: 'bar' },
+     * // ]
+     * ```
+     *
+     * @returns An iterable of the values in the map.
+     */
+    values() {
+        return __classPrivateFieldGet(this, _SnapIdMap_map, "f").values();
+    }
+    /**
+     * Returns the number of key-value pairs in the map.
+     *
+     * @returns The number of key-value pairs in the map.
+     */
+    get size() {
+        return __classPrivateFieldGet(this, _SnapIdMap_map, "f").size;
+    }
+}
+exports.SnapIdMap = SnapIdMap;
+_SnapIdMap_map = new WeakMap();
+//# sourceMappingURL=SnapIdMap.js.map

package/dist/SnapIdMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SnapIdMap.js","sourceRoot":"","sources":["../src/SnapIdMap.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAEA,6DAA0D;AAE1D;;GAEG;AACH,MAAa,kBAAmB,SAAQ,KAAK;IAW3C;;;;;OAKG;IACH,YAAY,MAAc,EAAE,GAAW;QACrC,KAAK,CAAC,SAAS,MAAM,4BAA4B,GAAG,GAAG,CAAC,CAAC;QACzD,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACjC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;CACF;AAvBD,gDAuBC;AAED;;;;;;GAMG;AACH,MAAa,SAAS;IAGpB;;;;;;;;;;;;;;;OAeG;IACH,YAAY,QAA6C;QAlBzD,iCAAgC;QAmB9B,uBAAA,IAAI,kBAAQ,IAAI,uCAAkB,CAAC,QAAQ,CAAC,MAAA,CAAC;IAC/C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ;QACN,OAAO,uBAAA,IAAI,sBAAK,CAAC,QAAQ,EAAE,CAAC;IAC9B,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,UAAU,CACf,GAA0B;QAE1B,OAAO,IAAI,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG,CAAC,MAAc,EAAE,GAAW;QAC7B,MAAM,KAAK,GAAG,uBAAA,IAAI,sBAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjC,OAAO,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACtD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,GAAG,CAAC,MAAc,EAAE,GAAW;QAC7B,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,SAAS,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,MAAc,EAAE,GAAW;QAChC,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,uBAAA,IAAI,sBAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACxD,CAAC;IAED,4CAA4C;IAC5C;;;;;;;;;;;;;;;;;OAiBG;IACH,2CAA2C;IAC3C,GAAG,CAAC,GAAW,EAAE,KAAY;QAC3B,uEAAuE;QACvE,sEAAsE;QACtE,sCAAsC;QACtC,IAAI,uBAAA,IAAI,sBAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE;YACtD,MAAM,IAAI,kBAAkB,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;SACjD;QACD,uBAAA,IAAI,sBAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM;QACJ,OAAO,uBAAA,IAAI,sBAAK,CAAC,MAAM,EAAE,CAAC;IAC5B,CAAC;IAED;;;;OAIG;IACH,IAAI,IAAI;QACN,OAAO,uBAAA,IAAI,sBAAK,CAAC,IAAI,CAAC;IACxB,CAAC;CACF;AAhND,8BAgNC","sourcesContent":["import type { SnapId } from '@metamask/snaps-sdk';\n\nimport { CaseInsensitiveMap } from './CaseInsensitiveMap';\n\n/**\n * Error thrown when an invalid Snap ID is encountered.\n */\nexport class InvalidSnapIdError extends Error {\n  /**\n   * The ID of the Snap that caused the error.\n   */\n  snapId: SnapId;\n\n  /**\n   * The key of the element that caused the error.\n   */\n  key: string;\n\n  /**\n   * Creates an instance of `InvalidSnapIdError`.\n   *\n   * @param snapId - The invalid Snap ID.\n   * @param key - The key associated with the invalid Snap ID.\n   */\n  constructor(snapId: SnapId, key: string) {\n    super(`Snap \"${snapId}\" is not allowed to set \"${key}\"`);\n    this.name = 'InvalidSnapIdError';\n    this.snapId = snapId;\n    this.key = key;\n  }\n}\n\n/**\n * A map that associates a string key with a value that has a `snapId`\n * property. Note that the key is case-insensitive.\n *\n * The `snapId` property is used to ensure that only the Snap that added an\n * item to the map can modify or delete it.\n */\nexport class SnapIdMap<Value extends { snapId: SnapId }> {\n  #map: CaseInsensitiveMap<Value>;\n\n  /**\n   * Creates a new `SnapIdMap` object.\n   *\n   * Example:\n   *\n   * ```ts\n   * const items = [\n   *   ['foo', { snapId: '1', name: 'foo' }],\n   *   ['bar', { snapId: '1', name: 'bar' }],\n   * ];\n   * const map = new SnapIdMap(items);\n   * ```\n   *\n   * @param iterable - An iterable object whose elements are key-value pairs.\n   * Each key-value pair will be added to the new map.\n   */\n  constructor(iterable?: Iterable<readonly [string, Value]>) {\n    this.#map = new CaseInsensitiveMap(iterable);\n  }\n\n  /**\n   * Returns a plain object with the same key-value pairs as this map.\n   *\n   * Example:\n   *\n   * ```ts\n   * const items = [\n   *   ['foo', { snapId: '1', name: 'foo' }],\n   *   ['bar', { snapId: '1', name: 'bar' }],\n   * ];\n   * const map = new SnapIdMap(items);\n   * map.toObject();\n   * // Returns\n   * // {\n   * //   foo: { snapId: '1', name: 'foo' },\n   * //   bar: { snapId: '1', name: 'bar' },\n   * // }\n   * ```\n   *\n   * @returns A plain object with the same key-value pairs as this map.\n   */\n  toObject(): Record<string, Value> {\n    return this.#map.toObject();\n  }\n\n  /**\n   * Returns a new `SnapIdMap` object from an plain object.\n   *\n   * Example:\n   *\n   * ```ts\n   * const obj = {\n   *   foo: { snapId: '1', name: 'foo' },\n   *   bar: { snapId: '1', name: 'bar' },\n   * };\n   * const map = SnapIdMap.fromObject(obj);\n   * ```\n   *\n   * @param obj - A plain object whose elements will be added to the new map.\n   * @returns A new `SnapIdMap` containing the elements of the given object.\n   */\n  static fromObject<Value extends { snapId: SnapId }>(\n    obj: Record<string, Value>,\n  ): SnapIdMap<Value> {\n    return new SnapIdMap(Object.entries(obj));\n  }\n\n  /**\n   * Gets a value from the map.\n   *\n   * If the given key is not present in the map or the Snap ID of the value is\n   * different from the given Snap ID, returns `undefined`.\n   *\n   * Example:\n   *\n   * ```ts\n   * const map = new SnapIdMap();\n   * map.set('foo', { snapId: '1', name: 'foo' });\n   * map.get('1', 'foo'); // Returns { snapId: '1', name: 'foo' }\n   * map.get('2', 'foo'); // Returns `undefined`\n   * map.get('1', 'bar'); // Returns `undefined`\n   * ```\n   *\n   * @param snapId - Snap ID present in the value to get.\n   * @param key - Key of the element to get.\n   * @returns The value associated with the given key and Snap ID.\n   */\n  get(snapId: SnapId, key: string): Value | undefined {\n    const value = this.#map.get(key);\n    return value?.snapId === snapId ? value : undefined;\n  }\n\n  /**\n   * Checks if a key is present in the map.\n   *\n   * If the given key is not present in the map or the Snap ID of the value is\n   * different from the given Snap ID, returns `false`.\n   *\n   * Example:\n   *\n   * ```ts\n   * const map = new SnapIdMap();\n   * map.set('foo', { snapId: '1', name: 'foo' });\n   * map.has('1', 'foo'); // Returns `true`\n   * map.has('2', 'foo'); // Returns `false`\n   * map.has('1', 'bar'); // Returns `false`\n   * ```\n   *\n   * @param snapId - Snap ID present in the value to check.\n   * @param key - Key of the element to check.\n   * @returns `true` if the key is present in the map and the Snap ID of the\n   * value is equal to the given Snap ID, `false` otherwise.\n   */\n  has(snapId: SnapId, key: string): boolean {\n    return this.get(snapId, key) !== undefined;\n  }\n\n  /**\n   * Deletes a key from the map.\n   *\n   * If the given key is not present in the map or the Snap IDs don't match,\n   * returns `false` and does nothing.\n   *\n   * Example:\n   *\n   * ```ts\n   * const map = new SnapIdMap();\n   * map.set('foo', { snapId: '1', name: 'foo' });\n   * map.delete('2', 'foo'); // Returns `false`\n   * map.delete('1', 'bar'); // Returns `false`\n   * map.delete('1', 'foo'); // Returns `true`\n   * ```\n   *\n   * @param snapId - Snap ID present in the value to delete.\n   * @param key - Key of the element to delete.\n   * @returns `true` if the key was present in the map and the Snap ID of the\n   * value was equal to the given Snap ID, `false` otherwise.\n   */\n  delete(snapId: SnapId, key: string): boolean {\n    return this.has(snapId, key) && this.#map.delete(key);\n  }\n\n  /* eslint-disable jsdoc/check-indentation */\n  /**\n   * Adds or updates a key-value pair in the map.\n   *\n   * Note that this method has a different behavior from the `Map.set`.\n   *\n   * - If the given key is not already present in the map, this method adds the\n   *   key-value pair to the map.\n   *\n   * - If the given key is already present in the map and the Snap IDs match,\n   *   this method updates the value associated with the key.\n   *\n   * - However, if the given key is already present in the map but the Snap IDs\n   *   do not match, this method throws an error.\n   *\n   * @param key - Key of the element to add or update.\n   * @param value - Value of the element to add or update.\n   * @returns The map itself.\n   */\n  /* eslint-enable jsdoc/check-indentation */\n  set(key: string, value: Value): this {\n    // If the key is present in the map but isn't associated with the given\n    // Snap ID, it means that the item was added to the map by a different\n    // Snap. In this case, throw an error.\n    if (this.#map.has(key) && !this.has(value.snapId, key)) {\n      throw new InvalidSnapIdError(value.snapId, key);\n    }\n    this.#map.set(key, value);\n    return this;\n  }\n\n  /**\n   * Returns an iterable of the values in the map.\n   *\n   * Example:\n   *\n   * ```ts\n   * const map = new SnapIdMap([\n   *   ['foo', { snapId: '1', name: 'foo' }],\n   *   ['bar', { snapId: '1', name: 'bar' }],\n   * ]);\n   * const values = [...map.values()];\n   * // Returns\n   * // [\n   * //   { snapId: '1', name: 'foo' },\n   * //   { snapId: '1', name: 'bar' },\n   * // ]\n   * ```\n   *\n   * @returns An iterable of the values in the map.\n   */\n  values(): IterableIterator<Value> {\n    return this.#map.values();\n  }\n\n  /**\n   * Returns the number of key-value pairs in the map.\n   *\n   * @returns The number of key-value pairs in the map.\n   */\n  get size(): number {\n    return this.#map.size;\n  }\n}\n"]}

package/dist/SnapKeyring.d.ts

@@ -0,0 +1,182 @@
+/// <reference types="node" />
+import type { TypedTransaction } from '@ethereumjs/tx';
+import type { TypedDataV1, TypedMessage } from '@metamask/eth-sig-util';
+import { SignTypedDataVersion } from '@metamask/eth-sig-util';
+import type { KeyringAccount, KeyringExecutionContext } from '@metamask/keyring-api';
+import type { EthBaseTransaction, EthBaseUserOperation, EthUserOperation, EthUserOperationPatch, InternalAccount } from '@metamask/keyring-internal-api';
+import type { SnapController } from '@metamask/snaps-controllers';
+import type { SnapId } from '@metamask/snaps-sdk';
+import type { Json } from '@metamask/utils';
+import { EventEmitter } from 'events';
+import type { SnapMessage } from './types';
+export declare const SNAP_KEYRING_TYPE = "Snap Keyring";
+/**
+ * Snap keyring state.
+ *
+ * This state is persisted by the keyring controller and passed to the Snap
+ * keyring when it's created.
+ */
+export declare type KeyringState = {
+    accounts: Record<string, {
+        account: KeyringAccount;
+        snapId: SnapId;
+    }>;
+};
+/**
+ * Snap keyring callbacks.
+ *
+ * These callbacks are used to interact with other components.
+ */
+export declare type SnapKeyringCallbacks = {
+    saveState: () => Promise<void>;
+    addressExists(address: string): Promise<boolean>;
+    addAccount(address: string, snapId: SnapId, handleUserInput: (accepted: boolean) => Promise<void>, accountNameSuggestion?: string, displayConfirmation?: boolean): Promise<void>;
+    removeAccount(address: string, snapId: SnapId, handleUserInput: (accepted: boolean) => Promise<void>): Promise<void>;
+    redirectUser(snapId: SnapId, url: string, message: string): Promise<void>;
+};
+/**
+ * Keyring bridge implementation to support Snaps.
+ */
+export declare class SnapKeyring extends EventEmitter {
+    #private;
+    static type: string;
+    type: string;
+    /**
+     * Create a new Snap keyring.
+     *
+     * @param controller - Snaps controller.
+     * @param callbacks - Callbacks used to interact with other components.
+     * @returns A new Snap keyring.
+     */
+    constructor(controller: SnapController, callbacks: SnapKeyringCallbacks);
+    /**
+     * Handle a message from a Snap.
+     *
+     * @param snapId - ID of the Snap.
+     * @param message - Message sent by the Snap.
+     * @returns The execution result.
+     */
+    handleKeyringSnapMessage(snapId: SnapId, message: SnapMessage): Promise<Json>;
+    /**
+     * Serialize the keyring state.
+     *
+     * @returns Serialized keyring state.
+     */
+    serialize(): Promise<KeyringState>;
+    /**
+     * Deserialize the keyring state into this keyring.
+     *
+     * @param state - Serialized keyring state.
+     */
+    deserialize(state: KeyringState | undefined): Promise<void>;
+    /**
+     * Get the addresses of the accounts in this keyring.
+     *
+     * @returns The addresses of the accounts in this keyring.
+     */
+    getAccounts(): Promise<string[]>;
+    /**
+     * Get the addresses of the accounts associated with a given Snap.
+     *
+     * @param snapId - Snap ID to filter by.
+     * @returns The addresses of the accounts associated with the given Snap.
+     */
+    getAccountsBySnapId(snapId: SnapId): Promise<string[]>;
+    /**
+     * Sign a transaction.
+     *
+     * @param address - Sender's address.
+     * @param transaction - Transaction.
+     * @param _opts - Transaction options (not used).
+     */
+    signTransaction(address: string, transaction: TypedTransaction, _opts?: {}): Promise<Json | TypedTransaction>;
+    /**
+     * Sign a typed data message.
+     *
+     * @param address - Signer's address.
+     * @param data - Data to sign.
+     * @param opts - Signing options.
+     * @returns The signature.
+     */
+    signTypedData(address: string, data: Record<string, unknown>[] | TypedDataV1 | TypedMessage<any>, opts?: {
+        version: SignTypedDataVersion;
+    }): Promise<string>;
+    /**
+     * Sign a message.
+     *
+     * @param address - Signer's address.
+     * @param hash - Data to sign.
+     * @returns The signature.
+     */
+    signMessage(address: string, hash: any): Promise<string>;
+    /**
+     * Sign a personal message.
+     *
+     * Note: KeyringController says this should return a Buffer but it actually
+     * expects a string.
+     *
+     * @param address - Signer's address.
+     * @param data - Data to sign.
+     * @returns Promise of the signature.
+     */
+    signPersonalMessage(address: string, data: any): Promise<string>;
+    /**
+     * Convert a base transaction to a base UserOperation.
+     *
+     * @param address - Address of the sender.
+     * @param transactions - Base transactions to include in the UserOperation.
+     * @param context - Keyring execution context.
+     * @returns A pseudo-UserOperation that can be used to construct a real.
+     */
+    prepareUserOperation(address: string, transactions: EthBaseTransaction[], context: KeyringExecutionContext): Promise<EthBaseUserOperation>;
+    /**
+     * Patches properties of a UserOperation. Currently, only the
+     * `paymasterAndData` can be patched.
+     *
+     * @param address - Address of the sender.
+     * @param userOp - UserOperation to patch.
+     * @param context - Keyring execution context.
+     * @returns A patch to apply to the UserOperation.
+     */
+    patchUserOperation(address: string, userOp: EthUserOperation, context: KeyringExecutionContext): Promise<EthUserOperationPatch>;
+    /**
+     * Signs an UserOperation.
+     *
+     * @param address - Address of the sender.
+     * @param userOp - UserOperation to sign.
+     * @param context - Leyring execution context.
+     * @returns The signature of the UserOperation.
+     */
+    signUserOperation(address: string, userOp: EthUserOperation, context: KeyringExecutionContext): Promise<string>;
+    /**
+     * Gets the private data associated with the given address so
+     * that it may be exported.
+     *
+     * If this keyring contains duplicate public keys the first
+     * matching address is exported.
+     *
+     * Used by the UI to export an account.
+     *
+     * @param _address - Address of the account to export.
+     */
+    exportAccount(_address: string): [Uint8Array, Json] | undefined;
+    /**
+     * Removes the account matching the given address.
+     *
+     * @param address - Address of the account to remove.
+     */
+    removeAccount(address: string): Promise<void>;
+    /**
+     * Return an internal account object for a given address.
+     *
+     * @param address - Address of the account to return.
+     * @returns An internal account object for the given address.
+     */
+    getAccountByAddress(address: string): InternalAccount | undefined;
+    /**
+     * List all Snap keyring accounts.
+     *
+     * @returns An array containing all Snap keyring accounts.
+     */
+    listAccounts(): InternalAccount[];
+}