Error Handling

import { isFlashnetError } from '@flashnet/sdk';

try {
  const swap = await client.executeSwap({
    poolId: "pool-id",
    assetInAddress: "bitcoin-pubkey",
    assetOutAddress: "usdb-pubkey",
    amountIn: "100000000",
    minAmountOut: "99000000",
    maxSlippageBps: 100,
  });
  
  console.log('Swap successful:', swap.amountOut);
} catch (error) {
  if (isFlashnetError(error)) {
    console.log('Error code:', error.errorCode);
    console.log('Category:', error.category);
    console.log('User message:', error.userMessage);
    
    // Check if auto-clawback was attempted
    if (error.wasClawbackAttempted()) {
      const summary = error.clawbackSummary!;
      
      if (error.wereAllTransfersRecovered()) {
        console.log('✅ All funds recovered automatically!');
      } else if (error.werePartialTransfersRecovered()) {
        console.log(`⚠️ Partial recovery: ${summary.successCount}/${summary.totalTransfers}`);
        console.log('Unrecovered transfers:', summary.unrecoveredTransferIds);
      } else {
        console.log('❌ Fund recovery failed');
        console.log('At-risk transfers:', error.transferIds);
      }
    }
    
    // Check specific error types
    if (error.isSlippageError()) {
      console.log('Price moved too much - funds auto-refunded');
    } else if (error.isInsufficientLiquidityError()) {
      console.log('Pool lacks liquidity - funds auto-refunded');
    }
  }
}

interface FlashnetError extends Error {
  // Core properties
  errorCode: string;           // e.g., "FSAG-4202"
  category: string;            // "Validation" | "Security" | "Infrastructure" | "Business" | "System"
  recovery: string;            // "clawback_required" | "clawback_recommended" | "auto_refund" | "none"
  httpStatus: number;          // HTTP status code
  requestId: string;           // Unique request ID for debugging
  
  // User-facing
  userMessage: string;         // Human-readable explanation
  actionHint: string;          // Suggested action
  isRetryable: boolean;        // Whether retry makes sense
  
  // Clawback info
  transferIds: string[];       // Unrecovered transfer IDs
  lpIdentityPublicKey?: string; // Pool ID for clawback
  clawbackSummary?: {          // Auto-clawback results
    attempted: boolean;
    totalTransfers: number;
    successCount: number;
    failureCount: number;
    recoveredTransferIds: string[];
    unrecoveredTransferIds: string[];
    results: ClawbackAttemptResult[];
  };
}

// Recovery status
error.isClawbackRequired();        // True if clawback is mandatory
error.isClawbackRecommended();     // True if clawback is advised
error.shouldClawback();            // True if either required or recommended
error.willAutoRefund();            // True if funds return automatically
error.hasTransfersAtRisk();        // True if unrecovered transfers exist

// Clawback status
error.wasClawbackAttempted();      // True if auto-clawback ran
error.wereAllTransfersRecovered(); // True if all funds recovered
error.werePartialTransfersRecovered(); // True if some but not all recovered
error.getRecoveredTransferCount(); // Number of recovered transfers
error.getRecoveredTransferIds();   // IDs of recovered transfers
error.getUnrecoveredTransferIds(); // IDs still at risk

// Error type checks
error.isValidationError();
error.isSecurityError();
error.isInfrastructureError();
error.isBusinessError();
error.isSystemError();

// Specific error checks
error.isSlippageError();           // FSAG-4202
error.isInsufficientLiquidityError(); // FSAG-4201
error.isAuthError();               // FSAG-2003 or FSAG-2004
error.isPoolNotFoundError();       // FSAG-4001
error.isTransferAlreadyUsedError(); // FSAG-4401

// Formatting
error.getUserFriendlyMessage();    // Full user-facing message
error.toLogString();               // Formatted for logging
error.toJSON();                    // Serializable object

import { isFlashnetError, FlashnetError } from '@flashnet/sdk';

try {
  await client.executeSwap({ /* ... */ });
} catch (error) {
  if (isFlashnetError(error)) {
    // Full typed access to error properties
    console.log(error.errorCode, error.userMessage);
  } else {
    // Generic error handling
    console.error('Unknown error:', error);
  }
}

if (error.isBusinessError()) {
  if (error.isSlippageError()) {
    // Suggest user increase slippage tolerance
    showMessage('Price moved. Try increasing slippage tolerance.');
  } else if (error.isInsufficientLiquidityError()) {
    // Suggest smaller trade or different pool
    showMessage('Not enough liquidity. Try a smaller amount.');
  }
  
  // Funds are automatically returned
  if (error.willAutoRefund()) {
    showMessage('Your funds will be returned automatically.');
  }
}

catch (error) {
  if (isFlashnetError(error)) {
    console.error(`[${error.requestId}] ${error.toLogString()}`);
    // Report to your error tracking service
    reportError({
      requestId: error.requestId,
      errorCode: error.errorCode,
      ...error.toJSON()
    });
  }
}

async function executeWithRetry(fn: () => Promise<any>, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (isFlashnetError(error) && error.isRetryable && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000; // Exponential backoff
        console.log(`Retrying in ${delay}ms... (attempt ${attempt}/${maxRetries})`);
        await new Promise(r => setTimeout(r, delay));
        continue;
      }
      throw error;
    }
  }
}