Error Handling

{
  "timestamp": "2026-06-23T15:30:00.123",
  "status": 404,
  "error": "Not Found",
  "message": "Transaction not found",
  "path": "/api/transactions/abc123",
  "requestId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
}

class GeroNexusError extends Error {
  constructor(status, body) {
    super(body.message || `HTTP ${status}`);
    this.name = 'GeroNexusError';
    this.status = status;
    this.errorCode = body.errorCode;       // may be undefined
    this.requestId = body.requestId;
    this.validationErrors = body.validationErrors;
  }
}

async function apiRequest(endpoint, options = {}) {
  const response = await fetch(`https://nexus.gerowallet.io${endpoint}`, {
    ...options,
    headers: {
      'X-Api-Key': process.env.NEXUS_API_KEY,
      ...options.headers
    }
  });

  const body = await response.json().catch(() => ({}));
  if (!response.ok) throw new GeroNexusError(response.status, body);
  return body;
}

try {
  const block = await apiRequest('/api/blocks/latest');
  console.log(block);
} catch (error) {
  if (error instanceof GeroNexusError) {
    switch (error.status) {
      case 401:
        console.error('Check your X-Api-Key header'); break;
      case 429:
        console.error('Rate limited — back off'); break;
      case 404:
        console.error('Not found:', error.message); break;
      default:
        console.error(`API ${error.status} (${error.requestId}):`, error.message);
    }
  } else {
    console.error('Network error:', error);
  }
}

import requests

class GeroNexusError(Exception):
    def __init__(self, status: int, body: dict):
        super().__init__(body.get('message', f'HTTP {status}'))
        self.status = status
        self.error_code = body.get('errorCode')       # may be None
        self.request_id = body.get('requestId')
        self.validation_errors = body.get('validationErrors')


def api_request(endpoint: str, method: str = 'GET', **kwargs) -> dict:
    response = requests.request(
        method,
        f'https://nexus.gerowallet.io{endpoint}',
        headers={'X-Api-Key': os.environ['NEXUS_API_KEY']},
        **kwargs,
    )
    body = response.json() if response.content else {}
    if not response.ok:
        raise GeroNexusError(response.status_code, body)
    return body


try:
    block = api_request('/api/blocks/latest')
    print(block)
except GeroNexusError as e:
    if e.status == 401:
        print('Check your X-Api-Key header')
    elif e.status == 429:
        print('Rate limited — back off')
    else:
        print(f'API {e.status} ({e.request_id}): {e}')
except requests.RequestException as e:
    print(f'Network error: {e}')

async function fetchWithRetry(fn, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      const retryable = error.status >= 500 || error.status === 429;
      if (!retryable || attempt === maxRetries) throw error;

      const delay = Math.min(1000 * 2 ** attempt, 30000);
      await new Promise((r) => setTimeout(r, delay));
    }
  }
}