@metamask-previews/phishing-controller 17.4.0-preview-4f4c98e → 17.4.0-preview-eb263b0ee

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (103) hide show
  1. package/CHANGELOG.md +0 -2
  2. package/dist/CacheManager.cjs +177 -0
  3. package/dist/CacheManager.cjs.map +1 -0
  4. package/dist/{CacheManager.d.ts → CacheManager.d.cts} +1 -1
  5. package/dist/CacheManager.d.cts.map +1 -0
  6. package/dist/CacheManager.d.mts +104 -0
  7. package/dist/CacheManager.d.mts.map +1 -0
  8. package/dist/{CacheManager.js → CacheManager.mjs} +2 -2
  9. package/dist/CacheManager.mjs.map +1 -0
  10. package/dist/PathTrie.cjs +169 -0
  11. package/dist/PathTrie.cjs.map +1 -0
  12. package/dist/{PathTrie.d.ts → PathTrie.d.cts} +1 -1
  13. package/dist/PathTrie.d.cts.map +1 -0
  14. package/dist/PathTrie.d.mts +46 -0
  15. package/dist/PathTrie.d.mts.map +1 -0
  16. package/dist/{PathTrie.js → PathTrie.mjs} +2 -2
  17. package/dist/PathTrie.mjs.map +1 -0
  18. package/dist/PhishingController-method-action-types.cjs +7 -0
  19. package/dist/PhishingController-method-action-types.cjs.map +1 -0
  20. package/dist/{PhishingController-method-action-types.d.ts → PhishingController-method-action-types.d.cts} +2 -2
  21. package/dist/PhishingController-method-action-types.d.cts.map +1 -0
  22. package/dist/PhishingController-method-action-types.d.mts +123 -0
  23. package/dist/PhishingController-method-action-types.d.mts.map +1 -0
  24. package/dist/{PhishingController-method-action-types.js → PhishingController-method-action-types.mjs} +1 -1
  25. package/dist/PhishingController-method-action-types.mjs.map +1 -0
  26. package/dist/PhishingController.cjs +1222 -0
  27. package/dist/PhishingController.cjs.map +1 -0
  28. package/dist/{PhishingController.d.ts → PhishingController.d.cts} +10 -10
  29. package/dist/PhishingController.d.cts.map +1 -0
  30. package/dist/PhishingController.d.mts +425 -0
  31. package/dist/PhishingController.d.mts.map +1 -0
  32. package/dist/{PhishingController.js → PhishingController.mjs} +12 -11
  33. package/dist/PhishingController.mjs.map +1 -0
  34. package/dist/PhishingDetector.cjs +277 -0
  35. package/dist/PhishingDetector.cjs.map +1 -0
  36. package/dist/{PhishingDetector.d.ts → PhishingDetector.d.cts} +4 -4
  37. package/dist/PhishingDetector.d.cts.map +1 -0
  38. package/dist/PhishingDetector.d.mts +73 -0
  39. package/dist/PhishingDetector.d.mts.map +1 -0
  40. package/dist/{PhishingDetector.js → PhishingDetector.mjs} +15 -21
  41. package/dist/PhishingDetector.mjs.map +1 -0
  42. package/dist/address-poisoning.cjs +71 -0
  43. package/dist/address-poisoning.cjs.map +1 -0
  44. package/dist/{address-poisoning.d.ts → address-poisoning.d.cts} +2 -2
  45. package/dist/address-poisoning.d.cts.map +1 -0
  46. package/dist/address-poisoning.d.mts +3 -0
  47. package/dist/address-poisoning.d.mts.map +1 -0
  48. package/dist/{address-poisoning.js → address-poisoning.mjs} +2 -2
  49. package/dist/address-poisoning.mjs.map +1 -0
  50. package/dist/index.cjs +36 -0
  51. package/dist/index.cjs.map +1 -0
  52. package/dist/{index.d.ts → index.d.cts} +12 -12
  53. package/dist/index.d.cts.map +1 -0
  54. package/dist/index.d.mts +12 -0
  55. package/dist/index.d.mts.map +1 -0
  56. package/dist/index.mjs +7 -0
  57. package/dist/index.mjs.map +1 -0
  58. package/dist/tests/utils.cjs +102 -0
  59. package/dist/tests/utils.cjs.map +1 -0
  60. package/dist/tests/{utils.d.ts → utils.d.cts} +3 -3
  61. package/dist/tests/utils.d.cts.map +1 -0
  62. package/dist/tests/utils.d.mts +70 -0
  63. package/dist/tests/utils.d.mts.map +1 -0
  64. package/dist/tests/{utils.js → utils.mjs} +2 -2
  65. package/dist/tests/utils.mjs.map +1 -0
  66. package/dist/types.cjs +267 -0
  67. package/dist/types.cjs.map +1 -0
  68. package/dist/{types.d.ts → types.d.cts} +62 -62
  69. package/dist/types.d.cts.map +1 -0
  70. package/dist/types.d.mts +338 -0
  71. package/dist/types.d.mts.map +1 -0
  72. package/dist/{types.js → types.mjs} +1 -1
  73. package/dist/types.mjs.map +1 -0
  74. package/dist/utils.cjs +522 -0
  75. package/dist/utils.cjs.map +1 -0
  76. package/dist/{utils.d.ts → utils.d.cts} +72 -74
  77. package/dist/utils.d.cts.map +1 -0
  78. package/dist/utils.d.mts +302 -0
  79. package/dist/utils.d.mts.map +1 -0
  80. package/dist/{utils.js → utils.mjs} +16 -16
  81. package/dist/utils.mjs.map +1 -0
  82. package/package.json +16 -12
  83. package/dist/CacheManager.d.ts.map +0 -1
  84. package/dist/CacheManager.js.map +0 -1
  85. package/dist/PathTrie.d.ts.map +0 -1
  86. package/dist/PathTrie.js.map +0 -1
  87. package/dist/PhishingController-method-action-types.d.ts.map +0 -1
  88. package/dist/PhishingController-method-action-types.js.map +0 -1
  89. package/dist/PhishingController.d.ts.map +0 -1
  90. package/dist/PhishingController.js.map +0 -1
  91. package/dist/PhishingDetector.d.ts.map +0 -1
  92. package/dist/PhishingDetector.js.map +0 -1
  93. package/dist/address-poisoning.d.ts.map +0 -1
  94. package/dist/address-poisoning.js.map +0 -1
  95. package/dist/index.d.ts.map +0 -1
  96. package/dist/index.js +0 -7
  97. package/dist/index.js.map +0 -1
  98. package/dist/tests/utils.d.ts.map +0 -1
  99. package/dist/tests/utils.js.map +0 -1
  100. package/dist/types.d.ts.map +0 -1
  101. package/dist/types.js.map +0 -1
  102. package/dist/utils.d.ts.map +0 -1
  103. package/dist/utils.js.map +0 -1
@@ -0,0 +1,1222 @@
1
+ "use strict";
2
+ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
3
+ if (kind === "m") throw new TypeError("Private method is not writable");
4
+ if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
5
+ 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");
6
+ return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
7
+ };
8
+ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
9
+ if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
10
+ 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");
11
+ return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
12
+ };
13
+ var _PhishingController_instances, _PhishingController_detector, _PhishingController_stalelistRefreshInterval, _PhishingController_hotlistRefreshInterval, _PhishingController_c2DomainBlocklistRefreshInterval, _PhishingController_urlScanCache, _PhishingController_tokenScanCache, _PhishingController_addressScanCache, _PhishingController_knownRecipients, _PhishingController_transactionRecipients, _PhishingController_transactionRecipientsByTransactionId, _PhishingController_transactionRecipientCounts, _PhishingController_addressBookRecipients, _PhishingController_inProgressHotlistUpdate, _PhishingController_inProgressStalelistUpdate, _PhishingController_isProgressC2DomainBlocklistUpdate, _PhishingController_transactionControllerStateChangeHandler, _PhishingController_addressBookControllerStateChangeHandler, _PhishingController_subscribeToAddressBookControllerStateChange, _PhishingController_subscribeToTransactionControllerStateChange, _PhishingController_isTransactionPatch, _PhishingController_isSimulationDataPatch, _PhishingController_onTransactionControllerStateChange, _PhishingController_onAddressBookControllerStateChange, _PhishingController_getTokensFromTransaction, _PhishingController_scanTokensByChain, _PhishingController_hydrateKnownRecipients, _PhishingController_hydrateKnownRecipientsFromTransactionState, _PhishingController_hydrateKnownRecipientsFromAddressBookState, _PhishingController_setKnownRecipientsFromTransactionState, _PhishingController_updateKnownRecipientsFromTransactionPatches, _PhishingController_getTransactionFromPatchValue, _PhishingController_updateTransactionRecipients, _PhishingController_addTransactionRecipients, _PhishingController_removeTransactionRecipients, _PhishingController_setKnownRecipientsFromAddressBookState, _PhishingController_rebuildKnownRecipients, _PhishingController_getAddressBookRecipients, _PhishingController_getRecipientAddressesFromTransaction, _PhishingController_normalizeAddress, _PhishingController_fetchTokenScanBulkResults, _PhishingController_processBatch, _PhishingController_updateStalelist, _PhishingController_updateHotlist, _PhishingController_updateC2DomainBlocklist, _PhishingController_queryConfig;
14
+ Object.defineProperty(exports, "__esModule", { value: true });
15
+ exports.PhishingController = exports.phishingListKeyNameMap = exports.ListNames = exports.ListKeys = exports.C2_DOMAIN_BLOCKLIST_URL = exports.METAMASK_HOTLIST_DIFF_URL = exports.METAMASK_STALELIST_URL = exports.STALELIST_REFRESH_INTERVAL = exports.HOTLIST_REFRESH_INTERVAL = exports.C2_DOMAIN_BLOCKLIST_REFRESH_INTERVAL = exports.DEFAULT_ADDRESS_SCAN_CACHE_MAX_SIZE = exports.DEFAULT_ADDRESS_SCAN_CACHE_TTL = exports.DEFAULT_TOKEN_SCAN_CACHE_MAX_SIZE = exports.DEFAULT_TOKEN_SCAN_CACHE_TTL = exports.DEFAULT_URL_SCAN_CACHE_MAX_SIZE = exports.DEFAULT_URL_SCAN_CACHE_TTL = exports.APPROVALS_ENDPOINT = exports.ADDRESS_SCAN_ENDPOINT = exports.TOKEN_BULK_SCANNING_ENDPOINT = exports.SECURITY_ALERTS_BASE_URL = exports.PHISHING_DETECTION_BULK_SCAN_ENDPOINT = exports.PHISHING_DETECTION_SCAN_ENDPOINT = exports.PHISHING_DETECTION_BASE_URL = exports.C2_DOMAIN_BLOCKLIST_ENDPOINT = exports.CLIENT_SIDE_DETECION_BASE_URL = exports.METAMASK_HOTLIST_DIFF_FILE = exports.METAMASK_STALELIST_FILE = exports.PHISHING_CONFIG_BASE_URL = void 0;
16
+ const base_controller_1 = require("@metamask/base-controller");
17
+ const controller_utils_1 = require("@metamask/controller-utils");
18
+ const transaction_controller_1 = require("@metamask/transaction-controller");
19
+ const punycode_js_1 = require("punycode/punycode.js");
20
+ const address_poisoning_js_1 = require("./address-poisoning.cjs");
21
+ const CacheManager_js_1 = require("./CacheManager.cjs");
22
+ const PathTrie_js_1 = require("./PathTrie.cjs");
23
+ const PhishingDetector_js_1 = require("./PhishingDetector.cjs");
24
+ const types_js_1 = require("./types.cjs");
25
+ const utils_js_1 = require("./utils.cjs");
26
+ exports.PHISHING_CONFIG_BASE_URL = 'https://phishing-detection.api.cx.metamask.io';
27
+ exports.METAMASK_STALELIST_FILE = '/v1/stalelist';
28
+ exports.METAMASK_HOTLIST_DIFF_FILE = '/v2/diffsSince';
29
+ exports.CLIENT_SIDE_DETECION_BASE_URL = 'https://client-side-detection.api.cx.metamask.io';
30
+ exports.C2_DOMAIN_BLOCKLIST_ENDPOINT = '/v1/request-blocklist';
31
+ exports.PHISHING_DETECTION_BASE_URL = 'https://dapp-scanning.api.cx.metamask.io';
32
+ exports.PHISHING_DETECTION_SCAN_ENDPOINT = 'v2/scan';
33
+ exports.PHISHING_DETECTION_BULK_SCAN_ENDPOINT = 'bulk-scan';
34
+ exports.SECURITY_ALERTS_BASE_URL = 'https://security-alerts.api.cx.metamask.io';
35
+ exports.TOKEN_BULK_SCANNING_ENDPOINT = '/token/scan-bulk';
36
+ exports.ADDRESS_SCAN_ENDPOINT = '/address/evm/scan';
37
+ exports.APPROVALS_ENDPOINT = '/address/evm/approvals';
38
+ // Cache configuration defaults
39
+ exports.DEFAULT_URL_SCAN_CACHE_TTL = 1 * 60; // 1 minute in seconds
40
+ exports.DEFAULT_URL_SCAN_CACHE_MAX_SIZE = 250;
41
+ exports.DEFAULT_TOKEN_SCAN_CACHE_TTL = 1 * 60; // 1 minute in seconds
42
+ exports.DEFAULT_TOKEN_SCAN_CACHE_MAX_SIZE = 1000;
43
+ exports.DEFAULT_ADDRESS_SCAN_CACHE_TTL = 1 * 60; // 1 minute in seconds
44
+ exports.DEFAULT_ADDRESS_SCAN_CACHE_MAX_SIZE = 1000;
45
+ exports.C2_DOMAIN_BLOCKLIST_REFRESH_INTERVAL = 5 * 60; // 5 mins in seconds
46
+ exports.HOTLIST_REFRESH_INTERVAL = 5 * 60; // 5 mins in seconds
47
+ exports.STALELIST_REFRESH_INTERVAL = 30 * 24 * 60 * 60; // 30 days in seconds
48
+ exports.METAMASK_STALELIST_URL = `${exports.PHISHING_CONFIG_BASE_URL}${exports.METAMASK_STALELIST_FILE}`;
49
+ exports.METAMASK_HOTLIST_DIFF_URL = `${exports.PHISHING_CONFIG_BASE_URL}${exports.METAMASK_HOTLIST_DIFF_FILE}`;
50
+ exports.C2_DOMAIN_BLOCKLIST_URL = `${exports.CLIENT_SIDE_DETECION_BASE_URL}${exports.C2_DOMAIN_BLOCKLIST_ENDPOINT}`;
51
+ /**
52
+ * Enum containing upstream data provider source list keys.
53
+ * These are the keys denoting lists consumed by the upstream data provider.
54
+ */
55
+ var ListKeys;
56
+ (function (ListKeys) {
57
+ ListKeys["EthPhishingDetectConfig"] = "eth_phishing_detect_config";
58
+ })(ListKeys || (exports.ListKeys = ListKeys = {}));
59
+ /**
60
+ * Enum containing downstream client attribution names.
61
+ */
62
+ var ListNames;
63
+ (function (ListNames) {
64
+ ListNames["MetaMask"] = "MetaMask";
65
+ })(ListNames || (exports.ListNames = ListNames = {}));
66
+ /**
67
+ * Maps from downstream client attribution name
68
+ * to list key sourced from upstream data provider.
69
+ */
70
+ const phishingListNameKeyMap = {
71
+ [ListNames.MetaMask]: ListKeys.EthPhishingDetectConfig,
72
+ };
73
+ /**
74
+ * Maps from list key sourced from upstream data
75
+ * provider to downstream client attribution name.
76
+ */
77
+ exports.phishingListKeyNameMap = {
78
+ [ListKeys.EthPhishingDetectConfig]: ListNames.MetaMask,
79
+ };
80
+ const controllerName = 'PhishingController';
81
+ const metadata = {
82
+ phishingLists: {
83
+ includeInStateLogs: false,
84
+ persist: true,
85
+ includeInDebugSnapshot: false,
86
+ usedInUi: false,
87
+ },
88
+ whitelist: {
89
+ includeInStateLogs: false,
90
+ persist: true,
91
+ includeInDebugSnapshot: false,
92
+ usedInUi: false,
93
+ },
94
+ whitelistPaths: {
95
+ includeInStateLogs: false,
96
+ persist: true,
97
+ includeInDebugSnapshot: false,
98
+ usedInUi: false,
99
+ },
100
+ hotlistLastFetched: {
101
+ includeInStateLogs: true,
102
+ persist: true,
103
+ includeInDebugSnapshot: false,
104
+ usedInUi: false,
105
+ },
106
+ stalelistLastFetched: {
107
+ includeInStateLogs: true,
108
+ persist: true,
109
+ includeInDebugSnapshot: false,
110
+ usedInUi: false,
111
+ },
112
+ c2DomainBlocklistLastFetched: {
113
+ includeInStateLogs: true,
114
+ persist: true,
115
+ includeInDebugSnapshot: false,
116
+ usedInUi: false,
117
+ },
118
+ urlScanCache: {
119
+ includeInStateLogs: false,
120
+ persist: true,
121
+ includeInDebugSnapshot: false,
122
+ usedInUi: true,
123
+ },
124
+ tokenScanCache: {
125
+ includeInStateLogs: false,
126
+ persist: true,
127
+ includeInDebugSnapshot: false,
128
+ usedInUi: true,
129
+ },
130
+ addressScanCache: {
131
+ includeInStateLogs: false,
132
+ persist: true,
133
+ includeInDebugSnapshot: false,
134
+ usedInUi: true,
135
+ },
136
+ };
137
+ /**
138
+ * Get a default empty state for the controller.
139
+ *
140
+ * @returns The default empty state.
141
+ */
142
+ const getDefaultState = () => {
143
+ return {
144
+ phishingLists: [],
145
+ whitelist: [],
146
+ whitelistPaths: {},
147
+ hotlistLastFetched: 0,
148
+ stalelistLastFetched: 0,
149
+ c2DomainBlocklistLastFetched: 0,
150
+ urlScanCache: {},
151
+ tokenScanCache: {},
152
+ addressScanCache: {},
153
+ };
154
+ };
155
+ const MESSENGER_EXPOSED_METHODS = [
156
+ 'maybeUpdateState',
157
+ 'testOrigin',
158
+ 'isBlockedRequest',
159
+ 'bypass',
160
+ 'scanUrl',
161
+ 'bulkScanUrls',
162
+ 'bulkScanTokens',
163
+ 'scanAddress',
164
+ 'getApprovals',
165
+ 'checkAddressPoisoning',
166
+ ];
167
+ /**
168
+ * Controller that manages community-maintained lists of approved and unapproved website origins.
169
+ */
170
+ class PhishingController extends base_controller_1.BaseController {
171
+ /**
172
+ * Construct a Phishing Controller.
173
+ *
174
+ * @param config - Initial options used to configure this controller.
175
+ * @param config.stalelistRefreshInterval - Polling interval used to fetch stale list.
176
+ * @param config.hotlistRefreshInterval - Polling interval used to fetch hotlist diff list.
177
+ * @param config.c2DomainBlocklistRefreshInterval - Polling interval used to fetch c2 domain blocklist.
178
+ * @param config.urlScanCacheTTL - Time to live in seconds for cached scan results.
179
+ * @param config.urlScanCacheMaxSize - Maximum number of entries in the scan cache.
180
+ * @param config.tokenScanCacheTTL - Time to live in seconds for cached token scan results.
181
+ * @param config.tokenScanCacheMaxSize - Maximum number of entries in the token scan cache.
182
+ * @param config.addressScanCacheTTL - Time to live in seconds for cached address scan results.
183
+ * @param config.addressScanCacheMaxSize - Maximum number of entries in the address scan cache.
184
+ * @param config.messenger - The controller restricted messenger.
185
+ * @param config.state - Initial state to set on this controller.
186
+ */
187
+ constructor({ stalelistRefreshInterval = exports.STALELIST_REFRESH_INTERVAL, hotlistRefreshInterval = exports.HOTLIST_REFRESH_INTERVAL, c2DomainBlocklistRefreshInterval = exports.C2_DOMAIN_BLOCKLIST_REFRESH_INTERVAL, urlScanCacheTTL = exports.DEFAULT_URL_SCAN_CACHE_TTL, urlScanCacheMaxSize = exports.DEFAULT_URL_SCAN_CACHE_MAX_SIZE, tokenScanCacheTTL = exports.DEFAULT_TOKEN_SCAN_CACHE_TTL, tokenScanCacheMaxSize = exports.DEFAULT_TOKEN_SCAN_CACHE_MAX_SIZE, addressScanCacheTTL = exports.DEFAULT_ADDRESS_SCAN_CACHE_TTL, addressScanCacheMaxSize = exports.DEFAULT_ADDRESS_SCAN_CACHE_MAX_SIZE, messenger, state = {}, }) {
188
+ super({
189
+ name: controllerName,
190
+ metadata,
191
+ messenger,
192
+ state: {
193
+ ...getDefaultState(),
194
+ ...state,
195
+ },
196
+ });
197
+ _PhishingController_instances.add(this);
198
+ // TODO: Replace `any` with type
199
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
200
+ _PhishingController_detector.set(this, void 0);
201
+ _PhishingController_stalelistRefreshInterval.set(this, void 0);
202
+ _PhishingController_hotlistRefreshInterval.set(this, void 0);
203
+ _PhishingController_c2DomainBlocklistRefreshInterval.set(this, void 0);
204
+ _PhishingController_urlScanCache.set(this, void 0);
205
+ _PhishingController_tokenScanCache.set(this, void 0);
206
+ _PhishingController_addressScanCache.set(this, void 0);
207
+ _PhishingController_knownRecipients.set(this, void 0);
208
+ _PhishingController_transactionRecipients.set(this, void 0);
209
+ _PhishingController_transactionRecipientsByTransactionId.set(this, void 0);
210
+ _PhishingController_transactionRecipientCounts.set(this, void 0);
211
+ _PhishingController_addressBookRecipients.set(this, void 0);
212
+ _PhishingController_inProgressHotlistUpdate.set(this, void 0);
213
+ _PhishingController_inProgressStalelistUpdate.set(this, void 0);
214
+ _PhishingController_isProgressC2DomainBlocklistUpdate.set(this, void 0);
215
+ _PhishingController_transactionControllerStateChangeHandler.set(this, void 0);
216
+ _PhishingController_addressBookControllerStateChangeHandler.set(this, void 0);
217
+ /**
218
+ * Determines if a given origin is unapproved.
219
+ *
220
+ * It is strongly recommended that you call {@link maybeUpdateState} before calling this,
221
+ * to check whether the phishing configuration is up-to-date. It will be updated if necessary
222
+ * by calling {@link updateStalelist} or {@link updateHotlist}.
223
+ *
224
+ * @param origin - Domain origin of a website.
225
+ * @returns Whether the origin is an unapproved origin.
226
+ * @deprecated Use {@link testOrigin} instead. This method is exposed for backward compatibility and will be removed in a future release.
227
+ */
228
+ this.test = this.testOrigin.bind(this);
229
+ /**
230
+ * Fetch bulk token scan results from the security alerts API.
231
+ *
232
+ * @param chain - The chain name.
233
+ * @param tokens - Array of token addresses to scan.
234
+ * @returns The API response or null if there was an error.
235
+ */
236
+ _PhishingController_fetchTokenScanBulkResults.set(this, async (chain, tokens) => {
237
+ const timeout = 8000; // 8 seconds
238
+ const apiResponse = await (0, controller_utils_1.safelyExecuteWithTimeout)(async () => {
239
+ const response = await fetch(`${exports.SECURITY_ALERTS_BASE_URL}${exports.TOKEN_BULK_SCANNING_ENDPOINT}`, {
240
+ method: 'POST',
241
+ headers: {
242
+ Accept: 'application/json',
243
+ 'Content-Type': 'application/json',
244
+ },
245
+ body: JSON.stringify({
246
+ chain,
247
+ tokens,
248
+ }),
249
+ });
250
+ if (!response.ok) {
251
+ return {
252
+ error: `${response.status} ${response.statusText}`,
253
+ status: response.status,
254
+ statusText: response.statusText,
255
+ };
256
+ }
257
+ const data = await response.json();
258
+ return data;
259
+ }, true, timeout);
260
+ if (!apiResponse) {
261
+ console.error(`Error scanning tokens: timeout of ${timeout}ms exceeded`);
262
+ return null;
263
+ }
264
+ if (apiResponse.error) {
265
+ const { status, statusText } = apiResponse;
266
+ console.warn(`Token bulk screening API error: ${status} ${statusText}`);
267
+ return null;
268
+ }
269
+ return apiResponse;
270
+ });
271
+ /**
272
+ * Get token approvals for an EVM address with security enrichments.
273
+ *
274
+ * @param chainId - The chain ID in hex format (e.g., '0x1' for Ethereum).
275
+ * @param address - The address to get approvals for.
276
+ * @returns The approvals response containing approval data, or empty approvals on error.
277
+ */
278
+ this.getApprovals = async (chainId, address) => {
279
+ if (!address || !chainId) {
280
+ return { approvals: [] };
281
+ }
282
+ const normalizedChainId = chainId.toLowerCase();
283
+ const normalizedAddress = address.toLowerCase();
284
+ const chain = (0, utils_js_1.resolveChainName)(normalizedChainId);
285
+ if (!chain || !(0, utils_js_1.isApprovalSupportedChain)(chain)) {
286
+ return { approvals: [] };
287
+ }
288
+ const apiResponse = await (0, controller_utils_1.safelyExecuteWithTimeout)(async () => {
289
+ const res = await fetch(`${exports.SECURITY_ALERTS_BASE_URL}${exports.APPROVALS_ENDPOINT}`, {
290
+ method: 'POST',
291
+ headers: {
292
+ Accept: 'application/json',
293
+ 'Content-Type': 'application/json',
294
+ },
295
+ body: JSON.stringify({
296
+ chain,
297
+ address: normalizedAddress,
298
+ }),
299
+ });
300
+ if (!res.ok) {
301
+ return { error: `${res.status} ${res.statusText}` };
302
+ }
303
+ const data = await res.json();
304
+ return data;
305
+ }, true, 5000);
306
+ if (!apiResponse) {
307
+ return { approvals: [] };
308
+ }
309
+ if (apiResponse.error ||
310
+ !Array.isArray(apiResponse.approvals)) {
311
+ return { approvals: [] };
312
+ }
313
+ return apiResponse;
314
+ };
315
+ /**
316
+ * Process a batch of URLs (up to 50) for phishing detection.
317
+ *
318
+ * @param urls - A batch of URLs to scan.
319
+ * @returns The scan results and errors for this batch.
320
+ */
321
+ _PhishingController_processBatch.set(this, async (urls) => {
322
+ const apiResponse = await (0, controller_utils_1.safelyExecuteWithTimeout)(async () => {
323
+ const res = await fetch(`${exports.PHISHING_DETECTION_BASE_URL}/${exports.PHISHING_DETECTION_BULK_SCAN_ENDPOINT}`, {
324
+ method: 'POST',
325
+ headers: {
326
+ Accept: 'application/json',
327
+ 'Content-Type': 'application/json',
328
+ },
329
+ body: JSON.stringify({ urls }),
330
+ });
331
+ if (!res.ok) {
332
+ return {
333
+ error: `${res.status} ${res.statusText}`,
334
+ status: res.status,
335
+ statusText: res.statusText,
336
+ };
337
+ }
338
+ const data = await res.json();
339
+ return data;
340
+ }, true, 15000);
341
+ // Handle timeout or network errors
342
+ if (!apiResponse) {
343
+ return {
344
+ results: {},
345
+ errors: {
346
+ network_error: ['timeout of 15000ms exceeded'],
347
+ },
348
+ };
349
+ }
350
+ // Handle HTTP error responses
351
+ if (apiResponse.error) {
352
+ const { status, statusText } = apiResponse;
353
+ return {
354
+ results: {},
355
+ errors: {
356
+ api_error: [`${status} ${statusText}`],
357
+ },
358
+ };
359
+ }
360
+ return apiResponse;
361
+ });
362
+ __classPrivateFieldSet(this, _PhishingController_stalelistRefreshInterval, stalelistRefreshInterval, "f");
363
+ __classPrivateFieldSet(this, _PhishingController_hotlistRefreshInterval, hotlistRefreshInterval, "f");
364
+ __classPrivateFieldSet(this, _PhishingController_c2DomainBlocklistRefreshInterval, c2DomainBlocklistRefreshInterval, "f");
365
+ __classPrivateFieldSet(this, _PhishingController_knownRecipients, new Set(), "f");
366
+ __classPrivateFieldSet(this, _PhishingController_transactionRecipients, new Set(), "f");
367
+ __classPrivateFieldSet(this, _PhishingController_transactionRecipientsByTransactionId, new Map(), "f");
368
+ __classPrivateFieldSet(this, _PhishingController_transactionRecipientCounts, new Map(), "f");
369
+ __classPrivateFieldSet(this, _PhishingController_addressBookRecipients, new Set(), "f");
370
+ __classPrivateFieldSet(this, _PhishingController_transactionControllerStateChangeHandler, __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_onTransactionControllerStateChange).bind(this), "f");
371
+ __classPrivateFieldSet(this, _PhishingController_addressBookControllerStateChangeHandler, __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_onAddressBookControllerStateChange).bind(this), "f");
372
+ __classPrivateFieldSet(this, _PhishingController_urlScanCache, new CacheManager_js_1.CacheManager({
373
+ cacheTTL: urlScanCacheTTL,
374
+ maxCacheSize: urlScanCacheMaxSize,
375
+ initialCache: this.state.urlScanCache,
376
+ updateState: (cache) => {
377
+ this.update((draftState) => {
378
+ draftState.urlScanCache = cache;
379
+ });
380
+ },
381
+ }), "f");
382
+ __classPrivateFieldSet(this, _PhishingController_tokenScanCache, new CacheManager_js_1.CacheManager({
383
+ cacheTTL: tokenScanCacheTTL,
384
+ maxCacheSize: tokenScanCacheMaxSize,
385
+ initialCache: this.state.tokenScanCache,
386
+ updateState: (cache) => {
387
+ this.update((draftState) => {
388
+ draftState.tokenScanCache = cache;
389
+ });
390
+ },
391
+ }), "f");
392
+ __classPrivateFieldSet(this, _PhishingController_addressScanCache, new CacheManager_js_1.CacheManager({
393
+ cacheTTL: addressScanCacheTTL,
394
+ maxCacheSize: addressScanCacheMaxSize,
395
+ initialCache: this.state.addressScanCache,
396
+ updateState: (cache) => {
397
+ this.update((draftState) => {
398
+ draftState.addressScanCache = cache;
399
+ });
400
+ },
401
+ }), "f");
402
+ this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
403
+ this.updatePhishingDetector();
404
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_hydrateKnownRecipients).call(this);
405
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_subscribeToAddressBookControllerStateChange).call(this);
406
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_subscribeToTransactionControllerStateChange).call(this);
407
+ }
408
+ /**
409
+ * Updates this.detector with an instance of PhishingDetector using the current state.
410
+ */
411
+ updatePhishingDetector() {
412
+ __classPrivateFieldSet(this, _PhishingController_detector, new PhishingDetector_js_1.PhishingDetector(this.state.phishingLists), "f");
413
+ }
414
+ /**
415
+ * Finds known recipient addresses that look like an address poisoning match.
416
+ *
417
+ * @param candidate - The recipient address being checked.
418
+ * @returns Similar known recipient matches sorted by score.
419
+ */
420
+ checkAddressPoisoning(candidate) {
421
+ return (0, address_poisoning_js_1.findSimilarAddresses)(candidate, Array.from(__classPrivateFieldGet(this, _PhishingController_knownRecipients, "f")));
422
+ }
423
+ /**
424
+ * Determine if an update to the stalelist configuration is needed.
425
+ *
426
+ * @returns Whether an update is needed
427
+ */
428
+ isStalelistOutOfDate() {
429
+ return ((0, utils_js_1.fetchTimeNow)() - this.state.stalelistLastFetched >=
430
+ __classPrivateFieldGet(this, _PhishingController_stalelistRefreshInterval, "f"));
431
+ }
432
+ /**
433
+ * Determine if an update to the hotlist configuration is needed.
434
+ *
435
+ * @returns Whether an update is needed
436
+ */
437
+ isHotlistOutOfDate() {
438
+ return ((0, utils_js_1.fetchTimeNow)() - this.state.hotlistLastFetched >=
439
+ __classPrivateFieldGet(this, _PhishingController_hotlistRefreshInterval, "f"));
440
+ }
441
+ /**
442
+ * Determine if an update to the C2 domain blocklist is needed.
443
+ *
444
+ * @returns Whether an update is needed
445
+ */
446
+ isC2DomainBlocklistOutOfDate() {
447
+ return ((0, utils_js_1.fetchTimeNow)() - this.state.c2DomainBlocklistLastFetched >=
448
+ __classPrivateFieldGet(this, _PhishingController_c2DomainBlocklistRefreshInterval, "f"));
449
+ }
450
+ /**
451
+ * Conditionally update the phishing configuration.
452
+ *
453
+ * If the stalelist configuration is out of date, this function will call `updateStalelist`
454
+ * to update the configuration. This will automatically grab the hotlist,
455
+ * so it isn't necessary to continue on to download the hotlist and the c2 domain blocklist.
456
+ *
457
+ */
458
+ async maybeUpdateState() {
459
+ const staleListOutOfDate = this.isStalelistOutOfDate();
460
+ if (staleListOutOfDate) {
461
+ await this.updateStalelist();
462
+ return;
463
+ }
464
+ const hotlistOutOfDate = this.isHotlistOutOfDate();
465
+ if (hotlistOutOfDate) {
466
+ await this.updateHotlist();
467
+ }
468
+ const c2DomainBlocklistOutOfDate = this.isC2DomainBlocklistOutOfDate();
469
+ if (c2DomainBlocklistOutOfDate) {
470
+ await this.updateC2DomainBlocklist();
471
+ }
472
+ }
473
+ /**
474
+ * Determines if a given origin is unapproved.
475
+ *
476
+ * It is strongly recommended that you call {@link maybeUpdateState} before calling this,
477
+ * to check whether the phishing configuration is up-to-date. It will be updated if necessary
478
+ * by calling {@link updateStalelist} or {@link updateHotlist}.
479
+ *
480
+ * @param origin - Domain origin of a website.
481
+ * @returns Whether the origin is an unapproved origin.
482
+ */
483
+ testOrigin(origin) {
484
+ const punycodeOrigin = (0, punycode_js_1.toASCII)(origin);
485
+ const hostname = (0, utils_js_1.getHostnameFromUrl)(punycodeOrigin);
486
+ const hostnameWithPaths = hostname + (0, utils_js_1.getPathnameFromUrl)(origin);
487
+ if ((0, PathTrie_js_1.matchedPathPrefix)(hostnameWithPaths, this.state.whitelistPaths)) {
488
+ return { result: false, type: types_js_1.PhishingDetectorResultType.All };
489
+ }
490
+ if (this.state.whitelist.includes(hostname || punycodeOrigin)) {
491
+ return { result: false, type: types_js_1.PhishingDetectorResultType.All }; // Same as whitelisted match returned by detector.check(...).
492
+ }
493
+ return __classPrivateFieldGet(this, _PhishingController_detector, "f").check(punycodeOrigin);
494
+ }
495
+ /**
496
+ * Checks if a request URL's domain is blocked against the request blocklist.
497
+ *
498
+ * This method is used to determine if a specific request URL is associated with a malicious
499
+ * command and control (C2) domain. The URL's hostname is hashed and checked against a configured
500
+ * blocklist of known malicious domains.
501
+ *
502
+ * @param origin - The full request URL to be checked.
503
+ * @returns An object indicating whether the URL's domain is blocked and relevant metadata.
504
+ */
505
+ isBlockedRequest(origin) {
506
+ const punycodeOrigin = (0, punycode_js_1.toASCII)(origin);
507
+ const hostname = (0, utils_js_1.getHostnameFromUrl)(punycodeOrigin);
508
+ if (this.state.whitelist.includes(hostname || punycodeOrigin)) {
509
+ return { result: false, type: types_js_1.PhishingDetectorResultType.All }; // Same as whitelisted match returned by detector.check(...).
510
+ }
511
+ return __classPrivateFieldGet(this, _PhishingController_detector, "f").isMaliciousC2Domain(punycodeOrigin);
512
+ }
513
+ /**
514
+ * Temporarily marks a given origin as approved.
515
+ *
516
+ * @param origin - The origin to mark as approved.
517
+ */
518
+ bypass(origin) {
519
+ const punycodeOrigin = (0, punycode_js_1.toASCII)(origin);
520
+ const hostname = (0, utils_js_1.getHostnameFromUrl)(punycodeOrigin);
521
+ const hostnameWithPaths = hostname + (0, utils_js_1.getPathnameFromUrl)(origin);
522
+ const { whitelist, whitelistPaths } = this.state;
523
+ const whitelistPath = (0, PathTrie_js_1.matchedPathPrefix)(hostnameWithPaths, whitelistPaths);
524
+ if (whitelist.includes(hostname || punycodeOrigin) || whitelistPath) {
525
+ return;
526
+ }
527
+ // If the origin was blocked by a path, then we only want to add it to the whitelistPaths since
528
+ // other paths with the same hostname may not be blocked.
529
+ const blockingPath = __classPrivateFieldGet(this, _PhishingController_detector, "f").blockingPath(origin);
530
+ if (blockingPath) {
531
+ this.update((draftState) => {
532
+ (0, PathTrie_js_1.insertToTrie)(blockingPath, draftState.whitelistPaths);
533
+ });
534
+ return;
535
+ }
536
+ this.update((draftState) => {
537
+ draftState.whitelist.push(hostname || punycodeOrigin);
538
+ });
539
+ }
540
+ /**
541
+ * Update the C2 domain blocklist.
542
+ *
543
+ * If an update is in progress, no additional update will be made. Instead this will wait until
544
+ * the in-progress update has finished.
545
+ */
546
+ async updateC2DomainBlocklist() {
547
+ if (__classPrivateFieldGet(this, _PhishingController_isProgressC2DomainBlocklistUpdate, "f")) {
548
+ await __classPrivateFieldGet(this, _PhishingController_isProgressC2DomainBlocklistUpdate, "f");
549
+ return;
550
+ }
551
+ try {
552
+ __classPrivateFieldSet(this, _PhishingController_isProgressC2DomainBlocklistUpdate, __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_updateC2DomainBlocklist).call(this), "f");
553
+ await __classPrivateFieldGet(this, _PhishingController_isProgressC2DomainBlocklistUpdate, "f");
554
+ }
555
+ finally {
556
+ __classPrivateFieldSet(this, _PhishingController_isProgressC2DomainBlocklistUpdate, undefined, "f");
557
+ }
558
+ }
559
+ /**
560
+ * Update the hotlist.
561
+ *
562
+ * If an update is in progress, no additional update will be made. Instead this will wait until
563
+ * the in-progress update has finished.
564
+ */
565
+ async updateHotlist() {
566
+ if (__classPrivateFieldGet(this, _PhishingController_inProgressHotlistUpdate, "f")) {
567
+ await __classPrivateFieldGet(this, _PhishingController_inProgressHotlistUpdate, "f");
568
+ return;
569
+ }
570
+ try {
571
+ __classPrivateFieldSet(this, _PhishingController_inProgressHotlistUpdate, __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_updateHotlist).call(this), "f");
572
+ await __classPrivateFieldGet(this, _PhishingController_inProgressHotlistUpdate, "f");
573
+ }
574
+ finally {
575
+ __classPrivateFieldSet(this, _PhishingController_inProgressHotlistUpdate, undefined, "f");
576
+ }
577
+ }
578
+ /**
579
+ * Update the stalelist.
580
+ *
581
+ * If an update is in progress, no additional update will be made. Instead this will wait until
582
+ * the in-progress update has finished.
583
+ */
584
+ async updateStalelist() {
585
+ if (__classPrivateFieldGet(this, _PhishingController_inProgressStalelistUpdate, "f")) {
586
+ await __classPrivateFieldGet(this, _PhishingController_inProgressStalelistUpdate, "f");
587
+ return;
588
+ }
589
+ try {
590
+ __classPrivateFieldSet(this, _PhishingController_inProgressStalelistUpdate, __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_updateStalelist).call(this), "f");
591
+ await __classPrivateFieldGet(this, _PhishingController_inProgressStalelistUpdate, "f");
592
+ }
593
+ finally {
594
+ __classPrivateFieldSet(this, _PhishingController_inProgressStalelistUpdate, undefined, "f");
595
+ }
596
+ }
597
+ /**
598
+ * Scan a URL for phishing. For most hosts only the hostname is sent to the API; for known
599
+ * shared gateways the pathname is included (see `PHISHING_DETECTION_PATH_BASED_ROOT_DOMAINS`).
600
+ * Only supports web URLs (`http:` / `https:`).
601
+ *
602
+ * @param url - The URL to scan.
603
+ * @returns The phishing detection scan result.
604
+ */
605
+ async scanUrl(url) {
606
+ const [scanUrlParam, scanParamOk] = (0, utils_js_1.getPhishingDetectionScanUrlParam)(url);
607
+ if (!scanParamOk) {
608
+ return {
609
+ hostname: '',
610
+ recommendedAction: types_js_1.RecommendedAction.None,
611
+ fetchError: 'url is not a valid web URL',
612
+ };
613
+ }
614
+ const [hostname] = (0, utils_js_1.getHostnameFromWebUrl)(url);
615
+ const cachedResult = __classPrivateFieldGet(this, _PhishingController_urlScanCache, "f").get(scanUrlParam);
616
+ if (cachedResult) {
617
+ return cachedResult;
618
+ }
619
+ const apiResponse = await (0, controller_utils_1.safelyExecuteWithTimeout)(async () => {
620
+ const res = await fetch(`${exports.PHISHING_DETECTION_BASE_URL}/${exports.PHISHING_DETECTION_SCAN_ENDPOINT}?url=${encodeURIComponent(scanUrlParam)}`, {
621
+ method: 'GET',
622
+ headers: {
623
+ Accept: 'application/json',
624
+ },
625
+ });
626
+ if (!res.ok) {
627
+ return {
628
+ error: `${res.status} ${res.statusText}`,
629
+ };
630
+ }
631
+ const data = await res.json();
632
+ return data;
633
+ }, true, 8000);
634
+ // Need to do it this way because safelyExecuteWithTimeout returns undefined for both timeouts and errors.
635
+ if (!apiResponse) {
636
+ return {
637
+ hostname: '',
638
+ recommendedAction: types_js_1.RecommendedAction.None,
639
+ fetchError: 'timeout of 8000ms exceeded',
640
+ };
641
+ }
642
+ else if (apiResponse.error) {
643
+ return {
644
+ hostname: '',
645
+ recommendedAction: types_js_1.RecommendedAction.None,
646
+ fetchError: apiResponse.error,
647
+ };
648
+ }
649
+ const scanResult = apiResponse;
650
+ const result = {
651
+ hostname,
652
+ recommendedAction: scanResult.recommendedAction,
653
+ };
654
+ __classPrivateFieldGet(this, _PhishingController_urlScanCache, "f").set(scanUrlParam, result);
655
+ return result;
656
+ }
657
+ /**
658
+ * Scan multiple URLs for phishing in bulk. It will only scan the hostnames of the URLs.
659
+ * It also only supports web URLs.
660
+ *
661
+ * @param urls - The URLs to scan.
662
+ * @returns A mapping of URLs to their phishing detection scan results and errors.
663
+ */
664
+ async bulkScanUrls(urls) {
665
+ if (!urls || urls.length === 0) {
666
+ return {
667
+ results: {},
668
+ errors: {},
669
+ };
670
+ }
671
+ // we are arbitrarily limiting the number of URLs to 250
672
+ const MAX_TOTAL_URLS = 250;
673
+ if (urls.length > MAX_TOTAL_URLS) {
674
+ return {
675
+ results: {},
676
+ errors: {
677
+ too_many_urls: [
678
+ `Maximum of ${MAX_TOTAL_URLS} URLs allowed per request`,
679
+ ],
680
+ },
681
+ };
682
+ }
683
+ const MAX_URL_LENGTH = 2048;
684
+ const combinedResponse = {
685
+ results: {},
686
+ errors: {},
687
+ };
688
+ // Extract hostnames from URLs and check for validity and length constraints
689
+ const urlsToHostnames = {};
690
+ const urlsToFetch = [];
691
+ for (const url of urls) {
692
+ if (url.length > MAX_URL_LENGTH) {
693
+ combinedResponse.errors[url] = [
694
+ `URL length must not exceed ${MAX_URL_LENGTH} characters`,
695
+ ];
696
+ continue;
697
+ }
698
+ const [hostname, ok] = (0, utils_js_1.getHostnameFromWebUrl)(url);
699
+ if (!ok) {
700
+ combinedResponse.errors[url] = ['url is not a valid web URL'];
701
+ continue;
702
+ }
703
+ // Check if result is already in cache
704
+ const cachedResult = __classPrivateFieldGet(this, _PhishingController_urlScanCache, "f").get(hostname);
705
+ if (cachedResult) {
706
+ // Use cached result
707
+ combinedResponse.results[url] = cachedResult;
708
+ }
709
+ else {
710
+ // Add to list of URLs to fetch
711
+ urlsToHostnames[url] = hostname;
712
+ urlsToFetch.push(url);
713
+ }
714
+ }
715
+ // If there are URLs to fetch, process them in batches
716
+ if (urlsToFetch.length > 0) {
717
+ // The API has a limit of 50 URLs per request, so we batch the requests
718
+ const MAX_URLS_PER_BATCH = 50;
719
+ const batches = [];
720
+ for (let i = 0; i < urlsToFetch.length; i += MAX_URLS_PER_BATCH) {
721
+ batches.push(urlsToFetch.slice(i, i + MAX_URLS_PER_BATCH));
722
+ }
723
+ // Process each batch in parallel
724
+ const batchResults = await Promise.all(batches.map((batchUrls) => __classPrivateFieldGet(this, _PhishingController_processBatch, "f").call(this, batchUrls)));
725
+ // Merge results and errors from all batches
726
+ batchResults.forEach((batchResponse) => {
727
+ // Add results to cache and combine with response
728
+ Object.entries(batchResponse.results).forEach(([url, result]) => {
729
+ const hostname = urlsToHostnames[url];
730
+ if (hostname) {
731
+ __classPrivateFieldGet(this, _PhishingController_urlScanCache, "f").set(hostname, result);
732
+ }
733
+ combinedResponse.results[url] = result;
734
+ });
735
+ // Combine errors
736
+ Object.entries(batchResponse.errors).forEach(([key, messages]) => {
737
+ combinedResponse.errors[key] = [
738
+ ...(combinedResponse.errors[key] || []),
739
+ ...messages,
740
+ ];
741
+ });
742
+ });
743
+ }
744
+ return combinedResponse;
745
+ }
746
+ /**
747
+ * Scan an address for security alerts.
748
+ *
749
+ * @param chainId - The chain ID in hex format (e.g., '0x1' for Ethereum).
750
+ * @param address - The address to scan.
751
+ * @returns The address scan result.
752
+ */
753
+ async scanAddress(chainId, address) {
754
+ if (!address || !chainId) {
755
+ return {
756
+ result_type: types_js_1.AddressScanResultType.ErrorResult,
757
+ label: '',
758
+ };
759
+ }
760
+ const normalizedChainId = chainId.toLowerCase();
761
+ const normalizedAddress = address.toLowerCase();
762
+ const chain = (0, utils_js_1.getAddressScanSupportedChain)(normalizedChainId);
763
+ if (!chain) {
764
+ return {
765
+ result_type: types_js_1.AddressScanResultType.ErrorResult,
766
+ label: '',
767
+ };
768
+ }
769
+ const cacheKey = (0, utils_js_1.buildCacheKey)(normalizedChainId, normalizedAddress);
770
+ const cachedResult = __classPrivateFieldGet(this, _PhishingController_addressScanCache, "f").get(cacheKey);
771
+ if (cachedResult) {
772
+ return {
773
+ result_type: cachedResult.result_type,
774
+ label: cachedResult.label,
775
+ };
776
+ }
777
+ const apiResponse = await (0, controller_utils_1.safelyExecuteWithTimeout)(async () => {
778
+ const res = await fetch(`${exports.SECURITY_ALERTS_BASE_URL}${exports.ADDRESS_SCAN_ENDPOINT}`, {
779
+ method: 'POST',
780
+ headers: {
781
+ Accept: 'application/json',
782
+ 'Content-Type': 'application/json',
783
+ },
784
+ body: JSON.stringify({
785
+ chain,
786
+ address: normalizedAddress,
787
+ }),
788
+ });
789
+ if (!res.ok) {
790
+ return {
791
+ error: `${res.status} ${res.statusText}`,
792
+ };
793
+ }
794
+ const data = await res.json();
795
+ return data;
796
+ }, true, 5000);
797
+ if (!apiResponse) {
798
+ return {
799
+ result_type: types_js_1.AddressScanResultType.ErrorResult,
800
+ label: '',
801
+ };
802
+ }
803
+ else if (apiResponse.error) {
804
+ return {
805
+ result_type: types_js_1.AddressScanResultType.ErrorResult,
806
+ label: '',
807
+ };
808
+ }
809
+ const scanResult = apiResponse;
810
+ const result = {
811
+ result_type: scanResult.result_type,
812
+ label: scanResult.label,
813
+ };
814
+ __classPrivateFieldGet(this, _PhishingController_addressScanCache, "f").set(cacheKey, result);
815
+ return {
816
+ result_type: scanResult.result_type,
817
+ label: scanResult.label,
818
+ };
819
+ }
820
+ /**
821
+ * Scan multiple tokens for malicious activity in bulk.
822
+ *
823
+ * @param request - The bulk scan request containing chainId and tokens.
824
+ * @param request.chainId - The chain identifier. Accepts a hex chain ID for
825
+ * EVM chains (e.g. `'0x1'` for Ethereum) or a chain name for non-EVM chains
826
+ * (e.g. `'solana'`).
827
+ * @param request.tokens - Array of token addresses to scan.
828
+ * @returns A mapping of token addresses to their scan results. For EVM chains,
829
+ * addresses are lowercased; for non-EVM chains, original casing is preserved.
830
+ * Tokens that fail to scan are omitted.
831
+ */
832
+ async bulkScanTokens(request) {
833
+ const { chainId, tokens } = request;
834
+ if (!tokens || tokens.length === 0) {
835
+ return {};
836
+ }
837
+ const MAX_TOKENS_PER_REQUEST = 100;
838
+ if (tokens.length > MAX_TOKENS_PER_REQUEST) {
839
+ console.warn(`Maximum of ${MAX_TOKENS_PER_REQUEST} tokens allowed per request`);
840
+ return {};
841
+ }
842
+ const normalizedChainId = chainId.toLowerCase();
843
+ const chain = (0, utils_js_1.resolveChainName)(normalizedChainId);
844
+ if (!chain || !(0, utils_js_1.isTokenScanSupportedChain)(chain)) {
845
+ console.warn(`Unsupported chain ID: ${chainId}`);
846
+ return {};
847
+ }
848
+ // EVM addresses are case-insensitive; non-EVM addresses (e.g. Solana
849
+ // base58) are case-sensitive and must not be lowercased.
850
+ const caseSensitive = !normalizedChainId.startsWith('0x');
851
+ // Split tokens into cached results and tokens that need to be fetched
852
+ const { cachedResults, tokensToFetch } = (0, utils_js_1.splitCacheHits)(__classPrivateFieldGet(this, _PhishingController_tokenScanCache, "f"), normalizedChainId, tokens, caseSensitive);
853
+ const results = { ...cachedResults };
854
+ // If there are tokens to fetch, call the bulk token scan API
855
+ if (tokensToFetch.length > 0) {
856
+ const apiResponse = await __classPrivateFieldGet(this, _PhishingController_fetchTokenScanBulkResults, "f").call(this, chain, tokensToFetch);
857
+ if (apiResponse?.results) {
858
+ // Process API results and update cache
859
+ for (const tokenAddress of tokensToFetch) {
860
+ const normalizedAddress = caseSensitive
861
+ ? tokenAddress
862
+ : tokenAddress.toLowerCase();
863
+ const tokenResult = apiResponse.results[normalizedAddress];
864
+ if (tokenResult?.result_type) {
865
+ const result = {
866
+ result_type: tokenResult.result_type,
867
+ chain: tokenResult.chain || normalizedChainId,
868
+ address: tokenResult.address || normalizedAddress,
869
+ };
870
+ // Update cache
871
+ const cacheKey = (0, utils_js_1.buildCacheKey)(normalizedChainId, normalizedAddress, caseSensitive);
872
+ __classPrivateFieldGet(this, _PhishingController_tokenScanCache, "f").set(cacheKey, {
873
+ result_type: tokenResult.result_type,
874
+ });
875
+ results[normalizedAddress] = result;
876
+ }
877
+ }
878
+ }
879
+ }
880
+ return results;
881
+ }
882
+ }
883
+ exports.PhishingController = PhishingController;
884
+ _PhishingController_detector = new WeakMap(), _PhishingController_stalelistRefreshInterval = new WeakMap(), _PhishingController_hotlistRefreshInterval = new WeakMap(), _PhishingController_c2DomainBlocklistRefreshInterval = new WeakMap(), _PhishingController_urlScanCache = new WeakMap(), _PhishingController_tokenScanCache = new WeakMap(), _PhishingController_addressScanCache = new WeakMap(), _PhishingController_knownRecipients = new WeakMap(), _PhishingController_transactionRecipients = new WeakMap(), _PhishingController_transactionRecipientsByTransactionId = new WeakMap(), _PhishingController_transactionRecipientCounts = new WeakMap(), _PhishingController_addressBookRecipients = new WeakMap(), _PhishingController_inProgressHotlistUpdate = new WeakMap(), _PhishingController_inProgressStalelistUpdate = new WeakMap(), _PhishingController_isProgressC2DomainBlocklistUpdate = new WeakMap(), _PhishingController_transactionControllerStateChangeHandler = new WeakMap(), _PhishingController_addressBookControllerStateChangeHandler = new WeakMap(), _PhishingController_fetchTokenScanBulkResults = new WeakMap(), _PhishingController_processBatch = new WeakMap(), _PhishingController_instances = new WeakSet(), _PhishingController_subscribeToAddressBookControllerStateChange = function _PhishingController_subscribeToAddressBookControllerStateChange() {
885
+ this.messenger.subscribe(
886
+ // eslint-disable-next-line no-restricted-syntax
887
+ 'AddressBookController:stateChange', __classPrivateFieldGet(this, _PhishingController_addressBookControllerStateChangeHandler, "f"));
888
+ }, _PhishingController_subscribeToTransactionControllerStateChange = function _PhishingController_subscribeToTransactionControllerStateChange() {
889
+ this.messenger.subscribe(
890
+ // eslint-disable-next-line no-restricted-syntax
891
+ 'TransactionController:stateChange', __classPrivateFieldGet(this, _PhishingController_transactionControllerStateChangeHandler, "f"));
892
+ }, _PhishingController_isTransactionPatch = function _PhishingController_isTransactionPatch(patch) {
893
+ const { path } = patch;
894
+ return (path.length === 2 &&
895
+ path[0] === 'transactions' &&
896
+ typeof path[1] === 'number');
897
+ }, _PhishingController_isSimulationDataPatch = function _PhishingController_isSimulationDataPatch(patch) {
898
+ const { path } = patch;
899
+ return (path.length === 3 &&
900
+ path[0] === 'transactions' &&
901
+ typeof path[1] === 'number' &&
902
+ path[2] === 'simulationData');
903
+ }, _PhishingController_onTransactionControllerStateChange = function _PhishingController_onTransactionControllerStateChange(_state, patches) {
904
+ try {
905
+ try {
906
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_updateKnownRecipientsFromTransactionPatches).call(this, _state, patches);
907
+ }
908
+ catch (error) {
909
+ console.error('Error updating known recipients from transaction state:', error);
910
+ }
911
+ const tokensByChain = new Map();
912
+ for (const patch of patches) {
913
+ if (patch.op === 'remove') {
914
+ continue;
915
+ }
916
+ // Handle transaction-level patches (includes simulation data updates)
917
+ if (__classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_isTransactionPatch).call(this, patch)) {
918
+ const transaction = patch.value;
919
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_getTokensFromTransaction).call(this, transaction, tokensByChain);
920
+ }
921
+ else if (__classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_isSimulationDataPatch).call(this, patch)) {
922
+ const transactionIndex = patch.path[1];
923
+ const transaction = _state.transactions?.[transactionIndex];
924
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_getTokensFromTransaction).call(this, transaction, tokensByChain);
925
+ }
926
+ }
927
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_scanTokensByChain).call(this, tokensByChain);
928
+ }
929
+ catch (error) {
930
+ console.error('Error processing transaction state change:', error);
931
+ }
932
+ }, _PhishingController_onAddressBookControllerStateChange = function _PhishingController_onAddressBookControllerStateChange(state) {
933
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_setKnownRecipientsFromAddressBookState).call(this, state);
934
+ }, _PhishingController_getTokensFromTransaction = function _PhishingController_getTokensFromTransaction(transaction, tokensByChain) {
935
+ // extract token addresses from simulation data
936
+ const tokenAddresses = transaction.simulationData?.tokenBalanceChanges?.map((tokenChange) => tokenChange.address.toLowerCase());
937
+ // add token addresses to the map by chainId
938
+ if (tokenAddresses && tokenAddresses.length > 0 && transaction.chainId) {
939
+ const chainId = transaction.chainId.toLowerCase();
940
+ if (!tokensByChain.has(chainId)) {
941
+ tokensByChain.set(chainId, new Set());
942
+ }
943
+ const chainTokens = tokensByChain.get(chainId);
944
+ if (chainTokens) {
945
+ for (const address of tokenAddresses) {
946
+ chainTokens.add(address);
947
+ }
948
+ }
949
+ }
950
+ }, _PhishingController_scanTokensByChain = function _PhishingController_scanTokensByChain(tokensByChain) {
951
+ for (const [chainId, tokenSet] of tokensByChain) {
952
+ if (tokenSet.size > 0) {
953
+ const tokens = Array.from(tokenSet);
954
+ this.bulkScanTokens({
955
+ chainId,
956
+ tokens,
957
+ }).catch((error) => console.error(`Error scanning tokens for chain ${chainId}:`, error));
958
+ }
959
+ }
960
+ }, _PhishingController_hydrateKnownRecipients = function _PhishingController_hydrateKnownRecipients() {
961
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_hydrateKnownRecipientsFromTransactionState).call(this);
962
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_hydrateKnownRecipientsFromAddressBookState).call(this);
963
+ }, _PhishingController_hydrateKnownRecipientsFromTransactionState = function _PhishingController_hydrateKnownRecipientsFromTransactionState() {
964
+ try {
965
+ const state = this.messenger.call('TransactionController:getState');
966
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_setKnownRecipientsFromTransactionState).call(this, state);
967
+ }
968
+ catch (error) {
969
+ console.error('Unable to hydrate known recipients from TransactionController state; address poisoning checks will not include existing confirmed transactions.', error);
970
+ }
971
+ }, _PhishingController_hydrateKnownRecipientsFromAddressBookState = function _PhishingController_hydrateKnownRecipientsFromAddressBookState() {
972
+ try {
973
+ const state = this.messenger.call('AddressBookController:getState');
974
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_setKnownRecipientsFromAddressBookState).call(this, state);
975
+ }
976
+ catch (error) {
977
+ console.error('Unable to hydrate known recipients from AddressBookController state; address poisoning checks will not include existing address book entries.', error);
978
+ }
979
+ }, _PhishingController_setKnownRecipientsFromTransactionState = function _PhishingController_setKnownRecipientsFromTransactionState(state) {
980
+ __classPrivateFieldGet(this, _PhishingController_transactionRecipients, "f").clear();
981
+ __classPrivateFieldGet(this, _PhishingController_transactionRecipientsByTransactionId, "f").clear();
982
+ __classPrivateFieldGet(this, _PhishingController_transactionRecipientCounts, "f").clear();
983
+ for (const transaction of state.transactions) {
984
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_addTransactionRecipients).call(this, transaction);
985
+ }
986
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_rebuildKnownRecipients).call(this);
987
+ }, _PhishingController_updateKnownRecipientsFromTransactionPatches = function _PhishingController_updateKnownRecipientsFromTransactionPatches(state, patches) {
988
+ let recipientsChanged = false;
989
+ for (const patch of patches) {
990
+ if (patch.path[0] !== 'transactions') {
991
+ continue;
992
+ }
993
+ if (patch.path.length === 1) {
994
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_setKnownRecipientsFromTransactionState).call(this, state);
995
+ return;
996
+ }
997
+ const transactionIndex = patch.path[1];
998
+ if (transactionIndex === 'length') {
999
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_setKnownRecipientsFromTransactionState).call(this, state);
1000
+ return;
1001
+ }
1002
+ if (patch.op === 'remove') {
1003
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_setKnownRecipientsFromTransactionState).call(this, state);
1004
+ return;
1005
+ }
1006
+ if (typeof transactionIndex !== 'number') {
1007
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_setKnownRecipientsFromTransactionState).call(this, state);
1008
+ return;
1009
+ }
1010
+ const transaction = __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_getTransactionFromPatchValue).call(this, patch.value) ??
1011
+ state.transactions[transactionIndex];
1012
+ if (!transaction) {
1013
+ continue;
1014
+ }
1015
+ recipientsChanged =
1016
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_updateTransactionRecipients).call(this, transaction) || recipientsChanged;
1017
+ }
1018
+ if (recipientsChanged) {
1019
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_rebuildKnownRecipients).call(this);
1020
+ }
1021
+ }, _PhishingController_getTransactionFromPatchValue = function _PhishingController_getTransactionFromPatchValue(value) {
1022
+ const transaction = value;
1023
+ if (value &&
1024
+ typeof value === 'object' &&
1025
+ typeof transaction.id === 'string' &&
1026
+ transaction.txParams !== undefined) {
1027
+ return value;
1028
+ }
1029
+ return undefined;
1030
+ }, _PhishingController_updateTransactionRecipients = function _PhishingController_updateTransactionRecipients(transaction) {
1031
+ const recipientsRemoved = __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_removeTransactionRecipients).call(this, transaction.id);
1032
+ const recipientsAdded = __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_addTransactionRecipients).call(this, transaction);
1033
+ return recipientsRemoved || recipientsAdded;
1034
+ }, _PhishingController_addTransactionRecipients = function _PhishingController_addTransactionRecipients(transaction) {
1035
+ const recipients = __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_getRecipientAddressesFromTransaction).call(this, transaction);
1036
+ if (recipients.length === 0) {
1037
+ return false;
1038
+ }
1039
+ __classPrivateFieldGet(this, _PhishingController_transactionRecipientsByTransactionId, "f").set(transaction.id, new Set(recipients));
1040
+ for (const address of recipients) {
1041
+ const count = __classPrivateFieldGet(this, _PhishingController_transactionRecipientCounts, "f").get(address) ?? 0;
1042
+ __classPrivateFieldGet(this, _PhishingController_transactionRecipientCounts, "f").set(address, count + 1);
1043
+ __classPrivateFieldGet(this, _PhishingController_transactionRecipients, "f").add(address);
1044
+ }
1045
+ return true;
1046
+ }, _PhishingController_removeTransactionRecipients = function _PhishingController_removeTransactionRecipients(transactionId) {
1047
+ const recipients = __classPrivateFieldGet(this, _PhishingController_transactionRecipientsByTransactionId, "f").get(transactionId);
1048
+ if (!recipients) {
1049
+ return false;
1050
+ }
1051
+ __classPrivateFieldGet(this, _PhishingController_transactionRecipientsByTransactionId, "f").delete(transactionId);
1052
+ for (const address of recipients) {
1053
+ const count = __classPrivateFieldGet(this, _PhishingController_transactionRecipientCounts, "f").get(address);
1054
+ if (count <= 1) {
1055
+ __classPrivateFieldGet(this, _PhishingController_transactionRecipientCounts, "f").delete(address);
1056
+ __classPrivateFieldGet(this, _PhishingController_transactionRecipients, "f").delete(address);
1057
+ }
1058
+ else {
1059
+ __classPrivateFieldGet(this, _PhishingController_transactionRecipientCounts, "f").set(address, count - 1);
1060
+ }
1061
+ }
1062
+ return true;
1063
+ }, _PhishingController_setKnownRecipientsFromAddressBookState = function _PhishingController_setKnownRecipientsFromAddressBookState(state) {
1064
+ __classPrivateFieldGet(this, _PhishingController_addressBookRecipients, "f").clear();
1065
+ for (const address of __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_getAddressBookRecipients).call(this, state)) {
1066
+ __classPrivateFieldGet(this, _PhishingController_addressBookRecipients, "f").add(address);
1067
+ }
1068
+ __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_rebuildKnownRecipients).call(this);
1069
+ }, _PhishingController_rebuildKnownRecipients = function _PhishingController_rebuildKnownRecipients() {
1070
+ __classPrivateFieldGet(this, _PhishingController_knownRecipients, "f").clear();
1071
+ for (const address of __classPrivateFieldGet(this, _PhishingController_transactionRecipients, "f")) {
1072
+ __classPrivateFieldGet(this, _PhishingController_knownRecipients, "f").add(address);
1073
+ }
1074
+ for (const address of __classPrivateFieldGet(this, _PhishingController_addressBookRecipients, "f")) {
1075
+ __classPrivateFieldGet(this, _PhishingController_knownRecipients, "f").add(address);
1076
+ }
1077
+ }, _PhishingController_getAddressBookRecipients = function _PhishingController_getAddressBookRecipients(state) {
1078
+ return new Set(Object.values(state.addressBook)
1079
+ .flatMap((entriesByAddress) => Object.values(entriesByAddress))
1080
+ .map((entry) => entry.address.toLowerCase()));
1081
+ }, _PhishingController_getRecipientAddressesFromTransaction = function _PhishingController_getRecipientAddressesFromTransaction(transaction) {
1082
+ if (transaction.status !== transaction_controller_1.TransactionStatus.confirmed) {
1083
+ return [];
1084
+ }
1085
+ const transactionRecipient = __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_normalizeAddress).call(this, (0, transaction_controller_1.getEffectiveRecipient)(transaction));
1086
+ const swapAndSendRecipient = __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_normalizeAddress).call(this, transaction.swapAndSendRecipient);
1087
+ return Array.from(new Set([transactionRecipient, swapAndSendRecipient].filter((address) => Boolean(address))));
1088
+ }, _PhishingController_normalizeAddress = function _PhishingController_normalizeAddress(address) {
1089
+ if (!address || !(0, controller_utils_1.isValidHexAddress)(address, { allowNonPrefixed: false })) {
1090
+ return null;
1091
+ }
1092
+ return address.toLowerCase();
1093
+ }, _PhishingController_updateStalelist =
1094
+ /**
1095
+ * Update the stalelist configuration.
1096
+ *
1097
+ * This should only be called from the `updateStalelist` function, which is a wrapper around
1098
+ * this function that prevents redundant configuration updates.
1099
+ */
1100
+ async function _PhishingController_updateStalelist() {
1101
+ let stalelistResponse = null;
1102
+ let hotlistDiffsResponse = null;
1103
+ let c2DomainBlocklistResponse = null;
1104
+ try {
1105
+ const stalelistPromise = __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_queryConfig).call(this, exports.METAMASK_STALELIST_URL);
1106
+ const c2DomainBlocklistPromise = __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_queryConfig).call(this, exports.C2_DOMAIN_BLOCKLIST_URL);
1107
+ [stalelistResponse, c2DomainBlocklistResponse] = await Promise.all([
1108
+ stalelistPromise,
1109
+ c2DomainBlocklistPromise,
1110
+ ]);
1111
+ // Fetching hotlist diffs relies on having a lastUpdated timestamp to do `GET /v1/diffsSince/:timestamp`,
1112
+ // so it doesn't make sense to call if there is not a timestamp to begin with.
1113
+ if (stalelistResponse?.data && stalelistResponse.data.lastUpdated > 0) {
1114
+ hotlistDiffsResponse = await __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_queryConfig).call(this, `${exports.METAMASK_HOTLIST_DIFF_URL}/${stalelistResponse.data.lastUpdated}`);
1115
+ }
1116
+ }
1117
+ finally {
1118
+ // Set `stalelistLastFetched` and `hotlistLastFetched` even for failed requests to prevent server
1119
+ // from being overwhelmed with traffic after a network disruption.
1120
+ const timeNow = (0, utils_js_1.fetchTimeNow)();
1121
+ this.update((draftState) => {
1122
+ draftState.stalelistLastFetched = timeNow;
1123
+ draftState.hotlistLastFetched = timeNow;
1124
+ if (c2DomainBlocklistResponse) {
1125
+ draftState.c2DomainBlocklistLastFetched = timeNow;
1126
+ }
1127
+ });
1128
+ }
1129
+ if (!stalelistResponse || !hotlistDiffsResponse) {
1130
+ return;
1131
+ }
1132
+ const metamaskListState = {
1133
+ allowlist: stalelistResponse.data.allowlist,
1134
+ fuzzylist: stalelistResponse.data.fuzzylist,
1135
+ tolerance: stalelistResponse.data.tolerance,
1136
+ version: stalelistResponse.data.version,
1137
+ lastUpdated: stalelistResponse.data.lastUpdated,
1138
+ blocklist: stalelistResponse.data.blocklist,
1139
+ blocklistPaths: (0, PathTrie_js_1.convertListToTrie)(stalelistResponse.data.blocklistPaths),
1140
+ c2DomainBlocklist: c2DomainBlocklistResponse
1141
+ ? c2DomainBlocklistResponse.recentlyAdded
1142
+ : [],
1143
+ name: exports.phishingListKeyNameMap.eth_phishing_detect_config,
1144
+ };
1145
+ const newMetaMaskListState = (0, utils_js_1.applyDiffs)(metamaskListState, hotlistDiffsResponse.data, ListKeys.EthPhishingDetectConfig);
1146
+ this.update((draftState) => {
1147
+ draftState.phishingLists = [newMetaMaskListState];
1148
+ });
1149
+ this.updatePhishingDetector();
1150
+ }, _PhishingController_updateHotlist =
1151
+ /**
1152
+ * Update the stalelist configuration.
1153
+ *
1154
+ * This should only be called from the `updateStalelist` function, which is a wrapper around
1155
+ * this function that prevents redundant configuration updates.
1156
+ */
1157
+ async function _PhishingController_updateHotlist() {
1158
+ let hotlistResponse;
1159
+ try {
1160
+ if (this.state.phishingLists.length === 0) {
1161
+ return;
1162
+ }
1163
+ const lastDiffTimestamp = Math.max(...this.state.phishingLists.map(({ lastUpdated }) => lastUpdated));
1164
+ hotlistResponse = await __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_queryConfig).call(this, `${exports.METAMASK_HOTLIST_DIFF_URL}/${lastDiffTimestamp}`);
1165
+ }
1166
+ finally {
1167
+ // Set `hotlistLastFetched` even for failed requests to prevent server from being overwhelmed with
1168
+ // traffic after a network disruption.
1169
+ this.update((draftState) => {
1170
+ draftState.hotlistLastFetched = (0, utils_js_1.fetchTimeNow)();
1171
+ });
1172
+ }
1173
+ if (!hotlistResponse?.data) {
1174
+ return;
1175
+ }
1176
+ const hotlist = hotlistResponse.data;
1177
+ const newPhishingLists = this.state.phishingLists.map((phishingList) => {
1178
+ const updatedList = (0, utils_js_1.applyDiffs)(phishingList, hotlist, phishingListNameKeyMap[phishingList.name], [], []);
1179
+ return updatedList;
1180
+ });
1181
+ this.update((draftState) => {
1182
+ draftState.phishingLists = newPhishingLists;
1183
+ });
1184
+ this.updatePhishingDetector();
1185
+ }, _PhishingController_updateC2DomainBlocklist =
1186
+ /**
1187
+ * Update the C2 domain blocklist.
1188
+ *
1189
+ * This should only be called from the `updateC2DomainBlocklist` function, which is a wrapper around
1190
+ * this function that prevents redundant configuration updates.
1191
+ */
1192
+ async function _PhishingController_updateC2DomainBlocklist() {
1193
+ const c2DomainBlocklistResponse = await __classPrivateFieldGet(this, _PhishingController_instances, "m", _PhishingController_queryConfig).call(this, `${exports.C2_DOMAIN_BLOCKLIST_URL}?timestamp=${(0, utils_js_1.roundToNearestMinute)(this.state.c2DomainBlocklistLastFetched)}`);
1194
+ if (!c2DomainBlocklistResponse) {
1195
+ return;
1196
+ }
1197
+ this.update((draftState) => {
1198
+ draftState.c2DomainBlocklistLastFetched = (0, utils_js_1.fetchTimeNow)();
1199
+ });
1200
+ const recentlyAddedC2Domains = c2DomainBlocklistResponse.recentlyAdded;
1201
+ const recentlyRemovedC2Domains = c2DomainBlocklistResponse.recentlyRemoved;
1202
+ const newPhishingLists = this.state.phishingLists.map((phishingList) => {
1203
+ const updatedList = (0, utils_js_1.applyDiffs)(phishingList, [], phishingListNameKeyMap[phishingList.name], recentlyAddedC2Domains, recentlyRemovedC2Domains);
1204
+ return updatedList;
1205
+ });
1206
+ this.update((draftState) => {
1207
+ draftState.phishingLists = newPhishingLists;
1208
+ });
1209
+ this.updatePhishingDetector();
1210
+ }, _PhishingController_queryConfig = async function _PhishingController_queryConfig(input) {
1211
+ const response = await (0, controller_utils_1.safelyExecute)(() => fetch(input, { cache: 'no-cache' }), true);
1212
+ switch (response?.status) {
1213
+ case 200: {
1214
+ return await response.json();
1215
+ }
1216
+ default: {
1217
+ return null;
1218
+ }
1219
+ }
1220
+ };
1221
+ exports.default = PhishingController;
1222
+ //# sourceMappingURL=PhishingController.cjs.map