@render-foundation/utils 0.0.187 → 0.0.188

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

@@ -1,1468 +0,0 @@
-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) {
-            log.info(`getting outstanding balances for ${f.channels ?? '(no channels specified)'} epoch: ${f.startEpochId.id ?? '(no epoch specified)'}`);
-            let epochUi;
-            let epochEndTime;
-            if (f.startEpochId.id) {
-                if (f.channels?.includes('node_operator') ||
-                    f.channels?.includes('availability') ||
-                    f.channels?.includes('render_compute_network')) {
-                    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 q = qb
-                        .orderBy('ui', 'desc')
-                        .limit(1);
-                    log.info(`getOutstanding->epoch ${qb.compile().sql} ps ${JSON.stringify(f)}`);
-                    const e = await q.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.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.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.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.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.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.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