@monygroupcorp/micro-web3 0.1.0

package/src/services/PriceService.js

@@ -0,0 +1,191 @@
+class PriceService {
+    constructor(blockchainService, eventBus, updateInterval = 60000) {
+        if (!blockchainService || !eventBus) {
+            throw new Error('PriceService requires blockchainService and eventBus instances.');
+        }
+        this._blockchainService = blockchainService;
+        this.eventBus = eventBus;
+
+        this._cache = new Map();
+        this._contractUpdateInterval = null;
+        this._updateIntervalTime = updateInterval;
+        this._cacheExpirationTime = 5 * 60 * 1000; // 5 minutes
+        
+        this._updateDebounceTimeout = null;
+        this._updateDebounceDelay = 2000; // 2 seconds
+        this._lastEmittedData = null;
+        
+        this.getCurrentPrice = this.getCurrentPrice.bind(this);
+        this.startContractUpdates = this.startContractUpdates.bind(this);
+        this.stopContractUpdates = this.stopContractUpdates.bind(this);
+        this.debouncedUpdateContractData = this.debouncedUpdateContractData.bind(this);
+    }
+
+    // Initialize with an address
+    initialize(address = null) {
+        console.log('PriceService: Fetching initial data immediately', address ? `for address: ${address}` : '(no address yet)');
+        this.updateContractData(address).catch(error => {
+            console.error('Failed to fetch initial contract data:', error);
+        });
+        
+        this.startContractUpdates(address);
+    }
+
+    async getCurrentPrice() {
+        try {
+            if (!this._blockchainService) {
+                throw new Error('PriceService not initialized');
+            }
+
+            const cachedPrice = this._getCacheValue('currentPrice');
+            if (cachedPrice !== null) {
+                return cachedPrice;
+            }
+
+            const price = await this._blockchainService.getTokenPrice();
+            
+            if (typeof price !== 'number' || isNaN(price) || price <= 0) {
+                console.error('Invalid price value:', price);
+                throw new Error('Invalid price value received');
+            }
+
+            this._setCacheValue('currentPrice', price);
+            this.eventBus.emit('price:updated', { price });
+            
+            return price;
+        } catch (error) {
+            console.error('Error fetching price:', error);
+            throw error;
+        }
+    }
+
+    async calculateCost(execAmount) {
+        try {
+            if (!this._blockchainService) {
+                throw new Error('PriceService not initialized');
+            }
+            return await this._blockchainService.calculateCost(execAmount);
+        } catch (error) {
+            console.error('Error calculating cost:', error);
+            throw error;
+        }
+    }
+
+    async updateContractData(address = null) {
+        try {
+            const dataPromises = [
+                this._blockchainService.getCurrentPrice(),
+                this._blockchainService.getTotalBondingSupply(),
+                this._blockchainService.getTotalMessages(),
+                this._blockchainService.getNFTSupply(),
+                this._blockchainService.getFreeSupply(),
+                this._blockchainService.getContractEthBalance(),
+                this._blockchainService.getCurrentTier(),
+                this._blockchainService.getLiquidityPool(),
+            ];
+
+            if (address) {
+                dataPromises.push(
+                    this._blockchainService.getEthBalance(address),
+                    this._blockchainService.getTokenBalance(address),
+                    this._blockchainService.getNFTBalance(address),
+                    this._blockchainService.getFreeMint(address)
+                );
+            }
+
+            const [
+                currentPrice,
+                totalBondingSupply,
+                totalMessages,
+                totalNFTs,
+                freeSupply,
+                contractEthBalance,
+                currentTier,
+                liquidityPool,
+                ethBalance,
+                tokenBalance,
+                nftBalance,
+                freeMint,
+            ] = await Promise.all(dataPromises);
+
+            const contractData = {
+                totalBondingSupply,
+                currentPrice,
+                totalMessages,
+                totalNFTs,
+                freeSupply,
+                freeMint: freeMint !== undefined ? freeMint : false,
+                contractEthBalance,
+                currentTier,
+                liquidityPool,
+            };
+
+            const balances = {
+                eth: ethBalance || '0',
+                exec: tokenBalance || '0',
+                nfts: nftBalance || 0,
+            };
+            
+            const contractDataChanged = !this._lastEmittedData || JSON.stringify(this._lastEmittedData.contractData) !== JSON.stringify(contractData);
+            const balancesChanged = !this._lastEmittedData || JSON.stringify(this._lastEmittedData.balances) !== JSON.stringify(balances);
+
+            if (contractDataChanged) {
+                this.eventBus.emit('contractData:updated', contractData);
+            }
+
+            if (balancesChanged) {
+                this.eventBus.emit('balances:updated', balances);
+            }
+
+            if (!this._lastEmittedData || this._lastEmittedData.contractData.currentPrice !== currentPrice) {
+                this.eventBus.emit('price:updated', { price: currentPrice });
+            }
+
+            this._lastEmittedData = { contractData, balances };
+
+        } catch (error) {
+            console.error('Error updating contract data:', error);
+            this.eventBus.emit('price:error', { error: error.message });
+        }
+    }
+
+    startContractUpdates() {
+        this.stopContractUpdates(); // Clear any existing interval
+
+        // Initial contract data fetch
+        this.debouncedUpdateContractData();
+        
+        // Set up interval for contract updates
+        this._contractUpdateInterval = setInterval(() => {
+            this.debouncedUpdateContractData();
+        }, this._updateIntervalTime);
+    }
+
+    stopContractUpdates() {
+        if (this._contractUpdateInterval) {
+            clearInterval(this._contractUpdateInterval);
+            this._contractUpdateInterval = null;
+        }
+    }
+
+    _setCacheValue(key, value) {
+        this._cache.set(key, {
+            value,
+            timestamp: Date.now()
+        });
+    }
+
+    debouncedUpdateContractData(address = null) {
+        if (this._updateDebounceTimeout) {
+            clearTimeout(this._updateDebounceTimeout);
+        }
+        
+        this._updateDebounceTimeout = setTimeout(() => {
+            this.updateContractData(address).catch(error => {
+                console.error('Failed to update contract data:', error);
+            });
+        }, this._updateDebounceDelay);
+    }
+}
+
+export default PriceService;