End-to-end swap walkthrough

import { randomUUID } from 'node:crypto';
 
const BASE = 'https://partners-api.ghostswap.io';
const AUTH = `Bearer ${process.env.GHOSTSWAP_PUBLIC_KEY}:${process.env.GHOSTSWAP_SECRET}`;
 
class GhostSwapError extends Error {
  constructor({ status, type, code, message, field }) {
    super(`${type}/${code}: ${message}`);
    this.status = status;
    this.type = type;
    this.code = code;
    this.field = field;
  }
}
 
async function api(method, path, { body, idempotencyKey } = {}) {
  const res = await fetch(`${BASE}${path}`, {
    method,
    headers: {
      'Authorization': AUTH,
      'Content-Type': 'application/json',
      ...(idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : {}),
    },
    body: body ? JSON.stringify(body) : undefined,
  });
  if (!res.ok) {
    const json = await res.json().catch(() => ({ error: {} }));
    throw new GhostSwapError({ status: res.status, ...json.error });
  }
  return res.json();
}
 
async function quote({ from, to, amountFrom }) {
  const { quote } = await api('POST', '/v1/quotes', { body: { from, to, amountFrom } });
  return quote;
}
 
async function validateAddress({ currency, address, extraId }) {
  const { valid, message } = await api('POST', '/v1/addresses/validate', {
    body: { currency, address, ...(extraId ? { extraId } : {}) },
  });
  if (!valid) throw new GhostSwapError({ type: 'validation_error', code: 'invalid_address', message });
}
 
async function createSwap(input) {
  const idempotencyKey = randomUUID();
  // Persist `idempotencyKey` alongside your order BEFORE the API call so you
  // can retry safely on network errors without creating a duplicate.
  await orderStore.update(input.orderId, { idempotencyKey });
 
  const { swap } = await api('POST', '/v1/swaps', {
    body: input,
    idempotencyKey,
  });
  return swap;
}
 
const TERMINAL = new Set(['finished', 'failed', 'refunded', 'overdue', 'expired']);
 
async function pollUntilTerminal(swapId, { onUpdate } = {}) {
  while (true) {
    const { swap } = await api('GET', `/v1/swaps/${swapId}`);
    onUpdate?.(swap);
    if (TERMINAL.has(swap.status)) return swap;
    if (swap.status === 'hold') {
      // KYC review can take hours/days. Slow down polling.
      await new Promise((r) => setTimeout(r, 5 * 60_000));
    } else {
      await new Promise((r) => setTimeout(r, 30_000));
    }
  }
}
 
// Putting it together:
async function runSwap({ orderId, from, to, amountFrom, payoutAddress, refundAddress }) {
  // 1. Quote.
  const q = await quote({ from, to, amountFrom });
  console.log(`Estimated payout: ${q.amountUserReceives} ${to}`);
 
  // 2. Validate the user's address. Catch invalid addresses early.
  await validateAddress({ currency: to, address: payoutAddress });
 
  // 3. Create the swap, persisting the idempotency key first.
  const swap = await createSwap({
    from,
    to,
    amountFrom,
    address: payoutAddress,
    refundAddress,
    partnerReferenceId: orderId,
  });
  console.log(`Swap ${swap.id} created. User must send ${amountFrom} ${from} to ${swap.payinAddress}.`);
 
  // 4. Show payinAddress to the user. They send funds on chain.
  await orderStore.update(orderId, {
    swapId: swap.id,
    payinAddress: swap.payinAddress,
    expectedPayout: swap.amountExpectedTo,
  });
 
  // 5. Poll until terminal. In production, do this in a background job, not
  // inline — this could take hours.
  const final = await pollUntilTerminal(swap.id, {
    onUpdate: (s) => orderStore.update(orderId, { status: s.status }),
  });
 
  // 6. Credit the user (or refund flow) based on terminal status.
  if (final.status === 'finished') {
    await orderStore.update(orderId, { state: 'fulfilled' });
  } else {
    await orderStore.update(orderId, { state: 'failed', failureReason: final.status });
  }
  return final;
}