@sschepis/magazine 0.1.0

package/src/components/EventMetadata.js

@@ -0,0 +1,273 @@
+/**
+ * EventMetadata - Enriches events with additional blockchain metadata
+ */
+export default class EventMetadata {
+    constructor(networkManager, logger) {
+        this.networkManager = networkManager;
+        this.logger = logger.child({ context: 'EventMetadata' });
+        this.logger.info('EventMetadata initialized');
+    }
+
+    /**
+     * Enrich event with metadata
+     * @param {Object} event - Event to enrich
+     * @param {Object} options - Enrichment options
+     * @param {boolean} options.includeBlock - Include block data
+     * @param {boolean} options.includeTransaction - Include transaction data
+     * @param {boolean} options.includeTimestamp - Include block timestamp
+     * @param {boolean} options.includeGasCost - Include gas cost
+     * @returns {Promise<Object>} Enriched event
+     */
+    async enrichEvent(event, options = {}) {
+        const {
+            includeBlock = true,
+            includeTransaction = true,
+            includeTimestamp = true,
+            includeGasCost = true
+        } = options;
+
+        try {
+            const enrichedEvent = { ...event };
+            const promises = [];
+
+            // Fetch block data if needed
+            if ((includeBlock || includeTimestamp) && event.blockNumber) {
+                promises.push(
+                    this.networkManager.provider.getBlock(event.blockNumber)
+                        .then(block => {
+                            if (block) {
+                                if (includeBlock) {
+                                    enrichedEvent.block = {
+                                        number: block.number,
+                                        hash: block.hash,
+                                        parentHash: block.parentHash,
+                                        miner: block.miner,
+                                        difficulty: block.difficulty?.toString(),
+                                        gasLimit: block.gasLimit.toString(),
+                                        gasUsed: block.gasUsed.toString()
+                                    };
+                                }
+                                if (includeTimestamp) {
+                                    enrichedEvent.timestamp = block.timestamp;
+                                    enrichedEvent.date = new Date(block.timestamp * 1000).toISOString();
+                                }
+                            }
+                        })
+                        .catch(err => {
+                            this.logger.warn('Failed to fetch block data', {
+                                blockNumber: event.blockNumber,
+                                error: err.message
+                            });
+                        })
+                );
+            }
+
+            // Fetch transaction data if needed
+            if ((includeTransaction || includeGasCost) && event.transactionHash) {
+                promises.push(
+                    Promise.all([
+                        this.networkManager.provider.getTransaction(event.transactionHash),
+                        includeGasCost ? this.networkManager.provider.getTransactionReceipt(event.transactionHash) : null
+                    ]).then(([tx, receipt]) => {
+                        if (tx) {
+                            if (includeTransaction) {
+                                enrichedEvent.transaction = {
+                                    hash: tx.hash,
+                                    from: tx.from,
+                                    to: tx.to,
+                                    value: tx.value.toString(),
+                                    nonce: tx.nonce,
+                                    gasLimit: tx.gasLimit.toString(),
+                                    gasPrice: tx.gasPrice?.toString(),
+                                    maxFeePerGas: tx.maxFeePerGas?.toString(),
+                                    maxPriorityFeePerGas: tx.maxPriorityFeePerGas?.toString(),
+                                    data: tx.data.length > 66 ? tx.data.substring(0, 66) + '...' : tx.data
+                                };
+                            }
+                            if (includeGasCost && receipt) {
+                                const gasUsed = receipt.gasUsed;
+                                const gasPrice = tx.gasPrice || tx.maxFeePerGas || 0n;
+                                const gasCost = gasUsed * gasPrice;
+                                
+                                enrichedEvent.gas = {
+                                    used: gasUsed.toString(),
+                                    price: gasPrice.toString(),
+                                    cost: gasCost.toString(),
+                                    costInEther: this._formatEther(gasCost)
+                                };
+                            }
+                        }
+                    }).catch(err => {
+                        this.logger.warn('Failed to fetch transaction data', {
+                            transactionHash: event.transactionHash,
+                            error: err.message
+                        });
+                    })
+                );
+            }
+
+            // Wait for all enrichment operations
+            await Promise.all(promises);
+
+            // Add metadata about the enrichment
+            enrichedEvent._metadata = {
+                enrichedAt: new Date().toISOString(),
+                enrichmentOptions: options
+            };
+
+            this.logger.debug('Event enriched with metadata', {
+                eventName: event.eventName,
+                blockNumber: event.blockNumber,
+                metadataAdded: Object.keys(enrichedEvent).filter(k => !event.hasOwnProperty(k))
+            });
+
+            return enrichedEvent;
+
+        } catch (error) {
+            this.logger.error('Failed to enrich event', {
+                event,
+                error: error.message
+            });
+            // Return original event on error
+            return event;
+        }
+    }
+
+    /**
+     * Enrich multiple events in batch
+     * @param {Array} events - Events to enrich
+     * @param {Object} options - Enrichment options
+     * @param {number} options.batchSize - Number of events to process concurrently
+     * @returns {Promise<Array>} Enriched events
+     */
+    async enrichEvents(events, options = {}) {
+        const { batchSize = 10, ...enrichOptions } = options;
+        
+        return this.logger.time('enrichEvents', async () => {
+            const enrichedEvents = [];
+            
+            // Process in batches to avoid overwhelming the provider
+            let failureCount = 0;
+            for (let i = 0; i < events.length; i += batchSize) {
+                const batch = events.slice(i, i + batchSize);
+                const results = await Promise.allSettled(
+                    batch.map(event => this.enrichEvent(event, enrichOptions))
+                );
+                for (let j = 0; j < results.length; j++) {
+                    if (results[j].status === 'fulfilled') {
+                        enrichedEvents.push(results[j].value);
+                    } else {
+                        failureCount++;
+                        this.logger.warn('Failed to enrich event, using original', {
+                            error: results[j].reason?.message,
+                            blockNumber: batch[j]?.blockNumber
+                        });
+                        enrichedEvents.push(batch[j]);
+                    }
+                }
+
+                this.logger.debug('Enriched event batch', {
+                    batchIndex: Math.floor(i / batchSize),
+                    batchSize: batch.length,
+                    failures: failureCount,
+                    totalProgress: `${enrichedEvents.length}/${events.length}`
+                });
+            }
+            
+            this.logger.info('Completed event enrichment', {
+                totalEvents: events.length,
+                enrichedEvents: enrichedEvents.length,
+                failures: failureCount
+            });
+            
+            return enrichedEvents;
+        });
+    }
+
+    /**
+     * Calculate statistics for a set of events
+     * @param {Array} events - Events to analyze
+     * @returns {Object} Event statistics
+     */
+    calculateStatistics(events) {
+        if (!Array.isArray(events) || events.length === 0) {
+            return {
+                count: 0,
+                blockRange: { min: null, max: null },
+                timeRange: { min: null, max: null },
+                gasStats: { total: '0', average: '0', min: '0', max: '0' }
+            };
+        }
+
+        const blockNumbers = events
+            .map(e => e.blockNumber)
+            .filter(n => n != null)
+            .sort((a, b) => a - b);
+
+        const timestamps = events
+            .map(e => e.timestamp)
+            .filter(t => t != null)
+            .sort((a, b) => a - b);
+
+        const gasCosts = events
+            .map(e => e.gas?.cost)
+            .filter(c => c != null)
+            .map(c => BigInt(c));
+
+        const stats = {
+            count: events.length,
+            blockRange: {
+                min: blockNumbers[0] || null,
+                max: blockNumbers[blockNumbers.length - 1] || null,
+                span: blockNumbers.length > 0 ? blockNumbers[blockNumbers.length - 1] - blockNumbers[0] : 0
+            },
+            timeRange: {
+                min: timestamps[0] || null,
+                max: timestamps[timestamps.length - 1] || null,
+                span: timestamps.length > 0 ? timestamps[timestamps.length - 1] - timestamps[0] : 0
+            }
+        };
+
+        if (gasCosts.length > 0) {
+            const totalGas = gasCosts.reduce((sum, cost) => sum + cost, 0n);
+            const avgGas = totalGas / BigInt(gasCosts.length);
+            const sortedGas = [...gasCosts].sort((a, b) => a < b ? -1 : 1);
+
+            stats.gasStats = {
+                total: totalGas.toString(),
+                average: avgGas.toString(),
+                min: sortedGas[0].toString(),
+                max: sortedGas[sortedGas.length - 1].toString(),
+                totalInEther: this._formatEther(totalGas)
+            };
+        } else {
+            stats.gasStats = { total: '0', average: '0', min: '0', max: '0' };
+        }
+
+        // Event type distribution
+        const eventTypes = {};
+        events.forEach(e => {
+            if (e.eventName) {
+                eventTypes[e.eventName] = (eventTypes[e.eventName] || 0) + 1;
+            }
+        });
+        stats.eventTypes = eventTypes;
+
+        this.logger.debug('Calculated event statistics', stats);
+        return stats;
+    }
+
+    /**
+     * Format wei to ether string
+     * @private
+     */
+    _formatEther(wei) {
+        try {
+            const weiString = wei.toString();
+            const ethValue = Number(weiString) / 1e18;
+            return ethValue.toFixed(6) + ' ETH';
+        } catch {
+            return '0 ETH';
+        }
+    }
+}