145 lines
8.9 KiB
JavaScript
145 lines
8.9 KiB
JavaScript
// Igneum light client, server half. GET /api/checkpoint returns the latest certified checkpoint with everything a
|
|
// browser needs to verify it by itself (site/verify/verify.js does the verifying; this function only ships data):
|
|
// the certificate as carried in a block, the canonical voter list with public keys and weights, and the
|
|
// selected-chain headers from the previous locked checkpoint to this one. Read from what tools/observer wrote to
|
|
// Neon (table live_certificates, or fintest_live_certificates for the test network).
|
|
//
|
|
// ?source=live the live chain (default: the dn4_ tables, or LIVE_TABLE_PREFIX); certificate:null with a reason before its first lock, never the fixture
|
|
// ?source=dn4 the same as live (the Igneum 2.0 devnet's name, for callers that want to say so)
|
|
// ?source=test the finality test network's fixture (fintest_live_certificates), only with the ops key in x-igneum-ops-key; 404 otherwise
|
|
// ?index=N one certified checkpoint by index instead of the newest (the explorer's per-block re-check, 8 October 2026)
|
|
//
|
|
// Zero dependencies: Neon's HTTP SQL endpoint over Node's built-in fetch, like live.mjs.
|
|
|
|
const MAX_HEADERS = 200;
|
|
|
|
function neon() {
|
|
const url = process.env.DATABASE_URL;
|
|
if (!url) throw new Error('DATABASE_URL is not set');
|
|
const host = new URL(url).hostname.replace('-pooler', '');
|
|
return async (query, params = []) => {
|
|
const r = await fetch(`https://${host}/sql`, {
|
|
method: 'POST',
|
|
headers: { 'Neon-Connection-String': url, 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ query, params }),
|
|
});
|
|
const j = await r.json();
|
|
if (!r.ok) throw new Error(j.message || JSON.stringify(j));
|
|
return j.rows || [];
|
|
};
|
|
}
|
|
|
|
const num = v => (v === null || v === undefined ? null : Number(v));
|
|
|
|
const tablePrefix = () => (process.env.LIVE_TABLE_PREFIX === undefined ? 'dn4_' : process.env.LIVE_TABLE_PREFIX).replace(/[^a-z0-9_]/gi, '');
|
|
// the live chain's name from its table prefix (dn4_ is igneum-devnet-4); LIVE_NETWORK overrides
|
|
const liveNetwork = () => process.env.LIVE_NETWORK || (/^dn(\d+)_$/.test(tablePrefix()) ? `igneum-devnet-${tablePrefix().slice(2, -1)}` : 'igneum-devnet-4');
|
|
// the finality test network's fixture (fintest_live_certificates) is served only to a request carrying the ops key (main, 8 Oct 2026 18:4x:
|
|
// a fixture chain answered on the public 2.0 site as source test, network igneum-devnet-7); with no IGNEUM_OPS_KEY set it is never served
|
|
const opsOk = req => { const k = process.env.IGNEUM_OPS_KEY || ''; const h = String((req.headers && req.headers['x-igneum-ops-key']) || ''); return k.length > 0 && h === k; };
|
|
const noCertificate = source => ({ source, network: liveNetwork(), certificate: null, reason: 'no finality certificate yet; the first lock is expected about 23:00 BST' });
|
|
async function latest(sql, table, index = null) {
|
|
// A table the observer has not created yet (the live chain before the cut-over) reads as "no certificate"
|
|
const rows = await (index === null ? sql(`SELECT * FROM ${table} ORDER BY index DESC LIMIT 1`) : sql(`SELECT * FROM ${table} WHERE index = $1 LIMIT 1`, [index])).catch(() => []);
|
|
return rows[0] || null;
|
|
}
|
|
|
|
function shape(row, source) {
|
|
const headers = (row.headers || []).slice(-MAX_HEADERS).map(h => ({
|
|
hash: h.hash, version: num(h.version), parents_by_level: h.parentsByLevel || [],
|
|
hash_merkle_root: h.hashMerkleRoot, accepted_id_merkle_root: h.acceptedIdMerkleRoot, utxo_commitment: h.utxoCommitment,
|
|
timestamp: String(h.timestamp), bits: num(h.bits), nonce: String(h.nonce), daa_score: String(h.daaScore),
|
|
blue_work: h.blueWork, blue_score: String(h.blueScore), pruning_point: h.pruningPoint, vote_key_hash: h.voteKeyHash,
|
|
}));
|
|
const voters = (row.voters || []).map(v => ({ vote_key_hash: v.key_hash, pubkey_hex: v.pubkey, weight: num(v.weight), participation: num(v.participation) }));
|
|
return {
|
|
source,
|
|
network: row.chain_id,
|
|
chain_id: row.chain_id,
|
|
index: num(row.index),
|
|
hash: row.hash,
|
|
blue_score: num(row.blue_score),
|
|
daa_score: num(row.daa_score),
|
|
certificate: {
|
|
bytes_hex: row.certificate_hex,
|
|
voter_count: num(row.voter_count),
|
|
bitmap_hex: row.bitmap_hex,
|
|
aggregate_signature_hex: row.signature_hex,
|
|
aggregator: row.aggregator,
|
|
aggregator_proof_hex: row.aggregator_proof_hex,
|
|
carrier: row.carrier,
|
|
},
|
|
voters,
|
|
voters_at_index: num(row.voters_index),
|
|
total_weight: num(row.total_weight),
|
|
active_weight: num(row.active_weight),
|
|
previous: row.prev_index === null || row.prev_index === undefined ? null : { index: num(row.prev_index), hash: row.prev_hash },
|
|
headers,
|
|
headers_complete: !!row.headers_complete && (row.headers || []).length <= MAX_HEADERS,
|
|
rule: { quorum_active: '2/3', floor_total: 0.567, floor_total_exact: '17/30', vote_message: 'igneum-vote-v1/<chain_id> 0x00 index_le64 checkpoint_hash', dst: 'IGNEUM_VOTE_V1_BLS12381G2_XMD:SHA-256_SSWU_RO_NUL_', key_hash: 'BLAKE2b-256 keyed IgneumVoteKeyHash over the 48-byte G1 key' },
|
|
stored_at: row.created_at,
|
|
};
|
|
}
|
|
|
|
/** The earliest certified Devnet 3 checkpoint whose chain block number is at least `number` (the reference apps' receipt:
|
|
* the smallest proof that a block is final), from the dn3_ rows; null when no certificate reaches that block yet.
|
|
* `chainNumberOf(hash)` resolves a checkpoint hash to its chain block number (the exec RPC); rows are tried newest first
|
|
* until one falls below `number`, so the cost is a few lookups. */
|
|
export async function earliestCheckpointAbove(sql, number, chainNumberOf, table = `${tablePrefix()}live_certificates`) {
|
|
const rows = await sql(`SELECT index, hash FROM ${table} ORDER BY index DESC LIMIT 400`).catch(() => []);
|
|
let pick = null;
|
|
for (const r of rows) {
|
|
const n = await chainNumberOf(r.hash).catch(() => null);
|
|
if (n === null) continue;
|
|
if (n >= number) pick = r; else break;
|
|
}
|
|
if (!pick) return null;
|
|
const full = await sql(`SELECT * FROM ${table} WHERE index = $1 LIMIT 1`, [Number(pick.index)]);
|
|
return full[0] ? shape(full[0], 'dn3') : null;
|
|
}
|
|
|
|
/** The latest certified checkpoint of `want` ('live', 'test' or 'dn3') through `sql`, shaped for the verifier, or null
|
|
* (the reference apps' read service calls this off Vercel: 'dn3' names the dn3_ tables whatever LIVE_TABLE_PREFIX says). */
|
|
export async function readCheckpoint(sql, want = 'live') {
|
|
// 'live', 'dn4' (and the retired 'dn3') read that chain's tables and never fall back to the test fixture; 'test' is the fixture, for the ops
|
|
// caller only (the handler gates it; this function is called off Vercel by the reference apps' read service, which names its chain)
|
|
if (want === 'test') { const row = await latest(sql, 'fintest_live_certificates'); return row ? shape(row, 'test') : null; }
|
|
const table = (want === 'dn3' || want === 'dn4') ? `${want}_live_certificates` : `${tablePrefix()}live_certificates`;
|
|
const row = await latest(sql, table);
|
|
return row ? shape(row, want === 'dn3' || want === 'dn4' ? want : 'live') : null;
|
|
}
|
|
export { neon };
|
|
|
|
export default async function handler(req, res) {
|
|
res.setHeader('Cache-Control', 'public, max-age=5');
|
|
res.setHeader('Access-Control-Allow-Origin', '*');
|
|
if (req.method !== 'GET') {
|
|
res.setHeader('Allow', 'GET');
|
|
return res.status(405).json({ ok: false, error: 'method not allowed' });
|
|
}
|
|
try {
|
|
const sql = neon();
|
|
const want = String((req.query && req.query.source) || 'live');
|
|
const idx = req.query && req.query.index !== undefined && /^\d{1,12}$/.test(String(req.query.index)) ? Number(req.query.index) : null;
|
|
if (want === 'test') {
|
|
res.setHeader('Cache-Control', 'no-store');
|
|
if (!opsOk(req)) return res.status(404).json({ ok: false, error: 'no such source' });
|
|
const row = await latest(sql, 'fintest_live_certificates', idx);
|
|
if (!row) return res.status(404).json({ ok: false, error: 'no certified checkpoint stored yet' });
|
|
return res.status(200).json({ ok: true, now: new Date().toISOString(), ...shape(row, 'test') });
|
|
}
|
|
// the public answer: the live chain's tables (source live; dn4 names them too), never the test fixture
|
|
const source = want === 'dn4' ? 'dn4' : 'live';
|
|
const row = await latest(sql, `${tablePrefix()}live_certificates`, idx);
|
|
if (!row) {
|
|
res.setHeader('Cache-Control', 'public, max-age=5');
|
|
if (idx !== null) return res.status(404).json({ ok: false, network: liveNetwork(), error: `no certified checkpoint at index ${idx} yet` });
|
|
return res.status(200).json({ ok: true, now: new Date().toISOString(), ...noCertificate(source) });
|
|
}
|
|
// the hand merge of 12:22 BST (a0b62cf7) returned `...cp` with no cp bound: every caller read "cp is not defined" (8 Oct 2026, build-server lane)
|
|
return res.status(200).json({ ok: true, now: new Date().toISOString(), ...shape(row, source) });
|
|
} catch (e) {
|
|
res.setHeader('Cache-Control', 'no-store');
|
|
return res.status(500).json({ ok: false, error: String(e.message || e) });
|
|
}
|
|
}
|