Merge branch 'develop' into feat/use-infura-gas-api

Author: OGPoyraz

.yarn/patches/@metamask-assets-controllers-patch-0f46262fea.patch

@@ -0,0 +1,16 @@
+diff --git a/dist/Standards/NftStandards/ERC721/ERC721Standard.js b/dist/Standards/NftStandards/ERC721/ERC721Standard.js
+index d9286b0c0e607d2857f3ee7dad40d13a6c11d7d7..4e12e4b590b1f34a66602d63035f1905917f8c93 100644
+--- a/dist/Standards/NftStandards/ERC721/ERC721Standard.js
++++ b/dist/Standards/NftStandards/ERC721/ERC721Standard.js
+@@ -66,7 +66,10 @@ class ERC721Standard {
+             const contract = new contracts_1.Contract(address, metamask_eth_abis_1.abiERC721, this.provider);
+             const supportsMetadata = yield this.contractSupportsMetadataInterface(address);
+             if (!supportsMetadata) {
+-                throw new Error('Contract does not support ERC721 metadata interface.');
++                // Do not throw error here, supporting Metadata interface is optional even though majority of ERC721 nfts do support it.
++                // This change is made because of instances of NFTs that are ERC404( mixed ERC20 / ERC721 implementation).
++                // As of today, ERC404 is unofficial but some people use it, the contract does not support Metadata interface, but it has the tokenURI() fct.
++                console.error('Contract does not support ERC721 metadata interface.');
+             }
+             return contract.tokenURI(tokenId);
+         });

app/_locales/en/messages.json

@@ -1,6 +1,6 @@
 {
   "content_security_policy": {
-    "extension_pages": "script-src 'self'; object-src 'none'; frame-ancestors 'none';"
+    "extension_pages": "script-src 'self' 'wasm-unsafe-eval'; object-src 'none'; frame-ancestors 'none';"
   },
   "externally_connectable": {
     "matches": ["https://metamask.io/*"],

app/images/scroll.svg

@@ -1,10 +1,9 @@
-/* global chrome */
 // This file is used only for manifest version 3
 
 // Represents if importAllScripts has been run
 // eslint-disable-next-line
 let scriptsLoadInitiated = false;
-
+const { chrome } = globalThis;
 const testMode = process.env.IN_TEST;
 
 const loadTimeLogs = [];

app/manifest/v3/chrome.json

@@ -56,7 +56,7 @@ export default class PreferencesController {
       useSafeChainsListValidation: true,
       // set to true means the dynamic list from the API is being used
       // set to false will be using the static list from contract-metadata
-      useTokenDetection: false,
+      useTokenDetection: opts?.initState?.useTokenDetection ?? true,
       useNftDetection: false,
       use4ByteResolution: true,
       useCurrencyRateCheck: true,
@@ -94,6 +94,7 @@ export default class PreferencesController {
         useNativeCurrencyAsPrimaryCurrency: true,
         hideZeroBalanceTokens: false,
         petnamesEnabled: true,
+        redesignedConfirmationsEnabled: false,
         featureNotificationsEnabled: false,
       },
       // ENS decentralized website resolution

app/scripts/app-init.js

@@ -237,10 +237,10 @@ describe('preferences controller', () => {
   });
 
   describe('setUseTokenDetection', function () {
-    it('should default to false', function () {
+    it('should default to true for new users', function () {
       const state = preferencesController.store.getState();
 
-      expect(state.useTokenDetection).toStrictEqual(false);
+      expect(state.useTokenDetection).toStrictEqual(true);
     });
 
     it('should set the useTokenDetection property in state', () => {
@@ -249,6 +249,22 @@ describe('preferences controller', () => {
         preferencesController.store.getState().useTokenDetection,
       ).toStrictEqual(true);
     });
+
+    it('should keep initial value of useTokenDetection for existing users', function () {
+      const preferencesControllerExistingUser = new PreferencesController({
+        initLangCode: 'en_US',
+        tokenListController,
+        initState: {
+          useTokenDetection: false,
+        },
+        networkConfigurations: NETWORK_CONFIGURATION_DATA,
+        onKeyringStateChange: (listener) => {
+          onKeyringStateChangeListener = listener;
+        },
+      });
+      const state = preferencesControllerExistingUser.store.getState();
+      expect(state.useTokenDetection).toStrictEqual(false);
+    });
   });
 
   describe('setUseNftDetection', () => {

app/scripts/controllers/preferences.js

@@ -7,7 +7,6 @@ import {
   MetaMetricsEventName,
   MetaMetricsEventUiCustomization,
 } from '../../../shared/constants/metametrics';
-import { SECOND } from '../../../shared/constants/time';
 
 import {
   BlockaidResultType,
@@ -25,18 +24,18 @@ import { getSnapAndHardwareInfoForMetrics } from './snap-keyring/metrics';
 
 /**
  * These types determine how the method tracking middleware handles incoming
- * requests based on the method name. There are three options right now but
- * the types could be expanded to cover other options in the future.
+ * requests based on the method name.
  */
 const RATE_LIMIT_TYPES = {
-  RATE_LIMITED: 'rate_limited',
+  TIMEOUT: 'timeout',
   BLOCKED: 'blocked',
   NON_RATE_LIMITED: 'non_rate_limited',
+  RANDOM_SAMPLE: 'random_sample',
 };
 
 /**
  * This object maps a method name to a RATE_LIMIT_TYPE. If not in this map the
- * default is 'RATE_LIMITED'
+ * default is RANDOM_SAMPLE
  */
 const RATE_LIMIT_MAP = {
   [MESSAGE_TYPE.ETH_SIGN]: RATE_LIMIT_TYPES.NON_RATE_LIMITED,
@@ -47,9 +46,12 @@ const RATE_LIMIT_MAP = {
   [MESSAGE_TYPE.ETH_DECRYPT]: RATE_LIMIT_TYPES.NON_RATE_LIMITED,
   [MESSAGE_TYPE.ETH_GET_ENCRYPTION_PUBLIC_KEY]:
     RATE_LIMIT_TYPES.NON_RATE_LIMITED,
-  [MESSAGE_TYPE.ETH_REQUEST_ACCOUNTS]: RATE_LIMIT_TYPES.RATE_LIMITED,
-  [MESSAGE_TYPE.WALLET_REQUEST_PERMISSIONS]: RATE_LIMIT_TYPES.RATE_LIMITED,
+  [MESSAGE_TYPE.ETH_REQUEST_ACCOUNTS]: RATE_LIMIT_TYPES.TIMEOUT,
+  [MESSAGE_TYPE.WALLET_REQUEST_PERMISSIONS]: RATE_LIMIT_TYPES.TIMEOUT,
   [MESSAGE_TYPE.SEND_METADATA]: RATE_LIMIT_TYPES.BLOCKED,
+  [MESSAGE_TYPE.ETH_CHAIN_ID]: RATE_LIMIT_TYPES.BLOCKED,
+  [MESSAGE_TYPE.ETH_ACCOUNTS]: RATE_LIMIT_TYPES.BLOCKED,
+  [MESSAGE_TYPE.LOG_WEB3_SHIM_USAGE]: RATE_LIMIT_TYPES.BLOCKED,
   [MESSAGE_TYPE.GET_PROVIDER_STATE]: RATE_LIMIT_TYPES.BLOCKED,
 };
 
@@ -107,7 +109,8 @@ const EVENT_NAME_MAP = {
   },
 };
 
-const rateLimitTimeouts = {};
+const rateLimitTimeoutsByMethod = {};
+let globalRateLimitCount = 0;
 
 ///: BEGIN:ONLY_INCLUDE_IF(blockaid)
 /**
@@ -120,20 +123,29 @@ const rateLimitTimeouts = {};
  *  MetaMetricsController
  * @param {Function} opts.getMetricsState - get the state of
  *  MetaMetricsController
- * @param {number} [opts.rateLimitSeconds] - number of seconds to wait before
- *  allowing another set of events to be tracked.
+ * @param {number} [opts.rateLimitTimeout] - time, in milliseconds, to wait before
+ *  allowing another set of events to be tracked for methods rate limited by timeout.
+ * @param {number} [opts.rateLimitSamplePercent] - percentage, in decimal, of events
+ *  that should be tracked for methods rate limited by random sample.
  * @param {Function} opts.getAccountType
  * @param {Function} opts.getDeviceModel
  * @param {RestrictedControllerMessenger} opts.snapAndHardwareMessenger
  * @param {AppStateController} opts.appStateController
+ * @param {number} [opts.globalRateLimitTimeout] - time, in milliseconds, of the sliding
+ * time window that should limit the number of method calls tracked to globalRateLimitMaxAmount.
+ * @param {number} [opts.globalRateLimitMaxAmount] - max number of method calls that should
+ * tracked within the globalRateLimitTimeout time window.
  * @returns {Function}
  */
 ///: END:ONLY_INCLUDE_IF
 
 export default function createRPCMethodTrackingMiddleware({
   trackEvent,
   getMetricsState,
-  rateLimitSeconds = 60 * 5,
+  rateLimitTimeout = 60 * 5 * 1000, // 5 minutes
+  rateLimitSamplePercent = 0.001, // 0.1%
+  globalRateLimitTimeout = 60 * 5 * 1000, // 5 minutes
+  globalRateLimitMaxAmount = 10, // max of events in the globalRateLimitTimeout window. pass 0 for no global rate limit
   getAccountType,
   getDeviceModel,
   snapAndHardwareMessenger,
@@ -148,14 +160,30 @@ export default function createRPCMethodTrackingMiddleware({
   ) {
     const { origin, method } = req;
 
-    // Determine what type of rate limit to apply based on method
     const rateLimitType =
-      RATE_LIMIT_MAP[method] ?? RATE_LIMIT_TYPES.RATE_LIMITED;
+      RATE_LIMIT_MAP[method] ?? RATE_LIMIT_TYPES.RANDOM_SAMPLE;
+
+    let isRateLimited;
+    switch (rateLimitType) {
+      case RATE_LIMIT_TYPES.TIMEOUT:
+        isRateLimited =
+          typeof rateLimitTimeoutsByMethod[method] !== 'undefined';
+        break;
+      case RATE_LIMIT_TYPES.NON_RATE_LIMITED:
+        isRateLimited = false;
+        break;
+      case RATE_LIMIT_TYPES.BLOCKED:
+        isRateLimited = true;
+        break;
+      default:
+      case RATE_LIMIT_TYPES.RANDOM_SAMPLE:
+        isRateLimited = Math.random() >= rateLimitSamplePercent;
+        break;
+    }
 
-    // If the rateLimitType is RATE_LIMITED check the rateLimitTimeouts
-    const rateLimited =
-      rateLimitType === RATE_LIMIT_TYPES.RATE_LIMITED &&
-      typeof rateLimitTimeouts[method] !== 'undefined';
+    const isGlobalRateLimited =
+      globalRateLimitMaxAmount > 0 &&
+      globalRateLimitCount >= globalRateLimitMaxAmount;
 
     // Get the participateInMetaMetrics state to determine if we should track
     // anything. This is extra redundancy because this value is checked in
@@ -173,10 +201,10 @@ export default function createRPCMethodTrackingMiddleware({
     const shouldTrackEvent =
       // Don't track if the request came from our own UI or background
       origin !== ORIGIN_METAMASK &&
-      // Don't track if this is a blocked method
-      rateLimitType !== RATE_LIMIT_TYPES.BLOCKED &&
       // Don't track if the rate limit has been hit
-      rateLimited === false &&
+      !isRateLimited &&
+      // Don't track if the global rate limit has been hit
+      !isGlobalRateLimited &&
       // Don't track if the user isn't participating in metametrics
       userParticipatingInMetaMetrics === true;
 
@@ -258,9 +286,16 @@ export default function createRPCMethodTrackingMiddleware({
         properties: eventProperties,
       });
 
-      rateLimitTimeouts[method] = setTimeout(() => {
-        delete rateLimitTimeouts[method];
-      }, SECOND * rateLimitSeconds);
+      if (rateLimitType === RATE_LIMIT_TYPES.TIMEOUT) {
+        rateLimitTimeoutsByMethod[method] = setTimeout(() => {
+          delete rateLimitTimeoutsByMethod[method];
+        }, rateLimitTimeout);
+      }
+
+      globalRateLimitCount += 1;
+      setTimeout(() => {
+        globalRateLimitCount -= 1;
+      }, globalRateLimitTimeout);
     }
 
     next(async (callback) => {