@render-foundation/utils 0.0.58 → 0.0.60

package/lib/cjs/client/pg/v2.js

@@ -0,0 +1,709 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Deferred_promise, _Deferred_resolve, _Deferred_reject;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deferred = exports.pgClient = exports.BURN_TABLE = exports.JOB_TABLE = exports.JOB_ID_TABLE = exports.SOL_TRANSFER_INFO_TABLE = exports.SOL_TRANSFER_TABLE = exports.ENTITY_TABLE = exports.MANUAL_BURN_TABLE = exports.EPOCH_TABLE = exports.SOL_TX_TABLE = void 0;
+const pg_1 = require("pg");
+const kysely_1 = require("kysely");
+const logger_1 = require("../../logger");
+const transferTypToChan = (t) => {
+    if (t == 'open_compute_rewards') {
+        return 'open_compute';
+    }
+    if (t == 'node_operator_rewards') {
+        return 'node_operator';
+    }
+    return 'upgrade';
+};
+const transferFromDB = (o) => {
+    return {
+        id: o.id,
+        solKey: o.sol_key,
+        solTx: o.sol_tx,
+        sqTx: o.sq_tx,
+        createdAt: o.created_at,
+        payedAt: o.payed_at,
+        amountDue: BigInt(o.amount_due),
+        amountPayed: o.amount_payed ? BigInt(o.amount_payed) : undefined,
+        operatorRewards: o.transfer_type == 'node_operator_rewards'
+            ? {
+                epochId: o.epoch_id,
+                startTime: o.start_time,
+                endTime: o.end_time,
+            }
+            : undefined,
+        computeClientRewards: o.transfer_type == 'open_compute_rewards'
+            ? {
+                epochId: o.epoch_id,
+                deviceId: o.device_id,
+            }
+            : undefined,
+        upgradeRewards: o.transfer_type == 'upgrade_rewards' && !!o.epoch_id
+            ? {
+                epochId: o.epoch_id,
+                epochStartTime: o.epoch_start_time,
+                points: BigInt(o.points),
+            }
+            : undefined,
+    };
+};
+exports.SOL_TX_TABLE = 'sol_tx';
+exports.EPOCH_TABLE = 'epoch';
+exports.MANUAL_BURN_TABLE = 'manual_burn';
+exports.ENTITY_TABLE = 'entity';
+exports.SOL_TRANSFER_TABLE = 'sol_transfer';
+exports.SOL_TRANSFER_INFO_TABLE = 'sol_transfer_info';
+exports.JOB_ID_TABLE = 'job_id';
+exports.JOB_TABLE = 'job';
+exports.BURN_TABLE = 'burn';
+const pgClient = (config) => {
+    var _a, _b;
+    const dialect = new kysely_1.PostgresDialect({
+        pool: new pg_1.Pool(Object.assign(Object.assign({}, config), { port: (_a = config.port) !== null && _a !== void 0 ? _a : 5432, max: (_b = config.max) !== null && _b !== void 0 ? _b : 10 })),
+    });
+    // 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_1.Kysely({
+        dialect,
+    });
+    const getOrInsertEntity = (db, p, log = logger_1.consoleLogger) => __awaiter(void 0, void 0, void 0, function* () {
+        const res = (yield db
+            .selectFrom(exports.ENTITY_TABLE)
+            .select('id')
+            .where('sol_key', '=', p.solKey)
+            .executeTakeFirst());
+        if (res) {
+            log.debug(`already found entity ${res.id}`);
+            return res.id;
+        }
+        const { id } = (yield db
+            .insertInto(exports.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 = (db, p, log = logger_1.consoleLogger) => __awaiter(void 0, void 0, void 0, function* () {
+        const res = yield db
+            .selectFrom(exports.SOL_TX_TABLE)
+            .select('id')
+            .where('sig', '=', p.sig)
+            .executeTakeFirst();
+        if (res) {
+            log.debug(`already found tx ${res.id}`);
+            return res.id;
+        }
+        const { id } = (yield db
+            .insertInto(exports.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 = (db, p, log = logger_1.consoleLogger) => __awaiter(void 0, void 0, void 0, function* () {
+        const res = yield db
+            .selectFrom(exports.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 } = (yield db
+            .insertInto(exports.EPOCH_TABLE)
+            .values({
+            ui: p.uiEpochId,
+            channel: p.channel,
+            start_time: p.startTime,
+            end_time: p.endTime,
+            total_rndr: p.totalRndr,
+        })
+            .onConflict((oc) => oc.columns(['ui', 'channel']).doNothing())
+            .returning((eb) => ['id as id'])
+            .executeTakeFirst());
+        log.debug(`inserted epoch ${id}`);
+        return id;
+    });
+    const createTransfers = (db, transfers, log = logger_1.consoleLogger, totalRndr = BigInt(0)) => __awaiter(void 0, void 0, void 0, function* () {
+        const epochIds = [];
+        for (const t of transfers) {
+            let solTxId;
+            if (t.solTx) {
+                solTxId = yield getOrInsertTx(db, {
+                    sig: t.solTx,
+                    executedAt: t.payedAt,
+                }, log);
+            }
+            const entityId = yield getOrInsertEntity(db, { solKey: t.solKey }, log);
+            const { id: transferId } = (yield db
+                .insertInto(exports.SOL_TRANSFER_TABLE)
+                .values({
+                sol_tx_id: solTxId,
+                entity_id: entityId,
+                channel: transferTypToChan((() => {
+                    if (t.operatorRewards) {
+                        return 'node_operator_rewards';
+                    }
+                    else if (t.upgradeRewards) {
+                        return 'upgrade_rewards';
+                    }
+                    else if (t.computeClientRewards) {
+                        return 'open_compute_rewards';
+                    }
+                    throw new Error('wtf');
+                })()),
+                created_at: t.createdAt,
+                amount_due: BigInt(t.amountDue),
+                amount_payed: t.amountPayed ? BigInt(t.amountPayed) : 0,
+            })
+                .returning((eb) => ['id as id'])
+                .executeTakeFirst());
+            log.info(`inserted transfer ${JSON.stringify(t, (key, value) => typeof value === 'bigint' ? value.toString() : value)}`);
+            let epochId;
+            let deviceId;
+            let points;
+            let startTime;
+            let endTime;
+            let channel;
+            if (t.operatorRewards) {
+                log.info(`inserting operator rewards ${transferId}`);
+                epochId = t.operatorRewards.epochId;
+                startTime = t.operatorRewards.startTime;
+                endTime = t.operatorRewards.endTime;
+                channel = 'node_operator';
+            }
+            else if (t.computeClientRewards) {
+                log.info(`inserting compute client rewards ${transferId}`);
+                epochId = t.computeClientRewards.epochId;
+                deviceId = t.computeClientRewards.deviceId;
+                channel = 'open_compute';
+            }
+            else if (t.upgradeRewards) {
+                log.info(`inserting upgrade rewards ${transferId}`);
+                channel = 'upgrade';
+                epochId = t.upgradeRewards.epochId;
+                points = t.upgradeRewards.points;
+            }
+            const epochIdDb = yield getOrInsertEpoch(db, {
+                channel,
+                startTime,
+                endTime,
+                uiEpochId: epochId,
+                totalRndr,
+            }, log);
+            yield db
+                .insertInto(exports.SOL_TRANSFER_INFO_TABLE)
+                .values({
+                transfer_id: transferId,
+                device_id: deviceId,
+                points,
+                epoch_id: BigInt(epochIdDb),
+            })
+                .executeTakeFirst();
+            epochIds.push({ epochDbId: epochIdDb });
+        }
+        return epochIds;
+    });
+    return {
+        db,
+        saveNodeOperatorEpoch(epochId, transfers, jobIds, totalRndr, log = logger_1.consoleLogger) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield db
+                    .transaction()
+                    .setIsolationLevel('repeatable read')
+                    .execute((trx) => __awaiter(this, void 0, void 0, function* () {
+                    const epochDbIds = yield createTransfers(trx, transfers, log, totalRndr);
+                    log.info(`inserted transfers`);
+                    for (const id of jobIds) {
+                        yield trx
+                            .insertInto(exports.JOB_ID_TABLE)
+                            .values({
+                            id: BigInt(id),
+                            epoch_id: epochDbIds[0].epochDbId,
+                        })
+                            .executeTakeFirstOrThrow();
+                    }
+                    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;
+            });
+        },
+        getLatestNodeOperatorEpoch(log = logger_1.consoleLogger) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const now = new Date(Date.now());
+                try {
+                    const res = yield db
+                        .selectFrom(exports.EPOCH_TABLE)
+                        .selectAll()
+                        .where('channel', '=', 'node_operator')
+                        .where('end_time', '<=', now)
+                        .where('saved_at', 'is', null)
+                        .orderBy('end_time asc')
+                        .limit(1)
+                        .executeTakeFirstOrThrow();
+                    return {
+                        epochId: BigInt(res.ui),
+                        startedAt: res.start_time,
+                        endedAt: res.end_time,
+                        savedAt: (_a = res.saved_at) !== null && _a !== void 0 ? _a : undefined,
+                    };
+                }
+                catch (e) {
+                    if (e instanceof kysely_1.NoResultError) {
+                        log.info(`no node operator epoch found`);
+                        return undefined;
+                    }
+                    throw e;
+                }
+            });
+        },
+        getOutstanding(f, log = logger_1.consoleLogger) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const { typ, nullKey, due } = f;
+                //select sol_key, sum(amount_due)-sum(amount_payed) from transfer group by sol_key;
+                let q = db
+                    .selectFrom(exports.SOL_TRANSFER_TABLE)
+                    .innerJoin(exports.ENTITY_TABLE, 'sol_transfer.entity_id', 'entity.id')
+                    .select(({ fn, val, ref }) => [
+                    'entity.sol_key',
+                    (0, kysely_1.sql) `${fn.sum('sol_transfer.amount_due')} -
+          ${fn.sum('sol_transfer.amount_payed')}`.as('due'),
+                ])
+                    .where('sol_transfer.channel', '=', transferTypToChan(typ))
+                    .groupBy(['entity.sol_key']);
+                if (!nullKey) {
+                    q = q.where('entity.sol_key', 'is not', null);
+                }
+                if (due) {
+                    q = q.having(({ fn, ref }) => (0, kysely_1.sql) `${fn.sum('sol_transfer.amount_due')} -
+            ${fn.sum('sol_transfer.amount_payed')}
+            >
+            0`);
+                }
+                const res = yield q.execute();
+                log.info(`outstanding query ${q.compile().sql} params ${JSON.stringify(f)} ${res.length} rows`);
+                const out = {};
+                for (const r of res) {
+                    out[(_a = r.sol_key) !== null && _a !== void 0 ? _a : ''] = BigInt(r.due);
+                }
+                return out;
+            });
+        },
+        fetchTransfers(f, log = logger_1.consoleLogger) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let base = db
+                    .selectFrom(exports.SOL_TRANSFER_TABLE)
+                    .selectAll(exports.SOL_TRANSFER_TABLE)
+                    .innerJoin(exports.SOL_TRANSFER_INFO_TABLE, 'sol_transfer_info.transfer_id', 'sol_transfer.id')
+                    .select(['sol_transfer_info.device_id', 'sol_transfer_info.points'])
+                    .innerJoin(exports.ENTITY_TABLE, 'entity.id', 'sol_transfer.entity_id')
+                    .select(['entity.sol_key'])
+                    .where('sol_transfer.channel', '=', transferTypToChan(f.typ));
+                if (f.solKey) {
+                    base = base.where('entity.sol_key', '=', f.solKey);
+                }
+                if (f.payed != undefined) {
+                    base = base
+                        .leftJoin(exports.SOL_TX_TABLE, 'sol_tx.id', 'sol_transfer.sol_tx_id')
+                        .select(['sol_tx.sig', 'sol_tx.executed_at'])
+                        .where('sol_transfer.sol_tx_id', f.payed ? 'is not' : 'is', null);
+                }
+                if (f.createdBefore != undefined) {
+                    base = base.where('sol_transfer.created_at', '<=', f.createdBefore);
+                }
+                if (f.epochId) {
+                    base = base
+                        .innerJoin(exports.EPOCH_TABLE, 'epoch.id', 'sol_transfer_info.epoch_id')
+                        .select(['epoch.ui'])
+                        .where('epoch.ui', '=', String(f.epochId));
+                }
+                if (f.sort) {
+                    base = base.orderBy('entity.sol_key asc');
+                }
+                const res = yield base.execute();
+                log.info(`fetched ${base.compile().sql} params ${JSON.stringify(f)} ${res.length} transfers`);
+                return res.map((r) => transferFromDB(r));
+            });
+        },
+        payoutTransfers(idToAmt, payedAt, solTx, log = logger_1.consoleLogger) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield db
+                    .transaction()
+                    .setIsolationLevel('repeatable read')
+                    .execute((tx) => __awaiter(this, void 0, void 0, function* () {
+                    const alreadyUpdatedIds = (yield tx
+                        .selectFrom(exports.SOL_TRANSFER_TABLE)
+                        .innerJoin(exports.SOL_TX_TABLE, 'sol_transfer.sol_tx_id', 'sol_tx.id')
+                        .select(['sol_transfer.id'])
+                        .where('sol_transfer.id', 'in', Object.keys(idToAmt))
+                        .where('sol_tx.sig', 'is not', null)
+                        .execute()).map(({ id }) => id);
+                    for (const [id, amt] of Object.entries(idToAmt)) {
+                        if (alreadyUpdatedIds.includes(id)) {
+                            log.info(`transfer ${id} already marked payed out. skipping`);
+                            continue;
+                        }
+                        const solTxId = yield getOrInsertTx(tx, { sig: solTx, executedAt: payedAt }, log);
+                        const res = yield tx
+                            .updateTable(exports.SOL_TRANSFER_TABLE)
+                            .set({
+                            sol_tx_id: solTxId,
+                            amount_payed: amt,
+                        })
+                            .where('id', '=', id.toString())
+                            .executeTakeFirstOrThrow();
+                        log.info(`marked ${res.numUpdatedRows} transfer payed out`);
+                    }
+                }));
+            });
+        },
+        payoutTransfer(id, payedAt, solTx, amtPayed, log = logger_1.consoleLogger) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield db
+                    .transaction()
+                    .setIsolationLevel('repeatable read')
+                    .execute((tx) => __awaiter(this, void 0, void 0, function* () {
+                    const solTxId = yield getOrInsertTx(tx, { sig: solTx, executedAt: payedAt }, log);
+                    const res = yield tx
+                        .updateTable(exports.SOL_TRANSFER_TABLE)
+                        .set({
+                        sol_tx_id: solTxId,
+                        amount_payed: amtPayed,
+                    })
+                        .where('id', '=', id.toString())
+                        .executeTakeFirst();
+                    log.info(`marked ${res.numUpdatedRows} transfer payed out`);
+                }));
+            });
+        },
+        createTransfers(transfers, log = logger_1.consoleLogger) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield db
+                    .transaction()
+                    .setIsolationLevel('repeatable read')
+                    .execute((trx) => __awaiter(this, void 0, void 0, function* () {
+                    yield createTransfers(trx, transfers, log);
+                }));
+            });
+        },
+        fetchInfoForEpoch(epochId, log = logger_1.consoleLogger) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const q = db
+                    .selectFrom(exports.JOB_ID_TABLE)
+                    .innerJoin(exports.EPOCH_TABLE, 'epoch.id', 'job_id.epoch_id')
+                    .leftJoin(exports.MANUAL_BURN_TABLE, 'manual_burn.epoch_id', 'epoch.id')
+                    .where('epoch.ui', '=', String(epochId))
+                    .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 = yield q.execute();
+                if (res.length == 0) {
+                    throw new Error(`epoch ${epochId} not found`);
+                }
+                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((_a = res[0].burned) !== null && _a !== void 0 ? _a : 0),
+                    burnTx: res[0].tx_sig,
+                };
+            });
+        },
+        updateComputeClientSolKey(deviceId, solKey, log = logger_1.consoleLogger) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const q = db
+                    .updateTable(`${exports.ENTITY_TABLE} as e`)
+                    .set({
+                    sol_key: solKey,
+                })
+                    .from(`${exports.SOL_TRANSFER_TABLE} as t`)
+                    .innerJoin(exports.SOL_TRANSFER_INFO_TABLE, 'sol_transfer_info.transfer_id', 't.id')
+                    //.whereRef('t.id', '=', 'o.transfer_id')
+                    .where('e.sol_key', 'is', null)
+                    .where('sol_transfer_info.device_id', '=', deviceId);
+                const sql = yield q.compile();
+                log.info(`sql ${sql.sql} params ${sql.parameters}`);
+                const res = yield q.executeTakeFirstOrThrow();
+                log.info(`updated ${res.numUpdatedRows} device-id sol_keys`);
+            });
+        },
+        markJobsBurnt(trx, p, log = logger_1.consoleLogger) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const solTxId = yield getOrInsertTx(trx, { sig: p.solTx, executedAt: p.executedAt }, log);
+                const { id } = yield trx
+                    .insertInto(exports.BURN_TABLE)
+                    .values({
+                    sol_tx_id: solTxId,
+                    priced_at: p.pricedAt,
+                    usdc_spent: p.usdcSpent,
+                    quote_amt: p.quoteAmt,
+                    burned: p.burned,
+                })
+                    //.onConflict((oc) => oc.column('sol_tx').doNothing())
+                    .returning((eb) => ['id as id'])
+                    .executeTakeFirstOrThrow();
+                const jobIdsStr = p.jobsIds.map(String);
+                const res = yield trx
+                    .updateTable(exports.JOB_TABLE)
+                    .where('id', 'in', jobIdsStr)
+                    .set('burn_id', id)
+                    .executeTakeFirstOrThrow();
+                log.debug(`set burn_id on ${res.numUpdatedRows} jobs`);
+                return;
+            });
+        },
+        produceBurnedJobs(jobs, log = logger_1.consoleLogger) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield db.transaction().execute((trx) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    let num = BigInt(0);
+                    for (const { amount, completedAt, jobId } of jobs) {
+                        const res = yield trx
+                            .insertInto(exports.JOB_TABLE)
+                            .values({
+                            id: jobId,
+                            render_amt: amount,
+                            completed_at: completedAt,
+                            inserted_at: new Date(Date.now()),
+                        })
+                            .onConflict((oc) => oc.column('id').doNothing())
+                            .executeTakeFirstOrThrow();
+                        num += (_a = res.numInsertedOrUpdatedRows) !== null && _a !== void 0 ? _a : BigInt(0);
+                    }
+                    log.debug(`inserted ${num} of ${jobs.length} burn jobs`);
+                }));
+            });
+        },
+        markJobsBurned(p, log = logger_1.consoleLogger) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { markedAt, solTx } = p;
+                let res = yield db
+                    .updateTable(exports.BURN_TABLE)
+                    .set({ marked_burned_at: markedAt })
+                    .from(exports.SOL_TX_TABLE)
+                    .whereRef('burn.sol_tx_id', '=', 'sol_tx.id')
+                    .where('sol_tx.sig', '=', solTx)
+                    .executeTakeFirstOrThrow();
+                log.debug(`set ${res.numUpdatedRows} ${solTx} -> marked_burned_at ${markedAt.toISOString()}`);
+            });
+        },
+        consumeAndLockBurnJobs(limit, lowerRndrThreshold, upperRndrThreshold, log = logger_1.consoleLogger) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const trx = yield begin(db);
+                const q = trx.trx
+                    .selectFrom(trx.trx
+                    .selectFrom(exports.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)
+                    .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 = yield 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 = yield trx.trx
+                    .selectFrom(exports.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,
+                        rndrUsed: BigInt(r.render_amt),
+                    });
+                }
+                return { trx, jobs };
+            });
+        },
+        incrBuyBurnMetrics(log = logger_1.consoleLogger) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const res = yield db
+                    .selectFrom(exports.JOB_TABLE)
+                    .select('completed_at')
+                    .orderBy('completed_at asc')
+                    .where('burn_id', 'is', null)
+                    .execute();
+                if (res.length == 0) {
+                    return { outstandingJobs: 0 };
+                }
+                return {
+                    outstandingJobs: res.length,
+                    oldestJobFinishedAt: (_a = res[0].completed_at) !== null && _a !== void 0 ? _a : undefined,
+                };
+            });
+        },
+        deleteAll() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (config.database.includes('render')) {
+                    throw new Error('cannot nuke from deployed database. call from tests only');
+                }
+                yield Promise.all([
+                    db
+                        .deleteFrom(exports.SOL_TX_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                    db
+                        .deleteFrom(exports.SOL_TRANSFER_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                    db
+                        .deleteFrom(exports.SOL_TRANSFER_INFO_TABLE)
+                        .where('transfer_id', 'is not', null)
+                        .executeTakeFirst(),
+                    db
+                        .deleteFrom(exports.EPOCH_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                    db
+                        .deleteFrom(exports.ENTITY_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                    db
+                        .deleteFrom(exports.MANUAL_BURN_TABLE)
+                        .where('epoch_id', 'is not', null)
+                        .executeTakeFirst(),
+                    db
+                        .deleteFrom(exports.JOB_ID_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                    db.deleteFrom(exports.JOB_TABLE).where('id', 'is not', null).executeTakeFirst(),
+                    db
+                        .deleteFrom(exports.BURN_TABLE)
+                        .where('id', 'is not', null)
+                        .executeTakeFirst(),
+                ]);
+            });
+        },
+    };
+};
+exports.pgClient = pgClient;
+function begin(db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const connection = new Deferred();
+        const result = new Deferred();
+        // Do NOT await this line.
+        db.transaction()
+            .setIsolationLevel('repeatable read')
+            .execute((trx) => {
+            connection.resolve(trx);
+            return result.promise;
+        })
+            .catch((err) => {
+            // Don't do anything here. Just swallow the exception.
+        });
+        const trx = yield connection.promise;
+        return {
+            trx,
+            commit() {
+                result.resolve(null);
+            },
+            rollback() {
+                result.reject(new Error('rollback'));
+            },
+        };
+    });
+}
+class Deferred {
+    constructor() {
+        _Deferred_promise.set(this, void 0);
+        _Deferred_resolve.set(this, void 0);
+        _Deferred_reject.set(this, void 0);
+        this.resolve = (value) => {
+            if (__classPrivateFieldGet(this, _Deferred_resolve, "f")) {
+                __classPrivateFieldGet(this, _Deferred_resolve, "f").call(this, value);
+            }
+        };
+        this.reject = (reason) => {
+            if (__classPrivateFieldGet(this, _Deferred_reject, "f")) {
+                __classPrivateFieldGet(this, _Deferred_reject, "f").call(this, reason);
+            }
+        };
+        __classPrivateFieldSet(this, _Deferred_promise, new Promise((resolve, reject) => {
+            __classPrivateFieldSet(this, _Deferred_reject, reject, "f");
+            __classPrivateFieldSet(this, _Deferred_resolve, resolve, "f");
+        }), "f");
+    }
+    get promise() {
+        return __classPrivateFieldGet(this, _Deferred_promise, "f");
+    }
+}
+exports.Deferred = Deferred;
+_Deferred_promise = new WeakMap(), _Deferred_resolve = new WeakMap(), _Deferred_reject = new WeakMap();
+//# sourceMappingURL=v2.js.map