Handle errors and retries

// Retry transient failures. Every attempt is signed again.
import { OlympexApiError, olympexRequest, type HttpMethod, type Json } from "./sign-request.ts"; // /authentication/sign-requests

/** 5xx responses (envelope or gateway), NO_ROUTE and network failures are worth another attempt with backoff. */
export const isRetryable = (error: unknown): boolean => {
  if (error instanceof OlympexApiError) return error.status >= 500 || error.code === "NO_ROUTE";
  // fetch() rejects with a TypeError when the network fails, and AbortSignal.timeout() with a TimeoutError.
  return error instanceof TypeError || (error instanceof Error && error.name === "TimeoutError");
};

const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

/** These create a resource each time they succeed. A blind retry after a timeout can create a duplicate. */
const CREATES = new Set(["/accounts", "/limit-order", "/dca-order/strategies"]);
export const isSafeToRepeat = (method: HttpMethod, path: string): boolean =>
  method !== "POST" || !CREATES.has(path.split("?")[0]);

export async function olympexRequestWithRetry<T>(
  method: HttpMethod,
  path: string,
  body?: Json,
  { attempts = 4, baseDelayMs = 1_000, maxDelayMs = 20_000 } = {},
): Promise<T> {
  let reSigned = false;
  for (let attempt = 1; ; attempt++) {
    try {
      return await olympexRequest<T>(method, path, body); // signs now: new timestamp, new nonce
    } catch (error) {
      const api = error instanceof OlympexApiError ? error : undefined;
      // One freshly signed attempt fixes a gateway 401 or 403 from a stale timestamp or a reused nonce.
      // Gateway 401 and 403 are returned before the request reaches Olympex, so nothing was created.
      const reSign = !reSigned && (api?.code === "HTTP_401" || api?.code === "HTTP_403");
      if (reSign) reSigned = true;
      const retry = attempt < attempts && (reSign || (isRetryable(error) && isSafeToRepeat(method, path)));
      console.warn(
        JSON.stringify({
          event: "olympex_request_failed",
          method,
          path,
          attempt,
          retry,
          status: api?.status,
          code: api?.code ?? (error instanceof Error ? error.name : "unknown"),
          requestId: api?.requestId, // envelope errors only; gateway errors carry it in the apigw-requestid header
          at: new Date().toISOString(),
        }),
      );
      if (!retry) throw error;
      // Exponential backoff with full jitter: 0 to 1 s, 0 to 2 s, 0 to 4 s, ... capped at maxDelayMs.
      await sleep(Math.random() * Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1)));
    }
  }
}

"""Retry transient Olympex failures. Every attempt is signed again."""
import logging
import random
import time

import requests

from sign_request import OlympexApiError, olympex_request  # /authentication/sign-requests

log = logging.getLogger("olympex")
TRANSPORT_ERRORS = (requests.ConnectionError, requests.Timeout)


def is_retryable(error):
    """5xx responses (envelope or gateway), NO_ROUTE and network failures are worth another attempt with backoff."""
    if isinstance(error, OlympexApiError):
        return error.status >= 500 or error.code == "NO_ROUTE"
    return isinstance(error, TRANSPORT_ERRORS)


# These create a resource each time they succeed. A blind retry after a timeout can create a duplicate.
CREATES = {"/accounts", "/limit-order", "/dca-order/strategies"}


def is_safe_to_repeat(method, path):
    return method.upper() != "POST" or path.split("?")[0] not in CREATES


def olympex_request_with_retry(method, path, body=None, attempts=4, base_delay=1.0, max_delay=20.0):
    re_signed = False
    for attempt in range(1, attempts + 1):
        try:
            return olympex_request(method, path, body)  # signs now: new timestamp, new nonce
        except (OlympexApiError, *TRANSPORT_ERRORS) as error:
            # One freshly signed attempt fixes a gateway 401 or 403 from a stale timestamp or a reused nonce.
            # Those are returned before the request reaches Olympex, so nothing was created.
            re_sign = not re_signed and getattr(error, "code", None) in ("HTTP_401", "HTTP_403")
            if re_sign:
                re_signed = True
            retry = attempt < attempts and (re_sign or (is_retryable(error) and is_safe_to_repeat(method, path)))
            log.warning(
                "olympex_request_failed method=%s path=%s attempt=%d retry=%s status=%s code=%s requestId=%s",
                method,
                path,
                attempt,
                retry,
                getattr(error, "status", None),
                getattr(error, "code", type(error).__name__),
                getattr(error, "request_id", None),  # envelope errors only; gateway errors carry it in the apigw-requestid header
            )
            if not retry:
                raise
            # Exponential backoff with full jitter: 0 to 1 s, 0 to 2 s, 0 to 4 s, ... capped at max_delay.
            time.sleep(random.uniform(0, min(max_delay, base_delay * 2 ** (attempt - 1))))

import { olympexRequestWithRetry } from "./olympex-retry.ts";

const supported = await olympexRequestWithRetry<boolean>("POST", "/support-chain", { chainId: 137 });

from olympex_retry import olympex_request_with_retry

supported = olympex_request_with_retry("POST", "/support-chain", {"chainId": 137})

import { olympexRequestWithRetry } from "./olympex-retry.ts";

type SentOrder = { accountTo: string; chainId: number; inTokenAddress: string; outTokenAddress: string; amount: string; priceTrigger: string; expired: string };
type LimitOrder = { id: string; status: string; inTokenAddress: string; outTokenAddress: string; amount: number; priceTrigger: number; expired: string };

/** Returns the order a failed POST /limit-order created, or undefined if it created none. */
export async function findLimitOrder(sent: SentOrder): Promise<LimitOrder | undefined> {
  // GET is safe to repeat. accountTo must be the exact form you sent: the filter is case-sensitive.
  const orders = await olympexRequestWithRetry<LimitOrder[]>("GET", `/limit-order?accountTo=${sent.accountTo}&chainId=${sent.chainId}`);
  return orders.find(
    (o) =>
      o.expired === sent.expired &&
      o.inTokenAddress.toLowerCase() === sent.inTokenAddress.toLowerCase() &&
      o.outTokenAddress.toLowerCase() === sent.outTokenAddress.toLowerCase() &&
      o.amount === Number(sent.amount) && // responses return amounts as numbers
      o.priceTrigger === Number(sent.priceTrigger),
  );
}

from olympex_retry import olympex_request_with_retry


def find_limit_order(sent):
    """Return the order a failed POST /limit-order created, or None if it created none."""
    # GET is safe to repeat. accountTo must be the exact form you sent: the filter is case-sensitive.
    orders = olympex_request_with_retry("GET", f"/limit-order?accountTo={sent['accountTo']}&chainId={sent['chainId']}")
    for order in orders:
        if (
            order["expired"] == sent["expired"]
            and order["inTokenAddress"].lower() == sent["inTokenAddress"].lower()
            and order["outTokenAddress"].lower() == sent["outTokenAddress"].lower()
            and order["amount"] == float(sent["amount"])  # responses return amounts as numbers
            and order["priceTrigger"] == float(sent["priceTrigger"])
        ):
            return order
    return None