pnpfucius 2.0.0

package/src/index.js

@@ -0,0 +1,139 @@
+// PNPFUCIUS - The PNP Exchange SDK
+// Create, trade, and settle prediction markets on Solana
+// Uses Helius RPC + PNP SDK
+
+// Core agent
+export { PrivacyOracleAgent, createAgent } from './agent.js';
+export { getConfig, validateConfig, getHeliusWsUrl, getHeliusApiUrl } from './config.js';
+export {
+    generatePrivacyMarket,
+    generateMultipleMarkets,
+    getMarketsByCategory,
+    listCategories,
+    PRIVACY_CATEGORIES
+} from './privacy-markets.js';
+
+// Helius integration
+export { HeliusClient, createHeliusClient } from './helius/client.js';
+export { TransactionTracker, createTransactionTracker } from './helius/transaction-tracker.js';
+export { WebhookServer, createWebhookServer } from './helius/webhooks.js';
+
+// Daemon mode
+export { PrivacyOracleDaemon, createDaemon } from './daemon/index.js';
+export { Scheduler, createScheduler } from './daemon/scheduler.js';
+export { setupGracefulShutdown, HealthMonitor } from './daemon/lifecycle.js';
+
+// Storage
+export { MarketStore, createMarketStore } from './storage/market-store.js';
+
+// Events
+export { agentEvents, AgentEvents } from './events/emitter.js';
+
+// Monitoring
+export { NewsMonitor, createNewsMonitor, DEFAULT_NEWS_SOURCES } from './monitoring/news-monitor.js';
+export { scoreRelevance, generateMarketFromNews, PRIVACY_KEYWORDS } from './monitoring/news-scorer.js';
+
+// Analytics
+export { DashboardAggregator, createAggregator, formatNumber, formatDuration } from './analytics/aggregator.js';
+
+// Privacy tokens
+export {
+    TOKENS,
+    PRIVACY_TOKEN_INFO,
+    getCollateralMint,
+    listSupportedTokens,
+    checkConfidentialTransferSupport,
+    getTokenInfo,
+    formatTokenAmount,
+    parseTokenAmount,
+    getCollateralConfig
+} from './collateral/privacy-tokens.js';
+
+// CLI utilities
+export {
+    createSpinner,
+    withSpinner,
+    withProgress,
+    createIndeterminateProgress,
+    StepProgress,
+    statusLine,
+    successLine,
+    errorLine,
+    infoLine
+} from './utils/spinner.js';
+
+// PNPFUCIUS - Interactive CLI Agent
+export { PnpfuciusAgent, createPnpfuciusAgent } from './predict/agent.js';
+export { tools as pnpTools, executeTool } from './predict/tools/index.js';
+
+// Quick start function for programmatic use
+export async function quickCreate(question, options = {}) {
+    const { createAgent } = await import('./agent.js');
+    const agent = await createAgent({ verbose: options.verbose });
+
+    if (question) {
+        return agent.createMarket({ question, ...options });
+    } else {
+        return agent.createPrivacyMarket(options);
+    }
+}
+
+// Run agent as daemon (recommended over runAutonomous)
+export async function startDaemon(config = {}) {
+    const { PrivacyOracleDaemon } = await import('./daemon/index.js');
+    const { getConfig } = await import('./config.js');
+
+    const baseConfig = getConfig();
+    const mergedConfig = {
+        ...baseConfig,
+        ...config,
+        daemon: {
+            ...baseConfig.daemon,
+            ...config.daemon
+        }
+    };
+
+    const daemon = new PrivacyOracleDaemon(mergedConfig);
+    await daemon.start();
+
+    return daemon;
+}
+
+// Legacy autonomous mode (use startDaemon instead)
+export async function runAutonomous(config = {}) {
+    console.warn('runAutonomous is deprecated. Use startDaemon for better functionality.');
+
+    const { createAgent } = await import('./agent.js');
+    const { generateMultipleMarkets } = await import('./privacy-markets.js');
+
+    const count = config.count || 1;
+    const interval = config.intervalMs || 3600000;
+
+    const agent = await createAgent({ verbose: true });
+
+    console.log(`Starting autonomous mode: ${count} markets every ${interval / 60000} minutes`);
+
+    const createRound = async () => {
+        const ideas = generateMultipleMarkets(count);
+
+        for (const idea of ideas) {
+            try {
+                const result = await agent.createMarket({
+                    question: idea.question,
+                    durationDays: idea.durationDays,
+                    liquidity: idea.suggestedLiquidity
+                });
+
+                console.log(`Created: ${result.market}`);
+            } catch (error) {
+                console.error(`Failed: ${error.message}`);
+            }
+        }
+    };
+
+    await createRound();
+
+    if (config.continuous) {
+        setInterval(createRound, interval);
+    }
+}

package/src/monitoring/news-monitor.js

@@ -0,0 +1,262 @@
+// RSS feed parsing for privacy-related news monitoring
+// Provides context for timely market generation
+
+import Parser from 'rss-parser';
+import { agentEvents, AgentEvents } from '../events/emitter.js';
+import { scoreRelevance, PRIVACY_KEYWORDS } from './news-scorer.js';
+
+// Default privacy news sources
+const DEFAULT_SOURCES = [
+    {
+        name: 'EFF',
+        url: 'https://www.eff.org/rss/updates.xml',
+        keywords: ['privacy', 'encryption', 'surveillance', 'data protection', 'FISA'],
+        weight: 1.0
+    },
+    {
+        name: 'Decrypt',
+        url: 'https://decrypt.co/feed',
+        keywords: ['privacy', 'zk', 'zero-knowledge', 'tornado', 'zcash', 'monero', 'mixer'],
+        weight: 0.9
+    },
+    {
+        name: 'CoinDesk',
+        url: 'https://www.coindesk.com/arc/outboundfeeds/rss/',
+        keywords: ['privacy', 'regulation', 'sanctions', 'compliance', 'OFAC'],
+        weight: 0.7
+    },
+    {
+        name: 'The Block',
+        url: 'https://www.theblock.co/rss.xml',
+        keywords: ['privacy', 'zk-rollup', 'confidential', 'anonymous'],
+        weight: 0.8
+    }
+];
+
+export class NewsMonitor {
+    constructor(config = {}) {
+        this.sources = config.sources || DEFAULT_SOURCES;
+        this.parser = new Parser({
+            timeout: 10000,
+            headers: {
+                'User-Agent': 'PrivacyOracleAgent/1.0'
+            }
+        });
+        this.checkInterval = config.checkInterval || 300000; // 5 minutes
+        this.recentEvents = [];
+        this.maxEvents = config.maxEvents || 100;
+        this.seenIds = new Set();
+        this.timer = null;
+        this.isRunning = false;
+        this.lastCheck = null;
+        this.errorCount = 0;
+    }
+
+    async start() {
+        if (this.isRunning) return this;
+
+        this.isRunning = true;
+
+        // Initial check
+        await this.checkFeeds();
+
+        // Schedule periodic checks
+        this.timer = setInterval(() => this.checkFeeds(), this.checkInterval);
+
+        return this;
+    }
+
+    async stop() {
+        this.isRunning = false;
+
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+
+        return this;
+    }
+
+    async checkFeeds() {
+        if (!this.isRunning) return;
+
+        this.lastCheck = Date.now();
+        const newEvents = [];
+
+        for (const source of this.sources) {
+            try {
+                const feed = await this.parser.parseURL(source.url);
+
+                for (const item of feed.items || []) {
+                    const id = item.guid || item.link || item.title;
+
+                    if (this.seenIds.has(id)) continue;
+
+                    const event = this.processItem(item, source);
+
+                    // Only keep events with relevance score >= 30
+                    if (event.relevanceScore >= 30) {
+                        this.addEvent(event);
+                        newEvents.push(event);
+
+                        agentEvents.emitTyped(AgentEvents.NEWS_EVENT, event);
+                    }
+
+                    this.seenIds.add(id);
+
+                    // Limit seen IDs to prevent memory growth
+                    if (this.seenIds.size > 10000) {
+                        const idsArray = Array.from(this.seenIds);
+                        this.seenIds = new Set(idsArray.slice(-5000));
+                    }
+                }
+            } catch (error) {
+                this.errorCount++;
+                console.error(`Failed to fetch ${source.name}:`, error.message);
+            }
+        }
+
+        agentEvents.emitTyped(AgentEvents.NEWS_CHECK_COMPLETE, {
+            sourcesChecked: this.sources.length,
+            newEventsFound: newEvents.length,
+            totalEvents: this.recentEvents.length,
+            errorCount: this.errorCount
+        });
+
+        return newEvents;
+    }
+
+    processItem(item, source) {
+        const title = item.title || '';
+        const content = item.contentSnippet || item.content || '';
+        const text = `${title} ${content}`.toLowerCase();
+
+        const { score, matchedKeywords, suggestedCategory, urgency } = scoreRelevance(
+            text,
+            source.keywords,
+            source.weight
+        );
+
+        return {
+            id: item.guid || item.link || `${source.name}-${Date.now()}`,
+            title: title,
+            link: item.link || '',
+            source: source.name,
+            publishedAt: item.pubDate ? new Date(item.pubDate).getTime() : Date.now(),
+            relevanceScore: score,
+            matchedKeywords,
+            suggestedCategory,
+            urgency,
+            snippet: content.slice(0, 200)
+        };
+    }
+
+    addEvent(event) {
+        this.recentEvents.unshift(event);
+
+        if (this.recentEvents.length > this.maxEvents) {
+            this.recentEvents = this.recentEvents.slice(0, this.maxEvents);
+        }
+    }
+
+    getRecentEvents(limit = 10) {
+        return this.recentEvents.slice(0, limit);
+    }
+
+    getEventsByCategory(category, limit = 10) {
+        return this.recentEvents
+            .filter(e => e.suggestedCategory === category)
+            .slice(0, limit);
+    }
+
+    getHighUrgencyEvents(limit = 5) {
+        return this.recentEvents
+            .filter(e => e.urgency === 'breaking' || e.urgency === 'timely')
+            .slice(0, limit);
+    }
+
+    getStatus() {
+        return {
+            isRunning: this.isRunning,
+            sourcesCount: this.sources.length,
+            eventsCount: this.recentEvents.length,
+            lastCheck: this.lastCheck,
+            errorCount: this.errorCount,
+            seenIdsCount: this.seenIds.size
+        };
+    }
+
+    // Add a custom news source
+    addSource(source) {
+        if (!source.name || !source.url) {
+            throw new Error('Source requires name and url');
+        }
+
+        this.sources.push({
+            keywords: PRIVACY_KEYWORDS,
+            weight: 0.5,
+            ...source
+        });
+
+        return this;
+    }
+
+    // Remove a news source
+    removeSource(name) {
+        this.sources = this.sources.filter(s => s.name !== name);
+        return this;
+    }
+}
+
+export function createNewsMonitor(config) {
+    return new NewsMonitor(config);
+}
+
+// Mock news source for testing
+export class MockNewsSource {
+    constructor() {
+        this.events = [
+            {
+                title: 'EU Proposes New Digital Privacy Framework with Strict Encryption Rules',
+                relevanceScore: 85,
+                suggestedCategory: 'regulation',
+                urgency: 'timely'
+            },
+            {
+                title: 'Major ZK Protocol Reaches $1B TVL Milestone',
+                relevanceScore: 90,
+                suggestedCategory: 'technology',
+                urgency: 'breaking'
+            },
+            {
+                title: 'Signal Reports Record User Growth Amid Privacy Concerns',
+                relevanceScore: 75,
+                suggestedCategory: 'adoption',
+                urgency: 'timely'
+            },
+            {
+                title: 'Data Breach Affects 50M Users at Major Tech Company',
+                relevanceScore: 80,
+                suggestedCategory: 'events',
+                urgency: 'breaking'
+            },
+            {
+                title: 'Tornado Cash Developer Case Reaches New Development',
+                relevanceScore: 95,
+                suggestedCategory: 'regulation',
+                urgency: 'breaking'
+            }
+        ];
+    }
+
+    async getEvents(limit = 5) {
+        return this.events.slice(0, limit).map(e => ({
+            ...e,
+            id: `mock-${Math.random().toString(36).slice(2)}`,
+            link: 'https://example.com',
+            source: 'mock',
+            publishedAt: Date.now(),
+            matchedKeywords: ['privacy']
+        }));
+    }
+}

package/src/monitoring/news-scorer.js

@@ -0,0 +1,236 @@
+// Relevance scoring algorithm for privacy news
+// Determines how relevant a news item is for market generation
+
+// Core privacy-related keywords with weights
+export const PRIVACY_KEYWORDS = {
+    // High relevance - direct privacy tech
+    'zero-knowledge': 3,
+    'zk-proof': 3,
+    'zk-snark': 3,
+    'zk-stark': 3,
+    'zkrollup': 3,
+    'confidential': 2.5,
+    'encryption': 2.5,
+    'encrypted': 2.5,
+    'privacy-preserving': 3,
+    'private transaction': 3,
+
+    // Privacy protocols
+    'tornado cash': 3,
+    'zcash': 2.5,
+    'monero': 2.5,
+    'light protocol': 3,
+    'elusiv': 3,
+    'aztec': 2.5,
+    'railgun': 2.5,
+    'secret network': 2.5,
+
+    // Regulatory
+    'gdpr': 2,
+    'privacy law': 2.5,
+    'data protection': 2,
+    'surveillance': 2.5,
+    'sanctions': 2,
+    'ofac': 2.5,
+    'compliance': 1.5,
+    'kyc': 1.5,
+    'aml': 1.5,
+
+    // General privacy
+    'privacy': 1.5,
+    'anonymous': 2,
+    'anonymity': 2,
+    'pseudonymous': 1.5,
+    'private': 1,
+    'mixer': 2,
+    'mixing': 2,
+    'shielded': 2.5,
+
+    // Tech terms
+    'homomorphic': 3,
+    'mpc': 2.5,
+    'secure enclave': 2,
+    'tee': 2,
+    'trusted execution': 2,
+
+    // Events
+    'data breach': 2.5,
+    'leak': 1.5,
+    'hack': 1.5,
+    'compromised': 1.5,
+
+    // Solana specific
+    'solana privacy': 3,
+    'spl confidential': 3,
+    'token-2022 confidential': 3
+};
+
+// Category mappings
+const CATEGORY_KEYWORDS = {
+    regulation: ['law', 'regulation', 'gdpr', 'sanctions', 'ofac', 'compliance', 'legislation', 'ban', 'restrict'],
+    technology: ['zk', 'protocol', 'launch', 'release', 'upgrade', 'mainnet', 'testnet', 'tvl', 'smart contract'],
+    adoption: ['users', 'growth', 'adoption', 'enterprise', 'mainstream', 'wallet', 'integration'],
+    events: ['breach', 'hack', 'leak', 'scandal', 'arrest', 'raid', 'lawsuit', 'verdict']
+};
+
+// Urgency indicators
+const URGENCY_KEYWORDS = {
+    breaking: ['breaking', 'just in', 'urgent', 'alert', 'confirmed', 'arrested', 'breached'],
+    timely: ['announces', 'launches', 'releases', 'proposes', 'reaches', 'exceeds', 'surpasses']
+};
+
+export function scoreRelevance(text, sourceKeywords = [], sourceWeight = 1.0) {
+    const lowerText = text.toLowerCase();
+    let score = 0;
+    const matchedKeywords = [];
+
+    // Score based on privacy keywords
+    for (const [keyword, weight] of Object.entries(PRIVACY_KEYWORDS)) {
+        if (lowerText.includes(keyword)) {
+            score += weight * 10;
+            matchedKeywords.push(keyword);
+        }
+    }
+
+    // Additional score from source-specific keywords
+    for (const keyword of sourceKeywords) {
+        if (lowerText.includes(keyword.toLowerCase())) {
+            score += 5;
+            if (!matchedKeywords.includes(keyword)) {
+                matchedKeywords.push(keyword);
+            }
+        }
+    }
+
+    // Apply source weight
+    score = Math.round(score * sourceWeight);
+
+    // Cap at 100
+    score = Math.min(score, 100);
+
+    // Determine suggested category
+    const suggestedCategory = determineCategory(lowerText);
+
+    // Determine urgency
+    const urgency = determineUrgency(lowerText);
+
+    return {
+        score,
+        matchedKeywords,
+        suggestedCategory,
+        urgency
+    };
+}
+
+function determineCategory(text) {
+    const scores = {
+        regulation: 0,
+        technology: 0,
+        adoption: 0,
+        events: 0
+    };
+
+    for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
+        for (const keyword of keywords) {
+            if (text.includes(keyword)) {
+                scores[category] += 1;
+            }
+        }
+    }
+
+    // Find highest scoring category
+    let maxScore = 0;
+    let bestCategory = 'technology'; // default
+
+    for (const [category, score] of Object.entries(scores)) {
+        if (score > maxScore) {
+            maxScore = score;
+            bestCategory = category;
+        }
+    }
+
+    return bestCategory;
+}
+
+function determineUrgency(text) {
+    for (const keyword of URGENCY_KEYWORDS.breaking) {
+        if (text.includes(keyword)) {
+            return 'breaking';
+        }
+    }
+
+    for (const keyword of URGENCY_KEYWORDS.timely) {
+        if (text.includes(keyword)) {
+            return 'timely';
+        }
+    }
+
+    return 'evergreen';
+}
+
+// Generate a market question from a news event
+export function generateMarketFromNews(newsEvent) {
+    const { title, suggestedCategory, urgency } = newsEvent;
+
+    // Extract key entities from title
+    const entities = extractEntities(title);
+
+    // Generate appropriate duration based on urgency
+    const durationDays = urgency === 'breaking' ? 14 :
+                         urgency === 'timely' ? 30 : 90;
+
+    // Generate question based on category
+    let question;
+
+    switch (suggestedCategory) {
+        case 'regulation':
+            question = `Will regulatory action be taken regarding "${entities.topic || 'this development'}" within ${durationDays} days?`;
+            break;
+        case 'technology':
+            question = `Will the technology mentioned in "${entities.topic || 'this news'}" see significant adoption by ${formatFutureDate(durationDays)}?`;
+            break;
+        case 'adoption':
+            question = `Will user adoption metrics exceed expectations for "${entities.topic || 'this platform'}" by ${formatFutureDate(durationDays)}?`;
+            break;
+        case 'events':
+            question = `Will there be follow-up developments on "${entities.topic || 'this event'}" within ${durationDays} days?`;
+            break;
+        default:
+            question = `Will "${entities.topic || 'this development'}" have significant impact by ${formatFutureDate(durationDays)}?`;
+    }
+
+    return {
+        question,
+        category: suggestedCategory,
+        durationDays,
+        urgency,
+        sourceEvent: newsEvent
+    };
+}
+
+function extractEntities(title) {
+    // Simple entity extraction - could be enhanced with NLP
+    const words = title.split(' ');
+
+    // Look for capitalized words as potential entities
+    const entities = words.filter(w =>
+        w.length > 2 &&
+        w[0] === w[0].toUpperCase() &&
+        !['The', 'And', 'For', 'New', 'With'].includes(w)
+    );
+
+    return {
+        topic: title.slice(0, 50),
+        entities
+    };
+}
+
+function formatFutureDate(daysFromNow) {
+    const date = new Date();
+    date.setDate(date.getDate() + daysFromNow);
+
+    const months = ['January', 'February', 'March', 'April', 'May', 'June',
+                    'July', 'August', 'September', 'October', 'November', 'December'];
+
+    return `${months[date.getMonth()]} ${date.getFullYear()}`;
+}