@lukso/transaction-decoder 1.0.1-dev.0f1bea5

package/src/shared/addressResolver.ts

@@ -0,0 +1,651 @@
+import request, { gql } from 'graphql-request'
+import type { Address, Chain, Hex } from 'viem'
+import { lukso } from 'viem/chains'
+import type { DataKey, EnhancedInfo } from '../types'
+import type { AddressIdentityCache } from './cache'
+
+/**
+ * GraphQL queries for address resolution
+ * Using the exact schema from addressGQL.ts
+ */
+const addressesGql = gql`
+query AddressQuery($profiles: [String!], $assets: [String!], $tokens: [String!]) {
+  Profile(
+    where: {id: {_in: $profiles}}
+  ) {
+    fullName
+    id
+    name
+    tags
+    description
+    standard
+    controllers {
+      address
+      tags
+      permissions
+    }
+    owner {
+      id
+    }
+    profileImages(where: {error: {_is_null: true}}, order_by: {width: asc}) {
+      width
+      height
+      src
+      verified
+    }
+    backgroundImages(where: {error: {_is_null: true}}, order_by: {width: asc}) {
+      width
+      height
+      src
+      verified
+    }
+    avatars(where: {error: {_is_null: true}}, order_by: {width: asc}) {
+      width
+      height
+      src
+      verified
+    }
+  }
+  Token(where: {id: {_in: $tokens}}) {
+    id
+    baseAsset {
+      id
+      description
+      icons {
+        src
+        verified
+        width
+        height
+      }
+      isCollection
+      isLSP7
+      isUnknown
+      name
+      standard
+      interfaces
+      decimals
+      owner_id
+      lsp4Creators {
+        profile_id
+      }
+    }
+    formattedTokenId
+    icons {
+      src
+      verified
+      width
+      height
+    }
+    images(where: {index: {_eq: 0}}) {
+      src
+      verified
+      width
+      height
+    }
+    lsp4TokenName
+    lsp4TokenSymbol
+    lsp4TokenType
+    lsp8TokenIdFormat
+    tokenId
+    name
+    description
+    lsp4Creators {
+      profile_id
+    }
+  }
+  Asset(where: {id: {_in: $assets}}) {
+    id
+    images(where: {index: {_eq: 0}}) {
+      src
+      width
+      verified
+      height
+    }
+    interfaces
+    isCollection
+    isLSP7
+    isUnknown
+    lsp4TokenName
+    lsp4TokenSymbol
+    lsp4TokenType
+    method
+    name
+    icons {
+      src
+      width
+      height
+    }
+    description
+    decimals
+    standard
+    owner_id
+    lsp4Creators {
+      profile_id
+    }
+  }
+}
+`
+
+// Image data structure from GraphQL
+export interface ImageData {
+  width?: number
+  height?: number
+  url?: string // Raw URL (may be ipfs://)
+  src?: string // Resolved HTTPS URL (fallback to url if not present)
+  verified?: boolean
+}
+
+// Link data structure from GraphQL
+export interface LinkData {
+  url: string
+  title?: string
+}
+
+// Profile data from GraphQL
+export interface ProfileData {
+  id: Hex
+  name?: string
+  fullName?: string
+  tags?: string[]
+  description?: string
+  links?: LinkData[]
+  standard?: string
+  controllers?: Array<{
+    address: string
+    tags?: string[]
+    permissions?: Hex
+  }>
+  owner?: { id: string }
+  profileImages?: ImageData[]
+  backgroundImages?: ImageData[]
+  avatars?: ImageData[]
+}
+
+// Asset data from GraphQL
+export interface AssetData {
+  id: Hex
+  name?: string
+  standard?: string
+  lsp4TokenName?: string
+  lsp4TokenSymbol?: string
+  lsp4TokenType?: string
+  method?: string
+  description?: string
+  links?: LinkData[]
+  decimals?: number
+  interfaces?: string[]
+  isCollection?: boolean
+  isLSP7?: boolean
+  isUnknown?: boolean
+  icons?: ImageData[]
+  images?: ImageData[]
+}
+
+// Token data from GraphQL
+export interface TokenData {
+  id: Hex
+  tokenId?: Hex
+  name?: string
+  description?: string
+  links?: LinkData[]
+  lsp4TokenName?: string
+  lsp4TokenSymbol?: string
+  lsp4TokenType?: string
+  lsp8TokenIdFormat?: string
+  formattedTokenId?: string
+  baseAsset?: {
+    id: Hex
+    description?: string
+    icons?: ImageData[]
+    isCollection?: boolean
+    isLSP7?: boolean
+    isUnknown?: boolean
+    name?: string
+    standard?: string
+    interfaces?: string[]
+    decimals?: number
+  }
+  icons?: ImageData[]
+  images?: ImageData[]
+}
+
+export type TFetchAddressData = {
+  Profile?: ProfileData[]
+  Asset?: AssetData[]
+  Token?: TokenData[]
+}
+
+/**
+ * Fetch multiple addresses from GraphQL and return them as a Map
+ * This is the shared implementation that both server and core can use
+ */
+export async function fetchMultipleAddresses(
+  addresses: readonly DataKey[],
+  graphqlEndpoint: string,
+  cache?: AddressIdentityCache
+): Promise<Map<DataKey, EnhancedInfo>> {
+  const results = new Map<DataKey, EnhancedInfo>()
+
+  if (addresses.length === 0) {
+    return results
+  }
+
+  // Check cache first if provided
+  const uncachedAddresses: DataKey[] = []
+
+  if (cache) {
+    // Try to get many at once if supported
+    if (cache.getMany) {
+      const cachedResults = await cache.getMany(addresses)
+      for (const [key, value] of cachedResults) {
+        results.set(key, value)
+      }
+      // Find which ones we still need to fetch
+      for (const addr of addresses) {
+        if (!results.has(addr)) {
+          uncachedAddresses.push(addr)
+        }
+      }
+    } else {
+      // Fall back to individual lookups
+      for (const addr of addresses) {
+        const cached = await cache.get(addr)
+        if (cached) {
+          results.set(addr, cached)
+        } else {
+          uncachedAddresses.push(addr)
+        }
+      }
+    }
+
+    // If all were cached, return early
+    if (uncachedAddresses.length === 0) {
+      return results
+    }
+  } else {
+    // No cache, fetch all
+    uncachedAddresses.push(...addresses)
+  }
+
+  // Parse addresses and tokens
+  const profiles: string[] = []
+  const assets: string[] = []
+  const tokens: string[] = []
+  const tokenMapping = new Map<string, { address: Address; tokenId: string }>()
+
+  for (const key of uncachedAddresses) {
+    const hasDash = key.includes('-')
+    const hasColon = key.includes(':')
+
+    if (hasColon || hasDash) {
+      const normalizedKey = key.replace(/[-:]/, '-')
+      tokens.push(normalizedKey)
+      const [address, tokenId] = key.split(/[-:]/)
+      tokenMapping.set(key, { address: address as Address, tokenId })
+    } else {
+      // Regular addresses - could be profiles or assets
+      profiles.push(key)
+      assets.push(key)
+    }
+  }
+
+  try {
+    // Fetch data from GraphQL
+    const data = (await request(graphqlEndpoint, addressesGql, {
+      profiles,
+      assets,
+      tokens,
+    })) as TFetchAddressData
+
+    // Process profiles
+    if (data.Profile) {
+      for (const profile of data.Profile) {
+        if (profile.standard !== 'LSP0ERC725Account') {
+          continue
+        }
+        const enhancedInfo: EnhancedInfo = {
+          address: profile.id as Address,
+          __gqltype: 'Profile',
+          name: profile.name || profile.fullName,
+          fullName: profile.fullName,
+          standard: profile.standard,
+          tags: profile.tags,
+          description: profile.description,
+          owner: profile.owner,
+          controllers: profile.controllers,
+          profileImages: profile.profileImages,
+          backgroundImages: profile.backgroundImages,
+          avatars: profile.avatars,
+        }
+        results.set(profile.id as Address, enhancedInfo)
+      }
+    }
+
+    // Process tokens (must be before assets per addressGQL.ts logic)
+    if (data.Token) {
+      for (const token of data.Token) {
+        const { id, baseAsset, tokenId, ...rest } = token
+
+        // Tokens have a composite ID format and baseAsset reference
+        if (baseAsset?.id && tokenId) {
+          const enhancedInfo: EnhancedInfo = {
+            address: baseAsset.id as Address,
+            tokenId: tokenId as Address,
+            __gqltype: 'Token',
+            ...rest,
+            baseAsset,
+          }
+          // Store with both dash and colon separators to handle both formats
+          const keyWithColon = `${baseAsset.id}:${tokenId}` as DataKey
+          const keyWithDash = `${baseAsset.id}-${tokenId}` as DataKey
+          results.set(keyWithColon, enhancedInfo)
+          results.set(keyWithDash, enhancedInfo)
+        }
+      }
+    }
+
+    // Process assets
+    if (data.Asset) {
+      for (const asset of data.Asset) {
+        if (asset.standard === 'LSP0ERC725Account') {
+          // Skip profiles - already processed
+          continue
+        }
+        const enhancedInfo: EnhancedInfo = {
+          address: asset.id as Address,
+          __gqltype: 'Asset',
+          ...asset,
+        }
+        if (!results.has(asset.id as Address)) {
+          results.set(asset.id as Address, enhancedInfo)
+        }
+      }
+    }
+
+    // Cache the newly fetched results
+    if (cache) {
+      const newEntries: Array<[DataKey, EnhancedInfo]> = []
+
+      // Collect all new entries
+      for (const [key, value] of results) {
+        // Only cache entries that were fetched (not from cache)
+        const isCached = addresses.some(
+          (addr) => addr.toLowerCase() === key.toLowerCase()
+        )
+
+        if (
+          isCached &&
+          uncachedAddresses.some(
+            (addr) => addr.toLowerCase() === key.toLowerCase()
+          )
+        ) {
+          newEntries.push([key, value])
+        }
+      }
+
+      // Use batch update if available
+      if (cache.setMany && newEntries.length > 0) {
+        await cache.setMany(newEntries)
+      } else {
+        // Fall back to individual updates
+        for (const [key, value] of newEntries) {
+          await cache.set(key, value)
+        }
+      }
+    }
+
+    return results
+  } catch (error) {
+    console.error('Failed to fetch addresses:', error)
+    return results
+  }
+}
+
+/**
+ * Get GraphQL endpoint for a given chain
+ */
+export function getGraphQLEndpoint(chain: Chain): string {
+  return chain.id === lukso.id
+    ? 'https://envio.lukso-mainnet.universal.tech/v1/graphql'
+    : 'https://envio.lukso-testnet.universal.tech/v1/graphql'
+}
+
+/**
+ * GraphQL query to find profiles controlled by specific addresses
+ */
+const profilesByControllerGql = gql`
+query ProfilesByController($controllerAddresses: [String!]) {
+  Profile(
+    where: {
+      controllers: {
+        address: { _in: $controllerAddresses }
+        tags: {
+          _contains: [
+            "ADDCONTROLLER"
+            "EDITPERMISSIONS"
+            "SUPER_TRANSFERVALUE"
+            "TRANSFERVALUE"
+            "SUPER_CALL"
+            "CALL"
+            "SUPER_STATICCALL"
+            "STATICCALL"
+            "DEPLOY"
+            "SUPER_SETDATA"
+            "SETDATA"
+            "ENCRYPT"
+            "DECRYPT"
+            "SIGN"
+            "EXECUTE_RELAY_CALL"
+          ]
+        }
+      }
+    }
+    order_by: { blockNumber: asc }
+  ) {
+    fullName
+    id
+    name
+    tags
+    description
+    standard
+    controllers {
+      address
+      tags
+      permissions
+    }
+    owner {
+      id
+    }
+    profileImages(where: {error: {_is_null: true}}, order_by: {width: asc}) {
+      width
+      height
+      src
+      verified
+    }
+    backgroundImages(where: {error: {_is_null: true}}, order_by: {width: asc}) {
+      width
+      height
+      src
+      verified
+    }
+    avatars(where: {error: {_is_null: true}}, order_by: {width: asc}) {
+      width
+      height
+      src
+      verified
+    }
+  }
+}
+`
+
+/**
+ * Find profiles controlled by specific controller addresses
+ * @param controllerAddresses - Array of controller addresses to search for
+ * @param chain - Which chain to query
+ * @returns Array of profile data
+ */
+export async function fetchProfilesByControllers(
+  controllerAddresses: readonly Address[],
+  chain: Chain
+): Promise<ProfileData[]> {
+  const graphqlEndpoint = getGraphQLEndpoint(chain)
+
+  try {
+    const data = (await request(graphqlEndpoint, profilesByControllerGql, {
+      controllerAddresses: controllerAddresses.map((addr) =>
+        addr.toLowerCase()
+      ),
+    })) as { Profile?: ProfileData[] }
+
+    return data.Profile || []
+  } catch (error) {
+    console.error(
+      `Failed to fetch profiles by controllers on ${chain.name}:`,
+      error
+    )
+    return []
+  }
+}
+
+export type ImageURL = {
+  url?: string
+  data?: string
+  src?: string
+  width: number
+  height: number
+  index?: number
+  verified?: string
+}
+
+/**
+ * Assuming the images are sorted ascending by width and/or height pick the first
+ * image that's larger than the requested size * dpr and process that one.
+ * By default this will assume the data came from the indexer and therefore
+ * we do not need to verify the existence of all the images (i.e. HEAD requests for
+ * each image) Setting ignoreHead to false is important during RPC mode so that
+ * we can skip images that are not really available.
+ *
+ * @param images - array of images
+ * @param options - specify arguments for search/processing
+ * @returns { width, height, src } - the image that fits the criteria
+ */
+export async function getImage(
+  images: ImageURL[],
+  options: {
+    width: number
+    height?: number
+    index?: number
+    ignoreVerification?: boolean
+    forcePng?: boolean
+    ignoreHead?: boolean
+    fallback?: string
+    dpr?: number
+  }
+): Promise<{ width: number; height: number; src?: string } | undefined> {
+  const {
+    width,
+    height: _height,
+    index,
+    ignoreVerification,
+    ignoreHead = true, // By default we don't want to do HEAD requests for all images.
+    dpr = 1,
+  } = options
+  const boost = dpr === 1 ? 1.5 : 1
+  const height = _height || width
+  const { src: _src, verified } =
+    (images || []).find(
+      (i) =>
+        i.width >= width * boost * dpr &&
+        i.height &&
+        i.height >= height * boost * dpr &&
+        (index ? i.index === index : i.index === undefined)
+    ) ||
+    images?.at(-1) ||
+    {}
+  // We're talking about images here, so we should be using /image/ instead of /ipfs/
+  const url = _src?.startsWith('https://api.universalprofile.cloud/ipfs/')
+    ? _src?.replace(/\/ipfs\//, '/image/')
+    : _src
+  if (!url) {
+    return options.fallback
+      ? { src: options.fallback, width: 128, height: 128 }
+      : undefined
+  }
+  try {
+    let isImage: string | undefined = undefined
+    if (typeof caches !== 'undefined' && !ignoreHead) {
+      const cache = await caches.open('image-types')
+      const cached = await cache.match(url)
+      if (cached) {
+        const response = await cached.json()
+        if (response) {
+          isImage = response
+        }
+      }
+    }
+    if (!isImage && !ignoreHead) {
+      // HEAD will return 200, 404 and so including the 'content-type'
+      // We use this to determine what type of images we have.
+      // If the images came from the indexer then this test
+      // has already been done on the indexer and we can skip it here.
+      const now = Date.now()
+      isImage = await fetch(url, { method: 'HEAD' })
+        .then((response) => {
+          if (response.ok) {
+            const mime = response.headers.get('content-type') || ''
+            response.body?.cancel()
+            return /^image\//.test(mime) ? mime : undefined
+          }
+          response.body?.cancel()
+          return undefined
+        })
+        .catch((error) => {
+          console.error((error as Error).stack)
+          return undefined
+        })
+      if (isImage != null && typeof caches !== 'undefined') {
+        const cache = await caches.open('image-types')
+        await cache
+          .put(url, new Response(JSON.stringify(isImage)))
+          .catch((error) => {
+            console.error((error as Error).stack, url)
+          })
+      }
+    }
+    if (isImage || ignoreHead) {
+      const finalUrl = new URL(url)
+      const { searchParams } = finalUrl
+      const qs = new URLSearchParams(searchParams)
+      if (width) {
+        qs.set('width', `${width * boost}`)
+      }
+      if (width || height) {
+        qs.set('height', `${(height || width) * boost}`)
+      }
+      qs.set('fit', 'cover')
+      qs.set('dpr', dpr.toString())
+      if (
+        !options.ignoreHead &&
+        !/\/svg/.test(isImage || '') &&
+        options.forcePng
+      ) {
+        qs.set('format', 'png')
+      }
+      finalUrl.search = qs.toString()
+      const image = finalUrl.toString()
+      return {
+        width,
+        height: height || width,
+        src:
+          verified === 'INVALID' && !ignoreVerification
+            ? `${image}&blur=30`
+            : image,
+      }
+    }
+  } catch (error) {
+    console.error((error as Error).stack)
+  }
+  return options.fallback
+    ? { src: options.fallback, width: 128, height: 128 }
+    : undefined
+}