@metamask-previews/eth-snap-keyring 12.0.0-cfe31db → 12.1.0-24dfaca

package/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [12.1.0]
+
+### Added
+
+- Add new concept of "internal options" and add a new `SnapKeyring.createAccount` method ([#252](https://github.com/MetaMask/accounts/pull/252)), ([#261](https://github.com/MetaMask/accounts/pull/261))
+  - Those internal options can be used by the caller of that method to customize the account creation flow.
+- Add `setSelectedAccount` internal option ([#257](https://github.com/MetaMask/accounts/pull/257))
+
 ## [12.0.0]
 
 ### Changed
@@ -490,7 +498,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release.
 
-[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@12.0.0...HEAD
+[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@12.1.0...HEAD
+[12.1.0]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@12.0.0...@metamask/eth-snap-keyring@12.1.0
 [12.0.0]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@11.1.0...@metamask/eth-snap-keyring@12.0.0
 [11.1.0]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@11.0.0...@metamask/eth-snap-keyring@11.1.0
 [11.0.0]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@10.0.0...@metamask/eth-snap-keyring@11.0.0

package/dist/SnapIdMap.cjs

@@ -127,6 +127,31 @@ class SnapIdMap {
         const value = __classPrivateFieldGet(this, _SnapIdMap_map, "f").get(key);
         return value?.snapId === snapId ? value : undefined;
     }
+    /**
+     * Gets and delete 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.pop('1', 'foo'); // Returns { snapId: '1', name: 'foo' }
+     * map.pop('1', 'foo'); // Returns `undefined` (already returned and deleted)
+     * map.pop('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.
+     */
+    pop(snapId, key) {
+        const value = this.get(snapId, key);
+        this.delete(snapId, key);
+        return value;
+    }
     /**
      * Checks if a key is present in the map.
      *

package/dist/SnapIdMap.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"SnapIdMap.cjs","sourceRoot":"","sources":["../src/SnapIdMap.ts"],"names":[],"mappings":"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","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  readonly #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   * Checks if a snap ID exists in the map.\n   *\n   * @param snapId - Snap ID present in the value to check.\n   * @returns `true` if the snap ID is present in the map, `false` otherwise.\n   */\n  hasSnapId(snapId: SnapId): boolean {\n    // We could use a reverse-mapping to map Snap ID to their actual key too, but\n    // for now, this will do the trick.\n    return [...this.#map.values()].some((value) => value.snapId === snapId);\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"]}
+{"version":3,"file":"SnapIdMap.cjs","sourceRoot":"","sources":["../src/SnapIdMap.ts"],"names":[],"mappings":"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","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  readonly #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   * Gets and delete 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.pop('1', 'foo'); // Returns { snapId: '1', name: 'foo' }\n   * map.pop('1', 'foo'); // Returns `undefined` (already returned and deleted)\n   * map.pop('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  pop(snapId: SnapId, key: string): Value | undefined {\n    const value = this.get(snapId, key);\n    this.delete(snapId, key);\n    return value;\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   * Checks if a snap ID exists in the map.\n   *\n   * @param snapId - Snap ID present in the value to check.\n   * @returns `true` if the snap ID is present in the map, `false` otherwise.\n   */\n  hasSnapId(snapId: SnapId): boolean {\n    // We could use a reverse-mapping to map Snap ID to their actual key too, but\n    // for now, this will do the trick.\n    return [...this.#map.values()].some((value) => value.snapId === snapId);\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/SnapIdMap.d.cts

@@ -109,6 +109,27 @@ export declare class SnapIdMap<Value extends {
      * @returns The value associated with the given key and Snap ID.
      */
     get(snapId: SnapId, key: string): Value | undefined;
+    /**
+     * Gets and delete 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.pop('1', 'foo'); // Returns { snapId: '1', name: 'foo' }
+     * map.pop('1', 'foo'); // Returns `undefined` (already returned and deleted)
+     * map.pop('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.
+     */
+    pop(snapId: SnapId, key: string): Value | undefined;
     /**
      * Checks if a key is present in the map.
      *

package/dist/SnapIdMap.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"SnapIdMap.d.cts","sourceRoot":"","sources":["../src/SnapIdMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,4BAA4B;AAIlD;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;;;;OAKG;gBACS,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;CAMxC;AAED;;;;;;GAMG;AACH,qBAAa,SAAS,CAAC,KAAK,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE;;IAGrD;;;;;;;;;;;;;;;OAeG;gBACS,QAAQ,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAIzD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAIjC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,UAAU,CAAC,KAAK,SAAS;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,EAChD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GACzB,SAAS,CAAC,KAAK,CAAC;IAInB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAKnD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzC;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAMlC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAK5C;;;;;;;;;;;;;;;;;OAiBG;IAEH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAWpC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,IAAI,gBAAgB,CAAC,KAAK,CAAC;IAIjC;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}
+{"version":3,"file":"SnapIdMap.d.cts","sourceRoot":"","sources":["../src/SnapIdMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,4BAA4B;AAIlD;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;;;;OAKG;gBACS,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;CAMxC;AAED;;;;;;GAMG;AACH,qBAAa,SAAS,CAAC,KAAK,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE;;IAGrD;;;;;;;;;;;;;;;OAeG;gBACS,QAAQ,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAIzD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAIjC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,UAAU,CAAC,KAAK,SAAS;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,EAChD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GACzB,SAAS,CAAC,KAAK,CAAC;IAInB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAKnD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAMnD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzC;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAMlC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAK5C;;;;;;;;;;;;;;;;;OAiBG;IAEH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAWpC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,IAAI,gBAAgB,CAAC,KAAK,CAAC;IAIjC;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/SnapIdMap.d.mts

@@ -109,6 +109,27 @@ export declare class SnapIdMap<Value extends {
      * @returns The value associated with the given key and Snap ID.
      */
     get(snapId: SnapId, key: string): Value | undefined;
+    /**
+     * Gets and delete 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.pop('1', 'foo'); // Returns { snapId: '1', name: 'foo' }
+     * map.pop('1', 'foo'); // Returns `undefined` (already returned and deleted)
+     * map.pop('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.
+     */
+    pop(snapId: SnapId, key: string): Value | undefined;
     /**
      * Checks if a key is present in the map.
      *

package/dist/SnapIdMap.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"SnapIdMap.d.mts","sourceRoot":"","sources":["../src/SnapIdMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,4BAA4B;AAIlD;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;;;;OAKG;gBACS,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;CAMxC;AAED;;;;;;GAMG;AACH,qBAAa,SAAS,CAAC,KAAK,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE;;IAGrD;;;;;;;;;;;;;;;OAeG;gBACS,QAAQ,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAIzD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAIjC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,UAAU,CAAC,KAAK,SAAS;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,EAChD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GACzB,SAAS,CAAC,KAAK,CAAC;IAInB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAKnD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzC;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAMlC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAK5C;;;;;;;;;;;;;;;;;OAiBG;IAEH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAWpC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,IAAI,gBAAgB,CAAC,KAAK,CAAC;IAIjC;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}
+{"version":3,"file":"SnapIdMap.d.mts","sourceRoot":"","sources":["../src/SnapIdMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,4BAA4B;AAIlD;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;;;;OAKG;gBACS,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;CAMxC;AAED;;;;;;GAMG;AACH,qBAAa,SAAS,CAAC,KAAK,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE;;IAGrD;;;;;;;;;;;;;;;OAeG;gBACS,QAAQ,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAIzD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAIjC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,UAAU,CAAC,KAAK,SAAS;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,EAChD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GACzB,SAAS,CAAC,KAAK,CAAC;IAInB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAKnD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAMnD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzC;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAMlC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAK5C;;;;;;;;;;;;;;;;;OAiBG;IAEH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAWpC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,IAAI,gBAAgB,CAAC,KAAK,CAAC;IAIjC;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/SnapIdMap.mjs

@@ -123,6 +123,31 @@ export class SnapIdMap {
         const value = __classPrivateFieldGet(this, _SnapIdMap_map, "f").get(key);
         return value?.snapId === snapId ? value : undefined;
     }
+    /**
+     * Gets and delete 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.pop('1', 'foo'); // Returns { snapId: '1', name: 'foo' }
+     * map.pop('1', 'foo'); // Returns `undefined` (already returned and deleted)
+     * map.pop('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.
+     */
+    pop(snapId, key) {
+        const value = this.get(snapId, key);
+        this.delete(snapId, key);
+        return value;
+    }
     /**
      * Checks if a key is present in the map.
      *

package/dist/SnapIdMap.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"SnapIdMap.mjs","sourceRoot":"","sources":["../src/SnapIdMap.ts"],"names":[],"mappings":"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","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  readonly #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   * Checks if a snap ID exists in the map.\n   *\n   * @param snapId - Snap ID present in the value to check.\n   * @returns `true` if the snap ID is present in the map, `false` otherwise.\n   */\n  hasSnapId(snapId: SnapId): boolean {\n    // We could use a reverse-mapping to map Snap ID to their actual key too, but\n    // for now, this will do the trick.\n    return [...this.#map.values()].some((value) => value.snapId === snapId);\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"]}
+{"version":3,"file":"SnapIdMap.mjs","sourceRoot":"","sources":["../src/SnapIdMap.ts"],"names":[],"mappings":"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","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  readonly #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   * Gets and delete 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.pop('1', 'foo'); // Returns { snapId: '1', name: 'foo' }\n   * map.pop('1', 'foo'); // Returns `undefined` (already returned and deleted)\n   * map.pop('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  pop(snapId: SnapId, key: string): Value | undefined {\n    const value = this.get(snapId, key);\n    this.delete(snapId, key);\n    return value;\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   * Checks if a snap ID exists in the map.\n   *\n   * @param snapId - Snap ID present in the value to check.\n   * @returns `true` if the snap ID is present in the map, `false` otherwise.\n   */\n  hasSnapId(snapId: SnapId): boolean {\n    // We could use a reverse-mapping to map Snap ID to their actual key too, but\n    // for now, this will do the trick.\n    return [...this.#map.values()].some((value) => value.snapId === snapId);\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.cjs

@@ -13,7 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _SnapKeyring_instances, _SnapKeyring_messenger, _SnapKeyring_snapClient, _SnapKeyring_accounts, _SnapKeyring_requests, _SnapKeyring_callbacks, _SnapKeyring_handleAccountCreated, _SnapKeyring_handleAccountUpdated, _SnapKeyring_handleAccountDeleted, _SnapKeyring_handleRequestApproved, _SnapKeyring_handleRequestRejected, _SnapKeyring_rePublishAccountEvent, _SnapKeyring_filterAccountEventEntries, _SnapKeyring_handleAccountBalancesUpdated, _SnapKeyring_handleAccountAssetListUpdated, _SnapKeyring_handleAccountTransactionsUpdated, _SnapKeyring_getAccount, _SnapKeyring_submitRequest, _SnapKeyring_submitSnapRequest, _SnapKeyring_hasMethod, _SnapKeyring_createRequestPromise, _SnapKeyring_clearRequestPromise, _SnapKeyring_handleSyncResponse, _SnapKeyring_handleAsyncResponse, _SnapKeyring_sanitizeRedirectUrl, _SnapKeyring_validateRedirectUrl, _SnapKeyring_deleteAccount, _SnapKeyring_resolveAddress, _SnapKeyring_getSnap, _SnapKeyring_getSnapMetadata, _SnapKeyring_getSnapAllowedOrigins;
+var _SnapKeyring_instances, _SnapKeyring_messenger, _SnapKeyring_snapClient, _SnapKeyring_accounts, _SnapKeyring_requests, _SnapKeyring_options, _SnapKeyring_callbacks, _SnapKeyring_getInternalOptions, _SnapKeyring_handleAccountCreated, _SnapKeyring_handleAccountUpdated, _SnapKeyring_handleAccountDeleted, _SnapKeyring_handleRequestApproved, _SnapKeyring_handleRequestRejected, _SnapKeyring_rePublishAccountEvent, _SnapKeyring_handleAccountBalancesUpdated, _SnapKeyring_handleAccountAssetListUpdated, _SnapKeyring_handleAccountTransactionsUpdated, _SnapKeyring_getAccount, _SnapKeyring_submitRequest, _SnapKeyring_submitSnapRequest, _SnapKeyring_hasMethod, _SnapKeyring_createRequestPromise, _SnapKeyring_clearRequestPromise, _SnapKeyring_handleSyncResponse, _SnapKeyring_handleAsyncResponse, _SnapKeyring_sanitizeRedirectUrl, _SnapKeyring_validateRedirectUrl, _SnapKeyring_deleteAccount, _SnapKeyring_resolveAddress, _SnapKeyring_getSnap, _SnapKeyring_getSnapMetadata, _SnapKeyring_getSnapAllowedOrigins;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnapKeyring = exports.SNAP_KEYRING_TYPE = void 0;
 const tx_1 = require("@ethereumjs/tx");
@@ -30,6 +30,7 @@ const DeferredPromise_1 = require("./DeferredPromise.cjs");
 const events_2 = require("./events.cjs");
 const logger_1 = require("./logger.cjs");
 const migrations_1 = require("./migrations/index.cjs");
+const options_1 = require("./options.cjs");
 const SnapIdMap_1 = require("./SnapIdMap.cjs");
 const types_1 = require("./types.cjs");
 const util_1 = require("./util.cjs");
@@ -79,6 +80,10 @@ class SnapKeyring extends events_1.EventEmitter {
          * Mapping between request IDs and their deferred promises.
          */
         _SnapKeyring_requests.set(this, void 0);
+        /**
+         * Mapping between internal options, a correlation ID and a Snap ID.
+         */
+        _SnapKeyring_options.set(this, void 0);
         /**
          * Callbacks used to interact with other components.
          */
@@ -88,6 +93,7 @@ class SnapKeyring extends events_1.EventEmitter {
         __classPrivateFieldSet(this, _SnapKeyring_snapClient, new keyring_internal_snap_client_1.KeyringInternalSnapClient({ messenger }), "f");
         __classPrivateFieldSet(this, _SnapKeyring_requests, new SnapIdMap_1.SnapIdMap(), "f");
         __classPrivateFieldSet(this, _SnapKeyring_accounts, new SnapIdMap_1.SnapIdMap(), "f");
+        __classPrivateFieldSet(this, _SnapKeyring_options, new SnapIdMap_1.SnapIdMap(), "f");
         __classPrivateFieldSet(this, _SnapKeyring_callbacks, callbacks, "f");
     }
     /**
@@ -189,6 +195,51 @@ class SnapKeyring extends events_1.EventEmitter {
             .filter(({ snapId: accountSnapId }) => accountSnapId === snapId)
             .map(({ account }) => normalizeAccountAddress(account)));
     }
+    /**
+     * Create an account.
+     *
+     * @param snapId - Snap ID to create the account for.
+     * @param options - Account creation options. Differs between keyrings.
+     * @param internalOptions - Internal Snap keyring options.
+     * @returns The account object.
+     */
+    async createAccount(snapId, options, internalOptions) {
+        const client = new keyring_internal_snap_client_1.KeyringInternalSnapClient({
+            messenger: __classPrivateFieldGet(this, _SnapKeyring_messenger, "f"),
+            snapId,
+        });
+        // The 'metamask' field is reserved, so we have to prevent use of it on
+        // the "normal options".
+        const reserved = 'metamask';
+        if ((0, utils_1.hasProperty)(options, reserved)) {
+            throw new Error(`The '${reserved}' property is reserved for internal use`);
+        }
+        // Those internal options are optional. If not set, we avoid registering anything
+        // to internal map (to avoid holding resources for nothing). In this case, it's
+        // just a normal `keyring_createAccount`.
+        if (!internalOptions) {
+            return await client.createAccount(options);
+        }
+        // A unique ID to identify this execution flow which allows to associate the
+        // internal options and the current `keyring_createAccount` flow for that Snap.
+        const correlationId = (0, uuid_1.v4)();
+        // Register those internal options to use them during the `keyring_createAccount`
+        // flow.
+        __classPrivateFieldGet(this, _SnapKeyring_options, "f").set(correlationId, {
+            snapId,
+            options: internalOptions,
+        });
+        return await client.createAccount({
+            ...options,
+            // Create internal options context.
+            // NOTE: Those options HAVE TO be re-emitted during the `notify:accountCreated` event.
+            ...{
+                metamask: {
+                    correlationId,
+                },
+            },
+        });
+    }
     /**
      * Checks if a Snap ID is known from the keyring.
      *
@@ -459,7 +510,23 @@ class SnapKeyring extends events_1.EventEmitter {
     }
 }
 exports.SnapKeyring = SnapKeyring;
-_SnapKeyring_messenger = new WeakMap(), _SnapKeyring_snapClient = new WeakMap(), _SnapKeyring_accounts = new WeakMap(), _SnapKeyring_requests = new WeakMap(), _SnapKeyring_callbacks = new WeakMap(), _SnapKeyring_instances = new WeakSet(), _SnapKeyring_handleAccountCreated = 
+_SnapKeyring_messenger = new WeakMap(), _SnapKeyring_snapClient = new WeakMap(), _SnapKeyring_accounts = new WeakMap(), _SnapKeyring_requests = new WeakMap(), _SnapKeyring_options = new WeakMap(), _SnapKeyring_callbacks = new WeakMap(), _SnapKeyring_instances = new WeakSet(), _SnapKeyring_getInternalOptions = function _SnapKeyring_getInternalOptions(snapId, correlationId) {
+    if (correlationId) {
+        // We still need to check if the correlation ID is valid and associated to
+        // some internal options.
+        //
+        // NOTE: `found` will be `undefined` if a Snap tried to use a correlation ID that
+        // belongs to another Snap ID. However, if a Snap starts 2 parallel flow (which
+        // will results in 2 different correlation IDs), we won't be able to prevent
+        // the Snap from swapping/mixing up those correlation IDs he owns.
+        const found = __classPrivateFieldGet(this, _SnapKeyring_options, "f").pop(snapId, correlationId);
+        if (found) {
+            return found.options;
+        }
+        console.warn(`SnapKeyring - Received unmapped correlation ID: "${correlationId}"`);
+    }
+    return undefined;
+}, _SnapKeyring_handleAccountCreated = 
 /**
  * Handle an Account Created event from a Snap.
  *
@@ -469,7 +536,8 @@ _SnapKeyring_messenger = new WeakMap(), _SnapKeyring_snapClient = new WeakMap(),
  */
 async function _SnapKeyring_handleAccountCreated(snapId, message) {
     (0, superstruct_1.assert)(message, events_2.AccountCreatedEventStruct);
-    const { account: newAccountFromEvent, accountNameSuggestion, displayConfirmation, displayAccountNameSuggestion, } = message.params;
+    const { metamask, // Used for internal options.
+    account: newAccountFromEvent, accountNameSuggestion, displayAccountNameSuggestion, displayConfirmation, } = message.params;
     // READ THIS CAREFULLY:
     // ------------------------------------------------------------------------
     // The account creation flow is now asynchronous. We expect the Snap to
@@ -536,7 +604,15 @@ async function _SnapKeyring_handleAccountCreated(snapId, message) {
                 onceSaved.reject(error);
             });
         }
-    }, onceSaved.promise, accountNameSuggestion, displayConfirmation, displayAccountNameSuggestion);
+    }, onceSaved.promise, accountNameSuggestion, (0, options_1.getInternalOptionsOf)([
+        // 1. We use the internal options from the Snap keyring.
+        __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getInternalOptions).call(this, snapId, metamask?.correlationId) ?? {},
+        // 2. We use the ones coming from the Snap.
+        {
+            displayConfirmation,
+            displayAccountNameSuggestion,
+        },
+    ]));
     return null;
 }, _SnapKeyring_handleAccountUpdated = 
 /**
@@ -625,27 +701,31 @@ async function _SnapKeyring_handleRequestRejected(snapId, message) {
 /**
  * Re-publish an account event.
  *
+ * @param snapId - Snap ID.
  * @param event - The event type. This is a unique identifier for this event.
- * @param payload - The event payload. The type of the parameters for each event handler must
- * match the type of this payload.
+ * @param filteredEventCallback - A callback that returns the event to re-publish. This callback takes a filtering
+ * function as parameter that can be used to filter out account ID that do not belong to this Snap ID.
  * @template EventType - A Snap keyring event type.
  * @returns `null`.
  */
-async function _SnapKeyring_rePublishAccountEvent(event, ...payload) {
-    __classPrivateFieldGet(this, _SnapKeyring_messenger, "f").publish(event, ...payload);
+async function _SnapKeyring_rePublishAccountEvent(snapId, event, filteredEventCallback) {
+    // This callback can be used to filter out the accounts that no longer exists on the Snap (fail-safe) or to
+    // prevent other Snaps from updating accounts they do not own.
+    const filter = (accountMapping) => {
+        return Object.entries(accountMapping).reduce((filtered, [accountId, entry]) => {
+            if (__classPrivateFieldGet(this, _SnapKeyring_accounts, "f").has(snapId, accountId)) {
+                // If the Snap owns this account, we can use it.
+                filtered[accountId] = entry;
+            }
+            else {
+                // Otherwise, we just filter it out and log it (for debugging/tracking purposes).
+                console.warn(`SnapKeyring - ${event} - Found an unknown account ID "${accountId}" for Snap ID "${snapId}". Skipping.`);
+            }
+            return filtered;
+        }, {});
+    };
+    __classPrivateFieldGet(this, _SnapKeyring_messenger, "f").publish(event, ...filteredEventCallback(filter));
     return null;
-}, _SnapKeyring_filterAccountEventEntries = function _SnapKeyring_filterAccountEventEntries(snapId, eventName, eventEntries) {
-    const entries = {};
-    for (const [accountId, entry] of Object.entries(eventEntries)) {
-        const account = __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").get(snapId, accountId);
-        if (account) {
-            entries[accountId] = entry;
-        }
-        else {
-            console.warn(`SnapKeyring - ${eventName} - Found an unknown account ID "${accountId}" for Snap ID "${snapId}". Skipping.`);
-        }
-    }
-    return entries;
 }, _SnapKeyring_handleAccountBalancesUpdated = 
 /**
  * Handle a balances updated event from a Snap.
@@ -656,12 +736,11 @@ async function _SnapKeyring_rePublishAccountEvent(event, ...payload) {
  */
 async function _SnapKeyring_handleAccountBalancesUpdated(snapId, message) {
     (0, superstruct_1.assert)(message, keyring_api_1.AccountBalancesUpdatedEventStruct);
-    const { method: eventName, params: eventData } = message;
-    const event = {
-        ...eventData,
-        balances: __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_filterAccountEventEntries).call(this, snapId, eventName, eventData.balances),
-    };
-    return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_rePublishAccountEvent).call(this, 'SnapKeyring:accountBalancesUpdated', event);
+    const event = message.params;
+    return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_rePublishAccountEvent).call(this, snapId, 'SnapKeyring:accountBalancesUpdated', (filter) => {
+        event.balances = filter(event.balances);
+        return [event];
+    });
 }, _SnapKeyring_handleAccountAssetListUpdated = 
 /**
  * Handle a asset list updated event from a Snap.
@@ -672,12 +751,11 @@ async function _SnapKeyring_handleAccountBalancesUpdated(snapId, message) {
  */
 async function _SnapKeyring_handleAccountAssetListUpdated(snapId, message) {
     (0, superstruct_1.assert)(message, keyring_api_1.AccountAssetListUpdatedEventStruct);
-    const { method: eventName, params: eventData } = message;
-    const event = {
-        ...eventData,
-        assets: __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_filterAccountEventEntries).call(this, snapId, eventName, eventData.assets),
-    };
-    return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_rePublishAccountEvent).call(this, 'SnapKeyring:accountAssetListUpdated', event);
+    const event = message.params;
+    return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_rePublishAccountEvent).call(this, snapId, 'SnapKeyring:accountAssetListUpdated', (filter) => {
+        event.assets = filter(event.assets);
+        return [event];
+    });
 }, _SnapKeyring_handleAccountTransactionsUpdated = 
 /**
  * Handle a transactions updated event from a Snap.
@@ -688,12 +766,11 @@ async function _SnapKeyring_handleAccountAssetListUpdated(snapId, message) {
  */
 async function _SnapKeyring_handleAccountTransactionsUpdated(snapId, message) {
     (0, superstruct_1.assert)(message, keyring_api_1.AccountTransactionsUpdatedEventStruct);
-    const { method: eventName, params: eventData } = message;
-    const event = {
-        ...eventData,
-        transactions: __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_filterAccountEventEntries).call(this, snapId, eventName, eventData.transactions),
-    };
-    return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_rePublishAccountEvent).call(this, 'SnapKeyring:accountTransactionsUpdated', event);
+    const event = message.params;
+    return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_rePublishAccountEvent).call(this, snapId, 'SnapKeyring:accountTransactionsUpdated', (filter) => {
+        event.transactions = filter(event.transactions);
+        return [event];
+    });
 }, _SnapKeyring_getAccount = function _SnapKeyring_getAccount(id) {
     const found = [...__classPrivateFieldGet(this, _SnapKeyring_accounts, "f").values()].find((entry) => entry.account.id === id);
     if (!found) {