3.4 Neg-Risk Sum Arb

1. Bot Identity

2. Purpose

Neg-Risk Sum Arb exploits pricing dislocations on Polymarket’s negative-risk (multi-outcome) markets, where the sum of YES token prices across N outcomes must equal $1.00 at resolution. When sum(YES asks across outcomes) < $1.00 net of fees, the bot buys the underpriced YES tokens and — where profitable — routes the position through the NegRiskAdapter on Polygon to convert NO tokens across the set into pUSD. The 'Other' outcome is always excluded from the conversion path. This is a user-controlled execution tool that targets a structural pricing constraint specific to negative-risk event design on Polymarket. It is the multi-outcome counterpart to sum-to-one-arb.

3. Why This Bot Matters

• Sum computed without excluding 'Other' outcome

  The 'Other' token is illiquid and reprices discontinuously. Including it in the sum produces false edge signals that cannot be closed via the NegRiskAdapter path.

• NegRiskAdapter path not available (market not on negRisk contract)

  Buying all YES tokens across N outcomes without a conversion path leaves open positions on all legs; settlement risk is uncapped until individual markets resolve.

• feeRateBps hardcoded on signed order (V1 pattern)

  CLOB V2 rejects orders with feeRateBps. Fees are operator-set at match time. All signed orders must omit this field.

• Partial fill on one outcome leg leaves unbalanced multi-leg exposure

  In a 4-outcome event, buying 3 of 4 YES tokens does not produce a guaranteed $1 settlement and creates directional risk on the unfilled outcome.

No worked examples on this bot yet. Worked examples are optional but strongly recommended — they turn an abstract failure mode into something a developer can verify in a fixture.

4. Required Polymarket Inputs

5. Required Internal Inputs

6. Parameter Guide

7. Detailed Parameter Instructions

{ "min_edge_bps": 20 }

if net_edge_bps < params.hard: return skip('NEG_RISK_SUM_ARB_NO_EDGE')

{ "prefer_conversion_path": true }

if params.prefer_conversion_path and adapter.available: EMIT NegRiskConvertRoute

{ "max_outcomes_per_trade": 8 }

if len(outcomes) > params.hard: return skip('NEG_RISK_SUM_ARB_NO_EDGE')

{ "exclude_other_outcome": true }

outcomes = [o for o in event.outcomes if o.name.lower() != 'other']

8. Default Configuration

{
  "bot_id": "strat.neg_risk_sum_arb",
  "version": "2.1.0",
  "mode": "general_live",
  "defaults": {
    "min_edge_bps": 20,
    "prefer_conversion_path": true,
    "max_outcomes_per_trade": 8,
    "exclude_other_outcome": true
  },
  "locked": {
    "exclude_other_outcome": true,
    "max_outcomes_per_trade": {
      "max": 12
    },
    "min_edge_bps": {
      "min": 8
    }
  }
}

9. Implementation Flow

1. Check KillSwitch active flag; if active, skip and emit no OrderIntents.
2. FETCH Gamma API for all active neg-risk events (enableNegRisk=true); extract outcome token lists.
3. Exclude 'Other' outcome token from each event's outcome list.
4. If len(outcomes) > max_outcomes_per_trade, skip this event.
5. Verify NegRiskAdapter availability for event condition ID via onchain call.
6. Subscribe to ws_market book updates for all YES token IDs of each eligible event.
7. On each book tick: compute sum_YES_asks = sum(best_ask[outcome] for outcome in outcomes).
8. Compute raw_edge_bps = (1.00 - sum_YES_asks) * 10000.
9. Deduct total fee drag across N legs; compute net_edge_bps = raw_edge_bps - N * per_leg_fee_bps - fee_buffer_bps.
10. If net_edge_bps < min_edge_bps hard floor (8), emit DecisionReport intent_emitted=false NEG_RISK_SUM_ARB_NO_EDGE; skip.
11. If 8 ≤ net_edge_bps < 20, emit WARN NEG_RISK_SUM_ARB_EDGE_MARGINAL; reduce leg size 50%.
12. Compute legSize = toPusdUnits(min(min_depth_across_outcomes, max_leg_size_usd) * sizeMultiplier).
13. Emit one OrderIntent per outcome leg: side=buy, outcome=YES, price=best_ask, tif=FOK, builder={code, fee_bps: 25}. No feeRateBps on any signed order — fees are operator-set at match time in V2.
14. If prefer_conversion_path and NegRiskAdapter available: EMIT NegRiskConvertRoute after fill confirmations (burn NO tokens → pUSD via NegRiskAdapter).
15. Emit DecisionReport with intent_emitted=true, edge_bps, outcome_count, conversion_path_used.

10. Reference Implementation

Scans Gamma API for neg-risk events, subscribes to book streams for all YES token IDs, computes net edge across N outcomes, and emits N FOK OrderIntents when edge exceeds threshold. Optionally routes through NegRiskAdapter for immediate pUSD conversion.

Pseudocode is language-agnostic. FETCH = read input. EMIT = produce output. Translate to TS/Python/Go/Rust.

FUNCTION scanNegRiskEvents():
  // --- 0. KillSwitch gate ---
  ks = FETCH internal.killswitch.status
  IF ks.active:
    RETURN

  // --- 1. Fetch active neg-risk events from Gamma ---
  events = FETCH gamma.GET('/markets?negRisk=true&active=true')
  FOR event IN events:
    outcomes = [o for o in event.outcomes if o.name.lower() != 'other']  // exclude Other (locked)
    IF len(outcomes) > params.max_outcomes_per_trade:
      SKIP event  // too many legs

    // --- 2. Verify NegRiskAdapter available ---
    adapterAvailable = FETCH onchain.NegRiskAdapter.isConditionRegistered(event.conditionId)

    // --- 3. Subscribe to book streams for all YES token IDs ---
    tokenIds = [o.yes_token_id for o in outcomes]
    ws_market.subscribe('book', tokenIds)

FUNCTION onBookTick(event, outcomes, tick):
  // --- 4. Check freshness ---
  IF isStale(tick, maxAgeS=5):
    EMIT DecisionReport(intent_emitted=false, reason='STALE_MARKET_DATA')
    RETURN

  // --- 5. Compute edge ---
  asks = [tick[o.yes_token_id].best_ask for o in outcomes]
  sum_YES_asks = SUM(asks)
  raw_edge_bps = (1.00 - sum_YES_asks) * 10000

  // --- 6. Fee drag across N legs ---
  feeRate   = FETCH onchain.feeConfig(event.conditionId)
  N         = len(outcomes)
  total_fee = SUM(feeRate * asks[i] * (1 - asks[i]) * 10000 for i in range(N))
  net_edge_bps = raw_edge_bps - total_fee - params.fee_buffer_bps

  // --- 7. Hard floor ---
  IF net_edge_bps < params.min_edge_bps_hard:  // 8 bps
    EMIT DecisionReport(intent_emitted=false, reason='NEG_RISK_SUM_ARB_NO_EDGE')
    RETURN

  // --- 8. Warning threshold ---
  legSizeMultiplier = 1.0
  IF net_edge_bps < params.min_edge_bps:  // 20 bps default
    WARN('NEG_RISK_SUM_ARB_EDGE_MARGINAL')
    legSizeMultiplier = 0.5

  // --- 9. Leg sizing ---
  minDepth = MIN(tick[o.yes_token_id].depth_pusd for o in outcomes)
  legSize  = toPusdUnits(min(minDepth, params.max_leg_size_usd) * legSizeMultiplier)

  // --- 10. Emit N OrderIntents (V2: no feeRateBps; builder field carries code) ---
  FOR i, outcome IN enumerate(outcomes):
    EMIT OrderIntent(
      market_id     = outcome.market_id,
      outcome       = 'YES',
      side          = 'buy',
      price         = asks[i],
      size_pUSD     = legSize,
      tif           = 'FOK',
      post_only     = false,
      builder       = { code: config.builder_code, fee_bps: 25 },
      negrisk_aware = true
    )

  // --- 11. NegRiskAdapter conversion path ---
  IF params.prefer_conversion_path AND adapterAvailable:
    EMIT NegRiskConvertRoute(
      conditionId = event.conditionId,
      action      = 'burn_NO_to_pUSD',  // NegRiskAdapter: burn NO across set -> pUSD
      trigger     = 'on_all_fills'
    )

  EMIT DecisionReport(
    intent_emitted  = true,
    edge_bps        = net_edge_bps,
    outcome_count   = N,
    conversion_path = 'NegRiskAdapter' IF adapterAvailable ELSE 'hold',
    reasons         = ['NEG_RISK_SUM_ARB_EDGE_PRESENT']
  )

SDK calls used

• gamma.GET('/markets?negRisk=true&active=true')
• onchain.NegRiskAdapter.isConditionRegistered(conditionId)
• ws_market.subscribe('book', tokenIds)
• onchain.feeConfig(conditionId)
• toPusdUnits(rawFloat)
• buildOrderTypedData(orderParams, { name: 'CTFExchange', version: '2', chainId: 137 })
• internal.killswitch.status()
• internal.builder_code

Complexity: O(N) per book tick where N = number of outcomes per event

11. Wire Examples

Input — what arrives on the wire

Gamma API neg-risk event with 4 outcomes — gamma

{
  "conditionId": "0xbcd1ef2345678901bcdef01234567890bcdef01234567890bcdef01234567890bc",
  "negRisk": true,
  "outcomes": [
    {
      "name": "Outcome A",
      "yes_token_id": "0xtoken_a"
    },
    {
      "name": "Outcome B",
      "yes_token_id": "0xtoken_b"
    },
    {
      "name": "Outcome C",
      "yes_token_id": "0xtoken_c"
    },
    {
      "name": "Outcome D",
      "yes_token_id": "0xtoken_d"
    },
    {
      "name": "Other",
      "yes_token_id": "0xtoken_other"
    }
  ]
}

ws_market book tick — sum(YES) = 0.978 — ws_market

{
  "token_a_ask": "0.242",
  "token_b_ask": "0.245",
  "token_c_ask": "0.248",
  "token_d_ask": "0.243",
  "sum_YES": "0.978",
  "received_at_ms": 1746789700000
}

Output — what the bot emits

OrderIntent — Outcome A leg (one of 4; all similar)

{
  "intent_id": "oi_01HX9NGRSUM4A1B",
  "trace_id": "tr_01HX9NGRSUM4VR5",
  "market_id": "0xbcd1ef2345678901bcdef01234567890bcdef01234567890bcdef01234567890bc",
  "outcome": "YES",
  "side": "buy",
  "price": "0.242",
  "size_pUSD": "400.00",
  "tif": "FOK",
  "post_only": false,
  "builder": {
    "code": "0x706f6c7974726164657273000000000000000000000000000000000000000000",
    "fee_bps": 25
  },
  "negrisk_aware": true,
  "decision": {
    "edge_bps": 22.1,
    "outcome_count": 4,
    "conversion_path": "NegRiskAdapter",
    "reasons": [
      "NEG_RISK_SUM_ARB_EDGE_PRESENT"
    ]
  },
  "comment": "fees are operator-set at match time in V2 — feeRateBps is NOT on the signed order"
}

NegRiskConvertRoute — burn NO tokens → pUSD after fills

{
  "route_id": "nrc_01HX9NGRSUM4X9Z",
  "conditionId": "0xbcd1ef2345678901bcdef01234567890bcdef01234567890bcdef01234567890bc",
  "action": "burn_NO_to_pUSD",
  "trigger": "on_all_fills",
  "adapter": "NegRiskAdapter",
  "network": "polygon"
}

12. Decision Logic

13. Standard Decision Output

This bot returns a OrderIntent object. See OrderIntent schema.

{
  "intent_id": "oi_01HX9NGRSUM4A1B",
  "trace_id": "tr_01HX9NGRSUM4VR5",
  "market_id": "0xbcd1ef2345678901bcdef01234567890bcdef01234567890bcdef01234567890bc",
  "outcome": "YES",
  "side": "buy",
  "price": "0.242",
  "size_pUSD": "400.00",
  "tif": "FOK",
  "post_only": false,
  "builder": {
    "code": "0x706f6c7974726164657273000000000000000000000000000000000000000000",
    "fee_bps": 25
  },
  "negrisk_aware": true,
  "decision": {
    "edge_bps": 22.1,
    "outcome_count": 4,
    "conversion_path": "NegRiskAdapter",
    "reasons": [
      "NEG_RISK_SUM_ARB_EDGE_PRESENT"
    ]
  },
  "comment": "fees are operator-set at match time in V2 \u2014 feeRateBps is NOT on the signed order"
}

14. Reason Codes

15. Metrics & Logs

Metrics emitted

Alerts

Dashboards

• Grafana — Strategy / NegRiskSumArb edge and outcome count distribution
• Grafana — Strategy / NegRiskSumArb NegRiskAdapter conversion throughput

16. Developer Reporting

{
  "bot_id": "strat.neg_risk_sum_arb",
  "event_condition_id": "0xbcd1ef2345678901bcdef01234567890bcdef01234567890bcdef01234567890bc",
  "outcome_count": 4,
  "sum_YES_asks": 0.978,
  "raw_edge_bps": 22.0,
  "total_fee_drag_bps": 14.2,
  "net_edge_bps": 22.1,
  "leg_size_pusd": 400.0,
  "conversion_path": "NegRiskAdapter",
  "intent_emitted": true,
  "reason": "NEG_RISK_SUM_ARB_EDGE_PRESENT",
  "emitted_at_ms": 1746789700000
}

17. Plain-English Reporting

18. Failure-Mode Block

19. Failure-Injection Recipes

20. State & Persistence

Cold-start recovery

On cold start, state is empty; first book tick per event triggers fresh evaluation. NegRiskAdapter availability is re-checked from onchain on first evaluation.

21. Concurrency & Idempotency

22. Dependencies

Depends on (must run first)

Emits to (downstream consumers)

External services

23. Security Surfaces

On-chain contract calls

Abuse vectors considered

• Injecting a fake Gamma API response to fabricate neg-risk events with artificially low outcome prices
• NegRiskAdapter reentrancy on Polygon if burn-NO flow is invoked with a manipulated condition ID
• Partial-fill attack: adversary moves one outcome book between leg submissions to leave an unbalanced position

Mitigations

• Gamma API response validated against onchain conditionId before any order emission
• NegRiskAdapter conditionId verified onchain before emitting NegRiskConvertRoute
• All legs use FOK; a failed leg prevents NegRiskConvertRoute from being triggered
• builder.code read from immutable internal config; not user-supplied
• V2 order timestamp(ms) invalidates replays outside exchange acceptance window

24. Polymarket V2 Compatibility

API surfaces declared

Networks supported

25. Versioning & Migration

Migration history

26. Acceptance Tests

Unit Tests

Integration Tests

Property Tests

27. Operational Runbook

NegRiskSumArb incidents typically involve NegRiskAdapter unavailability, stale Gamma API data, or partial-leg fills. Partial fills require manual risk review; adapter issues are usually transient RPC problems.

On-call actions

Manual overrides

• —
• —

Healthcheck

GET /internal/health/neg-risk-sum-arb -> 200 if Gamma API last_seen < 60s, ws_market feed last_seen < 5s per active event, NegRiskAdapter reachable, and KillSwitch inactive.

28. Promotion Gates

A bot does not advance to the next readiness state until every gate below is green. Gates are observable from production data — no subjective sign-off.

Promote to Shadow

Promote to Limited live

Promote to General live

29. Developer Checklist

Ready-to-ship score: 27/27 sections complete · 100%