refactor domain resolution & optimize validateAddress

Author: Dangoz

src/app/profile/edit/components/WalletLinkForm.tsx

@@ -5,32 +5,21 @@ import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Button } from "@/components/ui/button";
 import { Loader2, Info, Shield, ArrowRight } from "lucide-react";
-import {
-  getViemClient,
-  isAddress as isEvmAddressAsync,
-  normalizeEns,
-} from "@/lib/walletLinking/viem";
 import { LinkedWallet } from "@/lib/walletLinking/readmeUtils";
-import { resolveSolDomain } from "@/lib/walletLinking/sns";
+import { validateAddress } from "@/lib/walletLinking/chainUtils";
+import {
+  resolveSnsDomain,
+  resolveEnsDomain,
+  validateEnsFormat,
+  validateSnsFormat,
+} from "@/lib/walletLinking/domain";
 
 interface WalletLinkFormProps {
   wallets: LinkedWallet[];
   onSubmit: (wallets: LinkedWallet[]) => Promise<void>;
   isProcessing: boolean;
 }
 
-// Basic regex for Solana address (Base58, 32-44 chars)
-// For more robust validation, consider @solana/web3.js PublicKey.isOnCurve or similar
-const SOL_ADDRESS_REGEX = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
-
-// ENS name regex (name.eth format)
-// Matches names that end with .eth and contain valid characters
-const ENS_NAME_REGEX = /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?\.eth$/;
-
-// SNS name regex (name.sol format)
-// Matches names that end with .sol and contain valid characters
-const SNS_NAME_REGEX = /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?\.sol$/;
-
 export function WalletLinkForm({
   wallets = [],
   onSubmit,
@@ -56,15 +45,15 @@ export function WalletLinkForm({
     // Validate initial addresses asynchronously
     const validateInitialAddresses = async () => {
       if (ethWallet?.address) {
-        const isValid = await isEvmAddressAsync(ethWallet.address);
+        const isValid = await validateAddress(ethWallet.address, "ethereum");
         setIsEthValid(isValid);
         if (!isValid) {
           setEthAddressError("Invalid Ethereum address");
         }
       }
 
       if (solWallet?.address) {
-        const isValid = SOL_ADDRESS_REGEX.test(solWallet.address);
+        const isValid = await validateAddress(solWallet.address, "solana");
         setIsSolValid(isValid);
         if (!isValid) {
           setSolAddressError("Invalid Solana address");
@@ -83,8 +72,8 @@ export function WalletLinkForm({
     }
 
     const validateEthAddress = async () => {
-      const isEVMValid = await isEvmAddressAsync(ethAddress);
-      const isENSValid = ENS_NAME_REGEX.test(ethAddress);
+      const isEVMValid = await validateAddress(ethAddress, "ethereum");
+      const isENSValid = validateEnsFormat(ethAddress);
       setIsEthValid(isEVMValid || isENSValid);
       setEthAddressError(
         isEVMValid || isENSValid ? "" : "Invalid Ethereum address or ENS name.",
@@ -101,12 +90,16 @@ export function WalletLinkForm({
       return;
     }
 
-    const isSOLValid = SOL_ADDRESS_REGEX.test(solAddress);
-    const isSNSValid = SNS_NAME_REGEX.test(solAddress);
-    setIsSolValid(isSNSValid || isSOLValid);
-    setSolAddressError(
-      isSNSValid || isSOLValid ? "" : "Invalid Solana address or SNS name.",
-    );
+    const validateSolAddress = async () => {
+      const isSOLValid = await validateAddress(solAddress, "solana");
+      const isSNSValid = validateSnsFormat(solAddress);
+      setIsSolValid(isSNSValid || isSOLValid);
+      setSolAddressError(
+        isSNSValid || isSOLValid ? "" : "Invalid Solana address or SNS name.",
+      );
+    };
+
+    validateSolAddress();
   }, [solAddress]);
 
   const handleSubmit = async (e: FormEvent<HTMLFormElement>) => {
@@ -119,14 +112,10 @@ export function WalletLinkForm({
     const updatedWallets: LinkedWallet[] = [];
 
     if (ethAddress) {
-      const isENSValid = ENS_NAME_REGEX.test(ethAddress);
-      let address: string | null = ethAddress;
-
-      if (isENSValid) {
-        const viemClient = await getViemClient();
-        const normalizedName = await normalizeEns(ethAddress);
-        address = await viemClient.getEnsAddress({ name: normalizedName });
-      }
+      const isENSValid = validateEnsFormat(ethAddress);
+      const address = isENSValid
+        ? await resolveEnsDomain(ethAddress)
+        : ethAddress;
 
       // If the address is not found, set the error and return
       if (!address) {
@@ -142,9 +131,9 @@ export function WalletLinkForm({
     }
 
     if (solAddress) {
-      const isSNSValid = SNS_NAME_REGEX.test(solAddress);
+      const isSNSValid = validateSnsFormat(solAddress);
       const address = isSNSValid
-        ? await resolveSolDomain(solAddress)
+        ? await resolveSnsDomain(solAddress)
         : solAddress;
 
       // If the address is not found, set the error and return

src/app/profile/edit/hooks/useProfileWallets.ts

@@ -60,7 +60,8 @@ export function useProfileWallets() {
       setReadmeContent(decodedReadmeText);
 
       // parse Readme content for Wallet data
-      const walletData = parseWalletLinkingDataFromReadme(decodedReadmeText);
+      const walletData =
+        await parseWalletLinkingDataFromReadme(decodedReadmeText);
       setWalletData(walletData);
     } catch (err: unknown) {
       console.error("Error in fetchProfileData:", err);

src/lib/pipelines/ingest/fetchWalletAddresses.ts

@@ -111,7 +111,7 @@ const ingestWalletAddresses = createStep(
           for (const wallet of freshWalletData.wallets) {
             if (
               !SUPPORTED_CHAINS_NAMES.includes(wallet.chain.toLowerCase()) ||
-              !validateAddress(wallet.address, wallet.chain)
+              !(await validateAddress(wallet.address, wallet.chain))
             ) {
               logger?.warn(
                 `Skipping invalid wallet for ${username}: ${wallet.address} on chain ${wallet.chain}`,

src/lib/walletLinking/chainUtils.ts

@@ -1,10 +1,13 @@
 import EthereumIcon from "@/components/icons/EthereumIcon";
 import SolanaIcon from "@/components/icons/SolanaIcon";
-import { isAddress } from "viem";
+
+// Module-level caches for imported validators to optimize repeated calls
+let viemValidator: ((address: string) => boolean) | null = null;
+let solanaValidator: ((address: string) => boolean) | null = null;
 
 interface ChainConfig {
   chainId: string;
-  validator: (address: string) => boolean;
+  validator: (address: string) => Promise<boolean>;
   icon: React.ElementType;
 }
 
@@ -21,13 +24,44 @@ interface ChainConfig {
 export const SUPPORTED_CHAINS: Record<string, ChainConfig> = {
   ethereum: {
     chainId: "eip155:1",
-    validator: (address: string) => isAddress(address),
+    validator: async (address: string) => {
+      // Use cached validator if available, otherwise import and cache
+      if (!viemValidator) {
+        const { isAddress } = await import("viem");
+        viemValidator = isAddress;
+      }
+
+      try {
+        return viemValidator(address);
+      } catch (error) {
+        console.error(`Failed to validate Ethereum address ${address}:`, error);
+        return false;
+      }
+    },
     icon: EthereumIcon,
   },
   solana: {
     chainId: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
-    validator: (address: string) =>
-      /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address),
+    validator: async (address: string) => {
+      // Use cached validator if available, otherwise import and cache
+      if (!solanaValidator) {
+        const { PublicKey } = await import("@solana/web3.js");
+        solanaValidator = (addr: string) => {
+          try {
+            return PublicKey.isOnCurve(new PublicKey(addr).toBytes());
+          } catch {
+            return false;
+          }
+        };
+      }
+
+      try {
+        return solanaValidator(address);
+      } catch (error) {
+        console.error(`Failed to validate Solana address ${address}:`, error);
+        return false;
+      }
+    },
     icon: SolanaIcon,
   },
 };
@@ -79,7 +113,10 @@ export function createAccountId(chainId: string, address: string): string {
  * @param chain The blockchain name (e.g., "ethereum", "solana")
  * @returns True if the address is valid for the chain, false otherwise
  */
-export function validateAddress(address: string, chain: string): boolean {
+export async function validateAddress(
+  address: string,
+  chain: string,
+): Promise<boolean> {
   const chainConfig =
     SUPPORTED_CHAINS[chain.toLowerCase() as keyof typeof SUPPORTED_CHAINS];
   if (!chainConfig) {

src/lib/walletLinking/sns.ts renamed to src/lib/walletLinking/domain.ts

@@ -1,4 +1,4 @@
-// Array of RPC endpoints to try in order
+// Array of solana RPC endpoints to try in order
 const RPC_ENDPOINTS = [
   "https://api.mainnet-beta.solana.com", // Public Solana RPC
   "https://solana-mainnet.g.alchemy.com/v2/lqe31XHZcBd-8FsgmYnHJ", // Alchemy endpoint, domain restricted to https://elizaos.github.io
@@ -11,7 +11,7 @@ const RPC_ENDPOINTS = [
  * @returns Promise<string> The first working RPC endpoint URL
  * @throws Will throw an error if no endpoints are accessible
  */
-async function getWorkingRpcEndpoint(
+async function getWorkingRpcEndpointForSolana(
   Connection: typeof import("@solana/web3.js").Connection,
 ): Promise<string> {
   for (const endpoint of RPC_ENDPOINTS) {
@@ -35,7 +35,7 @@ async function getWorkingRpcEndpoint(
  * @returns A Promise that resolves to the PublicKey of the domain owner
  * @throws Will throw an error if the domain doesn't exist or if there's a network issue
  */
-export async function resolveSolDomain(domain: string): Promise<string | null> {
+export async function resolveSnsDomain(domain: string): Promise<string | null> {
   try {
     // Import all Solana dependencies dynamically
     const [{ Connection }, { getDomainKeySync, NameRegistryState }] =
@@ -44,7 +44,7 @@ export async function resolveSolDomain(domain: string): Promise<string | null> {
         import("@bonfida/spl-name-service"),
       ]);
 
-    const workingEndpoint = await getWorkingRpcEndpoint(Connection);
+    const workingEndpoint = await getWorkingRpcEndpointForSolana(Connection);
     const connection = new Connection(workingEndpoint);
 
     const { pubkey } = getDomainKeySync(domain);
@@ -57,3 +57,45 @@ export async function resolveSolDomain(domain: string): Promise<string | null> {
     return null;
   }
 }
+
+/**
+ * Resolves an Ethereum Name Service (ENS) domain to its owner's address.
+ * @param name The ENS domain name to resolve (e.g., "alice.eth")
+ * @returns A Promise that resolves to the Ethereum address of the domain owner
+ * @throws Will throw an error if the domain doesn't exist or if there's a network issue
+ */
+export async function resolveEnsDomain(name: string): Promise<string | null> {
+  try {
+    const { createPublicClient, http } = await import("viem");
+    const { normalize } = await import("viem/ens");
+    const { mainnet } = await import("viem/chains");
+
+    const viemClient = createPublicClient({
+      chain: mainnet,
+      transport: http(),
+    });
+
+    const normalizedName = await normalize(name);
+    const address = await viemClient.getEnsAddress({ name: normalizedName });
+    return address;
+  } catch (error) {
+    console.error(`Failed to resolve ENS domain ${name}:`, error);
+    return null;
+  }
+}
+
+// ENS name regex (name.eth format)
+// Matches names that end with .eth and contain valid characters
+const ENS_NAME_REGEX = /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?\.eth$/;
+
+export function validateEnsFormat(name: string): boolean {
+  return ENS_NAME_REGEX.test(name);
+}
+
+// SNS name regex (name.sol format)
+// Matches names that end with .sol and contain valid characters
+const SNS_NAME_REGEX = /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?\.sol$/;
+
+export function validateSnsFormat(name: string): boolean {
+  return SNS_NAME_REGEX.test(name);
+}

src/lib/walletLinking/fetchWalletDataFromGithub.ts

@@ -37,7 +37,9 @@ export async function batchFetchWalletDataFromGithub(
       const result = fileContents[i];
 
       if (result.content) {
-        const walletData = parseWalletLinkingDataFromReadme(result.content);
+        const walletData = await parseWalletLinkingDataFromReadme(
+          result.content,
+        );
         results[username] = {
           walletData,
           profileRepoExists: true,

src/lib/walletLinking/readmeUtils.ts

@@ -29,9 +29,9 @@ const WALLET_SECTION_END_MARKER = "WALLET-LINKING-END -->";
  * @param readmeContent The string content of the README file.
  * @returns The parsed and validated wallet linking data, or null if no valid data found.
  */
-export function parseWalletLinkingDataFromReadme(
+export async function parseWalletLinkingDataFromReadme(
   readmeContent: string,
-): WalletLinkingData | null {
+): Promise<WalletLinkingData | null> {
   const startIndex = readmeContent.indexOf(WALLET_SECTION_BEGIN_MARKER);
   const endIndex = readmeContent.indexOf(WALLET_SECTION_END_MARKER);
 
@@ -56,13 +56,23 @@ export function parseWalletLinkingDataFromReadme(
     }
 
     // Make sure to only return wallets for supported chains
+    const validWallets = [];
+    for (const wallet of result.data.wallets) {
+      const isChainSupported = SUPPORTED_CHAINS_NAMES.includes(
+        wallet.chain.toLowerCase(),
+      );
+      const isAddressValid = await validateAddress(
+        wallet.address,
+        wallet.chain,
+      );
+      if (isAddressValid && isChainSupported) {
+        validWallets.push(wallet);
+      }
+    }
+
     const walletLinkingData: WalletLinkingData = {
       lastUpdated: result.data.lastUpdated,
-      wallets: result.data.wallets.filter(
-        (wallet) =>
-          SUPPORTED_CHAINS_NAMES.includes(wallet.chain.toLowerCase()) &&
-          validateAddress(wallet.address, wallet.chain),
-      ),
+      wallets: validWallets,
     };
 
     return walletLinkingData;