pnpfucius 2.0.0

package/src/helius/client.js

@@ -0,0 +1,221 @@
+// Helius API client for enhanced Solana interactions
+// Provides DAS API, enhanced transactions, and webhook management
+
+const HELIUS_API_BASE = 'https://api.helius.xyz/v0';
+
+export class HeliusClient {
+    constructor(apiKey, network = 'devnet') {
+        if (!apiKey) {
+            throw new Error('Helius API key is required');
+        }
+        this.apiKey = apiKey;
+        this.network = network;
+        this.rpcUrl = `https://${network === 'mainnet' ? 'mainnet' : 'devnet'}.helius-rpc.com/?api-key=${apiKey}`;
+    }
+
+    // DAS API Methods
+
+    async getAssetsByOwner(ownerAddress, options = {}) {
+        const response = await this.dasRequest('getAssetsByOwner', {
+            ownerAddress,
+            page: options.page || 1,
+            limit: options.limit || 50,
+            sortBy: options.sortBy || { sortBy: 'created', sortDirection: 'desc' },
+            options: {
+                showFungible: options.showFungible || false,
+                showNativeBalance: options.showNativeBalance || false
+            }
+        });
+        return response.result;
+    }
+
+    async searchAssets(params) {
+        const response = await this.dasRequest('searchAssets', params);
+        return response.result;
+    }
+
+    async getSignaturesForAsset(assetId, options = {}) {
+        const response = await this.dasRequest('getSignaturesForAsset', {
+            id: assetId,
+            page: options.page || 1,
+            limit: options.limit || 100
+        });
+        return response.result;
+    }
+
+    async getAsset(assetId) {
+        const response = await this.dasRequest('getAsset', { id: assetId });
+        return response.result;
+    }
+
+    // Enhanced Transactions API
+
+    async getEnhancedTransactions(signatures) {
+        if (!Array.isArray(signatures)) {
+            signatures = [signatures];
+        }
+
+        const response = await fetch(`${HELIUS_API_BASE}/transactions?api-key=${this.apiKey}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ transactions: signatures })
+        });
+
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Helius API error: ${error}`);
+        }
+
+        return response.json();
+    }
+
+    async getEnhancedTransactionsByAddress(address, options = {}) {
+        const params = new URLSearchParams({
+            'api-key': this.apiKey
+        });
+
+        if (options.type) params.append('type', options.type);
+        if (options.before) params.append('before', options.before);
+        if (options.until) params.append('until', options.until);
+
+        const response = await fetch(
+            `${HELIUS_API_BASE}/addresses/${address}/transactions?${params}`,
+            { method: 'GET' }
+        );
+
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Helius API error: ${error}`);
+        }
+
+        return response.json();
+    }
+
+    // Webhook Management
+
+    async createWebhook(config) {
+        const webhookType = this.network === 'mainnet' ? 'enhanced' : 'enhancedDevnet';
+
+        const response = await fetch(`${HELIUS_API_BASE}/webhooks?api-key=${this.apiKey}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                webhookURL: config.url,
+                transactionTypes: config.transactionTypes || ['ANY'],
+                accountAddresses: config.addresses || [],
+                webhookType: config.type || webhookType,
+                authHeader: config.authToken || undefined
+            })
+        });
+
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to create webhook: ${error}`);
+        }
+
+        return response.json();
+    }
+
+    async listWebhooks() {
+        const response = await fetch(`${HELIUS_API_BASE}/webhooks?api-key=${this.apiKey}`, {
+            method: 'GET'
+        });
+
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to list webhooks: ${error}`);
+        }
+
+        return response.json();
+    }
+
+    async getWebhook(webhookId) {
+        const response = await fetch(`${HELIUS_API_BASE}/webhooks/${webhookId}?api-key=${this.apiKey}`, {
+            method: 'GET'
+        });
+
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to get webhook: ${error}`);
+        }
+
+        return response.json();
+    }
+
+    async updateWebhook(webhookId, config) {
+        const response = await fetch(`${HELIUS_API_BASE}/webhooks/${webhookId}?api-key=${this.apiKey}`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(config)
+        });
+
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to update webhook: ${error}`);
+        }
+
+        return response.json();
+    }
+
+    async deleteWebhook(webhookId) {
+        const response = await fetch(`${HELIUS_API_BASE}/webhooks/${webhookId}?api-key=${this.apiKey}`, {
+            method: 'DELETE'
+        });
+
+        return response.ok;
+    }
+
+    // Priority Fee API
+
+    async getPriorityFeeEstimate(params = {}) {
+        const response = await fetch(`${HELIUS_API_BASE}/priority-fee?api-key=${this.apiKey}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                accountKeys: params.accountKeys || [],
+                options: {
+                    priorityLevel: params.priorityLevel || 'Medium'
+                }
+            })
+        });
+
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to get priority fee: ${error}`);
+        }
+
+        return response.json();
+    }
+
+    // Internal helper for DAS API requests
+
+    async dasRequest(method, params) {
+        const response = await fetch(this.rpcUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: '1',
+                method,
+                params
+            })
+        });
+
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`DAS API error: ${error}`);
+        }
+
+        const result = await response.json();
+
+        if (result.error) {
+            throw new Error(`DAS API error: ${result.error.message}`);
+        }
+
+        return result;
+    }
+}
+
+export function createHeliusClient(apiKey, network) {
+    return new HeliusClient(apiKey, network);
+}

package/src/helius/transaction-tracker.js

@@ -0,0 +1,192 @@
+// Transaction confirmation tracking with enhanced Helius methods
+// Provides reliable transaction confirmation with retries and status updates
+
+import { Connection } from '@solana/web3.js';
+
+export class TransactionTracker {
+    constructor(config = {}) {
+        this.rpcUrl = config.rpcUrl;
+        this.heliusClient = config.heliusClient;
+        this.connection = new Connection(this.rpcUrl, 'confirmed');
+        this.maxRetries = config.maxRetries || 30;
+        this.retryDelay = config.retryDelay || 2000;
+        this.onStatusChange = config.onStatusChange || null;
+    }
+
+    async confirmTransaction(signature, options = {}) {
+        const maxRetries = options.maxRetries || this.maxRetries;
+        const retryDelay = options.retryDelay || this.retryDelay;
+        const commitment = options.commitment || 'confirmed';
+
+        this.emitStatus(signature, 'pending', 'Waiting for confirmation...');
+
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const status = await this.connection.getSignatureStatus(signature, {
+                    searchTransactionHistory: true
+                });
+
+                if (status && status.value) {
+                    const { confirmationStatus, err } = status.value;
+
+                    if (err) {
+                        this.emitStatus(signature, 'failed', `Transaction failed: ${JSON.stringify(err)}`);
+                        return {
+                            success: false,
+                            signature,
+                            error: err,
+                            confirmationStatus
+                        };
+                    }
+
+                    if (confirmationStatus === 'finalized') {
+                        this.emitStatus(signature, 'finalized', 'Transaction finalized');
+                        return {
+                            success: true,
+                            signature,
+                            confirmationStatus: 'finalized',
+                            slot: status.value.slot
+                        };
+                    }
+
+                    if (confirmationStatus === 'confirmed' && commitment === 'confirmed') {
+                        this.emitStatus(signature, 'confirmed', 'Transaction confirmed');
+                        return {
+                            success: true,
+                            signature,
+                            confirmationStatus: 'confirmed',
+                            slot: status.value.slot
+                        };
+                    }
+
+                    this.emitStatus(signature, 'processing', `Status: ${confirmationStatus} (attempt ${attempt}/${maxRetries})`);
+                }
+            } catch (error) {
+                this.emitStatus(signature, 'retrying', `Retry ${attempt}/${maxRetries}: ${error.message}`);
+            }
+
+            if (attempt < maxRetries) {
+                await this.sleep(retryDelay);
+            }
+        }
+
+        this.emitStatus(signature, 'timeout', 'Confirmation timeout');
+        return {
+            success: false,
+            signature,
+            error: 'Confirmation timeout',
+            confirmationStatus: 'unknown'
+        };
+    }
+
+    async getTransactionDetails(signature) {
+        // Try enhanced Helius API first for rich transaction data
+        if (this.heliusClient) {
+            try {
+                const enhanced = await this.heliusClient.getEnhancedTransactions([signature]);
+                if (enhanced && enhanced.length > 0) {
+                    return {
+                        enhanced: true,
+                        data: enhanced[0]
+                    };
+                }
+            } catch (error) {
+                // Fall back to standard RPC
+            }
+        }
+
+        // Standard RPC fallback
+        const tx = await this.connection.getTransaction(signature, {
+            maxSupportedTransactionVersion: 0
+        });
+
+        return {
+            enhanced: false,
+            data: tx
+        };
+    }
+
+    async waitForTransaction(signature, options = {}) {
+        const timeout = options.timeout || 60000;
+        const startTime = Date.now();
+
+        while (Date.now() - startTime < timeout) {
+            const result = await this.confirmTransaction(signature, {
+                maxRetries: 1,
+                ...options
+            });
+
+            if (result.success || result.error) {
+                return result;
+            }
+
+            await this.sleep(1000);
+        }
+
+        return {
+            success: false,
+            signature,
+            error: 'Transaction wait timeout'
+        };
+    }
+
+    async trackMultipleTransactions(signatures, options = {}) {
+        const results = new Map();
+        const pending = new Set(signatures);
+        const maxWait = options.maxWait || 120000;
+        const startTime = Date.now();
+
+        while (pending.size > 0 && Date.now() - startTime < maxWait) {
+            const statuses = await this.connection.getSignatureStatuses(
+                Array.from(pending),
+                { searchTransactionHistory: true }
+            );
+
+            for (let i = 0; i < statuses.value.length; i++) {
+                const sig = Array.from(pending)[i];
+                const status = statuses.value[i];
+
+                if (status) {
+                    if (status.err) {
+                        results.set(sig, { success: false, error: status.err });
+                        pending.delete(sig);
+                    } else if (status.confirmationStatus === 'finalized' ||
+                               status.confirmationStatus === 'confirmed') {
+                        results.set(sig, { success: true, status: status.confirmationStatus });
+                        pending.delete(sig);
+                    }
+                }
+            }
+
+            if (pending.size > 0) {
+                await this.sleep(2000);
+            }
+        }
+
+        // Mark remaining as timeout
+        for (const sig of pending) {
+            results.set(sig, { success: false, error: 'timeout' });
+        }
+
+        return results;
+    }
+
+    emitStatus(signature, status, message) {
+        if (this.onStatusChange) {
+            this.onStatusChange({
+                signature,
+                status,
+                message,
+                timestamp: Date.now()
+            });
+        }
+    }
+
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+export function createTransactionTracker(config) {
+    return new TransactionTracker(config);
+}

package/src/helius/webhooks.js

@@ -0,0 +1,233 @@
+// Helius webhook server for receiving real-time blockchain events
+// Express server with endpoints for market event notifications
+
+import express from 'express';
+import { agentEvents, AgentEvents } from '../events/emitter.js';
+
+export class WebhookServer {
+    constructor(config = {}) {
+        this.port = config.port || 3000;
+        this.authToken = config.authToken || process.env.WEBHOOK_AUTH_TOKEN;
+        this.app = express();
+        this.server = null;
+        this.eventHandlers = new Map();
+
+        this.setupMiddleware();
+        this.setupRoutes();
+    }
+
+    setupMiddleware() {
+        this.app.use(express.json({ limit: '10mb' }));
+
+        // Auth middleware for webhook endpoints
+        this.app.use('/webhook', (req, res, next) => {
+            if (this.authToken) {
+                const auth = req.headers['authorization'];
+                if (auth !== this.authToken) {
+                    return res.status(401).json({ error: 'Unauthorized' });
+                }
+            }
+            next();
+        });
+
+        // Request logging
+        this.app.use((req, res, next) => {
+            const start = Date.now();
+            res.on('finish', () => {
+                const duration = Date.now() - start;
+                if (req.path.startsWith('/webhook')) {
+                    agentEvents.emitTyped(AgentEvents.WEBHOOK_RECEIVED, {
+                        path: req.path,
+                        method: req.method,
+                        statusCode: res.statusCode,
+                        duration
+                    });
+                }
+            });
+            next();
+        });
+    }
+
+    setupRoutes() {
+        // Helius webhook endpoint
+        this.app.post('/webhook/helius', async (req, res) => {
+            try {
+                const events = Array.isArray(req.body) ? req.body : [req.body];
+                const processed = [];
+
+                for (const event of events) {
+                    try {
+                        await this.processHeliusEvent(event);
+                        processed.push({ success: true, signature: event.signature });
+                    } catch (error) {
+                        processed.push({ success: false, error: error.message });
+                    }
+                }
+
+                res.status(200).json({
+                    success: true,
+                    processed: processed.length,
+                    results: processed
+                });
+            } catch (error) {
+                console.error('Webhook processing error:', error);
+                res.status(500).json({ error: error.message });
+            }
+        });
+
+        // Health check endpoint
+        this.app.get('/health', (req, res) => {
+            res.json({
+                status: 'ok',
+                timestamp: Date.now(),
+                uptime: process.uptime()
+            });
+        });
+
+        // Analytics endpoint for dashboard
+        this.app.get('/api/stats', async (req, res) => {
+            try {
+                const handler = this.eventHandlers.get('getStats');
+                if (handler) {
+                    const stats = await handler();
+                    res.json(stats);
+                } else {
+                    res.json({ message: 'Stats handler not configured' });
+                }
+            } catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+
+        // Recent markets endpoint
+        this.app.get('/api/markets', async (req, res) => {
+            try {
+                const handler = this.eventHandlers.get('getMarkets');
+                if (handler) {
+                    const limit = parseInt(req.query.limit) || 20;
+                    const status = req.query.status || null;
+                    const markets = await handler({ limit, status });
+                    res.json(markets);
+                } else {
+                    res.json([]);
+                }
+            } catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+
+        // 404 handler
+        this.app.use((req, res) => {
+            res.status(404).json({ error: 'Not found' });
+        });
+    }
+
+    async processHeliusEvent(event) {
+        // Extract event type and process accordingly
+        const eventType = event.type || 'UNKNOWN';
+        const signature = event.signature;
+
+        // Emit for any listeners
+        agentEvents.emitTyped(AgentEvents.HELIUS_EVENT, {
+            type: eventType,
+            signature,
+            data: event
+        });
+
+        // Handle specific event types
+        switch (eventType) {
+            case 'CREATE_MARKET':
+                await this.handleMarketCreation(event);
+                break;
+            case 'SWAP':
+                await this.handleSwap(event);
+                break;
+            case 'TRANSFER':
+                await this.handleTransfer(event);
+                break;
+            default:
+                // Generic event handling
+                const handler = this.eventHandlers.get(eventType);
+                if (handler) {
+                    await handler(event);
+                }
+        }
+
+        return { processed: true, type: eventType };
+    }
+
+    async handleMarketCreation(event) {
+        const handler = this.eventHandlers.get('marketCreated');
+        if (handler) {
+            await handler(event);
+        }
+    }
+
+    async handleSwap(event) {
+        const handler = this.eventHandlers.get('swap');
+        if (handler) {
+            await handler(event);
+        }
+    }
+
+    async handleTransfer(event) {
+        const handler = this.eventHandlers.get('transfer');
+        if (handler) {
+            await handler(event);
+        }
+    }
+
+    // Register custom event handlers
+    on(eventType, handler) {
+        this.eventHandlers.set(eventType, handler);
+        return this;
+    }
+
+    // Remove event handler
+    off(eventType) {
+        this.eventHandlers.delete(eventType);
+        return this;
+    }
+
+    async start() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.server = this.app.listen(this.port, () => {
+                    console.log(`Webhook server listening on port ${this.port}`);
+                    agentEvents.emitTyped(AgentEvents.WEBHOOK_SERVER_STARTED, {
+                        port: this.port
+                    });
+                    resolve(this.port);
+                });
+
+                this.server.on('error', (error) => {
+                    reject(error);
+                });
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    console.log('Webhook server stopped');
+                    agentEvents.emitTyped(AgentEvents.WEBHOOK_SERVER_STOPPED, {});
+                    resolve();
+                });
+            } else {
+                resolve();
+            }
+        });
+    }
+
+    getExpressApp() {
+        return this.app;
+    }
+}
+
+export function createWebhookServer(config) {
+    return new WebhookServer(config);
+}