Chain-specific addresses using ENS

40}: Props) => {...119  useEffect(() => {...145146    // Debounce domain resolving147    const timeout = setTimeout(() => {148      // Must be set here, not before the timer — guard on line 107 must only block re-runs while the Promise is in-flight, not during the debounce window.149      resolveDomain({ domain: trimmedAddress })150        .then((result) => {151          if (latestFieldValueRef.current !== fieldValue) return152          setAddressState({153            fieldValue,

39export abstract class EnsCompatibleResolver implements NameResolver {...80  requiredChainId(networkMode: NetworkMode): string | undefined {81    return this.chainId[networkMode]82  }8384  protected providerFor(ctx: ResolveContext) {85    return ctx.getProvider(this.chainId[ctx.networkMode])86  }8788  async resolve(domain: string, ctx: ResolveContext): Promise<ForwardResolution | null> {89    const provider = this.providerFor(ctx)90    if (!provider) return null9192    return resolveENSDomain({93      provider,94      domain,95      options: {96        universalResolverAddress: this.universalResolver,97        expiry: this.expiryConfig98          ? {99              baseRegistrar: this.expiryConfig.baseRegistrar,100              nameWrapper: this.expiryConfig.nameWrapper[ctx.networkMode]101            }102          : null103      }104    })105  }106107  async reverse(addresses: string[], ctx: ResolveContext): Promise<ReverseLookupResult> {108    const provider = this.providerFor(ctx)

78}) {...80  const text = resolver?.getText(key)81  return text ?? null82}8384async function getOnChainEnsFetch(params: EnsLookupParams): Promise<string | null> {85  const { type, nameOrAddress } = params8687  const provider = createProvider({ chainId: UniverseChainId.Mainnet, rpcType: RPCType.Public })8889  if (!provider) {90    return null91  }9293  // Set ENS V2 tunneling batch gateway for CCIP-read tunneling for universal resolver94  const withTunnel = provider as providers.JsonRpcProvider & {95    setTunnelingBatchGateways?: (urls: string[]) => void96  }97  withTunnel.setTunnelingBatchGateways?.([ENS_TUNNELING_BATCH_GATEWAY])9899  switch (type) {100    case EnsLookupType.Name:101      return await getNameFetch(nameOrAddress, provider)102    case EnsLookupType.Address:103      return await getAddressFetch(nameOrAddress, provider)104    case EnsLookupType.Avatar:105      return await getAvatarFetch(nameOrAddress, provider)106    case EnsLookupType.Description:107      return await getTextFetch({ key: 'description', name: nameOrAddress, provider })108    case EnsLookupType.TwitterUsername:109      return await getTextFetch({ key: 'com.twitter', name: nameOrAddress, provider })110    default:111      throw new Error(`Invalid ENS lookup type: ${type}`)112  }113}114115function useEnsQuery(type: EnsLookupType, nameOrAddress?: string | null) {116  return useQuery(117    persistableQueryOptions<string | null>({

30}) => {...38  const getChainId = () => {...44    return ChainId.mainnet;45  };46  const chainId = getChainId();4748  const { ensAddress: toAddress, ensName: toEnsName } = useEns({49    addressOrName: toAddressOrName ?? '',50  });5152  const sendingNativeAsset = useMemo(53    () => !!asset && isNativeAsset(asset?.address, chainId),54    [asset, chainId],

15} = {}) {...17  return useQuery({18    queryKey: ['ensAddress', name, chainId],19    queryFn: async () => {20      if (!name) return null;21      return getEnsAddress(getViemClient({ chainId }), { name });22    },23    enabled: enabled && !!name,24    refetchOnWindowFocus: false,25    staleTime: 20 * 1000,

138export function SendSheet() {...385  useEffect(() => {386    const resolveAddressIfNeeded = async () => {387      const isValid = checkIsValidAddressOrDomainFormat(debouncedRecipient);388      if (isValid) {389        const resolvedAddress = await resolveNameOrAddress(debouncedRecipient);390        if (resolvedAddress && typeof resolvedAddress === 'string') {391          setToAddress(resolvedAddress);392        } else {393          setIsValidAddress(false);

462export const resolveNameOrAddress = async (nameOrAddress: string): Promise<string | null> => {463  if (!isHexString(nameOrAddress)) {464    if (isUnstoppableAddressFormat(nameOrAddress)) {465      const resolvedAddress = await resolveUnstoppableDomain(nameOrAddress);466      return resolvedAddress;467    }468    const p = getProvider({ chainId: ChainId.mainnet });469    const resolvedAddress = await p?.resolveName(nameOrAddress);470471    return resolvedAddress;472  }473  return nameOrAddress;

85}) => {...146  const debouncedResolveEns = useMemo(147    () =>148      debounce(...152        }: {153          address: string;154          requestId: number;155        }) => {156          try {157            const result = await resolveEnsAddressByName(address, wallet);158            if (requestId !== ensRequestIdRef.current) {159              return;160            }161            setEnsResult(

10): Promise<{ addr: string; name: string } | null> => {11  const input = name?.trim();12  if (!input) return null;1314  const ethServerId = findChainByID(1)?.serverId || 'eth';15  const ensClient = createPublicClient({16    chain: mainnet,17    transport: custom({18      request: async ({ method, params }) =>19        wallet.requestETHRpc(20          {21            method,22            params: (params || []) as any[],23          },24          ethServerId25        ),26    }),27  });2829  try {30    const normalizedName = normalize(input);31    const addr = await ensClient.getEnsAddress({32      name: normalizedName,33    });34    if (!addr) return null;35    return {

60}) => {...75  const debouncedResolveEns = React.useMemo(76    () =>77      debounce(78        async (79          value: string,80          callback: (result: { addr: string; name: string } | null) => void,81        ) => {82          const result = await resolveEnsAddressByName(value);83          callback(result);84        },85        500,86        { leading: false, trailing: true },

5import { normalize } from 'viem/ens';67const ethServerId = findChain({ id: 1 })?.serverId || 'eth';89const ensClient = createPublicClient({10  chain: mainnet,11  transport: custom({12    request: ({ method, params }) =>13      requestETHRpc(14        {15          method,16          params: (params || []) as any[],17        },18        ethServerId,19      ),20  }),21});2223export const resolveEnsAddressByName = async (24  name: string,25): Promise<{ addr: string; name: string } | null> => {26  const input = name?.trim();27  if (!input) {28    return null;29  }3031  try {32    const normalizedName = normalize(input);33    const addr = await ensClient.getEnsAddress({34      name: normalizedName,35    });36    if (!addr) {37      return null;38    }39    return {

90export class ViemClient {...120  getEnsAddress = memoize(121    async ({ name }: { name: string }): Promise<Address | null> => {122      try {123        const result = await this.extApiCache.get(124          "ens-get-addr",125          name,126          () => {127            console.log(`[VIEM] getEnsAddress for '${name}'`);128            return this.l1Client.getEnsAddress({ name }).then((a) => a || "");129          },130          24 * 3600131        );132        return !result ? null : getAddress(result);