Polymarket Bot Tutorial · Sura ya 29 kati ya 32

Jenga Polymarket paper trading engine kabla ya kwenda live: simulate orders dhidi ya real prices, track P&L, enforce 30-trade gate (>=55% win rate, +PnL) kabla ya live capital yoyote, na code skeleton.

Na Harley Young, mwandishi mkuu wa Polymarkets.co.il. Marekebisho ya mwisho: Mei 2026.

Sura hii inafunika nini

Paper trading ni non-negotiable step kati ya strategy idea na live deployment. Sura hii ni simple paper engine ambayo imegateed kila live bot tuliyoship - chini ya mistari 200 ya Python, inatrack kila trade katika JSONL diary, inaapply fees/slippage sawa na live path.

  • Kwa nini paper kabla live (daima)
  • 30-trade gate (verified +55% WR + positive PnL)
  • Kujenga simple paper engine
  • Kutrack paper diary pamoja na live diary
  • Wakati paper inadiverge kutoka live (na kwa nini)
  • Graduating kwenda live: small first deposit
  • Code: minimal paper engine

Kwa nini paper kabla live (daima)

30-trade paper gate ni single discipline inayotenga 7.6% ya profitable Polymarket traders kutoka 84.1% ambao wanapoteza. Builders wengi wanairuka na wanalipa tuition. Honest reason inafanya kazi: paper trading inafichua true win rate ya strategy juu ya samples za kutosha kutofautisha signal kutoka luck.

Kuruka paper kunacost zaidi kuliko kinachofidia. Strategy inayoonekana profitable katika backtest lakini actually ni coin flip itaburn $200-500 ya live capital kabla ya kuzalisha 30-sample size ya live data. Kupaper-trade trades 30 sawa kunacost $0.

Paper engine haitahitaji kuwa sophisticated. Lazima iwe honest - same fees, same slippage, same fill latency kama live path. Simpler ni better, kwa sababu kitu chochote optional kinakatwa na bot inaship live mapema kuliko inavyopaswa.

30-trade gate (verified +55% WR + positive PnL)

Gate ni binary: 30 closed paper trades, written-in-advance success criteria (typically WR ≥ 55% kwenye positive-EV strategy), au hakuna live deployment.

30 ni minimum sample size ambapo 95% confidence interval kwenye true win rate ni narrow enough kutofautisha signal kutoka noise. Chini ya 30, 60% observed rate inaweza correspond na true rate ya 45-75%. Kwa 30+, interval inanarrow hadi ~50-70% - bado wide, lakini ya kutosha kurule out "strategy ni coin flip."

Success criteria lazima zisetwe KABLA paper run inanza. Kuzisetting baada inazalisha post-hoc rationalization (utapata njia ya kuinterpret trades 30 yoyote kama "good enough").

Kujenga simple paper engine

Paper engine essentially ni live trading code na order-placement function imewekwa na simulated fill. Simulation:

  • Soma live order book: call sawa na live bot ingelifanya.
  • Simulate fill: ikiwa unanunua kwenye FOK na price ≥ best ask, fill order kwa volume-weighted average ya asks zilizoconsumedwa; record fill katika paper diary.
  • Apply fees: subtract fees sawa ambazo live path ingelipa.
  • Track inventory: dumisha parallel paper-balance na paper-positions dictionary.

Whole engine inafit katika mistari 100-200 ya Python. Key discipline: kila assumption live path inafanya (fill rate, latency, fee) lazima ireproducedwe katika paper, hata kama slightly worse kuliko reality - paper inapaswa kuwa floor, sio ceiling.

Kutrack paper diary pamoja na live diary

Paper trading run inazalisha JSONL diary indistinguishable katika structure kutoka live diary bot itakayoandika baadaye. Fields sawa: timestamp, action, market_slug, side, size, price, expected_fill_price, simulated_pnl_at_exit.

Sababu mbili kutumia format sawa. Kwanza, analysis tools zinazosoma live trades (PnL reports, win-rate calculators) zinafanya kazi kwenye paper bila modification. Pili, kulinganisha paper na live baadaye inakamata divergences zinazoindicate bugs.

Production tip: fanya paper engine iandike kwa per_trade_paper.jsonl katika directory sawa na live per_trade.jsonl. Single command inalinganisha both: diff -y <(jq -r .market_slug per_trade.jsonl) <(jq -r .market_slug per_trade_paper.jsonl).

Wakati paper inadiverge kutoka live (na kwa nini)

Inevitable divergences kati ya paper na live. Tatu za kawaida.

  • Slippage: paper inafill kwenye ask snapshot; live inawalk book na inaweza kufill 1-2c worse kwenye thin markets. Solution: simulate slippage katika paper kwa kuongeza per-trade penalty equal kwa half ya spread.
  • Fill latency: paper inafill instantly; live inachukua 200-500ms ambapo price inaweza kuhama. Solution: simulate kwa kusubiri na ku-re-read book kabla ya "kufill" katika paper.
  • Adverse selection: paper inadhani unapata best ask; live inashindana na bots wengine ambao wanaweza tayari kuwa wamelift ask hiyo. Solution: harder kusimulate; honest disclosure kwako mwenyewe kwamba paper inaoverestimates.

Wakati paper inasema +5%/month na live inaendesha kwa -2%/month, gap kawaida ni moja ya hizi. Audit moja kwa moja badala ya kudhani strategy yenyewe ilikuwa wrong.

Graduating kwenda live: small first deposit

Paper inapita trades 30. Live deployment plan:

  1. Deposit $25-50 kama smoke-test capital. Treat kama tuition; ukipoteza, lesson ilikuwa worth it.
  2. Endesha bot katika live mode kwa trades 5-10 na positions kwenye minimum size (shares 5).
  3. Hakiki kila fill inamatch paper expectations ndani ya 2c. Investigate any larger gap kabla ya kuendelea.
  4. Ikiwa trades 5-10 za live zinamatch paper, deposit $200-500 na endesha normal-size positions.
  5. Ikiwa hazimatch, halt, debug, fix, anza tena kutoka step 1.

Most common live-paper gap kwenye first deployment ni missing fee au slippage misestimate. Kuzifix ni rahisi; discipline ni kukamata gap kabla ya kuscale capital.

Code: minimal paper engine

Reference: simple paper engine inayosoma live book + simulates FOK fill.

import json, time
PAPER_BAL = 10_000.0   # USD starting
positions = {}         # token_id -> shares

def paper_fok_buy(token_id, max_price, size):
    book = fetch_book(token_id)
    # Walk asks, fill what we can within max_price
    filled = 0; cost = 0
    for level in book.asks:
        px = float(level["price"])
        if px > max_price: break
        avail = float(level["size"])
        take = min(avail, size - filled)
        filled += take
        cost += take * px
        if filled >= size: break
    if filled < size:
        return {"status":"rejected","filled":0}  # FOK semantics

    global PAPER_BAL
    PAPER_BAL -= cost
    positions[token_id] = positions.get(token_id, 0) + filled

    log_paper({"ts": int(time.time()), "action":"buy",
               "token": token_id, "size": filled, "price": cost/filled})
    return {"status":"matched","filled":filled,"cost":cost}

Production additions: paper sell function (mirror ya buy), paper GTC simulation (post kwenye book kwa price, simulate fill wakati mid inafikia price), reconciliation kati ya paper diary na "would-have-been" live diary.

Maswali yanayoulizwa mara kwa mara

Ni nini 30-trade gate?
Internal gating rule yetu kwa kwenda kutoka paper hadi live: angalau trades 30 zilizofungwa za paper, win rate >= 55%, na net PnL positive net ya slippage. Kufeli yoyote ya hizi kunamaanisha unakaa paper. Tuliibuni rule hii baada ya premature go-live attempts kadhaa zilizofuta accounts katika 2025.
Kwa nini trades 30 na sio 100?
Statistical power. Na trades 30, 55% win rate ina takriban 70% probability ya kuwa real edge (sio noise). Na trades 100, confidence inakua hadi 90%+. Tulichagua 30 kama minimum bar kwa sababu longer paper periods mara nyingi zinainduce overfitting - traders wanatweak strategy too long badala ya kuitest.
Je, ninaweza kuruka paper trading ikiwa nina confidence?
Confidence ni exactly wakati hupaswi kuiruka. Bots zinazofanya best kwenye Polymarket zinaendeshwa na watu walikuwa wrong kabla. 30-trade gate ipo kukamata strategies zinazoonekana right lakini sio. Strategies zetu nyingi wenyewe zilifail paper kwanza - hiyo ni value.
Je, paper results zinamatch live results?
Kawaida ndio kwa slow-moving strategies (politics, weather), hapana kwa fast (5-min crypto, sports microstructure). Gap ni "paper trading hailipi slippage" - real fills ni worse kuliko price uliyoiona. Tunadiscount paper returns kwa 30-50% kabla ya kuziamini kwa live, hasa kwa fast strategies.
Ninawezaje kuimplement paper engine katika Python?
Jisajili kwa real CLOB WebSocket kwa markets unayotrade. Wakati strategy yako inaamua "kuweka order," log kwa JSONL file na would-be fill price (current bid kwa buy, current ask kwa sell). Track positions virtually. Mark-to-market dhidi ya live price. Whole engine ni ~mistari 200 ya Python.
Niitrade paper kwa muda gani kabla ya kwenda live?
Hadi 30-trade gate inafikiwa, au wiki 2-4 chochote ni longer. Ikiwa unafikia gate haraka sana, unafanya overfitting; slow down na hakiki win rate yako ni robust kwa small parameter changes. Ikiwa huwezi kufikia gate baada ya miezi, strategy probably haina edge na unapaswa kuiua.
Umeelewa? Itumie sasa
Fanya mazoezi bure na $1,000 za mazoeziAu fanya biashara moja kwa moja kwenye Polymarket