Upload builderbrain/pipeline.py

builderbrain/pipeline.py

@@ -0,0 +1,377 @@
+"""
+BuilderBrain Main Pipeline
+==========================
+
+End-to-end flow:
+1. Ingest prediction market data (Polymarket + others)
+2. Generate reasoning traces for each market
+3. Compute correlation-aware Kelly positions
+4. Route orders via builder codes
+5. Settle via Arc (Gateway, Nanopayments, USYC)
+6. Log reasoning traces on-chain as artifacts
+
+Usage:
+    brain = BuilderBrain(bankroll_usd=10000)
+    brain.run_cycle()
+    signals = brain.get_signals()
+"""
+
+import json
+from typing import List, Dict, Optional
+from datetime import datetime
+
+from .quant_engine import KellyEngine, MarketEdge, Position
+from .polymarket_client import PolymarketClient, BuilderCodeRouter, PolymarketMarket
+from .reasoning_agent import ReasoningAgent, TradeSignal, ReasoningTrace
+from .arc_bridge import ArcBridge
+
+
+class BuilderBrain:
+    """
+    Main orchestrator for the BuilderBrain agent.
+    
+    Combines:
+    - Quant engine (Kelly sizing, correlation matrix)
+    - Reasoning agent (structured argumentation, risk assessment)
+    - Polymarket client (market data, builder code routing)
+    - Arc bridge (settlement, nanopayments, USYC)
+    """
+    
+    def __init__(
+        self,
+        bankroll_usd: float = 10000.0,
+        paper_trade: bool = True,
+        builder_code: str = "builderbrain_default",
+        min_edge: float = 0.03,
+        max_positions: int = 20,
+    ):
+        self.bankroll = bankroll_usd
+        self.paper_trade = paper_trade
+        self.max_positions = max_positions
+        
+        # Components
+        self.quant = KellyEngine(
+            bankroll_usd=bankroll_usd,
+            min_edge=min_edge,
+        )
+        self.reasoning = ReasoningAgent()
+        self.polymarket = PolymarketClient(paper_trade=paper_trade)
+        self.router = BuilderCodeRouter(self.polymarket)
+        self.arc = ArcBridge()
+        
+        # Register default builder code
+        self.polymarket.register_builder_code(
+            code=builder_code,
+            name="BuilderBrain Intelligence",
+            description="AI-generated prediction market intelligence with Kelly sizing",
+            fee_share_bps=10,
+        )
+        self.default_builder_code = builder_code
+        
+        # State
+        self.signals: List[TradeSignal] = []
+        self.positions: List[Position] = []
+        self.cycle_count = 0
+        self.paper_pnl = 0.0
+    
+    # ────────────────────────────── Main Cycle ──────────────────────────────
+    
+    def run_cycle(self, category: Optional[str] = None) -> List[TradeSignal]:
+        """
+        Execute one full intelligence → sizing → routing → settlement cycle.
+        
+        Returns list of trade signals generated.
+        """
+        print(f"\n{'='*60}")
+        print(f"BuilderBrain Cycle #{self.cycle_count + 1}")
+        print(f"{'='*60}")
+        
+        # 1. Fetch markets
+        markets = self._fetch_markets(category)
+        if not markets:
+            print("[BuilderBrain] No markets fetched")
+            return []
+        
+        print(f"[BuilderBrain] Fetched {len(markets)} markets")
+        
+        # 2. Generate edges + reasoning
+        edges = self._generate_edges(markets)
+        print(f"[BuilderBrain] Generated {len(edges)} viable edges")
+        
+        # 3. Kelly sizing
+        positions = self.quant.size_positions(edges)
+        print(f"[BuilderBrain] Sized {len(positions)} positions")
+        
+        # 4. Route orders
+        signals = self._route_positions(positions)
+        print(f"[BuilderBrain] Generated {len(signals)} trade signals")
+        
+        # 5. Settle via Arc
+        self._settle_signals(signals)
+        
+        # 6. Update state
+        self.signals.extend(signals)
+        self.positions.extend(positions)
+        self.cycle_count += 1
+        
+        return signals
+    
+    def _fetch_markets(self, category: Optional[str]) -> List[PolymarketMarket]:
+        """Fetch live markets from Polymarket."""
+        return self.polymarket.fetch_markets(
+            active=True,
+            limit=50,
+            category=category,
+        )
+    
+    def _generate_edges(self, markets: List[PolymarketMarket]) -> List[MarketEdge]:
+        """
+        Convert Polymarket markets to MarketEdge objects with model probabilities.
+        
+        In production, this would:
+        - Run NLP models on news/social
+        - Query prediction models
+        - Cross-reference with historical patterns
+        
+        For hackathon, we simulate model probabilities with structured logic.
+        """
+        edges = []
+        
+        for m in markets:
+            # Simulate model probability based on market characteristics
+            # In reality, this comes from your quant models
+            model_prob = self._simulate_model_prob(m)
+            
+            # Determine which side has edge
+            yes_edge = model_prob - m.implied_yes_prob
+            no_edge = (1 - model_prob) - m.best_no_price
+            
+            # Take the side with larger edge
+            if yes_edge > abs(no_edge):
+                side = "YES"
+                edge = yes_edge
+                market_prob = m.implied_yes_prob
+            else:
+                side = "NO"
+                edge = no_edge
+                market_prob = m.best_no_price
+            
+            # Skip if edge too small
+            if abs(edge) < self.quant.min_edge:
+                continue
+            
+            # Determine theme from category
+            theme = self._categorize_theme(m.category, m.question)
+            
+            edges.append(MarketEdge(
+                market_id=m.market_id,
+                title=m.question,
+                theme=theme,
+                side=side,
+                edge=edge,
+                market_prob=market_prob,
+                model_prob=model_prob if side == "YES" else 1 - model_prob,
+                liquidity_usd=m.liquidity,
+                expires_at=m.end_date,
+            ))
+        
+        return edges
+    
+    def _simulate_model_prob(self, market: PolymarketMarket) -> float:
+        """
+        Simulate a model probability for a market.
+        
+        In production, this queries your actual prediction models.
+        For hackathon demo, we add structured noise to market price
+        to simulate "edge detection."
+        """
+        import random
+        
+        # Base: market price is ~efficient, but we find small edges
+        base = market.implied_yes_prob
+        
+        # Add structured noise based on market characteristics
+        # More liquid markets = less edge (more efficient)
+        liquidity_factor = 1 / (1 + market.liquidity / 100000)
+        
+        # Volatility factor: high spread = more uncertainty = more edge potential
+        spread_factor = market.spread * 2
+        
+        # Simulate edge: ±5-15% on illiquid markets, ±2-5% on liquid
+        noise = random.gauss(0, 0.03 * liquidity_factor + 0.01 * spread_factor)
+        noise = max(-0.15, min(0.15, noise))  # Cap extreme noise
+        
+        model_prob = base + noise
+        return max(0.01, min(0.99, model_prob))
+    
+    def _categorize_theme(self, category: str, question: str) -> str:
+        """Map market to theme block."""
+        cat_lower = category.lower()
+        q_lower = question.lower()
+        
+        if any(w in q_lower for w in ['trump', 'election', 'biden', 'congress', 'vote']):
+            return 'politics'
+        elif any(w in q_lower for w in ['btc', 'bitcoin', 'eth', 'ethereum', 'crypto', 'etf']):
+            return 'crypto'
+        elif any(w in q_lower for w in ['super bowl', 'nba', 'world cup', 'champion']):
+            return 'sports'
+        elif any(w in q_lower for w in ['fed', 'cpi', 'recession', 'oil', 'rate']):
+            return 'macro'
+        elif 'politics' in cat_lower:
+            return 'politics'
+        elif 'crypto' in cat_lower:
+            return 'crypto'
+        elif 'sports' in cat_lower:
+            return 'sports'
+        else:
+            return 'other'
+    
+    def _route_positions(self, positions: List[Position]) -> List[TradeSignal]:
+        """Route sized positions through reasoning + builder codes."""
+        signals = []
+        
+        for pos in positions[:self.max_positions]:
+            # Generate reasoning trace
+            trace = self.reasoning.reason_about_market(
+                market_id=pos.market_id,
+                market_title=pos.market_id,  # Would fetch actual title
+                market_prob=0.5,  # Would fetch actual
+                model_prob=0.5 + pos.edge,
+                data_sources=[
+                    {
+                        "source_type": "polymarket",
+                        "source_id": f"gamma/{pos.market_id}",
+                        "timestamp": datetime.utcnow().isoformat(),
+                        "data_summary": f"Market price: {0.5}, Our model: {0.5 + pos.edge}",
+                        "relevance_score": 0.9,
+                    }
+                ],
+                theme=self._categorize_theme("", pos.market_id),
+            )
+            
+            # Generate trade signal
+            signal = self.reasoning.generate_signal(
+                trace=trace,
+                kelly_fraction=pos.fraction_of_bankroll,
+                expected_return=pos.expected_return,
+            )
+            
+            # Link builder code
+            trace.builder_code = self.default_builder_code
+            
+            # Route order via Polymarket
+            size_usd = pos.fraction_of_bankroll * self.bankroll
+            
+            # Find market in polymarket client
+            pm_market = None
+            for m in self.polymarket.fetch_markets(limit=100):
+                if m.market_id == pos.market_id:
+                    pm_market = m
+                    break
+            
+            if pm_market:
+                result = self.router.route_with_intent(
+                    market=pm_market,
+                    side="BUY",
+                    outcome=pos.side,
+                    size_usd=size_usd,
+                    price=pm_market.best_yes_price if pos.side == "YES" else pm_market.best_no_price,
+                )
+                
+                if result.get("status") == "FILLED":
+                    trace.executed = True
+                    trace.execution_tx = result.get("order_id")
+            
+            signals.append(signal)
+        
+        return signals
+    
+    def _settle_signals(self, signals: List[TradeSignal]):
+        """Settle generated signals via Arc infrastructure."""
+        for signal in signals:
+            # Charge per-trade nanopayment
+            notional = signal.size_fraction * self.bankroll
+            self.arc.charge_trade_fee(
+                user_id="default_user",
+                trade_id=signal.reasoning_trace.trace_id,
+                notional_usd=notional,
+            )
+            
+            # Charge per-insight fee
+            self.arc.charge_insight_fee(
+                user_id="default_user",
+                trace_id=signal.reasoning_trace.trace_id,
+            )
+        
+        # Batch settle
+        if self.arc.pending_payments:
+            settlement = self.arc.batch_settle()
+            print(f"[Arc] Settled {settlement['settled']} payments = ${settlement['total_usd']:.4f}")
+    
+    # ────────────────────────────── Queries ──────────────────────────────
+    
+    def get_signals(self, min_confidence: float = 0.0) -> List[TradeSignal]:
+        """Get all generated trade signals."""
+        return [s for s in self.signals if s.confidence >= min_confidence]
+    
+    def get_top_signals(self, n: int = 10) -> List[TradeSignal]:
+        """Get top N signals by expected return."""
+        sorted_signals = sorted(self.signals, key=lambda s: s.expected_return, reverse=True)
+        return sorted_signals[:n]
+    
+    def get_portfolio_stats(self) -> Dict:
+        """Get current portfolio statistics."""
+        kelly_stats = self.quant.portfolio_stats(self.positions)
+        arc_stats = self.arc.stats()
+        reasoning_stats = self.reasoning.stats()
+        
+        return {
+            "cycle": self.cycle_count,
+            "bankroll_usd": self.bankroll,
+            "kelly": kelly_stats,
+            "arc": arc_stats,
+            "reasoning": reasoning_stats,
+            "paper_portfolio": self.polymarket.get_paper_portfolio(),
+            "total_signals": len(self.signals),
+            "total_traces": len(self.reasoning.trace_history),
+        }
+    
+    def export_audit_log(self, filepath: str = "builderbrain_audit.json"):
+        """Export complete audit log for on-chain anchoring."""
+        audit = {
+            "agent": "BuilderBrain",
+            "version": self.reasoning.agent_version,
+            "cycles": self.cycle_count,
+            "bankroll_usd": self.bankroll,
+            "signals": [
+                {
+                    "market_id": s.market_id,
+                    "side": s.side,
+                    "size": s.size_fraction,
+                    "expected_return": s.expected_return,
+                    "confidence": s.confidence,
+                    "urgency": s.urgency,
+                    "trace_hash": s.reasoning_trace.reasoning_hash,
+                    "executed": s.reasoning_trace.executed,
+                }
+                for s in self.signals
+            ],
+            "traces": [
+                {
+                    "trace_id": t.trace_id,
+                    "hash": t.reasoning_hash,
+                    "market": t.market_title,
+                    "edge": t.edge,
+                    "confidence": t.confidence,
+                    "arguments": len(t.arguments),
+                    "risks": len(t.risk_factors),
+                }
+                for t in self.reasoning.trace_history
+            ],
+            "timestamp": datetime.utcnow().isoformat(),
+        }
+        
+        with open(filepath, 'w') as f:
+            json.dump(audit, f, indent=2)
+        
+        return filepath