Track a swap to finality

import { WaitForTransactionReceiptTimeoutError, createPublicClient, http, type Hash } from "viem";
import { polygon } from "viem/chains";

const publicClient = createPublicClient({ chain: polygon, transport: http(process.env.POLYGON_RPC_URL) });

type SwapOutcome = { state: "success" | "reverted" | "replaced" | "pending"; hash: Hash };

async function waitForSwap(hash: Hash): Promise<SwapOutcome> {
  let replaced = false;
  try {
    const receipt = await publicClient.waitForTransactionReceipt({
      hash,
      confirmations: 1, // raise to match your own finality policy
      timeout: 5 * 60_000,
      onReplaced: (replacement) => {
        replaced = replacement.reason !== "repriced"; // "repriced" is the same swap with a higher fee
      },
    });
    if (replaced) return { state: "replaced", hash: receipt.transactionHash }; // the swap itself never ran
    return { state: receipt.status === "success" ? "success" : "reverted", hash: receipt.transactionHash };
  } catch (error) {
    if (error instanceof WaitForTransactionReceiptTimeoutError) return { state: "pending", hash }; // check again later
    throw error;
  }
}

import { JsonRpcProvider, isError } from "ethers";

const provider = new JsonRpcProvider(process.env.POLYGON_RPC_URL);

type SwapOutcome = { state: "success" | "reverted" | "replaced" | "pending"; hash: string };

async function waitForSwap(hash: string): Promise<SwapOutcome> {
  const tx = await provider.getTransaction(hash);
  if (!tx) return { state: "pending", hash }; // this node hasn't seen it yet
  try {
    const receipt = await tx.wait(1, 5 * 60_000); // throws CALL_EXCEPTION on revert, TIMEOUT after 5 minutes
    return { state: "success", hash: receipt?.hash ?? hash };
  } catch (error) {
    if (isError(error, "TRANSACTION_REPLACED")) {
      // "repriced" is the same swap with a higher fee; "replaced" and "cancelled" mean the swap never ran.
      if (error.reason === "repriced") return { state: error.receipt.status === 1 ? "success" : "reverted", hash: error.receipt.hash };
      return { state: "replaced", hash: error.receipt.hash };
    }
    if (isError(error, "CALL_EXCEPTION")) return { state: "reverted", hash };
    if (isError(error, "TIMEOUT")) return { state: "pending", hash };
    throw error;
  }
}

// Poll POST /tx-status until a cross-chain transfer reaches a final state.
import { OlympexApiError, olympexRequest } from "./sign-request.ts"; // /authentication/sign-requests

export type TransferStatus = {
  status: string; // the provider's own value
  detailStatus: string;
  fromChainId: number;
  toChainId: number;
  fromTxHash?: string;
  toTxHash?: string | null;
  fromAmount?: string; // as the provider reports it: check the unit
  toAmount?: string; // as the provider reports it: check the unit
  bridgeHash?: string | null;
};

export type TransferOutcome =
  | { state: "success"; transfer: TransferStatus }
  | { state: "failure"; transfer: TransferStatus }
  | { state: "unknown"; transfer?: TransferStatus; requestId?: string }; // cap reached

const SUCCESS = new Set(["SUCCESS", "DONE", "success", "Success"]);
const FAILURE = new Set(["FAILURE", "FAILED", "failed", "REFUND", "Reverted", "FROM_FAILURE", "INVALID"]);

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

export async function waitForTransfer(
  transfer: { hash: string; chainId: number; dexHash: string },
  options: { maxWaitMs?: number; onUpdate?: (status: TransferStatus) => void } = {},
): Promise<TransferOutcome> {
  const { maxWaitMs = 60 * 60_000, onUpdate } = options; // your cap, not an Olympex limit
  const body = { hash: transfer.hash, chainId: transfer.chainId, dexHash: transfer.dexHash.toLowerCase() };
  const deadline = Date.now() + maxWaitMs;
  let delayMs = 15_000;
  let last: TransferStatus | undefined;
  let requestId: string | undefined;
  let signedAgain = false;

  while (Date.now() < deadline) {
    await sleep(delayMs + Math.random() * 3_000); // 15 s growing to 30 s, with jitter
    delayMs = Math.min(delayMs * 1.5, 30_000);
    try {
      last = await olympexRequest<TransferStatus>("POST", "/tx-status", body); // signed again on every call
    } catch (error) {
      if (error instanceof OlympexApiError && error.status < 500) {
        // A gateway 401 or 403 gets one new signature. Any other 4xx won't fix itself: fix the request.
        const gatewayAuth = error.code === "HTTP_401" || error.code === "HTTP_403";
        if (!gatewayAuth || signedAgain) throw error;
        signedAgain = true;
        continue;
      }
      if (error instanceof OlympexApiError) requestId = error.requestId ?? requestId; // 500 TX_STATUS_ERROR: unknown yet
      else if (!(error instanceof TypeError) && !(error instanceof Error && error.name === "TimeoutError")) throw error;
      continue; // no status yet, or a transient failure: poll again
    }
    onUpdate?.(last);
    if (SUCCESS.has(last.status)) return { state: "success", transfer: last };
    if (FAILURE.has(last.status)) return { state: "failure", transfer: last };
  }
  return { state: "unknown", transfer: last, requestId };
}

"""Poll POST /tx-status until a cross-chain transfer reaches a final state."""
import random
import time

import requests

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

SUCCESS = {"SUCCESS", "DONE", "success", "Success"}
FAILURE = {"FAILURE", "FAILED", "failed", "REFUND", "Reverted", "FROM_FAILURE", "INVALID"}


def wait_for_transfer(tx_hash, chain_id, dex_hash, max_wait_s=3600, on_update=None):
    """Return {"state": "success" | "failure" | "unknown", "transfer": ..., "request_id": ...}."""
    body = {"hash": tx_hash, "chainId": int(chain_id), "dexHash": dex_hash.lower()}
    deadline = time.monotonic() + max_wait_s  # your cap, not an Olympex limit
    delay, last, request_id, signed_again = 15.0, None, None, False
    while time.monotonic() < deadline:
        time.sleep(delay + random.uniform(0, 3))  # 15 s growing to 30 s, with jitter
        delay = min(delay * 1.5, 30.0)
        try:
            last = olympex_request("POST", "/tx-status", body)  # signed again on every call
        except OlympexApiError as error:
            if error.status < 500:
                # A gateway 401 or 403 gets one new signature. Any other 4xx won't fix itself: fix the request.
                if error.code not in ("HTTP_401", "HTTP_403") or signed_again:
                    raise
                signed_again = True
                continue
            request_id = error.request_id or request_id  # 500 TX_STATUS_ERROR: unknown yet
            continue
        except (requests.ConnectionError, requests.Timeout):
            continue  # transient network failure: poll again
        if on_update:
            on_update(last)
        if last["status"] in SUCCESS:
            return {"state": "success", "transfer": last}
        if last["status"] in FAILURE:
            return {"state": "failure", "transfer": last}
    return {"state": "unknown", "transfer": last, "request_id": request_id}

import { waitForTransfer } from "./wait-for-transfer.ts";

const outcome = await waitForTransfer(
  {
    hash: "0x5f2b0a3c3e8f9d1b7a6c4e2d0f8b6a4c2e0d8f6b4a2c0e8d6f4b2a0c8e6d4f2b", // source-chain transaction
    chainId: 137,
    dexHash: "0x6c2142a4113d1a2ef94717109dd5ac71f69439465f95a170fb9cf0f56d76ad7c", // from POST /swap
  },
  { onUpdate: (status) => console.log(status.status, status.detailStatus) },
);
console.log(outcome.state);

from wait_for_transfer import wait_for_transfer

outcome = wait_for_transfer(
    "0x5f2b0a3c3e8f9d1b7a6c4e2d0f8b6a4c2e0d8f6b4a2c0e8d6f4b2a0c8e6d4f2b",  # source-chain transaction
    137,
    "0x6c2142a4113d1a2ef94717109dd5ac71f69439465f95a170fb9cf0f56d76ad7c",  # from POST /swap
    on_update=lambda status: print(status["status"], status["detailStatus"]),
)
print(outcome["state"])