Rate limits.

// Module 09, Client-side token bucket (defense in depth).
//
// Limitless does not publish per-second / per-minute quotas, so
// the SDK-provided withRetry() + @retryOnErrors decorator cover
// the reactive case. A client-side limiter is your PROACTIVE
// layer, it stops your app from bursting in the first place.

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

class TokenBucket {
  private tokens: number;
  private lastRefill: number;

  constructor(private capacity: number, private refillPerSec: number) {
    this.tokens = capacity;
    this.lastRefill = Date.now();
  }

  private refill() {
    const now = Date.now();
    const add = ((now - this.lastRefill) / 1000) * this.refillPerSec;
    this.tokens = Math.min(this.capacity, this.tokens + add);
    this.lastRefill = now;
  }

  async acquire(): Promise<void> {
    while (true) {
      this.refill();
      if (this.tokens >= 1) { this.tokens -= 1; return; }
      const waitMs = ((1 - this.tokens) / this.refillPerSec) * 1000;
      await new Promise(r => setTimeout(r, waitMs));
    }
  }
}

// Pick conservative numbers until you see a 429 in the wild.
const limiter = new TokenBucket(20, 10);

// Limiter (proactive) + withRetry (reactive) = belt and braces.
export async function safeCall<T>(fn: () => Promise<T>): Promise<T> {
  await limiter.acquire();
  return withRetry(fn, {
    statusCodes: [429, 500, 502, 503, 504],
    maxRetries:  3,
    delays:      [1000, 2000, 4000],
    onRetry:     (err, attempt) => console.warn(`retry ${attempt}: ${err.message}`),
  });
}

# Module 09, Client-side token bucket (defense in depth).
#
# Limitless does not publish per-second / per-minute quotas. The
# SDK-provided retry_on_errors decorator covers the reactive case
# (back off when you actually see a 429). A client-side limiter
# is your PROACTIVE layer, it stops the burst from happening
# in the first place.

import asyncio
import time

from limitless_sdk.api import retry_on_errors


class TokenBucket:
    def __init__(self, capacity: int, refill_per_sec: float) -> None:
        self.capacity = capacity
        self.refill_per_sec = refill_per_sec
        self.tokens = float(capacity)
        self.last_refill = time.monotonic()
        self._lock = asyncio.Lock()

    def _refill(self) -> None:
        now = time.monotonic()
        self.tokens = min(
            self.capacity,
            self.tokens + (now - self.last_refill) * self.refill_per_sec,
        )
        self.last_refill = now

    async def acquire(self) -> None:
        while True:
            async with self._lock:
                self._refill()
                if self.tokens >= 1:
                    self.tokens -= 1
                    return
                wait = (1 - self.tokens) / self.refill_per_sec
            await asyncio.sleep(wait)


# Conservative defaults, tune once you see production traffic.
limiter = TokenBucket(capacity=20, refill_per_sec=10)


# Reactive layer: the SDK's retry_on_errors decorator backs off
# automatically on 429 + 5xx with exponential delays.
@retry_on_errors(status_codes={429, 500, 502, 503, 504}, max_retries=3, delays=[1, 2, 4])
async def limited_fetch(http_client, path: str):
    await limiter.acquire()
    return await http_client.get(path)

// Module 09, Client-side token bucket (defense in depth) +
// the SDK's WithRetry/RetryableClient for reactive backoff.
//
// Limitless does not publish per-second quotas, so we combine
// two layers: golang.org/x/time/rate keeps bursts in check,
// and limitless.WithRetry handles the occasional 429 that
// sneaks through.

package main

import (
    "context"
    "log"
    "time"

    limitless "github.com/limitless-labs-group/limitless-exchange-go-sdk/limitless"
    "golang.org/x/time/rate"
)

// 10 req/s sustained, burst up to 20.
var limiter = rate.NewLimiter(rate.Limit(10), 20)

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

    // Proactive limiter + reactive retry helper.
    if err := limiter.Wait(ctx); err != nil {
        log.Fatal(err)
    }
    result, err := limitless.WithRetry(
        ctx,
        func() (*limitless.ActiveMarketsResponse, error) {
            return mf.GetActiveMarkets(ctx, &limitless.ActiveMarketsParams{Limit: 10})
        },
        limitless.RetryConfig{
            StatusCodes:     []int{429, 500, 502, 503, 504},
            MaxRetries:      3,
            ExponentialBase: 2.0,
            MaxDelay:        60 * time.Second,
            OnRetry: func(attempt int, err error, delay time.Duration) {
                log.Printf("retry %d after %v: %v", attempt, delay, err)
            },
        },
    )
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("fetched %d markets", len(result.Data))
}