Error handling

import {
  ConflictError,    // 409 — active intent or other request conflict
  ActiveSwapIntentError, // 409 — active swap intent already exists (exposes existingIntentId)
  AmbiguousPoolPairError, // 409 — token pair maps to multiple pools
  AuthError,        // 401 — invalid or missing API key or wallet token
  ValidationError,  // 400 — bad parameters
  SettlementSafetyError, // 400 — swaps.create blocked by the pre-payout safety guard (exposes code/reason)
  NotFoundError,    // 404 — pool/intent/party not found
  RateLimitError,   // 429 — too many requests
  SlippageError,    // swap output below minimum
  PriceImpactError, // created swap later hit price_impact_exceeded during wait()
  InsufficientLiquidityError, // swap refunded because the pool was too thin
  InsufficientAmountError, // swap refunded because the deposit was below required network cost
  OutputFailedError,// swap output transfer failed
  SwapFailedError,  // generic terminal swap failure
  RefundFailedError,// swap refund failed
  ExpiredError,     // backend marked the intent expired or cancelled
  NetworkError,     // transport-level failure before an HTTP response
  TimeoutError,     // client-side request timeout or wait() polling deadline
  ServerError       // 500 — something went wrong on our end
} from '@oneswap/sdk'

try {
  const swap = await client.swaps.create({ ... })
  const result = await swap.wait()
} catch (err) {
  if (err instanceof SlippageError) {
    console.log('Swap refunded due to slippage')
  } else if (err instanceof PriceImpactError) {
    console.log('Swap rejected — price impact exceeds the maximum allowed')
  } else if (err instanceof InsufficientLiquidityError) {
    console.log('Swap refunded due to insufficient liquidity')
  } else if (err instanceof InsufficientAmountError) {
    console.log('Swap refunded because the input amount was too small')
  } else if (err instanceof OutputFailedError) {
    console.log('Swap payout failed — inspect the terminal intent status')
  } else if (err instanceof RefundFailedError) {
    console.log('Swap refund failed — manual intervention is required')
  } else if (err instanceof SwapFailedError) {
    console.log('Swap failed — inspect the intent before retrying')
  } else if (err instanceof ExpiredError) {
    console.log('Backend marked the intent expired or cancelled')
  } else if (err instanceof AmbiguousPoolPairError) {
    console.log(err.candidates)
  } else if (err instanceof ActiveSwapIntentError) {
    // An active intent already exists — resume it instead of creating a duplicate
    const status = await client.swaps.getStatus(err.existingIntentId)
  } else if (err instanceof ConflictError) {
    console.log(err.message)
  } else if (err instanceof AuthError) {
    console.log('Check your API key and repeat wallet authentication if needed')
  } else if (err instanceof SettlementSafetyError) {
    // swaps.create was blocked by the pre-payout safety guard before any deposit.
    // No intent was created. Reduce the swap size or wait a few minutes, then retry.
    console.log(err.message, err.code, err.reason)
  } else if (err instanceof ValidationError) {
    console.log(err.message)
  } else if (err instanceof TimeoutError) {
    // Client-side deadline (one request, or the wait() polling loop).
    // The swap may still be settling — resume with client.swaps.getStatus(id).
    console.log('Client timed out; the swap may still be settling')
  } else if (err instanceof NetworkError) {
    console.log(err.message)
  }
}

try {
  const swap = await client.swaps.create({ ... })
} catch (err) {
  if (err instanceof SettlementSafetyError) {
    // No intent was created. Reduce the swap size or wait a few minutes, then retry.
    console.log(err.message)        // user-facing sentence
    console.log(err.code)           // e.g. 'output_velocity_exceeded'
    console.log(err.reason)         // technical detail (bps/thresholds)
  }
}

err.message    // human-readable description
err.statusCode // HTTP status (0 for lifecycle or transport errors)
err.response   // raw response body from the API

const result = await swap.wait({
  pollInterval: 5000,   // check every 5 seconds (default: 3s)
  timeout: 600000       // give up after 10 minutes (default: 35min)
})