@metamask-previews/phishing-controller 6.0.0-preview.d32a7cc

package/CHANGELOG.md

@@ -0,0 +1,87 @@
+# 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]
+
+## [6.0.0]
+### Changed
+- **BREAKING:** Remove fallback phishing configuration ([#1527](https://github.com/MetaMask/core/pull/1527))
+  - The default configuration is now blank. A custom initial configuration can still be specified via the constructor to preserve the old behavior.
+
+## [5.0.0]
+### Changed
+- **BREAKING:** Bump to Node 16 ([#1262](https://github.com/MetaMask/core/pull/1262))
+
+## [4.0.0]
+### Changed
+- **BREAKING:** Switch to new phishing configuration API that returns a diff since the last update ([#1123](https://github.com/MetaMask/core/pull/1123))
+  - The "hotlist" has been replaced by a service that returns any configuration changes since the last update. This should reduce network traffic even further.
+  - The endpoints used are now `https://phishing-detection.metafi.codefi.network/v1/stalelist` and `https://phishing-detection.metafi.codefi.network/v1/diffsSince/:lastUpdated`
+- **BREAKING:**: The phishing controller state now keeps the MetaMask and PhishFort configuration separate, allowing for proper attribution of each block ([#1123](https://github.com/MetaMask/core/pull/1123))
+  - The `listState` state property has been replaced with an array of phishing list state objects (one entry for MetaMask, one for PhishFort).
+  - The PhishFort config is deduplicated server-side, so it should have zero overlap with the MetaMask configuration (which helps reduce memory/disk usage)
+
+## [3.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`
+
+## [2.0.0]
+### Changed
+- **BREAKING:** Refactor to Cost-Optimized Phishing List Data Architecture. ([#1080](https://github.com/MetaMask/core/pull/1080))
+  - Rather than periodically downloading two separate configurations (MetaMask and Phishfort), we now download a combined "stalelist" and "hotlist". The stalelist is downloaded every 4 days, and the hotlist is downloaded every 30 minutes. The hotlist only includes data from the last 8 days, which should dramatically reduce the required network traffic for phishing config updates.
+  - When a site is blocked, we no longer know which list is responsible due to the combined format. We will need to come up with another way to attribute blocks to a specific list; this controller will no longer be responsible for that.
+  - This change includes the removal of the exports:
+    - `METAMASK_CONFIG_FILE` and `PHISHFORT_HOTLIST_FILE` (replaced by `METAMASK_STALELIST_FILE` and `METAMASK_HOTLIST_DIFF_FILE`)
+    - `METAMASK_CONFIG_URL` and `PHISHFORT_HOTLIST_URL` (replaced by `METAMASK_STALELIST_URL` and `METAMASK_HOTLIST_DIFF_URL`)
+    - `EthPhishingResponse` (replaced by `PhishingStalelist` for the API response and `PhishingListState` for the list in controller state, as they're now different)
+  - The configuration has changed:
+    - Instead of accepting a `refreshInterval`, we now accept a separate interval for the stalelist and hotlist (`stalelistRefreshInterval` and `hotlistRefreshInterval`)
+  - The controller state has been updated:
+    - The phishing list itself has been renamed from `phishing` to `listState`, and the shape has changed. Removing the old `phishing` state would be advised, as it will get replaced by an updated configuration immediately anyway.
+    - `lastFetched` has been replaced by `hotlistLastFetched` and `stalelistLastFetched`. The old `lastFetched` state can be removed as well (it never needed to be persisted anyway).
+  - The `setRefreshInterval` method has been replaced by `setStalelistRefreshInterval` and `setHotlistRefreshInterval`
+  - The `isOutOfDate` method has been replaced by `isStalelistOutOfDate` and `isHotlistOutOfDate`
+  - The `maybeUpdatePhishingLists` method has been replaced by `maybeUpdateState`
+  - The `updatePhishingLists` method has been replaced by `updateStalelist` and `updateHotlist`
+
+## [1.1.2]
+### Fixed
+- Improve performance of phishing list update ([#1086](https://github.com/MetaMask/core/pull/1086))
+  - We now use a `Set` + `has` method instead of the array `includes` method for detecting overlap between phishing lists after an update.
+
+## [1.1.1]
+### 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.1.0]
+### Added
+- Add method to conditionally update the phishing lists ([#986](https://github.com/MetaMask/core/pull/986))
+
+### Changed
+- Relax dependencies on `@metamask/base-controller` and `@metamask/controller-utils` (use `^` instead of `~`) ([#998](https://github.com/MetaMask/core/pull/998))
+- Expose `lastFetched` in PhishingController state ([#986](https://github.com/MetaMask/core/pull/986))
+
+## [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:
+    - `src/third-party/PhishingController.ts`
+    - `src/third-party/PhishingController.test.ts`
+
+    All changes listed after this point were applied to this package following the monorepo conversion.
+
+[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/phishing-controller@6.0.0...HEAD
+[6.0.0]: https://github.com/MetaMask/core/compare/@metamask/phishing-controller@5.0.0...@metamask/phishing-controller@6.0.0
+[5.0.0]: https://github.com/MetaMask/core/compare/@metamask/phishing-controller@4.0.0...@metamask/phishing-controller@5.0.0
+[4.0.0]: https://github.com/MetaMask/core/compare/@metamask/phishing-controller@3.0.0...@metamask/phishing-controller@4.0.0
+[3.0.0]: https://github.com/MetaMask/core/compare/@metamask/phishing-controller@2.0.0...@metamask/phishing-controller@3.0.0
+[2.0.0]: https://github.com/MetaMask/core/compare/@metamask/phishing-controller@1.1.2...@metamask/phishing-controller@2.0.0
+[1.1.2]: https://github.com/MetaMask/core/compare/@metamask/phishing-controller@1.1.1...@metamask/phishing-controller@1.1.2
+[1.1.1]: https://github.com/MetaMask/core/compare/@metamask/phishing-controller@1.1.0...@metamask/phishing-controller@1.1.1
+[1.1.0]: https://github.com/MetaMask/core/compare/@metamask/phishing-controller@1.0.0...@metamask/phishing-controller@1.1.0
+[1.0.0]: https://github.com/MetaMask/core/releases/tag/@metamask/phishing-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/phishing-controller`
+
+Maintains a periodically updated list of approved and unapproved website origins.
+
+## Installation
+
+`yarn add @metamask/phishing-controller`
+
+or
+
+`npm install @metamask/phishing-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/PhishingController.d.ts

@@ -0,0 +1,256 @@
+import type { BaseConfig, BaseState } from '@metamask/base-controller';
+import { BaseController } from '@metamask/base-controller';
+/**
+ * @type ListTypes
+ *
+ * Type outlining the types of lists provided by aggregating different source lists
+ */
+export declare type ListTypes = 'fuzzylist' | 'blocklist' | 'allowlist';
+/**
+ * @type EthPhishingResponse
+ *
+ * Configuration response from the eth-phishing-detect package
+ * consisting of approved and unapproved website origins
+ * @property blacklist - List of unapproved origins
+ * @property fuzzylist - List of fuzzy-matched unapproved origins
+ * @property tolerance - Fuzzy match tolerance level
+ * @property version - Version number of this configuration
+ * @property whitelist - List of approved origins
+ */
+export interface EthPhishingResponse {
+    blacklist: string[];
+    fuzzylist: string[];
+    tolerance: number;
+    version: number;
+    whitelist: string[];
+}
+/**
+ * @type PhishingStalelist
+ *
+ * Interface defining expected type of the stalelist.json file.
+ * @property eth_phishing_detect_config - Stale list sourced from eth-phishing-detect's config.json.
+ * @property phishfort_hotlist - Stale list sourced from phishfort's hotlist.json. Only includes blocklist. Deduplicated entries from eth_phishing_detect_config.
+ * @property tolerance - Fuzzy match tolerance level
+ * @property lastUpdated - Timestamp of last update.
+ * @property version - Stalelist data structure iteration.
+ */
+export interface PhishingStalelist {
+    eth_phishing_detect_config: Record<ListTypes, string[]>;
+    phishfort_hotlist: Record<ListTypes, string[]>;
+    tolerance: number;
+    version: number;
+    lastUpdated: number;
+}
+/**
+ * @type PhishingListState
+ *
+ * Interface defining the persisted list state. This is the persisted state that is updated frequently with `this.maybeUpdateState()`.
+ * @property allowlist - List of approved origins (legacy naming "whitelist")
+ * @property blocklist - List of unapproved origins (legacy naming "blacklist")
+ * @property fuzzylist - List of fuzzy-matched unapproved origins
+ * @property tolerance - Fuzzy match tolerance level
+ * @property lastUpdated - Timestamp of last update.
+ * @property version - Version of the phishing list state.
+ * @property name - Name of the list. Used for attribution.
+ */
+export interface PhishingListState {
+    allowlist: string[];
+    blocklist: string[];
+    fuzzylist: string[];
+    tolerance: number;
+    version: number;
+    lastUpdated: number;
+    name: ListNames;
+}
+/**
+ * @type EthPhishingDetectResult
+ *
+ * Interface that describes the result of the `test` method.
+ * @property name - Name of the config on which a match was found.
+ * @property version - Version of the config on which a match was found.
+ * @property result - Whether a domain was detected as a phishing domain. True means an unsafe domain.
+ * @property match - The matching fuzzylist origin when a fuzzylist match is found. Returned as undefined for non-fuzzy true results.
+ * @property type - The field of the config on which a match was found.
+ */
+export interface EthPhishingDetectResult {
+    name?: string;
+    version?: string;
+    result: boolean;
+    match?: string;
+    type: 'all' | 'fuzzy' | 'blocklist' | 'allowlist';
+}
+/**
+ * @type HotlistDiff
+ *
+ * Interface defining the expected type of the diffs in hotlist.json file.
+ * @property url - Url of the diff entry.
+ * @property timestamp - Timestamp at which the diff was identified.
+ * @property targetList - The list name where the diff was identified.
+ * @property isRemoval - Was the diff identified a removal type.
+ */
+export interface HotlistDiff {
+    url: string;
+    timestamp: number;
+    targetList: `${ListKeys}.${ListTypes}`;
+    isRemoval?: boolean;
+}
+export interface DataResultWrapper<T> {
+    data: T;
+}
+/**
+ * @type Hotlist
+ *
+ * Type defining expected hotlist.json file.
+ * @property url - Url of the diff entry.
+ * @property timestamp - Timestamp at which the diff was identified.
+ * @property targetList - The list name where the diff was identified.
+ * @property isRemoval - Was the diff identified a removal type.
+ */
+export declare type Hotlist = HotlistDiff[];
+/**
+ * @type PhishingConfig
+ *
+ * Phishing controller configuration
+ * @property stalelistRefreshInterval - Polling interval used to fetch stale list.
+ * @property hotlistRefreshInterval - Polling interval used to fetch hotlist diff list.
+ */
+export interface PhishingConfig extends BaseConfig {
+    stalelistRefreshInterval: number;
+    hotlistRefreshInterval: number;
+}
+/**
+ * @type PhishingState
+ *
+ * Phishing controller state
+ * @property phishing - eth-phishing-detect configuration
+ * @property whitelist - array of temporarily-approved origins
+ */
+export interface PhishingState extends BaseState {
+    phishingLists: PhishingListState[];
+    whitelist: string[];
+    hotlistLastFetched: number;
+    stalelistLastFetched: number;
+}
+export declare const PHISHING_CONFIG_BASE_URL = "https://phishing-detection.metafi.codefi.network";
+export declare const METAMASK_STALELIST_FILE = "/v1/stalelist";
+export declare const METAMASK_HOTLIST_DIFF_FILE = "/v1/diffsSince";
+export declare const HOTLIST_REFRESH_INTERVAL: number;
+export declare const STALELIST_REFRESH_INTERVAL: number;
+export declare const METAMASK_STALELIST_URL: string;
+export declare const METAMASK_HOTLIST_DIFF_URL: string;
+/**
+ * Enum containing upstream data provider source list keys.
+ * These are the keys denoting lists consumed by the upstream data provider.
+ */
+export declare enum ListKeys {
+    PhishfortHotlist = "phishfort_hotlist",
+    EthPhishingDetectConfig = "eth_phishing_detect_config"
+}
+/**
+ * Enum containing downstream client attribution names.
+ */
+export declare enum ListNames {
+    MetaMask = "MetaMask",
+    Phishfort = "Phishfort"
+}
+/**
+ * Maps from list key sourced from upstream data
+ * provider to downstream client attribution name.
+ */
+export declare const phishingListKeyNameMap: {
+    eth_phishing_detect_config: ListNames;
+    phishfort_hotlist: ListNames;
+};
+/**
+ * Controller that manages community-maintained lists of approved and unapproved website origins.
+ */
+export declare class PhishingController extends BaseController<PhishingConfig, PhishingState> {
+    #private;
+    private detector;
+    /**
+     * Name of this controller used during composition
+     */
+    name: string;
+    /**
+     * Creates a PhishingController instance.
+     *
+     * @param config - Initial options used to configure this controller.
+     * @param state - Initial state to set on this controller.
+     */
+    constructor(config?: Partial<PhishingConfig>, state?: Partial<PhishingState>);
+    /**
+     * Updates this.detector with an instance of PhishingDetector using the current state.
+     */
+    updatePhishingDetector(): void;
+    /**
+     * Set the interval at which the stale phishing list will be refetched.
+     * Fetching will only occur on the next call to test/bypass.
+     * For immediate update to the phishing list, call {@link updateStalelist} directly.
+     *
+     * @param interval - the new interval, in ms.
+     */
+    setStalelistRefreshInterval(interval: number): void;
+    /**
+     * Set the interval at which the hot list will be refetched.
+     * Fetching will only occur on the next call to test/bypass.
+     * For immediate update to the phishing list, call {@link updateHotlist} directly.
+     *
+     * @param interval - the new interval, in ms.
+     */
+    setHotlistRefreshInterval(interval: number): void;
+    /**
+     * Determine if an update to the stalelist configuration is needed.
+     *
+     * @returns Whether an update is needed
+     */
+    isStalelistOutOfDate(): boolean;
+    /**
+     * Determine if an update to the hotlist configuration is needed.
+     *
+     * @returns Whether an update is needed
+     */
+    isHotlistOutOfDate(): boolean;
+    /**
+     * Conditionally update the phishing configuration.
+     *
+     * If the stalelist configuration is out of date, this function will call `updateStalelist`
+     * to update the configuration. This will automatically grab the hotlist,
+     * so it isn't necessary to continue on to download the hotlist.
+     *
+     */
+    maybeUpdateState(): Promise<void>;
+    /**
+     * Determines if a given origin is unapproved.
+     *
+     * It is strongly recommended that you call {@link maybeUpdateState} before calling this,
+     * to check whether the phishing configuration is up-to-date. It will be updated if necessary
+     * by calling {@link updateStalelist} or {@link updateHotlist}.
+     *
+     * @param origin - Domain origin of a website.
+     * @returns Whether the origin is an unapproved origin.
+     */
+    test(origin: string): EthPhishingDetectResult;
+    /**
+     * Temporarily marks a given origin as approved.
+     *
+     * @param origin - The origin to mark as approved.
+     */
+    bypass(origin: string): void;
+    /**
+     * Update the hotlist.
+     *
+     * If an update is in progress, no additional update will be made. Instead this will wait until
+     * the in-progress update has finished.
+     */
+    updateHotlist(): Promise<void>;
+    /**
+     * Update the stalelist.
+     *
+     * If an update is in progress, no additional update will be made. Instead this will wait until
+     * the in-progress update has finished.
+     */
+    updateStalelist(): Promise<void>;
+    private queryConfig;
+}
+export default PhishingController;
+//# sourceMappingURL=PhishingController.d.ts.map

package/dist/PhishingController.d.ts.map

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

package/dist/PhishingController.js

@@ -0,0 +1,335 @@
+"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());
+    });
+};
+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 __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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _PhishingController_instances, _PhishingController_inProgressHotlistUpdate, _PhishingController_inProgressStalelistUpdate, _PhishingController_updateStalelist, _PhishingController_updateHotlist;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhishingController = exports.phishingListKeyNameMap = exports.ListNames = exports.ListKeys = exports.METAMASK_HOTLIST_DIFF_URL = exports.METAMASK_STALELIST_URL = exports.STALELIST_REFRESH_INTERVAL = exports.HOTLIST_REFRESH_INTERVAL = exports.METAMASK_HOTLIST_DIFF_FILE = exports.METAMASK_STALELIST_FILE = exports.PHISHING_CONFIG_BASE_URL = void 0;
+const base_controller_1 = require("@metamask/base-controller");
+const controller_utils_1 = require("@metamask/controller-utils");
+const detector_1 = __importDefault(require("eth-phishing-detect/src/detector"));
+const punycode_1 = require("punycode/");
+const utils_1 = require("./utils");
+exports.PHISHING_CONFIG_BASE_URL = 'https://phishing-detection.metafi.codefi.network';
+exports.METAMASK_STALELIST_FILE = '/v1/stalelist';
+exports.METAMASK_HOTLIST_DIFF_FILE = '/v1/diffsSince';
+exports.HOTLIST_REFRESH_INTERVAL = 30 * 60; // 30 mins in seconds
+exports.STALELIST_REFRESH_INTERVAL = 4 * 24 * 60 * 60; // 4 days in seconds
+exports.METAMASK_STALELIST_URL = `${exports.PHISHING_CONFIG_BASE_URL}${exports.METAMASK_STALELIST_FILE}`;
+exports.METAMASK_HOTLIST_DIFF_URL = `${exports.PHISHING_CONFIG_BASE_URL}${exports.METAMASK_HOTLIST_DIFF_FILE}`;
+/**
+ * Enum containing upstream data provider source list keys.
+ * These are the keys denoting lists consumed by the upstream data provider.
+ */
+var ListKeys;
+(function (ListKeys) {
+    ListKeys["PhishfortHotlist"] = "phishfort_hotlist";
+    ListKeys["EthPhishingDetectConfig"] = "eth_phishing_detect_config";
+})(ListKeys = exports.ListKeys || (exports.ListKeys = {}));
+/**
+ * Enum containing downstream client attribution names.
+ */
+var ListNames;
+(function (ListNames) {
+    ListNames["MetaMask"] = "MetaMask";
+    ListNames["Phishfort"] = "Phishfort";
+})(ListNames = exports.ListNames || (exports.ListNames = {}));
+/**
+ * Maps from downstream client attribution name
+ * to list key sourced from upstream data provider.
+ */
+const phishingListNameKeyMap = {
+    [ListNames.Phishfort]: ListKeys.PhishfortHotlist,
+    [ListNames.MetaMask]: ListKeys.EthPhishingDetectConfig,
+};
+/**
+ * Maps from list key sourced from upstream data
+ * provider to downstream client attribution name.
+ */
+exports.phishingListKeyNameMap = {
+    [ListKeys.EthPhishingDetectConfig]: ListNames.MetaMask,
+    [ListKeys.PhishfortHotlist]: ListNames.Phishfort,
+};
+/**
+ * Controller that manages community-maintained lists of approved and unapproved website origins.
+ */
+class PhishingController extends base_controller_1.BaseController {
+    /**
+     * Creates a PhishingController instance.
+     *
+     * @param config - Initial options used to configure this controller.
+     * @param state - Initial state to set on this controller.
+     */
+    constructor(config, state) {
+        super(config, state);
+        _PhishingController_instances.add(this);
+        _PhishingController_inProgressHotlistUpdate.set(this, void 0);
+        _PhishingController_inProgressStalelistUpdate.set(this, void 0);
+        /**
+         * Name of this controller used during composition
+         */
+        this.name = 'PhishingController';
+        this.defaultConfig = {
+            stalelistRefreshInterval: exports.STALELIST_REFRESH_INTERVAL,
+            hotlistRefreshInterval: exports.HOTLIST_REFRESH_INTERVAL,
+        };
+        this.defaultState = {
+            phishingLists: [],
+            whitelist: [],
+            hotlistLastFetched: 0,
+            stalelistLastFetched: 0,
+        };
+        this.initialize();
+        this.updatePhishingDetector();
+    }
+    /**
+     * Updates this.detector with an instance of PhishingDetector using the current state.
+     */
+    updatePhishingDetector() {
+        this.detector = new detector_1.default(this.state.phishingLists);
+    }
+    /**
+     * Set the interval at which the stale phishing list will be refetched.
+     * Fetching will only occur on the next call to test/bypass.
+     * For immediate update to the phishing list, call {@link updateStalelist} directly.
+     *
+     * @param interval - the new interval, in ms.
+     */
+    setStalelistRefreshInterval(interval) {
+        this.configure({ stalelistRefreshInterval: interval }, false, false);
+    }
+    /**
+     * Set the interval at which the hot list will be refetched.
+     * Fetching will only occur on the next call to test/bypass.
+     * For immediate update to the phishing list, call {@link updateHotlist} directly.
+     *
+     * @param interval - the new interval, in ms.
+     */
+    setHotlistRefreshInterval(interval) {
+        this.configure({ hotlistRefreshInterval: interval }, false, false);
+    }
+    /**
+     * Determine if an update to the stalelist configuration is needed.
+     *
+     * @returns Whether an update is needed
+     */
+    isStalelistOutOfDate() {
+        return ((0, utils_1.fetchTimeNow)() - this.state.stalelistLastFetched >=
+            this.config.stalelistRefreshInterval);
+    }
+    /**
+     * Determine if an update to the hotlist configuration is needed.
+     *
+     * @returns Whether an update is needed
+     */
+    isHotlistOutOfDate() {
+        return ((0, utils_1.fetchTimeNow)() - this.state.hotlistLastFetched >=
+            this.config.hotlistRefreshInterval);
+    }
+    /**
+     * Conditionally update the phishing configuration.
+     *
+     * If the stalelist configuration is out of date, this function will call `updateStalelist`
+     * to update the configuration. This will automatically grab the hotlist,
+     * so it isn't necessary to continue on to download the hotlist.
+     *
+     */
+    maybeUpdateState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const staleListOutOfDate = this.isStalelistOutOfDate();
+            if (staleListOutOfDate) {
+                yield this.updateStalelist();
+                return;
+            }
+            const hotlistOutOfDate = this.isHotlistOutOfDate();
+            if (hotlistOutOfDate) {
+                yield this.updateHotlist();
+            }
+        });
+    }
+    /**
+     * Determines if a given origin is unapproved.
+     *
+     * It is strongly recommended that you call {@link maybeUpdateState} before calling this,
+     * to check whether the phishing configuration is up-to-date. It will be updated if necessary
+     * by calling {@link updateStalelist} or {@link updateHotlist}.
+     *
+     * @param origin - Domain origin of a website.
+     * @returns Whether the origin is an unapproved origin.
+     */
+    test(origin) {
+        const punycodeOrigin = (0, punycode_1.toASCII)(origin);
+        if (this.state.whitelist.includes(punycodeOrigin)) {
+            return { result: false, type: 'all' }; // Same as whitelisted match returned by detector.check(...).
+        }
+        return this.detector.check(punycodeOrigin);
+    }
+    /**
+     * Temporarily marks a given origin as approved.
+     *
+     * @param origin - The origin to mark as approved.
+     */
+    bypass(origin) {
+        const punycodeOrigin = (0, punycode_1.toASCII)(origin);
+        const { whitelist } = this.state;
+        if (whitelist.includes(punycodeOrigin)) {
+            return;
+        }
+        this.update({ whitelist: [...whitelist, punycodeOrigin] });
+    }
+    /**
+     * Update the hotlist.
+     *
+     * If an update is in progress, no additional update will be made. Instead this will wait until
+     * the in-progress update has finished.
+     */
+    updateHotlist() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (__classPrivateFieldGet(this, _PhishingController_inProgressHotlistUpdate, "f")) {
+                yield __classPrivateFieldGet(this, _PhishingController_inProgressHotlistUpdate, "f");
+                return;
+            }
+            try {
+                __classPrivateFieldSet(this, _PhishingController_inProgressHotlistUpdate, __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_updateHotlist).call(this), "f");
+                yield __classPrivateFieldGet(this, _PhishingController_inProgressHotlistUpdate, "f");
+            }
+            finally {
+                __classPrivateFieldSet(this, _PhishingController_inProgressHotlistUpdate, undefined, "f");
+            }
+        });
+    }
+    /**
+     * Update the stalelist.
+     *
+     * If an update is in progress, no additional update will be made. Instead this will wait until
+     * the in-progress update has finished.
+     */
+    updateStalelist() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (__classPrivateFieldGet(this, _PhishingController_inProgressStalelistUpdate, "f")) {
+                yield __classPrivateFieldGet(this, _PhishingController_inProgressStalelistUpdate, "f");
+                return;
+            }
+            try {
+                __classPrivateFieldSet(this, _PhishingController_inProgressStalelistUpdate, __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_updateStalelist).call(this), "f");
+                yield __classPrivateFieldGet(this, _PhishingController_inProgressStalelistUpdate, "f");
+            }
+            finally {
+                __classPrivateFieldSet(this, _PhishingController_inProgressStalelistUpdate, undefined, "f");
+            }
+        });
+    }
+    queryConfig(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield (0, controller_utils_1.safelyExecute)(() => fetch(input, { cache: 'no-cache' }), true);
+            switch (response === null || response === void 0 ? void 0 : response.status) {
+                case 200: {
+                    return yield response.json();
+                }
+                default: {
+                    return null;
+                }
+            }
+        });
+    }
+}
+exports.PhishingController = PhishingController;
+_PhishingController_inProgressHotlistUpdate = new WeakMap(), _PhishingController_inProgressStalelistUpdate = new WeakMap(), _PhishingController_instances = new WeakSet(), _PhishingController_updateStalelist = function _PhishingController_updateStalelist() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.disabled) {
+            return;
+        }
+        let stalelistResponse;
+        let hotlistDiffsResponse;
+        try {
+            stalelistResponse = yield this.queryConfig(exports.METAMASK_STALELIST_URL).then((d) => d);
+            // Fetching hotlist diffs relies on having a lastUpdated timestamp to do `GET /v1/diffsSince/:timestamp`,
+            // so it doesn't make sense to call if there is not a timestamp to begin with.
+            if ((stalelistResponse === null || stalelistResponse === void 0 ? void 0 : stalelistResponse.data) && stalelistResponse.data.lastUpdated > 0) {
+                hotlistDiffsResponse = yield this.queryConfig(`${exports.METAMASK_HOTLIST_DIFF_URL}/${stalelistResponse.data.lastUpdated}`);
+            }
+        }
+        finally {
+            // Set `stalelistLastFetched` and `hotlistLastFetched` even for failed requests to prevent server
+            // from being overwhelmed with traffic after a network disruption.
+            const timeNow = (0, utils_1.fetchTimeNow)();
+            this.update({
+                stalelistLastFetched: timeNow,
+                hotlistLastFetched: timeNow,
+            });
+        }
+        if (!stalelistResponse || !hotlistDiffsResponse) {
+            return;
+        }
+        const _a = stalelistResponse.data, { phishfort_hotlist, eth_phishing_detect_config } = _a, partialState = __rest(_a, ["phishfort_hotlist", "eth_phishing_detect_config"]);
+        const phishfortListState = Object.assign(Object.assign(Object.assign({}, phishfort_hotlist), partialState), { fuzzylist: [], allowlist: [], name: exports.phishingListKeyNameMap.phishfort_hotlist });
+        const metamaskListState = Object.assign(Object.assign(Object.assign({}, eth_phishing_detect_config), partialState), { name: exports.phishingListKeyNameMap.eth_phishing_detect_config });
+        // Correctly shaping eth-phishing-detect state by applying hotlist diffs to the stalelist.
+        const newPhishfortListState = (0, utils_1.applyDiffs)(phishfortListState, hotlistDiffsResponse.data, ListKeys.PhishfortHotlist);
+        const newMetaMaskListState = (0, utils_1.applyDiffs)(metamaskListState, hotlistDiffsResponse.data, ListKeys.EthPhishingDetectConfig);
+        this.update({
+            phishingLists: [newMetaMaskListState, newPhishfortListState],
+        });
+        this.updatePhishingDetector();
+    });
+}, _PhishingController_updateHotlist = function _PhishingController_updateHotlist() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.disabled) {
+            return;
+        }
+        const lastDiffTimestamp = Math.max(...this.state.phishingLists.map(({ lastUpdated }) => lastUpdated));
+        let hotlistResponse;
+        try {
+            hotlistResponse = yield this.queryConfig(`${exports.METAMASK_HOTLIST_DIFF_URL}/${lastDiffTimestamp}`);
+        }
+        finally {
+            // Set `hotlistLastFetched` even for failed requests to prevent server from being overwhelmed with
+            // traffic after a network disruption.
+            this.update({
+                hotlistLastFetched: (0, utils_1.fetchTimeNow)(),
+            });
+        }
+        if (!(hotlistResponse === null || hotlistResponse === void 0 ? void 0 : hotlistResponse.data)) {
+            return;
+        }
+        const hotlist = hotlistResponse.data;
+        const newPhishingLists = this.state.phishingLists.map((phishingList) => (0, utils_1.applyDiffs)(phishingList, hotlist, phishingListNameKeyMap[phishingList.name]));
+        this.update({
+            phishingLists: newPhishingLists,
+        });
+        this.updatePhishingDetector();
+    });
+};
+exports.default = PhishingController;
+//# sourceMappingURL=PhishingController.js.map

package/dist/PhishingController.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhishingController.js","sourceRoot":"","sources":["../src/PhishingController.ts"],"names":[],"mappings":"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","sourcesContent":["import type { BaseConfig, BaseState } from '@metamask/base-controller';\nimport { BaseController } from '@metamask/base-controller';\nimport { safelyExecute } from '@metamask/controller-utils';\nimport PhishingDetector from 'eth-phishing-detect/src/detector';\nimport { toASCII } from 'punycode/';\n\nimport { applyDiffs, fetchTimeNow } from './utils';\n\n/**\n * @type ListTypes\n *\n * Type outlining the types of lists provided by aggregating different source lists\n */\nexport type ListTypes = 'fuzzylist' | 'blocklist' | 'allowlist';\n\n/**\n * @type EthPhishingResponse\n *\n * Configuration response from the eth-phishing-detect package\n * consisting of approved and unapproved website origins\n * @property blacklist - List of unapproved origins\n * @property fuzzylist - List of fuzzy-matched unapproved origins\n * @property tolerance - Fuzzy match tolerance level\n * @property version - Version number of this configuration\n * @property whitelist - List of approved origins\n */\nexport interface EthPhishingResponse {\n  blacklist: string[];\n  fuzzylist: string[];\n  tolerance: number;\n  version: number;\n  whitelist: string[];\n}\n\n/**\n * @type PhishingStalelist\n *\n * Interface defining expected type of the stalelist.json file.\n * @property eth_phishing_detect_config - Stale list sourced from eth-phishing-detect's config.json.\n * @property phishfort_hotlist - Stale list sourced from phishfort's hotlist.json. Only includes blocklist. Deduplicated entries from eth_phishing_detect_config.\n * @property tolerance - Fuzzy match tolerance level\n * @property lastUpdated - Timestamp of last update.\n * @property version - Stalelist data structure iteration.\n */\nexport interface PhishingStalelist {\n  eth_phishing_detect_config: Record<ListTypes, string[]>;\n  phishfort_hotlist: Record<ListTypes, string[]>;\n  tolerance: number;\n  version: number;\n  lastUpdated: number;\n}\n\n/**\n * @type PhishingListState\n *\n * Interface defining the persisted list state. This is the persisted state that is updated frequently with `this.maybeUpdateState()`.\n * @property allowlist - List of approved origins (legacy naming \"whitelist\")\n * @property blocklist - List of unapproved origins (legacy naming \"blacklist\")\n * @property fuzzylist - List of fuzzy-matched unapproved origins\n * @property tolerance - Fuzzy match tolerance level\n * @property lastUpdated - Timestamp of last update.\n * @property version - Version of the phishing list state.\n * @property name - Name of the list. Used for attribution.\n */\nexport interface PhishingListState {\n  allowlist: string[];\n  blocklist: string[];\n  fuzzylist: string[];\n  tolerance: number;\n  version: number;\n  lastUpdated: number;\n  name: ListNames;\n}\n\n/**\n * @type EthPhishingDetectResult\n *\n * Interface that describes the result of the `test` method.\n * @property name - Name of the config on which a match was found.\n * @property version - Version of the config on which a match was found.\n * @property result - Whether a domain was detected as a phishing domain. True means an unsafe domain.\n * @property match - The matching fuzzylist origin when a fuzzylist match is found. Returned as undefined for non-fuzzy true results.\n * @property type - The field of the config on which a match was found.\n */\nexport interface EthPhishingDetectResult {\n  name?: string;\n  version?: string;\n  result: boolean;\n  match?: string; // Returned as undefined for non-fuzzy true results.\n  type: 'all' | 'fuzzy' | 'blocklist' | 'allowlist';\n}\n\n/**\n * @type HotlistDiff\n *\n * Interface defining the expected type of the diffs in hotlist.json file.\n * @property url - Url of the diff entry.\n * @property timestamp - Timestamp at which the diff was identified.\n * @property targetList - The list name where the diff was identified.\n * @property isRemoval - Was the diff identified a removal type.\n */\nexport interface HotlistDiff {\n  url: string;\n  timestamp: number;\n  targetList: `${ListKeys}.${ListTypes}`;\n  isRemoval?: boolean;\n}\n\nexport interface DataResultWrapper<T> {\n  data: T;\n}\n\n/**\n * @type Hotlist\n *\n * Type defining expected hotlist.json file.\n * @property url - Url of the diff entry.\n * @property timestamp - Timestamp at which the diff was identified.\n * @property targetList - The list name where the diff was identified.\n * @property isRemoval - Was the diff identified a removal type.\n */\nexport type Hotlist = HotlistDiff[];\n\n/**\n * @type PhishingConfig\n *\n * Phishing controller configuration\n * @property stalelistRefreshInterval - Polling interval used to fetch stale list.\n * @property hotlistRefreshInterval - Polling interval used to fetch hotlist diff list.\n */\nexport interface PhishingConfig extends BaseConfig {\n  stalelistRefreshInterval: number;\n  hotlistRefreshInterval: number;\n}\n\n/**\n * @type PhishingState\n *\n * Phishing controller state\n * @property phishing - eth-phishing-detect configuration\n * @property whitelist - array of temporarily-approved origins\n */\nexport interface PhishingState extends BaseState {\n  phishingLists: PhishingListState[];\n  whitelist: string[];\n  hotlistLastFetched: number;\n  stalelistLastFetched: number;\n}\n\nexport const PHISHING_CONFIG_BASE_URL =\n  'https://phishing-detection.metafi.codefi.network';\n\nexport const METAMASK_STALELIST_FILE = '/v1/stalelist';\n\nexport const METAMASK_HOTLIST_DIFF_FILE = '/v1/diffsSince';\n\nexport const HOTLIST_REFRESH_INTERVAL = 30 * 60; // 30 mins in seconds\nexport const STALELIST_REFRESH_INTERVAL = 4 * 24 * 60 * 60; // 4 days in seconds\n\nexport const METAMASK_STALELIST_URL = `${PHISHING_CONFIG_BASE_URL}${METAMASK_STALELIST_FILE}`;\nexport const METAMASK_HOTLIST_DIFF_URL = `${PHISHING_CONFIG_BASE_URL}${METAMASK_HOTLIST_DIFF_FILE}`;\n\n/**\n * Enum containing upstream data provider source list keys.\n * These are the keys denoting lists consumed by the upstream data provider.\n */\nexport enum ListKeys {\n  PhishfortHotlist = 'phishfort_hotlist',\n  EthPhishingDetectConfig = 'eth_phishing_detect_config',\n}\n\n/**\n * Enum containing downstream client attribution names.\n */\nexport enum ListNames {\n  MetaMask = 'MetaMask',\n  Phishfort = 'Phishfort',\n}\n\n/**\n * Maps from downstream client attribution name\n * to list key sourced from upstream data provider.\n */\nconst phishingListNameKeyMap = {\n  [ListNames.Phishfort]: ListKeys.PhishfortHotlist,\n  [ListNames.MetaMask]: ListKeys.EthPhishingDetectConfig,\n};\n\n/**\n * Maps from list key sourced from upstream data\n * provider to downstream client attribution name.\n */\nexport const phishingListKeyNameMap = {\n  [ListKeys.EthPhishingDetectConfig]: ListNames.MetaMask,\n  [ListKeys.PhishfortHotlist]: ListNames.Phishfort,\n};\n\n/**\n * Controller that manages community-maintained lists of approved and unapproved website origins.\n */\nexport class PhishingController extends BaseController<\n  PhishingConfig,\n  PhishingState\n> {\n  private detector: any;\n\n  #inProgressHotlistUpdate: Promise<void> | undefined;\n\n  #inProgressStalelistUpdate: Promise<void> | undefined;\n\n  /**\n   * Name of this controller used during composition\n   */\n  override name = 'PhishingController';\n\n  /**\n   * Creates a PhishingController instance.\n   *\n   * @param config - Initial options used to configure this controller.\n   * @param state - Initial state to set on this controller.\n   */\n  constructor(\n    config?: Partial<PhishingConfig>,\n    state?: Partial<PhishingState>,\n  ) {\n    super(config, state);\n    this.defaultConfig = {\n      stalelistRefreshInterval: STALELIST_REFRESH_INTERVAL,\n      hotlistRefreshInterval: HOTLIST_REFRESH_INTERVAL,\n    };\n\n    this.defaultState = {\n      phishingLists: [],\n      whitelist: [],\n      hotlistLastFetched: 0,\n      stalelistLastFetched: 0,\n    };\n\n    this.initialize();\n    this.updatePhishingDetector();\n  }\n\n  /**\n   * Updates this.detector with an instance of PhishingDetector using the current state.\n   */\n  updatePhishingDetector() {\n    this.detector = new PhishingDetector(this.state.phishingLists);\n  }\n\n  /**\n   * Set the interval at which the stale phishing list will be refetched.\n   * Fetching will only occur on the next call to test/bypass.\n   * For immediate update to the phishing list, call {@link updateStalelist} directly.\n   *\n   * @param interval - the new interval, in ms.\n   */\n  setStalelistRefreshInterval(interval: number) {\n    this.configure({ stalelistRefreshInterval: interval }, false, false);\n  }\n\n  /**\n   * Set the interval at which the hot list will be refetched.\n   * Fetching will only occur on the next call to test/bypass.\n   * For immediate update to the phishing list, call {@link updateHotlist} directly.\n   *\n   * @param interval - the new interval, in ms.\n   */\n  setHotlistRefreshInterval(interval: number) {\n    this.configure({ hotlistRefreshInterval: interval }, false, false);\n  }\n\n  /**\n   * Determine if an update to the stalelist configuration is needed.\n   *\n   * @returns Whether an update is needed\n   */\n  isStalelistOutOfDate() {\n    return (\n      fetchTimeNow() - this.state.stalelistLastFetched >=\n      this.config.stalelistRefreshInterval\n    );\n  }\n\n  /**\n   * Determine if an update to the hotlist configuration is needed.\n   *\n   * @returns Whether an update is needed\n   */\n  isHotlistOutOfDate() {\n    return (\n      fetchTimeNow() - this.state.hotlistLastFetched >=\n      this.config.hotlistRefreshInterval\n    );\n  }\n\n  /**\n   * Conditionally update the phishing configuration.\n   *\n   * If the stalelist configuration is out of date, this function will call `updateStalelist`\n   * to update the configuration. This will automatically grab the hotlist,\n   * so it isn't necessary to continue on to download the hotlist.\n   *\n   */\n  async maybeUpdateState() {\n    const staleListOutOfDate = this.isStalelistOutOfDate();\n    if (staleListOutOfDate) {\n      await this.updateStalelist();\n      return;\n    }\n    const hotlistOutOfDate = this.isHotlistOutOfDate();\n    if (hotlistOutOfDate) {\n      await this.updateHotlist();\n    }\n  }\n\n  /**\n   * Determines if a given origin is unapproved.\n   *\n   * It is strongly recommended that you call {@link maybeUpdateState} before calling this,\n   * to check whether the phishing configuration is up-to-date. It will be updated if necessary\n   * by calling {@link updateStalelist} or {@link updateHotlist}.\n   *\n   * @param origin - Domain origin of a website.\n   * @returns Whether the origin is an unapproved origin.\n   */\n  test(origin: string): EthPhishingDetectResult {\n    const punycodeOrigin = toASCII(origin);\n    if (this.state.whitelist.includes(punycodeOrigin)) {\n      return { result: false, type: 'all' }; // Same as whitelisted match returned by detector.check(...).\n    }\n    return this.detector.check(punycodeOrigin);\n  }\n\n  /**\n   * Temporarily marks a given origin as approved.\n   *\n   * @param origin - The origin to mark as approved.\n   */\n  bypass(origin: string) {\n    const punycodeOrigin = toASCII(origin);\n    const { whitelist } = this.state;\n    if (whitelist.includes(punycodeOrigin)) {\n      return;\n    }\n    this.update({ whitelist: [...whitelist, punycodeOrigin] });\n  }\n\n  /**\n   * Update the hotlist.\n   *\n   * If an update is in progress, no additional update will be made. Instead this will wait until\n   * the in-progress update has finished.\n   */\n  async updateHotlist() {\n    if (this.#inProgressHotlistUpdate) {\n      await this.#inProgressHotlistUpdate;\n      return;\n    }\n\n    try {\n      this.#inProgressHotlistUpdate = this.#updateHotlist();\n      await this.#inProgressHotlistUpdate;\n    } finally {\n      this.#inProgressHotlistUpdate = undefined;\n    }\n  }\n\n  /**\n   * Update the stalelist.\n   *\n   * If an update is in progress, no additional update will be made. Instead this will wait until\n   * the in-progress update has finished.\n   */\n  async updateStalelist() {\n    if (this.#inProgressStalelistUpdate) {\n      await this.#inProgressStalelistUpdate;\n      return;\n    }\n\n    try {\n      this.#inProgressStalelistUpdate = this.#updateStalelist();\n      await this.#inProgressStalelistUpdate;\n    } finally {\n      this.#inProgressStalelistUpdate = undefined;\n    }\n  }\n\n  /**\n   * Update the stalelist configuration.\n   *\n   * This should only be called from the `updateStalelist` function, which is a wrapper around\n   * this function that prevents redundant configuration updates.\n   */\n  async #updateStalelist() {\n    if (this.disabled) {\n      return;\n    }\n\n    let stalelistResponse;\n    let hotlistDiffsResponse;\n    try {\n      stalelistResponse = await this.queryConfig<\n        DataResultWrapper<PhishingStalelist>\n      >(METAMASK_STALELIST_URL).then((d) => d);\n\n      // Fetching hotlist diffs relies on having a lastUpdated timestamp to do `GET /v1/diffsSince/:timestamp`,\n      // so it doesn't make sense to call if there is not a timestamp to begin with.\n      if (stalelistResponse?.data && stalelistResponse.data.lastUpdated > 0) {\n        hotlistDiffsResponse = await this.queryConfig<\n          DataResultWrapper<Hotlist>\n        >(`${METAMASK_HOTLIST_DIFF_URL}/${stalelistResponse.data.lastUpdated}`);\n      }\n    } finally {\n      // Set `stalelistLastFetched` and `hotlistLastFetched` even for failed requests to prevent server\n      // from being overwhelmed with traffic after a network disruption.\n      const timeNow = fetchTimeNow();\n      this.update({\n        stalelistLastFetched: timeNow,\n        hotlistLastFetched: timeNow,\n      });\n    }\n\n    if (!stalelistResponse || !hotlistDiffsResponse) {\n      return;\n    }\n\n    const { phishfort_hotlist, eth_phishing_detect_config, ...partialState } =\n      stalelistResponse.data;\n\n    const phishfortListState: PhishingListState = {\n      ...phishfort_hotlist,\n      ...partialState,\n      fuzzylist: [], // Phishfort hotlist doesn't contain a fuzzylist\n      allowlist: [], // Phishfort hotlist doesn't contain an allowlist\n      name: phishingListKeyNameMap.phishfort_hotlist,\n    };\n    const metamaskListState: PhishingListState = {\n      ...eth_phishing_detect_config,\n      ...partialState,\n      name: phishingListKeyNameMap.eth_phishing_detect_config,\n    };\n    // Correctly shaping eth-phishing-detect state by applying hotlist diffs to the stalelist.\n    const newPhishfortListState: PhishingListState = applyDiffs(\n      phishfortListState,\n      hotlistDiffsResponse.data,\n      ListKeys.PhishfortHotlist,\n    );\n    const newMetaMaskListState: PhishingListState = applyDiffs(\n      metamaskListState,\n      hotlistDiffsResponse.data,\n      ListKeys.EthPhishingDetectConfig,\n    );\n\n    this.update({\n      phishingLists: [newMetaMaskListState, newPhishfortListState],\n    });\n    this.updatePhishingDetector();\n  }\n\n  /**\n   * Update the stalelist configuration.\n   *\n   * This should only be called from the `updateStalelist` function, which is a wrapper around\n   * this function that prevents redundant configuration updates.\n   */\n  async #updateHotlist() {\n    if (this.disabled) {\n      return;\n    }\n    const lastDiffTimestamp = Math.max(\n      ...this.state.phishingLists.map(({ lastUpdated }) => lastUpdated),\n    );\n    let hotlistResponse: DataResultWrapper<Hotlist> | null;\n\n    try {\n      hotlistResponse = await this.queryConfig<DataResultWrapper<Hotlist>>(\n        `${METAMASK_HOTLIST_DIFF_URL}/${lastDiffTimestamp}`,\n      );\n    } finally {\n      // Set `hotlistLastFetched` even for failed requests to prevent server from being overwhelmed with\n      // traffic after a network disruption.\n      this.update({\n        hotlistLastFetched: fetchTimeNow(),\n      });\n    }\n\n    if (!hotlistResponse?.data) {\n      return;\n    }\n    const hotlist = hotlistResponse.data;\n    const newPhishingLists = this.state.phishingLists.map((phishingList) =>\n      applyDiffs(\n        phishingList,\n        hotlist,\n        phishingListNameKeyMap[phishingList.name],\n      ),\n    );\n\n    this.update({\n      phishingLists: newPhishingLists,\n    });\n    this.updatePhishingDetector();\n  }\n\n  private async queryConfig<ResponseType>(\n    input: RequestInfo,\n  ): Promise<ResponseType | null> {\n    const response = await safelyExecute(\n      () => fetch(input, { cache: 'no-cache' }),\n      true,\n    );\n\n    switch (response?.status) {\n      case 200: {\n        return await response.json();\n      }\n\n      default: {\n        return null;\n      }\n    }\n  }\n}\n\nexport default PhishingController;\n"]}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './PhishingController';
+//# 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,sBAAsB,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("./PhishingController"), 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,uDAAqC","sourcesContent":["export * from './PhishingController';\n"]}

package/dist/utils.d.ts

@@ -0,0 +1,17 @@
+import type { Hotlist, ListKeys, PhishingListState } from './PhishingController';
+/**
+ * Fetches current epoch time in seconds.
+ *
+ * @returns the Date.now() time in seconds instead of miliseconds. backend files rely on timestamps in seconds since epoch.
+ */
+export declare const fetchTimeNow: () => number;
+/**
+ * Determines which diffs are applicable to the listState, then applies those diffs.
+ *
+ * @param listState - the stalelist or the existing liststate that diffs will be applied to.
+ * @param hotlistDiffs - the diffs to apply to the listState if valid.
+ * @param listKey - the key associated with the input/output phishing list state.
+ * @returns the new list state
+ */
+export declare const applyDiffs: (listState: PhishingListState, hotlistDiffs: Hotlist, listKey: ListKeys) => PhishingListState;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,QAAQ,EACR,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAE9B;;;;GAIG;AACH,eAAO,MAAM,YAAY,QAAO,MAAuC,CAAC;AAkBxE;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,cACV,iBAAiB,kCAEnB,QAAQ,KAChB,iBAyCF,CAAC"}

package/dist/utils.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDiffs = exports.fetchTimeNow = void 0;
+const PhishingController_1 = require("./PhishingController");
+/**
+ * Fetches current epoch time in seconds.
+ *
+ * @returns the Date.now() time in seconds instead of miliseconds. backend files rely on timestamps in seconds since epoch.
+ */
+const fetchTimeNow = () => Math.round(Date.now() / 1000);
+exports.fetchTimeNow = fetchTimeNow;
+/**
+ * Split a string into two pieces, using the first period as the delimiter.
+ *
+ * @param stringToSplit - The string to split.
+ * @returns An array of length two containing the beginning and end of the string.
+ */
+const splitStringByPeriod = (stringToSplit) => {
+    const periodIndex = stringToSplit.indexOf('.');
+    return [
+        stringToSplit.slice(0, periodIndex),
+        stringToSplit.slice(periodIndex + 1),
+    ];
+};
+/**
+ * Determines which diffs are applicable to the listState, then applies those diffs.
+ *
+ * @param listState - the stalelist or the existing liststate that diffs will be applied to.
+ * @param hotlistDiffs - the diffs to apply to the listState if valid.
+ * @param listKey - the key associated with the input/output phishing list state.
+ * @returns the new list state
+ */
+const applyDiffs = (listState, hotlistDiffs, listKey) => {
+    // filter to remove diffs that were added before the lastUpdate time.
+    // filter to remove diffs that aren't applicable to the specified list (by listKey).
+    const diffsToApply = hotlistDiffs.filter(({ timestamp, targetList }) => timestamp > listState.lastUpdated &&
+        splitStringByPeriod(targetList)[0] === listKey);
+    // the reason behind using latestDiffTimestamp as the lastUpdated time
+    // is so that we can benefit server-side from memoization due to end client's
+    // `GET /v1/diffSince/:timestamp` requests lining up with
+    // our periodic updates (which create diffs at specific timestamps).
+    let latestDiffTimestamp = listState.lastUpdated;
+    const listSets = {
+        allowlist: new Set(listState.allowlist),
+        blocklist: new Set(listState.blocklist),
+        fuzzylist: new Set(listState.fuzzylist),
+    };
+    for (const { isRemoval, targetList, url, timestamp } of diffsToApply) {
+        const targetListType = splitStringByPeriod(targetList)[1];
+        if (timestamp > latestDiffTimestamp) {
+            latestDiffTimestamp = timestamp;
+        }
+        if (isRemoval) {
+            listSets[targetListType].delete(url);
+        }
+        else {
+            listSets[targetListType].add(url);
+        }
+    }
+    return {
+        allowlist: Array.from(listSets.allowlist),
+        blocklist: Array.from(listSets.blocklist),
+        fuzzylist: Array.from(listSets.fuzzylist),
+        version: listState.version,
+        name: PhishingController_1.phishingListKeyNameMap[listKey],
+        tolerance: listState.tolerance,
+        lastUpdated: latestDiffTimestamp,
+    };
+};
+exports.applyDiffs = applyDiffs;
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":";;;AAKA,6DAA8D;AAC9D;;;;GAIG;AACI,MAAM,YAAY,GAAG,GAAW,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;AAA3D,QAAA,YAAY,gBAA+C;AAExE;;;;;GAKG;AACH,MAAM,mBAAmB,GAAG,CAC1B,aAAgC,EAClB,EAAE;IAChB,MAAM,WAAW,GAAG,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/C,OAAO;QACL,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,WAAW,CAAU;QAC5C,aAAa,CAAC,KAAK,CAAC,WAAW,GAAG,CAAC,CAAQ;KAC5C,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;GAOG;AACI,MAAM,UAAU,GAAG,CACxB,SAA4B,EAC5B,YAAqB,EACrB,OAAiB,EACE,EAAE;IACrB,qEAAqE;IACrE,oFAAoF;IACpF,MAAM,YAAY,GAAG,YAAY,CAAC,MAAM,CACtC,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,EAAE,EAAE,CAC5B,SAAS,GAAG,SAAS,CAAC,WAAW;QACjC,mBAAmB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CACjD,CAAC;IAEF,sEAAsE;IACtE,6EAA6E;IAC7E,yDAAyD;IACzD,oEAAoE;IACpE,IAAI,mBAAmB,GAAG,SAAS,CAAC,WAAW,CAAC;IAEhD,MAAM,QAAQ,GAAG;QACf,SAAS,EAAE,IAAI,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC;QACvC,SAAS,EAAE,IAAI,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC;QACvC,SAAS,EAAE,IAAI,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC;KACxC,CAAC;IACF,KAAK,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,YAAY,EAAE;QACpE,MAAM,cAAc,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1D,IAAI,SAAS,GAAG,mBAAmB,EAAE;YACnC,mBAAmB,GAAG,SAAS,CAAC;SACjC;QACD,IAAI,SAAS,EAAE;YACb,QAAQ,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;SACtC;aAAM;YACL,QAAQ,CAAC,cAAc,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;SACnC;KACF;IAED,OAAO;QACL,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;QACzC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;QACzC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;QACzC,OAAO,EAAE,SAAS,CAAC,OAAO;QAC1B,IAAI,EAAE,2CAAsB,CAAC,OAAO,CAAC;QACrC,SAAS,EAAE,SAAS,CAAC,SAAS;QAC9B,WAAW,EAAE,mBAAmB;KACjC,CAAC;AACJ,CAAC,CAAC;AA7CW,QAAA,UAAU,cA6CrB","sourcesContent":["import type {\n  Hotlist,\n  ListKeys,\n  PhishingListState,\n} from './PhishingController';\nimport { phishingListKeyNameMap } from './PhishingController';\n/**\n * Fetches current epoch time in seconds.\n *\n * @returns the Date.now() time in seconds instead of miliseconds. backend files rely on timestamps in seconds since epoch.\n */\nexport const fetchTimeNow = (): number => Math.round(Date.now() / 1000);\n\n/**\n * Split a string into two pieces, using the first period as the delimiter.\n *\n * @param stringToSplit - The string to split.\n * @returns An array of length two containing the beginning and end of the string.\n */\nconst splitStringByPeriod = <Start extends string, End extends string>(\n  stringToSplit: `${Start}.${End}`,\n): [Start, End] => {\n  const periodIndex = stringToSplit.indexOf('.');\n  return [\n    stringToSplit.slice(0, periodIndex) as Start,\n    stringToSplit.slice(periodIndex + 1) as End,\n  ];\n};\n\n/**\n * Determines which diffs are applicable to the listState, then applies those diffs.\n *\n * @param listState - the stalelist or the existing liststate that diffs will be applied to.\n * @param hotlistDiffs - the diffs to apply to the listState if valid.\n * @param listKey - the key associated with the input/output phishing list state.\n * @returns the new list state\n */\nexport const applyDiffs = (\n  listState: PhishingListState,\n  hotlistDiffs: Hotlist,\n  listKey: ListKeys,\n): PhishingListState => {\n  // filter to remove diffs that were added before the lastUpdate time.\n  // filter to remove diffs that aren't applicable to the specified list (by listKey).\n  const diffsToApply = hotlistDiffs.filter(\n    ({ timestamp, targetList }) =>\n      timestamp > listState.lastUpdated &&\n      splitStringByPeriod(targetList)[0] === listKey,\n  );\n\n  // the reason behind using latestDiffTimestamp as the lastUpdated time\n  // is so that we can benefit server-side from memoization due to end client's\n  // `GET /v1/diffSince/:timestamp` requests lining up with\n  // our periodic updates (which create diffs at specific timestamps).\n  let latestDiffTimestamp = listState.lastUpdated;\n\n  const listSets = {\n    allowlist: new Set(listState.allowlist),\n    blocklist: new Set(listState.blocklist),\n    fuzzylist: new Set(listState.fuzzylist),\n  };\n  for (const { isRemoval, targetList, url, timestamp } of diffsToApply) {\n    const targetListType = splitStringByPeriod(targetList)[1];\n    if (timestamp > latestDiffTimestamp) {\n      latestDiffTimestamp = timestamp;\n    }\n    if (isRemoval) {\n      listSets[targetListType].delete(url);\n    } else {\n      listSets[targetListType].add(url);\n    }\n  }\n\n  return {\n    allowlist: Array.from(listSets.allowlist),\n    blocklist: Array.from(listSets.blocklist),\n    fuzzylist: Array.from(listSets.fuzzylist),\n    version: listState.version,\n    name: phishingListKeyNameMap[listKey],\n    tolerance: listState.tolerance,\n    lastUpdated: latestDiffTimestamp,\n  };\n};\n"]}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@metamask-previews/phishing-controller",
+  "version": "6.0.0-preview.d32a7cc",
+  "description": "Maintains a periodically updated list of approved and unapproved website origins",
+  "keywords": [
+    "MetaMask",
+    "Ethereum"
+  ],
+  "homepage": "https://github.com/MetaMask/core/tree/main/packages/phishing-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/phishing-controller",
+    "publish:preview": "yarn npm publish --tag preview",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "@metamask-previews/base-controller": "3.2.0-preview.d32a7cc",
+    "@metamask-previews/controller-utils": "4.3.1-preview.d32a7cc",
+    "@types/punycode": "^2.1.0",
+    "eth-phishing-detect": "^1.2.0",
+    "punycode": "^2.1.1"
+  },
+  "devDependencies": {
+    "@metamask/auto-changelog": "^3.1.0",
+    "@types/jest": "^27.4.1",
+    "deepmerge": "^4.2.2",
+    "jest": "^27.5.1",
+    "nock": "^13.3.1",
+    "sinon": "^9.2.4",
+    "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/"
+  }
+}