@1001-digital/layers.evm 1.0.4 → 1.0.6

package/app/composables/ens.ts

@@ -1,12 +1,50 @@
 import { getPublicClient } from '@wagmi/core'
 import type { Config } from '@wagmi/vue'
 
+type EnsMode = 'indexer' | 'chain'
+
 interface UseEnsOptions {
-  mode?: MaybeRefOrGetter<'indexer' | 'chain' | undefined>
+  mode?: MaybeRefOrGetter<EnsMode | undefined>
+}
+
+interface EnsRuntimeConfig {
+  ens?: { indexer1?: string, indexer2?: string, indexer3?: string }
+}
+
+function getIndexerUrls(config: EnsRuntimeConfig): string[] {
+  if (!config.ens) return []
+  return [config.ens.indexer1, config.ens.indexer2, config.ens.indexer3].filter(Boolean) as string[]
+}
+
+async function resolve(
+  identifier: string,
+  strategies: EnsMode[],
+  indexerUrls: string[],
+  wagmi: Config,
+  chainKeys: string[],
+): Promise<EnsProfile> {
+  for (const strategy of strategies) {
+    try {
+      if (strategy === 'indexer') {
+        if (!indexerUrls.length) continue
+        return await fetchEnsFromIndexer(identifier, indexerUrls)
+      }
+
+      if (strategy === 'chain') {
+        const client = getPublicClient(wagmi, { chainId: 1 })
+        if (!client) continue
+        return await fetchEnsFromChain(identifier, client, chainKeys)
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return { address: identifier, ens: null, data: null }
 }
 
 function useEnsBase(
-  key: string,
+  tier: string,
   identifier: MaybeRefOrGetter<string | undefined>,
   chainKeys: string[],
   options: UseEnsOptions = {},
@@ -15,53 +53,35 @@ function useEnsBase(
   const appConfig = useAppConfig()
   const runtimeConfig = useRuntimeConfig()
 
-  const mode = computed(() => toValue(options.mode) || appConfig.evm?.ens?.mode || 'indexer')
-
-  const indexerUrls = computed(() => {
-    const ens = (runtimeConfig.public.evm as { ens?: { indexer1?: string, indexer2?: string, indexer3?: string } }).ens
-    if (!ens) return []
-    return [ens.indexer1, ens.indexer2, ens.indexer3].filter(Boolean) as string[]
-  })
-
-  const strategies = computed(() => {
-    const primary = mode.value
-    const fallback = primary === 'indexer' ? 'chain' : 'indexer'
-    return [primary, fallback] as const
-  })
+  const mode = computed<EnsMode>(() => toValue(options.mode) || appConfig.evm?.ens?.mode || 'indexer')
+  const indexerUrls = computed(() => getIndexerUrls(runtimeConfig.public.evm as EnsRuntimeConfig))
+  const cacheKey = computed(() => `ens-${tier}-${toValue(identifier)}`)
 
   return useAsyncData(
-    `ens-${key}-${toValue(identifier)}`,
+    cacheKey.value,
     async () => {
       const id = toValue(identifier)
       if (!id) return null
 
-      for (const strategy of strategies.value) {
-        try {
-          if (strategy === 'indexer') {
-            if (!indexerUrls.value.length) continue
-            return await fetchEnsFromIndexer(id, indexerUrls.value)
-          }
-
-          if (strategy === 'chain') {
-            const client = getPublicClient($wagmi as Config, { chainId: 1 })
-            if (!client) continue
-            return await fetchEnsFromChain(id, client, chainKeys)
-          }
-        } catch {
-          continue
-        }
-      }
+      const strategies: EnsMode[] = mode.value === 'indexer'
+        ? ['indexer', 'chain']
+        : ['chain', 'indexer']
 
-      return null
+      return ensCache.fetch(cacheKey.value, () =>
+        resolve(id, strategies, indexerUrls.value, $wagmi as Config, chainKeys),
+      )
+    },
+    {
+      watch: [() => toValue(identifier)],
+      getCachedData: () => ensCache.get(cacheKey.value) ?? undefined,
     },
-    { watch: [() => toValue(identifier)] },
   )
 }
 
 export const useEns = (identifier: MaybeRefOrGetter<string | undefined>, options?: UseEnsOptions) =>
   useEnsBase('resolve', identifier, [], options)
 
-export const useEnsAvatar = (identifier: MaybeRefOrGetter<string | undefined>, options?: UseEnsOptions) =>
+export const useEnsWithAvatar = (identifier: MaybeRefOrGetter<string | undefined>, options?: UseEnsOptions) =>
   useEnsBase('avatar', identifier, [...ENS_KEYS_AVATAR], options)
 
 export const useEnsProfile = (identifier: MaybeRefOrGetter<string | undefined>, options?: UseEnsOptions) =>

package/app/utils/cache.ts

@@ -0,0 +1,59 @@
+interface CacheEntry<T> {
+  data: T
+  expiresAt: number
+}
+
+export function createCache<T>(ttl: number, max: number) {
+  const entries = new Map<string, CacheEntry<T>>()
+  const pending = new Map<string, Promise<T>>()
+
+  function prune() {
+    const now = Date.now()
+    for (const [key, entry] of entries) {
+      if (entry.expiresAt <= now) entries.delete(key)
+    }
+
+    if (entries.size > max) {
+      const excess = entries.size - max
+      const keys = entries.keys()
+      for (let i = 0; i < excess; i++) {
+        entries.delete(keys.next().value!)
+      }
+    }
+  }
+
+  function get(key: string): T | undefined {
+    const entry = entries.get(key)
+    if (!entry) return undefined
+    if (entry.expiresAt <= Date.now()) {
+      entries.delete(key)
+      return undefined
+    }
+    return entry.data
+  }
+
+  function fetch(key: string, fn: () => Promise<T>): Promise<T> {
+    const cached = get(key)
+    if (cached) return Promise.resolve(cached)
+
+    const inflight = pending.get(key)
+    if (inflight) return inflight
+
+    const promise = fn()
+      .then((result) => {
+        entries.set(key, { data: result, expiresAt: Date.now() + ttl })
+        pending.delete(key)
+        if (entries.size > max) prune()
+        return result
+      })
+      .catch((err) => {
+        pending.delete(key)
+        throw err
+      })
+
+    pending.set(key, promise)
+    return promise
+  }
+
+  return { get, fetch }
+}

package/app/utils/ens.ts

@@ -1,5 +1,7 @@
-import type { PublicClient, Address } from 'viem'
-import { isAddress, normalize } from 'viem/ens'
+import { isAddress, type PublicClient, type Address } from 'viem'
+import { normalize } from 'viem/ens'
+
+// --- Types ---
 
 export interface EnsProfile {
   address: string
@@ -17,26 +19,18 @@ export interface EnsProfile {
   } | null
 }
 
-const TEXT_RECORD_KEYS = ['avatar', 'header', 'description', 'url', 'email', 'com.twitter', 'com.github'] as const
+// --- Text record keys ---
 
-function buildData(keys: string[], results: string[]): EnsProfile['data'] {
-  const get = (key: string) => {
-    const i = keys.indexOf(key)
-    return i >= 0 ? results[i] || '' : ''
-  }
+const ALL_KEYS = ['avatar', 'header', 'description', 'url', 'email', 'com.twitter', 'com.github'] as const
 
-  return {
-    avatar: get('avatar'),
-    header: get('header'),
-    description: get('description'),
-    links: {
-      url: get('url'),
-      email: get('email'),
-      twitter: get('com.twitter'),
-      github: get('com.github'),
-    },
-  }
-}
+export const ENS_KEYS_AVATAR = ['avatar'] as const
+export const ENS_KEYS_PROFILE = [...ALL_KEYS]
+
+// --- Cache ---
+
+export const ensCache = createCache<EnsProfile>(5 * 60 * 1000, 500)
+
+// --- Fetchers ---
 
 export async function fetchEnsFromIndexer(
   identifier: string,
@@ -79,11 +73,26 @@ export async function fetchEnsFromChain(
 
   const name = normalize(ens)
   const results = await Promise.all(
-    keys.map(key => client.getEnsText({ name, key }).catch(() => '')),
+    keys.map(key => client.getEnsText({ name, key }).catch(() => null)),
   )
 
-  return { address, ens, data: buildData(keys, results) }
+  return { address, ens, data: toProfileData(keys, results.map(r => r || '')) }
 }
 
-export const ENS_KEYS_AVATAR = ['avatar'] as const
-export const ENS_KEYS_PROFILE = [...TEXT_RECORD_KEYS]
+// --- Helpers ---
+
+function toProfileData(keys: string[], results: string[]): EnsProfile['data'] {
+  const get = (key: string) => results[keys.indexOf(key)] || ''
+
+  return {
+    avatar: get('avatar'),
+    header: get('header'),
+    description: get('description'),
+    links: {
+      url: get('url'),
+      email: get('email'),
+      twitter: get('com.twitter'),
+      github: get('com.github'),
+    },
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@1001-digital/layers.evm",
   "type": "module",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "main": "./nuxt.config.ts",
   "devDependencies": {
     "@nuxt/eslint": "latest",