Error Handling

{
  "data": null,
  "error": {
    "code": "INVALID_PARAMS",
    "message": "Parameter 'fromChain' is required",
    "details": {
      "field": "fromChain",
      "reason": "missing"
    }
  },
  "meta": {
    "requestId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "timestamp": 1711234567,
    "rateLimit": {
      "limit": 2000,
      "remaining": 1995,
      "reset": 1711234627
    }
  }
}

async function withRetry<T>(
  fn: () => Promise<T>,
  maxRetries: number = 3,
  baseDelay: number = 1000
): Promise<T> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const result = await fn();
      return result;
    } catch (error: any) {
      const retryableCodes = [
        "INTERNAL_ERROR",
        "UPSTREAM_ERROR",
        "RPC_FAILURE",
        "SERVICE_UNAVAILABLE",
        "TIMEOUT",
        "UPSTREAM_TIMEOUT",
      ];

      if (
        attempt === maxRetries ||
        !retryableCodes.includes(error.code)
      ) {
        throw error;
      }

      const delay = baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
      console.log(`Retry ${attempt + 1}/${maxRetries} in ${Math.round(delay)}ms`);
      await new Promise((r) => setTimeout(r, delay));
    }
  }
  throw new Error("Max retries exceeded");
}

// Usage
const quote = await withRetry(() =>
  client.getQuote({
    fromChain: 1,
    toChain: 42161,
    fromToken: "0x0000000000000000000000000000000000000000",
    toToken: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
    fromAmount: "1000000000000000000",
    fromAddress: "0xYourAddress",
  })
);

async function handleRateLimit<T>(fn: () => Promise<{ meta: any; error: any; data: T }>) {
  const response = await fn();

  if (response.error?.code === "RATE_LIMIT") {
    const resetAt = response.meta.rateLimit.reset;
    const waitMs = (resetAt - Math.floor(Date.now() / 1000)) * 1000 + 1000;
    console.log(`Rate limited. Waiting ${waitMs}ms...`);
    await new Promise((r) => setTimeout(r, waitMs));
    return fn(); // Retry once
  }

  return response;
}

async function getQuoteWithFallback(params: QuoteParams) {
  // Try with original params
  let quote = await client.getQuote(params);

  if (quote.error?.code === "NO_ROUTE_FOUND") {
    // Strategy 1: Increase slippage
    quote = await client.getQuote({ ...params, slippage: 0.05 });
  }

  if (quote.error?.code === "NO_ROUTE_FOUND") {
    // Strategy 2: Try a different intermediate token
    // For example, swap to USDC first, then to the target token
    console.log("No direct route found. Consider a multi-hop swap.");
  }

  return quote;
}

if (error.code === "SLIPPAGE_ERROR") {
  // Get a fresh quote with higher slippage
  const freshQuote = await client.getQuote({
    ...originalParams,
    slippage: Math.min(originalParams.slippage * 2, 0.10), // Double slippage, max 10%
  });

  // Show the user the new estimated output before proceeding
  console.log("Price has changed. New estimated output:", freshQuote.estimate.toAmount);
}

import { Hypermid } from "@hypermid/sdk";

interface HypermidResponse<T> {
  data: T | null;
  error: { code: string; message: string; details: any } | null;
  meta: { requestId: string; rateLimit: { reset: number } };
}

async function handleResponse<T>(response: HypermidResponse<T>): Promise<T> {
  if (!response.error) {
    return response.data!;
  }

  const { code, message, details } = response.error;
  const { requestId } = response.meta;

  switch (code) {
    case "INVALID_PARAMS":
    case "VALIDATION_ERROR":
      // Developer error — fix the request
      throw new Error(`Invalid request [${requestId}]: ${message} (${JSON.stringify(details)})`);

    case "SLIPPAGE_ERROR":
      // Price moved — notify user
      throw new Error(`Price changed beyond tolerance. Please get a fresh quote.`);

    case "NO_ROUTE_FOUND":
      // No route — inform user
      throw new Error(`No swap route available for this token pair and amount.`);

    case "UNAUTHORIZED":
      // Auth error — check API key
      throw new Error(`Authentication failed. Check your API key.`);

    case "RATE_LIMIT":
      // Rate limited — wait and retry
      throw new Error(`Rate limit exceeded. Retry after reset.`);

    case "TRANSACTION_BUILD_FAILED":
      // Transaction build failure
      throw new Error(`Failed to build transaction [${requestId}]. Try again or use a different route.`);

    case "UPSTREAM_ERROR":
    case "RPC_FAILURE":
    case "UPSTREAM_TIMEOUT":
      // Upstream issue — retry
      throw new Error(`Upstream provider error [${requestId}]: ${message}. Retry in a moment.`);

    case "SERVICE_UNAVAILABLE":
    case "TIMEOUT":
    case "INTERNAL_ERROR":
      // Server issue — retry with backoff
      throw new Error(`Service error [${requestId}]: ${message}. Retry with backoff.`);

    default:
      throw new Error(`Unknown error [${requestId}]: ${code} - ${message}`);
  }
}