Price trigger swaps

import base64
import hashlib
import hmac
import json
import os
import time
import uuid
from urllib.parse import urlencode

import requests

API_KEY = os.environ["PWS_API_KEY"]
API_SECRET = os.environ["PWS_API_SECRET"]
BASE_URL = os.environ["PWS_BASE_URL"]


def payward_signature(secret, timestamp, method, path_with_query, body=""):
    """Return the API-Sign value for one request.

    body is the exact string sent on the wire, or "" for a request without a body.
    """
    body_hash = hashlib.sha256(body.encode("utf-8")).hexdigest().upper()
    message = f"{timestamp}\n{method.upper()}\n{path_with_query}\n{body_hash}"
    mac = hmac.new(base64.b64decode(secret), message.encode("utf-8"), hashlib.sha512)
    return base64.b64encode(mac.digest()).decode()


def signed_headers(method, path_with_query, body="", idempotent=False):
    """Return the headers for one request, signed now."""
    timestamp = str(time.time_ns() // 1_000_000)
    headers = {
        "API-Key": API_KEY,
        "API-Timestamp": timestamp,
        "API-Sign": payward_signature(
            API_SECRET, timestamp, method, path_with_query, body
        ),
    }
    if body:
        headers["Content-Type"] = "application/json"
    if idempotent:
        headers["Idempotency-Key"] = str(uuid.uuid4())
    return headers

import crypto from 'node:crypto';

const API_KEY = process.env.PWS_API_KEY;
const API_SECRET = process.env.PWS_API_SECRET;
const BASE_URL = process.env.PWS_BASE_URL;

/**
 * Returns the API-Sign value for one request.
 * `body` is the exact string sent on the wire, or '' for a request without a body.
 */
function paywardSignature(secret, timestamp, method, pathWithQuery, body = '') {
  const bodyHash = crypto.createHash('sha256').update(body, 'utf8').digest('hex').toUpperCase();
  const message = `${timestamp}\n${method.toUpperCase()}\n${pathWithQuery}\n${bodyHash}`;
  return crypto.createHmac('sha512', Buffer.from(secret, 'base64')).update(message, 'utf8').digest('base64');
}

/** Returns the headers for one request, signed now. */
function signedHeaders(method, pathWithQuery, body = '', { idempotent = false } = {}) {
  const timestamp = String(Date.now());
  const headers = {
    'API-Key': API_KEY,
    'API-Timestamp': timestamp,
    'API-Sign': paywardSignature(API_SECRET, timestamp, method, pathWithQuery, body),
  };
  if (body) {
    headers['Content-Type'] = 'application/json';
  }
  if (idempotent) {
    headers['Idempotency-Key'] = crypto.randomUUID();
  }
  return headers;
}

def create_price_trigger_swap(account_id):
    path = f"/v1/accounts/{account_id}/price-trigger-swaps"
    body = json.dumps(
        {
            "client_order_id": "buy-dip-btc-001",
            "trade": {
                "from": {"symbol": "USD", "type": "fiat", "amount": "100.00"},
                "to": {"symbol": "BTC", "type": "crypto"},
                "fee": {"bps": 50},
            },
            "when": {
                "base": {"symbol": "BTC", "type": "crypto"},
                "quote": {"symbol": "USD", "type": "fiat"},
                "drops_to": "50000.00",
            },
        }
    )

    response = requests.post(
        BASE_URL + path,
        headers=signed_headers("POST", path, body, idempotent=True),
        data=body,
        timeout=10,
    )
    response.raise_for_status()
    return response.json()


account_id = "NL00KRAK0123456789"
created = create_price_trigger_swap(account_id)
swap_id = created["data"]["id"]
print(f"Swap created: {swap_id}")

async function createPriceTriggerSwap(accountId) {
  const path = `/v1/accounts/${accountId}/price-trigger-swaps`;
  const body = JSON.stringify({
    client_order_id: 'buy-dip-btc-001',
    trade: {
      from: { symbol: 'USD', type: 'fiat', amount: '100.00' },
      to: { symbol: 'BTC', type: 'crypto' },
      fee: { bps: 50 },
    },
    when: {
      base: { symbol: 'BTC', type: 'crypto' },
      quote: { symbol: 'USD', type: 'fiat' },
      drops_to: '50000.00',
    },
  });

  const response = await fetch(BASE_URL + path, {
    method: 'POST',
    headers: signedHeaders('POST', path, body, { idempotent: true }),
    body,
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

const accountId = 'NL00KRAK0123456789';
const created = await createPriceTriggerSwap(accountId);
const swapId = created.data.id;
console.log('Swap created:', swapId);

def get_price_trigger_swap(account_id, swap_id):
    path = f"/v1/accounts/{account_id}/price-trigger-swaps/{swap_id}"
    response = requests.get(
        BASE_URL + path, headers=signed_headers("GET", path), timeout=10
    )
    response.raise_for_status()
    return response.json()


swap = get_price_trigger_swap(account_id, swap_id)
print(f"Status: {swap['data']['status']}")

async function getPriceTriggerSwap(accountId, swapId) {
  const path = `/v1/accounts/${accountId}/price-trigger-swaps/${swapId}`;
  const response = await fetch(BASE_URL + path, {
    method: 'GET',
    headers: signedHeaders('GET', path),
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

const swap = await getPriceTriggerSwap(accountId, swapId);
console.log('Status:', swap.data.status);

def list_price_trigger_swaps(account_id, statuses=None, page_token=None, page_size=20):
    params = []
    if statuses:
        params.extend(("statuses", s) for s in statuses)
    if page_token:
        params.append(("page_token", page_token))
    params.append(("page_size", page_size))
    path = f"/v1/accounts/{account_id}/price-trigger-swaps?{urlencode(params)}"

    response = requests.get(
        BASE_URL + path, headers=signed_headers("GET", path), timeout=10
    )
    response.raise_for_status()
    return response.json()


page = list_price_trigger_swaps(account_id, statuses=["active"])
for s in page["data"]:
    print(f"{s.get('client_order_id', s['id'])}: {s['status']}")

async function listPriceTriggerSwaps(accountId, { statuses = [], pageToken, pageSize = 20 } = {}) {
  const search = new URLSearchParams();
  for (const s of statuses) search.append('statuses', s);
  if (pageToken) search.append('page_token', pageToken);
  search.append('page_size', String(pageSize));
  const path = `/v1/accounts/${accountId}/price-trigger-swaps?${search}`;

  const response = await fetch(BASE_URL + path, {
    method: 'GET',
    headers: signedHeaders('GET', path),
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

const page = await listPriceTriggerSwaps(accountId, { statuses: ['active'] });
for (const s of page.data) {
  console.log(`${s.client_order_id ?? s.id}: ${s.status}`);
}

def cancel_price_trigger_swap(account_id, swap_id):
    path = f"/v1/accounts/{account_id}/price-trigger-swaps/{swap_id}/cancel"
    body = "{}"

    response = requests.post(
        BASE_URL + path,
        headers=signed_headers("POST", path, body, idempotent=True),
        data=body,
        timeout=10,
    )
    response.raise_for_status()


cancel_price_trigger_swap(account_id, swap_id)
swap = get_price_trigger_swap(account_id, swap_id)
print(f"Status: {swap['data']['status']}")  # cancelled

async function cancelPriceTriggerSwap(accountId, swapId) {
  const path = `/v1/accounts/${accountId}/price-trigger-swaps/${swapId}/cancel`;
  const body = '{}';

  const response = await fetch(BASE_URL + path, {
    method: 'POST',
    headers: signedHeaders('POST', path, body, { idempotent: true }),
    body,
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
}

await cancelPriceTriggerSwap(accountId, swapId);
const after = await getPriceTriggerSwap(accountId, swapId);
console.log('Status:', after.data.status); // cancelled