Front-run from pending trades

import os, json, time
from websockets.sync.client import connect

KEY = os.environ["PREDEXON_API_KEY"]
WSS = "wss://wss.predexon.com/v1"

def sub_msg(market_slugs):
    return json.dumps({
        "action": "subscribe",
        "platform": "polymarket",
        "version": 1,
        "type": "orders",
        "filters": {
            "market_slugs": market_slugs,
            "status": "pending",   # the magic flag
        },
    })

MARKETS = ["bitcoin-100k-by-end-2026", "us-recession-2026"]  # your watch list

with connect(f"{WSS}/{KEY}") as ws:
    ws.send(sub_msg(MARKETS))
    for raw in ws:
        msg = json.loads(raw)
        if msg.get("type") == "event":
            handle_pending(msg["data"])

import requests

DATA = "https://api.predexon.com"
H = {"x-api-key": KEY}

MIN_NOTIONAL = 5_000      # ignore noise — only act on $5k+ pending trades
LIFT_SIZE = 100           # shares to buy

def execute_on_venue(token_id, side, size, price):
    # your venue-native execution — e.g. Polymarket CLOB client
    # keep this pre-warmed: authenticated session, cached allowances
    raise NotImplementedError

def handle_pending(t):
    notional = float(t["shares_normalized"]) * float(t["price"])
    if notional < MIN_NOTIONAL:
        return
    if t["side"] != "BUY":
        return            # only lift on buy pressure for this example

    # current best ask — we'll target ask + tick to actually fill
    book = requests.get(
        f"{DATA}/v2/polymarket/market-price/{t['token_id']}",
        headers=H,
    ).json()
    target_price = round(min(book["best_ask"] + 0.001, 0.999), 3)

    # lift the book before the pending trade settles
    # use a limit not a market order — slippage protection
    execute_on_venue(
        token_id=t["token_id"],
        side="buy",
        size=LIFT_SIZE,
        price=target_price,
    )

# in your handler, log the pending event with timestamp_pending
# in a separate trades subscription (no status filter), log the same trade_id with timestamp_confirmed

# offline analysis:
# - lead_time = timestamp_confirmed - timestamp_pending  (target: 3–5s)
# - hit_rate  = fraction of your lift orders that filled at or below target_price
# - net_pnl   = (avg_fill_price - mid_after_confirm) * shares for each filled lift

MY_RECENT_ORDERS = {}  # token_id → timestamp_placed

def handle_pending(t):
    last = MY_RECENT_ORDERS.get(t["token_id"], 0)
    if time.time() - last < 10:
        return   # probably my own order
    ...