34efb319cc
Payment flow for the paid wave (the free wave is still the default):
1. Publisher POSTs /api/listing. If PAYMENT_REQUIRED=1 is set, the
listing lands with payment_status='pending' and is hidden from
browse. If not set, the listing goes straight to 'free' and is
visible immediately (today's behaviour, unchanged).
2. Anyone (publisher, their script, their wallet) POSTs
/api/invoice {listing_id} and gets back a one-shot invoice:
operator receive address, exact sat amount (USD-pegged + random
1..256 sat jitter so no two in-flight invoices collide),
bitcoincash: URI for a wallet, 20-min expiry.
3. Reader pays. The amount matches exactly one pending invoice, and
when the mempool watcher reports (address, amount, txid) to
tryMatchPayment, both the invoice and the listing flip to paid.
Browse starts showing the listing.
The mempool watcher that would do (3) automatically is deliberately NOT
in this commit — it needs an electrum-cash subscription or a block
explorer webhook, and that's a next milestone. In the meantime, admins
reconcile by hand from /admin/payments, which shows every invoice with
a Mark paid form (optional txid field). Same effect on the DB, same
audit log entry, different `paid_by` string.
Design decisions worth recording:
- One receive address + amount matching, NOT an HD wallet per invoice.
BitPay used this for years; it is simple, auditable, and doesn't
require a seed on the server to spend from later.
- Random few-sat jitter per invoice guarantees uniqueness of the
(address, amount) pair across all in-flight invoices.
- Price oracle is CoinGecko (public, no key, 60s cache, 15-min stale
fallback). If both the fresh fetch and the stale fallback fail,
/api/invoice refuses — issuing invoices on a stale price is worse
than refusing to quote until the oracle recovers.
- Quote is locked at issue time; the 20-min deadline is the lock.
- Lazy expiry: GET /api/invoice/<id> flips an expired pending invoice
to 'expired' as a side effect, so there's no sweeper to run.
Admin UI /admin/payments shows every invoice (pending/paid/expired),
plus a dashboard-ish header with the configured mode + receive address.
The gating config appears in the UI even when payments are disabled, so
an operator spinning up a new instance can see at a glance what's set.
Config:
PAYMENT_REQUIRED=1 — turn paid mode on
PROMETHEUS_PAYMENT_ADDRESS=… — the operator's receive address
PROMETHEUS_LISTING_FEE_USD=1 — the fee (default 1 USD)
PROMETHEUS_PRICE_SOURCE=… — override the CoinGecko URL
End-to-end verified:
PAYMENT_REQUIRED=1 → new listing hidden from browse → /api/invoice
returns correct sats at live BCH price → admin login + mark-paid →
listing becomes visible → /api/invoice/<id> returns status 'paid'
with paid_by='manual:admin.x'.
48 lines
1.9 KiB
JavaScript
48 lines
1.9 KiB
JavaScript
/**
|
|
* BCH ↔ USD price lookup, with a 60-second in-memory cache.
|
|
*
|
|
* We pull from CoinGecko by default — public, no API key, generous for the
|
|
* once-a-minute cadence we need. The price feeds the invoice quote; a
|
|
* publisher's quote is locked at issue time and does not re-quote while they
|
|
* decide whether to pay.
|
|
*
|
|
* On fetch failure we return the last good value if it is under 15 minutes
|
|
* old. Beyond that, we throw — handing out invoices with stale prices is
|
|
* worse than refusing to quote until the oracle recovers.
|
|
*/
|
|
|
|
const CACHE_TTL_MS = 60_000;
|
|
const STALE_FALLBACK_MS = 15 * 60_000;
|
|
const SOURCE = process.env.PROMETHEUS_PRICE_SOURCE
|
|
|| 'https://api.coingecko.com/api/v3/simple/price?ids=bitcoin-cash&vs_currencies=usd';
|
|
|
|
let cached = null; // { price_usd, at }
|
|
|
|
export async function bchUsd() {
|
|
const now = Date.now();
|
|
if (cached && now - cached.at < CACHE_TTL_MS) return cached.price_usd;
|
|
|
|
try {
|
|
const resp = await fetch(SOURCE, {
|
|
headers: { accept: 'application/json' },
|
|
signal: AbortSignal.timeout(5000),
|
|
});
|
|
if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
|
|
const body = await resp.json();
|
|
const p = Number(body?.['bitcoin-cash']?.usd);
|
|
if (!Number.isFinite(p) || p <= 0) throw new Error('bad price in response');
|
|
cached = { price_usd: p, at: now };
|
|
return p;
|
|
} catch (err) {
|
|
if (cached && now - cached.at < STALE_FALLBACK_MS) return cached.price_usd;
|
|
throw new Error(`price oracle: ${err?.message || err}`);
|
|
}
|
|
}
|
|
|
|
/** USD → sats, using the current (or last-good) BCH/USD price. */
|
|
export async function usdToSats(usd) {
|
|
const price = await bchUsd(); // USD per BCH
|
|
const bch = Number(usd) / price; // BCH per `usd` dollars
|
|
const sats = Math.round(bch * 1e8); // satoshis per BCH = 1e8
|
|
return { sats, rate_sat_per_usd: Math.round(1e8 / price), price_usd: price };
|
|
}
|