Order book.

// Module 08, Delta updates + periodic REST reconciliation.
//
// NOTE: Limitless does not document sequence numbers on the
// orderbookUpdate stream. The SDK applies deltas to its internal
// book for you, so your job isn't "detect gaps", it's "notice
// staleness" and reconcile against the REST endpoint on a timer.

import { HttpClient, MarketFetcher, WebSocketClient } from '@limitless-exchange/sdk';

const http = new HttpClient({ baseURL: 'https://api.limitless.exchange' });
const mf   = new MarketFetcher(http);
const ws   = new WebSocketClient({ url: 'wss://ws.limitless.exchange', autoReconnect: true });

const MARKET = 'btc-100k-weekly';
let   lastUpdate = 0;           // ms since epoch of last delta
const STALE_MS   = 15_000;      // if no delta in 15s, reconcile
const RECON_MS   = 60_000;      // and always reconcile every minute

ws.on('orderbookUpdate', (data) => {
  lastUpdate = Date.now();
  // The SDK has already merged this delta into its internal book.
  // Consume `data.orderbook` as your merged view for signal logic.
});

async function reconcile() {
  // Pull a fresh snapshot via MarketFetcher.getOrderBook (wraps
  // GET /markets/{slug}/orderbook) and diff against the SDK's view.
  // Use this as your staleness safety net, the server doesn't
  // persist subscriptions, and there's no sequence number to trust.
  const snapshot = await mf.getOrderBook(MARKET);
  console.log(`reconciled bids=${snapshot.bids.length} asks=${snapshot.asks.length}`);
}

setInterval(() => {
  if (Date.now() - lastUpdate > STALE_MS) {
    console.warn('book looks stale, reconciling');
    reconcile().catch(console.error);
  }
}, 5_000);

setInterval(reconcile, RECON_MS);

ws.connect();

# Module 08, Delta updates + periodic REST reconciliation.
#
# NOTE: Limitless does not document sequence numbers on the
# orderbookUpdate stream. The SDK maintains the local book for
# you, so your job isn't "detect gaps", it's "notice staleness"
# and reconcile against the REST endpoint on a timer.

import asyncio
import time

from limitless_sdk.api import HttpClient
from limitless_sdk.markets import MarketFetcher
from limitless_sdk.websocket import WebSocketClient, WebSocketConfig

http = HttpClient()
market_fetcher = MarketFetcher(http)
ws_client = WebSocketClient(WebSocketConfig(
    url="wss://ws.limitless.exchange",
    auto_reconnect=True,
))

MARKET    = "btc-100k-weekly"
STALE_SEC = 15
RECON_SEC = 60
last_update = 0.0


@ws_client.on("orderbookUpdate")
async def on_orderbook(data):
    global last_update
    last_update = time.time()
    # data["orderbook"] already reflects the merged book, consume it directly.


async def reconcile() -> None:
    # MarketFetcher.get_orderbook wraps GET /markets/{slug}/orderbook
    # and returns a dict with "bids" and "asks" arrays.
    snapshot = await market_fetcher.get_orderbook(MARKET)
    print(f"reconciled bids={len(snapshot['bids'])} asks={len(snapshot['asks'])}")


async def watchdog() -> None:
    while True:
        await asyncio.sleep(5)
        if time.time() - last_update > STALE_SEC:
            print("book looks stale, reconciling")
            try:
                await reconcile()
            except Exception as e:
                print("reconcile failed:", e)


async def heartbeat_reconcile() -> None:
    while True:
        await asyncio.sleep(RECON_SEC)
        await reconcile()


async def main():
    await ws_client.connect()
    await asyncio.gather(watchdog(), heartbeat_reconcile())


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

// Module 08, Delta updates + periodic REST reconciliation.
//
// NOTE: Limitless does not document sequence numbers on the
// orderbookUpdate stream. The SDK keeps the local book merged,
// so your job isn't "detect gaps", it's "notice staleness"
// and reconcile against GET /markets/{slug}/orderbook.

package main

import (
    "context"
    "log"
    "sync/atomic"
    "time"

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

const market = "btc-100k-weekly"

var lastUpdate atomic.Int64 // UnixMilli

func reconcile(ctx context.Context, mf *limitless.MarketFetcher) {
    // GetOrderBook wraps GET /markets/{slug}/orderbook and returns a
    // typed struct with Bids / Asks / AdjustedMidpoint / LastTradePrice.
    snap, err := mf.GetOrderBook(ctx, market)
    if err != nil {
        log.Println("reconcile failed:", err)
        return
    }
    log.Printf("reconciled bids=%d asks=%d", len(snap.Bids), len(snap.Asks))
}

func main() {
    ctx := context.Background()
    client := limitless.NewHttpClient()
    mf := limitless.NewMarketFetcher(client)

    ws := limitless.NewWebSocketClient()
    defer ws.Disconnect()

    ws.OnOrderbookUpdate(func(u limitless.OrderbookUpdate) {
        lastUpdate.Store(time.Now().UnixMilli())
        // u.Orderbook is the merged view, consume directly.
    })

    if err := ws.Connect(ctx); err != nil {
        log.Fatal(err)
    }
    _ = ws.Subscribe(ctx, limitless.ChannelSubscribeMarketPrices, limitless.SubscriptionOptions{
        MarketSlugs: []string{market},
    })

    // Stale watchdog.
    go func() {
        t := time.NewTicker(5 * time.Second)
        defer t.Stop()
        for range t.C {
            if time.Now().UnixMilli()-lastUpdate.Load() > 15_000 {
                log.Println("book looks stale, reconciling")
                reconcile(ctx, mf)
            }
        }
    }()

    // Heartbeat reconciliation.
    go func() {
        t := time.NewTicker(60 * time.Second)
        defer t.Stop()
        for range t.C {
            reconcile(ctx, mf)
        }
    }()

    select {}
}

// Module 08, Touch prices + live trade prints.
//
// For the touch (top of book) on AMM markets, newPriceData is
// the lightest feed: a delta with {yes, no} after every block.
// For CLOB touch, read `orderbook.bids[0]` / `orderbook.asks[0]`
// from the orderbookUpdate payload. For individual prints the
// SDK exposes the `tx` transaction event.

import { WebSocketClient } from '@limitless-exchange/sdk';

const ws = new WebSocketClient({
  url:           'wss://ws.limitless.exchange',
  autoReconnect: true,
});

const MARKETS = ['btc-100k-weekly'];

ws.on('connect', () => {
  ws.subscribe('subscribe_market_prices', { marketSlugs: MARKETS });
});

// AMM touch, fires on every block with the new yes/no prices.
ws.on('newPriceData', (d) => {
  console.log(`[PRC] ${d.marketAddress} yes=${d.updatedPrices.yes} no=${d.updatedPrices.no}`);
});

// CLOB touch, best bid/ask comes from the merged orderbook delta.
ws.on('orderbookUpdate', (d) => {
  const bid = d.orderbook.bids?.[0];
  const ask = d.orderbook.asks?.[0];
  if (bid && ask) {
    console.log(`[BBO] ${d.marketSlug} bid=${bid.price}x${bid.size} ask=${ask.price}x${ask.size}`);
  }
});

ws.connect();

# Module 08, Touch prices + live order book.
#
# AMM touch: newPriceData is the lightest feed, yes/no delta per block.
# CLOB touch: read orderbook.bids[0] / asks[0] from orderbookUpdate.

import asyncio

from limitless_sdk.websocket import WebSocketClient, WebSocketConfig

ws_client = WebSocketClient(WebSocketConfig(
    url="wss://ws.limitless.exchange",
    auto_reconnect=True,
))

MARKETS = ["btc-100k-weekly"]


@ws_client.on("connect")
async def on_connect():
    await ws_client.subscribe(
        "subscribe_market_prices",
        {"marketSlugs": MARKETS},
    )


@ws_client.on("newPriceData")
async def on_price(data):
    prices = data["updatedPrices"]
    print(f"[PRC] {data['marketAddress']} yes={prices['yes']} no={prices['no']}")


@ws_client.on("orderbookUpdate")
async def on_orderbook(data):
    book = data["orderbook"]
    bid = (book.get("bids") or [None])[0]
    ask = (book.get("asks") or [None])[0]
    if bid and ask:
        print(f"[BBO] {data['marketSlug']} bid={bid['price']}x{bid['size']} "
              f"ask={ask['price']}x{ask['size']}")


async def main():
    await ws_client.connect()
    await asyncio.Event().wait()


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

// Module 08, Touch prices + live order book.
//
// The Go SDK exposes typed callbacks instead of the raw event name:
//   OnNewPriceData    , AMM yes/no deltas
//   OnOrderbookUpdate , CLOB merged book; first row = touch
// Both arrive on the single market-prices subscription. There is no
// market-wide trade-print channel; for the trade tape, poll the REST
// feed GET /markets/{slug}/events.

package main

import (
    "context"
    "log"

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

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

    ws := limitless.NewWebSocketClient()
    defer ws.Disconnect()

    ws.OnNewPriceData(func(p limitless.NewPriceData) {
        if len(p.UpdatedPrices) > 0 {
            log.Printf("[PRC] %s yes=%.3f no=%.3f",
                p.MarketAddress, p.UpdatedPrices[0].YesPrice, p.UpdatedPrices[0].NoPrice)
        }
    })

    ws.OnOrderbookUpdate(func(u limitless.OrderbookUpdate) {
        if len(u.Orderbook.Bids) > 0 && len(u.Orderbook.Asks) > 0 {
            bid, ask := u.Orderbook.Bids[0], u.Orderbook.Asks[0]
            log.Printf("[BBO] %s bid=%.3f x%.2f ask=%.3f x%.2f",
                u.MarketSlug, bid.Price, bid.Size, ask.Price, ask.Size)
        }
    })

    if err := ws.Connect(ctx); err != nil {
        log.Fatal(err)
    }

    // CLOB orderbook + AMM price updates both arrive on this one subscription.
    if err := ws.Subscribe(ctx, limitless.ChannelSubscribeMarketPrices, limitless.SubscriptionOptions{
        MarketSlugs: []string{"btc-100k-weekly"},
    }); err != nil {
        log.Fatal(err)
    }
    select {}
}