@render-foundation/utils 0.0.255 → 0.0.256

package/lib/esm/src/client/pg/v2Client.js

@@ -1506,7 +1506,6 @@ export const pgClient = (config) => {
                     eurToUsdc: r.eur_to_usdc,
                     markedBurnedAt: r.marked_burned_at,
                     tags: r.tags ? r.tags.split(',') : [],
-                    fromEscrowUsdc: BigInt(r.from_escrow_usdc ?? 0),
                 });
                 burnIdToIdx[r.id] = burns.length - 1;
             }
@@ -1529,133 +1528,70 @@ export const pgClient = (config) => {
             return burns;
         },
         async fetchBurnsPage(db, f, log = consoleLogger) {
-            const params = [];
-            const p = (v) => {
-                params.push(v);
-                return `$${params.length}`;
-            };
-            // Decode cursor — supports new {t,id,ea} format and legacy bare-id format.
-            let cursorEa;
-            let cursorType;
-            let cursorId;
-            if (f.cursor) {
-                const raw = atob(f.cursor);
-                try {
-                    const c = JSON.parse(raw);
-                    cursorEa = new Date(c.ea);
-                    cursorType = c.t;
-                    cursorId = c.id;
-                }
-                catch {
-                    // Legacy cursor: bare burn.id — treat as buy-burn cursor.
-                    cursorId = Number(raw);
-                    cursorType = 'buy';
-                }
+            const lastId = f.cursor ? atob(f.cursor) : undefined;
+            let q = db.trx
+                .selectFrom('burn')
+                .selectAll('burn')
+                .innerJoin('sol_tx', 'sol_tx.id', 'burn.sol_tx_id')
+                .select(['sol_tx.executed_at', 'sol_tx.sig']);
+            if (!f.inclManual) {
+                q = q.where('burn.usdc_spent', '>', String(0));
+            }
+            if (f.executedAfter) {
+                q = q.where('sol_tx.executed_at', '>=', f.executedAfter);
+            }
+            if (f.executedBefore) {
+                q = q.where('sol_tx.executed_at', '<=', f.executedBefore);
+            }
+            if (f.sig) {
+                // Exact match, not a prefix: sol_tx.sig is unique, so this is an index hit returning at most one row.
+                q = q.where('sol_tx.sig', '=', f.sig);
             }
-            // Shared WHERE fragments pushed into each union leg for index use.
-            const dateFilters = [];
-            if (f.executedAfter)
-                dateFilters.push(`st.executed_at >= ${p(f.executedAfter)}`);
-            if (f.executedBefore)
-                dateFilters.push(`st.executed_at <= ${p(f.executedBefore)}`);
-            const sigFilter = f.sig ? `st.sig = ${p(f.sig)}` : '';
-            // Buy-burn leg
-            const buyWhere = [...dateFilters];
-            if (!f.inclManual)
-                buyWhere.push('b.usdc_spent > 0');
-            if (sigFilter)
-                buyWhere.push(sigFilter);
-            if (f.jobId !== undefined) {
-                buyWhere.push(`b.id IN (SELECT burn_id FROM job WHERE id = ${p(f.jobId)})`);
-            }
-            const buyWhereClause = buyWhere.length ? `WHERE ${buyWhere.join(' AND ')}` : '';
-            const buySql = `
-        SELECT 'buy'::text AS type, b.id::bigint AS sortid, b.id AS id,
-               st.executed_at, b.priced_at, b.burned::text AS burned,
-               b.usdc_spent::text AS usdc_spent, b.quote_amt::text AS quote_amt,
-               b.tags, st.sig, b.render_to_usdc, b.eur_to_usdc,
-               coalesce(b.from_escrow_usdc, 0)::text AS from_escrow_usdc,
-               b.down_correction_id, b.escrow_correction_id,
-               b.marked_burned_at
-          FROM burn b
-         INNER JOIN sol_tx st ON st.id = b.sol_tx_id
-         ${buyWhereClause}`;
-            // Grant-burn leg
-            const grantWhere = [...dateFilters];
-            if (sigFilter)
-                grantWhere.push(sigFilter);
             if (f.jobId !== undefined) {
-                grantWhere.push(`gb.id IN (SELECT grant_burn_id FROM job WHERE id = ${p(f.jobId)})`);
-            }
-            const grantWhereClause = grantWhere.length ? `WHERE ${grantWhere.join(' AND ')}` : '';
-            const grantSql = `
-        SELECT 'grant'::text AS type, gb.id::bigint AS sortid, gb.id AS id,
-               st.executed_at, null::timestamp AS priced_at, gb.burned::text AS burned,
-               '0' AS usdc_spent, '0' AS quote_amt,
-               gb.tags, st.sig, null::float8 AS render_to_usdc, null::float8 AS eur_to_usdc,
-               '0' AS from_escrow_usdc,
-               null::bigint AS down_correction_id, null::bigint AS escrow_correction_id,
-               gb.marked_burned_at
-          FROM grant_burn gb
-         INNER JOIN sol_tx st ON st.id = gb.sol_tx_id
-         ${grantWhereClause}`;
-            // Cursor filter on the outer query — row comparison for deterministic paging.
-            let cursorFilter = '';
-            if (cursorEa && cursorType && cursorId !== undefined) {
-                cursorFilter = `WHERE (u.executed_at, u.type, u.sortid) > (${p(cursorEa)}, ${p(cursorType)}, ${p(cursorId)})`;
-            }
-            else if (cursorId !== undefined) {
-                // Legacy cursor fallback: only buy burns, ordered by id.
-                cursorFilter = `WHERE u.type = 'buy' AND u.sortid > ${p(cursorId)}`;
+                // "Which burn consumed this job?" — job.burn_id is the FK, so resolve it as a subquery rather than
+                // joining `job` into the page query, which would multiply rows by job count and break both the limit
+                // and the cursor.
+                q = q.where('burn.id', 'in', (eb) => eb
+                    .selectFrom('job')
+                    .select('job.burn_id')
+                    .where('job.id', '=', String(f.jobId)));
+            }
+            if (lastId) {
+                q = q.where('burn.id', '>', lastId);
             }
             const limit = f.limit ?? 1000;
-            const sql = `
-        SELECT u.* FROM (
-          ${buySql}
-          UNION ALL
-          ${grantSql}
-        ) u
-        ${cursorFilter}
-        ORDER BY u.executed_at ASC, u.type, u.sortid
-        LIMIT ${p(limit)}`;
-            const { rows } = await timedQuery(pgPool, sql, params, 'fetchBurnsPage', log);
+            q = q.limit(limit).orderBy('burn.id');
+            const comp = q.compile();
+            const { rows } = await timedQuery(pgPool, comp.sql, comp.parameters, 'fetchBurnsPage', log);
             const burns = rows.map((r) => ({
                 jobs: [],
                 id: Number(r.id),
-                type: r.type,
-                renderToUsdc: r.render_to_usdc ?? undefined,
+                renderToUsdc: r.render_to_usdc,
                 solTx: r.sig,
                 executedAt: r.executed_at,
-                pricedAt: r.priced_at ?? undefined,
+                pricedAt: r.priced_at,
                 usdcSpent: BigInt(r.usdc_spent ?? 0),
                 quoteAmt: BigInt(r.quote_amt ?? 0),
                 burned: BigInt(r.burned),
-                eurToUsdc: r.eur_to_usdc ?? undefined,
+                eurToUsdc: r.eur_to_usdc,
                 markedBurnedAt: r.marked_burned_at,
                 tags: r.tags ? r.tags.split(',') : [],
-                fromEscrowUsdc: BigInt(r.from_escrow_usdc ?? 0),
-                downCorrectionId: r.down_correction_id ? Number(r.down_correction_id) : undefined,
-                escrowCorrectionId: r.escrow_correction_id ? Number(r.escrow_correction_id) : undefined,
             }));
             return {
                 burns,
+                // Only hand back a cursor on a full page; a short page means we're done.
                 cursor: burns.length === limit
-                    ? btoa(JSON.stringify({
-                        ea: rows[burns.length - 1].executed_at,
-                        t: rows[burns.length - 1].type,
-                        id: rows[burns.length - 1].sortid,
-                    }))
+                    ? btoa(String(burns[burns.length - 1].id))
                     : undefined,
             };
         },
-        async fetchBurnJobs(db, burnId, burnType = 'buy', log = consoleLogger) {
-            const fk = burnType === 'grant' ? 'grant_burn_id' : 'burn_id';
+        async fetchBurnJobs(db, burnId, log = consoleLogger) {
             const rows = await db.trx
                 .selectFrom('job')
                 .selectAll('job')
-                .where(fk, '=', String(burnId))
+                .where('burn_id', '=', String(burnId))
                 .execute();
-            log.debug(`fetchBurnJobs ${burnType} ${burnId} -> ${rows.length} jobs`);
+            log.debug(`fetchBurnJobs burn ${burnId} -> ${rows.length} jobs`);
             return rows.map((r) => ({
                 id: Number(r.id),
                 completedAt: r.completed_at,
@@ -1676,8 +1612,8 @@ export const pgClient = (config) => {
                 .innerJoin('sol_tx', 'sol_tx.id', 'burn.sol_tx_id')
                 .select(({ fn }) => [
                 dayExpr.as('day'),
-                sql `SUM(CASE WHEN burn.burned > 0 THEN burn.burned WHEN COALESCE(burn.from_escrow_usdc, 0) > 0 AND burn.render_to_usdc > 0 THEN (burn.from_escrow_usdc::numeric / burn.render_to_usdc * 100)::bigint ELSE 0 END)`.as('render_burned'),
-                sql `SUM(CASE WHEN burn.usdc_spent > 0 THEN burn.usdc_spent ELSE COALESCE(burn.from_escrow_usdc, 0) END)`.as('usdc_spent'),
+                fn.sum('burn.burned').as('render_burned'),
+                fn.sum('burn.usdc_spent').as('usdc_spent'),
                 fn.count('burn.id').as('burn_count'),
             ])
                 .groupBy(sql `date_trunc('day', sol_tx.executed_at)`)
@@ -1957,6 +1893,21 @@ export const pgClient = (config) => {
             });
         },
         async insertDispersedOutbox(p, log = consoleLogger) {
+            // Check if dispersed_obligation table exists BEFORE the transaction so a missing table never
+            // poisons the txn (PG aborts the entire transaction on any error, even a caught one).
+            let hasObligationTable = false;
+            if (p.obligations?.length) {
+                try {
+                    const { rows } = await timedQuery(pgPool, `SELECT 1 FROM information_schema.tables WHERE table_name = 'dispersed_obligation' LIMIT 1`, [], 'checkObligationTable', log);
+                    hasObligationTable = rows.length > 0;
+                }
+                catch {
+                    hasObligationTable = false;
+                }
+                if (!hasObligationTable) {
+                    log.warn(`dispersed obligations: table not found (migration 44 pending); skipping for tx ${p.txSignature}`);
+                }
+            }
             // The outbox row is the durable, crash-safe anchor persisted BEFORE broadcast. When it carries a
             // burn-correction draw, we increment consumed_render in the SAME transaction as the insert, bounded
             // so it can never exceed amount_render. Row + counter are therefore atomic and inseparable: no
@@ -1964,7 +1915,7 @@ export const pgClient = (config) => {
             // (decremented again by voidDispersedOutbox). If the bounded increment can't fit (a concurrent draw
             // took the room), the whole txn rolls back and we return {inserted:false} — the caller must NOT
             // broadcast (no row, no counter change, no burn).
-            return await db.transaction().execute(async (trx) => {
+            const result = await db.transaction().execute(async (trx) => {
                 const res = await trx
                     .insertInto(DISPERSED_SETTLEMENT_TABLE)
                     .values({
@@ -2005,13 +1956,29 @@ export const pgClient = (config) => {
                         throw new DispersedCorrectionRejected();
                     }
                 }
-                log.debug(`dispersed outbox tx ${p.txSignature}: ${res.numInsertedOrUpdatedRows} row(s)`);
+                if (inserted && hasObligationTable && p.obligations?.length) {
+                    for (const o of p.obligations) {
+                        await trx
+                            .insertInto('dispersed_obligation')
+                            .values({
+                            settlement_tx_sig: p.txSignature,
+                            uuid: o.uuid,
+                            amount_eur: o.amountEur,
+                            opened_at: o.openedAt,
+                            authorization_uuid: o.authorizationUuid ?? null,
+                        })
+                            .onConflict((oc) => oc.column('uuid').doNothing())
+                            .execute();
+                    }
+                }
+                log.debug(`dispersed outbox tx ${p.txSignature}: ${res.numInsertedOrUpdatedRows} row(s), ${hasObligationTable ? (p.obligations?.length ?? 0) : 0} obligations`);
                 return { inserted };
             }).catch((e) => {
                 if (e instanceof DispersedCorrectionRejected)
                     return { inserted: false };
                 throw e;
             });
+            return result;
         },
         async getOutstandingDispersedCorrection(log = consoleLogger) {
             // consumed_render is the atomic source of truth; outstanding = amount_render - consumed_render.