# Strategy 1: UUID
IDEMPOTENCY_KEY=$(uuidgen)
# Result: "550e8400-e29b-41d4-a716-446655440000"

# Strategy 2: Order ID + Timestamp (recommended for traceability)
IDEMPOTENCY_KEY="ord_${ORDER_ID}_$(date +%s)"
# Result: "ord_12345_1705689660"

# Use in request
curl -X POST "{{host}}/api/v1/orders" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Secret: $API_SECRET" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $IDEMPOTENCY_KEY" \
  -d '{"product_id": 123, "denomination": 100, "quantity": 5}'

<?php
// Strategy 1: UUID
function generateUuidKey(): string {
    return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
        mt_rand(0, 0xffff), mt_rand(0, 0xffff),
        mt_rand(0, 0xffff),
        mt_rand(0, 0x0fff) | 0x4000,
        mt_rand(0, 0x3fff) | 0x8000,
        mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
    );
}

// Strategy 2: Order ID + Timestamp (recommended)
function generateTraceableKey(string $orderId): string {
    return "ord_{$orderId}_" . time();
}

// Strategy 3: Hash of parameters (deterministic)
function generateDeterministicKey(int $productId, float $amount, string $userId): string {
    return 'ord_' . substr(hash('sha256', "{$userId}_{$productId}_{$amount}_" . time()), 0, 32);
}

// Usage
$idempotencyKey = generateTraceableKey('INV-2024-001');

$ch = curl_init('{{host}}/api/v1/orders');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'X-API-Key: ' . $apiKey,
        'X-API-Secret: ' . $apiSecret,
        'Content-Type: application/json',
        'Idempotency-Key: ' . $idempotencyKey
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'product_id' => 123,
        'denomination' => 100,
        'quantity' => 5
    ])
]);

$response = curl_exec($ch);
curl_close($ch);
?>

#!/bin/bash
# Safe retry pattern with idempotency

MAX_RETRIES=3
IDEMPOTENCY_KEY="ord_$(uuidgen)"  # Generate ONCE before retries

for i in $(seq 1 $MAX_RETRIES); do
  RESPONSE=$(curl -s -w "\n%{http_code}" -X POST "{{host}}/api/v1/orders" \
    -H "X-API-Key: $API_KEY" \
    -H "X-API-Secret: $API_SECRET" \
    -H "Content-Type: application/json" \
    -H "Idempotency-Key: $IDEMPOTENCY_KEY" \
    -d '{"product_id": 123, "denomination": 100, "quantity": 5}')

  HTTP_CODE=$(echo "$RESPONSE" | tail -1)
  BODY=$(echo "$RESPONSE" | sed '$d')

  if [[ "$HTTP_CODE" -ge 200 && "$HTTP_CODE" -lt 300 ]]; then
    echo "Success: $BODY"
    exit 0
  elif [[ "$HTTP_CODE" -ge 400 && "$HTTP_CODE" -lt 500 ]]; then
    echo "Client error (no retry): $BODY"
    exit 1
  else
    echo "Attempt $i failed with HTTP $HTTP_CODE, retrying..."
    sleep $((2 ** i))  # Exponential backoff
  fi
done

echo "All retries exhausted"
exit 1

<?php
class OrderClient {
    private string $baseUrl;
    private string $apiKey;
    private string $apiSecret;

    public function __construct(string $baseUrl, string $apiKey, string $apiSecret) {
        $this->baseUrl = $baseUrl;
        $this->apiKey = $apiKey;
        $this->apiSecret = $apiSecret;
    }

    public function createOrderSafely(array $orderData, int $maxRetries = 3): array {
        // Generate idempotency key ONCE before any retries
        $idempotencyKey = 'ord_' . uniqid() . '_' . time();

        for ($attempt = 1; $attempt <= $maxRetries; $attempt++) {
            try {
                $response = $this->doRequest($orderData, $idempotencyKey);
                return $response;

            } catch (ClientException $e) {
                // 4xx errors - don't retry, fix the request
                throw $e;

            } catch (ServerException $e) {
                // 5xx errors - retry with backoff
                if ($attempt < $maxRetries) {
                    sleep(pow(2, $attempt)); // 2, 4, 8 seconds
                    continue;
                }
                throw $e;

            } catch (NetworkException $e) {
                // Network errors - retry with backoff
                if ($attempt < $maxRetries) {
                    sleep(pow(2, $attempt));
                    continue;
                }
                throw $e;
            }
        }

        throw new Exception('All retries exhausted');
    }

    private function doRequest(array $data, string $idempotencyKey): array {
        $ch = curl_init($this->baseUrl . '/api/v1/orders');
        curl_setopt_array($ch, [
            CURLOPT_POST => true,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT => 30,
            CURLOPT_HTTPHEADER => [
                'X-API-Key: ' . $this->apiKey,
                'X-API-Secret: ' . $this->apiSecret,
                'Content-Type: application/json',
                'Idempotency-Key: ' . $idempotencyKey
            ],
            CURLOPT_POSTFIELDS => json_encode($data)
        ]);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $error = curl_error($ch);
        curl_close($ch);

        if ($error) {
            throw new NetworkException($error);
        }

        $result = json_decode($response, true);

        if ($httpCode >= 400 && $httpCode < 500) {
            throw new ClientException($result['message'] ?? 'Client error', $httpCode);
        }

        if ($httpCode >= 500) {
            throw new ServerException($result['message'] ?? 'Server error', $httpCode);
        }

        return $result;
    }
}

// Usage
$client = new OrderClient('{{host}}', 'sk_live_abc123def456', 'your-secret-here');

try {
    $order = $client->createOrderSafely([
        'product_id' => 123,
        'denomination' => 100,
        'quantity' => 5
    ]);
    echo "Order created: {$order['id']}\n";
} catch (Exception $e) {
    echo "Failed: {$e->getMessage()}\n";
}
?>