@explorins/pers-sdk-react-native 2.1.6 → 2.1.7

package/dist/index.js

@@ -38805,7 +38805,12 @@ class Web3ChainService {
 
 // type ContractAnalysis = ReturnType<ContractDomainService['analyzeContract']>;
 /**
- * TokenDomainService - Clean, focused token operations with smart caching
+ * TokenDomainService - Clean, focused token operations
+ *
+ * Caching strategy:
+ * - Balance/ownership: NO CACHING - always fetch fresh from blockchain
+ *   (event-based updates in consuming apps handle refresh)
+ * - Metadata: CACHED 24h - IPFS content is immutable
  */
 class TokenDomainService {
     constructor(web3Api, metadataService, contractService) {
@@ -38875,12 +38880,20 @@ class TokenDomainService {
                 }
                 return this.processTokenBatch(params, params.tokenIds, batchSize, 'ERC-1155');
             }
-            // ERC-721: Use cached token ownership to minimize enumeration calls
+            // ERC-721: Enumerate tokens directly (no caching)
             if (analysis.isERC721) {
                 if (analysis.hasEnumeration) {
-                    const { tokenIds, fromCache } = await this.getCachedTokenOwnership(params, abi);
+                    // Get current balance to know how many tokens to enumerate
+                    const currentBalance = await this.web3Api.getTokenBalance({
+                        ...params, abi, tokenId: null
+                    });
+                    if (currentBalance === 0) {
+                        return this.emptyCollection(params, 'No tokens owned');
+                    }
+                    const maxTokens = Math.min(params.maxTokens || currentBalance, currentBalance, 100);
+                    const tokenIds = await this.getTokenIdsByEnumeration(params, abi, maxTokens);
                     if (tokenIds.length === 0) {
-                        return this.emptyCollection(params, fromCache ? 'No tokens owned (cached)' : 'No tokens owned');
+                        return this.emptyCollection(params, 'No tokens owned');
                     }
                     return this.processTokenBatch(params, tokenIds, batchSize, 'ERC-721');
                 }
@@ -38900,44 +38913,13 @@ class TokenDomainService {
         }
     }
     /**
-     * Get cached token ownership for ERC-721 with separate longer TTL
+     * Enumerate token IDs owned by account (no caching - fresh data each call)
      */
-    async getCachedTokenOwnership(params, abi) {
-        const ownershipCacheKey = `ownership:${params.contractAddress}:${params.accountAddress}:${params.chainId}`;
-        // ALWAYS check current balance first to detect changes
-        const currentBalance = await this.web3Api.getTokenBalance({
-            ...params, abi, tokenId: null
-        });
-        if (currentBalance === 0) {
-            // Clear any existing cache and return empty
-            this.cache.delete(ownershipCacheKey);
-            return { tokenIds: [], fromCache: false };
-        }
-        // Check ownership cache with balance validation
-        const cached = this.cache.get(ownershipCacheKey);
-        const cacheAge = cached ? Date.now() - cached.timestamp : Infinity;
-        if (cached && cacheAge < CacheTTL.SHORT && cached.balance === currentBalance) {
-            return { tokenIds: cached.tokenIds, fromCache: true };
-        }
-        // Enumerate tokens
-        const maxTokens = Math.min(params.maxTokens || currentBalance, currentBalance, 100);
-        const tokenIds = await this.getTokenIdsByEnumeration(params, abi, maxTokens);
-        // Cache with current balance for validation
-        this.cache.set(ownershipCacheKey, { tokenIds, balance: currentBalance, timestamp: Date.now() }, CacheTTL.SHORT);
-        return { tokenIds, fromCache: false };
-    }
     async getTokenIdsByEnumeration(params, abi, maxTokens) {
-        // Cache individual enumeration calls to avoid repeated tokenOfOwnerByIndex calls
-        const promises = Array.from({ length: maxTokens }, (_, i) => {
-            const enumerationCacheKey = `enumeration:${params.contractAddress}:${params.accountAddress}:${i}:${params.chainId}`;
-            return this.cache.getOrSet(enumerationCacheKey, () => this.web3Api.getTokenOfOwnerByIndex({
-                ...params, abi, tokenIndex: i
-            }).catch(error => {
-                // Silently handle token enumeration errors (index out of bounds is normal)
-                return null;
-            }), CacheTTL.SHORT // 5 minutes - enumeration results rarely change
-            );
-        });
+        const promises = Array.from({ length: maxTokens }, (_, i) => this.web3Api.getTokenOfOwnerByIndex({
+            ...params, abi, tokenIndex: i
+        }).catch(() => null) // Silently handle index out of bounds
+        );
         const results = await Promise.all(promises);
         return results.filter((id) => id !== null);
     }