@render-foundation/utils 0.0.180 → 0.0.182

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

@@ -0,0 +1,1465 @@
+import { Kysely, NoResultError, PostgresDialect, sql, } from 'kysely';
+import { consoleLogger } from '../../logger';
+import { Pool } from 'pg';
+import * as pg from 'pg';
+import { timedQuery } from './base';
+export const SOL_TX_TABLE = 'sol_tx';
+export const EPOCH_TABLE = 'epoch';
+export const MANUAL_BURN_TABLE = 'manual_burn';
+export const ENTITY_TABLE = 'entity';
+export const SOL_TRANSFER_TABLE = 'sol_transfer1';
+export const LIABILITY_TABLE = 'liability';
+export const JOB_ID_TABLE = 'job_id';
+export const JOB_TABLE = 'job';
+export const BURN_TABLE = 'burn';
+export const BRIDGE_TRANSFER_TABLE = 'bridge_transfer';
+export const NETWORK_REVENUE_TABLE = 'network_revenue';
+export const BURN_ADJUSTMENT_TABLE = 'burn_adjustment';
+export const ENTITY_EPOCH_INFO_TABLE = 'entity_epoch_info';
+export const POLYGON_UPGRADE_TABLE = 'polygon_upgrade';
+export const CURRENT_USER_GRANT_SPEND_TABLE = 'current_user_grant_spend';
+export const USER_GRANT_SPEND_TABLE = 'user_grant_spend';
+export const GRANT_BURN_ID_TABLE = 'grant_burn_id';
+export const GRANT_BURN_TABLE = 'grant_burn';
+BigInt.prototype.toJSON = function () {
+    return this.toString();
+};
+import { begin } from './base';
+import moment from 'moment';
+pg.types.setTypeParser(1114, (str) => moment.utc(str).toDate());
+pg.defaults.parseInputDatesAsUTC = true;
+/* ;(Date.prototype as any).toPostgres = function (prepareValue: (v: any) => any) {
+  return this.toISOString()
+}
+ */
+export const batchFinishedAtMedian = (jobs) => {
+    const pricedAt = jobs.length % 2 == 0
+        ? new Date(Math.trunc((Date.parse(jobs[jobs.length / 2].finishedAt) +
+            Date.parse(jobs[jobs.length / 2 - 1].finishedAt)) /
+            2))
+        : new Date(Date.parse(jobs[Math.floor(jobs.length / 2)].finishedAt));
+    return pricedAt;
+};
+export const pgClient = (config) => {
+    // Single pg pool that we can also use for ad-hoc performance tests outside Kysely
+    const pgPool = new Pool(config);
+    pgPool.on('connect', (c) => console.log('new pg socket created'));
+    pgPool.on('error', (err) => console.log('idle pg client died and was replaced:', err));
+    const dialect = new PostgresDialect({ pool: pgPool });
+    // Database interface is passed to Kysely's constructor, and from now on, Kysely
+    // knows your database structure.
+    // Dialect is passed to Kysely's constructor, and from now on, Kysely knows how
+    // to communicate with your database.
+    const db = new Kysely({
+        dialect,
+    });
+    const getOrInsertEntity = async (db, p, log = consoleLogger) => {
+        const res = (await db
+            .selectFrom(ENTITY_TABLE)
+            .select('id')
+            .where('sol_key', '=', p.solKey)
+            .executeTakeFirst());
+        if (res) {
+            log.debug(`already found entity ${res.id}`);
+            return res.id;
+        }
+        const { id } = (await db
+            .insertInto(ENTITY_TABLE)
+            .values({
+            sol_key: p.solKey,
+        })
+            .onConflict((oc) => oc.column('sol_key').doNothing())
+            .returning((eb) => ['id as id'])
+            .executeTakeFirst());
+        log.debug(`inserted entity ${id}`);
+        return id;
+    };
+    const getOrInsertTx = async (db, p, log = consoleLogger) => {
+        const res = await db
+            .selectFrom(SOL_TX_TABLE)
+            .select('id')
+            .where('sig', '=', p.sig)
+            .executeTakeFirst();
+        if (res) {
+            log.debug(`already found tx ${res.id}`);
+            return res.id;
+        }
+        const { id } = (await db
+            .insertInto(SOL_TX_TABLE)
+            .values({
+            sig: p.sig,
+            executed_at: p.executedAt,
+        })
+            .onConflict((oc) => oc.column('sig').doNothing())
+            .returning((eb) => ['id as id'])
+            .executeTakeFirst());
+        log.debug(`inserted tx ${id}`);
+        return id;
+    };
+    const getOrInsertEpoch = async (db, p, log = consoleLogger) => {
+        const res = await db
+            .selectFrom(EPOCH_TABLE)
+            .select('id')
+            .where('ui', '=', String(p.uiEpochId))
+            .where('channel', '=', p.channel)
+            .executeTakeFirst();
+        if (res) {
+            log.debug(`already found epoch ${res.id}`);
+            return res.id;
+        }
+        const { id } = (await db
+            .insertInto(EPOCH_TABLE)
+            .values({
+            ui: p.uiEpochId,
+            channel: p.channel,
+            start_time: p.startTime,
+            end_time: p.endTime,
+            saved_at: p.channel == 'node_operator' || p.channel == 'availability'
+                ? new Date()
+                : undefined,
+        })
+            .onConflict((oc) => oc.columns(['ui', 'channel']).doNothing())
+            .returning((eb) => ['id as id'])
+            .executeTakeFirst());
+        log.debug(`inserted epoch ${id}`);
+        return id;
+    };
+    const getCurrentUserGrantSpend = async (db, p, log = consoleLogger) => {
+        const res = await db
+            .selectFrom(CURRENT_USER_GRANT_SPEND_TABLE)
+            .selectAll()
+            .where('user_id', '=', p.userId)
+            .forUpdate()
+            .executeTakeFirst();
+        return res
+            ? {
+                id: BigInt(res.id),
+                user: res.user_id,
+                renderSpent: BigInt(res.render_spent),
+                perpetual: res.perpetual ?? false,
+                description: res.description,
+            }
+            : undefined;
+    };
+    const updateTotalRndr = async (db, p, totalRndr, savedAt, log) => {
+        const res = (await db
+            .updateTable(EPOCH_TABLE)
+            .set({
+            total_rndr: totalRndr,
+            saved_at: savedAt,
+        })
+            .where('channel', '=', p.channel)
+            .where('ui', '=', String(p.uiEpochId))
+            .executeTakeFirst());
+        log.info(`set ${res.numUpdatedRows} rows. channel: ${p.channel}, ui: ${p.uiEpochId} -> totalRndr ${totalRndr} `);
+    };
+    const fetchJobs1 = async (db, f, log = consoleLogger) => {
+        let q = db.selectFrom('job').selectAll();
+        //.where('job.burn_id', 'is not', null)
+        if (f.completedAtAfter) {
+            q = q.where('completed_at', '>=', f.completedAtAfter);
+        }
+        if (f.completedAtBefore) {
+            q = q.where('completed_at', '<=', f.completedAtBefore);
+        }
+        if (f.ids) {
+            q = q.where('id', 'in', f.ids);
+        }
+        else {
+            if (f.burned == false) {
+                q = q.where('burn_id', 'is', null);
+            }
+            else if (f.burned == true) {
+                q = q.where('burn_id', 'is not', null);
+            }
+        }
+        q = q.orderBy('completed_at asc');
+        log.info(`fetchJobs q ${q.compile().sql} ${JSON.stringify(f)}`);
+        const rows = await q.execute();
+        return rows.map((r) => ({
+            id: Number(r.id),
+            completedAt: r.completed_at,
+            rndrUsed: BigInt(r.render_amt),
+            insertedAt: r.inserted_at,
+        }));
+    };
+    const createBridgeTransfers = async (db, bts, log = consoleLogger) => {
+        const sequenceNumbers = [];
+        const dbEpochIds = [];
+        for (const bt of bts) {
+            let { solKey: toSolKey, seq, createdAt, amount, upgradeBracket, priorSupply, points, epochId, } = bt;
+            let entityId;
+            if (toSolKey && toSolKey != '') {
+                entityId = await getOrInsertEntity(db, { solKey: toSolKey });
+            }
+            const dbEpochId = await getOrInsertEpoch(db, {
+                channel: 'upgrade',
+                uiEpochId: epochId,
+            }, log);
+            dbEpochIds.push(BigInt(dbEpochId));
+            const q = db
+                .insertInto(BRIDGE_TRANSFER_TABLE)
+                .values({
+                entity_id: entityId,
+                sequence: seq,
+                created_at: createdAt,
+                amount: amount,
+                upgrade_bracket: upgradeBracket,
+                prior_supply: priorSupply,
+                points: points,
+                epoch_id: dbEpochId,
+            })
+                .onConflict((oc) => oc.column('sequence').doUpdateSet({
+                created_at: createdAt,
+                amount: amount,
+                upgrade_bracket: upgradeBracket,
+                prior_supply: priorSupply,
+                points: points,
+                epoch_id: dbEpochId,
+                entity_id: entityId,
+            }))
+                .returning('sequence');
+            const c = q.compile();
+            log.debug(`inserting bridge transfer ${JSON.stringify(bt)} -> ${c.sql} ps ${c.parameters}`);
+            const { sequence: seqNum } = await q.executeTakeFirst();
+            log.debug(`inserted bridge transfer sequence ${seq}`);
+            sequenceNumbers.push(BigInt(seqNum));
+        }
+        return { sequenceNumbers: sequenceNumbers };
+    };
+    const createPayments = async (db, ps, log = consoleLogger) => {
+        const ids = [];
+        const epochDbIds = [];
+        for (const p of ps) {
+            let liabilityId;
+            let transferId;
+            if (p.liability) {
+                let { id: dbId, solKey, channel, epochId, createdAt, amountDue, deviceId, points, obhUsed, } = p.liability;
+                try {
+                    let entityId;
+                    if (solKey && solKey != '') {
+                        entityId = await getOrInsertEntity(db, { solKey });
+                    }
+                    const dbEpochId = await getOrInsertEpoch(db, {
+                        channel,
+                        uiEpochId: epochId,
+                    }, log);
+                    epochDbIds.push(BigInt(dbEpochId));
+                    log.debug(`inserting liability ${JSON.stringify(p.liability)}`);
+                    const { id } = await db
+                        .insertInto(LIABILITY_TABLE)
+                        .values({
+                        id: dbId,
+                        entity_id: entityId,
+                        epoch_id: dbEpochId,
+                        channel,
+                        created_at: createdAt ?? new Date(),
+                        amount_due: amountDue,
+                        device_id: deviceId,
+                        points,
+                        obh_used: obhUsed,
+                    })
+                        .returning((eb) => ['id as id'])
+                        .executeTakeFirstOrThrow();
+                    log.debug(`inserted liability ${id}`);
+                    liabilityId = BigInt(id);
+                }
+                catch (e) {
+                    throw new Error(`failed inserting solKey ${solKey} epochId ${epochId} ${JSON.stringify(p.liability)}: ${e}`);
+                }
+            }
+            if (p.transfer) {
+                let { executedAt, symbol, amountPayed, solTx, channel, fromSolKey, toSolKey, id: dbId, } = p.transfer;
+                if (!fromSolKey || !toSolKey || !solTx) {
+                    log.debug(`skipping transfer. one of undefined: fromKey ${fromSolKey} toKey ${toSolKey} tx ${solTx}`);
+                    continue;
+                }
+                log.debug(`inserting transfer ${JSON.stringify(p.transfer)}`);
+                const fromEntityId = await getOrInsertEntity(db, { solKey: fromSolKey });
+                const toEntityId = await getOrInsertEntity(db, { solKey: toSolKey });
+                const solTxId = await getOrInsertTx(db, {
+                    sig: solTx,
+                    executedAt,
+                }, log);
+                const { id } = await db
+                    .insertInto(SOL_TRANSFER_TABLE)
+                    .values({
+                    id: dbId,
+                    sol_tx_id: solTxId,
+                    from_entity_id: fromEntityId,
+                    to_entity_id: toEntityId,
+                    channel,
+                    symbol,
+                    amount_payed: amountPayed,
+                })
+                    .returning((eb) => ['id as id'])
+                    .executeTakeFirstOrThrow();
+                transferId = BigInt(id);
+            }
+            ids.push({ transferId, liabilityId });
+        }
+        return { epochDbIds, inserted: ids };
+    };
+    return {
+        db: {
+            commit: () => { },
+            rollback: () => { },
+            trx: db,
+        },
+        async startTransaction(log = consoleLogger) {
+            return begin(db, log);
+        },
+        async createPayments(db, ps, log = consoleLogger) {
+            return createPayments(db.trx, ps, log);
+        },
+        async fetchTransfers(db, f, log = consoleLogger) {
+            let lastId = undefined;
+            if (f.cursor) {
+                lastId = atob(f.cursor);
+            }
+            let q = db.trx
+                .selectFrom(SOL_TRANSFER_TABLE)
+                .select([
+                'sol_transfer1.id',
+                'sol_transfer1.channel',
+                'sol_transfer1.symbol',
+                'sol_transfer1.amount_payed',
+            ])
+                .innerJoin('sol_tx', 'sol_tx.id', 'sol_transfer1.sol_tx_id')
+                .select(['sol_tx.sig', 'sol_tx.executed_at'])
+                .innerJoin('entity as f', 'f.id', 'sol_transfer1.from_entity_id')
+                .select(['f.sol_key as from_sol_key'])
+                .innerJoin('entity as t', 't.id', 'sol_transfer1.to_entity_id')
+                .select(['t.sol_key as to_sol_key']);
+            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.channels) {
+                q = q.where('sol_transfer1.channel', 'in', f.channels);
+            }
+            if (lastId) {
+                q = q.where('sol_transfer1.id', '>', lastId);
+            }
+            let limit = 10000;
+            if (f.limit) {
+                limit = f.limit;
+            }
+            q = q.limit(limit).orderBy(`${SOL_TRANSFER_TABLE}.id`);
+            const comp = q.compile();
+            const { rows } = await timedQuery(pgPool, comp.sql, comp.parameters, 'fetchTransfers', log);
+            const trs = rows.map((r) => ({
+                id: BigInt(r.id),
+                channel: r.channel,
+                symbol: r.symbol,
+                amountPayed: BigInt(r.amount_payed),
+                solTx: r.sig,
+                executedAt: r.executed_at,
+                fromSolKey: r.from_sol_key,
+                toSolKey: r.to_sol_key,
+            }));
+            return {
+                transfers: trs,
+                cursor: trs.length === limit
+                    ? btoa(trs[trs.length - 1].id.toString())
+                    : undefined,
+            };
+        },
+        async fetchEpochs(db, f, log = consoleLogger) {
+            let q = db.trx.selectFrom(EPOCH_TABLE).selectAll();
+            if (f.channels) {
+                q = q.where('channel', 'in', f.channels);
+            }
+            if (f.startTimeAfter) {
+                q = q.where('epoch.start_time', '>', f.startTimeAfter);
+            }
+            if (f.endTimeBefore) {
+                q = q.where('epoch.end_time', '<', f.endTimeBefore);
+            }
+            q = q.orderBy('epoch.start_time');
+            const comp = q.compile();
+            const { rows } = await timedQuery(pgPool, comp.sql, comp.parameters, 'fetchEpochs', log);
+            return rows.map((e) => ({
+                channel: e.channel,
+                startTime: e.start_time,
+                endTime: e.end_time,
+                ui: Number(e.ui),
+                totalRndr: Number(e.total_rndr),
+            }));
+        },
+        async fetchLiabilities(db, f, log = consoleLogger) {
+            let offset = 0;
+            let orderBy = f.orderBy ?? 'epoch.ui,liability.id';
+            if (f.cursor) {
+                const c = JSON.parse(atob(f.cursor));
+                if (c.offset) {
+                    offset = c.offset;
+                }
+                if (c.orderBy) {
+                    orderBy = c.orderBy;
+                }
+            }
+            let q = db.trx
+                .selectFrom(LIABILITY_TABLE)
+                .selectAll()
+                .innerJoin(ENTITY_TABLE, `${LIABILITY_TABLE}.entity_id`, 'entity.id')
+                .select(['entity.sol_key'])
+                .innerJoin(EPOCH_TABLE, `${EPOCH_TABLE}.id`, 'liability.epoch_id')
+                .select(['epoch.ui', 'epoch.start_time', 'epoch.end_time']);
+            if (f.epochEndedAtAfter) {
+                q = q.where('epoch.end_time', '>=', f.epochEndedAtAfter);
+            }
+            if (f.epochEndedAtBefore) {
+                q = q.where('epoch.end_time', '<=', f.epochEndedAtBefore);
+            }
+            if (f.epochId) {
+                q = q.where('epoch.ui', '=', f.epochId.toString());
+            }
+            if (f.channels) {
+                q = q.where('liability.channel', 'in', f.channels);
+            }
+            let limit = 10000;
+            if (f.limit) {
+                limit = f.limit;
+            }
+            // @ts-ignore
+            q = q.limit(limit).orderBy(orderBy.split(','));
+            if (offset) {
+                q = q.offset(offset);
+            }
+            const comp = q.compile();
+            const { rows } = await timedQuery(pgPool, comp.sql, comp.parameters, 'fetchLiabilities', log);
+            const ls = [];
+            for (const l of rows) {
+                ls.push({
+                    id: BigInt(l.id),
+                    solKey: l.sol_key,
+                    epochId: Number(l.ui),
+                    channel: l.channel,
+                    createdAt: l.created_at,
+                    amountDue: BigInt(l.amount_due),
+                    deviceId: l.device_id,
+                    obhUsed: l.obh_used,
+                    points: l.points ? BigInt(l.points) : undefined,
+                    startTime: l.start_time,
+                    endTime: l.end_time,
+                    ui: Number(l.ui),
+                });
+            }
+            return {
+                liabilities: ls,
+                cursor: ls.length == limit
+                    ? btoa(JSON.stringify({ offset: ls.length + offset, orderBy }))
+                    : undefined,
+            };
+        },
+        async getLiabilitiesAndTransfers(f, log = consoleLogger) {
+            let lq = db
+                .selectFrom(LIABILITY_TABLE)
+                .selectAll()
+                .innerJoin(ENTITY_TABLE, `${LIABILITY_TABLE}.entity_id`, 'entity.id')
+                .select(['entity.sol_key'])
+                .innerJoin(EPOCH_TABLE, `${EPOCH_TABLE}.id`, 'liability.epoch_id')
+                .select(['epoch.ui', 'epoch.start_time', 'epoch.end_time'])
+                .where('entity.sol_key', '=', f.user);
+            let tq = db
+                .selectFrom(SOL_TRANSFER_TABLE)
+                .selectAll()
+                .innerJoin(SOL_TX_TABLE, 'sol_tx.id', 'sol_transfer1.sol_tx_id')
+                .select(['sol_tx.sig', 'sol_tx.executed_at'])
+                .innerJoin(`${ENTITY_TABLE} as t`, `${SOL_TRANSFER_TABLE}.to_entity_id`, 't.id')
+                .select(['t.sol_key as to_sol_key'])
+                .innerJoin(`${ENTITY_TABLE} as f`, `${SOL_TRANSFER_TABLE}.from_entity_id`, 'f.id')
+                .select(['f.sol_key as from_sol_key'])
+                .where('t.sol_key', '=', f.user);
+            log.info(`fetch liabilities ${lq.compile().sql} ps ${JSON.stringify(f)}`);
+            log.info(`fetch transfers ${tq.compile().sql} ps ${JSON.stringify(f)}`);
+            const lc = lq.compile();
+            const tc = tq.compile();
+            const [liabRes, transRes] = await Promise.all([
+                timedQuery(pgPool, lc.sql, lc.parameters, 'getLiabilitiesAndTransfers->liabilities', log),
+                timedQuery(pgPool, tc.sql, tc.parameters, 'getLiabilitiesAndTransfers->transfers', log),
+            ]);
+            const rows = [liabRes.rows, transRes.rows];
+            const epochs = {};
+            const liabilities = [];
+            for (const l of rows[0]) {
+                epochs[`${l.ui}-${l.channel}`] = {
+                    startTime: l.start_time,
+                    endTime: l.end_time,
+                    channel: l.channel,
+                    ui: Number(l.ui),
+                };
+                liabilities.push({
+                    id: BigInt(l.id),
+                    solKey: l.sol_key,
+                    epochId: Number(l.ui),
+                    channel: l.channel,
+                    createdAt: l.created_at,
+                    amountDue: BigInt(l.amount_due),
+                    deviceId: l.device_id,
+                    points: l.points ? BigInt(l.points) : undefined,
+                });
+            }
+            const transfers = rows[1].map((r) => ({
+                id: BigInt(r.id),
+                fromSolKey: r.from_sol_key,
+                toSolKey: r.to_sol_key,
+                symbol: r.symbol,
+                channel: r.channel,
+                solTx: r.sig,
+                executedAt: r.executed_at,
+                amountPayed: BigInt(r.amount_payed),
+            }));
+            return { transfers, liabilities, epochs: Object.values(epochs) };
+        },
+        async getOutstanding(f, log = consoleLogger) {
+            let epochUi;
+            let epochEndTime;
+            if (f.startEpochId.id) {
+                if (f.channels?.includes('node_operator') ||
+                    f.channels?.includes('availability')) {
+                    let qb = db
+                        .selectFrom(EPOCH_TABLE)
+                        .selectAll(EPOCH_TABLE)
+                        .where('ui', '>', f.startEpochId.id.toString())
+                        .where('channel', 'in', f.channels);
+                    if (f.startEpochId.savedAtNotNull) {
+                        qb = qb.where('saved_at', 'is not', null);
+                    }
+                    const e = await qb
+                        .orderBy('ui', 'desc')
+                        .limit(1)
+                        .executeTakeFirstOrThrow();
+                    epochEndTime = e.end_time;
+                    epochUi = e.ui;
+                }
+                else {
+                    epochUi = f.startEpochId.id.toString();
+                }
+            }
+            let q = db
+                .selectFrom((eb) => eb
+                .selectFrom((eb) => {
+                let b = eb
+                    .selectFrom(SOL_TRANSFER_TABLE)
+                    .select(({ fn }) => fn.sum(`amount_payed`).as('payed'))
+                    .innerJoin(ENTITY_TABLE, `${SOL_TRANSFER_TABLE}.to_entity_id`, 'entity.id')
+                    .select(['entity.sol_key'])
+                    .groupBy('entity.sol_key');
+                if (f.banned) {
+                    b = b.where('entity.banned', '=', true);
+                }
+                else {
+                    b = b.where('entity.banned', '=', false);
+                }
+                if (epochEndTime) {
+                    b = b
+                        .innerJoin(SOL_TX_TABLE, `${SOL_TX_TABLE}.id`, `${SOL_TRANSFER_TABLE}.sol_tx_id`)
+                        .where(`${SOL_TX_TABLE}.executed_at`, '>', epochEndTime);
+                }
+                if (f.channels && f.channels.length > 0) {
+                    b = b.where((eb) => eb.or(f.channels.map((c) => eb('sol_transfer1.channel', '=', c))));
+                }
+                else {
+                    b = b.where((eb) => eb.or([
+                        eb('sol_transfer1.channel', '=', 'node_operator'),
+                        eb('sol_transfer1.channel', '=', 'availability'),
+                    ]));
+                }
+                return b.as('y');
+            })
+                .fullJoin((eb) => {
+                let b = eb
+                    .selectFrom(LIABILITY_TABLE)
+                    .select(({ fn }) => fn.sum(`amount_due`).as('due'))
+                    .innerJoin(ENTITY_TABLE, `${LIABILITY_TABLE}.entity_id`, 'entity.id')
+                    .select(['entity.sol_key'])
+                    .groupBy('entity.sol_key');
+                if (f.banned) {
+                    b = b.where('entity.banned', '=', true);
+                }
+                else {
+                    b = b.where('entity.banned', '=', false);
+                }
+                if (epochUi) {
+                    b = b
+                        .innerJoin(EPOCH_TABLE, `${LIABILITY_TABLE}.epoch_id`, `${EPOCH_TABLE}.id`)
+                        .where(`${EPOCH_TABLE}.ui`, '>=', epochUi);
+                }
+                if (f.channels && f.channels.length > 0) {
+                    b = b.where((eb) => eb.or(f.channels.map((c) => eb('liability.channel', '=', c))));
+                }
+                else {
+                    b = b.where((eb) => eb.or([
+                        eb('liability.channel', '=', 'node_operator'),
+                        eb('liability.channel', '=', 'availability'),
+                    ]));
+                }
+                return b.as('x');
+            }, (join) => join.onRef('y.sol_key', '=', 'x.sol_key'))
+                .select(({ fn }) => [
+                fn.coalesce('y.sol_key', 'x.sol_key').as('sol_key'),
+                sql `${fn.coalesce(`x.due`, sql `0`)} -
+              ${fn.coalesce(`y.payed`, sql `0`)}`.as('out'),
+            ])
+                .as('z'))
+                .selectAll();
+            if (f.due == 'overpayed') {
+                q = q.where('out', '<', '0');
+            }
+            else if (f.due == 'underpayed') {
+                q = q.where('out', '>', '0');
+            }
+            log.info(`${q.compile().sql} ps ${JSON.stringify({
+                ...f,
+                epochEndTime,
+                epochUi,
+            })}`);
+            const res = await q.execute();
+            const out = {};
+            for (const r of res) {
+                out[r.sol_key] = BigInt(r.out);
+            }
+            return out;
+        },
+        async fetchNodeOperatorEpoch(epochId, log = consoleLogger) {
+            const q = db
+                .selectFrom(JOB_ID_TABLE)
+                .innerJoin(EPOCH_TABLE, 'epoch.id', 'job_id.epoch_id')
+                .leftJoin(MANUAL_BURN_TABLE, 'manual_burn.epoch_id', 'epoch.id')
+                .where('epoch.ui', '=', epochId.toString())
+                .where('epoch.channel', '=', 'node_operator')
+                .select([
+                'job_id.id',
+                'epoch.total_rndr',
+                'epoch.start_time',
+                'epoch.end_time',
+                'manual_burn.burned',
+                'manual_burn.tx_sig',
+            ])
+                .orderBy('job_id.id asc');
+            log.debug(`fetch epoch info q ${q.compile().sql} epochId ${epochId}`);
+            const res = await q.execute();
+            if (res.length == 0) {
+                throw new Error(`epoch ${epochId} not found`);
+            }
+            log.debug(`fetchNodeOperatorEpoch -> fetching liablities`);
+            const ks = await db
+                .selectFrom(LIABILITY_TABLE)
+                .innerJoin(ENTITY_TABLE, 'liability.entity_id', 'entity.id')
+                .select(({ fn }) => [
+                sql `distinct
+              (entity.sol_key)`.as('sol_key'),
+            ])
+                .innerJoin(EPOCH_TABLE, 'liability.epoch_id', 'epoch.id')
+                .where('epoch.ui', '=', epochId.toString())
+                .where('epoch.channel', '=', 'node_operator')
+                .where('liability.channel', '=', 'node_operator')
+                .execute();
+            log.debug(`fetchNodeOperatorEpoch -> fetched liablities`);
+            const solKeys = ks.reduce((r, k) => {
+                r[k.sol_key] = {};
+                return r;
+            }, {});
+            return {
+                jobIds: res.map((r) => Number(r.id)),
+                totalRndr: BigInt(res[0].total_rndr),
+                startTime: res[0].start_time,
+                endTime: res[0].end_time,
+                burned: BigInt(res[0].burned ?? 0),
+                burnTx: res[0].tx_sig,
+                solKeys,
+            };
+        },
+        async insertEpoch(db, epoch, log = consoleLogger) {
+            await getOrInsertEpoch(db.trx, { ...epoch, uiEpochId: epoch.ui }, log);
+        },
+        async getEpoch(f, log = consoleLogger) {
+            const now = new Date(Date.now());
+            try {
+                let q = db
+                    .selectFrom(EPOCH_TABLE)
+                    .selectAll()
+                    .where('channel', '=', f.channel);
+                if (f.epochId) {
+                    q = q.where('ui', '=', f.epochId.toString());
+                }
+                else {
+                    q = q.where('end_time', '<=', now);
+                    if (!f.savedAtNotNull) {
+                        q = q.where('saved_at', 'is', null);
+                    }
+                    else {
+                        q = q.where('saved_at', 'is not', null);
+                    }
+                }
+                q = q.orderBy('end_time desc').limit(1);
+                const res = await q.executeTakeFirstOrThrow();
+                return {
+                    ui: Number(res.ui),
+                    channel: f.channel,
+                    startTime: res.start_time,
+                    endTime: res.end_time,
+                    savedAt: res.saved_at ?? undefined,
+                };
+            }
+            catch (e) {
+                if (e instanceof NoResultError) {
+                    log.info(`no node operator epoch found`);
+                    return undefined;
+                }
+                throw e;
+            }
+        },
+        async getLatestNodeOperatorEpoch(f, log = consoleLogger) {
+            const now = new Date(Date.now());
+            try {
+                let q = db
+                    .selectFrom(EPOCH_TABLE)
+                    .selectAll()
+                    .where('channel', '=', 'node_operator')
+                    .where('end_time', '<=', now);
+                if (!f.latestDistributed) {
+                    q = q.where('saved_at', 'is', null).orderBy('end_time asc');
+                }
+                else {
+                    q = q.orderBy('end_time desc');
+                }
+                q = q.limit(1);
+                const res = await q.executeTakeFirstOrThrow();
+                return {
+                    epochId: BigInt(res.ui),
+                    startedAt: res.start_time,
+                    endedAt: res.end_time,
+                    savedAt: res.saved_at ?? undefined,
+                };
+            }
+            catch (e) {
+                if (e instanceof NoResultError) {
+                    log.info(`no node operator epoch found`);
+                    return undefined;
+                }
+                throw e;
+            }
+        },
+        async insertEpochEntityInfo(db, eeis, log) {
+            for (const eei of eeis) {
+                await db.trx.insertInto(ENTITY_EPOCH_INFO_TABLE).values(eei).execute();
+                log.debug(`inserted eei ${JSON.stringify(eei)}`);
+            }
+        },
+        async saveNodeOperatorEpoch(epochId, liabilities, jobIds, totalRndr, log = consoleLogger) {
+            await db
+                .transaction()
+                .setIsolationLevel('repeatable read')
+                .execute(async (trx) => {
+                const { epochDbIds } = await createPayments(trx, liabilities.map((l) => ({
+                    liability: l,
+                })), log);
+                log.info(`inserted liabilities`);
+                for (const id of jobIds) {
+                    await trx
+                        .insertInto(JOB_ID_TABLE)
+                        .values({
+                        id: BigInt(id),
+                        epoch_id: epochDbIds[0],
+                    })
+                        .executeTakeFirstOrThrow();
+                }
+                const now = new Date();
+                await updateTotalRndr(db, { uiEpochId: epochId, channel: 'node_operator' }, totalRndr, now, log);
+                log.debug(`saved epoch`);
+                /*const now = new Date(Date.now())
+                const res = await trx
+                  .updateTable(EPOCH_TABLE)
+                  .set({
+                    saved_at: now,
+                    total_rndr: totalRndr,
+                  })
+                  .where('channel')
+                  .where('ui', '=', epochId.toString())
+                  .where('', '=')
+                  .executeTakeFirstOrThrow()*/
+            });
+            return;
+        },
+        async produceBurnedJobs(jobs, log = consoleLogger) {
+            await db.transaction().execute(async (trx) => {
+                let num = BigInt(0);
+                for (const { amount, obhUsed, completedAt, jobId, userId } of jobs) {
+                    const res = await trx
+                        .insertInto(JOB_TABLE)
+                        .values({
+                        id: jobId,
+                        render_amt: amount,
+                        completed_at: completedAt,
+                        inserted_at: new Date(Date.now()),
+                        obh_used: obhUsed,
+                        user_id: userId,
+                    })
+                        .onConflict((oc) => oc.column('id').doNothing())
+                        .executeTakeFirstOrThrow();
+                    num += res.numInsertedOrUpdatedRows ?? BigInt(0);
+                }
+                log.debug(`inserted ${num} of ${jobs.length} burn jobs`);
+            });
+        },
+        async markJobsBurntWithGrant(db, p, log = consoleLogger) {
+            const solTxId = await getOrInsertTx(db.trx, { sig: p.tx.sig, executedAt: p.tx.executedAt }, log);
+            const { id } = await db.trx
+                .insertInto(GRANT_BURN_TABLE)
+                .values({
+                sol_tx_id: solTxId,
+                burned: p.burned,
+                tags: p.tags?.join(','),
+            })
+                .returning((eb) => ['id as id'])
+                .executeTakeFirstOrThrow();
+            const jobIdsStr = p.jobsIds.map(String);
+            const res = await db.trx
+                .updateTable(JOB_TABLE)
+                .where('id', 'in', jobIdsStr)
+                .set('grant_burn_id', id)
+                .executeTakeFirstOrThrow();
+            log.debug(`set grant_burn_id on ${res.numUpdatedRows} jobs`);
+            for (const [userId, grantSpendDelta] of Object.entries(p.userIdToGrantSpendDelta)) {
+                await db.trx
+                    .insertInto(USER_GRANT_SPEND_TABLE)
+                    .values({
+                    user_id: userId,
+                    grant_burn_id: id,
+                    render_spent_delta: -grantSpendDelta,
+                })
+                    .executeTakeFirstOrThrow();
+            }
+            return;
+        },
+        async insertGrantSpend(db, p, log = consoleLogger) {
+            const existing = await getCurrentUserGrantSpend(db.trx, { userId: p.userId }, log);
+            const diff = {
+                render_spent: (existing?.renderSpent ?? BigInt(0)) + p.renderSpentDelta,
+                description: p.description ? p.description : existing?.description,
+                perpetual: p.perpetual ? p.perpetual : existing?.perpetual ?? false,
+                updated_at: new Date(),
+            };
+            log.debug(`insertGrantSpend currUserGrantSpend: ${JSON.stringify(existing)} delta: ${JSON.stringify(p)}`);
+            const res = await db.trx
+                .insertInto(CURRENT_USER_GRANT_SPEND_TABLE)
+                .values({
+                user_id: p.userId,
+                render_spent: p.renderSpentDelta,
+                description: p.description,
+                perpetual: p.perpetual ?? false,
+            })
+                .onConflict((oc) => oc.column('user_id').doUpdateSet(diff))
+                .returning((eb) => [
+                'user_id as user_id',
+                'render_spent as render_spent',
+                'description as description',
+                'perpetual as perpetual',
+                'updated_at as updated_at',
+            ])
+                .executeTakeFirstOrThrow();
+            if (res) {
+                log.debug(`inserted current_user_grant_spend row ${JSON.stringify(res)}`);
+            }
+            if (p.renderSpentDelta > BigInt(0)) {
+                const v = {
+                    user_id: p.userId,
+                    render_spent_delta: p.renderSpentDelta,
+                    grant_burn_id: p.grantBurnId,
+                };
+                const res = await db.trx
+                    .insertInto(USER_GRANT_SPEND_TABLE)
+                    .values(v)
+                    .executeTakeFirstOrThrow();
+                log.debug(`inserted ${res.numInsertedOrUpdatedRows} user_grant_spend rows ${JSON.stringify(v)}`);
+            }
+        },
+        async markJobsBurnt(trx, p, log = consoleLogger) {
+            if (!p.buyBurn && !p.grantBurn) {
+                throw new Error('no buyBurn or grantBurn');
+            }
+            const solTxId = await getOrInsertTx(trx, { sig: p.solTx.sig, executedAt: p.solTx.executedAt }, log);
+            let buyBurnId;
+            let grantBurnId;
+            if (p.buyBurn) {
+                const { burned, usdcSpent, eurToUsdc, renderToUsdc, quoteAmt, tags, burnAdjustmentId, toBurn, } = p.buyBurn;
+                let pricedAt = p.buyBurn.pricedAt;
+                if (!pricedAt) {
+                    const jobs = await fetchJobs1(trx, { ids: p.jobs.map((j) => String(j.id)) }, log);
+                    pricedAt = batchFinishedAtMedian(jobs.map((j) => ({
+                        finishedAt: j.completedAt.toISOString(),
+                        jobId: j.id,
+                        rndrUsed: Number(j.rndrUsed.toString()),
+                    })));
+                }
+                const { id } = await trx
+                    .insertInto(BURN_TABLE)
+                    .values({
+                    sol_tx_id: solTxId,
+                    priced_at: pricedAt,
+                    eur_to_usdc: eurToUsdc,
+                    render_to_usdc: renderToUsdc,
+                    usdc_spent: usdcSpent,
+                    quote_amt: quoteAmt,
+                    burned: burned,
+                    tags: tags.join(','),
+                    burn_adjustment_id: burnAdjustmentId,
+                    to_burn: toBurn,
+                })
+                    //.onConflict((oc) => oc.column('sol_tx').doNothing())
+                    .returning((eb) => ['id as id'])
+                    .executeTakeFirstOrThrow();
+                buyBurnId = Number(id);
+            }
+            if (p.grantBurn) {
+                const { burned, tags } = p.grantBurn;
+                const { id } = await trx
+                    .insertInto(GRANT_BURN_TABLE)
+                    .values({
+                    sol_tx_id: solTxId,
+                    burned: burned,
+                    tags: tags?.join(','),
+                })
+                    .returning((eb) => ['id as id'])
+                    .executeTakeFirstOrThrow();
+                grantBurnId = Number(id);
+            }
+            for (const job of p.jobs) {
+                const res = await trx
+                    .updateTable(JOB_TABLE)
+                    .where('id', '=', String(job.id))
+                    .set('burn_id', job.buyRenderAmt != undefined ? buyBurnId : null)
+                    .set('grant_burn_id', job.grantRenderAmt != undefined ? grantBurnId : null)
+                    .set('buy_render_amt', job.buyRenderAmt ?? 0)
+                    .set('grant_render_amt', job.grantRenderAmt ?? 0)
+                    .executeTakeFirstOrThrow();
+                log.debug(`set grant_burn_id ${grantBurnId} burn_id ${buyBurnId} buy_render_amt ${job.buyRenderAmt} grant_render_amt ${job.grantRenderAmt} on ${res.numUpdatedRows} jobs id ${job.id}`);
+            }
+            return { grantBurnId, buyBurnId };
+        },
+        async markJobsBurned(trx, p, log = consoleLogger) {
+            let { markedAt, solTx } = p;
+            let res = await trx.trx
+                .updateTable(BURN_TABLE)
+                .set({ marked_burned_at: markedAt })
+                .from(SOL_TX_TABLE)
+                .whereRef('burn.sol_tx_id', '=', 'sol_tx.id')
+                .where('sol_tx.sig', '=', solTx)
+                .executeTakeFirst();
+            if (res) {
+                log.debug(`buy burn set ${res.numUpdatedRows} ${solTx} -> marked_burned_at ${markedAt.toISOString()}`);
+            }
+            let res1 = await trx.trx
+                .updateTable(GRANT_BURN_TABLE)
+                .set({ marked_burned_at: markedAt })
+                .from(SOL_TX_TABLE)
+                .whereRef('grant_burn.sol_tx_id', '=', 'sol_tx.id')
+                .where('sol_tx.sig', '=', solTx)
+                .executeTakeFirst();
+            if (res1) {
+                log.debug(`grant burn set ${res1.numUpdatedRows} ${solTx} -> marked_burned_at ${markedAt.toISOString()}`);
+            }
+        },
+        async consumeAndLockBurnJobs(limit, lowerRndrThreshold, upperRndrThreshold, log = consoleLogger) {
+            const trx = await begin(db, log);
+            const q = trx.trx
+                .selectFrom(trx.trx
+                .selectFrom(JOB_TABLE)
+                .select(({ fn, val, ref }) => [
+                'id',
+                fn
+                    .sum('render_amt')
+                    .over((ob) => ob.orderBy(`completed_at`, `asc`))
+                    .as('total'),
+            ])
+                .where('burn_id', 'is', null)
+                .where('grant_burn_id', 'is', null)
+                .as('t'))
+                .select('id')
+                .where('total', '>=', lowerRndrThreshold)
+                .where('total', '<=', upperRndrThreshold);
+            log.debug(`outstanding jobs q: ${q.compile().sql} ${JSON.stringify({
+                limit,
+                lowerRndrThreshold,
+                upperRndrThreshold,
+            })}`);
+            const idRs = await q.execute();
+            const ids = idRs.map((x) => x.id);
+            log.debug(`${ids.length} candidate jobs for burn. locking up to ${limit} jobs`);
+            if (ids.length == 0) {
+                return { trx, jobs: [] };
+            }
+            const rows = await trx.trx
+                .selectFrom(JOB_TABLE)
+                .selectAll()
+                .where('id', 'in', ids)
+                .limit(limit)
+                .forUpdate()
+                .skipLocked()
+                .execute();
+            log.debug(`locked ${rows.length} jobs`);
+            const jobs = [];
+            for (const r of rows) {
+                jobs.push({
+                    id: Number(r.id),
+                    completedAt: r.completed_at,
+                    userId: r.user_id,
+                    rndrUsed: BigInt(r.render_amt),
+                });
+            }
+            return { trx, jobs };
+        },
+        async paymentMetrics(log) {
+            // Get the latest epochs for each channel
+            const latestEpochs = await db
+                .selectFrom(EPOCH_TABLE)
+                .select(['id', 'ui', 'channel', 'start_time', 'end_time'])
+                .where('channel', 'in', [
+                'availability',
+                'node_operator',
+                'render_compute_network',
+            ])
+                .distinctOn('channel')
+                .where('saved_at', 'is not', null)
+                .orderBy('channel')
+                .orderBy('ui', 'desc')
+                .execute();
+            // Calculate distributed rewards for each channel
+            let availabilityRewards = 0;
+            let nodeOperatorRewards = 0;
+            let renderComputeNetworkRewards = 0;
+            let latestEpochId = 0;
+            for (const epoch of latestEpochs) {
+                if (!epoch.end_time) {
+                    log?.info(`Skipping epoch ${epoch.ui} for channel ${epoch.channel} - no end_time`);
+                    continue;
+                }
+                // Get total distributed rewards for this channel after epoch ended
+                const transfersResult = await db
+                    .selectFrom(SOL_TRANSFER_TABLE)
+                    .innerJoin('sol_tx', 'sol_tx.id', `${SOL_TRANSFER_TABLE}.sol_tx_id`)
+                    .select([(eb) => eb.fn.sum('amount_payed').as('total_distributed')])
+                    .where(`${SOL_TRANSFER_TABLE}.channel`, '=', epoch.channel)
+                    .where('sol_tx.executed_at', '>', epoch.end_time)
+                    .executeTakeFirst();
+                const totalDistributed = Number(transfersResult?.total_distributed || 0);
+                switch (epoch.channel) {
+                    case 'availability':
+                        availabilityRewards = totalDistributed;
+                        break;
+                    case 'node_operator':
+                        nodeOperatorRewards = totalDistributed;
+                        latestEpochId = Number(epoch.ui);
+                        break;
+                    case 'render_compute_network':
+                        renderComputeNetworkRewards = totalDistributed;
+                        break;
+                }
+                log?.info(`Channel ${epoch.channel}: ${totalDistributed} distributed after epoch ${epoch.ui}`);
+            }
+            return {
+                latestEpochId,
+                availabilityRewards,
+                nodeOperatorRewards,
+                renderComputeNetworkRewards,
+            };
+        },
+        async incrBuyBurnMetrics(log = consoleLogger) {
+            const res = await db
+                .selectFrom(JOB_TABLE)
+                .select('inserted_at')
+                .orderBy('completed_at asc')
+                .where('burn_id', 'is', null)
+                .execute();
+            if (res.length == 0) {
+                return { outstandingJobs: 0 };
+            }
+            return {
+                outstandingJobs: res.length,
+                oldestJobInsertedAt: res[0].inserted_at ?? undefined,
+            };
+        },
+        async fetchBurns(db, f, log = consoleLogger) {
+            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.pricedAtBefore) {
+                q = q.where('burn.priced_at', '<=', f.pricedAtBefore);
+            }
+            if (f.pricedAtAfter) {
+                q = q.where('burn.priced_at', '>=', f.pricedAtAfter);
+            }
+            if (f.orderBy == 'pricedAt') {
+                q = q.orderBy(['burn.priced_at']);
+            }
+            else if (f.orderBy == 'executedAt') {
+                q = q.orderBy(['sol_tx.executed_at']);
+            }
+            log.info(`fetchBurns q ${q.compile().sql} ${JSON.stringify(f)}`);
+            const burns = [];
+            const burnIdToIdx = {};
+            const comp = q.compile();
+            const { rows } = await timedQuery(pgPool, comp.sql, comp.parameters, 'fetchBurns', log);
+            log.info(`fetchBurns len ${rows.length}`);
+            for (const r of rows) {
+                burns.push({
+                    jobs: [],
+                    id: Number(r.id),
+                    renderToUsdc: r.render_to_usdc,
+                    solTx: r.sig,
+                    executedAt: r.executed_at,
+                    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,
+                    markedBurnedAt: r.marked_burned_at,
+                    tags: r.tags ? r.tags.split(',') : [],
+                });
+                burnIdToIdx[r.id] = burns.length - 1;
+            }
+            if (f.inclJobs) {
+                const jobRows = await db.trx
+                    .selectFrom('job')
+                    .selectAll('job')
+                    .where('burn_id', 'in', rows.map((r) => r.id))
+                    .execute();
+                log.info(`fetchBurns jobRows len ${jobRows.length}`);
+                for (const r of jobRows) {
+                    burns[burnIdToIdx[r.burn_id]].jobs.push({
+                        id: Number(r.id),
+                        completedAt: r.completed_at,
+                        rndrUsed: BigInt(r.render_amt),
+                        obhUsed: r.obh_used ? Number(r.obh_used) : undefined,
+                    });
+                }
+            }
+            return burns;
+        },
+        async createBridgeTransfers(db, bts, log = consoleLogger) {
+            return createBridgeTransfers(db.trx, bts, log);
+        },
+        async getBridgeTransfers({ solKey, page, }, log = consoleLogger) {
+            let q = db
+                .selectFrom(BRIDGE_TRANSFER_TABLE)
+                .innerJoin(EPOCH_TABLE, 'epoch.id', 'bridge_transfer.epoch_id')
+                .innerJoin(ENTITY_TABLE, 'entity.id', 'bridge_transfer.entity_id')
+                .select([
+                'entity.sol_key',
+                'bridge_transfer.sequence',
+                'bridge_transfer.created_at',
+                'bridge_transfer.amount',
+                'bridge_transfer.upgrade_bracket',
+                'bridge_transfer.prior_supply',
+                'bridge_transfer.points',
+                'epoch.ui',
+            ]);
+            let limit = 10000;
+            if (page && page.limit) {
+                limit = page.limit;
+            }
+            q = q.limit(page.limit).orderBy(`${BRIDGE_TRANSFER_TABLE}.id`);
+            let offset = 0;
+            if (page && page.cursor) {
+                offset = Number(atob(page.cursor));
+                q = q.offset(offset);
+            }
+            if (solKey) {
+                q = q.where('entity.sol_key', '=', solKey);
+            }
+            const c = q.compile();
+            log.debug(`fetch bridge transfers ${c.sql} params ${c.parameters}`);
+            const res = await q.execute();
+            log.info(`bridge transfers ${res.length}`);
+            return {
+                bts: res.map((row) => {
+                    return {
+                        solKey: row.sol_key,
+                        seq: BigInt(row.sequence),
+                        createdAt: row.created_at,
+                        amount: BigInt(row.amount),
+                        upgradeBracket: row.upgrade_bracket
+                            ? Number(row.upgrade_bracket)
+                            : undefined,
+                        priorSupply: BigInt(row.prior_supply),
+                        points: row.points ? BigInt(row.points) : undefined,
+                        epochId: Number(row.ui),
+                    };
+                }),
+                cursor: res.length == limit ? btoa(`${res.length + offset}`) : undefined,
+            };
+        },
+        async getLiabilitySolKeys(f) {
+            let q = db
+                .selectFrom(LIABILITY_TABLE)
+                .innerJoin(ENTITY_TABLE, `${LIABILITY_TABLE}.entity_id`, 'entity.id')
+                .select(({ fn }) => [
+                sql `distinct
+              (entity.sol_key)`.as('sol_key'),
+            ])
+                .where(`${LIABILITY_TABLE}.channel`, '=', f.channel);
+            if (f.epoch) {
+                q = q.where('liability.epoch_id', '=', db
+                    .selectFrom('epoch')
+                    .select('id')
+                    .where('channel', '=', f.channel)
+                    .where('ui', '=', String(f.epoch)));
+            }
+            const ks = await q.execute();
+            const solKeys = {};
+            for (const k of ks) {
+                solKeys[k.sol_key] = {};
+            }
+            return solKeys;
+        },
+        async getTotalBurned(db) {
+            const total = await db.trx
+                .selectFrom('burn')
+                .select(({ fn }) => fn.sum('burned').as('total_burned'))
+                .execute();
+            return BigInt(total[0]?.total_burned ?? 0);
+        },
+        async insertBurn(p, log = consoleLogger) {
+            await db.transaction().execute(async (trx) => {
+                const solTxId = await getOrInsertTx(trx, { sig: p.solTx, executedAt: p.executedAt }, log);
+                const { id } = await trx
+                    .insertInto(BURN_TABLE)
+                    .values({
+                    sol_tx_id: solTxId,
+                    priced_at: p.pricedAt,
+                    usdc_spent: p.usdcSpent,
+                    quote_amt: p.quoteAmt,
+                    burned: p.burned,
+                    marked_burned_at: p.markedBurnedAt,
+                })
+                    //.onConflict((oc) => oc.column('sol_tx').doNothing())
+                    .returning((eb) => ['id as id'])
+                    .executeTakeFirstOrThrow();
+                let num = BigInt(0);
+                for (const { rndrUsed, completedAt, id: jobId, insertedAt, userId, } of p.jobs) {
+                    const res = await trx
+                        .insertInto(JOB_TABLE)
+                        .values({
+                        id: jobId,
+                        render_amt: rndrUsed,
+                        burn_id: id,
+                        completed_at: completedAt,
+                        inserted_at: insertedAt ?? new Date(),
+                        user_id: userId,
+                    })
+                        .onConflict((oc) => oc.column('id').doNothing())
+                        .executeTakeFirstOrThrow();
+                    num += res.numInsertedOrUpdatedRows ?? BigInt(0);
+                }
+                log.debug(`burn id ${id} inserted ${num} of ${p.jobs.length} burn jobs`);
+            });
+        },
+        async fetchJobs(db, f, log = consoleLogger) {
+            return await fetchJobs1(db.trx, f, log);
+        },
+        async fetchLiabilityEpochs(db, log = consoleLogger) {
+            const q = db.trx
+                .selectFrom(LIABILITY_TABLE)
+                .select(({ fn }) => [
+                `${LIABILITY_TABLE}.channel`,
+                fn.sum(`${LIABILITY_TABLE}.amount_due`).as('amount_due'),
+            ])
+                .innerJoin(EPOCH_TABLE, `${EPOCH_TABLE}.id`, `${LIABILITY_TABLE}.epoch_id`)
+                .select(['ui', 'start_time', 'end_time'])
+                .groupBy([
+                'liability.channel',
+                'epoch.ui',
+                'epoch.start_time',
+                'epoch.end_time',
+            ])
+                .orderBy(['epoch.start_time desc']);
+            // Fetch node_operator SOL key metadata separately
+            const nodeOpMetadataQuery = db.trx
+                .selectFrom(LIABILITY_TABLE)
+                .select([`${LIABILITY_TABLE}.obh_used`])
+                .innerJoin(EPOCH_TABLE, `${EPOCH_TABLE}.id`, `${LIABILITY_TABLE}.epoch_id`)
+                .select([`${EPOCH_TABLE}.ui as epoch_ui`])
+                .innerJoin('entity', 'entity.id', `${LIABILITY_TABLE}.entity_id`)
+                .select(['entity.sol_key'])
+                .where(`${LIABILITY_TABLE}.channel`, '=', 'node_operator')
+                .where('entity.sol_key', 'is not', null)
+                .where(`${LIABILITY_TABLE}.obh_used`, 'is not', null);
+            log.debug(`fetchLiabilityEpochs ${q.compile().sql}`);
+            log.debug(`nodeOpMetadata ${nodeOpMetadataQuery.compile().sql}`);
+            const [rs, nodeOpMetadata] = await Promise.all([
+                q.execute(),
+                nodeOpMetadataQuery.execute(),
+            ]);
+            // Group node operator metadata by epoch
+            const metadataByEpoch = {};
+            nodeOpMetadata.forEach((row) => {
+                const epochId = Number(row.epoch_ui);
+                if (!metadataByEpoch[epochId]) {
+                    metadataByEpoch[epochId] = {};
+                }
+                if (row.sol_key && row.obh_used !== null) {
+                    metadataByEpoch[epochId][row.sol_key] = {
+                        obhUsed: Number(row.obh_used),
+                    };
+                }
+            });
+            return rs.map((r) => ({
+                epochId: Number(r.ui),
+                channel: r.channel,
+                start: r.start_time,
+                end: r.end_time,
+                amountDue: Number(r.amount_due),
+                metadataBySolKey: r.channel === 'node_operator'
+                    ? metadataByEpoch[Number(r.ui)] || {}
+                    : {},
+            }));
+        },
+        async getBurnAdjustments(trx, ps, log = consoleLogger) {
+            if (ps.toFill) {
+                const q = trx
+                    .selectFrom(BURN_ADJUSTMENT_TABLE)
+                    .selectAll(BURN_ADJUSTMENT_TABLE)
+                    .innerJoin(JOB_TABLE, `${JOB_TABLE}.id`, `${BURN_ADJUSTMENT_TABLE}.job_id`)
+                    .select([`${JOB_TABLE}.completed_at`, `${JOB_TABLE}.render_amt`])
+                    .leftJoin(BURN_TABLE, `${BURN_TABLE}.burn_adjustment_id`, `${BURN_ADJUSTMENT_TABLE}.id`)
+                    .select(({ fn, lit }) => [
+                    fn
+                        .sum(fn.coalesce(`${BURN_TABLE}.to_burn`, lit(0)))
+                        .as('tot_to_burn'),
+                    fn
+                        .sum(fn.coalesce(`${BURN_TABLE}.burned`, lit(0)))
+                        .as('tot_burned'),
+                ])
+                    .groupBy([
+                    `${BURN_ADJUSTMENT_TABLE}.id`,
+                    `${JOB_TABLE}.completed_at`,
+                    `${JOB_TABLE}.render_amt`,
+                ])
+                    .havingRef(sql `SUM(COALESCE("burn"."to_burn", 0)) - SUM(COALESCE("burn"."burned", 0))`, '<', `${BURN_ADJUSTMENT_TABLE}.down_adj_to_burn`);
+                log.info(`getBurnAdjustments ${q.compile().sql}`);
+                const res = await q.execute();
+                return res.map((r) => ({
+                    id: Number(r.id),
+                    createdAt: r.created_at,
+                    jobId: Number(r.job_id),
+                    downAdjRndrUsed: Number(r.down_adj_rndr_used),
+                    downAdjToBurn: Number(r.down_adj_to_burn),
+                    adjusted: Number(r.tot_to_burn) - Number(r.tot_burned),
+                    job: {
+                        id: Number(r.job_id),
+                        completedAt: r.completed_at,
+                        rndrUsed: BigInt(r.render_amt),
+                    },
+                }));
+            }
+            return [];
+        },
+        async insertPolygonUpgrade(db, p, log = consoleLogger) {
+            const solTxId = await getOrInsertTx(db.trx, {
+                sig: p.solTx.sig,
+                executedAt: p.solTx.executedAt,
+            });
+            await db.trx
+                .insertInto(POLYGON_UPGRADE_TABLE)
+                .values({
+                eth_addr: p.ethAddr,
+                sol_addr: p.solAddr,
+                amount: p.amount,
+                sol_tx_id: solTxId,
+            })
+                .execute();
+            log.info(`insertPolygonUpgrade ${JSON.stringify(p)}`);
+            return;
+        },
+        async fetchPolygonUpgrades(db, f, log = consoleLogger) {
+            let query = db.trx
+                .selectFrom('polygon_upgrade')
+                .selectAll('polygon_upgrade')
+                .innerJoin('sol_tx', 'sol_tx.id', 'polygon_upgrade.sol_tx_id')
+                .select(['sol_tx.sig', 'sol_tx.executed_at'])
+                .orderBy('sol_tx.executed_at', 'desc');
+            if (f.executedAfter) {
+                query = query.where('sol_tx.executed_at', '>=', f.executedAfter);
+            }
+            if (f.executedBefore) {
+                query = query.where('sol_tx.executed_at', '<=', f.executedBefore);
+            }
+            const results = await query.execute();
+            log.info(`fetchPolygonUpgrades returned ${results.length} records`);
+            return results.map((row) => ({
+                ethAddr: row.eth_addr,
+                solAddr: row.sol_addr,
+                amount: BigInt(row.amount.toString()),
+                solTx: {
+                    sig: row.sig,
+                    executedAt: row.executed_at,
+                },
+            }));
+        },
+        async getCurrentUserGrantSpend(db, f, log = consoleLogger) {
+            return await getCurrentUserGrantSpend(db.trx, f, log);
+        },
+        async deleteAll(log = consoleLogger) {
+            if (config.database.includes('render')) {
+                throw new Error('cannot nuke from deployed database. call from tests only');
+            }
+            const tx = await begin(db, log);
+            try {
+                const res = await Promise.all([
+                    tx.trx
+                        .deleteFrom(SOL_TX_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                    tx.trx.deleteFrom(LIABILITY_TABLE).executeTakeFirstOrThrow(),
+                    tx.trx.deleteFrom(SOL_TRANSFER_TABLE).executeTakeFirstOrThrow(),
+                    tx.trx
+                        .deleteFrom(EPOCH_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                    tx.trx
+                        .deleteFrom(ENTITY_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                    tx.trx
+                        .deleteFrom(MANUAL_BURN_TABLE)
+                        .where('epoch_id', 'is not', null)
+                        .executeTakeFirst(),
+                    tx.trx
+                        .deleteFrom(JOB_ID_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                    tx.trx
+                        .deleteFrom(JOB_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                    tx.trx
+                        .deleteFrom(BURN_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                ]);
+                tx.commit();
+            }
+            catch (e) {
+                log.error(`caught ${e}`);
+                tx.rollback();
+            }
+        },
+    };
+};
+//# sourceMappingURL=v2Client.js.map