@metamask-previews/rate-limit-controller 3.0.0-preview.3dbf14f

package/CHANGELOG.md

@@ -0,0 +1,47 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [3.0.0]
+### Changed
+- **BREAKING:** Allow `RateLimitController` to define a rate-limit per method ([#1355](https://github.com/MetaMask/core/pull/1355))
+  - The constructor `implementations` option now maps API names to objects with a `method` property, rather than mapping to a function. This object may also have `rateLimitCount` and `rateLimitTimeout` properties, allowing custom rate limits for that method.
+- **BREAKING:** Bump to Node 16 ([#1262](https://github.com/MetaMask/core/pull/1262))
+
+## [2.0.1]
+### Changed
+- deps: eth-rpc-errors@4.0.0->4.0.2 ([#1215](https://github.com/MetaMask/core/pull/1215))
+
+## [2.0.0]
+### Removed
+- **BREAKING:** Remove `isomorphic-fetch` ([#1106](https://github.com/MetaMask/controllers/pull/1106))
+  - Consumers must now import `isomorphic-fetch` or another polyfill themselves if they are running in an environment without `fetch`
+
+## [1.0.2]
+### Changed
+- Rename this repository to `core` ([#1031](https://github.com/MetaMask/controllers/pull/1031))
+- Update `@metamask/controller-utils` package ([#1041](https://github.com/MetaMask/controllers/pull/1041))
+
+## [1.0.1]
+### Changed
+- Relax dependency on `@metamask/base-controller` (use `^` instead of `~`) ([#998](https://github.com/MetaMask/core/pull/998))
+
+## [1.0.0]
+### Added
+- Initial release
+  - As a result of converting our shared controllers repo into a monorepo ([#831](https://github.com/MetaMask/core/pull/831)), we've created this package from select parts of [`@metamask/controllers` v33.0.0](https://github.com/MetaMask/core/tree/v33.0.0), namely:
+    - Everything in `src/ratelimit`
+
+    All changes listed after this point were applied to this package following the monorepo conversion.
+
+[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/rate-limit-controller@3.0.0...HEAD
+[3.0.0]: https://github.com/MetaMask/core/compare/@metamask/rate-limit-controller@2.0.1...@metamask/rate-limit-controller@3.0.0
+[2.0.1]: https://github.com/MetaMask/core/compare/@metamask/rate-limit-controller@2.0.0...@metamask/rate-limit-controller@2.0.1
+[2.0.0]: https://github.com/MetaMask/core/compare/@metamask/rate-limit-controller@1.0.2...@metamask/rate-limit-controller@2.0.0
+[1.0.2]: https://github.com/MetaMask/core/compare/@metamask/rate-limit-controller@1.0.1...@metamask/rate-limit-controller@1.0.2
+[1.0.1]: https://github.com/MetaMask/core/compare/@metamask/rate-limit-controller@1.0.0...@metamask/rate-limit-controller@1.0.1
+[1.0.0]: https://github.com/MetaMask/core/releases/tag/@metamask/rate-limit-controller@1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2018 MetaMask
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

package/README.md

@@ -0,0 +1,15 @@
+# `@metamask/rate-limit-controller`
+
+Contains logic for rate-limiting API endpoints by requesting origin.
+
+## Installation
+
+`yarn add @metamask/rate-limit-controller`
+
+or
+
+`npm install @metamask/rate-limit-controller`
+
+## Contributing
+
+This package is part of a monorepo. Instructions for contributing can be found in the [monorepo README](https://github.com/MetaMask/core#readme).

package/dist/RateLimitController.d.ts

@@ -0,0 +1,94 @@
+import type { RestrictedControllerMessenger } from '@metamask/base-controller';
+import { BaseControllerV2 as BaseController } from '@metamask/base-controller';
+import type { Patch } from 'immer';
+/**
+ * @type RateLimitedApi
+ * @property method - The method that is rate-limited.
+ * @property rateLimitTimeout - The time window in which the rate limit is applied (in ms).
+ * @property rateLimitCount - The amount of calls an origin can make in the rate limit time window.
+ */
+export declare type RateLimitedApi = {
+    method: (...args: any[]) => any;
+    rateLimitTimeout?: number;
+    rateLimitCount?: number;
+};
+/**
+ * @type RateLimitState
+ * @property requests - Object containing number of requests in a given interval for each origin and api type combination
+ */
+export declare type RateLimitState<RateLimitedApis extends Record<string, RateLimitedApi>> = {
+    requests: Record<keyof RateLimitedApis, Record<string, number>>;
+};
+declare const name = "RateLimitController";
+export declare type RateLimitStateChange<RateLimitedApis extends Record<string, RateLimitedApi>> = {
+    type: `${typeof name}:stateChange`;
+    payload: [RateLimitState<RateLimitedApis>, Patch[]];
+};
+export declare type GetRateLimitState<RateLimitedApis extends Record<string, RateLimitedApi>> = {
+    type: `${typeof name}:getState`;
+    handler: () => RateLimitState<RateLimitedApis>;
+};
+export declare type CallApi<RateLimitedApis extends Record<string, RateLimitedApi>> = {
+    type: `${typeof name}:call`;
+    handler: RateLimitController<RateLimitedApis>['call'];
+};
+export declare type RateLimitControllerActions<RateLimitedApis extends Record<string, RateLimitedApi>> = GetRateLimitState<RateLimitedApis> | CallApi<RateLimitedApis>;
+export declare type RateLimitMessenger<RateLimitedApis extends Record<string, RateLimitedApi>> = RestrictedControllerMessenger<typeof name, RateLimitControllerActions<RateLimitedApis>, RateLimitStateChange<RateLimitedApis>, never, never>;
+/**
+ * Controller with logic for rate-limiting API endpoints per requesting origin.
+ */
+export declare class RateLimitController<RateLimitedApis extends Record<string, RateLimitedApi>> extends BaseController<typeof name, RateLimitState<RateLimitedApis>, RateLimitMessenger<RateLimitedApis>> {
+    private readonly implementations;
+    private readonly rateLimitTimeout;
+    private readonly rateLimitCount;
+    /**
+     * Creates a RateLimitController instance.
+     *
+     * @param options - Constructor options.
+     * @param options.messenger - A reference to the messaging system.
+     * @param options.state - Initial state to set on this controller.
+     * @param options.implementations - Mapping from API type to API implementation.
+     * @param options.rateLimitTimeout - The time window in which the rate limit is applied (in ms).
+     * @param options.rateLimitCount - The amount of calls an origin can make in the rate limit time window.
+     */
+    constructor({ rateLimitTimeout, rateLimitCount, messenger, state, implementations, }: {
+        rateLimitTimeout?: number;
+        rateLimitCount?: number;
+        messenger: RateLimitMessenger<RateLimitedApis>;
+        state?: Partial<RateLimitState<RateLimitedApis>>;
+        implementations: RateLimitedApis;
+    });
+    /**
+     * Calls an API if the requesting origin is not rate-limited.
+     *
+     * @param origin - The requesting origin.
+     * @param type - The type of API call to make.
+     * @param args - Arguments for the API call.
+     * @returns `false` if rate-limited, and `true` otherwise.
+     */
+    call<ApiType extends keyof RateLimitedApis>(origin: string, type: ApiType, ...args: Parameters<RateLimitedApis[ApiType]['method']>): Promise<ReturnType<RateLimitedApis[ApiType]['method']>>;
+    /**
+     * Checks whether an origin is rate limited for the a specific API.
+     *
+     * @param api - The API the origin is trying to access.
+     * @param origin - The origin trying to access the API.
+     * @returns `true` if rate-limited, and `false` otherwise.
+     */
+    private isRateLimited;
+    /**
+     * Records that an origin has made a request to call an API, for rate-limiting purposes.
+     *
+     * @param api - The API the origin is trying to access.
+     * @param origin - The origin trying to access the API.
+     */
+    private recordRequest;
+    /**
+     * Resets the request count for a given origin and API combination, for rate-limiting purposes.
+     *
+     * @param api - The API in question.
+     * @param origin - The origin in question.
+     */
+    private resetRequestCount;
+}
+export {};
+//# sourceMappingURL=RateLimitController.d.ts.map

package/dist/RateLimitController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RateLimitController.d.ts","sourceRoot":"","sources":["../src/RateLimitController.ts"],"names":[],"mappings":"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"}

package/dist/RateLimitController.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitController = void 0;
+const base_controller_1 = require("@metamask/base-controller");
+const eth_rpc_errors_1 = require("eth-rpc-errors");
+const name = 'RateLimitController';
+const metadata = {
+    requests: { persist: false, anonymous: false },
+};
+/**
+ * Controller with logic for rate-limiting API endpoints per requesting origin.
+ */
+class RateLimitController extends base_controller_1.BaseControllerV2 {
+    /**
+     * Creates a RateLimitController instance.
+     *
+     * @param options - Constructor options.
+     * @param options.messenger - A reference to the messaging system.
+     * @param options.state - Initial state to set on this controller.
+     * @param options.implementations - Mapping from API type to API implementation.
+     * @param options.rateLimitTimeout - The time window in which the rate limit is applied (in ms).
+     * @param options.rateLimitCount - The amount of calls an origin can make in the rate limit time window.
+     */
+    constructor({ rateLimitTimeout = 5000, rateLimitCount = 1, messenger, state, implementations, }) {
+        const defaultState = {
+            requests: Object.keys(implementations).reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: {} })), {}),
+        };
+        super({
+            name,
+            metadata,
+            messenger,
+            state: Object.assign(Object.assign({}, defaultState), state),
+        });
+        this.implementations = implementations;
+        this.rateLimitTimeout = rateLimitTimeout;
+        this.rateLimitCount = rateLimitCount;
+        this.messagingSystem.registerActionHandler(`${name}:call`, ((origin, type, ...args) => this.call(origin, type, ...args)));
+    }
+    /**
+     * Calls an API if the requesting origin is not rate-limited.
+     *
+     * @param origin - The requesting origin.
+     * @param type - The type of API call to make.
+     * @param args - Arguments for the API call.
+     * @returns `false` if rate-limited, and `true` otherwise.
+     */
+    call(origin, type, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isRateLimited(type, origin)) {
+                throw eth_rpc_errors_1.ethErrors.rpc.limitExceeded({
+                    message: `"${type.toString()}" is currently rate-limited. Please try again later.`,
+                });
+            }
+            this.recordRequest(type, origin);
+            const implementation = this.implementations[type].method;
+            if (!implementation) {
+                throw new Error('Invalid api type');
+            }
+            return implementation(...args);
+        });
+    }
+    /**
+     * Checks whether an origin is rate limited for the a specific API.
+     *
+     * @param api - The API the origin is trying to access.
+     * @param origin - The origin trying to access the API.
+     * @returns `true` if rate-limited, and `false` otherwise.
+     */
+    isRateLimited(api, origin) {
+        var _a;
+        const rateLimitCount = (_a = this.implementations[api].rateLimitCount) !== null && _a !== void 0 ? _a : this.rateLimitCount;
+        return this.state.requests[api][origin] >= rateLimitCount;
+    }
+    /**
+     * Records that an origin has made a request to call an API, for rate-limiting purposes.
+     *
+     * @param api - The API the origin is trying to access.
+     * @param origin - The origin trying to access the API.
+     */
+    recordRequest(api, origin) {
+        var _a;
+        const rateLimitTimeout = (_a = this.implementations[api].rateLimitTimeout) !== null && _a !== void 0 ? _a : this.rateLimitTimeout;
+        this.update((state) => {
+            var _a;
+            const previous = (_a = state.requests[api][origin]) !== null && _a !== void 0 ? _a : 0;
+            state.requests[api][origin] = previous + 1;
+            if (previous === 0) {
+                setTimeout(() => this.resetRequestCount(api, origin), rateLimitTimeout);
+            }
+        });
+    }
+    /**
+     * Resets the request count for a given origin and API combination, for rate-limiting purposes.
+     *
+     * @param api - The API in question.
+     * @param origin - The origin in question.
+     */
+    resetRequestCount(api, origin) {
+        this.update((state) => {
+            state.requests[api][origin] = 0;
+        });
+    }
+}
+exports.RateLimitController = RateLimitController;
+//# sourceMappingURL=RateLimitController.js.map

package/dist/RateLimitController.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RateLimitController.js","sourceRoot":"","sources":["../src/RateLimitController.ts"],"names":[],"mappings":"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","sourcesContent":["import type { RestrictedControllerMessenger } from '@metamask/base-controller';\nimport { BaseControllerV2 as BaseController } from '@metamask/base-controller';\nimport { ethErrors } from 'eth-rpc-errors';\nimport type { Patch } from 'immer';\n\n/**\n * @type RateLimitedApi\n * @property method - The method that is rate-limited.\n * @property rateLimitTimeout - The time window in which the rate limit is applied (in ms).\n * @property rateLimitCount - The amount of calls an origin can make in the rate limit time window.\n */\nexport type RateLimitedApi = {\n  method: (...args: any[]) => any;\n  rateLimitTimeout?: number;\n  rateLimitCount?: number;\n};\n\n/**\n * @type RateLimitState\n * @property requests - Object containing number of requests in a given interval for each origin and api type combination\n */\nexport type RateLimitState<\n  RateLimitedApis extends Record<string, RateLimitedApi>,\n> = {\n  requests: Record<keyof RateLimitedApis, Record<string, number>>;\n};\n\nconst name = 'RateLimitController';\n\nexport type RateLimitStateChange<\n  RateLimitedApis extends Record<string, RateLimitedApi>,\n> = {\n  type: `${typeof name}:stateChange`;\n  payload: [RateLimitState<RateLimitedApis>, Patch[]];\n};\n\nexport type GetRateLimitState<\n  RateLimitedApis extends Record<string, RateLimitedApi>,\n> = {\n  type: `${typeof name}:getState`;\n  handler: () => RateLimitState<RateLimitedApis>;\n};\n\nexport type CallApi<RateLimitedApis extends Record<string, RateLimitedApi>> = {\n  type: `${typeof name}:call`;\n  handler: RateLimitController<RateLimitedApis>['call'];\n};\n\nexport type RateLimitControllerActions<\n  RateLimitedApis extends Record<string, RateLimitedApi>,\n> = GetRateLimitState<RateLimitedApis> | CallApi<RateLimitedApis>;\n\nexport type RateLimitMessenger<\n  RateLimitedApis extends Record<string, RateLimitedApi>,\n> = RestrictedControllerMessenger<\n  typeof name,\n  RateLimitControllerActions<RateLimitedApis>,\n  RateLimitStateChange<RateLimitedApis>,\n  never,\n  never\n>;\n\nconst metadata = {\n  requests: { persist: false, anonymous: false },\n};\n\n/**\n * Controller with logic for rate-limiting API endpoints per requesting origin.\n */\nexport class RateLimitController<\n  RateLimitedApis extends Record<string, RateLimitedApi>,\n> extends BaseController<\n  typeof name,\n  RateLimitState<RateLimitedApis>,\n  RateLimitMessenger<RateLimitedApis>\n> {\n  private readonly implementations;\n\n  private readonly rateLimitTimeout;\n\n  private readonly rateLimitCount;\n\n  /**\n   * Creates a RateLimitController instance.\n   *\n   * @param options - Constructor options.\n   * @param options.messenger - A reference to the messaging system.\n   * @param options.state - Initial state to set on this controller.\n   * @param options.implementations - Mapping from API type to API implementation.\n   * @param options.rateLimitTimeout - The time window in which the rate limit is applied (in ms).\n   * @param options.rateLimitCount - The amount of calls an origin can make in the rate limit time window.\n   */\n  constructor({\n    rateLimitTimeout = 5000,\n    rateLimitCount = 1,\n    messenger,\n    state,\n    implementations,\n  }: {\n    rateLimitTimeout?: number;\n    rateLimitCount?: number;\n    messenger: RateLimitMessenger<RateLimitedApis>;\n    state?: Partial<RateLimitState<RateLimitedApis>>;\n    implementations: RateLimitedApis;\n  }) {\n    const defaultState = {\n      requests: Object.keys(implementations).reduce(\n        (acc, key) => ({ ...acc, [key]: {} }),\n        {} as Record<keyof RateLimitedApis, Record<string, number>>,\n      ),\n    };\n    super({\n      name,\n      metadata,\n      messenger,\n      state: { ...defaultState, ...state },\n    });\n    this.implementations = implementations;\n    this.rateLimitTimeout = rateLimitTimeout;\n    this.rateLimitCount = rateLimitCount;\n\n    this.messagingSystem.registerActionHandler(\n      `${name}:call` as const,\n      ((\n        origin: string,\n        type: keyof RateLimitedApis,\n        ...args: Parameters<RateLimitedApis[keyof RateLimitedApis]['method']>\n      ) => this.call(origin, type, ...args)) as any,\n    );\n  }\n\n  /**\n   * Calls an API if the requesting origin is not rate-limited.\n   *\n   * @param origin - The requesting origin.\n   * @param type - The type of API call to make.\n   * @param args - Arguments for the API call.\n   * @returns `false` if rate-limited, and `true` otherwise.\n   */\n  async call<ApiType extends keyof RateLimitedApis>(\n    origin: string,\n    type: ApiType,\n    ...args: Parameters<RateLimitedApis[ApiType]['method']>\n  ): Promise<ReturnType<RateLimitedApis[ApiType]['method']>> {\n    if (this.isRateLimited(type, origin)) {\n      throw ethErrors.rpc.limitExceeded({\n        message: `\"${type.toString()}\" is currently rate-limited. Please try again later.`,\n      });\n    }\n    this.recordRequest(type, origin);\n\n    const implementation = this.implementations[type].method;\n\n    if (!implementation) {\n      throw new Error('Invalid api type');\n    }\n\n    return implementation(...args);\n  }\n\n  /**\n   * Checks whether an origin is rate limited for the a specific API.\n   *\n   * @param api - The API the origin is trying to access.\n   * @param origin - The origin trying to access the API.\n   * @returns `true` if rate-limited, and `false` otherwise.\n   */\n  private isRateLimited(api: keyof RateLimitedApis, origin: string) {\n    const rateLimitCount =\n      this.implementations[api].rateLimitCount ?? this.rateLimitCount;\n    return this.state.requests[api][origin] >= rateLimitCount;\n  }\n\n  /**\n   * Records that an origin has made a request to call an API, for rate-limiting purposes.\n   *\n   * @param api - The API the origin is trying to access.\n   * @param origin - The origin trying to access the API.\n   */\n  private recordRequest(api: keyof RateLimitedApis, origin: string) {\n    const rateLimitTimeout =\n      this.implementations[api].rateLimitTimeout ?? this.rateLimitTimeout;\n    this.update((state) => {\n      const previous = (state as any).requests[api][origin] ?? 0;\n      (state as any).requests[api][origin] = previous + 1;\n\n      if (previous === 0) {\n        setTimeout(() => this.resetRequestCount(api, origin), rateLimitTimeout);\n      }\n    });\n  }\n\n  /**\n   * Resets the request count for a given origin and API combination, for rate-limiting purposes.\n   *\n   * @param api - The API in question.\n   * @param origin - The origin in question.\n   */\n  private resetRequestCount(api: keyof RateLimitedApis, origin: string) {\n    this.update((state) => {\n      (state as any).requests[api][origin] = 0;\n    });\n  }\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './RateLimitController';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RateLimitController"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAsC","sourcesContent":["export * from './RateLimitController';\n"]}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@metamask-previews/rate-limit-controller",
+  "version": "3.0.0-preview.3dbf14f",
+  "description": "Contains logic for rate-limiting API endpoints by requesting origin",
+  "keywords": [
+    "MetaMask",
+    "Ethereum"
+  ],
+  "homepage": "https://github.com/MetaMask/core/tree/main/packages/rate-limit-controller#readme",
+  "bugs": {
+    "url": "https://github.com/MetaMask/core/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MetaMask/core.git"
+  },
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build:docs": "typedoc",
+    "changelog:validate": "../../scripts/validate-changelog.sh @metamask/rate-limit-controller",
+    "publish:preview": "yarn npm publish --tag preview",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "@metamask-previews/base-controller": "3.2.0-preview.3dbf14f",
+    "eth-rpc-errors": "^4.0.2",
+    "immer": "^9.0.6"
+  },
+  "devDependencies": {
+    "@metamask/auto-changelog": "^3.1.0",
+    "@types/jest": "^27.4.1",
+    "deepmerge": "^4.2.2",
+    "jest": "^27.5.1",
+    "ts-jest": "^27.1.4",
+    "typedoc": "^0.22.15",
+    "typedoc-plugin-missing-exports": "^0.22.6",
+    "typescript": "~4.6.3"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}