chore: use faster address checksum functions

Author: Nodonisko

packages/controller-utils/package.json

@@ -47,7 +47,6 @@
     "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch"
   },
   "dependencies": {
-    "@ethereumjs/util": "^9.1.0",
     "@metamask/eth-query": "^4.0.0",
     "@metamask/ethjs-unit": "^0.3.0",
     "@metamask/utils": "^11.2.0",
@@ -57,12 +56,14 @@
     "bn.js": "^5.2.1",
     "cockatiel": "^3.1.2",
     "eth-ens-namehash": "^2.0.8",
-    "fast-deep-equal": "^3.1.3"
+    "fast-deep-equal": "^3.1.3",
+    "lodash.memoize": "^4.1.2"
   },
   "devDependencies": {
     "@babel/runtime": "^7.23.9",
     "@metamask/auto-changelog": "^3.4.4",
     "@types/jest": "^27.4.1",
+    "@types/lodash.memoize": "^4.1.9",
     "deepmerge": "^4.2.2",
     "jest": "^27.5.1",
     "jest-environment-jsdom": "^27.5.1",

packages/controller-utils/src/util.test.ts

@@ -3,9 +3,9 @@ import BigNumber from 'bignumber.js';
 import BN from 'bn.js';
 import nock from 'nock';
 
-import { FakeProvider } from '../../../tests/fake-provider';
 import { MAX_SAFE_CHAIN_ID } from './constants';
 import * as util from './util';
+import { FakeProvider } from '../../../tests/fake-provider';
 
 const VALID = '4e1fF7229BDdAf0A73DF183a88d9c3a04cc975e0';
 const SOME_API = 'https://someapi.com';
@@ -320,6 +320,52 @@ describe('util', () => {
     it('should return the input untouched if it is null', () => {
       expect(util.toChecksumHexAddress(null)).toBeNull();
     });
+
+    it('should memoize results for same input', () => {
+      const testAddress = '4e1ff7229bddaf0a73df183a88d9c3a04cc975e0';
+
+      // Call the function multiple times with the same input
+      const result1 = util.toChecksumHexAddress(testAddress);
+      const result2 = util.toChecksumHexAddress(testAddress);
+      const result3 = util.toChecksumHexAddress(testAddress);
+
+      // All results should be identical
+      expect(result1).toBe('0x4e1fF7229BDdAf0A73DF183a88d9c3a04cc975e0');
+      expect(result2).toBe(result1);
+      expect(result3).toBe(result1);
+    });
+
+    it('should return different results for different inputs but still memoize each', () => {
+      const testAddress1 = '4e1ff7229bddaf0a73df183a88d9c3a04cc975e0';
+      const testAddress2 = '742d35cc6ba4c0a2b7e8b4c0b1b0c2b2b2b2b2b2';
+
+      // Call with first address multiple times
+      const result1a = util.toChecksumHexAddress(testAddress1);
+      const result1b = util.toChecksumHexAddress(testAddress1);
+
+      // Call with second address multiple times
+      const result2a = util.toChecksumHexAddress(testAddress2);
+      const result2b = util.toChecksumHexAddress(testAddress2);
+
+      // Results for same address should be identical
+      expect(result1b).toBe(result1a);
+      expect(result2b).toBe(result2a);
+
+      // Results for different addresses should be different
+      expect(result1a).not.toBe(result2a);
+    });
+
+    it('should memoize based on complete argument signature', () => {
+      const testAddress = '4e1ff7229bddaf0a73df183a88d9c3a04cc975e0';
+
+      // Call with string argument
+      const result1 = util.toChecksumHexAddress(testAddress);
+      const result2 = util.toChecksumHexAddress(testAddress);
+
+      // Both should be memoized and return the same result
+      expect(result2).toBe(result1);
+      expect(result1).toBe('0x4e1fF7229BDdAf0A73DF183a88d9c3a04cc975e0');
+    });
   });
 
   describe('isValidHexAddress', () => {
@@ -336,6 +382,83 @@ describe('util', () => {
         false,
       );
     });
+
+    it('should memoize results for same input', () => {
+      const validAddress = '4e1fF7229BDdAf0A73DF183a88d9c3a04cc975e0';
+
+      // Call the function multiple times with the same input
+      const result1 = util.isValidHexAddress(validAddress);
+      const result2 = util.isValidHexAddress(validAddress);
+      const result3 = util.isValidHexAddress(validAddress);
+
+      // All results should be identical
+      expect(result1).toBe(true);
+      expect(result2).toBe(result1);
+      expect(result3).toBe(result1);
+    });
+
+    it('should memoize results for same input with options', () => {
+      const validAddress = '4e1fF7229BDdAf0A73DF183a88d9c3a04cc975e0';
+      const options = { allowNonPrefixed: true };
+
+      // Call the function multiple times with the same input and options
+      const result1 = util.isValidHexAddress(validAddress, options);
+      const result2 = util.isValidHexAddress(validAddress, options);
+      const result3 = util.isValidHexAddress(validAddress, options);
+
+      // All results should be identical
+      expect(result1).toBe(true);
+      expect(result2).toBe(result1);
+      expect(result3).toBe(result1);
+    });
+
+    it('should return different results for different option combinations', () => {
+      const addressWithoutPrefix = '4e1fF7229BDdAf0A73DF183a88d9c3a04cc975e0';
+
+      // Call with different options
+      const result1 = util.isValidHexAddress(addressWithoutPrefix, {
+        allowNonPrefixed: true,
+      });
+      const result2 = util.isValidHexAddress(addressWithoutPrefix, {
+        allowNonPrefixed: false,
+      });
+
+      // Should return different results for different options
+      expect(result1).toBe(true);
+      expect(result2).toBe(false);
+
+      // But calling again with same options should return memoized results
+      const result1Again = util.isValidHexAddress(addressWithoutPrefix, {
+        allowNonPrefixed: true,
+      });
+      const result2Again = util.isValidHexAddress(addressWithoutPrefix, {
+        allowNonPrefixed: false,
+      });
+
+      expect(result1Again).toBe(result1);
+      expect(result2Again).toBe(result2);
+    });
+
+    it('should handle memoization with different address inputs', () => {
+      const validAddress = '4e1fF7229BDdAf0A73DF183a88d9c3a04cc975e0';
+      const invalidAddress = '0x00';
+
+      // Call with valid address multiple times
+      const validResult1 = util.isValidHexAddress(validAddress);
+      const validResult2 = util.isValidHexAddress(validAddress);
+
+      // Call with invalid address multiple times
+      const invalidResult1 = util.isValidHexAddress(invalidAddress);
+      const invalidResult2 = util.isValidHexAddress(invalidAddress);
+
+      // Results for same address should be identical
+      expect(validResult2).toBe(validResult1);
+      expect(invalidResult2).toBe(invalidResult1);
+
+      // Results should be correct
+      expect(validResult1).toBe(true);
+      expect(invalidResult1).toBe(false);
+    });
   });
 
   it('messageHexToString', () => {

packages/controller-utils/src/util.ts

@@ -1,4 +1,3 @@
-import { isValidAddress, toChecksumAddress } from '@ethereumjs/util';
 import type EthQuery from '@metamask/eth-query';
 import { fromWei, toWei } from '@metamask/ethjs-unit';
 import type { Hex, Json } from '@metamask/utils';
@@ -7,11 +6,15 @@ import {
   add0x,
   isHexString,
   remove0x,
+  getChecksumAddress,
+  // TODO: we need to bump package version to get this
+  isHexChecksumAddress,
 } from '@metamask/utils';
 import type { BigNumber } from 'bignumber.js';
 import BN from 'bn.js';
 import ensNamehash from 'eth-ens-namehash';
 import deepEqual from 'fast-deep-equal';
+import memoize from 'lodash.memoize';
 
 import { MAX_SAFE_CHAIN_ID } from './constants';
 
@@ -284,7 +287,7 @@ export async function safelyExecuteWithTimeout<Result>(
  * @param address - The address to convert.
  * @returns The address in 0x-prefixed hexadecimal checksummed form if it is valid.
  */
-export function toChecksumHexAddress(address: string): string;
+function toChecksumHexAddressUnmemoized(address: string): string;
 
 /**
  * Convert an address to a checksummed hexadecimal address.
@@ -299,11 +302,11 @@ export function toChecksumHexAddress(address: string): string;
  */
 // TODO: Either fix this lint violation or explain why it's necessary to ignore.
 // eslint-disable-next-line @typescript-eslint/naming-convention
-export function toChecksumHexAddress<T>(address: T): T;
+function toChecksumHexAddressUnmemoized<T>(address: T): T;
 
 // Tools only see JSDocs for overloads and ignore them for the implementation.
 // eslint-disable-next-line jsdoc/require-jsdoc
-export function toChecksumHexAddress(address: unknown) {
+function toChecksumHexAddressUnmemoized(address: unknown) {
   if (typeof address !== 'string') {
     // Mimic behavior of `addHexPrefix` from `ethereumjs-util` (which this
     // function was previously using) for backward compatibility.
@@ -320,9 +323,20 @@ export function toChecksumHexAddress(address: unknown) {
     return hexPrefixed;
   }
 
-  return toChecksumAddress(hexPrefixed);
+  return getChecksumAddress(hexPrefixed);
 }
 
+/**
+ * Convert an address to a checksummed hexadecimal address.
+ *
+ * @param address - The address to convert.
+ * @returns The address in 0x-prefixed hexadecimal checksummed form if it is valid.
+ */
+export const toChecksumHexAddress: {
+  (address: string): string;
+  <T>(address: T): T;
+} = memoize(toChecksumHexAddressUnmemoized);
+
 /**
  * Validates that the input is a hex address. This utility method is a thin
  * wrapper around @metamask/utils.isValidHexAddress, with the exception that it
@@ -334,7 +348,7 @@ export function toChecksumHexAddress(address: unknown) {
  * @param options.allowNonPrefixed - If true will allow addresses without `0x` prefix.`
  * @returns Whether or not the input is a valid hex address.
  */
-export function isValidHexAddress(
+function isValidHexAddressUnmemoized(
   possibleAddress: string,
   { allowNonPrefixed = true } = {},
 ): boolean {
@@ -345,9 +359,17 @@ export function isValidHexAddress(
     return false;
   }
 
-  return isValidAddress(addressToCheck);
+  return isHexChecksumAddress(addressToCheck);
 }
 
+export const isValidHexAddress: (
+  address: string,
+  options?: { allowNonPrefixed?: boolean },
+) => boolean = memoize(
+  isValidHexAddressUnmemoized,
+  (address, options) => `${address}-${options?.allowNonPrefixed}`,
+);
+
 /**
  * Returns whether the given code corresponds to a smart contract.
  *

yarn.lock

@@ -2917,14 +2917,14 @@ __metadata:
   resolution: "@metamask/controller-utils@workspace:packages/controller-utils"
   dependencies:
     "@babel/runtime": "npm:^7.23.9"
-    "@ethereumjs/util": "npm:^9.1.0"
     "@metamask/auto-changelog": "npm:^3.4.4"
     "@metamask/eth-query": "npm:^4.0.0"
     "@metamask/ethjs-unit": "npm:^0.3.0"
     "@metamask/utils": "npm:^11.2.0"
     "@spruceid/siwe-parser": "npm:2.1.0"
     "@types/bn.js": "npm:^5.1.5"
     "@types/jest": "npm:^27.4.1"
+    "@types/lodash.memoize": "npm:^4.1.9"
     bignumber.js: "npm:^9.1.2"
     bn.js: "npm:^5.2.1"
     cockatiel: "npm:^3.1.2"
@@ -2933,6 +2933,7 @@ __metadata:
     fast-deep-equal: "npm:^3.1.3"
     jest: "npm:^27.5.1"
     jest-environment-jsdom: "npm:^27.5.1"
+    lodash.memoize: "npm:^4.1.2"
     nock: "npm:^13.3.1"
     sinon: "npm:^9.2.4"
     ts-jest: "npm:^27.1.4"
@@ -5593,6 +5594,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/lodash.memoize@npm:^4.1.9":
+  version: 4.1.9
+  resolution: "@types/lodash.memoize@npm:4.1.9"
+  dependencies:
+    "@types/lodash": "npm:*"
+  checksum: 10/d11efe604911aabbf9c49eb02e944de856619d6e0ab348d83be3ff07de245ee605ea71b1f3ee24b5c134286d02625119edf3ac2c0e6aa4732f699b1f4aa55240
+  languageName: node
+  linkType: hard
+
+"@types/lodash@npm:*":
+  version: 4.17.19
+  resolution: "@types/lodash@npm:4.17.19"
+  checksum: 10/555e53da60dd9904ef4b6f4e663abb965cf45582079f2ea231a18b0b48df4808b60f36c978548fcf5e307bf12ccd563bd4551963039028ea120b1695c7146f7c
+  languageName: node
+  linkType: hard
+
 "@types/lodash@npm:^4.14.191":
   version: 4.17.7
   resolution: "@types/lodash@npm:4.17.7"
@@ -11556,7 +11573,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lodash.memoize@npm:4.x":
+"lodash.memoize@npm:4.x, lodash.memoize@npm:^4.1.2":
   version: 4.1.2
   resolution: "lodash.memoize@npm:4.1.2"
   checksum: 10/192b2168f310c86f303580b53acf81ab029761b9bd9caa9506a019ffea5f3363ea98d7e39e7e11e6b9917066c9d36a09a11f6fe16f812326390d8f3a54a1a6da