@metamask-previews/eth-snap-keyring 4.3.2-preview-37040eb → 4.3.2-preview-399ef96

package/dist/CaseInsensitiveMap.d.ts

@@ -0,0 +1,63 @@
+/**
+ * A case-insensitive map that stores key-value pairs.
+ */
+export declare class CaseInsensitiveMap<Value> extends Map<string, Value> {
+    /**
+     * 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<Value>(obj: Record<string, Value>): CaseInsensitiveMap<Value>;
+    /**
+     * Return a plain object with all entries from this map.
+     *
+     * @returns A plain object with all entries from this map.
+     */
+    toObject(): Record<string, Value>;
+    /**
+     * 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: string): Value | undefined;
+    /**
+     * 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: string, name?: string): Value;
+    /**
+     * 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: string): boolean;
+    /**
+     * 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: string, value: Value): this;
+    /**
+     * 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: string): boolean;
+}
+//# sourceMappingURL=CaseInsensitiveMap.d.ts.map

package/dist/CaseInsensitiveMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CaseInsensitiveMap.d.ts","sourceRoot":"","sources":["../src/CaseInsensitiveMap.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,kBAAkB,CAAC,KAAK,CAAE,SAAQ,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC;IAC/D;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,KAAK,EACrB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GACzB,kBAAkB,CAAC,KAAK,CAAC;IAI5B;;;;OAIG;IACH,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAIjC;;;;;;;OAOG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAInC;;;;;;;OAOG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,SAAQ,GAAG,KAAK;IAI5C;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB;;;;;;;;;;OAUG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAIpC;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;CAG7B"}

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.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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
+ */
+export declare class DeferredPromise<Type> {
+    promise: Promise<Type>;
+    resolve: (value: Type | PromiseLike<Type>) => void;
+    reject: (reason?: any) => void;
+    constructor();
+}
+//# sourceMappingURL=DeferredPromise.d.ts.map

package/dist/DeferredPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeferredPromise.d.ts","sourceRoot":"","sources":["../src/DeferredPromise.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qBAAa,eAAe,CAAC,IAAI;IAC/B,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB,OAAO,EAAE,CAAC,KAAK,EAAE,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,KAAK,IAAI,CAAoB;IAEtE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,CAAoB;;CAenD"}

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.d.ts

@@ -0,0 +1,46 @@
+import { KeyringClient } from '@metamask/keyring-api';
+import type { SnapController } from '@metamask/snaps-controllers';
+import type { SnapId } from '@metamask/snaps-sdk';
+import type { HandlerType } from '@metamask/snaps-utils';
+/**
+ * A `KeyringClient` that allows the communication with a snap through the
+ * `SnapController`.
+ */
+export declare class KeyringSnapControllerClient extends KeyringClient {
+    #private;
+    /**
+     * 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, origin, handler, }: {
+        controller: SnapController;
+        snapId?: SnapId;
+        origin?: string;
+        handler?: HandlerType;
+    });
+    /**
+     * 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: SnapId): KeyringSnapControllerClient;
+    /**
+     * Get the `SnapController` instance used by this client.
+     *
+     * @returns The `SnapController` instance used by this client.
+     */
+    getController(): SnapController;
+}
+//# sourceMappingURL=KeyringSnapControllerClient.d.ts.map

package/dist/KeyringSnapControllerClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyringSnapControllerClient.d.ts","sourceRoot":"","sources":["../src/KeyringSnapControllerClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAe,MAAM,uBAAuB,CAAC;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAoDzD;;;GAGG;AACH,qBAAa,2BAA4B,SAAQ,aAAa;;IAG5D;;;;;;;;;;;;OAYG;gBACS,EACV,UAAU,EACV,MAA8B,EAC9B,MAAmB,EACnB,OAA2C,GAC5C,EAAE;QACD,UAAU,EAAE,cAAc,CAAC;QAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,WAAW,CAAC;KACvB;IAKD;;;;;;;OAOG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,2BAA2B;IAOvD;;;;OAIG;IACH,aAAa,IAAI,cAAc;CAGhC"}

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.d.ts

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

package/dist/SnapIdMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SnapIdMap.d.ts","sourceRoot":"","sources":["../src/SnapIdMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;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;;;;;;;;;;;;;;;;;;;;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"}