@bopen-io/wallet-toolbox 2.6.2-brc153.5 → 2.14.6

package/out/src/storage/StorageKnex.js

@@ -11,12 +11,17 @@ const reviewStatus_1 = require("./methods/reviewStatus");
 const WERR_errors_1 = require("../sdk/WERR_errors");
 const utilityHelpers_1 = require("../utility/utilityHelpers");
 const managedChange_1 = require("./methods/managedChange");
+const preparedBeef_1 = require("./methods/preparedBeef");
 // Keep bulk statements below conservative SQLite/MySQL bind-parameter
 // ceilings. The surrounding transaction still makes a complete pack atomic.
 const ACTION_BATCH_BLOB_SQL_CHUNK = 500;
 const OUTPUT_INSERT_SQL_CHUNK = 500;
 class StorageKnex extends StorageProvider_1.StorageProvider {
     knex;
+    preparedBeefPolicy;
+    preparedBeefCoordinator;
+    preparedBeefReadSuspensions = new Set();
+    nextPreparedBeefReadSuspension = 0;
     querySpans = new Map();
     onQuery = (query) => {
         if (!this.telemetry.enabled || query.__knexQueryUid == null)
@@ -42,6 +47,9 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         if (options.knex == null)
             throw new WERR_errors_1.WERR_INVALID_PARAMETER('options.knex', 'valid');
         this.knex = options.knex;
+        parsePostgresInt8AsNumber(this.knex);
+        this.preparedBeefPolicy = (0, preparedBeef_1.validatePreparedBeefPolicy)(options.preparedBeef);
+        this.preparedBeefCoordinator = new preparedBeef_1.PreparedBeefCoordinator(this);
         if (this.telemetry.enabled) {
             this.knex.on('query', this.onQuery);
             this.knex.on('query-response', this.onQueryResponse);
@@ -67,10 +75,26 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         this.querySpans.delete(query.__knexQueryUid);
         span.end(error == null ? {} : { status: 'error', error });
     }
-    supportsActionBatchPersistence() { return true; }
-    requiresActionBatchCleanupBeforeCreateAction() { return false; }
-    async readSettings() {
-        return this.validateEntity((0, utilityHelpers_1.verifyOne)(await this.toDb()('settings')));
+    supportsActionBatchPersistence() {
+        return true;
+    }
+    supportsNoSendExpiryPersistence() {
+        return true;
+    }
+    requiresActionBatchCleanupBeforeCreateAction() {
+        return false;
+    }
+    async makeAvailable() {
+        const settings = await super.makeAvailable();
+        this.startPreparedBeefBackfill();
+        return settings;
+    }
+    setServices(services) {
+        super.setServices(services);
+        this.startPreparedBeefBackfill();
+    }
+    async readSettings(trx) {
+        return this.validateEntity((0, utilityHelpers_1.verifyOne)(await this.toDb(trx)('settings')));
     }
     async getProvenOrRawTx(txid, trx) {
         const k = this.toDb(trx);
@@ -87,7 +111,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
                 .select('rawTx', 'inputBEEF'));
             if (reqRawTx != null) {
                 r.rawTx = Array.from(reqRawTx.rawTx);
-                r.inputBEEF = Array.from(reqRawTx.inputBEEF);
+                r.inputBEEF = reqRawTx.inputBEEF == null ? undefined : Array.from(reqRawTx.inputBEEF);
             }
         }
         return r;
@@ -124,33 +148,235 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         }
         return results;
     }
-    dbTypeSubstring(source, fromOffset, forLength) {
-        if (this.dbtype === 'MySQL')
-            return `substring(${source} from ${fromOffset} for ${String(forLength)})`;
-        return `substr(${source}, ${fromOffset}, ${String(forLength)})`;
+    async findPreparedBeefs(userId, rootTxids, trx) {
+        const unique = [...new Set(rootTxids)];
+        if (unique.length === 0)
+            return [];
+        let query = this.toDb(trx)('prepared_beefs')
+            .where({ userId, state: 'ready', formatVersion: preparedBeef_1.PREPARED_BEEF_FORMAT_VERSION })
+            .whereIn('rootTxid', unique);
+        // Enforce the per-row byte limit in SQL so a corrupt metadata value cannot
+        // make Knex transfer an oversized blob before JavaScript validates it.
+        query = query.whereRaw('length(??) <= ?', ['beef', this.preparedBeefPolicy.maxArtifactBytes]);
+        const rows = await query;
+        return this.validateEntities(rows);
+    }
+    /**
+     * Metadata-only foreground preflight for fragmented actions. SQL computes
+     * the actual blob lengths; BEEF bytes are not transferred to the process.
+     */
+    async readPreparedBeefLookupByteLength(userId, rootTxids) {
+        const unique = [...new Set(rootTxids)];
+        if (unique.length === 0)
+            return 0;
+        const row = (await this.knex('prepared_beefs')
+            .where({ userId, state: 'ready', formatVersion: preparedBeef_1.PREPARED_BEEF_FORMAT_VERSION })
+            .whereIn('rootTxid', unique)
+            .first({ byteLength: this.knex.raw('coalesce(sum(length(??)), 0)', ['beef']) }));
+        return Number(row?.byteLength ?? 0);
+    }
+    async readPreparedBeefProofEpoch(trx) {
+        const row = await this.toDb(trx)('prepared_beef_metadata')
+            .where({ preparedBeefMetadataId: 1 })
+            .first('proofEpoch');
+        if (row == null || !Number.isSafeInteger(Number(row.proofEpoch))) {
+            throw new WERR_errors_1.WERR_INTERNAL('prepared BEEF proof epoch is unavailable');
+        }
+        return Number(row.proofEpoch);
+    }
+    /**
+     * Cheap worker preflight. It prevents a large tenant-controlled no-send BEEF
+     * from being loaded and parsed merely to discover that COOK will reject it.
+     */
+    async readPreparedBeefSourceByteLength(rootTxid) {
+        const byteLength = (...columns) => this.knex.raw(columns.map(() => 'coalesce(length(??), 0)').join(' + '), columns);
+        const proven = (await this.knex('proven_txs')
+            .where({ txid: rootTxid })
+            .first({ byteLength: byteLength('rawTx', 'merklePath') }));
+        if (proven != null)
+            return Number(proven.byteLength);
+        const request = (await this.knex('proven_tx_reqs')
+            .where({ txid: rootTxid })
+            .whereIn('status', ['unsent', 'unmined', 'unconfirmed', 'sending', 'nosend', 'completed'])
+            .first({ byteLength: byteLength('rawTx', 'inputBEEF') }));
+        return request == null ? undefined : Number(request.byteLength);
+    }
+    async upsertPreparedBeef(artifact, expectedProofEpoch) {
+        return await this.transaction(async (trx) => {
+            let epochQuery = this.toDb(trx)('prepared_beef_metadata').where({
+                preparedBeefMetadataId: 1
+            });
+            // Serialize a worker commit with proof invalidation across MySQL and
+            // Postgres server processes. SQLite serializes the subsequent write transaction.
+            if (this.dbtype === 'MySQL' || this.dbtype === 'Postgres')
+                epochQuery = epochQuery.forUpdate();
+            const metadata = await epochQuery.first('proofEpoch');
+            if (metadata == null || Number(metadata.proofEpoch) !== expectedProofEpoch)
+                return false;
+            const row = await this.validateEntityForInsert(artifact, trx);
+            if (row.preparedBeefId === 0)
+                delete row.preparedBeefId;
+            const update = {
+                beef: row.beef,
+                checksum: row.checksum,
+                formatVersion: row.formatVersion,
+                state: row.state,
+                txCount: row.txCount,
+                bumpCount: row.bumpCount,
+                byteLength: row.byteLength,
+                updated_at: row.updated_at
+            };
+            await this.toDb(trx)('prepared_beefs')
+                .insert(row)
+                .onConflict(['userId', 'rootTxid'])
+                .merge(update);
+            return true;
+        });
+    }
+    async findPreparedBeefBackfillRoots(limit, formatVersion) {
+        const rows = (await this.knex('outputs as o')
+            .join('transactions as t', function () {
+            this.on('t.transactionId', '=', 'o.transactionId').andOn('t.userId', '=', 'o.userId');
+        })
+            .leftJoin('prepared_beefs as pb', function () {
+            this.on('pb.userId', '=', 'o.userId')
+                .andOn('pb.rootTxid', '=', 'o.txid')
+                .andOnVal('pb.formatVersion', '=', formatVersion);
+        })
+            .where('o.spendable', true)
+            .whereNull('o.spentBy')
+            .where('o.change', true)
+            .where('o.providedBy', 'storage')
+            .where('o.purpose', 'change')
+            .where('o.type', 'P2PKH')
+            .whereNotNull('o.derivationPrefix')
+            .whereNotNull('o.derivationSuffix')
+            .whereNotNull('o.txid')
+            // Backfill only settled roots. Pending roots receive one organic
+            // processAction attempt and can be retried after a canonical read; a
+            // perpetual backfill loop must not poll an unconfirmed ancestry chain.
+            .where('t.status', 'completed')
+            .whereNotNull('t.provenTxId')
+            .whereNull('pb.preparedBeefId')
+            .select('o.userId', 'o.txid as rootTxid')
+            .groupBy('o.userId', 'o.txid')
+            // ?? quotes identifiers: Postgres lowercases unquoted names, so camelCase columns must be quoted.
+            .orderByRaw('MIN(??)', ['o.outputId'])
+            .limit(limit));
+        return rows;
+    }
+    async invalidatePreparedBeefs(trx) {
+        if (trx == null) {
+            return await this.transaction(async (transaction) => await this.invalidatePreparedBeefs(transaction));
+        }
+        const metadataUpdates = await this.toDb(trx)('prepared_beef_metadata')
+            .where({ preparedBeefMetadataId: 1 })
+            .increment('proofEpoch', 1);
+        if (metadataUpdates !== 1)
+            throw new WERR_errors_1.WERR_INTERNAL('prepared BEEF proof epoch update failed');
+        return await this.toDb(trx)('prepared_beefs')
+            .where({ state: 'ready' })
+            .update(this.validatePartialForUpdate({
+            state: 'stale',
+            // A later backfill pass must not mistake an invalidated current-format
+            // row for a completed artifact.
+            formatVersion: 0
+        }));
+    }
+    async lookupPreparedBeefs(userId, rootTxids, parent) {
+        return await (0, preparedBeef_1.lookupPreparedBeefs)(this, userId, rootTxids, parent);
+    }
+    preparedBeefReadsEnabled() {
+        return this.preparedBeefPolicy.readEnabled && this.preparedBeefReadSuspensions.size === 0;
+    }
+    /**
+     * Synchronously close the local prepared-read gate before asynchronous reorg
+     * invalidation waits for manager/database locks. The returned release is
+     * idempotent; callers release it only after invalidation commits.
+     */
+    suspendPreparedBeefReads() {
+        const suspension = ++this.nextPreparedBeefReadSuspension;
+        this.preparedBeefReadSuspensions.add(suspension);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            // This committed invalidation covers every reorg observed before it,
+            // including an earlier failed attempt. Do not clear a newer suspension
+            // whose database invalidation may still be pending.
+            for (const pending of this.preparedBeefReadSuspensions) {
+                if (pending <= suspension)
+                    this.preparedBeefReadSuspensions.delete(pending);
+            }
+        };
+    }
+    preparedBeefWritesEnabled() {
+        return this.preparedBeefPolicy.writeEnabled;
+    }
+    /** Queue best-effort preparation after foreground action work has completed. */
+    enqueuePreparedBeef(preparation) {
+        return this.preparedBeefCoordinator.enqueue(preparation);
+    }
+    /** Start the optional, rate-limited existing-wallet backfill. */
+    startPreparedBeefBackfill() {
+        if (!this.isAvailable() || this._services == null)
+            return;
+        this.preparedBeefCoordinator.startBackfill();
+    }
+    /** Test/operator hook for waiting until currently queued work is complete. */
+    async waitForPreparedBeefTasks() {
+        await this.preparedBeefCoordinator.waitForIdle();
+    }
+    /** Stop accepting background work and settle an active preparation before shutdown. */
+    async stopPreparedBeefTasks() {
+        await this.preparedBeefCoordinator.stop();
     }
-    normaliseKnexRawResult(rs) {
-        if (this.dbtype === 'MySQL')
-            return rs[0];
-        return rs;
+    rawTxSliceExpression(offset, length, dbtype) {
+        const sql = dbtype === 'MySQL' ? 'substring(?? from ? for ?)' : 'substr(??, ?, ?)';
+        return this.knex.raw(sql, ['rawTx', offset + 1, length]);
     }
-    async getRawTxSlice(txid, offset, length, trx) {
-        const sub = this.dbTypeSubstring('rawTx', offset + 1, length);
-        let rs = await this.toDb(trx).raw(`select ${sub} as rawTx from proven_txs where txid = '${txid}'`);
-        const proven = (0, utilityHelpers_1.verifyOneOrNone)(this.normaliseKnexRawResult(rs));
+    async getRawTxSlice(txid, offset, length, dbtype, trx) {
+        const k = this.toDb(trx);
+        const slice = this.rawTxSliceExpression(offset, length, dbtype);
+        const proven = (0, utilityHelpers_1.verifyOneOrNone)(await k('proven_txs').select({ rawTx: slice }).where({ txid }));
         if (proven?.rawTx != null)
             return Array.from(proven.rawTx);
-        rs = await this.toDb(trx).raw(`select ${sub} as rawTx from proven_tx_reqs where txid = '${txid}' and status in ('unsent', 'nosend', 'sending', 'unmined', 'completed', 'unfail')`);
-        const req = (0, utilityHelpers_1.verifyOneOrNone)(this.normaliseKnexRawResult(rs));
+        const req = (0, utilityHelpers_1.verifyOneOrNone)(await k('proven_tx_reqs')
+            .select({ rawTx: slice })
+            .where({ txid })
+            .whereIn('status', ['unsent', 'nosend', 'sending', 'unmined', 'completed', 'unfail']));
         return req?.rawTx != null ? Array.from(req.rawTx) : undefined;
     }
     async getRawTxOfKnownValidTransaction(txid, offset, length, trx) {
         if (txid == null || txid === '')
             return undefined;
-        if (!this.isAvailable())
-            await this.makeAvailable();
-        if (Number.isInteger(offset) && Number.isInteger(length)) {
-            return await this.getRawTxSlice(txid, offset, length, trx);
+        const hasOffset = offset !== undefined;
+        const hasLength = length !== undefined;
+        if (hasOffset !== hasLength) {
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('offset and length', 'both defined or both undefined');
+        }
+        if (hasOffset &&
+            (!/^[0-9a-f]{64}$/i.test(txid) ||
+                !Number.isSafeInteger(offset) ||
+                !Number.isSafeInteger(length) ||
+                offset < 0 ||
+                length < 0 ||
+                !Number.isSafeInteger(offset + length))) {
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('txid, offset and length', 'a hexadecimal transaction id and non-negative safe slice integers with a safe sum');
+        }
+        // A cold caller may already own SQLite's only connection. Read settings
+        // through that transaction without caching uncommitted state or starting
+        // the background backfill before the caller commits.
+        let settings;
+        if (this.isAvailable())
+            settings = this.getSettings();
+        else if (trx != null)
+            settings = await this.readSettings(trx);
+        else
+            settings = await this.makeAvailable();
+        if (hasOffset) {
+            return await this.getRawTxSlice(txid, offset, length, settings.dbtype, trx);
         }
         const r = await this.getProvenOrRawTx(txid, trx);
         return r.proven != null ? r.proven.rawTx : r.rawTx;
@@ -161,9 +387,16 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             void this.whereExists(k
                 .select('*')
                 .from('transactions')
-                .whereRaw(`proven_txs.provenTxId = transactions.provenTxId and transactions.userId = ${args.userId}`));
+                // ?? quotes identifiers: Postgres lowercases unquoted names, so camelCase columns must be quoted.
+                .whereRaw('?? = ?? and ?? = ?', [
+                'proven_txs.provenTxId',
+                'transactions.provenTxId',
+                'transactions.userId',
+                args.userId
+            ]));
         });
         if (args.paged != null) {
+            q = q.orderBy(pagingOrder('proven_txs'));
             q = q.limit(args.paged.limit);
             q = q.offset(args.paged.offset ?? 0);
         }
@@ -182,9 +415,11 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             void this.whereExists(k
                 .select('*')
                 .from('transactions')
-                .whereRaw(`proven_tx_reqs.txid = transactions.txid and transactions.userId = ${args.userId}`));
+                // ?? quotes identifiers: Postgres lowercases unquoted names, so camelCase columns must be quoted.
+                .whereRaw('proven_tx_reqs.txid = transactions.txid and ?? = ?', ['transactions.userId', args.userId]));
         });
         if (args.paged != null) {
+            q = q.orderBy(pagingOrder('proven_tx_reqs'));
             q = q.limit(args.paged.limit);
             q = q.offset(args.paged.offset ?? 0);
         }
@@ -202,10 +437,17 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         let q = k('tx_labels_map').whereExists(k
             .select('*')
             .from('tx_labels')
-            .whereRaw(`tx_labels.txLabelId = tx_labels_map.txLabelId and tx_labels.userId = ${args.userId}`));
+            // ?? quotes identifiers: Postgres lowercases unquoted names, so camelCase columns must be quoted.
+            .whereRaw('?? = ?? and ?? = ?', [
+            'tx_labels.txLabelId',
+            'tx_labels_map.txLabelId',
+            'tx_labels.userId',
+            args.userId
+        ]));
         if (args.since != null)
             q = q.where('updated_at', '>=', this.validateDateForWhere(args.since));
         if (args.paged != null) {
+            q = q.orderBy(pagingOrder('tx_labels_map'));
             q = q.limit(args.paged.limit);
             q = q.offset(args.paged.offset ?? 0);
         }
@@ -221,10 +463,17 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         let q = k('output_tags_map').whereExists(k
             .select('*')
             .from('output_tags')
-            .whereRaw(`output_tags.outputTagId = output_tags_map.outputTagId and output_tags.userId = ${args.userId}`));
+            // ?? quotes identifiers: Postgres lowercases unquoted names, so camelCase columns must be quoted.
+            .whereRaw('?? = ?? and ?? = ?', [
+            'output_tags.outputTagId',
+            'output_tags_map.outputTagId',
+            'output_tags.userId',
+            args.userId
+        ]));
         if (args.since != null)
             q = q.where('updated_at', '>=', this.validateDateForWhere(args.since));
         if (args.paged != null) {
+            q = q.orderBy(pagingOrder('output_tags_map'));
             q = q.limit(args.paged.limit);
             q = q.offset(args.paged.offset ?? 0);
         }
@@ -235,6 +484,45 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const rs = await q;
         return this.validateEntities(rs, undefined, ['isDeleted']);
     }
+    async countSyncQuery(query) {
+        const row = await query.count({ count: '*' }).first();
+        return Number(row?.count ?? 0);
+    }
+    async getSyncChunkTotals(args, userId) {
+        const since = args.since;
+        const [provenTxs, outputBaskets, outputTags, txLabels, transactions, outputs, txLabelMaps, outputTagMaps, certificates, certificateFields, commissions, provenTxReqs] = await Promise.all([
+            this.countSyncQuery(this.getProvenTxsForUserQuery({ userId, since })),
+            this.countOutputBaskets({ partial: { userId }, since }),
+            this.countOutputTags({ partial: { userId }, since }),
+            this.countTxLabels({ partial: { userId }, since }),
+            this.countTransactions({ partial: { userId }, since, noRawTx: true }),
+            this.countOutputs({ partial: { userId }, since, noScript: true }),
+            this.countSyncQuery(this.getTxLabelMapsForUserQuery({ userId, since })),
+            this.countSyncQuery(this.getOutputTagMapsForUserQuery({ userId, since })),
+            this.countCertificates({ partial: { userId }, since }),
+            this.countCertificateFields({ partial: { userId }, since }),
+            this.countCommissions({ partial: { userId }, since }),
+            this.countSyncQuery(this.getProvenTxReqsForUserQuery({ userId, since }))
+        ]);
+        const records = {
+            provenTxs,
+            outputBaskets,
+            outputTags,
+            txLabels,
+            transactions,
+            outputs,
+            txLabelMaps,
+            outputTagMaps,
+            certificates,
+            certificateFields,
+            commissions,
+            provenTxReqs
+        };
+        return {
+            totalRecords: Object.values(records).reduce((total, count) => total + count, 0),
+            records
+        };
+    }
     async listActions(auth, vargs) {
         if (auth.userId == null)
             throw new WERR_errors_1.WERR_UNAUTHORIZED();
@@ -245,11 +533,36 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             throw new WERR_errors_1.WERR_UNAUTHORIZED();
         return await (0, listOutputsKnex_1.listOutputs)(this, auth, vargs);
     }
+    /**
+     * Insert one row and return its auto-increment primary key. MySQL and SQLite
+     * report the id as the insert result; Postgres requires a RETURNING clause.
+     */
+    async insertReturningId(table, idColumn, row, trx) {
+        if (this.dbtype !== 'Postgres') {
+            const [id] = await this.toDb(trx)(table).insert(row);
+            return id;
+        }
+        return await this.inSavepoint(trx, async (db) => {
+            const [r] = await db(table).insert(row).returning(idColumn);
+            return r[idColumn];
+        });
+    }
+    /**
+     * The findOrInsert helpers catch a failed insert and find the row again in
+     * the same transaction. MySQL and SQLite allow that. Postgres aborts the
+     * whole transaction on any statement error, so there the insert runs in a
+     * savepoint that is rolled back on its own.
+     */
+    async inSavepoint(trx, run) {
+        if (trx == null || this.dbtype !== 'Postgres')
+            return await run(this.toDb(trx));
+        return await trx.transaction(async (savepoint) => await run(savepoint));
+    }
     async insertProvenTx(tx, trx) {
         const e = await this.validateEntityForInsert(tx, trx);
         if (e.provenTxId === 0)
             delete e.provenTxId;
-        const [id] = await this.toDb(trx)('proven_txs').insert(e);
+        const id = await this.insertReturningId('proven_txs', 'provenTxId', e, trx);
         tx.provenTxId = id;
         return tx.provenTxId;
     }
@@ -257,7 +570,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const e = await this.validateEntityForInsert(batch, trx, ['expiresAt', 'hardExpiresAt']);
         if (e.actionBatchId === 0)
             delete e.actionBatchId;
-        const [id] = await this.toDb(trx)('action_batches').insert(e);
+        const id = await this.insertReturningId('action_batches', 'actionBatchId', e, trx);
         batch.actionBatchId = id;
         return id;
     }
@@ -266,10 +579,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         return row == null ? undefined : this.validateEntity(row, ['expiresAt', 'hardExpiresAt']);
     }
     async findActionBatchForUpdate(userId, batchId, trx) {
-        const row = await this.toDb(trx)('action_batches')
-            .where({ userId, batchId })
-            .forUpdate()
-            .first();
+        const row = await this.toDb(trx)('action_batches').where({ userId, batchId }).forUpdate().first();
         return row == null ? undefined : this.validateEntity(row, ['expiresAt', 'hardExpiresAt']);
     }
     async findExpiredActionBatches(now, trx) {
@@ -345,9 +655,9 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const rows = [];
         const uniqueDigests = [...new Set(digests)];
         for (let offset = 0; offset < uniqueDigests.length; offset += ACTION_BATCH_BLOB_SQL_CHUNK) {
-            rows.push(...await this.toDb(trx)('action_batch_blobs')
+            rows.push(...(await this.toDb(trx)('action_batch_blobs')
                 .where({ actionBatchId })
-                .whereIn('digest', uniqueDigests.slice(offset, offset + ACTION_BATCH_BLOB_SQL_CHUNK)));
+                .whereIn('digest', uniqueDigests.slice(offset, offset + ACTION_BATCH_BLOB_SQL_CHUNK))));
         }
         for (const row of rows) {
             if (Buffer.isBuffer(row.bytes)) {
@@ -380,7 +690,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const e = await this.validateEntityForInsert(tx, trx);
         if (e.provenTxReqId === 0)
             delete e.provenTxReqId;
-        const [id] = await this.toDb(trx)('proven_tx_reqs').insert(e);
+        const id = await this.insertReturningId('proven_tx_reqs', 'provenTxReqId', e, trx);
         tx.provenTxReqId = id;
         return tx.provenTxReqId;
     }
@@ -388,12 +698,13 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const e = await this.validateEntityForInsert(user, trx);
         if (e.userId === 0)
             delete e.userId;
-        const [id] = await this.toDb(trx)('users').insert(e);
+        const id = await this.insertReturningId('users', 'userId', e, trx);
         user.userId = id;
         return user.userId;
     }
     async insertCertificateAuth(auth, certificate) {
-        if (auth.userId == null || (certificate.userId != null && certificate.userId !== 0 && certificate.userId !== auth.userId))
+        if (auth.userId == null ||
+            (certificate.userId != null && certificate.userId !== 0 && certificate.userId !== auth.userId))
             throw new WERR_errors_1.WERR_UNAUTHORIZED();
         certificate.userId = auth.userId;
         return await this.insertCertificate(certificate);
@@ -407,7 +718,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const fields = e.fields;
         if (e.fields != null)
             delete e.fields;
-        const [id] = await this.toDb(trx)('certificates').insert(e);
+        const id = await this.insertReturningId('certificates', 'certificateId', e, trx);
         certificate.certificateId = id;
         if (fields != null) {
             for (const field of fields) {
@@ -426,7 +737,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const e = await this.validateEntityForInsert(basket, trx, undefined, ['isDeleted']);
         if (e.basketId === 0)
             delete e.basketId;
-        const [id] = await this.toDb(trx)('output_baskets').insert(e);
+        const id = await this.insertReturningId('output_baskets', 'basketId', e, trx);
         basket.basketId = id;
         return basket.basketId;
     }
@@ -434,7 +745,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const e = await this.validateEntityForInsert(tx, trx);
         if (e.transactionId === 0)
             delete e.transactionId;
-        const [id] = await this.toDb(trx)('transactions').insert(e);
+        const id = await this.insertReturningId('transactions', 'transactionId', e, trx);
         tx.transactionId = id;
         return tx.transactionId;
     }
@@ -442,7 +753,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const e = await this.validateEntityForInsert(commission, trx);
         if (e.commissionId === 0)
             delete e.commissionId;
-        const [id] = await this.toDb(trx)('commissions').insert(e);
+        const id = await this.insertReturningId('commissions', 'commissionId', e, trx);
         commission.commissionId = id;
         return commission.commissionId;
     }
@@ -450,7 +761,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const e = await this.validateEntityForInsert(output, trx);
         if (e.outputId === 0)
             delete e.outputId;
-        const [id] = await this.toDb(trx)('outputs').insert(e);
+        const id = await this.insertReturningId('outputs', 'outputId', e, trx);
         output.outputId = id;
         return output.outputId;
     }
@@ -471,31 +782,31 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const e = await this.validateEntityForInsert(tag, trx, undefined, ['isDeleted']);
         if (e.outputTagId === 0)
             delete e.outputTagId;
-        const [id] = await this.toDb(trx)('output_tags').insert(e);
+        const id = await this.insertReturningId('output_tags', 'outputTagId', e, trx);
         tag.outputTagId = id;
         return tag.outputTagId;
     }
     async insertOutputTagMap(tagMap, trx) {
         const e = await this.validateEntityForInsert(tagMap, trx, undefined, ['isDeleted']);
-        await this.toDb(trx)('output_tags_map').insert(e);
+        await this.inSavepoint(trx, async (db) => await db('output_tags_map').insert(e));
     }
     async insertTxLabel(label, trx) {
         const e = await this.validateEntityForInsert(label, trx, undefined, ['isDeleted']);
         if (e.txLabelId === 0)
             delete e.txLabelId;
-        const [id] = await this.toDb(trx)('tx_labels').insert(e);
+        const id = await this.insertReturningId('tx_labels', 'txLabelId', e, trx);
         label.txLabelId = id;
         return label.txLabelId;
     }
     async insertTxLabelMap(labelMap, trx) {
         const e = await this.validateEntityForInsert(labelMap, trx, undefined, ['isDeleted']);
-        await this.toDb(trx)('tx_labels_map').insert(e);
+        await this.inSavepoint(trx, async (db) => await db('tx_labels_map').insert(e));
     }
     async insertMonitorEvent(event, trx) {
         const e = await this.validateEntityForInsert(event, trx);
         if (e.id === 0)
             delete e.id;
-        const [id] = await this.toDb(trx)('monitor_events').insert(e);
+        const id = await this.insertReturningId('monitor_events', 'id', e, trx);
         event.id = id;
         return event.id;
     }
@@ -503,7 +814,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const e = await this.validateEntityForInsert(syncState, trx, ['when'], ['init']);
         if (e.syncStateId === 0)
             delete e.syncStateId;
-        const [id] = await this.toDb(trx)('sync_states').insert(e);
+        const id = await this.insertReturningId('sync_states', 'syncStateId', e, trx);
         syncState.syncStateId = id;
         return syncState.syncStateId;
     }
@@ -597,6 +908,13 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         }
         return r;
     }
+    async compareAndSetNoSendExpiryState(transactionId, expected, next, trx) {
+        await this.verifyReadyForDatabaseAccess(trx);
+        const updated = await this.toDb(trx)('transactions')
+            .where({ transactionId, noSendExpiryState: expected })
+            .update(this.validatePartialForUpdate({ noSendExpiryState: next }));
+        return updated === 1;
+    }
     async updateTxLabelMap(transactionId, txLabelId, update, trx) {
         await this.verifyReadyForDatabaseAccess(trx);
         return await this.toDb(trx)('tx_labels_map')
@@ -672,6 +990,8 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             }
         }
         if (args.paged != null) {
+            if (args.orderDescending !== true)
+                void q.orderBy(pagingOrder(table));
             void q.limit(args.paged.limit);
             void q.offset(args.paged.offset ?? 0);
         }
@@ -682,9 +1002,9 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
     }
     findCertificatesQuery(args) {
         const q = this.setupQuery('certificates', args);
-        if ((args.certifiers != null) && args.certifiers.length > 0)
+        if (args.certifiers != null && args.certifiers.length > 0)
             void q.whereIn('certifier', args.certifiers);
-        if ((args.types != null) && args.types.length > 0)
+        if (args.types != null && args.types.length > 0)
             void q.whereIn('type', args.types);
         return q;
     }
@@ -702,10 +1022,30 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             throw new WERR_errors_1.WERR_INVALID_PARAMETER('args.partial.lockingScript', 'undefined. Outputs may not be found by lockingScript value.');
         }
         const q = this.setupQuery('outputs', args);
-        if ((args.txStatus != null) && args.txStatus.length > 0) {
-            void q.whereRaw(`(select status from transactions where transactions.transactionId = outputs.transactionId) in (${args.txStatus.map(s => "'" + s + "'").join(',')})`);
+        if (args.txStatus != null && args.txStatus.length > 0) {
+            const allowedStatuses = new Set([
+                'completed',
+                'failed',
+                'unprocessed',
+                'sending',
+                'unproven',
+                'unsigned',
+                'nosend',
+                'nonfinal',
+                'unfail'
+            ]);
+            if (args.txStatus.some(status => !allowedStatuses.has(status))) {
+                throw new WERR_errors_1.WERR_INVALID_PARAMETER('args.txStatus', 'supported transaction statuses');
+            }
+            const statuses = [...new Set(args.txStatus)];
+            void q.whereExists(function () {
+                void this.select(1)
+                    .from('transactions')
+                    .whereRaw('?? = ??', ['transactions.transactionId', 'outputs.transactionId'])
+                    .whereIn('transactions.status', statuses);
+            });
         }
-        if ((args.noScript === true) && count !== true) {
+        if (args.noScript === true && count !== true) {
             const columns = tables_1.outputColumnsWithoutLockingScript.map(c => `outputs.${c}`);
             void q.select(columns);
         }
@@ -713,7 +1053,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
     }
     findOutputTagMapsQuery(args) {
         const q = this.setupQuery('output_tags_map', args);
-        if ((args.tagIds != null) && args.tagIds.length > 0)
+        if (args.tagIds != null && args.tagIds.length > 0)
             void q.whereIn('outputTagId', args.tagIds);
         return q;
     }
@@ -728,7 +1068,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             throw new WERR_errors_1.WERR_INVALID_PARAMETER('args.partial.inputBEEF', 'undefined. ProvenTxReqs may not be found by inputBEEF value.');
         }
         const q = this.setupQuery('proven_tx_reqs', args);
-        if ((args.status != null) && args.status.length > 0)
+        if (args.status != null && args.status.length > 0)
             void q.whereIn('status', args.status);
         if (args.txids != null) {
             const txids = args.txids.filter(txid => txid !== undefined);
@@ -771,13 +1111,13 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             throw new WERR_errors_1.WERR_INVALID_PARAMETER('args.partial.inputBEEF', 'undefined. Transactions may not be found by inputBEEF value.');
         }
         const q = this.setupQuery('transactions', args);
-        if ((args.status != null) && args.status.length > 0)
+        if (args.status != null && args.status.length > 0)
             void q.whereIn('status', args.status);
         if (args.from != null)
             void q.where('created_at', '>=', this.validateDateForWhere(args.from));
         if (args.to != null)
             void q.where('created_at', '<', this.validateDateForWhere(args.to));
-        if ((args.noRawTx === true) && count !== true) {
+        if (args.noRawTx === true && count !== true) {
             const columns = tables_1.transactionColumnsWithoutRawTx.map(c => `transactions.${c}`);
             void q.select(columns);
         }
@@ -785,7 +1125,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
     }
     findTxLabelMapsQuery(args) {
         const q = this.setupQuery('tx_labels_map', args);
-        if ((args.labelIds != null) && args.labelIds.length > 0)
+        if (args.labelIds != null && args.labelIds.length > 0)
             void q.whereIn('txLabelId', args.labelIds);
         return q;
     }
@@ -799,19 +1139,32 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         return this.setupQuery('monitor_events', args);
     }
     async findCertificatesAuth(auth, args) {
-        if (auth.userId == null || (args.partial.userId != null && args.partial.userId !== 0 && args.partial.userId !== auth.userId))
+        if (auth.userId == null ||
+            (args.partial.userId != null && args.partial.userId !== 0 && args.partial.userId !== auth.userId))
             throw new WERR_errors_1.WERR_UNAUTHORIZED();
         args.partial.userId = auth.userId;
         return await this.findCertificates(args);
     }
+    async findProvenTxReqsAuth(auth, args) {
+        const userId = (0, utilityHelpers_1.verifyId)(auth.userId);
+        const k = this.toDb(args.trx);
+        const q = this.findProvenTxReqsQuery(args).whereExists(k
+            .select(1)
+            .from('transactions')
+            .whereRaw('proven_tx_reqs.txid = transactions.txid')
+            .where('transactions.userId', userId));
+        return this.validateEntities(await q, undefined, ['notified', 'wasBroadcast']);
+    }
     async findOutputBasketsAuth(auth, args) {
-        if (auth.userId == null || (args.partial.userId != null && args.partial.userId !== 0 && args.partial.userId !== auth.userId))
+        if (auth.userId == null ||
+            (args.partial.userId != null && args.partial.userId !== 0 && args.partial.userId !== auth.userId))
             throw new WERR_errors_1.WERR_UNAUTHORIZED();
         args.partial.userId = auth.userId;
         return await this.findOutputBaskets(args);
     }
     async findOutputsAuth(auth, args) {
-        if (auth.userId == null || (args.partial.userId != null && args.partial.userId !== 0 && args.partial.userId !== auth.userId))
+        if (auth.userId == null ||
+            (args.partial.userId != null && args.partial.userId !== 0 && args.partial.userId !== auth.userId))
             throw new WERR_errors_1.WERR_UNAUTHORIZED();
         args.partial.userId = auth.userId;
         return await this.findOutputs(args);
@@ -880,6 +1233,12 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
     }
     async findSyncStates(args) {
         const q = this.findSyncStatesQuery(args);
+        // Serialize sync checkpoint reads with the page transaction on MySQL and Postgres too.
+        if (args.trx != null &&
+            (this.dbtype === 'MySQL' || this.dbtype === 'Postgres') &&
+            args.partial.userId != null &&
+            (args.partial.syncStateId != null || args.partial.storageIdentityKey != null))
+            q.forUpdate();
         const r = await q;
         return this.validateEntities(r, ['when'], ['init']);
     }
@@ -928,9 +1287,12 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         return this.validateEntities(r, ['when']);
     }
     async getCount(q) {
-        void q.count();
+        // Alias the count: the default result key differs by dialect, and Postgres
+        // returns count(*) as a bigint string.
+        // A paged find query orders its rows; an aggregate cannot keep that order on Postgres.
+        void q.clearOrder().count({ count: '*' });
         const r = await q;
-        return r[0]['count(*)'];
+        return Number(r[0].count);
     }
     async countCertificateFields(args) {
         return await this.getCount(this.findCertificateFieldsQuery(args));
@@ -978,6 +1340,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         return await this.getCount(this.findMonitorEventsQuery(args));
     }
     async destroy() {
+        await this.stopPreparedBeefTasks();
         this.knex.off('query', this.onQuery);
         this.knex.off('query-response', this.onQueryResponse);
         this.knex.off('query-error', this.onQueryError);
@@ -990,24 +1353,32 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         // Check if this is a SQLite database by looking at the Knex client config
         const clientName = this.knex.client.config?.client ?? '';
         const isSQLite = clientName.includes('sqlite');
-        // For SQLite, disable transactions during migrations and turn off foreign keys.
-        // PRAGMA foreign_keys is silently ignored inside transactions, so we must
-        // disable transactions for the migration to allow the PRAGMA to take effect.
-        // See: https://github.com/knex/knex/issues/4155
+        // For SQLite, turn foreign keys off for the duration of the migration.
+        // PRAGMA foreign_keys is silently ignored *when executed inside* a
+        // transaction (https://github.com/knex/knex/issues/4155), so it is issued
+        // here, outside migrate.latest(). SQLite's single-connection pool means
+        // knex's per-migration transaction runs on this same connection and
+        // inherits the setting, and knex's own SQLite alter-table rebuild leaves an
+        // ambient pragma alone while transacting (sqlite3/schema/ddl.js: alter()
+        // uses `enforceForeignCheck = this.client.transacting ? null : false`).
         if (isSQLite) {
             await this.knex.raw('PRAGMA foreign_keys = OFF;');
         }
-        const config = {
-            migrationSource: new KnexMigrations_1.KnexMigrations(this.chain, storageName, storageIdentityKey, 1024),
-            disableTransactions: isSQLite
-        };
-        await this.knex.migrate.latest(config);
-        const version = await this.knex.migrate.currentVersion(config);
-        // Re-enable foreign key checks for SQLite
-        if (isSQLite) {
-            await this.knex.raw('PRAGMA foreign_keys = ON;');
+        try {
+            const config = {
+                migrationSource: new KnexMigrations_1.KnexMigrations(this.chain, storageName, storageIdentityKey, 1024),
+                // Keep DDL and its migration journal entry in the same transaction.
+                disableTransactions: false
+            };
+            await this.knex.migrate.latest(config);
+            return await this.knex.migrate.currentVersion(config);
+        }
+        finally {
+            // Leaving foreign-key enforcement disabled after a failed migration would
+            // weaken every subsequent write on this connection.
+            if (isSQLite)
+                await this.knex.raw('PRAGMA foreign_keys = ON;');
         }
-        return version;
     }
     async dropAllData() {
         // Only using migrations to migrate down, don't need valid properties for settings table.
@@ -1029,24 +1400,22 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         if (isSQLite) {
             await this.knex.raw('PRAGMA foreign_keys = OFF;');
         }
-        for (let i = 0; i < count; i++) {
-            try {
-                const r = await this.knex.migrate.down(config);
-                if (r == null) {
-                    console.error('Migration returned falsy result await this.knex.migrate.down(config)');
-                    break;
-                }
+        try {
+            for (let i = 0; i < count; i++) {
+                const version = await this.knex.migrate.currentVersion(config);
+                if (version === 'none')
+                    return;
+                const result = await this.knex.migrate.down(config);
+                if (result == null)
+                    throw new WERR_errors_1.WERR_INTERNAL('database migration rollback returned no result');
             }
-            catch (migrationError) {
-                // migrate.down throws when there are no more migrations to roll back — this is
-                // the expected terminal condition, so we stop iterating rather than propagating.
-                console.debug('migrate.down stopped (no more migrations or error):', migrationError);
-                break;
+            if ((await this.knex.migrate.currentVersion(config)) !== 'none') {
+                throw new WERR_errors_1.WERR_INTERNAL('database migration rollback did not reach the empty schema');
             }
         }
-        // Re-enable foreign key checks for SQLite
-        if (isSQLite) {
-            await this.knex.raw('PRAGMA foreign_keys = ON;');
+        finally {
+            if (isSQLite)
+                await this.knex.raw('PRAGMA foreign_keys = ON;');
         }
     }
     async transaction(scope, trx) {
@@ -1064,7 +1433,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     toDb(trx) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const db = (trx == null) ? this.knex : trx;
+        const db = trx == null ? this.knex : trx;
         this.whenLastAccess = new Date();
         return db;
     }
@@ -1088,7 +1457,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
      * @param trx
      */
     async verifyReadyForDatabaseAccess(trx) {
-        this._settings ??= await this.readSettings();
+        this._settings ??= await this.readSettings(trx);
         // Always run the PRAGMA for SQLite to ensure foreign key constraints are enabled.
         // This is necessary because PRAGMA foreign_keys is a per-connection setting,
         // and connection pools may create new connections that don't have it set.
@@ -1236,7 +1605,8 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             void this.select(1)
                 .from('action_batch_outputs as abo')
                 .join('action_batches as ab', 'abo.actionBatchId', 'ab.actionBatchId')
-                .whereRaw('abo.outputId = o.outputId')
+                // ?? quotes identifiers: Postgres lowercases unquoted names, so camelCase columns must be quoted.
+                .whereRaw('?? = ??', ['abo.outputId', 'o.outputId'])
                 .whereIn('ab.status', ['active', 'prepared'])
                 .where('ab.expiresAt', '>', now)
                 .where('ab.hardExpiresAt', '>', now);
@@ -1270,7 +1640,8 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             void this.select(1)
                 .from('action_batch_outputs as abo')
                 .join('action_batches as ab', 'abo.actionBatchId', 'ab.actionBatchId')
-                .whereRaw('abo.outputId = o.outputId')
+                // ?? quotes identifiers: Postgres lowercases unquoted names, so camelCase columns must be quoted.
+                .whereRaw('?? = ??', ['abo.outputId', 'o.outputId'])
                 .whereIn('ab.status', ['active', 'prepared'])
                 .where('ab.expiresAt', '>', now)
                 .where('ab.hardExpiresAt', '>', now);
@@ -1304,13 +1675,14 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             void this.select(1)
                 .from('action_batch_outputs as abo')
                 .join('action_batches as ab', 'abo.actionBatchId', 'ab.actionBatchId')
-                .whereRaw('abo.outputId = o.outputId')
+                // ?? quotes identifiers: Postgres lowercases unquoted names, so camelCase columns must be quoted.
+                .whereRaw('?? = ??', ['abo.outputId', 'o.outputId'])
                 .whereIn('ab.status', ['active', 'prepared'])
                 .where('ab.expiresAt', '>', now)
                 .where('ab.hardExpiresAt', '>', now);
         })
             .whereIn('t.status', statuses)
-            .select('o.outputId', 'o.transactionId', 'o.satoshis', 'o.txid', 'o.vout');
+            .select('o.outputId', 'o.transactionId', 'o.satoshis', 'o.txid', 'o.vout', 't.status as transactionStatus');
     }
     async findOutputsByIds(outputIds, trx) {
         const byId = {};
@@ -1481,7 +1853,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             .whereIn('t.status', status)
             .sum({ totalSatoshis: 'o.satoshis' })
             .first();
-        const total = (row != null) ? row.totalSatoshis : undefined;
+        const total = row != null ? row.totalSatoshis : undefined;
         return Number(total ?? 0);
     }
     /**
@@ -1493,6 +1865,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
         const status = ['completed', 'unproven'];
         if (!excludeSending)
             status.push('sending');
+        let reservedConcurrently = false;
         const r = await this.knex.transaction(async (trx) => {
             const baseQuery = () => trx('outputs as o')
                 .join('transactions as t', 'o.transactionId', 't.transactionId')
@@ -1511,9 +1884,8 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
                 .whereNot('o.derivationSuffix', '')
                 .whereNull('o.spentBy')
                 .whereNotExists(function () {
-                void this.select(1)
-                    .from('action_batch_outputs as abo')
-                    .whereRaw('abo.outputId = o.outputId');
+                // ?? quotes identifiers: Postgres lowercases unquoted names, so camelCase columns must be quoted.
+                void this.select(1).from('action_batch_outputs as abo').whereRaw('?? = ??', ['abo.outputId', 'o.outputId']);
             })
                 .whereIn('t.status', status)
                 .select('o.*')
@@ -1534,6 +1906,14 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
                 .first();
             if (output == null)
                 return undefined;
+            // Under Postgres READ COMMITTED the NOT EXISTS above uses the statement's
+            // snapshot, so an action batch reservation committed while the statement
+            // waited for the row lock is not visible to it. Retry in a new transaction.
+            if (this.dbtype === 'Postgres' &&
+                (await this.findReservedActionBatchOutputIds([output.outputId], trx)).length > 0) {
+                reservedConcurrently = true;
+                return undefined;
+            }
             await this.updateOutput(output.outputId, {
                 spendable: false,
                 spentBy: transactionId
@@ -1545,6 +1925,8 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             output.spentBy = transactionId;
             return output;
         });
+        if (reservedConcurrently)
+            return await this.allocateChangeInput(userId, basketId, targetSatoshis, exactSatoshis, excludeSending, transactionId);
         return r;
     }
     async markChangeInputsSpent(outputIds, transactionId, trx) {
@@ -1591,7 +1973,8 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             for (const df of booleanFields) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 if (entity[df] !== undefined)
-                    entity[df] = entity[df] !== 0 && entity[df] != null && entity[df] !== false;
+                    entity[df] =
+                        entity[df] !== 0 && entity[df] != null && entity[df] !== false;
             }
         }
         this.deserialiseFromKnex(entity);
@@ -1616,7 +1999,7 @@ class StorageKnex extends StorageProvider_1.StorageProvider {
             orderDescending: true,
             paged: { limit: 1 }
         }));
-        const monitorStats = (monitorEvent != null) ? JSON.parse(monitorEvent.details) : undefined;
+        const monitorStats = monitorEvent != null ? JSON.parse(monitorEvent.details) : undefined;
         const servicesStats = this.getServices().getServicesCallHistory(true);
         const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
         const oneWeekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
@@ -1770,4 +2153,67 @@ select
     }
 }
 exports.StorageKnex = StorageKnex;
+/**
+ * Key columns that give paged queries a deterministic row order. Without an
+ * ORDER BY, Postgres may return the rows of consecutive LIMIT/OFFSET pages in
+ * different orders, so sync chunks could repeat some rows and skip others.
+ */
+function pagingOrder(table) {
+    return pagingKey(table).map(column => `${table}.${column}`);
+}
+function pagingKey(table) {
+    switch (table) {
+        case 'certificate_fields':
+            return ['certificateId', 'fieldName'];
+        case 'certificates':
+            return ['certificateId'];
+        case 'commissions':
+            return ['commissionId'];
+        case 'monitor_events':
+            return ['id'];
+        case 'output_baskets':
+            return ['basketId'];
+        case 'output_tags':
+            return ['outputTagId'];
+        case 'output_tags_map':
+            return ['outputTagId', 'outputId'];
+        case 'outputs':
+            return ['outputId'];
+        case 'proven_tx_reqs':
+            return ['provenTxReqId'];
+        case 'proven_txs':
+            return ['provenTxId'];
+        case 'sync_states':
+            return ['syncStateId'];
+        case 'transactions':
+            return ['transactionId'];
+        case 'tx_labels':
+            return ['txLabelId'];
+        case 'tx_labels_map':
+            return ['txLabelId', 'transactionId'];
+        case 'users':
+            return ['userId'];
+        default:
+            return [];
+    }
+}
+const pgInt8Parsed = Symbol('pgInt8Parsed');
+/**
+ * node-postgres returns int8 values (bigint columns such as satoshis, `count(*)`)
+ * as strings. Set a parser on each connection this knex acquires so they come
+ * back as numbers, as with mysql2 and better-sqlite3. The process-wide `pg.types`
+ * defaults are left unchanged.
+ */
+function parsePostgresInt8AsNumber(knex) {
+    const client = knex.client;
+    if (client?.dialect !== 'postgresql' || client[pgInt8Parsed] === true)
+        return;
+    client[pgInt8Parsed] = true;
+    const acquireConnection = client.acquireConnection.bind(client);
+    client.acquireConnection = async () => {
+        const connection = await acquireConnection();
+        connection.setTypeParser(20, (value) => Number.parseInt(value, 10));
+        return connection;
+    };
+}
 //# sourceMappingURL=StorageKnex.js.map