pnpfucius 2.0.0

package/src/ai/index.js

@@ -0,0 +1,6 @@
+// AI module exports
+// Claude API-powered market generation, resolution, and scoring
+
+export { AIMarketGenerator, createMarketGenerator } from './market-generator.js';
+export { AIResolver, createResolver } from './resolver.js';
+export { AIScorer, createScorer, quickScore } from './scorer.js';

package/src/ai/market-generator.js

@@ -0,0 +1,186 @@
+// AI-powered market generation using Claude API
+// Transforms news headlines into privacy-themed prediction markets
+
+import Anthropic from '@anthropic-ai/sdk';
+import { getConfig } from '../config.js';
+
+const MARKET_GENERATION_PROMPT = `You are an expert at creating prediction market questions for a privacy-focused prediction market on Solana.
+
+Given news headlines or topics, generate relevant YES/NO prediction market questions that:
+1. Are clearly verifiable with a definitive outcome
+2. Focus on privacy, regulation, zero-knowledge proofs, encryption, data protection, or surveillance
+3. Have appropriate timeframes (30-365 days typically)
+4. Are interesting enough to attract betting activity
+5. Are NOT already obviously true or false
+
+Categories to consider:
+- regulation: Government policies, GDPR, privacy laws, sanctions
+- technology: ZK protocols, encryption standards, privacy tools, Solana privacy features
+- adoption: User growth, TVL milestones, enterprise adoption
+- events: Breaches, scandals, conference announcements, court cases
+
+Respond with valid JSON only, no markdown formatting:
+{
+  "question": "The yes/no question ending with ?",
+  "category": "regulation|technology|adoption|events",
+  "categoryName": "Human readable category name",
+  "suggestedDurationDays": 30-365,
+  "suggestedLiquidityUSDC": 1000-10000,
+  "urgency": "breaking|timely|evergreen",
+  "reasoning": "Brief explanation of why this is a good market"
+}`;
+
+export class AIMarketGenerator {
+    constructor(apiKey = null) {
+        const config = getConfig();
+        this.apiKey = apiKey || config.anthropicApiKey;
+
+        if (!this.apiKey) {
+            throw new Error('ANTHROPIC_API_KEY is required for AI market generation');
+        }
+
+        this.client = new Anthropic({ apiKey: this.apiKey });
+        this.model = 'claude-sonnet-4-20250514';
+    }
+
+    /**
+     * Generate a market question from a news headline
+     */
+    async generateFromNews(newsItem) {
+        const { title, summary, source, link } = newsItem;
+
+        const userPrompt = `Generate a prediction market question based on this news:
+
+Title: ${title}
+${summary ? `Summary: ${summary}` : ''}
+${source ? `Source: ${source}` : ''}
+
+Create a compelling, verifiable YES/NO question that privacy-focused traders would want to bet on.`;
+
+        try {
+            const response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 500,
+                messages: [
+                    { role: 'user', content: MARKET_GENERATION_PROMPT + '\n\n' + userPrompt }
+                ]
+            });
+
+            const content = response.content[0].text;
+            const market = JSON.parse(content);
+
+            return {
+                ...market,
+                sourceNews: { title, source, link },
+                generatedAt: Date.now()
+            };
+        } catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`Failed to parse AI response as JSON: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Generate multiple markets from a batch of news items
+     */
+    async generateBatchFromNews(newsItems, options = {}) {
+        const { maxMarkets = 5, minScore = 50 } = options;
+        const results = [];
+
+        for (const item of newsItems.slice(0, maxMarkets)) {
+            try {
+                // Skip low-relevance items if score provided
+                if (item.relevanceScore !== undefined && item.relevanceScore < minScore) {
+                    continue;
+                }
+
+                const market = await this.generateFromNews(item);
+                results.push({ success: true, market, newsItem: item });
+            } catch (error) {
+                results.push({ success: false, error: error.message, newsItem: item });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Generate a market from a topic/theme (not news-based)
+     */
+    async generateFromTopic(topic, category = null) {
+        const userPrompt = `Generate a prediction market question about: ${topic}
+${category ? `Focus on the "${category}" category.` : ''}
+
+Create a compelling, verifiable YES/NO question that privacy-focused traders would want to bet on.`;
+
+        try {
+            const response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 500,
+                messages: [
+                    { role: 'user', content: MARKET_GENERATION_PROMPT + '\n\n' + userPrompt }
+                ]
+            });
+
+            const content = response.content[0].text;
+            const market = JSON.parse(content);
+
+            return {
+                ...market,
+                sourceTopic: topic,
+                generatedAt: Date.now()
+            };
+        } catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`Failed to parse AI response as JSON: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Generate multiple diverse markets
+     */
+    async generateDiverseMarkets(count = 5) {
+        const topics = [
+            'GDPR enforcement trends in 2026',
+            'Zero-knowledge proof adoption on Solana',
+            'Privacy coin regulations in the US',
+            'Enterprise adoption of confidential computing',
+            'End-to-end encryption legislation',
+            'Decentralized identity adoption',
+            'Privacy-preserving AI developments',
+            'Tornado Cash legal developments',
+            'Light Protocol and Solana privacy',
+            'Data breach trends and regulations'
+        ];
+
+        const categories = ['regulation', 'technology', 'adoption', 'events'];
+        const results = [];
+
+        for (let i = 0; i < count; i++) {
+            const topic = topics[i % topics.length];
+            const category = categories[i % categories.length];
+
+            try {
+                const market = await this.generateFromTopic(topic, category);
+                results.push({ success: true, market });
+            } catch (error) {
+                results.push({ success: false, error: error.message, topic });
+            }
+        }
+
+        return results;
+    }
+}
+
+/**
+ * Factory function
+ */
+export function createMarketGenerator(apiKey = null) {
+    return new AIMarketGenerator(apiKey);
+}
+
+export default AIMarketGenerator;

package/src/ai/resolver.js

@@ -0,0 +1,172 @@
+// AI-powered market resolution helper using Claude API
+// Analyzes whether market conditions have been met
+
+import Anthropic from '@anthropic-ai/sdk';
+import { getConfig } from '../config.js';
+
+const RESOLUTION_PROMPT = `You are an expert at determining whether prediction market conditions have been met.
+
+Given a prediction market question and the current date, analyze whether:
+1. The condition can be definitively resolved (enough time has passed, event occurred, etc.)
+2. If resolvable, whether the outcome is YES or NO
+3. Your confidence level in the assessment
+
+Consider:
+- Time-bound conditions (has the deadline passed?)
+- Verifiable events (did the specific event occur?)
+- Measurable thresholds (was the metric achieved?)
+
+Be conservative - if uncertain, indicate the market cannot be resolved yet.
+
+Respond with valid JSON only, no markdown formatting:
+{
+  "canResolve": true/false,
+  "outcome": "yes"|"no"|"unknown",
+  "confidence": 0.0-1.0,
+  "reasoning": "Detailed explanation of your assessment",
+  "sources": ["Any sources or facts you're basing this on"],
+  "suggestedAction": "resolve_yes"|"resolve_no"|"wait"|"needs_oracle"
+}`;
+
+export class AIResolver {
+    constructor(apiKey = null) {
+        const config = getConfig();
+        this.apiKey = apiKey || config.anthropicApiKey;
+
+        if (!this.apiKey) {
+            throw new Error('ANTHROPIC_API_KEY is required for AI resolution');
+        }
+
+        this.client = new Anthropic({ apiKey: this.apiKey });
+        this.model = 'claude-sonnet-4-20250514';
+    }
+
+    /**
+     * Analyze if a market can be resolved
+     */
+    async analyzeResolution(market) {
+        const { question, creationTime, endTime, durationDays } = market;
+        const now = new Date();
+        const createdAt = new Date(creationTime);
+        const endsAt = endTime ? new Date(endTime) : null;
+
+        const userPrompt = `Analyze this prediction market for resolution:
+
+Question: ${question}
+
+Market Details:
+- Created: ${createdAt.toISOString().split('T')[0]}
+- Duration: ${durationDays} days
+${endsAt ? `- End Date: ${endsAt.toISOString().split('T')[0]}` : ''}
+- Current Date: ${now.toISOString().split('T')[0]}
+
+Has enough time passed? Has the condition been met or definitively failed?
+Use your knowledge cutoff to assess current events and facts.`;
+
+        try {
+            const response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 800,
+                messages: [
+                    { role: 'user', content: RESOLUTION_PROMPT + '\n\n' + userPrompt }
+                ]
+            });
+
+            const content = response.content[0].text;
+            const analysis = JSON.parse(content);
+
+            return {
+                ...analysis,
+                marketAddress: market.address,
+                analyzedAt: Date.now()
+            };
+        } catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`Failed to parse AI response as JSON: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Batch analyze multiple markets for resolution
+     */
+    async analyzeMarkets(markets) {
+        const results = [];
+
+        for (const market of markets) {
+            try {
+                const analysis = await this.analyzeResolution(market);
+                results.push({
+                    success: true,
+                    market,
+                    analysis
+                });
+            } catch (error) {
+                results.push({
+                    success: false,
+                    market,
+                    error: error.message
+                });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Get markets that are ready to resolve
+     */
+    async findResolvableMarkets(markets, options = {}) {
+        const { minConfidence = 0.8 } = options;
+        const analyses = await this.analyzeMarkets(markets);
+
+        return analyses
+            .filter(r => r.success && r.analysis.canResolve && r.analysis.confidence >= minConfidence)
+            .map(r => ({
+                market: r.market,
+                outcome: r.analysis.outcome,
+                confidence: r.analysis.confidence,
+                reasoning: r.analysis.reasoning,
+                suggestedAction: r.analysis.suggestedAction
+            }));
+    }
+
+    /**
+     * Generate a resolution report for a market
+     */
+    async generateResolutionReport(market) {
+        const analysis = await this.analyzeResolution(market);
+
+        return {
+            market: {
+                address: market.address,
+                question: market.question,
+                category: market.category
+            },
+            resolution: {
+                canResolve: analysis.canResolve,
+                outcome: analysis.outcome,
+                confidence: analysis.confidence,
+                suggestedAction: analysis.suggestedAction
+            },
+            details: {
+                reasoning: analysis.reasoning,
+                sources: analysis.sources
+            },
+            meta: {
+                analyzedAt: new Date().toISOString(),
+                model: this.model
+            }
+        };
+    }
+}
+
+/**
+ * Factory function
+ */
+export function createResolver(apiKey = null) {
+    return new AIResolver(apiKey);
+}
+
+export default AIResolver;

package/src/ai/scorer.js

@@ -0,0 +1,184 @@
+// AI-powered news relevance scoring using Claude API
+// Scores incoming news items 0-100 on privacy relevance
+
+import Anthropic from '@anthropic-ai/sdk';
+import { getConfig } from '../config.js';
+
+const SCORING_PROMPT = `You are an expert at evaluating news relevance for a privacy-focused prediction market on Solana.
+
+Score news items from 0-100 based on their relevance to:
+- Privacy regulations (GDPR, CCPA, federal privacy laws)
+- Privacy technology (zero-knowledge proofs, encryption, confidential computing)
+- Privacy tools (Tor, Signal, privacy coins, mixers like Tornado Cash)
+- Data protection (breaches, surveillance, data rights)
+- Blockchain privacy (Solana privacy features, Token-2022 confidential transfers)
+- Crypto regulations affecting privacy (sanctions, KYC requirements)
+
+Scoring guidelines:
+- 90-100: Directly about privacy regulation/technology, major impact, breaking news
+- 70-89: Strongly privacy-related, significant developments
+- 50-69: Moderately relevant, tangential privacy implications
+- 30-49: Loosely related, minor privacy angle
+- 0-29: Not relevant or very weak connection
+
+Also suggest if this news could generate an interesting prediction market.
+
+Respond with valid JSON only, no markdown formatting:
+{
+  "score": 0-100,
+  "category": "regulation"|"technology"|"adoption"|"events"|"none",
+  "urgency": "breaking"|"timely"|"evergreen",
+  "marketPotential": true/false,
+  "reasoning": "Brief explanation of the score",
+  "suggestedMarketAngle": "If marketPotential is true, a brief market idea"
+}`;
+
+export class AIScorer {
+    constructor(apiKey = null) {
+        const config = getConfig();
+        this.apiKey = apiKey || config.anthropicApiKey;
+
+        if (!this.apiKey) {
+            throw new Error('ANTHROPIC_API_KEY is required for AI scoring');
+        }
+
+        this.client = new Anthropic({ apiKey: this.apiKey });
+        this.model = 'claude-haiku-4-20250514'; // Use Haiku for speed/cost on scoring
+        this.cache = new Map(); // Simple cache for repeated items
+    }
+
+    /**
+     * Score a single news item
+     */
+    async scoreNews(newsItem) {
+        const { title, summary, source } = newsItem;
+
+        // Check cache
+        const cacheKey = title.toLowerCase().trim();
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+
+        const userPrompt = `Score this news item for privacy relevance:
+
+Title: ${title}
+${summary ? `Summary: ${summary}` : ''}
+${source ? `Source: ${source}` : ''}`;
+
+        try {
+            const response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 300,
+                messages: [
+                    { role: 'user', content: SCORING_PROMPT + '\n\n' + userPrompt }
+                ]
+            });
+
+            const content = response.content[0].text;
+            const result = JSON.parse(content);
+
+            const scored = {
+                ...result,
+                newsItem: { title, source },
+                scoredAt: Date.now()
+            };
+
+            // Cache result
+            this.cache.set(cacheKey, scored);
+
+            return scored;
+        } catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`Failed to parse AI response as JSON: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Score multiple news items in batch
+     */
+    async scoreBatch(newsItems) {
+        const results = [];
+
+        for (const item of newsItems) {
+            try {
+                const score = await this.scoreNews(item);
+                results.push({ success: true, ...score });
+            } catch (error) {
+                results.push({
+                    success: false,
+                    error: error.message,
+                    newsItem: item
+                });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Filter news items by minimum score
+     */
+    async filterByRelevance(newsItems, minScore = 50) {
+        const scored = await this.scoreBatch(newsItems);
+
+        return scored
+            .filter(r => r.success && r.score >= minScore)
+            .sort((a, b) => b.score - a.score);
+    }
+
+    /**
+     * Get high-potential market candidates from news
+     */
+    async findMarketCandidates(newsItems, options = {}) {
+        const { minScore = 60 } = options;
+        const scored = await this.scoreBatch(newsItems);
+
+        return scored
+            .filter(r => r.success && r.marketPotential && r.score >= minScore)
+            .sort((a, b) => b.score - a.score)
+            .map(r => ({
+                title: r.newsItem.title,
+                source: r.newsItem.source,
+                score: r.score,
+                category: r.category,
+                urgency: r.urgency,
+                marketAngle: r.suggestedMarketAngle
+            }));
+    }
+
+    /**
+     * Clear the score cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+
+    /**
+     * Get cache stats
+     */
+    getCacheStats() {
+        return {
+            size: this.cache.size,
+            entries: Array.from(this.cache.keys())
+        };
+    }
+}
+
+/**
+ * Factory function
+ */
+export function createScorer(apiKey = null) {
+    return new AIScorer(apiKey);
+}
+
+/**
+ * Quick scoring function for single items
+ */
+export async function quickScore(newsItem, apiKey = null) {
+    const scorer = new AIScorer(apiKey);
+    return scorer.scoreNews(newsItem);
+}
+
+export default AIScorer;