Market Maker Bot

def calculate_smart_prices(self, state: AssetState, current_price: float) -> tuple[float, float, float]:
    """Compute YES target, NO target, and spread using statistical model.
    
    P(YES) = Φ(z), where z = (price - strike) / (volatility × √time)
    """
    strike_usd = state.strike_price / 1e6
    seconds_remaining = state.market_end_time - int(time.time())
    
    # Deviation from strike
    return_deviation = (current_price - strike_usd) / strike_usd
    
    # Estimate volatility per sqrt-second from price tracker
    signals = state.price_tracker.get_signals()
    vol_per_sqrt_second = signals.volatility / math.sqrt(FAST_POLL_INTERVAL)
    
    # Floor at daily vol / sqrt(86400)
    min_daily_vol = 0.03  # 3% daily (typical BTC)
    min_vol = min_daily_vol / math.sqrt(86400)
    vol_per_sqrt_second = max(vol_per_sqrt_second, min_vol)
    
    # Expected volatility remaining
    expected_vol = vol_per_sqrt_second * math.sqrt(seconds_remaining)
    
    # Z-score
    z_score = return_deviation / expected_vol if expected_vol > 0 else 0.0
    
    # P(YES) = normal CDF
    yes_target = normal_cdf(z_score)
    
    return yes_target, 1.0 - yes_target, spread

class PriceTracker:
    def __init__(self, window_size: int = 60, max_age: float = 120.0):
        self.observations: deque[tuple[float, float]] = deque(maxlen=window_size)
    
    def get_signals(self) -> PriceSignals:
        # Velocity: price change per second (last 5 observations)
        velocity = (latest_price - first_price) / dt
        
        # Volatility: stddev of returns over window
        returns = [(obs[i] - obs[i-1]) / obs[i-1] for i in range(1, len(obs))]
        volatility = stdev(returns)
        
        # Momentum: EMA of velocity (trend direction)
        momentum = alpha * velocity + (1 - alpha) * last_ema
        
        return PriceSignals(velocity, volatility, momentum)

# Momentum adjustment
momentum_shift = signals.momentum * MOMENTUM_FACTOR / 1e6
yes_target += momentum_shift  # Lead the price

# Spread adjustments
spread *= (1.0 + signals.volatility * VOLATILITY_SPREAD_FACTOR)
spread *= (1.0 + abs(signals.momentum) * MOMENTUM_SPREAD_FACTOR / 1e6)

class InventoryTracker:
    def __init__(self):
        self.yes_position: int = 0  # Net shares
        self.no_position: int = 0
        self.recent_fills: list[FillRecord] = []
    
    def get_net_exposure(self) -> float:
        """Normalized skew from -1.0 to +1.0."""
        total = abs(self.yes_position) + abs(self.no_position)
        if total == 0:
            return 0.0
        return (self.yes_position - self.no_position) / total

# If long YES (net_exposure > 0), lower YES target to sell more YES
net_exposure = state.inventory.get_net_exposure()
inventory_skew = net_exposure * INVENTORY_SKEW_FACTOR
yes_target -= inventory_skew  # Push probability down when long

def is_adversely_selected(self, threshold: float = 0.80) -> bool:
    """True if one side fills >80% in last 30 seconds."""
    cutoff = time.time() - 30.0
    buy_count = sum(1 for f in self.recent_fills if f.timestamp >= cutoff and f.side == "BUY")
    sell_count = sum(1 for f in self.recent_fills if f.timestamp >= cutoff and f.side == "SELL")
    total = buy_count + sell_count
    
    if total < 3:
        return False
    
    ratio = max(buy_count, sell_count) / total
    return ratio > threshold

if state.inventory.is_adversely_selected():
    print(f"ADVERSE SELECTION detected — circuit breaker for 10s")
    await self.cancel_asset_orders(state)
    state.circuit_breaker_tripped = True
    state.circuit_breaker_until = time.time() + 10

yes_deviation = state.yes_target - 0.5

if yes_deviation > ONE_SIDE_THRESHOLD:  # 0.15
    # YES is likely — don't provide NO liquidity
    quote_no_buy = False
    quote_no_sell = False
    print(f"ONE-SIDED: YES={yes_target:.2f} — skipping NO orders")
elif yes_deviation < -ONE_SIDE_THRESHOLD:
    # NO is likely — don't provide YES liquidity
    quote_yes_buy = False
    quote_yes_sell = False
    print(f"ONE-SIDED: YES={yes_target:.2f} — skipping YES orders")

def calculate_geometric_weights(self, n: int, side: str) -> list[float]:
    """Geometric distribution: first level gets most size, later levels get less."""
    lam = 1.5  # Decay parameter
    weights = [lam ** i for i in range(n)]
    total = sum(weights)
    return [w / total for w in weights]

async def graceful_rebalance(self, state: AssetState):
    """Place new orders FIRST, then cancel old ones (no gap in liquidity)."""
    old_orders = dict(state.active_orders)
    state.active_orders.clear()
    
    # Place new orders at current fair value
    new_orders = await self.place_smart_quotes(state)
    state.active_orders.update(new_orders)
    
    # Brief pause for in-flight trades
    await asyncio.sleep(0.2)
    
    # Cancel old orders
    for order_hash in old_orders:
        try:
            self.client.cancel_order(order_hash, market_id=state.market_id, ...)
        except TurbineApiError:
            pass  # Already filled or expired

async def check_and_refresh_fills(self, state: AssetState):
    """Detect filled orders and replace at CURRENT fair value."""
    # Find filled orders
    for order_hash, info in state.active_orders.items():
        if order_hash not in api_active:
            # Order filled — record in inventory
            state.inventory.record_fill(
                side=info["side"],
                outcome=info["outcome"],
                price=info["price"],
                size=info["size"],
            )
            
            # Replace at CURRENT target, not old fill price
            target = state.yes_target if info["outcome"] == "YES" else state.no_target
            new_price = target - (state.current_spread / 2)  # Bid below fair value
            
            order = self.client.create_limit_buy(
                market_id=state.market_id,
                outcome=outcome,
                price=new_price,
                size=info["size"],
                ...
            )
            self.client.post_order(order)

python examples/market_maker.py \
  --allocation 100 \         # $100 total per asset
  --spread 0.015 \           # 1.5% spread
  --levels 8 \               # 8 orders per side
  --base-vol 0.025 \         # 2.5% daily volatility
  --assets BTC,ETH           # Trade BTC and ETH
  --asset-vol BTC=0.03 ETH=0.04  # Per-asset vol overrides

# Allocation
DEFAULT_ALLOCATION_USDC = 60.0   # $60 per asset (split across all levels)
DEFAULT_NUM_LEVELS = 6           # 6 bids + 6 asks = 12 orders per asset

# Pricing
DEFAULT_SPREAD = 0.012           # 1.2% spread around fair value
DEFAULT_BASE_VOLATILITY = 0.03   # 3% daily volatility floor

# Rebalancing
REBALANCE_THRESHOLD = 0.02       # 2% probability change triggers requote
MIN_REBALANCE_INTERVAL = 2       # Min 2 seconds between rebalances
FAST_POLL_INTERVAL = 2           # Check prices every 2 seconds

# Risk controls
INVENTORY_SKEW_FACTOR = 0.05     # Quote skew per unit net exposure
ADVERSE_SELECTION_THRESHOLD = 0.80  # 80% one-sided fills trips breaker
CIRCUIT_BREAKER_COOLDOWN = 10    # 10 seconds dark after adverse selection
ONE_SIDE_THRESHOLD = 0.15        # Skip losing side when YES > 0.65 or < 0.35

# Setup
git clone https://github.com/ojo-network/turbine-py-client.git
cd turbine-py-client
python3 -m venv .venv && source .venv/bin/activate
pip install -e .

# Configure
echo 'TURBINE_PRIVATE_KEY=0x...' > .env
echo 'CHAIN_ID=137' >> .env
echo 'TURBINE_HOST=https://api.turbinefi.com' >> .env

# Run with custom params
python examples/market_maker.py --allocation 50 --spread 0.01 --levels 4

python examples/market_maker.py --allocation 20 --assets BTC
# $20 on BTC only

async def claim_resolved_markets(self):
    """Claim all winnings using Multicall3 discovery every 5 minutes."""
    while self.running:
        try:
            result = self.client.claim_all_winnings()
            tx_hash = result.get("txHash")
            print(f"[CLAIM] Claimed winnings! TX: {tx_hash}")
        except ValueError as e:
            if "no claimable" in str(e).lower():
                print(f"[CLAIM] No claimable positions found")
        
        await asyncio.sleep(300)  # Every 5 minutes

if seconds_remaining <= 30:
    print(f"PULLING all orders ({seconds_remaining}s remaining)")
    await self.cancel_asset_orders(state)
    state.orders_pulled = True

# More conservative (wider spreads)
DEFAULT_BASE_VOLATILITY = 0.05  # 5% daily

# More aggressive (tighter spreads)
DEFAULT_BASE_VOLATILITY = 0.02  # 2% daily

# Stronger momentum signal
MOMENTUM_FACTOR = 1.0  # Default: 0.5

# Disable momentum entirely
MOMENTUM_FACTOR = 0.0

def calculate_smart_prices(self, state: AssetState, current_price: float):
    # Example: Linear probability based on deviation
    strike_usd = state.strike_price / 1e6
    deviation = (current_price - strike_usd) / strike_usd
    
    # Map [-0.05, +0.05] to [0.2, 0.8]
    yes_target = 0.5 + (deviation * 10)  # 10x multiplier
    yes_target = max(0.2, min(0.8, yes_target))
    
    return yes_target, 1.0 - yes_target, self.base_spread