@render-foundation/utils 0.0.256 → 0.0.258

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

@@ -1506,6 +1506,7 @@ 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;
             }
@@ -1528,70 +1529,133 @@ export const pgClient = (config) => {
             return burns;
         },
         async fetchBurnsPage(db, f, log = consoleLogger) {
-            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);
+            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 = c.ea;
+                    cursorType = c.t;
+                    cursorId = c.id;
+                }
+                catch {
+                    // Legacy cursor: bare burn.id — treat as buy-burn cursor.
+                    cursorId = Number(raw);
+                    cursorType = 'buy';
+                }
             }
+            // 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) {
-                // "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);
+                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, st.executed_at::text AS executed_at_raw, 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, st.executed_at::text AS executed_at_raw, 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)}`;
             }
             const limit = f.limit ?? 1000;
-            q = q.limit(limit).orderBy('burn.id');
-            const comp = q.compile();
-            const { rows } = await timedQuery(pgPool, comp.sql, comp.parameters, 'fetchBurnsPage', log);
+            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);
             const burns = rows.map((r) => ({
                 jobs: [],
                 id: Number(r.id),
-                renderToUsdc: r.render_to_usdc,
+                type: r.type,
+                renderToUsdc: r.render_to_usdc ?? undefined,
                 solTx: r.sig,
                 executedAt: r.executed_at,
-                pricedAt: r.priced_at,
+                pricedAt: r.priced_at ?? undefined,
                 usdcSpent: BigInt(r.usdc_spent ?? 0),
                 quoteAmt: BigInt(r.quote_amt ?? 0),
                 burned: BigInt(r.burned),
-                eurToUsdc: r.eur_to_usdc,
+                eurToUsdc: r.eur_to_usdc ?? undefined,
                 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(String(burns[burns.length - 1].id))
+                    ? btoa(JSON.stringify({
+                        ea: rows[burns.length - 1].executed_at_raw,
+                        t: rows[burns.length - 1].type,
+                        id: rows[burns.length - 1].sortid,
+                    }))
                     : undefined,
             };
         },
-        async fetchBurnJobs(db, burnId, log = consoleLogger) {
+        async fetchBurnJobs(db, burnId, burnType = 'buy', log = consoleLogger) {
+            const fk = burnType === 'grant' ? 'grant_burn_id' : 'burn_id';
             const rows = await db.trx
                 .selectFrom('job')
                 .selectAll('job')
-                .where('burn_id', '=', String(burnId))
+                .where(fk, '=', String(burnId))
                 .execute();
-            log.debug(`fetchBurnJobs burn ${burnId} -> ${rows.length} jobs`);
+            log.debug(`fetchBurnJobs ${burnType} ${burnId} -> ${rows.length} jobs`);
             return rows.map((r) => ({
                 id: Number(r.id),
                 completedAt: r.completed_at,
@@ -1612,8 +1676,8 @@ export const pgClient = (config) => {
                 .innerJoin('sol_tx', 'sol_tx.id', 'burn.sol_tx_id')
                 .select(({ fn }) => [
                 dayExpr.as('day'),
-                fn.sum('burn.burned').as('render_burned'),
-                fn.sum('burn.usdc_spent').as('usdc_spent'),
+                sql `SUM(burn.burned + CASE 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(burn.usdc_spent + COALESCE(burn.from_escrow_usdc, 0))`.as('usdc_spent'),
                 fn.count('burn.id').as('burn_count'),
             ])
                 .groupBy(sql `date_trunc('day', sol_tx.executed_at)`)
@@ -1893,21 +1957,6 @@ 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
@@ -1915,7 +1964,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).
-            const result = await db.transaction().execute(async (trx) => {
+            return await db.transaction().execute(async (trx) => {
                 const res = await trx
                     .insertInto(DISPERSED_SETTLEMENT_TABLE)
                     .values({
@@ -1956,29 +2005,13 @@ export const pgClient = (config) => {
                         throw new DispersedCorrectionRejected();
                     }
                 }
-                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`);
+                log.debug(`dispersed outbox tx ${p.txSignature}: ${res.numInsertedOrUpdatedRows} row(s)`);
                 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.