Market making.

// Module 15, Basic quote placer with reposition on mid drift.

import {
  HttpClient,
  MarketFetcher,
  OrderClient,
  Side,
  OrderType,
  withRetry,
} from '@limitless-exchange/sdk';
import { Wallet } from 'ethers';

const SPREAD     = 0.02;   // quote ±2% of mid
const REPOSITION = 0.005;  // re-quote if mid moves > 0.5%
const SIZE       = 100;    // shares per quote

const httpClient    = new HttpClient({ apiKey: process.env.LIMITLESS_API_KEY });
const marketFetcher = new MarketFetcher(httpClient);
const wallet        = new Wallet(process.env.PRIVATE_KEY!);
const orderClient   = new OrderClient({ httpClient, wallet, marketFetcher });

let quotedMid = 0;

async function requote(slug: string) {
  // 1. Pull orderbook for a fresh mid.
  //    GET /markets/{slug}/orderbook
  const book = await marketFetcher.getOrderBook(slug);
  const bestBid = Number(book.bids[0]?.price ?? 0);
  const bestAsk = Number(book.asks[0]?.price ?? 0);
  if (!bestBid || !bestAsk) return;
  const mid = (bestBid + bestAsk) / 2;

  // 2. Skip if drift is below the reposition threshold.
  if (quotedMid && Math.abs(mid - quotedMid) / quotedMid < REPOSITION) return;

  // 3. Cancel every live order on this market before re-quoting.
  //    DELETE /orders/all/{slug}
  await orderClient.cancelAll(slug);

  // 4. Place a fresh maker-only pair on the YES token.
  const market = await marketFetcher.getMarket(slug);
  const yesTokenId = market.positionIds[0];

  await withRetry(
    () => orderClient.createOrder({
      marketSlug: slug,
      tokenId:    yesTokenId,
      side:       Side.BUY,
      price:      mid * (1 - SPREAD),
      size:       SIZE,
      orderType:  OrderType.GTC,
      postOnly:   true,          // rejects if it would cross, guarantees maker fees
    }),
    { statusCodes: [429, 500, 502, 503, 504], maxRetries: 3, delays: [1000, 2000, 4000] },
  );

  await withRetry(
    () => orderClient.createOrder({
      marketSlug: slug,
      tokenId:    yesTokenId,
      side:       Side.SELL,
      price:      mid * (1 + SPREAD),
      size:       SIZE,
      orderType:  OrderType.GTC,
      postOnly:   true,
    }),
    { statusCodes: [429, 500, 502, 503, 504], maxRetries: 3, delays: [1000, 2000, 4000] },
  );

  quotedMid = mid;
}

setInterval(() => {
  requote('btc-100k-weekly').catch(console.error);
}, 2_000);

# Module 15, Basic quote placer with reposition on mid drift.

import asyncio
import os
from eth_account import Account
from limitless_sdk.api import HttpClient, retry_on_errors
from limitless_sdk.markets import MarketFetcher
from limitless_sdk.orders import OrderClient
from limitless_sdk.types import Side, OrderType

SPREAD     = 0.02    # quote ±2% of mid
REPOSITION = 0.005   # re-quote if mid moves > 0.5%
SIZE       = 100.0   # shares per quote

http_client    = HttpClient()
market_fetcher = MarketFetcher(http_client)
wallet         = Account.from_key(os.environ["PRIVATE_KEY"])
order_client   = OrderClient(http_client, wallet=wallet, market_fetcher=market_fetcher)

state = {"mid": 0.0}


@retry_on_errors(status_codes={429, 500, 502, 503, 504}, max_retries=3, delays=[1, 2, 4])
async def place(slug: str, token_id: str, side: Side, price: float) -> None:
    await order_client.create_order(
        token_id=token_id,
        price=price,
        size=SIZE,
        side=side,
        order_type=OrderType.GTC,
        market_slug=slug,
        post_only=True,   # rejects if it would cross, guarantees maker fees
    )


async def requote(slug: str) -> None:
    # 1. Pull orderbook for a fresh mid.
    #    GET /markets/{slug}/orderbook
    book = await market_fetcher.get_orderbook(slug)
    bids, asks = book.get("bids") or [], book.get("asks") or []
    if not bids or not asks:
        return
    best_bid = float(bids[0]["price"])
    best_ask = float(asks[0]["price"])
    mid      = (best_bid + best_ask) / 2

    # 2. Skip if drift is below the reposition threshold.
    if state["mid"] and abs(mid - state["mid"]) / state["mid"] < REPOSITION:
        return

    # 3. Cancel every live order on this market before re-quoting.
    #    DELETE /orders/all/{slug}
    await order_client.cancel_all(slug)

    # 4. Place a fresh maker-only pair on the YES token.
    market = await market_fetcher.get_market(slug)
    yes_token_id = market["positionIds"][0]

    await place(slug, yes_token_id, Side.BUY,  mid * (1 - SPREAD))
    await place(slug, yes_token_id, Side.SELL, mid * (1 + SPREAD))

    state["mid"] = mid


async def main() -> None:
    while True:
        await requote("btc-100k-weekly")
        await asyncio.sleep(2)


if __name__ == "__main__":
    asyncio.run(main())

// Module 15, Basic quote placer with reposition on mid drift.

package main

import (
    "context"
    "log"
    "math"
    "os"
    "time"

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

const (
    Spread     = 0.02   // quote ±2% of mid
    Reposition = 0.005  // re-quote if mid moves > 0.5%
    Size       = 100.0  // shares per quote
)

func main() {
    ctx := context.Background()

    client        := limitless.NewHttpClient()
    marketFetcher := limitless.NewMarketFetcher(client)
    orderClient, err := limitless.NewOrderClient(client, os.Getenv("PRIVATE_KEY"))
    if err != nil { log.Fatal(err) }

    retryCfg := limitless.RetryConfig{
        StatusCodes:     []int{429, 500, 502, 503, 504},
        MaxRetries:      3,
        ExponentialBase: 2.0,
        MaxDelay:        60 * time.Second,
    }

    slug := "btc-100k-weekly"
    var quotedMid float64

    tick := time.NewTicker(2 * time.Second)
    defer tick.Stop()

    for range tick.C {
        // 1. Pull orderbook for a fresh mid.
        book, err := marketFetcher.GetOrderBook(ctx, slug)
        if err != nil {
            log.Println(err); continue
        }
        if len(book.Bids) == 0 || len(book.Asks) == 0 { continue }
        bestBid := book.Bids[0].Price
        bestAsk := book.Asks[0].Price
        mid := (bestBid + bestAsk) / 2

        // 2. Skip if drift is below reposition threshold.
        if quotedMid != 0 && math.Abs(mid-quotedMid)/quotedMid < Reposition {
            continue
        }

        // 3. Cancel every live order on this market.
        if _, err := orderClient.CancelAll(ctx, slug); err != nil {
            log.Println(err); continue
        }

        // 4. Place a maker-only pair on the YES token.
        market, err := marketFetcher.GetMarket(ctx, slug)
        if err != nil { log.Println(err); continue }

        place := func(side limitless.Side, price float64) error {
            return limitless.WithRetry(ctx, func() error {
                _, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
                    OrderType:  limitless.OrderTypeGTC,
                    MarketSlug: slug,
                    Args: limitless.GTCOrderArgs{
                        TokenID:  market.Tokens.Yes,
                        Side:     side,
                        Price:    price,
                        Size:     Size,
                        PostOnly: true,
                    },
                })
                return err
            }, retryCfg)
        }

        if err := place(limitless.SideBuy,  mid*(1-Spread)); err != nil { log.Println(err) }
        if err := place(limitless.SideSell, mid*(1+Spread)); err != nil { log.Println(err) }

        quotedMid = mid
    }
}