Error Handling

{
  "error": "Error Type",
  "message": "Human-readable error description",
  "code": "ERROR_CODE",
  "details": {
    // Additional context (optional)
  }
}

class GeroNexusError extends Error {
  constructor(response) {
    super(response.message);
    this.name = 'GeroNexusError';
    this.status = response.status;
    this.code = response.code;
    this.details = response.details;
  }
}

async function apiRequest(endpoint, options = {}) {
  const response = await fetch(`https://nexus-dev.gerowallet.io${endpoint}`, {
    ...options,
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json',
      ...options.headers
    }
  });

  const data = await response.json();

  if (!response.ok) {
    throw new GeroNexusError({
      status: response.status,
      ...data
    });
  }

  return data;
}

// Usage with error handling
try {
  const block = await apiRequest('/api/blocks/latest');
  console.log(block);
} catch (error) {
  if (error instanceof GeroNexusError) {
    switch (error.code) {
      case 'INVALID_TOKEN':
        await refreshToken();
        // Retry request
        break;
      case 'RATE_LIMIT_EXCEEDED':
        await delay(error.details?.retry_after || 1000);
        // Retry request
        break;
      case 'RESOURCE_NOT_FOUND':
        console.log('Resource not found:', error.message);
        break;
      default:
        console.error('API Error:', error.message);
    }
  } else {
    console.error('Network error:', error);
  }
}

import requests
from typing import Optional

class GeroNexusError(Exception):
    """Custom exception for Gero Nexus API errors"""

    def __init__(self, status: int, error: str, message: str,
                 code: str, details: Optional[dict] = None):
        super().__init__(message)
        self.status = status
        self.error = error
        self.code = code
        self.details = details or {}

    def __str__(self):
        return f"[{self.code}] {self.args[0]}"


def api_request(endpoint: str, method: str = 'GET', **kwargs) -> dict:
    """Make API request with error handling"""
    response = requests.request(
        method,
        f'https://nexus-dev.gerowallet.io{endpoint}',
        headers={
            'Authorization': f'Bearer {access_token}',
            'Content-Type': 'application/json'
        },
        **kwargs
    )

    data = response.json()

    if not response.ok:
        raise GeroNexusError(
            status=response.status_code,
            error=data.get('error', 'Unknown'),
            message=data.get('message', 'An error occurred'),
            code=data.get('code', 'UNKNOWN_ERROR'),
            details=data.get('details')
        )

    return data


# Usage with error handling
try:
    block = api_request('/api/blocks/latest')
    print(block)
except GeroNexusError as e:
    if e.code == 'INVALID_TOKEN':
        refresh_token()
        # Retry request
    elif e.code == 'RATE_LIMIT_EXCEEDED':
        time.sleep(e.details.get('retry_after', 1))
        # Retry request
    elif e.code == 'RESOURCE_NOT_FOUND':
        print(f'Resource not found: {e}')
    else:
        print(f'API Error: {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 isRetryable =
        error.status >= 500 ||
        error.code === 'RATE_LIMIT_EXCEEDED' ||
        error.code === 'TIMEOUT';

      if (!isRetryable || attempt === maxRetries) {
        throw error;
      }

      const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
      console.log(`Retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
      await new Promise(r => setTimeout(r, delay));
    }
  }
}