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

package/src/core/addressCollector.ts

@@ -0,0 +1,153 @@
+import { type Address, type Hex, isHex, size } from 'viem'
+import type { ArrayArgs } from '../decoder/types'
+import { getArgByName } from '../decoder/utils'
+import type { DataKey } from '../types'
+
+export interface CollectedAddress {
+  key: DataKey
+  path: Array<string | number>
+  parent?: Record<string, unknown>
+  root: unknown
+}
+
+/**
+ * Collect all DataKeys from a data structure
+ * This is a simplified version that just returns the keys
+ * @param data - The data to analyze
+ * @param skipGqlTypes - Whether to skip GraphQL type fields
+ * @param existingKeys - Optional existing keys to merge with
+ */
+export function collectDataKeys(
+  data: unknown,
+  skipGqlTypes = true,
+  existingKeys?: DataKey[]
+): DataKey[] {
+  const addresses = new Set<string>()
+
+  // Add existing keys to the set first
+  if (existingKeys) {
+    for (const key of existingKeys) {
+      if (typeof key === 'string') {
+        addresses.add(key)
+      } else {
+        addresses.add(JSON.stringify(key))
+      }
+    }
+  }
+
+  // Check if this is an LSP8 decoded transaction and collect tokens
+  function collectLSP8Tokens(obj: Record<string, unknown>): void {
+    if (
+      obj.standard !== 'LSP8IdentifiableDigitalAsset' ||
+      !obj.to ||
+      !obj.args
+    ) {
+      return
+    }
+
+    const contractAddress = obj.to as string
+    const args = obj.args as ArrayArgs
+
+    // Check for single tokenId
+    const tokenId = getArgByName(args, 'tokenId') as string | undefined
+    if (tokenId && tokenId !== null && tokenId !== '0x') {
+      addresses.add(`${contractAddress}:${tokenId}`)
+    }
+
+    // Check for multiple tokenIds
+    const tokenIds = getArgByName(args, 'tokenIds') as string[] | undefined
+    if (Array.isArray(tokenIds)) {
+      for (const tokenId of tokenIds) {
+        // Skip null/undefined/empty tokens
+        if (tokenId && tokenId !== null && tokenId !== '0x') {
+          addresses.add(`${contractAddress}:${tokenId}`)
+        }
+      }
+    }
+  }
+
+  function collect(
+    obj: unknown,
+    parent?: Record<string, unknown>,
+    visited = new WeakSet(),
+    path: string[] = []
+  ): void {
+    // Circular reference detection
+    if (obj && typeof obj === 'object' && visited.has(obj)) {
+      return
+    }
+
+    if (obj && typeof obj === 'object') {
+      visited.add(obj)
+    }
+    // Handle string case first
+    if (typeof obj === 'string' && obj.startsWith('0x')) {
+      // Check if this is a composite address:tokenId format
+      if (obj.includes(':')) {
+        const [addressPart, tokenIdPart] = obj.split(':')
+        // Validate both parts are hex strings
+        if (
+          addressPart.startsWith('0x') &&
+          tokenIdPart.startsWith('0x') &&
+          isHex(addressPart) &&
+          size(addressPart as Hex) === 20
+        ) {
+          addresses.add(obj) // Just add the composite string directly
+          return
+        }
+      }
+
+      // Use regex to detect zero-padded addresses
+      const isPaddedAddress = /^0x0*([a-fA-F0-9]{40})$/.test(obj)
+
+      if (isPaddedAddress || (isHex(obj) && size(obj as Hex) === 20)) {
+        // Skip if parent has __gqltype
+        if (parent && skipGqlTypes && '__gqltype' in parent) {
+          return
+        }
+
+        // Extract the actual address (remove padding if needed)
+        const address = isPaddedAddress
+          ? (obj.replace(/^0x0*([a-fA-F0-9]{40})$/, '0x$1') as Address)
+          : obj
+
+        // Skip if too many zeros (likely not an address)
+        if (
+          address
+            .slice(2)
+            .split('')
+            .filter((c: string) => c === '0').length > 10
+        ) {
+          return
+        }
+
+        addresses.add(address)
+      }
+      return
+    }
+
+    if (!obj || typeof obj !== 'object') return
+
+    if (Array.isArray(obj)) {
+      for (let i = 0; i < obj.length; i++) {
+        collect(obj[i], parent, visited, [...path, `[${i}]`])
+      }
+    } else {
+      const record = obj as Record<string, unknown>
+
+      // Check if this is an LSP8 transaction at the root level
+      if ('standard' in record && 'to' in record && 'args' in record) {
+        collectLSP8Tokens(record)
+      }
+
+      for (const [key, value] of Object.entries(record)) {
+        collect(value, record, visited, [...path, key])
+      }
+    }
+  }
+
+  collect(data)
+
+  // Convert to DataKey array (all as strings)
+  return Array.from(addresses) as DataKey[]
+}

package/src/core/addressResolver.ts

@@ -0,0 +1,135 @@
+import type { Chain } from 'viem'
+import { fetchMultipleAddresses } from '../shared/addressResolver'
+import type { AddressIdentityCache } from '../shared/cache'
+import type { DataKey, EnhancedInfo, IDataModel } from '../types'
+
+/**
+ * Configuration for address resolver
+ */
+export interface AddressResolverConfig {
+  dataModel: IDataModel
+  graphqlEndpoint: string
+  chain: Chain
+  batchSize?: number
+  batchDelay?: number
+  cache?: AddressIdentityCache
+}
+
+/**
+ * Resolve addresses using GraphQL
+ * Replaces the old patchValue mechanism
+ */
+export class AddressResolver {
+  private dataModel: IDataModel
+  private graphqlEndpoint: string
+  private batchSize: number
+  private batchDelay: number
+  private pendingAddresses = new Set<string>()
+  private batchTimer?: NodeJS.Timeout
+  private cache?: AddressIdentityCache
+
+  constructor(config: AddressResolverConfig) {
+    this.dataModel = config.dataModel
+    this.graphqlEndpoint = config.graphqlEndpoint
+    this.batchSize = config.batchSize || 50
+    this.batchDelay = config.batchDelay || 100
+    this.cache = config.cache
+  }
+
+  /**
+   * Start watching for missing addresses
+   */
+  startWatching() {
+    // Check for missing addresses periodically
+    setInterval(() => {
+      const missing = this.dataModel.getMissingKeys()
+      if (missing.length > 0) {
+        this.queueAddresses(missing)
+      }
+    }, 1000)
+  }
+
+  /**
+   * Queue addresses for batch resolution
+   */
+  queueAddresses(addresses: DataKey[]) {
+    // Add to pending set
+    for (const addr of addresses) {
+      this.pendingAddresses.add(addr)
+    }
+
+    // Clear existing timer
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer)
+    }
+
+    // Set new timer
+    this.batchTimer = setTimeout(() => {
+      this.processBatch()
+    }, this.batchDelay)
+
+    // Process immediately if batch is full
+    if (this.pendingAddresses.size >= this.batchSize) {
+      clearTimeout(this.batchTimer)
+      this.processBatch()
+    }
+  }
+
+  /**
+   * Process a batch of addresses
+   */
+  private async processBatch() {
+    const batch = Array.from(this.pendingAddresses).slice(0, this.batchSize)
+    if (batch.length === 0) return
+
+    // Remove from pending
+    for (const key of batch) {
+      this.pendingAddresses.delete(key)
+    }
+
+    // Convert batch keys back to DataKey format
+    const dataKeys: DataKey[] = batch.map((key) => {
+      return key as DataKey
+    })
+
+    try {
+      // Fetch data using shared implementation with cache
+      const results = await fetchMultipleAddresses(
+        dataKeys,
+        this.graphqlEndpoint,
+        this.cache
+      )
+
+      // Convert to array for injection
+      const enhancedData: EnhancedInfo[] = Array.from(results.values())
+
+      // Inject data into model
+      if (enhancedData.length > 0) {
+        this.dataModel.injectData(enhancedData)
+      }
+    } catch (error) {
+      console.error('Failed to resolve addresses:', error)
+
+      // Mark addresses as having errors
+      for (const key of dataKeys) {
+        this.dataModel.setError(key, 'Failed to fetch address data')
+      }
+    }
+
+    // Continue processing if more pending
+    if (this.pendingAddresses.size > 0) {
+      this.batchTimer = setTimeout(() => {
+        this.processBatch()
+      }, this.batchDelay)
+    }
+  }
+
+  /**
+   * Stop watching for addresses
+   */
+  stopWatching() {
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer)
+    }
+  }
+}