KaleidoSDK Troubleshooting

import { KaleidoError, RateLimitError, QuoteExpiredError } from 'kaleido-sdk';

try {
  const quote = await client.maker.getQuote({ /* ... */ });
  const swap = await client.maker.initSwap({ /* ... */ });
} catch (error) {
  if (error instanceof QuoteExpiredError) {
    // Get a fresh quote and retry
  } else if (error instanceof RateLimitError) {
    await new Promise(r => setTimeout(r, (error.retryAfter ?? 5) * 1000));
  } else if (error instanceof KaleidoError && error.isRetryable()) {
    // Back off and retry — see Retry Patterns below
  } else if (error instanceof KaleidoError) {
    console.error(`SDK error [${error.code}]: ${error.message}`);
  }
}

import asyncio

from kaleido_sdk import (
    KaleidoError,
    PairQuoteRequest,
    QuoteExpiredError,
    RateLimitError,
    SwapRequest,
)

try:
    quote = await client.maker.get_quote(PairQuoteRequest(...))
    swap = await client.maker.init_swap(SwapRequest(...))
except QuoteExpiredError:
    # Get a fresh quote and retry
    pass
except RateLimitError as e:
    await asyncio.sleep(e.retry_after or 5)
except KaleidoError as e:
    if e.is_retryable():
        # Back off and retry — see Retry Patterns below
        pass
    else:
        print(f"SDK error [{e.code}]: {e}")

async function withRetry<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (error instanceof KaleidoError && error.isRetryable() && attempt < maxRetries - 1) {
        const delay = Math.pow(2, attempt) * 1000;
        await new Promise(r => setTimeout(r, delay));
        continue;
      }
      throw error;
    }
  }
  throw new Error('Max retries exceeded');
}

const pairs = await withRetry(() => client.maker.listPairs());

import asyncio

async def with_retry(fn, max_retries=3):
    for attempt in range(max_retries):
        try:
            return await fn()
        except KaleidoError as e:
            if e.is_retryable() and attempt < max_retries - 1:
                delay = 2 ** attempt
                await asyncio.sleep(delay)
                continue
            raise
    raise RuntimeError("Max retries exceeded")

pairs = await with_retry(lambda: client.maker.list_pairs())