Swaps

import os
import json
import time
import uuid
import hashlib
import hmac
import base64
import urllib.parse
import requests

API_KEY = os.environ["PWS_API_KEY"]
API_SECRET = os.environ["PWS_API_SECRET"]
BASE_URL = "https://api.services.payward.com"


def get_payward_signature(urlpath, data, secret, nonce, params=None):
    encoded = (
        str(nonce).encode("utf-8")
        if data is None
        else (str(nonce) + json.dumps(data)).encode("utf-8")
    )

    sign_path = urlpath
    if params:
        sign_path += "?" + urllib.parse.urlencode(params)

    message = sign_path.encode() + hashlib.sha256(encoded).digest()
    mac = hmac.new(base64.b64decode(secret), message, hashlib.sha512)
    return base64.b64encode(mac.digest()).decode()


def pws_headers(signature, nonce, idempotent=False):
    headers = {
        "API-Key": API_KEY,
        "API-Sign": signature,
        "API-Nonce": str(nonce),
        "Content-Type": "application/json",
    }
    if idempotent:
        headers["Idempotency-Key"] = str(uuid.uuid4())
    return headers

import crypto from 'crypto';

const API_KEY = process.env.PWS_API_KEY;
const API_SECRET = process.env.PWS_API_SECRET;
const BASE_URL = 'https://api.services.payward.com';

function getPaywardSignature(urlpath, data, secret, nonce, params = null) {
  const encoded = data === null ? String(nonce) : String(nonce) + JSON.stringify(data);

  let signPath = urlpath;
  if (params) {
    signPath += '?' + new URLSearchParams(params).toString();
  }

  const sha256Hash = crypto.createHash('sha256').update(encoded).digest();
  const message = Buffer.concat([Buffer.from(signPath), sha256Hash]);

  const secretBuffer = Buffer.from(secret, 'base64');
  const hmac = crypto.createHmac('sha512', secretBuffer);
  hmac.update(message);
  return hmac.digest('base64');
}

function pwsHeaders(signature, nonce, { idempotent = false } = {}) {
  const headers = {
    'API-Key': API_KEY,
    'API-Sign': signature,
    'API-Nonce': String(nonce),
    'Content-Type': 'application/json',
  };
  if (idempotent) {
    headers['Idempotency-Key'] = crypto.randomUUID();
  }
  return headers;
}

def create_swap_quote(account_id):
    endpoint = f"/v1/accounts/{account_id}/quotes"
    nonce = time.time_ns()

    body = {
        "from": {"symbol": "BTC", "type": "crypto", "amount": "0.5"},
        "to":   {"symbol": "USD", "type": "fiat"},
        "fee":  {"bps": 50},
    }

    signature = get_payward_signature(endpoint, body, API_SECRET, nonce)
    response = requests.post(
        BASE_URL + endpoint,
        headers=pws_headers(signature, nonce, idempotent=True),
        json=body,
    )
    return response.json()


account_id = "NL00KRAK0123456789"
quote = create_swap_quote(account_id)
print(f"Quote ID:    {quote['data']['id']}")
print(f"Status:      {quote['data']['status']}")
print(f"Expires at:  {quote['data']['expires_at']}")
print(f"You send:    {quote['data']['from']['amount']} {quote['data']['from']['symbol']}")
print(f"You receive: {quote['data']['to']['amount']} {quote['data']['to']['symbol']}")

async function createSwapQuote(accountId) {
  const endpoint = `/v1/accounts/${accountId}/quotes`;
  const nonce = process.hrtime.bigint().toString();

  const body = {
    from: { symbol: 'BTC', type: 'crypto', amount: '0.5' },
    to: { symbol: 'USD', type: 'fiat' },
    fee: { bps: 50 },
  };

  const signature = getPaywardSignature(endpoint, body, API_SECRET, nonce);
  const response = await fetch(BASE_URL + endpoint, {
    method: 'POST',
    headers: pwsHeaders(signature, nonce, { idempotent: true }),
    body: JSON.stringify(body),
  });

  return response.json();
}

const accountId = 'NL00KRAK0123456789';
const quote = await createSwapQuote(accountId);
console.log('Quote ID:   ', quote.data.id);
console.log('Status:     ', quote.data.status);
console.log('Expires at: ', quote.data.expires_at);

def execute_swap_quote(account_id, quote_id):
    endpoint = f"/v1/accounts/{account_id}/quotes/{quote_id}/execute"
    nonce = time.time_ns()
    body = {}

    signature = get_payward_signature(endpoint, body, API_SECRET, nonce)
    response = requests.post(
        BASE_URL + endpoint,
        headers=pws_headers(signature, nonce, idempotent=True),
        json=body,
    )
    return response.json()


execution = execute_swap_quote(account_id, quote["data"]["id"])
print(f"Status:      {execution['data']['status']}")
print(f"Executed at: {execution['data']['executed_at']}")

async function executeSwapQuote(accountId, quoteId) {
  const endpoint = `/v1/accounts/${accountId}/quotes/${quoteId}/execute`;
  const nonce = process.hrtime.bigint().toString();
  const body = {};

  const signature = getPaywardSignature(endpoint, body, API_SECRET, nonce);
  const response = await fetch(BASE_URL + endpoint, {
    method: 'POST',
    headers: pwsHeaders(signature, nonce, { idempotent: true }),
    body: JSON.stringify(body),
  });

  return response.json();
}

const execution = await executeSwapQuote(accountId, quote.data.id);
console.log('Status:     ', execution.data.status);
console.log('Executed at:', execution.data.executed_at);

def get_swap_quote(account_id, quote_id):
    endpoint = f"/v1/accounts/{account_id}/quotes/{quote_id}"
    nonce = time.time_ns()

    signature = get_payward_signature(endpoint, None, API_SECRET, nonce)
    response = requests.get(BASE_URL + endpoint, headers=pws_headers(signature, nonce))
    return response.json()


def wait_for_terminal_status(account_id, quote_id, max_attempts=60):
    terminal = {"executed", "expired", "failed"}

    for _ in range(max_attempts):
        quote = get_swap_quote(account_id, quote_id)
        status = quote["data"]["status"]
        print(f"Status: {status}")

        if status in terminal:
            return quote

        time.sleep(1)

    raise RuntimeError("Quote did not reach a terminal state in time")


final = wait_for_terminal_status(account_id, quote["data"]["id"])

async function getSwapQuote(accountId, quoteId) {
  const endpoint = `/v1/accounts/${accountId}/quotes/${quoteId}`;
  const nonce = process.hrtime.bigint().toString();

  const signature = getPaywardSignature(endpoint, null, API_SECRET, nonce);
  const response = await fetch(BASE_URL + endpoint, {
    method: 'GET',
    headers: pwsHeaders(signature, nonce),
  });

  return response.json();
}

async function waitForTerminalStatus(accountId, quoteId, maxAttempts = 60) {
  const terminal = new Set(['executed', 'expired', 'failed']);

  for (let i = 0; i < maxAttempts; i++) {
    const quote = await getSwapQuote(accountId, quoteId);
    const { status } = quote.data;
    console.log('Status:', status);

    if (terminal.has(status)) {
      return quote;
    }

    await new Promise(resolve => setTimeout(resolve, 1000));
  }

  throw new Error('Quote did not reach a terminal state in time');
}

const final = await waitForTerminalStatus(accountId, quote.data.id);