Error handling.

// Module 10, Use the SDK's built-in retry helpers.
//
// @limitless-exchange/sdk ships two retry mechanisms so you
// don't have to hand-roll your own:
//   withRetry(fn, opts)       , wrapper for a single call
//   @retryOnErrors(opts)      , decorator for a whole method
//
// Both only retry on the status-code allow-list you pass in.
// Stick to [429, 500, 502, 503, 504]. 4xx errors (except 429)
// are your bug, not a transient blip.

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

// 1) Inline wrapper, one retry policy, one call.
const markets = await withRetry(
  () => marketFetcher.getActiveMarkets({ limit: 100 }),
  {
    statusCodes: [429, 500, 502, 503, 504],
    maxRetries:  3,
    delays:      [1000, 2000, 4000],
    onRetry:     (err, attempt) => {
      if (err instanceof ApiError) {
        console.warn(`retry ${attempt}, HTTP ${err.status}: ${err.message}`);
      }
    },
  },
);

// 2) Decorator, every call on the method inherits the policy.
class Strategy {
  @retryOnErrors({
    statusCodes:     [429, 500, 502, 503, 504],
    maxRetries:      5,
    exponentialBase: 2,
    maxDelay:        60_000,
  })
  async refreshMarkets() {
    return marketFetcher.getActiveMarkets({ limit: 100 });
  }
}

# Module 10, Use the SDK's built-in retry helper.
#
# limitless_sdk.api ships a @retry_on_errors decorator that
# implements exponential backoff with a status-code allow-list.
# Stick to {429, 500, 502, 503, 504}. 4xx errors (except 429)
# are your bug, not a transient blip.

from limitless_sdk.api import APIError, retry_on_errors
from limitless_sdk.markets import MarketFetcher

market_fetcher = MarketFetcher(http_client)


@retry_on_errors(
    status_codes={429, 500, 502, 503, 504},
    max_retries=3,
    delays=[1, 2, 4],
)
async def fetch_markets():
    # On 429/5xx the decorator sleeps then re-invokes this function.
    # On 400/401/403/404 the APIError propagates immediately.
    return await market_fetcher.get_active_markets(limit=100)


async def main():
    try:
        markets = await fetch_markets()
    except APIError as e:
        # Exhausted the retry budget, or a non-retryable status.
        print(f"status {e.status_code}: {e.message}")
        raise

// Module 10, Use the SDK's built-in retry helpers.
//
// The Go SDK ships TWO options:
//   limitless.WithRetry(ctx, fn, cfg)        , wrap a single call
//   limitless.NewRetryableClient(client, cfg), wrap the HTTP client
//                                                so every call inherits the policy
//
// Both respect Retry-After when the server sets it, otherwise
// they fall back to ExponentialBase^attempt capped at MaxDelay.

package main

import (
    "context"
    "errors"
    "log"
    "time"

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

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

    retryCfg := 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 in %v: %v", attempt, delay, err)
        },
    }

    // Option A, one-shot wrapper.
    mf := limitless.NewMarketFetcher(client)
    result, err := limitless.WithRetry(
        ctx,
        func() (*limitless.ActiveMarketsResponse, error) {
            return mf.GetActiveMarkets(ctx, &limitless.ActiveMarketsParams{Limit: 100})
        },
        retryCfg,
    )
    if err != nil {
        var rateLimitErr *limitless.RateLimitError
        if errors.As(err, &rateLimitErr) {
            log.Printf("still rate-limited after retries")
        }
        log.Fatal(err)
    }
    log.Printf("fetched %d markets", len(result.Data))

    // Option B, retryable client applied to every call.
    retryable := limitless.NewRetryableClient(client, retryCfg)
    _ = limitless.NewMarketFetcher(retryable.Client)
}

// Module 10, Catch ApiError and log the raw response body.
//
// ApiError carries { status, message, data }. `data` is the raw
// response body, grep that for any correlation id or validation
// detail the server attached. Also catch TypeError for pure
// network failures (no response at all).

import {
  HttpClient,
  OrderClient,
  ApiError,
  Side,
  OrderType,
} from '@limitless-exchange/sdk';

async function safeCreateOrder(orderClient: OrderClient, params: any) {
  try {
    return await orderClient.createOrder(params);
  } catch (error) {
    if (error instanceof ApiError) {
      console.error(
        `[HTTP ${error.status}] ${error.message}`,
        { body: error.data, params },
      );
      // Decide what to do by status.
      if (error.status === 429) return { retry: true };
      if (error.status === 409) return { duplicate: true };
      throw error;
    }
    if (error instanceof TypeError) {
      // fetch() threw before we got a response, network failure.
      console.error('network error, no response', error);
      throw error;
    }
    throw error;
  }
}

# Module 10, Catch APIError and log status + message.
#
# limitless_sdk.api.APIError exposes status_code and message.
# Log both plus your own context (order params, market slug)
# so that you can reproduce the failure later.

import logging

from limitless_sdk.api import APIError
from limitless_sdk.orders import OrderClient
from limitless_sdk.types import Side, OrderType

log = logging.getLogger("limitless")


async def safe_create_order(order_client: OrderClient, **params) -> dict | None:
    try:
        return await order_client.create_order(**params)
    except APIError as e:
        log.error(
            "createOrder failed: status=%s message=%s params=%s",
            e.status_code,
            e.message,
            params,
        )
        if e.status_code == 429:
            return {"retry": True}
        if e.status_code == 409:
            return {"duplicate": True}
        raise
    except Exception:
        log.exception("unexpected error calling createOrder")
        raise

// Module 10, Unwrap the typed error hierarchy.
//
// The Go SDK ships a typed error tree:
//   APIError            , base (has Status, Message, Body)
//   ValidationError     , 400 / OrderValidationError for client-side
//   AuthenticationError , 401 / 403
//   RateLimitError      , 429 (may carry Retry-After)
//
// Use errors.As to branch on whichever one you care about
// and log the raw body for support tickets.

package main

import (
    "context"
    "errors"
    "log"

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

func safeCreateOrder(
    ctx context.Context,
    client *limitless.OrderClient,
    params limitless.CreateOrderParams,
) (*limitless.OrderResponse, error) {
    result, err := client.CreateOrder(ctx, params)
    if err == nil {
        return result, nil
    }

    var validErr *limitless.ValidationError
    var authErr *limitless.AuthenticationError
    var rateLimitErr *limitless.RateLimitError
    var orderValidErr *limitless.OrderValidationError
    var apiErr *limitless.APIError

    switch {
    case errors.As(err, &orderValidErr):
        log.Printf("client-side validation failed: %v", orderValidErr)
    case errors.As(err, &validErr):
        log.Printf("400 bad request: %v", validErr)
    case errors.As(err, &authErr):
        log.Printf("auth failure (401/403): %v, check API key", authErr)
    case errors.As(err, &rateLimitErr):
        log.Printf("429 rate limited: %v", rateLimitErr)
    case errors.As(err, &apiErr):
        log.Printf("HTTP %d: %s body=%s", apiErr.Status, apiErr.Message, apiErr.Body)
    default:
        log.Printf("unexpected error: %v", err)
    }
    return nil, err
}