@explorins/pers-sdk 1.2.2 → 1.2.4

package/dist/web3.js

@@ -1,333 +1,7 @@
-import { getSmartContractInstance, getAddressTokenBalanceByContract, getTokenUri, getTokenOfOwnerByIndex } from '@explorins/web3-ts';
 import { jwtDecode } from 'jwt-decode';
 import Web3 from 'web3';
 import { FetchRequest, JsonRpcProvider } from 'ethers';
-
-class Web3Api {
-    constructor(web3ChainService) {
-        this.web3ChainService = web3ChainService;
-    }
-    async getTokenBalance(request) {
-        const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
-        const tokenContract = getSmartContractInstance(request.contractAddress, request.abi, web3);
-        const balance = await getAddressTokenBalanceByContract(tokenContract, request.accountAddress, request.tokenId);
-        return Number(balance);
-    }
-    async getTokenUri(request) {
-        const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
-        // ✅ DIRECT: Use web3-ts functions directly
-        const tokenContract = getSmartContractInstance(request.contractAddress, request.abi, web3);
-        const tokenId = Number(request.tokenId);
-        const tokenUri = await getTokenUri(tokenContract, tokenId);
-        return String(tokenUri);
-    }
-    async getTokenOfOwnerByIndex(request) {
-        const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
-        // ✅ DIRECT: Use web3-ts functions directly
-        const tokenContract = getSmartContractInstance(request.contractAddress, request.abi, web3);
-        const tokenId = await getTokenOfOwnerByIndex(tokenContract, request.accountAddress, request.tokenIndex);
-        return String(tokenId);
-    }
-}
-
-class SimpleCache {
-    constructor() {
-        this.storage = {};
-        this.defaultTTL = 10 * 1000; // 10 seconds
-    }
-    set(key, data, ttl) {
-        this.storage[key] = {
-            data,
-            timestamp: Date.now(),
-            ttl: ttl ?? this.defaultTTL
-        };
-    }
-    get(key) {
-        const entry = this.storage[key];
-        if (!entry) {
-            return null;
-        }
-        const now = Date.now();
-        const isExpired = (now - entry.timestamp) > entry.ttl;
-        if (isExpired) {
-            delete this.storage[key];
-            return null;
-        }
-        return entry.data;
-    }
-    clear() {
-        this.storage = {};
-    }
-    cleanup() {
-        const now = Date.now();
-        Object.keys(this.storage).forEach(key => {
-            const entry = this.storage[key];
-            if ((now - entry.timestamp) > entry.ttl) {
-                delete this.storage[key];
-            }
-        });
-    }
-}
-
-class Web3Service {
-    constructor(web3Api, web3ChainService) {
-        this.web3Api = web3Api;
-        this.web3ChainService = web3ChainService;
-        //temporary fix, remove when the backend supports custom gateways
-        this.defaultIpfsGatewayDomain = 'pers.mypinata.cloud';
-        // ✅ CACHE: Simple 10-second cache instance
-        this.cache = new SimpleCache();
-        this.cleanupInterval = null;
-        this.cleanupInterval = setInterval(() => {
-            this.cache.cleanup();
-        }, 30 * 1000);
-    }
-    destroy() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-            this.cleanupInterval = null;
-        }
-        this.cache.clear();
-    }
-    async getERC20Balance(request) {
-        const cacheKey = `erc20_balance_${request.accountAddress}_${request.token.contractAddress}_${request.token.chainId}`;
-        // ✅ CACHE CHECK: Try to get from cache first
-        const cached = this.cache.get(cacheKey);
-        if (cached) {
-            console.debug(`💾 [Web3Service] Using cached ERC20 balance for ${request.token.symbol}`);
-            return cached;
-        }
-        console.debug(`🔄 [Web3Service] Fetching fresh ERC20 balance for ${request.token.symbol}`);
-        const rawBalance = await this.web3Api.getTokenBalance({
-            accountAddress: request.accountAddress,
-            contractAddress: request.token.contractAddress,
-            abi: request.token.abi,
-            tokenId: null, // Always null for ERC20
-            chainId: request.token.chainId
-        });
-        const decimals = request.token.decimals ?? 18;
-        const symbol = request.token.symbol ?? 'UNKNOWN';
-        const response = {
-            rawBalance,
-            formattedBalance: this.formatBalance(rawBalance, decimals),
-            decimals,
-            symbol,
-            hasBalance: rawBalance > 0
-        };
-        // ✅ CACHE SET: Store result in cache
-        this.cache.set(cacheKey, response);
-        return response;
-    }
-    async getERC1155Collection(request) {
-        // ✅ CACHE KEY: Create unique cache key for collection request
-        const contractAddresses = request.tokens.map(t => t.contractAddress).sort().join(',');
-        const cacheKey = `erc1155_collection_${request.accountAddress}_${contractAddresses}`;
-        // ✅ CACHE CHECK: Try to get from cache first
-        const cached = this.cache.get(cacheKey);
-        if (cached) {
-            console.debug(`💾 [Web3Service] Using cached ERC1155 collection for ${request.accountAddress}`);
-            return cached;
-        }
-        console.debug(`🔄 [Web3Service] Fetching fresh ERC1155 collection for ${request.accountAddress}`);
-        const tokenResults = await Promise.all(request.tokens.map(async (token) => {
-            // ✅ FIXED: Handle null metadata properly
-            const tokenIds = token.metadata?.map(m => m.tokenMetadataIncrementalId?.toString()).filter((id) => id !== undefined) ?? [];
-            // Check balance for each known tokenId
-            const balanceResults = await Promise.allSettled(tokenIds.map(async (tokenId) => {
-                try {
-                    const rawBalance = await this.web3Api.getTokenBalance({
-                        accountAddress: request.accountAddress,
-                        contractAddress: token.contractAddress,
-                        abi: token.abi,
-                        tokenId,
-                        chainId: token.chainId
-                    });
-                    const decimals = token.decimals ?? 0; // ERC1155 usually no decimals
-                    return {
-                        tokenId,
-                        balance: rawBalance,
-                        formattedBalance: this.formatBalance(rawBalance, decimals),
-                        hasBalance: rawBalance > 0,
-                        // ✅ FIXED: Convert null to undefined for findMetadata
-                        metadata: this.findMetadata(token.metadata ?? undefined, tokenId)
-                    };
-                }
-                catch (error) {
-                    console.warn(`Failed to get balance for token ${token.contractAddress}:${tokenId}`, error);
-                    return null; // Skip failed tokens
-                }
-            }));
-            // Filter successful results with balance > 0
-            const successfulResults = [];
-            for (const result of balanceResults) {
-                if (result.status === 'fulfilled' && result.value !== null && result.value.hasBalance) {
-                    successfulResults.push(result.value);
-                }
-            }
-            return {
-                token,
-                results: successfulResults
-            };
-        }));
-        const response = {
-            accountAddress: request.accountAddress,
-            tokens: tokenResults.filter(t => t.results.length > 0)
-        };
-        // ✅ CACHE SET: Store complete collection result
-        this.cache.set(cacheKey, response);
-        return response;
-    }
-    async getERC721Collection(request) {
-        // ✅ CACHE KEY: Create unique cache key for NFT collection
-        const contractAddresses = request.nftContracts.map(t => t.contractAddress).sort().join(',');
-        const maxNFTs = request.maxNFTsPerContract || 50;
-        const cacheKey = `erc721_collection_${request.accountAddress}_${contractAddresses}_${maxNFTs}`;
-        // ✅ CACHE CHECK: Try to get from cache first
-        const cached = this.cache.get(cacheKey);
-        if (cached) {
-            console.debug(`💾 [Web3Service] Using cached ERC721 collection for ${request.accountAddress}`);
-            return cached;
-        }
-        console.debug(`🔄 [Web3Service] Fetching fresh ERC721 collection for ${request.accountAddress}`);
-        const startTime = Date.now();
-        const contractResults = await Promise.all(request.nftContracts.map(async (token) => {
-            try {
-                const totalBalance = await this.web3Api.getTokenBalance({
-                    accountAddress: request.accountAddress,
-                    contractAddress: token.contractAddress,
-                    abi: token.abi,
-                    tokenId: null,
-                    chainId: token.chainId
-                });
-                if (totalBalance === 0) {
-                    return {
-                        token,
-                        totalNFTs: 0,
-                        nfts: [],
-                        hasMore: false
-                    };
-                }
-                const nftsToLoad = Math.min(totalBalance, maxNFTs);
-                const nftResults = await Promise.allSettled(Array.from({ length: nftsToLoad }, async (_, index) => {
-                    try {
-                        const tokenId = await this.web3Api.getTokenOfOwnerByIndex({
-                            contractAddress: token.contractAddress,
-                            abi: token.abi,
-                            accountAddress: request.accountAddress,
-                            tokenIndex: index,
-                            chainId: token.chainId
-                        });
-                        const tokenUri = await this.web3Api.getTokenUri({
-                            contractAddress: token.contractAddress,
-                            abi: token.abi,
-                            tokenId,
-                            chainId: token.chainId
-                        });
-                        const metadata = await this.fetchMetadata(tokenUri, token.chainId);
-                        const nftItem = {
-                            tokenId,
-                            name: metadata?.name || `Token #${tokenId}`,
-                            description: metadata?.description || '',
-                            imageUrl: await this.resolveIPFSUrl(metadata?.image || '', token.chainId),
-                            rawBalance: 1,
-                            formattedBalance: '1',
-                            hasBalance: true,
-                            metadata,
-                            tokenIndex: index
-                        };
-                        return nftItem;
-                    }
-                    catch (error) {
-                        console.warn(`Failed to load NFT at index ${index} for ${token.symbol}:`, error);
-                        return null;
-                    }
-                }));
-                // ✅ FIXED: Usar tipo específico NFTItem
-                const successfulNFTs = nftResults
-                    .filter((result) => result.status === 'fulfilled' && result.value !== null)
-                    .map(result => result.value);
-                return {
-                    token,
-                    totalNFTs: totalBalance,
-                    nfts: successfulNFTs,
-                    hasMore: totalBalance > maxNFTs
-                };
-            }
-            catch (error) {
-                console.error(`Failed to load NFT collection for ${token.symbol}:`, error);
-                return {
-                    token,
-                    totalNFTs: 0,
-                    nfts: [],
-                    hasMore: false
-                };
-            }
-        }));
-        const totalNFTs = contractResults.reduce((sum, contract) => sum + contract.nfts.length, 0);
-        const loadingTime = Date.now() - startTime;
-        const response = {
-            accountAddress: request.accountAddress,
-            contracts: contractResults,
-            summary: {
-                totalContracts: request.nftContracts.length,
-                totalNFTs,
-                loadingTime
-            }
-        };
-        // ✅ CACHE SET: Store complete collection response
-        this.cache.set(cacheKey, response);
-        return response;
-    }
-    // ==========================================
-    // HELPER METHODS
-    // ==========================================
-    formatBalance(rawBalance, decimals) {
-        const balance = rawBalance / Math.pow(10, decimals);
-        return balance.toLocaleString('en-US', {
-            minimumFractionDigits: 0,
-            maximumFractionDigits: decimals > 0 ? 2 : 0
-        });
-    }
-    // ✅ FIXED: Update method signature to handle null properly
-    findMetadata(metadata, tokenId) {
-        if (!metadata || tokenId === null)
-            return null;
-        return metadata.find(m => m.tokenMetadataIncrementalId?.toString() === tokenId) || null;
-    }
-    async fetchMetadata(uri, chainId) {
-        try {
-            const httpUrl = await this.resolveIPFSUrl(uri, chainId);
-            const response = await fetch(httpUrl);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            return await response.json();
-        }
-        catch (error) {
-            console.warn('Failed to fetch NFT metadata:', error);
-            return null;
-        }
-    }
-    async getIpfsGatewayDomain(chainId) {
-        try {
-            const chainData = await this.web3ChainService.getChainDataWithCache(chainId);
-            return chainData.ipfsGatewayDomain || this.defaultIpfsGatewayDomain;
-        }
-        catch (error) {
-            console.warn(`Failed to get chain data for chainId ${chainId}, using default IPFS gateway:`, error);
-            return this.defaultIpfsGatewayDomain;
-        }
-    }
-    async resolveIPFSUrl(url, chainId) {
-        if (!url)
-            return '';
-        if (url.startsWith('ipfs://')) {
-            const gatewayDomain = await this.getIpfsGatewayDomain(chainId);
-            return `https://${gatewayDomain}/ipfs/${url.slice(7)}`;
-        }
-        return url;
-    }
-}
+import { getSmartContractInstance, getAccountTokenBalance, getTokenUri, getTokenOfOwnerByIndex } from '@explorins/web3-ts';
 
 /**
  * Platform-Agnostic Web3 Chain API Client
@@ -861,21 +535,518 @@ function createWeb3ChainSDK(apiClient, providerService) {
     };
 }
 
-//import { PublicHttpProviderService } from '../web3-chain/services/public-http-provider.service';
+/**
+ * TokenDomainService - Domain service for token operations
+ * Implements business logic for token balance, metadata, and collection operations
+ */
+class TokenDomainService {
+    constructor(web3Api, metadataService, contractService) {
+        this.web3Api = web3Api;
+        this.metadataService = metadataService;
+        this.contractService = contractService;
+    }
+    async getTokenBalance(request) {
+        const balance = await this.web3Api.getTokenBalance({
+            accountAddress: request.accountAddress,
+            contractAddress: request.contractAddress,
+            abi: request.abi,
+            tokenId: request.tokenId,
+            chainId: request.chainId
+        });
+        return {
+            tokenId: request.tokenId,
+            balance,
+            hasBalance: balance > 0,
+            metadata: null
+        };
+    }
+    async getTokenWithMetadata(params) {
+        try {
+            const balance = await this.web3Api.getTokenBalance({
+                accountAddress: params.accountAddress,
+                contractAddress: params.contractAddress,
+                abi: params.abi,
+                tokenId: params.tokenId,
+                chainId: params.chainId
+            });
+            let metadata = null;
+            if (balance > 0) {
+                const tokenUri = await this.web3Api.getTokenUri({
+                    contractAddress: params.contractAddress,
+                    abi: params.abi,
+                    tokenId: params.tokenId,
+                    chainId: params.chainId
+                });
+                if (tokenUri) {
+                    metadata = await this.metadataService.fetchAndProcessMetadata(tokenUri, params.chainId);
+                }
+            }
+            return {
+                tokenId: params.tokenId,
+                balance,
+                hasBalance: balance > 0,
+                metadata
+            };
+        }
+        catch (error) {
+            console.error('Error getting token with metadata:', error);
+            return {
+                tokenId: params.tokenId,
+                balance: 0,
+                hasBalance: false,
+                metadata: null
+            };
+        }
+    }
+    async getTokenCollection(params) {
+        try {
+            const contractAnalysis = this.contractService.analyzeContract(params.abi);
+            const tokens = [];
+            if (!contractAnalysis.hasEnumeration && !contractAnalysis.isERC1155) {
+                console.warn('Contract does not support enumeration, cannot retrieve full collection');
+                return {
+                    accountAddress: params.accountAddress,
+                    contractAddress: params.contractAddress,
+                    totalBalance: 0,
+                    tokensRetrieved: 0,
+                    tokens: [],
+                    note: 'Contract does not support enumeration'
+                };
+            }
+            else if (contractAnalysis.isERC1155) {
+                const tokenIdsToProcess = params.tokenIds || [];
+                if (tokenIdsToProcess.length > 0) {
+                    for (const tokenId of tokenIdsToProcess) {
+                        const tokenBalance = await this.getTokenWithMetadata({
+                            accountAddress: params.accountAddress,
+                            contractAddress: params.contractAddress,
+                            abi: params.abi,
+                            tokenId,
+                            chainId: params.chainId
+                        });
+                        tokens.push(tokenBalance);
+                    }
+                }
+                console.log('ERC-1155 User balances:', tokens);
+                // ERC-1155: Cannot enumerate without knowing token IDs
+                // Would need to use events or provide specific token IDs
+                console.warn('ERC-1155 collection retrieval requires specific token IDs or event analysis');
+                return {
+                    accountAddress: params.accountAddress,
+                    contractAddress: params.contractAddress,
+                    totalBalance: 0,
+                    tokensRetrieved: 0,
+                    tokens: tokens,
+                    note: 'ERC-1155 collection retrieval requires specific token IDs. Use getTokenWithMetadata() for individual tokens.'
+                };
+            }
+            // Handle different token standards
+            if (contractAnalysis.isERC721) {
+                // ERC-721: Get user's total balance and enumerate through tokens
+                const userBalance = await this.web3Api.getTokenBalance({
+                    accountAddress: params.accountAddress,
+                    contractAddress: params.contractAddress,
+                    abi: params.abi,
+                    tokenId: null, // null for ERC-721 total balance
+                    chainId: params.chainId
+                });
+                console.log(`ERC-721 User balance for ${params.accountAddress}:`, userBalance);
+                if (userBalance === 0) {
+                    return {
+                        accountAddress: params.accountAddress,
+                        contractAddress: params.contractAddress,
+                        totalBalance: 0,
+                        tokensRetrieved: 0,
+                        tokens: []
+                    };
+                }
+                // Enumerate through user's tokens
+                const maxTokens = params.maxTokens || userBalance;
+                const tokensToRetrieve = Math.min(maxTokens, userBalance);
+                for (let i = 0; i < tokensToRetrieve; i++) {
+                    try {
+                        const tokenId = await this.web3Api.getTokenOfOwnerByIndex({
+                            contractAddress: params.contractAddress,
+                            abi: params.abi,
+                            accountAddress: params.accountAddress,
+                            tokenIndex: i,
+                            chainId: params.chainId
+                        });
+                        const tokenWithMetadata = await this.getTokenWithMetadata({
+                            accountAddress: params.accountAddress,
+                            contractAddress: params.contractAddress,
+                            abi: params.abi,
+                            tokenId,
+                            chainId: params.chainId
+                        });
+                        if (tokenWithMetadata.hasBalance) {
+                            tokens.push(tokenWithMetadata);
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Error retrieving ERC-721 token at index ${i}:`, error);
+                        continue;
+                    }
+                }
+            }
+            else {
+                // Unknown standard
+                return {
+                    accountAddress: params.accountAddress,
+                    contractAddress: params.contractAddress,
+                    totalBalance: 0,
+                    tokensRetrieved: 0,
+                    tokens: [],
+                    note: 'Unsupported token standard for collection retrieval'
+                };
+            }
+            // Calculate total balance based on retrieved tokens
+            let totalBalance = 0;
+            if (contractAnalysis.isERC721) {
+                // For ERC-721, total balance is the number of unique tokens owned
+                totalBalance = tokens.length;
+            }
+            else {
+                // For other standards, sum up individual token balances
+                totalBalance = tokens.reduce((sum, token) => sum + token.balance, 0);
+            }
+            return {
+                accountAddress: params.accountAddress,
+                contractAddress: params.contractAddress,
+                totalBalance,
+                tokensRetrieved: tokens.length,
+                tokens
+            };
+        }
+        catch (error) {
+            console.error('Error getting token collection:', error);
+            return {
+                accountAddress: params.accountAddress,
+                contractAddress: params.contractAddress,
+                totalBalance: 0,
+                tokensRetrieved: 0,
+                tokens: [],
+                note: 'Error retrieving collection'
+            };
+        }
+    }
+    async getTokenMetadata(params) {
+        try {
+            const tokenUri = await this.web3Api.getTokenUri({
+                contractAddress: params.contractAddress,
+                abi: params.abi,
+                tokenId: params.tokenId,
+                chainId: params.chainId
+            });
+            let metadata = null;
+            if (tokenUri) {
+                metadata = await this.metadataService.fetchAndProcessMetadata(tokenUri, params.chainId);
+            }
+            return {
+                tokenId: params.tokenId,
+                tokenUri,
+                metadata
+            };
+        }
+        catch (error) {
+            console.error('Error getting token metadata:', error);
+            return {
+                tokenId: params.tokenId,
+                tokenUri: null,
+                metadata: null
+            };
+        }
+    }
+}
+
+/**
+ * MetadataDomainService - Clean IPFS metadata resolution
+ */
+class MetadataDomainService {
+    constructor(ipfsApi) {
+        this.ipfsApi = ipfsApi;
+    }
+    async fetchAndProcessMetadata(tokenUri, chainId) {
+        return this.ipfsApi.fetchAndProcessMetadata(tokenUri, chainId);
+    }
+    async resolveIPFSUrl(url, chainId) {
+        return this.ipfsApi.resolveIPFSUrl(url, chainId);
+    }
+}
+
+/**
+ * ContractDomainService - Clean contract analysis without external dependencies
+ */
+class ContractDomainService {
+    constructor() { }
+    analyzeContract(abi) {
+        const methods = abi.filter(item => item.type === 'function').map(item => item.name);
+        // ERC-721 detection
+        const hasOwnerOf = methods.includes('ownerOf');
+        const hasTokenURI = methods.includes('tokenURI');
+        const hasTransferFrom = methods.includes('transferFrom');
+        const isERC721 = hasOwnerOf && hasTokenURI && hasTransferFrom;
+        // ERC-1155 detection
+        const hasBalanceOfBatch = methods.includes('balanceOfBatch');
+        const hasSafeBatchTransferFrom = methods.includes('safeBatchTransferFrom');
+        const hasURI = methods.includes('uri');
+        const isERC1155 = hasBalanceOfBatch && hasSafeBatchTransferFrom && hasURI;
+        return {
+            hasEnumeration: methods.includes('tokenByIndex') && methods.includes('totalSupply'),
+            hasOwnerOf,
+            hasBalanceOf: methods.includes('balanceOf'),
+            hasTokenURI,
+            hasTransfer: methods.includes('transfer') || methods.includes('transferFrom'),
+            hasApprove: methods.includes('approve'),
+            isERC721,
+            isERC1155
+        };
+    }
+    supportsEnumeration(abi) {
+        return this.analyzeContract(abi).hasEnumeration;
+    }
+    supportsMethod(abi, methodName) {
+        const methods = abi.filter(item => item.type === 'function').map(item => item.name);
+        return methods.includes(methodName);
+    }
+}
+
+/**
+ * Web3ApplicationService - Application layer entrance point
+ * Orchestrates domain services and provides clean public interface
+ * Simplified architecture with concrete classes
+ */
+class Web3ApplicationService {
+    constructor(web3Api, ipfsApi) {
+        // Type-safe metadata conversion methods for ERC-721/ERC-1155 standards
+        this.metadataMapper = {
+            fromERCStandard: (ercMetadata) => ({
+                name: ercMetadata.name || '',
+                description: ercMetadata.description || '',
+                imageUrl: ercMetadata.image || '',
+                externalUrl: ercMetadata.external_url,
+                animationUrl: ercMetadata.animation_url,
+                animationUrlConverted: undefined, // Will be set by IPFS conversion
+                attributes: ercMetadata.attributes || [],
+                ...ercMetadata
+            }),
+            toERCStandard: (metadata) => ({
+                name: metadata.name,
+                description: metadata.description,
+                image: metadata.imageUrl,
+                animation_url: metadata.animationUrl,
+                external_url: metadata.externalUrl,
+                attributes: metadata.attributes,
+                ...Object.fromEntries(Object.entries(metadata).filter(([key]) => !['name', 'description', 'imageUrl', 'animationUrl', 'externalUrl', 'attributes', 'animationUrlConverted'].includes(key)))
+            })
+        };
+        // Create domain services with injected infrastructure dependencies
+        this.contractDomainService = new ContractDomainService();
+        this.metadataDomainService = new MetadataDomainService(ipfsApi);
+        this.tokenDomainService = new TokenDomainService(web3Api, this.metadataDomainService, this.contractDomainService);
+    }
+    /**
+     * Get balance and metadata for a specific token
+     */
+    async getSpecificTokenBalance(request) {
+        if (!request.tokenId) {
+            return this.tokenDomainService.getTokenBalance({
+                accountAddress: request.accountAddress || '',
+                contractAddress: request.contractAddress,
+                abi: request.abi,
+                tokenId: '',
+                chainId: request.chainId
+            });
+        }
+        return this.tokenDomainService.getTokenWithMetadata({
+            accountAddress: request.accountAddress || '',
+            contractAddress: request.contractAddress,
+            abi: request.abi,
+            tokenId: request.tokenId || '',
+            chainId: request.chainId
+        });
+    }
+    /**
+     * Get metadata for a specific token from on-chain
+     */
+    async getTokenMetadata(request) {
+        const domainResult = await this.tokenDomainService.getTokenMetadata({
+            contractAddress: request.contractAddress,
+            abi: request.abi,
+            tokenId: request.tokenId || '',
+            chainId: request.chainId
+        });
+        return domainResult.metadata;
+    }
+    /**
+     * Retrieve entire collection of tokens with balance and metadata
+     */
+    async getTokenCollection(request) {
+        return this.tokenDomainService.getTokenCollection({
+            accountAddress: request.accountAddress || '',
+            contractAddress: request.contractAddress,
+            abi: request.abi,
+            chainId: request.chainId,
+            maxTokens: request.maxTokens,
+            tokenIds: request.tokenIds
+        });
+    }
+    /**
+     * Resolve IPFS URLs to HTTPS if needed
+     */
+    async resolveIPFSUrl(url, chainId) {
+        return this.metadataDomainService.resolveIPFSUrl(url, chainId);
+    }
+    /**
+     * Fetch and process metadata from URI with IPFS conversion
+     */
+    async fetchAndProcessMetadata(tokenUri, chainId) {
+        const domainMetadata = await this.metadataDomainService.fetchAndProcessMetadata(tokenUri, chainId);
+        if (!domainMetadata)
+            return null;
+        // Convert from ERC token standard to our clean interface
+        const cleanMetadata = this.metadataMapper.fromERCStandard(domainMetadata);
+        // Add IPFS conversion if needed
+        if (cleanMetadata.animationUrl?.startsWith('ipfs://')) {
+            return {
+                ...cleanMetadata,
+                animationUrlConverted: await this.resolveIPFSUrl(cleanMetadata.animationUrl, chainId)
+            };
+        }
+        return cleanMetadata;
+    }
+}
+
+/**
+ * Web3InfrastructureApi - Infrastructure implementation for blockchain operations
+ * Uses @explorins/web3-ts for Web3 interactions
+ */
+class Web3InfrastructureApi {
+    constructor(web3ChainService) {
+        this.web3ChainService = web3ChainService;
+    }
+    async getTokenBalance(request) {
+        try {
+            if (request.tokenId !== null)
+                request.tokenId = request.tokenId.toString();
+            const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
+            const contract = getSmartContractInstance(request.contractAddress, request.abi, web3);
+            return await getAccountTokenBalance(contract, request.accountAddress, request.tokenId);
+        }
+        catch (error) {
+            console.error(`Failed to get token balance for ${request.accountAddress} for ${request.contractAddress} and tokenId ${request.tokenId}, return 0 instead:`, error);
+            return 0;
+        }
+    }
+    async getTokenUri(request) {
+        try {
+            const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
+            const contract = getSmartContractInstance(request.contractAddress, request.abi, web3);
+            const tokenId = Number(request.tokenId);
+            const tokenUri = await getTokenUri(contract, tokenId);
+            return String(tokenUri);
+        }
+        catch (error) {
+            console.error(`Failed to get token URI for tokenId ${request.tokenId}:`, error);
+            throw error;
+        }
+    }
+    async getTokenOfOwnerByIndex(request) {
+        try {
+            const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
+            const tokenContract = getSmartContractInstance(request.contractAddress, request.abi, web3);
+            const tokenId = await getTokenOfOwnerByIndex(tokenContract, request.accountAddress, request.tokenIndex);
+            return String(tokenId);
+        }
+        catch (error) {
+            console.error(`Failed to get token by index ${request.tokenIndex} for ${request.accountAddress}:`, error);
+            throw error;
+        }
+    }
+}
+
+/**
+ * IPFSInfrastructureApi - Infrastructure implementation for IPFS operations
+ * Uses Web3ChainService for IPFS gateway resolution
+ */
+class IPFSInfrastructureApi {
+    constructor(web3ChainService) {
+        this.web3ChainService = web3ChainService;
+        this.defaultIpfsGatewayDomain = 'pers.mypinata.cloud';
+    }
+    async getIpfsGatewayDomain(chainId) {
+        try {
+            const chainData = await this.web3ChainService.getChainDataWithCache(chainId);
+            return chainData.ipfsGatewayDomain || this.defaultIpfsGatewayDomain;
+        }
+        catch (error) {
+            console.warn(`Failed to get chain data for chainId ${chainId}, using default IPFS gateway:`, error);
+            return this.defaultIpfsGatewayDomain;
+        }
+    }
+    async resolveIPFSUrl(url, chainId) {
+        if (url.startsWith('ipfs://')) {
+            const gateway = await this.getIpfsGatewayDomain(chainId);
+            return url.replace('ipfs://', `https://${gateway}/ipfs/`);
+        }
+        return url;
+    }
+    async fetchAndProcessMetadata(tokenUri, chainId) {
+        try {
+            const resolvedUri = await this.resolveIPFSUrl(tokenUri, chainId);
+            const response = await fetch(resolvedUri);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const metadata = await response.json();
+            // Process and return clean metadata
+            return {
+                name: metadata.name || '',
+                description: metadata.description || '',
+                image: metadata.image ? await this.resolveIPFSUrl(metadata.image, chainId) : '',
+                attributes: metadata.attributes || [],
+                animation_url: metadata.animation_url ? await this.resolveIPFSUrl(metadata.animation_url, chainId) : undefined,
+                external_url: metadata.external_url || undefined
+            };
+        }
+        catch (error) {
+            console.error('Error fetching metadata:', error);
+            return null;
+        }
+    }
+    async fetchFromUrl(url) {
+        try {
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch from ${url}: ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            console.error(`Error fetching from URL ${url}:`, error);
+            throw error;
+        }
+    }
+}
+
 function createWeb3SDK(apiClient) {
     // TODO: FIX LATER - TEMPORARY CONSTRUCTION
     const web3ProviderService = new Web3ProviderService();
     const web3ChainSDK = createWeb3ChainSDK(apiClient, web3ProviderService);
-    const web3Api = new Web3Api(web3ChainSDK.service);
-    const web3Service = new Web3Service(web3Api, web3ChainSDK.service);
+    // Create Web3ApplicationService - main entry point for all Web3 operations
+    const web3InfrastructureApi = new Web3InfrastructureApi(web3ChainSDK.service);
+    const ipfsInfrastructureApi = new IPFSInfrastructureApi(web3ChainSDK.service);
+    const web3ApplicationService = new Web3ApplicationService(web3InfrastructureApi, ipfsInfrastructureApi);
+    // Clean SDK - all functions route through Web3ApplicationService
     return {
-        getCreditsBalance: (request) => web3Service.getERC20Balance(request),
-        getRewardsCollection: (request) => web3Service.getERC1155Collection(request),
-        getStampsCollection: (request) => web3Service.getERC721Collection(request),
-        api: web3Api,
-        service: web3Service
+        getTokenBalance: (request) => web3ApplicationService.getSpecificTokenBalance(request),
+        getTokenMetadata: (request) => web3ApplicationService.getTokenMetadata(request),
+        getTokenCollection: (request) => web3ApplicationService.getTokenCollection(request),
+        resolveIPFSUrl: (url, chainId) => web3ApplicationService.resolveIPFSUrl(url, chainId),
+        fetchAndProcessMetadata: (tokenUri, chainId) => web3ApplicationService.fetchAndProcessMetadata(tokenUri, chainId),
+        applicationService: web3ApplicationService
     };
 }
 
-export { SimpleCache, createWeb3SDK };
+export { IPFSInfrastructureApi, Web3ApplicationService, Web3InfrastructureApi, createWeb3SDK };
 //# sourceMappingURL=web3.js.map