@explorins/pers-sdk 2.1.39 → 2.1.42

package/dist/chunks/{web3-manager-C-JflQ86.cjs → web3-manager-NJaeBrci.cjs}

@@ -76,7 +76,10 @@ class TokenDomainService {
         try {
             const abi = ethers.convertAbiToInterface(params.abi);
             const analysis = this.contractService.analyzeContract(abi);
-            const batchSize = Math.min(params.batchSize || 10, 20); // Cap at 20 for safety
+            // ERC-1155 balanceOfBatch can handle large batches efficiently (1 RPC call)
+            // Default to 100 for ERC-1155, 20 for ERC-721 (which has no batch function)
+            const defaultBatchSize = analysis.isERC1155 ? 100 : 20;
+            const batchSize = Math.min(params.batchSize || defaultBatchSize, analysis.isERC1155 ? 200 : 50);
             // ERC-1155: Requires specific token IDs
             if (analysis.isERC1155) {
                 if (!params.tokenIds?.length) {
@@ -130,31 +133,44 @@ class TokenDomainService {
     async processTokenBatch(params, tokenIds, batchSize, tokenStandard) {
         const tokens = [];
         const errors = [];
+        const abi = ethers.convertAbiToInterface(params.abi);
         // Process in batches
         for (let i = 0; i < tokenIds.length; i += batchSize) {
             const batch = tokenIds.slice(i, i + batchSize);
-            // Step 1: Check balance for each token (handle ERC-721 vs ERC-1155 differences)
-            const balancePromises = batch.map(tokenId => {
-                if (tokenStandard === 'ERC-721') {
-                    // For ERC-721: Skip balance check, we know ownership from enumeration or explicit tokenIds
-                    return Promise.resolve({
-                        tokenId,
-                        balance: 1,
-                        hasBalance: true,
-                        metadata: null
-                    });
-                }
-                else {
-                    // For ERC-1155: Check actual balance
-                    return this.getTokenBalance({ ...params, tokenId })
-                        .catch(error => {
-                        errors.push(`${tokenId}: ${error.message}`);
-                        return null;
-                    });
-                }
-            });
-            const balanceResults = await Promise.all(balancePromises);
-            const validTokens = balanceResults.filter((token) => token !== null && token.hasBalance);
+            let validTokens;
+            if (tokenStandard === 'ERC-721') {
+                // For ERC-721: Skip balance check, we know ownership from enumeration or explicit tokenIds
+                validTokens = batch.map(tokenId => ({
+                    tokenId,
+                    balance: 1,
+                    hasBalance: true,
+                    metadata: null
+                }));
+            }
+            else {
+                // For ERC-1155: Use native balanceOfBatch (1 RPC call for entire batch)
+                const batchResults = await this.web3Api.getBatchTokenBalances({
+                    accountAddress: params.accountAddress,
+                    contractAddress: params.contractAddress,
+                    abi,
+                    tokenIds: batch,
+                    chainId: params.chainId,
+                    isERC1155: true
+                });
+                // Convert batch results to TokenBalance format
+                validTokens = batchResults
+                    .filter(r => r.success && r.balance > 0n)
+                    .map(r => ({
+                    tokenId: r.tokenId,
+                    balance: Number(r.balance),
+                    hasBalance: true,
+                    metadata: null
+                }));
+                // Track errors
+                batchResults.filter(r => !r.success).forEach(r => {
+                    errors.push(`${r.tokenId}: ${r.error}`);
+                });
+            }
             // Step 2: Get metadata for tokens that have balance
             if (validTokens.length > 0) {
                 const metadataPromises = validTokens.map(token => this.getTokenMetadata({
@@ -278,6 +294,627 @@ class ContractDomainService {
     }
 }
 
+/**
+ * TokenCollectionManager - Auto-refresh token collections on wallet events
+ *
+ * This manager provides:
+ * 1. Cached token collection storage with automatic refresh
+ * 2. Auto-subscription to wallet events (transfers, mints, burns)
+ * 3. Targeted invalidation based on contract address
+ * 4. Subscriber pattern for reactive updates
+ *
+ * @example
+ * ```typescript
+ * // Get from SDK
+ * const manager = sdk.tokens.collectionManager;
+ *
+ * // Subscribe to collection updates
+ * const unsubscribe = manager.subscribe((collection, contractAddress) => {
+ *   console.log(`Collection updated for ${contractAddress}`);
+ *   updateUI(collection);
+ * });
+ *
+ * // Fetch collection (auto-cached, auto-refreshed on wallet events)
+ * const collection = await manager.getCollection({
+ *   accountAddress: '0x...',
+ *   contractAddress: '0x...',
+ *   abi: contractAbi,
+ *   chainId: 39123,
+ *   tokenIds: ['1', '2', '3']
+ * });
+ *
+ * // Cleanup
+ * unsubscribe();
+ * ```
+ */
+/**
+ * Manages token collections with automatic refresh on wallet events
+ */
+class TokenCollectionManager {
+    constructor(tokenService, eventEmitter, config) {
+        this.tokenService = tokenService;
+        this.eventEmitter = eventEmitter;
+        this.collections = new Map();
+        this.handlers = new Set();
+        this.pendingRefresh = new Map();
+        this.config = {
+            autoRefreshOnWalletEvents: config?.autoRefreshOnWalletEvents ?? true,
+            eventDebounceMs: config?.eventDebounceMs ?? 500,
+            debug: config?.debug ?? false
+        };
+        if (this.config.autoRefreshOnWalletEvents && eventEmitter) {
+            this.setupEventSubscription();
+        }
+    }
+    /**
+     * Subscribe to wallet events for auto-refresh
+     */
+    setupEventSubscription() {
+        if (!this.eventEmitter) {
+            return;
+        }
+        this.eventUnsubscribe = this.eventEmitter.subscribe((event) => {
+            const contractAddress = event.details?.contractAddress;
+            this.handleWalletEvent(contractAddress, event.type);
+        }, { domains: ['wallet'] });
+    }
+    /**
+     * Get a token collection (cached, auto-refreshed on wallet events)
+     *
+     * @param params - Collection parameters
+     * @returns Promise resolving to the token collection
+     */
+    async getCollection(params) {
+        const key = this.getCacheKey(params);
+        const cached = this.collections.get(key);
+        // Return cached if available and not stale
+        if (cached?.lastCollection) {
+            this.log(`Cache HIT for ${key}`);
+            return cached.lastCollection;
+        }
+        this.log(`Cache MISS for ${key}, fetching...`);
+        return this.fetchAndCache(params);
+    }
+    /**
+     * Force refresh a specific collection
+     *
+     * @param contractAddress - Contract address to refresh
+     * @param accountAddress - Account address to refresh
+     * @returns Promise that resolves when refresh is complete
+     */
+    async refreshCollection(contractAddress, accountAddress) {
+        const toRefresh = [];
+        for (const [key, entry] of this.collections) {
+            if (entry.params.contractAddress === contractAddress) {
+                if (!accountAddress || entry.params.accountAddress === accountAddress) {
+                    toRefresh.push(key);
+                }
+            }
+        }
+        await Promise.all(toRefresh.map(key => {
+            const entry = this.collections.get(key);
+            if (entry) {
+                return this.refreshEntry(key, entry, 'refresh');
+            }
+        }));
+    }
+    /**
+     * Subscribe to collection change events
+     *
+     * @param handler - Callback when any tracked collection changes
+     * @returns Unsubscribe function
+     */
+    subscribe(handler) {
+        this.handlers.add(handler);
+        return () => this.handlers.delete(handler);
+    }
+    /**
+     * Get all currently tracked collections
+     */
+    getTrackedCollections() {
+        return Array.from(this.collections.entries()).map(([_, entry]) => ({
+            contractAddress: entry.params.contractAddress,
+            accountAddress: entry.params.accountAddress,
+            collection: entry.lastCollection
+        }));
+    }
+    /**
+     * Check if a collection is currently being tracked
+     */
+    isTracking(contractAddress, accountAddress) {
+        const key = `${contractAddress}:${accountAddress}`;
+        return this.collections.has(key);
+    }
+    /**
+     * Clear tracking for a specific collection
+     */
+    untrack(contractAddress, accountAddress) {
+        if (accountAddress) {
+            const key = `${contractAddress}:${accountAddress}`;
+            this.collections.delete(key);
+            this.log(`Untracked ${key}`);
+        }
+        else {
+            // Untrack all for this contract
+            for (const key of this.collections.keys()) {
+                if (key.startsWith(`${contractAddress}:`)) {
+                    this.collections.delete(key);
+                }
+            }
+            this.log(`Untracked all collections for ${contractAddress}`);
+        }
+    }
+    /**
+     * Clear all tracked collections
+     */
+    clearAll() {
+        this.collections.clear();
+        this.log('Cleared all tracked collections');
+    }
+    /**
+     * Handle wallet events (with debouncing)
+     */
+    handleWalletEvent(contractAddress, eventType) {
+        // Determine which collections to refresh
+        const keysToRefresh = [];
+        for (const [key, entry] of this.collections) {
+            // If no specific contract, refresh all; otherwise match contract
+            if (!contractAddress || entry.params.contractAddress.toLowerCase() === contractAddress.toLowerCase()) {
+                keysToRefresh.push(key);
+            }
+        }
+        if (keysToRefresh.length === 0) {
+            this.log(`No tracked collections affected by event for ${contractAddress || 'all contracts'}`);
+            return;
+        }
+        // Debounce refresh per key
+        for (const key of keysToRefresh) {
+            const existing = this.pendingRefresh.get(key);
+            if (existing) {
+                clearTimeout(existing);
+            }
+            const timeout = setTimeout(async () => {
+                this.pendingRefresh.delete(key);
+                const entry = this.collections.get(key);
+                if (entry) {
+                    this.log(`Refreshing ${key} due to wallet event: ${eventType}`);
+                    await this.refreshEntry(key, entry, eventType);
+                }
+            }, this.config.eventDebounceMs);
+            this.pendingRefresh.set(key, timeout);
+        }
+    }
+    /**
+     * Fetch and cache a collection
+     */
+    async fetchAndCache(params) {
+        const key = this.getCacheKey(params);
+        // Mark as refreshing to prevent duplicate fetches
+        const existing = this.collections.get(key);
+        if (existing?.refreshing) {
+            // Wait for existing refresh to complete
+            return existing.lastCollection || this.emptyCollection(params);
+        }
+        this.collections.set(key, {
+            params,
+            lastCollection: null,
+            timestamp: Date.now(),
+            refreshing: true
+        });
+        try {
+            const collection = await this.tokenService.getTokenCollection(params);
+            this.collections.set(key, {
+                params,
+                lastCollection: collection,
+                timestamp: Date.now(),
+                refreshing: false
+            });
+            this.log(`Cached collection for ${key}: ${collection.tokensRetrieved} tokens`);
+            return collection;
+        }
+        catch (error) {
+            // Remove failed entry
+            this.collections.delete(key);
+            throw error;
+        }
+    }
+    /**
+     * Refresh a cached entry and notify handlers
+     */
+    async refreshEntry(key, entry, source) {
+        if (entry.refreshing) {
+            this.log(`Skipping refresh for ${key} - already refreshing`);
+            return;
+        }
+        entry.refreshing = true;
+        try {
+            const newCollection = await this.tokenService.getTokenCollection(entry.params);
+            entry.lastCollection = newCollection;
+            entry.timestamp = Date.now();
+            entry.refreshing = false;
+            this.log(`Refreshed ${key}: ${newCollection.tokensRetrieved} tokens`);
+            // Notify subscribers
+            for (const handler of this.handlers) {
+                try {
+                    handler(newCollection, entry.params.contractAddress, {
+                        type: source === 'refresh' ? 'refresh' : 'wallet_event',
+                        source
+                    });
+                }
+                catch (handlerError) {
+                    console.error('[TokenCollectionManager] Handler error:', handlerError);
+                }
+            }
+        }
+        catch (error) {
+            entry.refreshing = false;
+            console.error(`[TokenCollectionManager] Refresh failed for ${key}:`, error);
+        }
+    }
+    /**
+     * Generate cache key from params
+     */
+    getCacheKey(params) {
+        return `${params.contractAddress}:${params.accountAddress}`;
+    }
+    /**
+     * Create empty collection placeholder
+     */
+    emptyCollection(params) {
+        return {
+            accountAddress: params.accountAddress,
+            contractAddress: params.contractAddress,
+            totalBalance: 0,
+            tokensRetrieved: 0,
+            tokens: [],
+            note: 'Loading...'
+        };
+    }
+    /**
+     * Debug logging
+     */
+    log(message, data) {
+        if (this.config.debug) {
+            console.log(`[TokenCollectionManager] ${message}`, data || '');
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        // Clear pending refreshes
+        for (const timeout of this.pendingRefresh.values()) {
+            clearTimeout(timeout);
+        }
+        this.pendingRefresh.clear();
+        // Unsubscribe from events
+        this.eventUnsubscribe?.();
+        // Clear handlers and collections
+        this.handlers.clear();
+        this.collections.clear();
+        this.log('Destroyed');
+    }
+}
+
+/**
+ * BalanceManager - Auto-refresh ERC-20 token balances on wallet events
+ *
+ * This manager provides:
+ * 1. Cached balance storage with automatic refresh
+ * 2. Auto-subscription to wallet events (transfers)
+ * 3. Targeted invalidation based on contract address
+ * 4. Subscriber pattern for reactive updates
+ *
+ * @example
+ * ```typescript
+ * // Get from SDK
+ * const manager = sdk.tokens.balanceManager;
+ *
+ * // Subscribe to balance updates
+ * const unsubscribe = manager.subscribe((balance, contractAddress) => {
+ *   console.log(`Balance updated for ${contractAddress}: ${balance}`);
+ *   updateUI(balance);
+ * });
+ *
+ * // Fetch balance (auto-cached, auto-refreshed on wallet events)
+ * const balance = await manager.getBalance({
+ *   accountAddress: '0x...',
+ *   contractAddress: '0x...',
+ *   abi: contractAbi,
+ *   chainId: 39123
+ * });
+ *
+ * // Manual refresh
+ * await manager.refreshBalance(contractAddress);
+ *
+ * // Cleanup
+ * unsubscribe();
+ * ```
+ */
+/**
+ * Manages ERC-20 token balances with automatic refresh on wallet events
+ */
+class BalanceManager {
+    constructor(tokenService, eventEmitter, config) {
+        this.tokenService = tokenService;
+        this.eventEmitter = eventEmitter;
+        this.balances = new Map();
+        this.handlers = new Set();
+        this.pendingRefresh = new Map();
+        this.config = {
+            autoRefreshOnWalletEvents: config?.autoRefreshOnWalletEvents ?? true,
+            eventDebounceMs: config?.eventDebounceMs ?? 500,
+            debug: config?.debug ?? false
+        };
+        if (this.config.autoRefreshOnWalletEvents && eventEmitter) {
+            this.setupEventSubscription();
+        }
+    }
+    /**
+     * Subscribe to wallet events for auto-refresh
+     */
+    setupEventSubscription() {
+        if (!this.eventEmitter) {
+            return;
+        }
+        this.eventUnsubscribe = this.eventEmitter.subscribe((event) => {
+            const contractAddress = event.details?.contractAddress;
+            this.handleWalletEvent(contractAddress, event.type);
+        }, { domains: ['wallet'] });
+    }
+    /**
+     * Get a token balance (cached, auto-refreshed on wallet events)
+     *
+     * @param params - Balance parameters
+     * @returns Promise resolving to the token balance
+     */
+    async getBalance(params) {
+        const key = this.getCacheKey(params);
+        const cached = this.balances.get(key);
+        // Return cached if available and not stale
+        if (cached?.lastBalance) {
+            this.log(`Cache HIT for ${key}`);
+            return cached.lastBalance;
+        }
+        this.log(`Cache MISS for ${key}, fetching...`);
+        return this.fetchAndCache(params);
+    }
+    /**
+     * Force refresh a specific balance
+     *
+     * @param contractAddress - Contract address to refresh
+     * @param accountAddress - Account address to refresh (optional, refreshes all if not provided)
+     * @returns Promise that resolves when refresh is complete
+     */
+    async refreshBalance(contractAddress, accountAddress) {
+        const toRefresh = [];
+        for (const [key, entry] of this.balances) {
+            if (entry.params.contractAddress.toLowerCase() === contractAddress.toLowerCase()) {
+                if (!accountAddress || entry.params.accountAddress.toLowerCase() === accountAddress.toLowerCase()) {
+                    toRefresh.push(key);
+                }
+            }
+        }
+        await Promise.all(toRefresh.map(key => {
+            const entry = this.balances.get(key);
+            if (entry) {
+                return this.refreshEntry(key, entry, 'refresh');
+            }
+        }));
+    }
+    /**
+     * Force refresh all tracked balances
+     *
+     * @returns Promise that resolves when all refreshes are complete
+     */
+    async refreshAll() {
+        const refreshPromises = Array.from(this.balances.entries()).map(([key, entry]) => this.refreshEntry(key, entry, 'refresh'));
+        await Promise.all(refreshPromises);
+    }
+    /**
+     * Subscribe to balance change events
+     *
+     * @param handler - Callback when any tracked balance changes
+     * @returns Unsubscribe function
+     */
+    subscribe(handler) {
+        this.handlers.add(handler);
+        return () => this.handlers.delete(handler);
+    }
+    /**
+     * Get all currently tracked balances
+     */
+    getTrackedBalances() {
+        return Array.from(this.balances.entries()).map(([_, entry]) => ({
+            contractAddress: entry.params.contractAddress,
+            accountAddress: entry.params.accountAddress,
+            balance: entry.lastBalance
+        }));
+    }
+    /**
+     * Check if a balance is currently being tracked
+     */
+    isTracking(contractAddress, accountAddress) {
+        const key = `${contractAddress.toLowerCase()}:${accountAddress.toLowerCase()}`;
+        return this.balances.has(key);
+    }
+    /**
+     * Clear tracking for a specific balance
+     */
+    untrack(contractAddress, accountAddress) {
+        if (accountAddress) {
+            const key = `${contractAddress.toLowerCase()}:${accountAddress.toLowerCase()}`;
+            this.balances.delete(key);
+            this.log(`Untracked ${key}`);
+        }
+        else {
+            // Untrack all for this contract
+            const toDelete = [];
+            for (const key of this.balances.keys()) {
+                if (key.startsWith(`${contractAddress.toLowerCase()}:`)) {
+                    toDelete.push(key);
+                }
+            }
+            toDelete.forEach(key => this.balances.delete(key));
+            this.log(`Untracked all balances for ${contractAddress}`);
+        }
+    }
+    /**
+     * Clear all tracked balances
+     */
+    clearAll() {
+        this.balances.clear();
+        this.log('Cleared all tracked balances');
+    }
+    /**
+     * Handle wallet events (with debouncing)
+     */
+    handleWalletEvent(contractAddress, eventType) {
+        // Determine which balances to refresh
+        const keysToRefresh = [];
+        for (const [key, entry] of this.balances) {
+            // If no specific contract, refresh all; otherwise match contract
+            if (!contractAddress || entry.params.contractAddress.toLowerCase() === contractAddress.toLowerCase()) {
+                keysToRefresh.push(key);
+            }
+        }
+        if (keysToRefresh.length === 0) {
+            this.log(`No tracked balances affected by event for ${contractAddress || 'all contracts'}`);
+            return;
+        }
+        // Debounce refresh per key
+        for (const key of keysToRefresh) {
+            const existing = this.pendingRefresh.get(key);
+            if (existing) {
+                clearTimeout(existing);
+            }
+            const timeout = setTimeout(async () => {
+                this.pendingRefresh.delete(key);
+                const entry = this.balances.get(key);
+                if (entry) {
+                    this.log(`Refreshing ${key} due to wallet event: ${eventType}`);
+                    await this.refreshEntry(key, entry, eventType);
+                }
+            }, this.config.eventDebounceMs);
+            this.pendingRefresh.set(key, timeout);
+        }
+    }
+    /**
+     * Fetch and cache a balance
+     */
+    async fetchAndCache(params) {
+        const key = this.getCacheKey(params);
+        // Mark as refreshing to prevent duplicate fetches
+        const existing = this.balances.get(key);
+        if (existing?.refreshing) {
+            // Wait for existing refresh to complete
+            return existing.lastBalance || this.emptyBalance();
+        }
+        this.balances.set(key, {
+            params,
+            lastBalance: null,
+            timestamp: Date.now(),
+            refreshing: true
+        });
+        try {
+            const balance = await this.tokenService.getTokenBalance({
+                ...params,
+                tokenId: null // ERC-20 has no tokenId
+            });
+            this.balances.set(key, {
+                params,
+                lastBalance: balance,
+                timestamp: Date.now(),
+                refreshing: false
+            });
+            this.log(`Cached balance for ${key}: ${balance.balance}`);
+            return balance;
+        }
+        catch (error) {
+            // Remove failed entry
+            this.balances.delete(key);
+            throw error;
+        }
+    }
+    /**
+     * Refresh a cached entry and notify handlers
+     */
+    async refreshEntry(key, entry, source) {
+        if (entry.refreshing) {
+            this.log(`Skipping refresh for ${key} - already refreshing`);
+            return;
+        }
+        entry.refreshing = true;
+        try {
+            const newBalance = await this.tokenService.getTokenBalance({
+                ...entry.params,
+                tokenId: null // ERC-20 has no tokenId
+            });
+            entry.lastBalance = newBalance;
+            entry.timestamp = Date.now();
+            entry.refreshing = false;
+            this.log(`Refreshed ${key}: ${newBalance.balance}`);
+            // Notify subscribers
+            for (const handler of this.handlers) {
+                try {
+                    handler(newBalance, entry.params.contractAddress, {
+                        type: source === 'refresh' ? 'refresh' : 'wallet_event',
+                        source
+                    });
+                }
+                catch (handlerError) {
+                    console.error('[BalanceManager] Handler error:', handlerError);
+                }
+            }
+        }
+        catch (error) {
+            entry.refreshing = false;
+            console.error(`[BalanceManager] Refresh failed for ${key}:`, error);
+        }
+    }
+    /**
+     * Generate cache key from params
+     */
+    getCacheKey(params) {
+        return `${params.contractAddress.toLowerCase()}:${params.accountAddress.toLowerCase()}`;
+    }
+    /**
+     * Create empty balance placeholder
+     */
+    emptyBalance() {
+        return {
+            tokenId: null,
+            balance: 0,
+            hasBalance: false,
+            metadata: null
+        };
+    }
+    /**
+     * Debug logging
+     */
+    log(message, data) {
+        if (this.config.debug) {
+            console.log(`[BalanceManager] ${message}`, data || '');
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        // Clear pending refreshes
+        for (const timeout of this.pendingRefresh.values()) {
+            clearTimeout(timeout);
+        }
+        this.pendingRefresh.clear();
+        // Unsubscribe from events
+        this.eventUnsubscribe?.();
+        // Clear handlers and balances
+        this.handlers.clear();
+        this.balances.clear();
+        this.log('Destroyed');
+    }
+}
+
 /**
  * Web3ApplicationService - Application layer entrance point
  * Orchestrates domain services and provides clean public interface
@@ -386,6 +1023,30 @@ class Web3InfrastructureApi {
             return 0;
         }
     }
+    /**
+     * Get multiple ERC-1155 token balances in a single RPC call using native balanceOfBatch.
+     * Falls back to individual calls if balanceOfBatch fails.
+     *
+     * @param request - Batch balance request
+     * @returns Array of balance results per tokenId
+     */
+    async getBatchTokenBalances(request) {
+        try {
+            const ethersProvider = await this.web3ChainService.getEthersProviderByChainId(request.chainId);
+            const results = await ethers.getBatchBalancesWithFallback(ethersProvider, request.contractAddress, request.abi, request.accountAddress, request.tokenIds, request.isERC1155 ?? true);
+            return results;
+        }
+        catch (error) {
+            console.error(`Failed to get batch token balances:`, error);
+            // Return empty results on failure
+            return request.tokenIds.map(tokenId => ({
+                tokenId,
+                balance: 0n,
+                success: false,
+                error: `${error}`
+            }));
+        }
+    }
     async getTokenUri(request) {
         try {
             const ethersProvider = await this.web3ChainService.getEthersProviderByChainId(request.chainId);
@@ -623,17 +1284,11 @@ async function getExplorerUrlByChainId(getChainData, chainId, address, type) {
  * ```
  */
 class Web3Manager {
-    // TODO: Add PersEventEmitter support for blockchain events
-    // When ready, add:
-    // 1. constructor param: private events?: PersEventEmitter
-    // 2. Subscribe to contract events (Transfer, Approval, etc.)
-    // 3. Emit via: this.events?.emitSuccess({ domain: 'web3', type: 'NFT_TRANSFERRED', ... })
-    // 4. Filter to only user's address (not all transfers)
-    // 5. Add cleanup for event listeners on SDK destroy
-    constructor(apiClient, tenantManager$1) {
+    constructor(apiClient, tenantManager$1, eventEmitter) {
         this.apiClient = apiClient;
         // Use provided TenantManager or create one
         this.tenantManager = tenantManager$1 || new tenantManager.TenantManager(apiClient);
+        this.eventEmitter = eventEmitter;
         // Initialize Web3 Chain service
         const web3ChainApi = new web3ChainService.Web3ChainApi(apiClient);
         this.web3ChainService = new web3ChainService.Web3ChainService(web3ChainApi);
@@ -641,6 +1296,75 @@ class Web3Manager {
         const web3InfrastructureApi = new Web3InfrastructureApi(this.web3ChainService);
         const ipfsInfrastructureApi = new IPFSInfrastructureApi(this.tenantManager);
         this.web3ApplicationService = new Web3ApplicationService(web3InfrastructureApi, ipfsInfrastructureApi);
+        // Initialize domain services for managers
+        const contractDomainService = new ContractDomainService();
+        const metadataDomainService = new MetadataDomainService(ipfsInfrastructureApi);
+        this.tokenDomainService = new TokenDomainService(web3InfrastructureApi, metadataDomainService, contractDomainService);
+    }
+    /**
+     * Get the TokenCollectionManager for NFT collection operations.
+     *
+     * Features:
+     * - Auto-refresh on wallet events (transfers, mints, burns)
+     * - Cached collections
+     * - Subscriber pattern for reactive updates
+     *
+     * @example
+     * ```typescript
+     * const manager = sdk.web3.collectionManager;
+     *
+     * // Subscribe to updates
+     * const unsubscribe = manager.subscribe((collection, contractAddress) => {
+     *   console.log(`Collection updated for ${contractAddress}`);
+     * });
+     *
+     * // Fetch collection (auto-cached, auto-refreshed)
+     * const collection = await manager.getCollection({...});
+     *
+     * // Manual refresh
+     * await manager.refreshCollection(contractAddress);
+     * ```
+     */
+    get collectionManager() {
+        if (!this._collectionManager) {
+            this._collectionManager = new TokenCollectionManager(this.tokenDomainService, this.eventEmitter);
+        }
+        return this._collectionManager;
+    }
+    /**
+     * Get the BalanceManager for ERC-20 (credit token) balance operations.
+     *
+     * Features:
+     * - Auto-refresh on wallet events (transfers)
+     * - Cached balances
+     * - Subscriber pattern for reactive updates
+     *
+     * @example
+     * ```typescript
+     * const manager = sdk.web3.balanceManager;
+     *
+     * // Subscribe to balance updates
+     * const unsubscribe = manager.subscribe((balance, contractAddress) => {
+     *   console.log(`Balance updated: ${balance.balance}`);
+     * });
+     *
+     * // Fetch balance (auto-cached, auto-refreshed)
+     * const balance = await manager.getBalance({
+     *   accountAddress: '0x...',
+     *   contractAddress: '0x...',
+     *   abi: creditTokenAbi,
+     *   chainId: 39123
+     * });
+     *
+     * // Manual refresh
+     * await manager.refreshBalance(contractAddress);
+     * ```
+     */
+    get balanceManager() {
+        if (!this._balanceManager) {
+            this._balanceManager = new BalanceManager(this.tokenDomainService, this.eventEmitter);
+        }
+        return this._balanceManager;
     }
     /**
      * Get token balance for a specific token
@@ -839,12 +1563,26 @@ class Web3Manager {
             maxTokens
         };
     }
+    /**
+     * Cleanup resources.
+     *
+     * Call this when the SDK is being destroyed to clean up
+     * event subscriptions and cached data.
+     */
+    destroy() {
+        this._collectionManager?.destroy();
+        this._balanceManager?.destroy();
+        this._collectionManager = undefined;
+        this._balanceManager = undefined;
+    }
 }
 
+exports.BalanceManager = BalanceManager;
 exports.IPFSInfrastructureApi = IPFSInfrastructureApi;
+exports.TokenCollectionManager = TokenCollectionManager;
 exports.Web3ApplicationService = Web3ApplicationService;
 exports.Web3InfrastructureApi = Web3InfrastructureApi;
 exports.Web3Manager = Web3Manager;
 exports.getExplorerUrl = getExplorerUrl;
 exports.getExplorerUrlByChainId = getExplorerUrlByChainId;
-//# sourceMappingURL=web3-manager-C-JflQ86.cjs.map
+//# sourceMappingURL=web3-manager-NJaeBrci.cjs.map