אסטרטגיות Bot רב-תוצאתיות של NegRisk

מדריך לבוט Polymarket · פרק 22 מתוך 32

בוטי NegRisk מרובי-תוצאות ב־Polymarket: מכניקת סכום-ל-1, ארביטראז' בין legs כש־YES legs לא מסתכמים ל־1, גידור בין legs, ומלכודות ביצוע ייחודיות לשווקים מרובי-תוצאות.

מאת הארלי יאנג, כותבת ראשית ב־Polymarkets.co.il. עודכן לאחרונה: מאי 2026.

על מה הפרק הזה עוסק

שוקי NegRisk מרובי-תוצאות הם הדדיים ומוציאים זה את זה - בדיוק תוצאה אחת תיסגר כ־YES. הפרק הזה הוא שכבת האסטרטגיה מעל מכניקת הביצוע של פרק 11: איך מגדרים בין legs, מתי arb של סכום-ל-1 הוא אמיתי, ואילו באגים רוב בוטי NegRisk פוגשים בפריסה הראשונה שלהם.

• סיכום NegRisk מול binary
• אינווריאנט סכום-ל-1 וארביטראז'
• בניית גידור leg-אחר-leg
• ביצוע: דגל neg_risk בהזמנות
• באגים נפוצים בבוטי NegRisk
• קוד: צילום מצב של כל ה־legs וזיהוי סכום מתחת ל־1.00

סיכום NegRisk מול binary

binary: שוק yes/no אחד, שני טוקנים, סכום ל־1.0. NegRisk: N תוצאות הדדיות, N טוקנים, וכל ה־YES legs יחד מסתכמים לכ־1.0 לאורך האירוע.

מבחינת ביצוע, NegRisk דורש negRisk: true בכל הזמנה (פרק 11) ומנותב דרך חוזה exchange נפרד. מבחינת אסטרטגיה, NegRisk מציע שתי הזדמנויות ייחודיות שאין ב־binary: ארב בין legs כשהסכום סוטה מ־1.0, ובניית גידור באמצעות קניית כמה YES legs.

עלויות ייחודיות ל־NegRisk: יותר legs = יותר spread tax (כל leg שאתה סוחר בו עולה בערך 0.5-1 סנט של spread), וסטיות גדולות יותר מסכום-ל-1 באירועים לא נזילים (הארב זמין יותר, אבל קטן יותר).

אינווריאנט סכום-ל-1 וארביטראז'

הנחת היסוד של הארב: אם קניית כל N ה־YES legs עולה פחות מ־$1.00, נעלת רווח מובטח בזמן ההכרעה (אחת ה־legs חייבת לשלם $1.00; האחרות יורדות ל־$0).

בפועל, פער הארב הוא בדרך כלל 0-3 סנט, ונאכל על ידי spread + fees בכל leg, ונעלם בתוך דקות מרגע הפתיחה. הקיבולת מוגבלת על ידי הנזילות של ה־leg הדק ביותר.

הארב גם כפוף למקרי כשל ספציפיים של הכרעה: תוצאה של "none of the above" שמסווגת במפורש כ־YES כשאף מועמד נקוב לא עומד בתנאי. אם לאירוע יש leg כזה ולא קנית אותו, ה"גידור המלא" שלך מפספס את התשלום בפועל.

בניית גידור leg-אחר-leg

אם אתה מחזיק פוזיציה על leg אחד ב־NegRisk, אפשר לגדר על ידי קניית YES ב־legs מתחרים ביחס מתאים. אם אתה מחזיק Trump-YES ב־0.50 ורוצה להתגדר מפני הפסד של Trump, קונים סל של שאר ה־legs הנקובים.

משקל הגידור לכל leg ≈ ההסתברות המשתמעת הנוכחית של ה־leg בתנאי ש־Trump מפסיד. קירוב: weight_i = price_i / (1 - trump_price).

הגידור אינו מושלם כי המחירים הם נקודת זמן, וההסתברויות המותנות משתנות כשחדשות מגיעות. מאזן מחדש את הגידור מדי שבוע או בעקבות חדשות משמעותיות. אל תעשה over-engineer; המטרה של הגידור היא להפחית שונות, לא לבטל אותה.

ביצוע: דגל neg_risk בהזמנות

הבאג הנפוץ ביותר הספציפי ל־NegRisk: לשכוח negRisk: true ב־payload של שליחת ההזמנה. ההזמנה מתקבלת על ידי ה־API אבל נסלקת באופן שגוי כי היא מנותבת ל־CTF exchange הסטנדרטי במקום ל־NegRisk exchange.

// CORRECT for NegRisk markets:
await client.createAndPostOrder(
  { tokenID, price, size, side: Side.BUY },
  { tickSize: '0.01', negRisk: true },   // <-- REQUIRED
  OrderType.FOK
);

מקור האמת: market.negRisk מ־Gamma API. קרא אותו; העבר אותו הלאה. לעולם אל ת hardcode את הדגל על סמך ניחוש.

באגים נפוצים בבוטי NegRisk

מתוך לוגי דיבוג מייצור על פני כמה בוטים.

1. דגל negRisk חסר: ההזמנות מתקבלות, הסליקה נכשלת. הפתרון: לאכוף את הדגל בכל wrapper.
2. גידור בלי leg ה-"Other": באירועים עם תוצאה של "None of the above", סל הגידור שמוציא אותו הוא לא שלם. הפתרון: תמיד לבדוק אם יש leg של Other כשבונים גידורים.
3. תת-מימד של arb סכום-ל-1: הארבר מזהה את יתרון הסנט, אבל סוחר 5 shares לכל leg; הרווח הכולל הוא 5 סנט לפני spread, נטו שלילי. הפתרון: לתמחר את הארב כך שיניב דולרים מוחשיים, לא לרדוף אחרי אחוזים בכותרת.
4. תמחור leg מיושן: הבוט מביא 3 מחירי legs, זה לוקח 200ms בסך הכול, ומחיר ה־leg האחרון השתנה בזמן המשיכה. הפתרון: למשוך את כל ה־legs במקביל + להתייחס ל־snapshot כהתבוננות אחת.

קוד: צילום מצב של כל ה־legs וזיהוי סכום מתחת ל־1.00

הפניה: צילום מצב של כל ה־YES legs של אירוע NegRisk במקביל, וזיהוי arb.

import asyncio, aiohttp

async def fetch_leg_ask(session, token_id):
    async with session.get(f"https://clob.polymarket.com/book?token_id={token_id}") as r:
        d = await r.json()
        asks = d.get("asks", [])
        return float(asks[0]["price"]) if asks else None

async def check_arb(event_slug):
    event = await fetch_event(event_slug)
    if not event["markets"][0]["negRisk"]: return None
    legs = []
    for m in event["markets"]:
        toks = json.loads(m["clobTokenIds"])
        yes_token = toks[0]
        legs.append(yes_token)

    async with aiohttp.ClientSession() as s:
        asks = await asyncio.gather(*[fetch_leg_ask(s, t) for t in legs])
    if any(a is None for a in asks): return None
    total = sum(asks)
    if total < 0.97:
        return {"edge": 1 - total, "legs": list(zip(legs, asks))}
    return None

ביצוע אטומי של כל ה־legs הוא הבעיה הקשה יותר, והוא דורש FOK לכל leg + rollback במקרה של fill חלקי (תבנית דומה לקוד stat-arb של פרק 16).

שאלות נפוצות