pnpfucius 2.0.0

package/src/collateral/privacy-tokens.js

@@ -0,0 +1,183 @@
+// Privacy token collateral support for prediction markets
+// Supports Token-2022 confidential transfers and configurable collateral
+
+import { PublicKey, Connection } from '@solana/web3.js';
+
+// Known token addresses
+export const TOKENS = {
+    mainnet: {
+        // Standard stablecoins
+        USDC: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+        USDT: 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB',
+
+        // Native SOL (wrapped)
+        WSOL: 'So11111111111111111111111111111111111111112',
+
+        // Token-2022 program ID for reference
+        TOKEN_2022_PROGRAM: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb'
+    },
+    devnet: {
+        // Devnet USDC
+        USDC: '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU',
+
+        // Wrapped SOL
+        WSOL: 'So11111111111111111111111111111111111111112',
+
+        // Token-2022 program ID
+        TOKEN_2022_PROGRAM: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb'
+    }
+};
+
+// Privacy-focused token metadata
+export const PRIVACY_TOKEN_INFO = {
+    // These would be mints with confidential transfer extension enabled
+    // In practice, you'd register actual Token-2022 confidential mints here
+    description: `
+        Privacy-focused collateral support for the PNP bounty requirement.
+
+        Solana's native privacy mechanism is the Token-2022 Confidential Transfer extension,
+        which provides:
+        - Encrypted balances using ElGamal encryption
+        - Zero-knowledge proofs for transfer validity
+        - Optional auditor key for compliance
+
+        To use privacy-focused collateral:
+        1. Use a Token-2022 mint with confidential transfer extension enabled
+        2. Configure the mint address in COLLATERAL_TOKEN env variable
+        3. Ensure your wallet has configured confidential transfer on the account
+    `
+};
+
+export function getCollateralMint(symbol, network = 'devnet') {
+    const tokens = TOKENS[network] || TOKENS.devnet;
+
+    // Check if it's a known symbol
+    if (tokens[symbol]) {
+        return new PublicKey(tokens[symbol]);
+    }
+
+    // Try to parse as a direct public key
+    try {
+        return new PublicKey(symbol);
+    } catch {
+        throw new Error(`Unknown token: ${symbol}. Use a token symbol (USDC, USDT) or a valid mint address.`);
+    }
+}
+
+export function listSupportedTokens(network = 'devnet') {
+    const tokens = TOKENS[network] || TOKENS.devnet;
+
+    return Object.entries(tokens)
+        .filter(([key]) => key !== 'TOKEN_2022_PROGRAM')
+        .map(([symbol, address]) => ({
+            symbol,
+            address,
+            network
+        }));
+}
+
+// Check if a mint supports Token-2022 confidential transfers
+export async function checkConfidentialTransferSupport(connection, mintAddress) {
+    try {
+        const mint = new PublicKey(mintAddress);
+        const accountInfo = await connection.getAccountInfo(mint);
+
+        if (!accountInfo) {
+            return { supported: false, reason: 'Mint account not found' };
+        }
+
+        // Check if owned by Token-2022 program
+        const token2022Program = new PublicKey(TOKENS.mainnet.TOKEN_2022_PROGRAM);
+        const isToken2022 = accountInfo.owner.equals(token2022Program);
+
+        if (!isToken2022) {
+            return {
+                supported: false,
+                reason: 'Not a Token-2022 mint',
+                isToken2022: false
+            };
+        }
+
+        // Token-2022 mints have extension data
+        // The confidential transfer extension has type discriminator 10
+        // This is a simplified check - full implementation would parse extensions
+        const hasExtensions = accountInfo.data.length > 82; // Base mint is 82 bytes
+
+        return {
+            supported: hasExtensions,
+            isToken2022: true,
+            reason: hasExtensions
+                ? 'Token-2022 mint with extensions (may support confidential transfers)'
+                : 'Token-2022 mint without extensions'
+        };
+    } catch (error) {
+        return {
+            supported: false,
+            reason: `Error checking mint: ${error.message}`
+        };
+    }
+}
+
+// Get token info including decimals
+export async function getTokenInfo(connection, mintAddress) {
+    try {
+        const mint = new PublicKey(mintAddress);
+        const accountInfo = await connection.getAccountInfo(mint);
+
+        if (!accountInfo) {
+            throw new Error('Mint not found');
+        }
+
+        // Parse basic mint data (works for both Token and Token-2022)
+        // Mint structure: mintAuthorityOption (4) + mintAuthority (32) + supply (8) + decimals (1) + ...
+        const data = accountInfo.data;
+        const decimals = data[44]; // Offset to decimals field
+
+        return {
+            address: mintAddress,
+            decimals,
+            owner: accountInfo.owner.toBase58()
+        };
+    } catch (error) {
+        throw new Error(`Failed to get token info: ${error.message}`);
+    }
+}
+
+// Format amount with decimals
+export function formatTokenAmount(amount, decimals) {
+    const divisor = BigInt(10 ** decimals);
+    const wholePart = amount / divisor;
+    const fractionalPart = amount % divisor;
+
+    if (fractionalPart === 0n) {
+        return wholePart.toString();
+    }
+
+    const fractionalStr = fractionalPart.toString().padStart(decimals, '0');
+    const trimmed = fractionalStr.replace(/0+$/, '');
+
+    return `${wholePart}.${trimmed}`;
+}
+
+// Parse amount string to base units
+export function parseTokenAmount(amountStr, decimals) {
+    const [whole, fraction = ''] = amountStr.split('.');
+    const paddedFraction = fraction.padEnd(decimals, '0').slice(0, decimals);
+
+    return BigInt(whole + paddedFraction);
+}
+
+// Collateral configuration helper
+export function getCollateralConfig(config = {}) {
+    const network = config.network || process.env.NETWORK || 'devnet';
+    const tokenSymbol = config.token || process.env.COLLATERAL_TOKEN || 'USDC';
+
+    const mint = getCollateralMint(tokenSymbol, network);
+
+    return {
+        mint,
+        symbol: tokenSymbol,
+        network,
+        preferConfidential: config.preferConfidential || process.env.PREFER_CONFIDENTIAL_COLLATERAL === 'true'
+    };
+}

package/src/config.js

@@ -0,0 +1,128 @@
+import dotenv from 'dotenv';
+import { PublicKey } from '@solana/web3.js';
+
+dotenv.config();
+
+// Token addresses
+const USDC_MAINNET = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
+const USDC_DEVNET = '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU';
+
+// Get collateral mint based on config
+function getCollateralMintAddress(network, tokenSymbol) {
+    const isMainnet = network === 'mainnet';
+
+    // If a specific token is configured, try to use it
+    if (tokenSymbol && tokenSymbol !== 'USDC') {
+        // Try to parse as public key
+        try {
+            return new PublicKey(tokenSymbol);
+        } catch {
+            // Fall back to USDC
+        }
+    }
+
+    return new PublicKey(isMainnet ? USDC_MAINNET : USDC_DEVNET);
+}
+
+export function getConfig() {
+    const network = process.env.NETWORK || 'devnet';
+    const isMainnet = network === 'mainnet';
+
+    const heliusKey = process.env.HELIUS_API_KEY;
+    if (!heliusKey) {
+        console.warn('Warning: HELIUS_API_KEY not set. Using public RPC (rate limited).');
+    }
+
+    const rpcUrl = heliusKey
+        ? `https://${isMainnet ? 'mainnet' : 'devnet'}.helius-rpc.com/?api-key=${heliusKey}`
+        : `https://api.${isMainnet ? 'mainnet-beta' : 'devnet'}.solana.com`;
+
+    const walletKey = process.env.WALLET_PRIVATE_KEY || process.env.PRIVATE_KEY;
+    const collateralToken = process.env.COLLATERAL_TOKEN || 'USDC';
+
+    return {
+        // Network
+        network,
+        isMainnet,
+        rpcUrl,
+        heliusKey,
+        walletKey,
+
+        // Collateral
+        collateralMint: getCollateralMintAddress(network, collateralToken),
+        collateralToken,
+        preferConfidential: process.env.PREFER_CONFIDENTIAL_COLLATERAL === 'true',
+
+        // Market defaults
+        defaultLiquidity: BigInt(process.env.DEFAULT_LIQUIDITY || '1000000'),
+        defaultDurationDays: parseInt(process.env.DEFAULT_DURATION_DAYS || '30', 10),
+        proxyBaseUrl: process.env.PNP_PROXY_URL || 'https://api.pnp.exchange',
+
+        // Daemon settings
+        daemon: {
+            schedule: process.env.DAEMON_SCHEDULE || '1h',
+            marketsPerRound: parseInt(process.env.DAEMON_MARKETS_PER_ROUND || '1', 10),
+            storagePath: process.env.DAEMON_STORAGE_PATH || null
+        },
+
+        // News monitoring
+        news: {
+            enabled: process.env.NEWS_ENABLED === 'true',
+            checkInterval: parseInt(process.env.NEWS_CHECK_INTERVAL || '300000', 10)
+        },
+
+        // Webhook server
+        webhook: {
+            enabled: process.env.WEBHOOK_ENABLED === 'true',
+            port: parseInt(process.env.WEBHOOK_PORT || '3000', 10),
+            authToken: process.env.WEBHOOK_AUTH_TOKEN || null
+        },
+
+        // AI settings
+        anthropicApiKey: process.env.ANTHROPIC_API_KEY || null,
+        ai: {
+            enabled: process.env.AI_ENABLED !== 'false',
+            minRelevanceScore: parseInt(process.env.AI_MIN_RELEVANCE_SCORE || '50', 10)
+        }
+    };
+}
+
+export function validateConfig(config) {
+    const errors = [];
+    const warnings = [];
+
+    if (!config.walletKey) {
+        errors.push('WALLET_PRIVATE_KEY or PRIVATE_KEY is required for creating markets');
+    }
+
+    if (!config.heliusKey) {
+        warnings.push('HELIUS_API_KEY not set - using public RPC (rate limited)');
+    }
+
+    if (config.webhook.enabled && !config.webhook.authToken) {
+        warnings.push('WEBHOOK_AUTH_TOKEN not set - webhook endpoints are unprotected');
+    }
+
+    if (config.ai.enabled && !config.anthropicApiKey) {
+        warnings.push('ANTHROPIC_API_KEY not set - AI features will be unavailable');
+    }
+
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings
+    };
+}
+
+// Get Helius websocket URL
+export function getHeliusWsUrl(config) {
+    if (!config.heliusKey) return null;
+
+    const network = config.isMainnet ? 'mainnet' : 'devnet';
+    return `wss://${network}.helius-rpc.com/?api-key=${config.heliusKey}`;
+}
+
+// Get Helius API URL (for REST endpoints)
+export function getHeliusApiUrl() {
+    return 'https://api.helius.xyz/v0';
+}

package/src/daemon/index.js

@@ -0,0 +1,321 @@
+// Main daemon orchestrator for autonomous market creation
+// Coordinates agent, storage, scheduling, news monitoring, and webhooks
+
+import { PrivacyOracleAgent } from '../agent.js';
+import { Scheduler } from './scheduler.js';
+import { setupGracefulShutdown, HealthMonitor } from './lifecycle.js';
+import { agentEvents, AgentEvents } from '../events/emitter.js';
+import { MarketStore } from '../storage/market-store.js';
+import { NewsMonitor } from '../monitoring/news-monitor.js';
+import { WebhookServer } from '../helius/webhooks.js';
+import { getConfig } from '../config.js';
+
+export class PrivacyOracleDaemon {
+    constructor(config = {}) {
+        this.config = {
+            schedule: config.schedule || '1h',
+            maxIterations: config.maxIterations || null,
+            marketsPerRound: config.marketsPerRound || 1,
+            dryRun: config.dryRun || false,
+            enableNewsMonitoring: config.enableNewsMonitoring || false,
+            enableWebhooks: config.enableWebhooks || false,
+            webhookPort: config.webhookPort || 3000,
+            storagePath: config.storagePath || null,
+            verbose: config.verbose || false,
+            ...config
+        };
+
+        this.agent = null;
+        this.scheduler = new Scheduler();
+        this.store = null;
+        this.newsMonitor = null;
+        this.webhookServer = null;
+        this.healthMonitor = null;
+        this.lifecycle = null;
+
+        this.isRunning = false;
+        this.iterationCount = 0;
+        this.startTime = null;
+    }
+
+    log(message, level = 'info') {
+        if (this.config.verbose || level === 'error') {
+            const prefix = level === 'error' ? '[ERROR]' : '[DAEMON]';
+            console.log(`${prefix} ${message}`);
+        }
+    }
+
+    async start() {
+        if (this.isRunning) {
+            throw new Error('Daemon is already running');
+        }
+
+        this.startTime = Date.now();
+        this.log('Starting Privacy Oracle Daemon...');
+
+        // 1. Initialize agent
+        const agentConfig = getConfig();
+        this.agent = new PrivacyOracleAgent({
+            config: agentConfig,
+            verbose: this.config.verbose
+        });
+        await this.agent.initialize();
+        this.log('Agent initialized');
+
+        // 2. Initialize storage
+        this.store = new MarketStore({ storagePath: this.config.storagePath });
+        await this.store.initialize();
+        this.log('Storage initialized');
+
+        // 3. Restore state if available
+        await this.restoreState();
+
+        // 4. Setup graceful shutdown
+        this.lifecycle = setupGracefulShutdown(this, { timeout: 30000 });
+
+        // 5. Start health monitoring
+        this.healthMonitor = new HealthMonitor({
+            checkInterval: 60000,
+            maxMemoryMB: 512,
+            onUnhealthy: (health) => {
+                this.log(`Health check failed: ${health.issues.join(', ')}`, 'error');
+            }
+        });
+        this.healthMonitor.start();
+
+        // 6. Optionally start news monitoring
+        if (this.config.enableNewsMonitoring) {
+            this.newsMonitor = new NewsMonitor();
+            await this.newsMonitor.start();
+            this.log('News monitoring started');
+        }
+
+        // 7. Optionally start webhook server
+        if (this.config.enableWebhooks) {
+            this.webhookServer = new WebhookServer({
+                port: this.config.webhookPort,
+                authToken: process.env.WEBHOOK_AUTH_TOKEN
+            });
+
+            // Register handlers
+            this.webhookServer.on('getStats', () => this.store.getStats());
+            this.webhookServer.on('getMarkets', (opts) => this.store.getAllMarkets(opts));
+
+            await this.webhookServer.start();
+            this.log(`Webhook server started on port ${this.config.webhookPort}`);
+        }
+
+        // 8. Schedule main market creation task
+        this.scheduler.addTask({
+            name: 'market-creation',
+            schedule: this.config.schedule,
+            task: () => this.executeCycle(),
+            runImmediately: true
+        });
+
+        this.scheduler.start();
+        this.isRunning = true;
+
+        agentEvents.emitTyped(AgentEvents.DAEMON_STARTED, {
+            config: this.config,
+            startTime: this.startTime
+        });
+
+        this.log('Daemon started successfully');
+        return this;
+    }
+
+    async executeCycle() {
+        // Check iteration limit
+        if (this.config.maxIterations && this.iterationCount >= this.config.maxIterations) {
+            this.log(`Reached max iterations (${this.config.maxIterations}), stopping...`);
+            await this.stop();
+            return;
+        }
+
+        this.iterationCount++;
+        const cycleStart = Date.now();
+
+        agentEvents.emitTyped(AgentEvents.CYCLE_START, {
+            iteration: this.iterationCount,
+            timestamp: cycleStart
+        });
+
+        this.log(`Starting cycle ${this.iterationCount}...`);
+
+        try {
+            // Get news context if available
+            let newsContext = null;
+            if (this.newsMonitor) {
+                newsContext = this.newsMonitor.getRecentEvents(5);
+                if (newsContext.length > 0) {
+                    this.log(`Found ${newsContext.length} relevant news events`);
+                }
+            }
+
+            // Generate and create markets
+            const results = [];
+
+            if (this.config.dryRun) {
+                // Dry run - just generate ideas
+                const { generateMultipleMarkets } = await import('../privacy-markets.js');
+                const ideas = generateMultipleMarkets(this.config.marketsPerRound);
+
+                for (const idea of ideas) {
+                    this.log(`[DRY RUN] Would create: ${idea.question}`);
+                    results.push({
+                        success: true,
+                        dryRun: true,
+                        question: idea.question,
+                        category: idea.category
+                    });
+                }
+            } else {
+                // Actually create markets
+                const batchResults = await this.agent.createBatchMarkets(this.config.marketsPerRound);
+
+                for (const result of batchResults) {
+                    if (result.success) {
+                        // Store in database
+                        await this.store.saveMarket({
+                            address: result.market,
+                            question: result.question,
+                            category: result.category,
+                            categoryKey: result.categoryKey,
+                            creationTime: Date.now(),
+                            creationSignature: result.signature,
+                            initialLiquidity: result.liquidity,
+                            durationDays: result.durationDays,
+                            status: 'active',
+                            metadata: { newsContext, iteration: this.iterationCount }
+                        });
+
+                        agentEvents.emitTyped(AgentEvents.MARKET_CREATED, result);
+                        this.log(`Created market: ${result.market}`);
+                    } else {
+                        agentEvents.emitTyped(AgentEvents.MARKET_FAILED, result);
+                        this.log(`Failed to create market: ${result.error}`, 'error');
+                    }
+
+                    results.push(result);
+                }
+            }
+
+            // Save state after each cycle
+            await this.saveState();
+
+            const cycleDuration = Date.now() - cycleStart;
+
+            agentEvents.emitTyped(AgentEvents.CYCLE_COMPLETE, {
+                iteration: this.iterationCount,
+                results,
+                duration: cycleDuration,
+                successCount: results.filter(r => r.success).length,
+                failCount: results.filter(r => !r.success).length
+            });
+
+            this.log(`Cycle ${this.iterationCount} complete (${cycleDuration}ms)`);
+
+        } catch (error) {
+            agentEvents.emitTyped(AgentEvents.CYCLE_ERROR, {
+                iteration: this.iterationCount,
+                error: error.message
+            });
+
+            this.log(`Cycle ${this.iterationCount} failed: ${error.message}`, 'error');
+        }
+    }
+
+    async stop() {
+        if (!this.isRunning) return;
+
+        this.log('Stopping daemon...');
+
+        // Stop scheduler
+        this.scheduler.stop();
+
+        // Stop news monitoring
+        if (this.newsMonitor) {
+            await this.newsMonitor.stop();
+        }
+
+        // Stop webhook server
+        if (this.webhookServer) {
+            await this.webhookServer.stop();
+        }
+
+        // Stop health monitor
+        if (this.healthMonitor) {
+            this.healthMonitor.stop();
+        }
+
+        // Save final state
+        await this.saveState();
+
+        // Close storage
+        if (this.store) {
+            await this.store.close();
+        }
+
+        this.isRunning = false;
+
+        agentEvents.emitTyped(AgentEvents.DAEMON_STOPPED, {
+            totalIterations: this.iterationCount,
+            uptime: Date.now() - this.startTime
+        });
+
+        this.log('Daemon stopped');
+    }
+
+    async saveState() {
+        if (!this.store) return;
+
+        const state = {
+            iterationCount: this.iterationCount,
+            lastRunTime: Date.now(),
+            config: {
+                schedule: this.config.schedule,
+                marketsPerRound: this.config.marketsPerRound
+            }
+        };
+
+        await this.store.saveState('daemon', state);
+        agentEvents.emitTyped(AgentEvents.STATE_SAVED, state);
+    }
+
+    async restoreState() {
+        if (!this.store) return null;
+
+        try {
+            const state = await this.store.getState('daemon');
+
+            if (state) {
+                this.iterationCount = state.iterationCount || 0;
+                this.log(`Restored state: ${this.iterationCount} previous iterations`);
+
+                agentEvents.emitTyped(AgentEvents.STATE_RESTORED, state);
+                return state;
+            }
+        } catch (error) {
+            this.log('No previous state found, starting fresh');
+        }
+
+        return null;
+    }
+
+    getStatus() {
+        return {
+            isRunning: this.isRunning,
+            iterationCount: this.iterationCount,
+            startTime: this.startTime,
+            uptime: this.startTime ? Date.now() - this.startTime : 0,
+            config: this.config,
+            scheduler: this.scheduler.getAllTasks(),
+            health: this.healthMonitor?.getHealth() || null
+        };
+    }
+}
+
+export function createDaemon(config) {
+    return new PrivacyOracleDaemon(config);
+}