Add tests, alerts, and blockchain tracker

src/alerts.py

@@ -0,0 +1,62 @@
+import os
+import requests
+import logging
+
+logger = logging.getLogger(__name__)
+
+class AlertManager:
+    def __init__(self):
+        # Read Webhook URLs from environment
+        self.discord_webhook = os.environ.get("DISCORD_WEBHOOK_URL")
+        self.slack_webhook = os.environ.get("SLACK_WEBHOOK_URL")
+
+    def send_discord_alert(self, title: str, message: str, color: int = 5814783):
+        """Send a rich embed to Discord."""
+        if not self.discord_webhook:
+            logger.debug("Discord webhook not configured.")
+            return
+
+        payload = {
+            "embeds": [{
+                "title": title,
+                "description": message,
+                "color": color
+            }]
+        }
+        
+        try:
+            response = requests.post(self.discord_webhook, json=payload)
+            if response.status_code != 204:
+                logger.error(f"Failed to send Discord alert: {response.status_code}")
+        except Exception as e:
+            logger.error(f"Error sending Discord alert: {e}")
+
+    def send_slack_alert(self, title: str, message: str):
+        """Send a message to Slack."""
+        if not self.slack_webhook:
+            logger.debug("Slack webhook not configured.")
+            return
+
+        payload = {
+            "text": f"*{title}*\n{message}"
+        }
+        
+        try:
+            response = requests.post(self.slack_webhook, json=payload)
+            if response.status_code != 200:
+                logger.error(f"Failed to send Slack alert: {response.status_code}")
+        except Exception as e:
+            logger.error(f"Error sending Slack alert: {e}")
+            
+    def alert_arbitrage(self, opp: dict):
+        """Format and send an arbitrage opportunity alert."""
+        title = "🚨 New Arbitrage Opportunity Detected!"
+        msg = f"**{opp['event_name']}**\n"
+        msg += f"Buy on {opp['buy_platform']} @ ${opp['buy_price']}\n"
+        msg += f"Sell on {opp['sell_platform']} @ ${opp['sell_price']}\n"
+        msg += f"**Net Edge:** {opp['expected_profit_margin']*100:.2f}%\n"
+        msg += f"**Max Size:** ${opp['buy_size']:.2f}"
+        
+        # Color: Greenish for profit
+        self.send_discord_alert(title, msg, color=5763719)
+        self.send_slack_alert(title, msg)

src/blockchain.py

@@ -0,0 +1,89 @@
+import os
+import logging
+from web3 import Web3
+from typing import Callable, Optional
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+class BlockchainTracker:
+    def __init__(self):
+        """
+        Track whale movements on Polygon (Polymarket's native chain).
+        """
+        # Alchemy or Infura RPC URL for Polygon Mainnet
+        self.rpc_url = os.environ.get("POLYGON_RPC_URL", "https://polygon-rpc.com")
+        self.w3 = Web3(Web3.HTTPProvider(self.rpc_url))
+        
+        if self.w3.is_connected():
+             logger.info(f"Connected to Polygon Network via {self.rpc_url}")
+        else:
+             logger.error("Failed to connect to Polygon Network")
+
+        # USDC Token Contract on Polygon
+        self.usdc_address = self.w3.to_checksum_address("0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174")
+        
+        # Polymarket CTF Exchange Contract
+        self.poly_exchange = self.w3.to_checksum_address("0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E")
+
+        # Standard ERC20 Transfer ABI (reduced form)
+        self.erc20_abi = [
+            {
+                "anonymous": False,
+                "inputs": [
+                    {"indexed": True, "name": "from", "type": "address"},
+                    {"indexed": True, "name": "to", "type": "address"},
+                    {"indexed": False, "name": "value", "type": "uint256"}
+                ],
+                "name": "Transfer",
+                "type": "event"
+            }
+        ]
+        
+        self.usdc_contract = self.w3.eth.contract(address=self.usdc_address, abi=self.erc20_abi)
+
+    async def watch_whale_deposits(self, threshold_usdc: float = 100000.0, callback: Optional[Callable] = None):
+        """
+        Poll for large USDC transfers (whales) flowing into Polymarket.
+        Threshold defaults to 100k USDC (USDC has 6 decimals on Polygon).
+        """
+        threshold_wei = int(threshold_usdc * (10 ** 6))
+        
+        # Create a filter for Transfer events to the Polymarket exchange
+        # Note: In production, relying on direct get_logs polling can be rate limited. 
+        # WebSockets (WSS) and async Web3 is preferred.
+        
+        filter_params = {
+            'address': self.usdc_address,
+            'topics': [
+                self.w3.keccak(text="Transfer(address,address,uint256)").hex(),
+                None, # from any
+                "0x000000000000000000000000" + self.poly_exchange[2:] # to polymarket
+            ]
+        }
+        
+        latest_block = self.w3.eth.block_number
+        
+        while True:
+            try:
+                # Fetch logs from latest block
+                logs = self.w3.eth.get_logs({**filter_params, 'fromBlock': latest_block, 'toBlock': 'latest'})
+                
+                for log in logs:
+                    # value is not indexed, so it's in the data field
+                    value = int(log['data'].hex(), 16)
+                    
+                    if value >= threshold_wei:
+                         usdc_amount = value / (10 ** 6)
+                         sender = "0x" + log['topics'][1].hex()[-40:]
+                         logger.info(f"🐋 WHALE ALERT: {usdc_amount} USDC deposited to Polymarket by {sender}")
+                         
+                         if callback:
+                             callback(f"🐋 WHALE ALERT", f"${usdc_amount:,.2f} deposited to Polymarket by `{sender}`")
+                
+                latest_block = self.w3.eth.block_number + 1
+                
+            except Exception as e:
+                 logger.error(f"Blockchain poll error: {e}")
+                 
+            await asyncio.sleep(15) # Poll every 15 seconds (Polygon block time is ~2s)

tests/test_arbitrage.py

@@ -0,0 +1,44 @@
+import pytest
+from src.strategies.arbitrage import CrossPlatformArbitrage, IntraMarketArbitrage
+
+def test_cross_platform_arbitrage_profitable():
+    scanner = CrossPlatformArbitrage(min_profit_threshold=0.01)
+    
+    # State where Arb exists (Polymarket cheaper than Kalshi)
+    scanner.update_state('polymarket', '0x217...', bid=0.50, bid_size=1000, ask=0.52, ask_size=1000)
+    scanner.update_state('kalshi', 'KXUS2024', bid=0.55, bid_size=1500, ask=0.57, ask_size=500)
+    
+    opps = scanner.scan_opportunities()
+    
+    assert len(opps) == 1
+    opp = opps[0]
+    
+    assert opp.buy_platform == 'polymarket'
+    assert opp.sell_platform == 'kalshi'
+    assert opp.buy_price == 0.52
+    assert opp.sell_price == 0.55
+    assert opp.buy_size == 1000  # min of 1000 and 1500
+    assert opp.expected_profit_margin > 0.01 # Expect profit > min threshold
+
+def test_cross_platform_arbitrage_no_opportunity():
+    scanner = CrossPlatformArbitrage(min_profit_threshold=0.01)
+    
+    # Efficient market state
+    scanner.update_state('polymarket', '0x217...', bid=0.53, bid_size=1000, ask=0.54, ask_size=1000)
+    scanner.update_state('kalshi', 'KXUS2024', bid=0.53, bid_size=1500, ask=0.54, ask_size=500)
+    
+    opps = scanner.scan_opportunities()
+    assert len(opps) == 0
+
+def test_intra_market_arbitrage():
+    scanner = IntraMarketArbitrage(min_profit_threshold=0.01)
+    
+    # Parity violation: P(Yes) + P(No) = 0.45 + 0.45 = 0.90 < 1.0 (Margin = 0.10)
+    margin = scanner.check_parity_violation(ask_yes=0.45, ask_no=0.45)
+    
+    assert margin is not None
+    assert round(margin, 2) == 0.10
+    
+    # Efficient market: P(Yes) + P(No) = 0.52 + 0.52 = 1.04 > 1.0 (No Arb)
+    margin_eff = scanner.check_parity_violation(ask_yes=0.52, ask_no=0.52)
+    assert margin_eff is None

tests/test_bayesian.py

@@ -0,0 +1,35 @@
+import pytest
+from src.models.bayesian import BayesianFairValue
+
+def test_bayesian_fair_value_initialization():
+    model = BayesianFairValue(prior_prob=0.5, prior_confidence=10.0)
+    
+    assert model.get_fair_value() == 0.5
+    assert model.alpha == 5.0
+    assert model.beta == 5.0
+
+def test_bayesian_update():
+    model = BayesianFairValue(prior_prob=0.5, prior_confidence=10.0)
+    
+    # We observe a lot of volume trading at 0.70 implied probability
+    model.update(market_implied_prob=0.70, trade_volume=100.0, noise_factor=0.1)
+    
+    # FV should shift towards 0.70
+    fv = model.get_fair_value()
+    assert fv > 0.5
+    assert fv < 0.70
+    
+def test_evaluate_opportunity():
+    model = BayesianFairValue(prior_prob=0.6, prior_confidence=100.0) # Highly confident at 0.6
+    
+    # Market asks are way below FV (Underpriced)
+    opp_buy = model.evaluate_opportunity(current_ask=0.40, current_bid=0.38)
+    assert opp_buy is not None
+    assert opp_buy["action"] == "BUY_YES"
+    assert opp_buy["edge"] > 0.15 # 0.60 - 0.40 = 0.20ish edge
+    
+    # Market bids are way above FV (Overpriced)
+    opp_sell = model.evaluate_opportunity(current_ask=0.82, current_bid=0.80)
+    assert opp_sell is not None
+    assert opp_sell["action"] == "SELL_YES"
+    assert opp_sell["edge"] > 0.15 # 0.80 - 0.60 = 0.20ish edge

tests/test_kalman.py

@@ -0,0 +1,27 @@
+import pytest
+import numpy as np
+from src.models.kalman import KalmanPriceSmoother
+
+def test_kalman_filter_initialization():
+    filter = KalmanPriceSmoother()
+    assert filter.x is None
+    
+    filter.initialize(0.50)
+    assert filter.x == 0.50
+    assert filter.P == 1.0
+
+def test_kalman_filter_smoothing():
+    filter = KalmanPriceSmoother(process_variance=1e-4, measurement_variance=1e-2)
+    
+    # Simulate a stable price with a sudden noisy spike
+    prices = [0.50, 0.505, 0.495, 0.50, 0.51, 0.65, 0.50, 0.505]
+    
+    smoothed = filter.batch_smooth(np.array(prices))
+    
+    # The smoothed value at index 5 (0.65 spike) should be significantly lower than 0.65
+    # because the filter heavily trusts its prior state (0.50) and dampens the noise.
+    assert smoothed[5] < 0.65
+    assert smoothed[5] > 0.50 # It should move up slightly
+    
+    # The final smoothed value should quickly return near 0.50
+    assert abs(smoothed[-1] - 0.50) < 0.05