chore: faster address validation

src/hex.test.ts

@@ -3,10 +3,12 @@ import {
   add0x,
   assertIsHexString,
   assertIsStrictHexString,
-  isValidChecksumAddress,
+  isValidChecksumAddressUnmemoized as isValidChecksumAddress,
   isHexString,
+  isHexAddress,
+  isHexChecksumAddress,
   isStrictHexString,
-  isValidHexAddress,
+  isValidHexAddressUnmemoized as isValidHexAddress,
   remove0x,
   getChecksumAddressUnmemoized as getChecksumAddress,
   getChecksumAddress as getChecksumAddressMemoized,
@@ -156,6 +158,100 @@ describe('assertIsStrictHexString', () => {
   });
 });
 
+describe('isHexAddress', () => {
+  it.each([
+    '0x0000000000000000000000000000000000000000',
+    '0x1234567890abcdef1234567890abcdef12345678',
+    '0xffffffffffffffffffffffffffffffffffffffff',
+    '0x0123456789abcdef0123456789abcdef01234567',
+  ])('returns true for a valid hex address', (hexString) => {
+    expect(isHexAddress(hexString)).toBe(true);
+  });
+
+  it.each([
+    true,
+    false,
+    null,
+    undefined,
+    0,
+    1,
+    {},
+    [],
+    // Missing 0x prefix
+    '0000000000000000000000000000000000000000',
+    '1234567890abcdef1234567890abcdef12345678',
+    // Wrong case prefix
+    '0X1234567890abcdef1234567890abcdef12345678',
+    // Too short
+    '0x123456789abcdef1234567890abcdef1234567',
+    '0x',
+    '0x0',
+    '0x123',
+    // Too long
+    '0x1234567890abcdef1234567890abcdef123456789',
+    '0x1234567890abcdef1234567890abcdef12345678a',
+    // Contains uppercase letters (should be lowercase only)
+    '0x1234567890ABCDEF1234567890abcdef12345678',
+    '0x1234567890abcdef1234567890ABCDEF12345678',
+    '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF',
+    // Invalid characters
+    '0x1234567890abcdefg123456789abcdef12345678',
+    '0x1234567890abcdef1234567890abcdef1234567g',
+    '0x1234567890abcdef123456789abcdef12345678!',
+  ])('returns false for an invalid hex address', (hexString) => {
+    expect(isHexAddress(hexString)).toBe(false);
+  });
+});
+
+describe('isHexChecksumAddress', () => {
+  it.each([
+    '0x0000000000000000000000000000000000000000',
+    '0x1234567890abcdef1234567890abcdef12345678',
+    '0x1234567890ABCDEF1234567890abcdef12345678',
+    '0x1234567890abcdef1234567890ABCDEF12345678',
+    '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF',
+    '0xffffffffffffffffffffffffffffffffffffffff',
+    '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
+    '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed',
+    '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359',
+  ])('returns true for a valid hex checksum address', (hexString) => {
+    expect(isHexChecksumAddress(hexString)).toBe(true);
+  });
+
+  it.each([
+    true,
+    false,
+    null,
+    undefined,
+    0,
+    1,
+    {},
+    [],
+    // Missing 0x prefix
+    '0000000000000000000000000000000000000000',
+    '1234567890abcdef1234567890abcdef12345678',
+    'd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
+    // Wrong case prefix
+    '0X1234567890abcdef1234567890abcdef12345678',
+    '0Xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
+    // Too short
+    '0x123456789abcdef1234567890abcdef1234567',
+    '0x',
+    '0x0',
+    '0x123',
+    // Too long
+    '0x1234567890abcdef1234567890abcdef123456789',
+    '0x1234567890abcdef1234567890abcdef12345678a',
+    // Invalid characters
+    '0x1234567890abcdefg123456789abcdef12345678',
+    '0x1234567890abcdef1234567890abcdef1234567g',
+    '0x1234567890abcdef123456789abcdef12345678!',
+    '0x1234567890abcdef123456789abcdef12345678@',
+  ])('returns false for an invalid hex checksum address', (hexString) => {
+    expect(isHexChecksumAddress(hexString)).toBe(false);
+  });
+});
+
 describe('isValidHexAddress', () => {
   it.each([
     '0x0000000000000000000000000000000000000000' as Hex,

src/hex.ts

@@ -1,34 +1,42 @@
-import type { Struct } from '@metamask/superstruct';
-import { is, pattern, string } from '@metamask/superstruct';
+import { pattern, type Struct, string } from '@metamask/superstruct';
 import { keccak_256 as keccak256 } from '@noble/hashes/sha3';
 import memoize from 'lodash.memoize';
 
 import { assert } from './assert';
 
 export type Hex = `0x${string}`;
 
-export const HexStruct = pattern(string(), /^(?:0x)?[0-9a-f]+$/iu);
-export const StrictHexStruct = pattern(string(), /^0x[0-9a-f]+$/iu) as Struct<
+// Use native regexes instead of superstruct for maximum performance.
+// Pre-compiled regex for maximum performance - avoids recompilation on each call
+const HEX_REGEX = /^(?:0x)?[0-9a-f]+$/iu;
+const STRICT_HEX_REGEX = /^0x[0-9a-f]+$/iu;
+const HEX_ADDRESS_REGEX = /^0x[0-9a-f]{40}$/u;
+const HEX_CHECKSUM_ADDRESS_REGEX = /^0x[0-9a-fA-F]{40}$/u;
+
+export const HexStruct = pattern(string(), HEX_REGEX);
+export const StrictHexStruct = pattern(string(), STRICT_HEX_REGEX) as Struct<
+  Hex,
+  null
+>;
+export const HexAddressStruct = pattern(string(), HEX_ADDRESS_REGEX) as Struct<
   Hex,
   null
 >;
-export const HexAddressStruct = pattern(
-  string(),
-  /^0x[0-9a-f]{40}$/u,
-) as Struct<Hex, null>;
 export const HexChecksumAddressStruct = pattern(
   string(),
-  /^0x[0-9a-fA-F]{40}$/u,
+  HEX_CHECKSUM_ADDRESS_REGEX,
 ) as Struct<Hex, null>;
 
+const isString = (value: unknown): value is string => typeof value === 'string';
+
 /**
  * Check if a string is a valid hex string.
  *
  * @param value - The value to check.
  * @returns Whether the value is a valid hex string.
  */
 export function isHexString(value: unknown): value is string {
-  return is(value, HexStruct);
+  return isString(value) && HEX_REGEX.test(value);
 }
 
 /**
@@ -39,7 +47,27 @@ export function isHexString(value: unknown): value is string {
  * @returns Whether the value is a valid hex string.
  */
 export function isStrictHexString(value: unknown): value is Hex {
-  return is(value, StrictHexStruct);
+  return isString(value) && STRICT_HEX_REGEX.test(value);
+}
+
+/**
+ * Check if a string is a valid hex address.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a valid hex address.
+ */
+export function isHexAddress(value: unknown): value is Hex {
+  return isString(value) && HEX_ADDRESS_REGEX.test(value);
+}
+
+/**
+ * Check if a string is a valid hex checksum address.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a valid hex checksum address.
+ */
+export function isHexChecksumAddress(value: unknown): value is Hex {
+  return isString(value) && HEX_CHECKSUM_ADDRESS_REGEX.test(value);
 }
 
 /**
@@ -66,20 +94,6 @@ export function assertIsStrictHexString(value: unknown): asserts value is Hex {
   );
 }
 
-/**
- * Validate that the passed prefixed hex string is an all-lowercase
- * hex address, or a valid mixed-case checksum address.
- *
- * @param possibleAddress - Input parameter to check against.
- * @returns Whether or not the input is a valid hex address.
- */
-export function isValidHexAddress(possibleAddress: Hex) {
-  return (
-    is(possibleAddress, HexAddressStruct) ||
-    isValidChecksumAddress(possibleAddress)
-  );
-}
-
 /**
  * Encode a passed hex string as an ERC-55 mixed-case checksum address.
  * This is the unmemoized version, primarily used for testing.
@@ -89,7 +103,7 @@ export function isValidHexAddress(possibleAddress: Hex) {
  * @see https://eips.ethereum.org/EIPS/eip-55
  */
 export function getChecksumAddressUnmemoized(hexAddress: Hex): Hex {
-  assert(is(hexAddress, HexChecksumAddressStruct), 'Invalid hex address.');
+  assert(isHexChecksumAddress(hexAddress), 'Invalid hex address.');
   const address = remove0x(hexAddress).toLowerCase();
 
   const hashBytes = keccak256(address);
@@ -127,14 +141,45 @@ export const getChecksumAddress = memoize(getChecksumAddressUnmemoized);
  * @param possibleChecksum - The hex address to check.
  * @returns True if the address is a checksum address.
  */
-export function isValidChecksumAddress(possibleChecksum: Hex) {
-  if (!is(possibleChecksum, HexChecksumAddressStruct)) {
+export function isValidChecksumAddressUnmemoized(possibleChecksum: Hex) {
+  if (!isHexChecksumAddress(possibleChecksum)) {
     return false;
   }
 
   return getChecksumAddress(possibleChecksum) === possibleChecksum;
 }
 
+/**
+ * Validate that the passed hex string is a valid ERC-55 mixed-case
+ * checksum address.
+ *
+ * @param possibleChecksum - The hex address to check.
+ * @returns True if the address is a checksum address.
+ */
+export const isValidChecksumAddress = memoize(isValidChecksumAddressUnmemoized);
+
+/**
+ * Validate that the passed prefixed hex string is an all-lowercase
+ * hex address, or a valid mixed-case checksum address.
+ *
+ * @param possibleAddress - Input parameter to check against.
+ * @returns Whether or not the input is a valid hex address.
+ */
+export function isValidHexAddressUnmemoized(possibleAddress: Hex) {
+  return (
+    isHexAddress(possibleAddress) || isValidChecksumAddress(possibleAddress)
+  );
+}
+
+/**
+ * Validate that the passed prefixed hex string is an all-lowercase
+ * hex address, or a valid mixed-case checksum address.
+ *
+ * @param possibleAddress - Input parameter to check against.
+ * @returns Whether or not the input is a valid hex address.
+ */
+export const isValidHexAddress = memoize(isValidHexAddressUnmemoized);
+
 /**
  * Add the `0x`-prefix to a hexadecimal string. If the string already has the
  * prefix, it is returned as-is.

src/index.test.ts

@@ -118,6 +118,8 @@ describe('index', () => {
         "isErrorWithCode",
         "isErrorWithMessage",
         "isErrorWithStack",
+        "isHexAddress",
+        "isHexChecksumAddress",
         "isHexString",
         "isJsonRpcError",
         "isJsonRpcFailure",

src/index.ts

@@ -15,6 +15,8 @@ export {
   HexChecksumAddressStruct,
   isHexString,
   isStrictHexString,
+  isHexAddress,
+  isHexChecksumAddress,
   assertIsHexString,
   assertIsStrictHexString,
   isValidHexAddress,

src/node.test.ts

@@ -123,6 +123,8 @@ describe('node', () => {
         "isErrorWithCode",
         "isErrorWithMessage",
         "isErrorWithStack",
+        "isHexAddress",
+        "isHexChecksumAddress",
         "isHexString",
         "isJsonRpcError",
         "isJsonRpcFailure",