Arbitrage.

// Module 16, Two-leg FOK execution with idempotent client order ids.

import {
  HttpClient,
  MarketFetcher,
  OrderClient,
  Side,
  OrderType,
  ApiError,
} from '@limitless-exchange/sdk';
import { randomUUID } from 'node:crypto';

async function executeSellBoth(
  httpClient: HttpClient,
  orders: OrderClient,
  marketFetcher: MarketFetcher,
  slug: string,
  makerAmount: number,
) {
  const market  = await marketFetcher.getMarket(slug);
  const yesId   = market.positionIds[0];
  const noId    = market.positionIds[1];
  const keyBase = randomUUID();
  const legAId  = `${keyBase}-yes`;
  const legBId  = `${keyBase}-no`;

  const submitLeg = (tokenId: string, clientOrderId: string) =>
    orders.createOrder({
      marketSlug:  slug,
      tokenId,
      side:        Side.SELL,         // sell both sides for > $1 parity
      makerAmount,
      orderType:   OrderType.FOK,
      clientOrderId,
    }).catch((err) => {
      // 409 = duplicate clientOrderId; safe to treat as already-submitted.
      if (err instanceof ApiError && err.status === 409) return null;
      throw err;
    });

  const [legA, legB] = await Promise.allSettled([
    submitLeg(yesId, legAId),
    submitLeg(noId,  legBId),
  ]);

  // Confirm settlement via POST /orders/status/batch (1–50 items).
  const statusResp = await httpClient.post('/orders/status/batch', {
    items: [{ clientOrderId: legAId }, { clientOrderId: legBId }],
  });

  for (const r of statusResp.results) {
    console.log(r.clientOrderId, '→', r.data?.execution?.settlementStatus);
  }

  if (legA.status === 'rejected' || legB.status === 'rejected') {
    console.warn('at least one leg rejected', legA, legB);
  }
}

# Module 16, Two-leg FOK execution with idempotent client order ids.

import asyncio
import uuid
from limitless_sdk.api import HttpClient, APIError
from limitless_sdk.markets import MarketFetcher
from limitless_sdk.orders import OrderClient
from limitless_sdk.types import Side, OrderType


async def execute_sell_both(
    http_client: HttpClient,
    orders: OrderClient,
    market_fetcher: MarketFetcher,
    slug: str,
    maker_amount: float,
) -> None:
    market  = await market_fetcher.get_market(slug)
    yes_id  = market["positionIds"][0]
    no_id   = market["positionIds"][1]

    key_base = str(uuid.uuid4())
    leg_a_id = f"{key_base}-yes"
    leg_b_id = f"{key_base}-no"

    async def submit(token_id: str, client_order_id: str):
        try:
            return await orders.create_order(
                token_id=token_id,
                maker_amount=maker_amount,
                side=Side.SELL,                 # sell both sides for > $1 parity
                order_type=OrderType.FOK,
                market_slug=slug,
                client_order_id=client_order_id,
            )
        except APIError as e:
            if e.status_code == 409:            # duplicate clientOrderId
                return None
            raise

    leg_a, leg_b = await asyncio.gather(
        submit(yes_id, leg_a_id),
        submit(no_id,  leg_b_id),
        return_exceptions=True,
    )

    # Confirm settlement via POST /orders/status/batch (1–50 items).
    status = await http_client.post(
        "/orders/status/batch",
        json={"items": [
            {"clientOrderId": leg_a_id},
            {"clientOrderId": leg_b_id},
        ]},
    )
    for r in status.get("results", []):
        settlement = (r.get("data") or {}).get("execution", {}).get("settlementStatus")
        print(r.get("clientOrderId"), "→", settlement)

    if isinstance(leg_a, Exception) or isinstance(leg_b, Exception):
        print("at least one leg rejected:", leg_a, leg_b)

// Module 16, Two-leg FOK execution with idempotent client order ids.

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

    "github.com/google/uuid"
    limitless "github.com/limitless-labs-group/limitless-exchange-go-sdk/limitless"
)

func executeSellBoth(
    ctx context.Context,
    client *limitless.HttpClient,
    orders *limitless.OrderClient,
    marketFetcher *limitless.MarketFetcher,
    slug string,
    makerAmount float64,
) error {
    market, err := marketFetcher.GetMarket(ctx, slug)
    if err != nil {
        return err
    }

    keyBase := uuid.New().String()
    legAID  := keyBase + "-yes"
    legBID  := keyBase + "-no"

    submit := func(tokenID, clientOrderID string) error {
        _, err := orders.CreateOrder(ctx, limitless.CreateOrderParams{
            OrderType:     limitless.OrderTypeFOK,
            MarketSlug:    slug,
            ClientOrderID: clientOrderID,
            Args: limitless.FOKOrderArgs{
                TokenID:     tokenID,
                Side:        limitless.SideSell,  // sell both sides for > $1 parity
                MakerAmount: makerAmount,
            },
        })
        // 409 = duplicate clientOrderId; safe to treat as already-submitted.
        var apiErr *limitless.APIError
        if errors.As(err, &apiErr) && apiErr.Status == 409 {
            return nil
        }
        return err
    }

    errA := submit(market.Tokens.Yes, legAID)
    errB := submit(market.Tokens.No,  legBID)

    // Confirm settlement via POST /orders/status/batch (1–50 items).
    body := map[string]any{
        "items": []map[string]string{
            {"clientOrderId": legAID},
            {"clientOrderId": legBID},
        },
    }
    resp, _ := client.Post(ctx, "/orders/status/batch", body)
    fmt.Println("status batch:", resp)

    if errA != nil || errB != nil {
        log.Println("at least one leg rejected:", errA, errB)
    }
    return nil
}