const API_KEY = process.env.UNIKRON_API_KEY;
const API_URL = "https://api.unikron.ch";
 
async function getOrderStatus(orderId: string) {
  const response = await fetch(`${API_URL}/api/v1/mev/orders/${orderId}`, {
    headers: {
      "X-API-Key": API_KEY,
    },
  });
 
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }
 
  const { ok, data } = await response.json();
 
  if (!ok) {
    throw new Error(`API Error: ${data.error}`);
  }
 
  return data;
}
 
// Example: Poll until confirmed
async function waitForConfirmation(orderId: string) {
  while (true) {
    const order = await getOrderStatus(orderId);
 
    console.log(`Status: ${order.status}`);
 
    // Terminal states
    if (order.status === "confirmed") {
      console.log(" Transaction confirmed!");
      console.log(`TX Hash: ${order.txHash}`);
      console.log(`Block: ${order.blockNumber}`);
      return order;
    }
 
    if (order.status === "failed") {
      console.error(" Transaction failed");
      throw new Error(order.error || "Transaction failed");
    }
 
    // Wait 10 seconds before next poll
    await new Promise((resolve) => setTimeout(resolve, 10000));
  }
}
 
// Usage
const orderId = "ord_abc123xyz";
try {
  const result = await waitForConfirmation(orderId);
  console.log("Order complete:", result);
} catch (error) {
  console.error("Order failed:", error);
}

import os
import time
import requests
from typing import Dict, Any
 
API_KEY = os.environ.get("UNIKRON_API_KEY")
API_URL = "https://api.unikron.ch"
 
def get_order_status(order_id: str) -> Dict[str, Any]:
    """
    Get the current status of an order.
 
    Args:
        order_id: Order ID from submit response
 
    Returns:
        Order status data
 
    Raises:
        requests.HTTPError: If API request fails
        Exception: If API returns error response
    """
    response = requests.get(
        f"{API_URL}/api/v1/mev/orders/{order_id}",
        headers={
            "X-API-Key": API_KEY,
        },
        timeout=10
    )
 
    response.raise_for_status()
    data = response.json()
 
    if not data.get("ok"):
        error = data.get("error", "Unknown error")
        raise Exception(f"API Error: {error}")
 
    return data["data"]
 
 
def wait_for_confirmation(order_id: str, timeout: int = 300) -> Dict[str, Any]:
    """
    Poll order status until confirmed or failed.
 
    Args:
        order_id: Order ID to monitor
        timeout: Maximum wait time in seconds (default: 5 minutes)
 
    Returns:
        Final order status
 
    Raises:
        TimeoutError: If order doesn't confirm within timeout
        Exception: If order fails
    """
    start_time = time.time()
 
    while True:
        # Check timeout
        if time.time() - start_time > timeout:
            raise TimeoutError(f"Order {order_id} timed out after {timeout}s")
 
        # Get current status
        order = get_order_status(order_id)
        print(f"Status: {order['status']}")
 
        # Terminal states
        if order['status'] == 'confirmed':
            print(f" Transaction confirmed!")
            print(f"TX Hash: {order['txHash']}")
            print(f"Block: {order['blockNumber']}")
            return order
 
        if order['status'] == 'failed':
            error = order.get('error', 'Transaction failed')
            print(f" Transaction failed: {error}")
            raise Exception(error)
 
        # Wait 10 seconds before next poll
        time.sleep(10)
 
 
# Usage
order_id = "ord_abc123xyz"
try:
    result = wait_for_confirmation(order_id)
    print(f"Order complete: {result}")
except Exception as e:
    print(f"Order failed: {e}")

curl -X GET "https://api.unikron.ch/api/v1/mev/orders/ord_abc123xyz" \
  -H "X-API-Key: YOUR_API_KEY"

const API_KEY = process.env.UNIKRON_API_KEY;
const API_URL = "https://api.unikron.ch";
 
async function getUserOrders(
  userAddress: string,
  limit: number = 50,
  offset: number = 0,
  status?: string
) {
  const params = new URLSearchParams({
    limit: limit.toString(),
    offset: offset.toString(),
  });
 
  if (status) {
    params.append("status", status);
  }
 
  const response = await fetch(
    `${API_URL}/api/v1/mev/orders/user/${userAddress}?${params}`,
    {
      headers: {
        "X-API-Key": API_KEY,
      },
    }
  );
 
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }
 
  const { ok, data } = await response.json();
 
  if (!ok) {
    throw new Error(`API Error: ${data.error}`);
  }
 
  return data;
}
 
// Example: Get recent orders
const userAddress = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb";
 
try {
  const orders = await getUserOrders(userAddress, 20);
 
  console.log(`Total orders: ${orders.total}`);
  console.log(`Showing: ${orders.orders.length}`);
  console.log(`Has more: ${orders.hasMore}`);
 
  orders.orders.forEach((order) => {
    console.log(`\nOrder ID: ${order.orderId}`);
    console.log(`Status: ${order.status}`);
    console.log(`Created: ${order.createdAt}`);
    console.log(`TX Hash: ${order.txHash || "pending"}`);
  });
} catch (error) {
  console.error("Failed to get orders:", error);
}

import os
import requests
from typing import Dict, Any, Optional
 
API_KEY = os.environ.get("UNIKRON_API_KEY")
API_URL = "https://api.unikron.ch"
 
def get_user_orders(
    user_address: str,
    limit: int = 50,
    offset: int = 0,
    status: Optional[str] = None
) -> Dict[str, Any]:
    """
    Get order history for a user address.
 
    Args:
        user_address: User's wallet address
        limit: Maximum orders to return (default: 50, max: 200)
        offset: Number of orders to skip (default: 0)
        status: Filter by status (optional)
 
    Returns:
        Order history data
 
    Raises:
        requests.HTTPError: If API request fails
        Exception: If API returns error response
    """
    params = {
        "limit": limit,
        "offset": offset
    }
 
    if status:
        params["status"] = status
 
    response = requests.get(
        f"{API_URL}/api/v1/mev/orders/user/{user_address}",
        params=params,
        headers={
            "X-API-Key": API_KEY,
        },
        timeout=10
    )
 
    response.raise_for_status()
    data = response.json()
 
    if not data.get("ok"):
        error = data.get("error", "Unknown error")
        raise Exception(f"API Error: {error}")
 
    return data["data"]
 
 
# Example: Get recent confirmed orders
user_address = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
 
try:
    orders = get_user_orders(user_address, limit=20, status="confirmed")
 
    print(f"Total confirmed orders: {orders['total']}")
    print(f"Showing: {len(orders['orders'])}")
 
    for order in orders['orders']:
        print(f"\nOrder ID: {order['orderId']}")
        print(f"Status: {order['status']}")
        print(f"Created: {order['createdAt']}")
        print(f"TX Hash: {order.get('txHash', 'pending')}")
 
        if 'summary' in order:
            print(f"Swap: {order['summary']['sellAmount']} → {order['summary']['buyAmount']}")
 
except Exception as e:
    print(f"Failed to get orders: {e}")

curl -X GET "https://api.unikron.ch/api/v1/mev/orders/user/0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb?limit=20" \
  -H "X-API-Key: YOUR_API_KEY"