Autonomous Market Making: AI Agents as Liquidity Providers

/**
 * Avellaneda-Stoikov Market Making Agent
 * Posts bid/ask quotes on ETH/USDC, manages inventory risk,
 * and executes via Purple Flea Trading API.
 */

const PF_TRADING = 'https://purpleflea.com/trading-api'
const API_KEY    = 'your_api_key'

// Model parameters
const CONFIG = {
  gamma:          0.10,   // risk aversion (0 = neutral, 1 = very risk averse)
  kappa:          1.50,   // order book density param
  quoteSize:      0.50,   // ETH per quote level
  quoteLevels:    3,      // number of bid/ask levels to post
  levelSpacing:   0.0003, // 0.03% between levels
  maxInventory:   5.0,    // max ±ETH position before quoting halts
  targetInventory:0.0,    // desired neutral inventory
  horizonSec:     300,    // rebalance horizon (5 minutes)
  refreshSec:     5,      // how often to refresh quotes
}

// Shared state
let state = {
  midPrice:    0,
  sigma:       0.015,      // realized volatility (updated dynamically)
  inventory:   0,          // current ETH inventory
  activeOrders: [],
  totalSpreadPnl: 0,
  totalInventoryPnl: 0,
}

/**
 * Avellaneda-Stoikov reservation price and optimal spread.
 */
function computeQuotes(midPrice, inventory, sigma, tRemain) {
  const { gamma, kappa } = CONFIG
  // Reservation price: biased away from current inventory
  const reservationPrice = midPrice - inventory * gamma * sigma * sigma * tRemain

  // Optimal half-spread
  const spread = gamma * sigma * sigma * tRemain
              + (2 / gamma) * Math.log(1 + gamma / kappa)

  return {
    bid: reservationPrice - spread / 2,
    ask: reservationPrice + spread / 2,
    spread,
    reservationPrice,
  }
}

/**
 * Compute realized volatility from recent price ticks.
 * @param {number[]} priceTicks - array of recent mid prices
 */
function computeRealizedVol(priceTicks) {
  if (priceTicks.length < 2) return 0.015
  const returns = []
  for (let i = 1; i < priceTicks.length; i++) {
    returns.push(Math.log(priceTicks[i] / priceTicks[i - 1]))
  }
  const mean = returns.reduce((a, b) => a + b, 0) / returns.length
  const variance = returns.reduce((s, r) => s + (r - mean) ** 2, 0) / returns.length
  return Math.sqrt(variance)  // per-tick vol; scale by sqrt(ticks_per_unit_time)
}

/**
 * Cancel all active orders and post fresh quotes.
 */
async function refreshQuotes(wallet) {
  const tRemain = CONFIG.horizonSec / 86400  // fraction of trading day
  const { bid, ask, spread } = computeQuotes(
    state.midPrice,
    state.inventory - CONFIG.targetInventory,
    state.sigma,
    tRemain
  )

  // Halt quoting if inventory limit breached
  if (Math.abs(state.inventory) >= CONFIG.maxInventory) {
    console.warn(`Inventory limit reached (${state.inventory} ETH) — pausing quotes`)
    await cancelAllOrders(wallet)
    return
  }

  // Cancel existing orders
  await cancelAllOrders(wallet)

  // Post layered quotes at multiple levels
  const newOrders = []
  for (let i = 0; i < CONFIG.quoteLevels; i++) {
    const offset = i * CONFIG.levelSpacing * state.midPrice
    newOrders.push(
      postOrder(wallet, 'buy',  (bid  - offset).toFixed(2), CONFIG.quoteSize),
      postOrder(wallet, 'sell', (ask  + offset).toFixed(2), CONFIG.quoteSize)
    )
  }
  const results = await Promise.all(newOrders)
  state.activeOrders = results.map(r => r.order_id).filter(Boolean)

  console.log(`Quotes refreshed | Bid: $${bid.toFixed(2)} | Ask: $${ask.toFixed(2)} | Spread: $${spread.toFixed(2)} | Inv: ${state.inventory.toFixed(3)} ETH`)
}

async function postOrder(wallet, side, price, size) {
  const res = await fetch(`${PF_TRADING}/v1/orders/limit`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
    body: JSON.stringify({
      wallet, side, price, size,
      pair: 'ETH/USDC',
      time_in_force: 'GTC',
      post_only: true  // ensure maker fee tier, never take liquidity
    })
  })
  return res.json()
}

async function cancelAllOrders(wallet) {
  if (!state.activeOrders.length) return
  await fetch(`${PF_TRADING}/v1/orders/cancel-batch`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
    body: JSON.stringify({ wallet, order_ids: state.activeOrders })
  })
  state.activeOrders = []
}

/**
 * Process a fill notification from the exchange websocket.
 * Updates inventory and PnL tracking.
 */
function processFill(fill) {
  const { side, size, price } = fill
  if (side === 'buy')  state.inventory += parseFloat(size)
  if (side === 'sell') state.inventory -= parseFloat(size)

  // Spread PnL approximation: half the spread per fill
  const spreadPerFill = Math.abs(parseFloat(price) - state.midPrice)
  state.totalSpreadPnl += spreadPerFill * parseFloat(size)

  console.log(`Fill: ${side} ${size} ETH @ $${price} | Inv: ${state.inventory.toFixed(3)} ETH | Spread PnL: $${state.totalSpreadPnl.toFixed(2)}`)
}

/**
 * Main agent loop.
 */
async function runAMMAgent(wallet) {
  const priceTicks = []

  setInterval(async () => {
    // 1. Fetch current mid price
    const tickRes = await fetch(`${PF_TRADING}/v1/ticker/ETH-USDC`, {
      headers: { 'X-API-Key': API_KEY }
    })
    const ticker = await tickRes.json()
    state.midPrice = (ticker.best_bid + ticker.best_ask) / 2
    priceTicks.push(state.midPrice)
    if (priceTicks.length > 100) priceTicks.shift()

    // 2. Update realized volatility
    state.sigma = computeRealizedVol(priceTicks)

    // 3. Check for fills and update inventory
    const fillsRes = await fetch(`${PF_TRADING}/v1/fills/recent`, {
      headers: { 'X-API-Key': API_KEY },
    })
    const { fills } = await fillsRes.json()
    fills.forEach(processFill)

    // 4. Refresh quotes with updated parameters
    await refreshQuotes(wallet)

  }, CONFIG.refreshSec * 1000)

  console.log(`AMM Agent started for wallet ${wallet}`)
}

runAMMAgent('0xYourAgentWallet')

import math
import httpx
import asyncio
from dataclasses import dataclass

PF_TRADING = "https://purpleflea.com/trading-api"
API_KEY    = "your_api_key"

@dataclass
class LPPosition:
    entry_price: float      # ETH price at position entry
    tick_lower:  float      # lower price bound of concentrated range
    tick_upper:  float      # upper price bound of concentrated range
    liquidity_usd: float    # total USD value at entry

def compute_il(pos: LPPosition, current_price: float) -> float:
    """
    Compute impermanent loss for a Uniswap V3 concentrated LP position.
    Returns IL as a fraction (negative = loss relative to HODL).
    Uses V3 formula accounting for concentrated range.
    """
    p0 = pos.entry_price
    p1 = current_price
    pa = pos.tick_lower
    pb = pos.tick_upper

    # Handle out-of-range: full exposure to one asset
    if p1 <= pa:
        # Fully in token0 (ETH): all assets are ETH
        eth_ratio = 1.0
        # Value of LP if HODL'd: 50% ETH + 50% USDC at entry
        hodl_value = 0.5 * pos.liquidity_usd * (p1 / p0) + 0.5 * pos.liquidity_usd
        lp_value   = pos.liquidity_usd * (p1 / p0)  # all became ETH, now worth p1/p0
        return (lp_value - hodl_value) / hodl_value

    elif p1 >= pb:
        # Fully in token1 (USDC): no price exposure
        hodl_value = 0.5 * pos.liquidity_usd * (p1 / p0) + 0.5 * pos.liquidity_usd
        lp_value   = pos.liquidity_usd  # all USDC, no change
        return (lp_value - hodl_value) / hodl_value

    # In-range: standard V3 IL formula
    sq_p0, sq_p1 = math.sqrt(p0), math.sqrt(p1)
    sq_pa, sq_pb = math.sqrt(pa), math.sqrt(pb)

    # LP value ratio (normalized)
    lp_ratio = (
        (2 * math.sqrt(sq_p0 * sq_p1) - sq_p0 - sq_p1) /
        (2 * math.sqrt(sq_p0 * sq_pb) - sq_p0 - sq_pb)
    )
    hold_ratio = (p1 / p0 + 1) / 2

    return (lp_ratio / hold_ratio) - 1

def optimal_hedge_size(
    pos: LPPosition,
    current_price: float,
    perp_funding_rate: float  # daily funding rate
) -> dict:
    """
    Calculate optimal delta hedge size for an LP position.
    Only hedge if IL risk exceeds hedge cost.
    """
    il_pct = abs(compute_il(pos, current_price)) * 100

    # Estimate delta exposure: how much ETH does LP "hold" at current price?
    # For in-range V3 position, delta ≈ 0.5 at midpoint of range
    range_center = math.sqrt(pos.tick_lower * pos.tick_upper)
    relative_pos = (current_price - pos.tick_lower) / (pos.tick_upper - pos.tick_lower)
    delta_fraction = max(0, min(1, 1 - relative_pos))  # ETH fraction

    eth_exposure = (pos.liquidity_usd * delta_fraction) / current_price
    hedge_cost_pct = abs(perp_funding_rate) * 30  # 30-day cost

    should_hedge = il_pct > hedge_cost_pct * 2  # hedge only if IL > 2x cost

    return {
        "il_pct": round(il_pct, 4),
        "eth_delta": round(eth_exposure, 4),
        "hedge_short_eth": round(eth_exposure, 4) if should_hedge else 0,
        "hedge_cost_pct_30d": round(hedge_cost_pct, 4),
        "should_hedge": should_hedge,
    }

async def open_perp_hedge(wallet: str, short_eth: float):
    """Open a short perp position to hedge LP delta."""
    async with httpx.AsyncClient() as client:
        res = await client.post(
            f"{PF_TRADING}/v1/perp/open",
            json={
                "wallet": wallet,
                "asset": "ETH",
                "side": "short",
                "size": short_eth,
                "leverage": 2,
                "order_type": "market",
            },
            headers={"X-API-Key": API_KEY}
        )
        result = res.json()
    print(f"Hedge opened: short {short_eth:.4f} ETH perp | txid: {result.get('tx_hash','')[:16]}")

// Example usage
pos = LPPosition(
    entry_price=2800,
    tick_lower=2500,
    tick_upper=3200,
    liquidity_usd=100_000
)

current_price = 2600
funding = 0.0001  # 0.01% daily funding
hedge = optimal_hedge_size(pos, current_price, funding)
print(f"IL: {hedge['il_pct']:.2f}% | Delta: {hedge['eth_delta']:.3f} ETH | Hedge needed: {hedge['should_hedge']}")