Error Handling

import { RebelfiError, ErrorCode } from '@rebelfi/sdk';

try {
  await client.operations.supply(request);
} catch (error) {
  if (error instanceof RebelfiError) {
    console.error('Message:', error.message);
    console.error('Status:', error.statusCode);
    console.error('Code:', error.code);
    console.error('Details:', error.details);
  }
}

if (error instanceof RebelfiError) {
  if (error.is(ErrorCode.INSUFFICIENT_BALANCE)) {
    // Show "insufficient funds" message to user
  } else if (error.is(ErrorCode.OPERATION_EXPIRED)) {
    // Retry with a new operation
  }
}

if (error.is(ErrorCode.INVALID_AMOUNT)) {
  // Show validation error to user
  showError('Please enter a valid amount');
}

switch (error.code) {
  case ErrorCode.INSUFFICIENT_BALANCE:
    const balance = error.details?.available;
    showError(`Insufficient balance. Available: ${balance}`);
    break;

  case ErrorCode.STRATEGY_NOT_ACTIVE:
    // Refresh and show available strategies
    await refreshStrategies();
    showError('This strategy is no longer available');
    break;

  case ErrorCode.OPERATION_EXPIRED:
    // Automatically retry
    return await retryOperation();

  case ErrorCode.OPERATION_IN_PROGRESS:
    // Another operation is executing — wait or cancel it
    const { operationId, walletId } = error.details as { operationId: number; walletId: number };
    showError(`Operation ${operationId} is still executing. Please wait for it to complete.`);
    break;
}

if (error.is(ErrorCode.INSUFFICIENT_GAS)) {
  showError('Please add SOL to cover transaction fees');
}

if (error.is(ErrorCode.RATE_LIMIT_EXCEEDED)) {
  // Exponential backoff
  await delay(retryCount * 1000);
  return await retry();
}

const operation = await client.operations.get(operationId);

if (operation.status === 'FAILED') {
  const tx = operation.transactions[0];

  switch (tx.failureCode) {
    case 'REVERTED':
      console.error('Contract reverted:', tx.revertReason);
      break;
    case 'OUT_OF_GAS':
      console.error('Transaction ran out of gas');
      break;
    case 'TIMEOUT':
      console.error('Transaction not confirmed in time');
      break;
    case 'INSUFFICIENT_FUNDS':
      console.error('Not enough SOL for gas');
      break;
  }
}

import { RebelfiError, ErrorCode } from '@rebelfi/sdk';

async function handleSupply(params: SupplyParams) {
  try {
    const operation = await client.operations.supply(params);
    return { success: true, operation };
  } catch (error) {
    if (!(error instanceof RebelfiError)) {
      // Unexpected error
      console.error('Unexpected error:', error);
      return { success: false, error: 'An unexpected error occurred' };
    }

    // User-fixable errors
    if (error.is(ErrorCode.INSUFFICIENT_BALANCE)) {
      return {
        success: false,
        error: 'Insufficient balance',
        userAction: 'deposit_more'
      };
    }

    if (error.is(ErrorCode.INSUFFICIENT_GAS)) {
      return {
        success: false,
        error: 'Need SOL for transaction fee',
        userAction: 'add_sol'
      };
    }

    // Retryable errors
    if (error.is(ErrorCode.RATE_LIMIT_EXCEEDED) ||
        error.is(ErrorCode.TIMEOUT) ||
        error.is(ErrorCode.NETWORK_ERROR)) {
      return {
        success: false,
        error: 'Temporary error',
        retryable: true
      };
    }

    // Strategy issues
    if (error.is(ErrorCode.STRATEGY_NOT_ACTIVE) ||
        error.is(ErrorCode.STRATEGY_NOT_FOUND)) {
      return {
        success: false,
        error: 'Strategy unavailable',
        userAction: 'select_different_strategy'
      };
    }

    // Auth issues
    if (error.is(ErrorCode.INVALID_API_KEY) ||
        error.is(ErrorCode.API_KEY_DISABLED)) {
      console.error('API key issue:', error.message);
      return {
        success: false,
        error: 'Service configuration error'
      };
    }

    // Unknown API error
    return {
      success: false,
      error: error.message
    };
  }
}

async function withRetry<T>(
  fn: () => Promise<T>,
  options: { maxAttempts?: number; baseDelay?: number } = {}
): Promise<T> {
  const { maxAttempts = 3, baseDelay = 1000 } = options;

  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (!(error instanceof RebelfiError)) throw error;

      const isRetryable =
        error.is(ErrorCode.TIMEOUT) ||
        error.is(ErrorCode.NETWORK_ERROR) ||
        error.is(ErrorCode.RATE_LIMIT_EXCEEDED);

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

      const delay = baseDelay * Math.pow(2, attempt - 1);
      await new Promise(r => setTimeout(r, delay));
    }
  }

  throw new Error('Max attempts reached');
}

// Usage
const operation = await withRetry(() =>
  client.operations.supply(params)
);

async function supplyWithRetry(params: SupplyParams) {
  const maxRetries = 2;

  for (let i = 0; i < maxRetries; i++) {
    try {
      const operation = await client.operations.supply(params);

      // Check if we have enough time
      const expiresAt = new Date(operation.expiresAt);
      const timeLeft = expiresAt.getTime() - Date.now();

      if (timeLeft < 30000) {
        console.warn('Operation expires soon, may need retry');
      }

      return operation;
    } catch (error) {
      if (error instanceof RebelfiError &&
          error.is(ErrorCode.OPERATION_EXPIRED)) {
        console.log('Operation expired, retrying...');
        continue;
      }
      throw error;
    }
  }

  throw new Error('Failed after retries');
}