Error Responses#

async function fetchMarket(address: string) {
  try {
    const response = await fetch(`/api/markets/${address}`);

    if (!response.ok) {
      const error = await response.json();

      switch (error.code) {
        case 'UNAUTHORIZED':
          throw new Error('Please check your API key');
        case 'NOT_FOUND':
          throw new Error('Market not found');
        case 'RATE_LIMITED':
          const retryAfter = error.retryAfter || 60;
          throw new Error(`Rate limited. Retry after ${retryAfter}s`);
        default:
          throw new Error(error.error || 'Unknown error');
      }
    }

    return response.json();
  } catch (error) {
    console.error('API Error:', error);
    throw error;
  }
}

import requests

def fetch_market(address):
    response = requests.get(f'{BASE_URL}/api/markets/{address}')

    if response.status_code == 200:
        return response.json()

    error = response.json()

    if response.status_code == 401:
        raise AuthenticationError(error['error'])
    elif response.status_code == 404:
        raise NotFoundError(f"Market {address} not found")
    elif response.status_code == 429:
        raise RateLimitError(error.get('retryAfter', 60))
    else:
        raise APIError(error['error'])

function useMarket(address: string) {
  const [data, setData] = useState(null);
  const [error, setError] = useState<string | null>(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    async function fetchData() {
      try {
        const response = await fetch(`/api/markets/${address}`);

        if (!response.ok) {
          const errorData = await response.json();
          setError(getErrorMessage(errorData));
          return;
        }

        setData(await response.json());
        setError(null);
      } catch (e) {
        setError('Network error. Please try again.');
      } finally {
        setLoading(false);
      }
    }

    fetchData();
  }, [address]);

  return { data, error, loading };
}

function getErrorMessage(error: any): string {
  switch (error.code) {
    case 'NOT_FOUND':
      return 'Market not found. Please check the address.';
    case 'RATE_LIMITED':
      return 'Too many requests. Please wait a moment.';
    case 'INTERNAL_ERROR':
      return 'Server error. Please try again later.';
    default:
      return error.error || 'An error occurred.';
  }
}

async function fetchWithRetry(url: string, maxRetries = 3, initialDelay = 1000) {
  let lastError: Error | null = null;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url);

      if (response.ok) {
        return response.json();
      }

      const error = await response.json();

      // Retry rate limits using Retry-After when present
      if (response.status === 429) {
        const retryAfterHeader = response.headers.get('retry-after');
        const retryAfterSeconds = retryAfterHeader ? Number(retryAfterHeader) : NaN;
        const retryDelay =
          Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0
            ? retryAfterSeconds * 1000
            : initialDelay * Math.pow(2, attempt);
        await sleep(retryDelay);
        continue;
      }

      // Don't retry other client errors
      if (response.status >= 400 && response.status < 500) {
        throw new Error(error.error);
      }

      // Server error - use backoff
      await sleep(initialDelay * Math.pow(2, attempt));
    } catch (error) {
      lastError = error as Error;
    }
  }

  throw lastError || new Error('Max retries exceeded');
}