@metamask-previews/eth-snap-keyring 4.3.2-preview-8d6e44e → 4.3.2-preview-d458961

package/dist/CaseInsensitiveMap.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaseInsensitiveMap = void 0;
+const util_1 = require("./util");
+/**
+ * A case-insensitive map that stores key-value pairs.
+ */
+class CaseInsensitiveMap extends Map {
+    /**
+     * Create a new case-insensitive map from a plain object.
+     *
+     * @param obj - An object with entries to initialize the map with.
+     * @returns A new case-insensitive map with all entries from `obj`.
+     */
+    static fromObject(obj) {
+        return new CaseInsensitiveMap(Object.entries(obj));
+    }
+    /**
+     * Return a plain object with all entries from this map.
+     *
+     * @returns A plain object with all entries from this map.
+     */
+    toObject() {
+        return Object.fromEntries(this.entries());
+    }
+    /**
+     * Return the value associated to the given key, or `undefined` if the key is
+     * not found.
+     *
+     * @param key - The key to get the value for.
+     * @returns The value associated to the given key, or `undefined` if the key
+     * is not found.
+     */
+    get(key) {
+        return super.get(key.toLowerCase());
+    }
+    /**
+     * Return the value associated with the given key, or throw an error if the
+     * key is not found.
+     *
+     * @param key - The key to look up in the map.
+     * @param name - Optional name of the key to include in the error message.
+     * @returns The value associated with the given key.
+     */
+    getOrThrow(key, name = 'Key') {
+        return this.get(key) ?? (0, util_1.throwError)(`${name} '${key}' not found`);
+    }
+    /**
+     * Check whether the given key is present in the map.
+     *
+     * @param key - The key to check for.
+     * @returns `true` if the key is present in the map, `false` otherwise.
+     */
+    has(key) {
+        return super.has(key.toLowerCase());
+    }
+    /**
+     * Set the value for the given key. If the key already exists in the map, its
+     * value will be updated.
+     *
+     * The key is converted to lowercase before being stored in the map to ensure
+     * case-insensitivity.
+     *
+     * @param key - The key to set the value for.
+     * @param value - The value to set.
+     * @returns The map instance.
+     */
+    set(key, value) {
+        return super.set(key.toLowerCase(), value);
+    }
+    /**
+     * Delete the entry for the given key.
+     *
+     * @param key - The key to delete the entry for.
+     * @returns `true` if the entry was present in the map, `false` otherwise.
+     */
+    delete(key) {
+        return super.delete(key.toLowerCase());
+    }
+}
+exports.CaseInsensitiveMap = CaseInsensitiveMap;
+//# sourceMappingURL=CaseInsensitiveMap.js.map

package/dist/CaseInsensitiveMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CaseInsensitiveMap.js","sourceRoot":"","sources":["../src/CaseInsensitiveMap.ts"],"names":[],"mappings":";;;AAAA,iCAAoC;AAEpC;;GAEG;AACH,MAAa,kBAA0B,SAAQ,GAAkB;IAC/D;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CACf,GAA0B;QAE1B,OAAO,IAAI,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;IACrD,CAAC;IAED;;;;OAIG;IACH,QAAQ;QACN,OAAO,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;OAOG;IACH,GAAG,CAAC,GAAW;QACb,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC;IACtC,CAAC;IAED;;;;;;;OAOG;IACH,UAAU,CAAC,GAAW,EAAE,IAAI,GAAG,KAAK;QAClC,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAA,iBAAU,EAAC,GAAG,IAAI,KAAK,GAAG,aAAa,CAAC,CAAC;IACnE,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAC,GAAW;QACb,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC;IACtC,CAAC;IAED;;;;;;;;;;OAUG;IACH,GAAG,CAAC,GAAW,EAAE,KAAY;QAC3B,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,GAAW;QAChB,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC;IACzC,CAAC;CACF;AAhFD,gDAgFC","sourcesContent":["import { throwError } from './util';\n\n/**\n * A case-insensitive map that stores key-value pairs.\n */\nexport class CaseInsensitiveMap<Value> extends Map<string, Value> {\n  /**\n   * Create a new case-insensitive map from a plain object.\n   *\n   * @param obj - An object with entries to initialize the map with.\n   * @returns A new case-insensitive map with all entries from `obj`.\n   */\n  static fromObject<Value>(\n    obj: Record<string, Value>,\n  ): CaseInsensitiveMap<Value> {\n    return new CaseInsensitiveMap(Object.entries(obj));\n  }\n\n  /**\n   * Return a plain object with all entries from this map.\n   *\n   * @returns A plain object with all entries from this map.\n   */\n  toObject(): Record<string, Value> {\n    return Object.fromEntries(this.entries());\n  }\n\n  /**\n   * Return the value associated to the given key, or `undefined` if the key is\n   * not found.\n   *\n   * @param key - The key to get the value for.\n   * @returns The value associated to the given key, or `undefined` if the key\n   * is not found.\n   */\n  get(key: string): Value | undefined {\n    return super.get(key.toLowerCase());\n  }\n\n  /**\n   * Return the value associated with the given key, or throw an error if the\n   * key is not found.\n   *\n   * @param key - The key to look up in the map.\n   * @param name - Optional name of the key to include in the error message.\n   * @returns The value associated with the given key.\n   */\n  getOrThrow(key: string, name = 'Key'): Value {\n    return this.get(key) ?? throwError(`${name} '${key}' not found`);\n  }\n\n  /**\n   * Check whether the given key is present in the map.\n   *\n   * @param key - The key to check for.\n   * @returns `true` if the key is present in the map, `false` otherwise.\n   */\n  has(key: string): boolean {\n    return super.has(key.toLowerCase());\n  }\n\n  /**\n   * Set the value for the given key. If the key already exists in the map, its\n   * value will be updated.\n   *\n   * The key is converted to lowercase before being stored in the map to ensure\n   * case-insensitivity.\n   *\n   * @param key - The key to set the value for.\n   * @param value - The value to set.\n   * @returns The map instance.\n   */\n  set(key: string, value: Value): this {\n    return super.set(key.toLowerCase(), value);\n  }\n\n  /**\n   * Delete the entry for the given key.\n   *\n   * @param key - The key to delete the entry for.\n   * @returns `true` if the entry was present in the map, `false` otherwise.\n   */\n  delete(key: string): boolean {\n    return super.delete(key.toLowerCase());\n  }\n}\n"]}

package/dist/DeferredPromise.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeferredPromise = void 0;
+/**
+ * A deferred promise can be resolved by a caller different from the one who
+ * created it.
+ *
+ * Example:
+ * - "A" creates a deferred promise "P", adds it to a list, and awaits it
+ * - "B" gets "P" from the list and resolves it
+ * - "A" gets the resolved value
+ */
+class DeferredPromise {
+    constructor() {
+        this.resolve = undefined;
+        this.reject = undefined;
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+        // This is a sanity check to make sure that the promise constructor
+        // actually set the `resolve` and `reject` functions.
+        /* istanbul ignore next */
+        if (!this.resolve || !this.reject) {
+            throw new Error('Promise constructor failed');
+        }
+    }
+}
+exports.DeferredPromise = DeferredPromise;
+//# sourceMappingURL=DeferredPromise.js.map

package/dist/DeferredPromise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeferredPromise.js","sourceRoot":"","sources":["../src/DeferredPromise.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;GAQG;AACH,MAAa,eAAe;IAO1B;QAJA,YAAO,GAA8C,SAAgB,CAAC;QAEtE,WAAM,GAA2B,SAAgB,CAAC;QAGhD,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC7C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;YACvB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACvB,CAAC,CAAC,CAAC;QAEH,mEAAmE;QACnE,qDAAqD;QACrD,0BAA0B;QAC1B,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YACjC,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;SAC/C;IACH,CAAC;CACF;AApBD,0CAoBC","sourcesContent":["/**\n * A deferred promise can be resolved by a caller different from the one who\n * created it.\n *\n * Example:\n * - \"A\" creates a deferred promise \"P\", adds it to a list, and awaits it\n * - \"B\" gets \"P\" from the list and resolves it\n * - \"A\" gets the resolved value\n */\nexport class DeferredPromise<Type> {\n  promise: Promise<Type>;\n\n  resolve: (value: Type | PromiseLike<Type>) => void = undefined as any;\n\n  reject: (reason?: any) => void = undefined as any;\n\n  constructor() {\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = resolve;\n      this.reject = reject;\n    });\n\n    // This is a sanity check to make sure that the promise constructor\n    // actually set the `resolve` and `reject` functions.\n    /* istanbul ignore next */\n    if (!this.resolve || !this.reject) {\n      throw new Error('Promise constructor failed');\n    }\n  }\n}\n"]}

package/dist/KeyringSnapControllerClient.js

@@ -0,0 +1,104 @@
+"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 _SnapControllerSender_snapId, _SnapControllerSender_origin, _SnapControllerSender_controller, _SnapControllerSender_handler, _KeyringSnapControllerClient_controller;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyringSnapControllerClient = void 0;
+const keyring_api_1 = require("@metamask/keyring-api");
+/**
+ * Implementation of the `Sender` interface that can be used to send requests
+ * to a snap through a `SnapController`.
+ */
+class SnapControllerSender {
+    /**
+     * Create a new instance of `SnapControllerSender`.
+     *
+     * @param controller - The `SnapController` instance to send requests to.
+     * @param snapId - The ID of the snap to use.
+     * @param origin - The sender's origin.
+     * @param handler - The handler type.
+     */
+    constructor(controller, snapId, origin, handler) {
+        _SnapControllerSender_snapId.set(this, void 0);
+        _SnapControllerSender_origin.set(this, void 0);
+        _SnapControllerSender_controller.set(this, void 0);
+        _SnapControllerSender_handler.set(this, void 0);
+        __classPrivateFieldSet(this, _SnapControllerSender_controller, controller, "f");
+        __classPrivateFieldSet(this, _SnapControllerSender_snapId, snapId, "f");
+        __classPrivateFieldSet(this, _SnapControllerSender_origin, origin, "f");
+        __classPrivateFieldSet(this, _SnapControllerSender_handler, handler, "f");
+    }
+    /**
+     * Send a request to the snap and return the response.
+     *
+     * @param request - JSON-RPC request to send to the snap.
+     * @returns A promise that resolves to the response of the request.
+     */
+    async send(request) {
+        return __classPrivateFieldGet(this, _SnapControllerSender_controller, "f").handleRequest({
+            snapId: __classPrivateFieldGet(this, _SnapControllerSender_snapId, "f"),
+            origin: __classPrivateFieldGet(this, _SnapControllerSender_origin, "f"),
+            handler: __classPrivateFieldGet(this, _SnapControllerSender_handler, "f"),
+            request,
+        });
+    }
+}
+_SnapControllerSender_snapId = new WeakMap(), _SnapControllerSender_origin = new WeakMap(), _SnapControllerSender_controller = new WeakMap(), _SnapControllerSender_handler = new WeakMap();
+/**
+ * A `KeyringClient` that allows the communication with a snap through the
+ * `SnapController`.
+ */
+class KeyringSnapControllerClient extends keyring_api_1.KeyringClient {
+    /**
+     * Create a new instance of `KeyringSnapControllerClient`.
+     *
+     * The `handlerType` argument has a hard-coded default `string` value instead
+     * of a `HandlerType` value to prevent the `@metamask/snaps-utils` module
+     * from being required at runtime.
+     *
+     * @param args - Constructor arguments.
+     * @param args.controller - The `SnapController` instance to use.
+     * @param args.snapId - The ID of the snap to use (default: `'undefined'`).
+     * @param args.origin - The sender's origin (default: `'metamask'`).
+     * @param args.handler - The handler type (default: `'onKeyringRequest'`).
+     */
+    constructor({ controller, snapId = 'undefined', origin = 'metamask', handler = 'onKeyringRequest', }) {
+        super(new SnapControllerSender(controller, snapId, origin, handler));
+        _KeyringSnapControllerClient_controller.set(this, void 0);
+        __classPrivateFieldSet(this, _KeyringSnapControllerClient_controller, controller, "f");
+    }
+    /**
+     * Create a new instance of `KeyringSnapControllerClient` with the specified
+     * `snapId`.
+     *
+     * @param snapId - The ID of the snap to use in the new instance.
+     * @returns A new instance of `KeyringSnapControllerClient` with the
+     * specified snap ID.
+     */
+    withSnapId(snapId) {
+        return new KeyringSnapControllerClient({
+            controller: __classPrivateFieldGet(this, _KeyringSnapControllerClient_controller, "f"),
+            snapId,
+        });
+    }
+    /**
+     * Get the `SnapController` instance used by this client.
+     *
+     * @returns The `SnapController` instance used by this client.
+     */
+    getController() {
+        return __classPrivateFieldGet(this, _KeyringSnapControllerClient_controller, "f");
+    }
+}
+exports.KeyringSnapControllerClient = KeyringSnapControllerClient;
+_KeyringSnapControllerClient_controller = new WeakMap();
+//# sourceMappingURL=KeyringSnapControllerClient.js.map

package/dist/KeyringSnapControllerClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyringSnapControllerClient.js","sourceRoot":"","sources":["../src/KeyringSnapControllerClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,uDAAmE;AAOnE;;;GAGG;AACH,MAAM,oBAAoB;IASxB;;;;;;;OAOG;IACH,YACE,UAAe,EACf,MAAc,EACd,MAAc,EACd,OAAoB;QApBtB,+CAAgB;QAEhB,+CAAgB;QAEhB,mDAA4B;QAE5B,gDAAsB;QAgBpB,uBAAA,IAAI,oCAAe,UAAU,MAAA,CAAC;QAC9B,uBAAA,IAAI,gCAAW,MAAM,MAAA,CAAC;QACtB,uBAAA,IAAI,gCAAW,MAAM,MAAA,CAAC;QACtB,uBAAA,IAAI,iCAAY,OAAO,MAAA,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI,CAAC,OAAuB;QAChC,OAAO,uBAAA,IAAI,wCAAY,CAAC,aAAa,CAAC;YACpC,MAAM,EAAE,uBAAA,IAAI,oCAAQ;YACpB,MAAM,EAAE,uBAAA,IAAI,oCAAQ;YACpB,OAAO,EAAE,uBAAA,IAAI,qCAAS;YACtB,OAAO;SACR,CAAkB,CAAC;IACtB,CAAC;CACF;;AAED;;;GAGG;AACH,MAAa,2BAA4B,SAAQ,2BAAa;IAG5D;;;;;;;;;;;;OAYG;IACH,YAAY,EACV,UAAU,EACV,MAAM,GAAG,WAAqB,EAC9B,MAAM,GAAG,UAAU,EACnB,OAAO,GAAG,kBAAiC,GAM5C;QACC,KAAK,CAAC,IAAI,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QA1BvE,0DAA4B;QA2B1B,uBAAA,IAAI,2CAAe,UAAU,MAAA,CAAC;IAChC,CAAC;IAED;;;;;;;OAOG;IACH,UAAU,CAAC,MAAc;QACvB,OAAO,IAAI,2BAA2B,CAAC;YACrC,UAAU,EAAE,uBAAA,IAAI,+CAAY;YAC5B,MAAM;SACP,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,aAAa;QACX,OAAO,uBAAA,IAAI,+CAAY,CAAC;IAC1B,CAAC;CACF;AAtDD,kEAsDC","sourcesContent":["import { KeyringClient, type Sender } from '@metamask/keyring-api';\nimport type { JsonRpcRequest } from '@metamask/keyring-api/dist/JsonRpcRequest';\nimport type { SnapController } from '@metamask/snaps-controllers';\nimport type { SnapId } from '@metamask/snaps-sdk';\nimport type { HandlerType } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\n\n/**\n * Implementation of the `Sender` interface that can be used to send requests\n * to a snap through a `SnapController`.\n */\nclass SnapControllerSender implements Sender {\n  #snapId: SnapId;\n\n  #origin: string;\n\n  #controller: SnapController;\n\n  #handler: HandlerType;\n\n  /**\n   * Create a new instance of `SnapControllerSender`.\n   *\n   * @param controller - The `SnapController` instance to send requests to.\n   * @param snapId - The ID of the snap to use.\n   * @param origin - The sender's origin.\n   * @param handler - The handler type.\n   */\n  constructor(\n    controller: any,\n    snapId: SnapId,\n    origin: string,\n    handler: HandlerType,\n  ) {\n    this.#controller = controller;\n    this.#snapId = snapId;\n    this.#origin = origin;\n    this.#handler = handler;\n  }\n\n  /**\n   * Send a request to the snap and return the response.\n   *\n   * @param request - JSON-RPC request to send to the snap.\n   * @returns A promise that resolves to the response of the request.\n   */\n  async send(request: JsonRpcRequest): Promise<Json> {\n    return this.#controller.handleRequest({\n      snapId: this.#snapId,\n      origin: this.#origin,\n      handler: this.#handler,\n      request,\n    }) as Promise<Json>;\n  }\n}\n\n/**\n * A `KeyringClient` that allows the communication with a snap through the\n * `SnapController`.\n */\nexport class KeyringSnapControllerClient extends KeyringClient {\n  #controller: SnapController;\n\n  /**\n   * Create a new instance of `KeyringSnapControllerClient`.\n   *\n   * The `handlerType` argument has a hard-coded default `string` value instead\n   * of a `HandlerType` value to prevent the `@metamask/snaps-utils` module\n   * from being required at runtime.\n   *\n   * @param args - Constructor arguments.\n   * @param args.controller - The `SnapController` instance to use.\n   * @param args.snapId - The ID of the snap to use (default: `'undefined'`).\n   * @param args.origin - The sender's origin (default: `'metamask'`).\n   * @param args.handler - The handler type (default: `'onKeyringRequest'`).\n   */\n  constructor({\n    controller,\n    snapId = 'undefined' as SnapId,\n    origin = 'metamask',\n    handler = 'onKeyringRequest' as HandlerType,\n  }: {\n    controller: SnapController;\n    snapId?: SnapId;\n    origin?: string;\n    handler?: HandlerType;\n  }) {\n    super(new SnapControllerSender(controller, snapId, origin, handler));\n    this.#controller = controller;\n  }\n\n  /**\n   * Create a new instance of `KeyringSnapControllerClient` with the specified\n   * `snapId`.\n   *\n   * @param snapId - The ID of the snap to use in the new instance.\n   * @returns A new instance of `KeyringSnapControllerClient` with the\n   * specified snap ID.\n   */\n  withSnapId(snapId: SnapId): KeyringSnapControllerClient {\n    return new KeyringSnapControllerClient({\n      controller: this.#controller,\n      snapId,\n    });\n  }\n\n  /**\n   * Get the `SnapController` instance used by this client.\n   *\n   * @returns The `SnapController` instance used by this client.\n   */\n  getController(): SnapController {\n    return this.#controller;\n  }\n}\n"]}

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"]}