Error Handling

import httpx
import time
import json

RETRYABLE = {500, 502, 503, 504}
MAX_RETRIES = 3

def call_limitguard(endpoint: str, payload: dict, api_key: str) -> dict:
    headers = {
        "X-API-Key": api_key,
        "Content-Type": "application/json",
    }

    for attempt in range(MAX_RETRIES):
        response = httpx.post(
            f"https://api.limitguard.ai{endpoint}",
            headers=headers,
            json=payload,
            timeout=10.0,
        )

        # Success
        if response.status_code in (200, 201):
            return response.json()

        error = response.json()

        # Rate limited — respect Retry-After
        if response.status_code == 429:
            wait = int(response.headers.get("Retry-After", 60))
            print(f"Rate limited. Waiting {wait}s...")
            time.sleep(wait)
            continue

        # Transient server error — exponential backoff
        if response.status_code in RETRYABLE:
            wait = 2 ** attempt
            print(f"Server error ({response.status_code}). Retrying in {wait}s...")
            time.sleep(wait)
            continue

        # Validation error — surface all field errors
        if response.status_code == 422:
            errors = error.get("detail", [])
            if isinstance(errors, list):
                for err in errors:
                    print(f"  Field '{err['field']}': {err['message']}")
            raise ValueError(f"Validation failed: {errors}")

        # Payment required (x402) — handle separately
        if response.status_code == 402:
            raise PaymentRequiredError(error)

        # Non-retryable client error
        raise LimitGuardError(
            status=response.status_code,
            title=error.get("title"),
            detail=error.get("detail"),
        )

    raise LimitGuardError(status=429, title="Max retries exceeded", detail=None)


class LimitGuardError(Exception):
    def __init__(self, status: int, title: str, detail):
        self.status = status
        self.title = title
        self.detail = detail
        super().__init__(f"HTTP {status}: {title} — {detail}")


class PaymentRequiredError(Exception):
    def __init__(self, body: dict):
        self.accepts = body.get("accepts", [])
        super().__init__("Payment required (x402)")

const RETRYABLE = new Set([500, 502, 503, 504]);
const MAX_RETRIES = 3;

async function callLimitGuard(endpoint, payload, apiKey) {
  const headers = {
    "X-API-Key": apiKey,
    "Content-Type": "application/json",
  };

  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
    const response = await fetch(`https://api.limitguard.ai${endpoint}`, {
      method: "POST",
      headers,
      body: JSON.stringify(payload),
    });

    // Success
    if (response.status === 200 || response.status === 201) {
      return response.json();
    }

    const error = await response.json();

    // Rate limited — respect Retry-After
    if (response.status === 429) {
      const wait = parseInt(response.headers.get("Retry-After") ?? "60", 10);
      console.log(`Rate limited. Waiting ${wait}s...`);
      await sleep(wait * 1000);
      continue;
    }

    // Transient server error — exponential backoff
    if (RETRYABLE.has(response.status)) {
      const wait = Math.pow(2, attempt);
      console.log(`Server error (${response.status}). Retrying in ${wait}s...`);
      await sleep(wait * 1000);
      continue;
    }

    // Validation error — surface all field errors
    if (response.status === 422) {
      const errors = Array.isArray(error.detail) ? error.detail : [];
      errors.forEach(({ field, message }) => {
        console.error(`  Field '${field}': ${message}`);
      });
      throw Object.assign(new Error("Validation failed"), { errors });
    }

    // Payment required (x402)
    if (response.status === 402) {
      throw Object.assign(new Error("Payment required (x402)"), {
        accepts: error.accepts ?? [],
      });
    }

    // Non-retryable client error
    throw Object.assign(new Error(`HTTP ${response.status}: ${error.title}`), {
      status: response.status,
      detail: error.detail,
    });
  }

  throw new Error("Max retries exceeded");
}

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

# Check status code and handle errors in shell scripts

response=$(curl -s -w "\n%{http_code}" -X POST https://api.limitguard.ai/v1/entity/check \
  -H "X-API-Key: lg_live_xxxxxxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{"entity_name": "Acme Corp BV", "country": "NL"}')

http_code=$(echo "$response" | tail -1)
body=$(echo "$response" | head -1)

case $http_code in
  200|201)
    echo "Success: $body"
    ;;
  401)
    echo "Error: Invalid API key. Check X-API-Key header."
    ;;
  422)
    echo "Validation error: $(echo $body | jq '.detail')"
    ;;
  429)
    retry_after=$(curl -s -I https://api.limitguard.ai/v1/entity/check | grep -i retry-after | awk '{print $2}')
    echo "Rate limited. Retry after ${retry_after}s"
    ;;
  5*)
    echo "Server error $http_code — retry with backoff"
    ;;
  *)
    echo "Unexpected status $http_code: $body"
    ;;
esac

import httpx
import base64
import json
import secrets
import time
from eth_account import Account
from eth_account.messages import encode_typed_data

def call_with_x402(
    endpoint: str,
    payload: dict,
    sender_key: str,
    chain_id: str = "eip155:8453",
) -> dict:
    """Make an API call, automatically handling x402 payment if required."""

    url = f"https://api.limitguard.ai{endpoint}"

    # First attempt — no payment
    response = httpx.post(url, json=payload, timeout=10.0)

    if response.status_code != 402:
        response.raise_for_status()
        return response.json()

    # Parse payment requirements
    requirements = response.json()
    accepted = next(
        (a for a in requirements["accepts"] if a["chainId"] == chain_id),
        None,
    )
    if not accepted:
        raise ValueError(f"No accepted payment option for chain {chain_id}")

    # Build payment
    x_payment = build_evm_payment(
        chain_id=chain_id,
        amount=int(accepted["amount"]),
        sender_key=sender_key,
        recipient=accepted["recipient"],
        usdc_address=accepted["contractAddress"],
    )

    # Retry with payment
    paid_response = httpx.post(
        url,
        headers={"X-PAYMENT": x_payment, "Content-Type": "application/json"},
        json=payload,
        timeout=10.0,
    )
    paid_response.raise_for_status()
    return paid_response.json()


def build_evm_payment(chain_id, amount, sender_key, recipient, usdc_address):
    sender = Account.from_key(sender_key).address
    chain_num = int(chain_id.split(":")[1])
    nonce = "0x" + secrets.token_hex(32)
    now = int(time.time())

    domain = {"name": "USD Coin", "version": "2", "chainId": chain_num, "verifyingContract": usdc_address}
    message = {"from": sender, "to": recipient, "value": amount, "validAfter": now - 10, "validBefore": now + 300, "nonce": bytes.fromhex(nonce[2:])}
    types = {
        "EIP712Domain": [{"name": "name", "type": "string"}, {"name": "version", "type": "string"}, {"name": "chainId", "type": "uint256"}, {"name": "verifyingContract", "type": "address"}],
        "TransferWithAuthorization": [{"name": "from", "type": "address"}, {"name": "to", "type": "address"}, {"name": "value", "type": "uint256"}, {"name": "validAfter", "type": "uint256"}, {"name": "validBefore", "type": "uint256"}, {"name": "nonce", "type": "bytes32"}],
    }
    signed = Account.sign_message(encode_typed_data(domain, types, "TransferWithAuthorization", message), private_key=sender_key)
    payload = {"chainId": chain_id, "amount": str(amount), "sender": sender, "recipient": recipient, "nonce": nonce, "signature": signed.signature.hex(), "validAfter": now - 10, "validBefore": now + 300}
    return base64.b64encode(json.dumps(payload).encode()).decode()

import { ethers } from "ethers";

async function callWithX402(endpoint, payload, signer, chainId = "eip155:8453") {
  const url = `https://api.limitguard.ai${endpoint}`;

  // First attempt — no payment
  let response = await fetch(url, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(payload),
  });

  if (response.status !== 402) {
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    return response.json();
  }

  // Parse payment requirements
  const requirements = await response.json();
  const accepted = requirements.accepts.find((a) => a.chainId === chainId);
  if (!accepted) throw new Error(`No accepted payment option for chain ${chainId}`);

  // Build payment
  const xPayment = await buildEvmPayment(
    chainId,
    parseInt(accepted.amount, 10),
    signer,
    accepted.recipient,
    accepted.contractAddress,
  );

  // Retry with payment
  response = await fetch(url, {
    method: "POST",
    headers: { "X-PAYMENT": xPayment, "Content-Type": "application/json" },
    body: JSON.stringify(payload),
  });

  if (!response.ok) throw new Error(`Payment rejected: HTTP ${response.status}`);
  return response.json();
}

async function buildEvmPayment(chainId, amount, signer, recipient, usdcAddress) {
  const chainNum = parseInt(chainId.split(":")[1]);
  const nonce = "0x" + [...crypto.getRandomValues(new Uint8Array(32))].map((b) => b.toString(16).padStart(2, "0")).join("");
  const now = Math.floor(Date.now() / 1000);

  const domain = { name: "USD Coin", version: "2", chainId: chainNum, verifyingContract: usdcAddress };
  const types = { TransferWithAuthorization: [{ name: "from", type: "address" }, { name: "to", type: "address" }, { name: "value", type: "uint256" }, { name: "validAfter", type: "uint256" }, { name: "validBefore", type: "uint256" }, { name: "nonce", type: "bytes32" }] };
  const message = { from: signer.address, to: recipient, value: amount, validAfter: now - 10, validBefore: now + 300, nonce };

  const signature = await signer.signTypedData(domain, types, message);
  const payloadObj = { chainId, amount: String(amount), sender: signer.address, recipient, nonce, signature, validAfter: now - 10, validBefore: now + 300 };
  return btoa(JSON.stringify(payloadObj));
}