@bsv/wallet-toolbox-client 2.1.24 → 3.0.0-alpha.0

package/out/src/storage/schema/transactionService.js

@@ -0,0 +1,783 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionService = void 0;
+exports.indexFromMerklePath = indexFromMerklePath;
+const sdk_1 = require("@bsv/sdk");
+const transactionCrud_1 = require("./transactionCrud");
+const txAudit_1 = require("./txAudit");
+const monitorLease_1 = require("./monitorLease");
+/**
+ * High-level service over the new-schema storage primitives.
+ *
+ * Storage methods and the Monitor call into this surface rather than the
+ * lower-level CRUD/FSM/audit/lease modules so that:
+ *  - Every processing transition is audited.
+ *  - Optimistic concurrency is uniformly enforced.
+ *  - Chain tip + monitor lease access have one canonical entry point.
+ *
+ * Construction takes a Knex handle; instances are stateless and cheap to
+ * create — typically one per request or per Monitor task tick.
+ */
+/**
+ * Extract the merkle leaf index for `txid` from a BUMP-encoded merkle path.
+ *
+ * The BUMP format encodes level 0 leaves with `txid: true` and an `offset`
+ * equal to the position of the transaction in its block. For a single-tx
+ * proof exactly one leaf is flagged; for trimmed compound proofs the leaf
+ * matching `txid` is selected.
+ */
+function indexFromMerklePath(merklePath, txid) {
+    var _a;
+    const mp = sdk_1.MerklePath.fromBinary(merklePath);
+    const level0 = (_a = mp.path[0]) !== null && _a !== void 0 ? _a : [];
+    const leaf = level0.find(l => l.txid === true && l.hash === txid);
+    if (leaf == null)
+        throw new Error(`txid ${txid} not present in merklePath`);
+    return leaf.offset;
+}
+class TransactionService {
+    constructor(knex) {
+        this.knex = knex;
+    }
+    // -----------------------
+    // Transactions
+    // -----------------------
+    async findByTxid(txid) {
+        return await (0, transactionCrud_1.findTransactionNewByTxid)(this.knex, txid);
+    }
+    async findById(transactionId) {
+        return await (0, transactionCrud_1.findTransactionNew)(this.knex, transactionId);
+    }
+    /**
+     * Insert a new new transaction row. The row is created in `queued` state
+     * unless the caller overrides `processing`.
+     */
+    async create(args) {
+        var _a, _b;
+        const now = (_a = args.now) !== null && _a !== void 0 ? _a : new Date();
+        const row = {
+            txid: args.txid,
+            processing: (_b = args.processing) !== null && _b !== void 0 ? _b : 'queued',
+            processingChangedAt: now,
+            nextActionAt: undefined,
+            attempts: 0,
+            rebroadcastCycles: 0,
+            wasBroadcast: false,
+            idempotencyKey: args.idempotencyKey,
+            batch: args.batch,
+            rawTx: args.rawTx,
+            inputBeef: args.inputBeef,
+            height: undefined,
+            merkleIndex: undefined,
+            merklePath: undefined,
+            merkleRoot: undefined,
+            blockHash: undefined,
+            isCoinbase: args.isCoinbase === true,
+            lastProvider: undefined,
+            lastProviderStatus: undefined,
+            frozenReason: undefined,
+            rowVersion: 0
+        };
+        const id = await (0, transactionCrud_1.insertTransactionNew)(this.knex, row, now);
+        await (0, txAudit_1.auditProcessingTransition)(this.knex, id, row.processing, row.processing, { reason: 'create' }, now);
+        const stored = await this.findById(id);
+        if (stored == null)
+            throw new Error(`new transaction ${id} disappeared after insert`);
+        return stored;
+    }
+    /**
+     * Transition processing state with optimistic concurrency. Returns
+     * `undefined` when the FSM rejects the move OR the row's current state no
+     * longer matches `expectedFrom`.
+     */
+    async transition(args) {
+        return await (0, transactionCrud_1.transitionProcessing)(this.knex, {
+            transactionId: args.transactionId,
+            expectedFromState: args.expectedFrom,
+            toState: args.to,
+            provider: args.provider,
+            providerStatus: args.providerStatus,
+            details: args.details
+        }, args.now);
+    }
+    /**
+     * Record acquisition of a Merkle proof for a transaction. Atomically:
+     *  - Updates proof columns (height, index, merkle_path, merkle_root, block_hash)
+     *  - Transitions processing to `confirmed` from any spendable-class state.
+     *  - Writes a `proof.acquired` audit row.
+     *
+     * The merkle leaf index is derived from `merklePath` (BUMP) using the row's
+     * `txid`; callers do not pass it.
+     */
+    async recordProof(args) {
+        var _a;
+        const now = (_a = args.now) !== null && _a !== void 0 ? _a : new Date();
+        const existing = await this.findById(args.transactionId);
+        if (existing == null)
+            return undefined;
+        const merkleIndex = indexFromMerklePath(args.merklePath, existing.txid);
+        const next = await this.transition({
+            transactionId: args.transactionId,
+            expectedFrom: args.expectedFrom,
+            to: 'confirmed',
+            details: { source: 'recordProof', height: args.height },
+            now
+        });
+        if (next == null)
+            return undefined;
+        await this.knex('transactions').where({ transactionId: args.transactionId }).update({
+            height: args.height,
+            merkle_index: merkleIndex,
+            merkle_path: Buffer.from(args.merklePath),
+            merkle_root: args.merkleRoot,
+            block_hash: args.blockHash,
+            updated_at: now
+        });
+        return await this.findById(args.transactionId);
+    }
+    // -----------------------
+    // Actions
+    // -----------------------
+    async findActionForUser(userId, transactionId) {
+        return await (0, transactionCrud_1.findAction)(this.knex, userId, transactionId);
+    }
+    async createAction(args) {
+        return await (0, transactionCrud_1.insertAction)(this.knex, {
+            userId: args.userId,
+            transactionId: args.transactionId,
+            reference: args.reference,
+            description: args.description,
+            isOutgoing: args.isOutgoing,
+            satoshisDelta: args.satoshisDelta,
+            userNosend: args.userNosend === true,
+            hidden: false,
+            userAborted: false,
+            notifyJson: args.notifyJson,
+            rowVersion: 0
+        }, args.now);
+    }
+    // -----------------------
+    // Chain tip
+    // -----------------------
+    async getChainTip() {
+        const tip = await (0, transactionCrud_1.getChainTip)(this.knex);
+        if (tip == null)
+            return undefined;
+        return { height: tip.height, blockHash: tip.blockHash };
+    }
+    async setChainTip(args) {
+        await (0, transactionCrud_1.setChainTip)(this.knex, args, args.now);
+    }
+    // -----------------------
+    // Monitor lease
+    // -----------------------
+    async tryClaimLease(claim, now) {
+        return await (0, monitorLease_1.tryClaimLease)(this.knex, claim, now);
+    }
+    async renewLease(renew, now) {
+        return await (0, monitorLease_1.renewLease)(this.knex, renew, now);
+    }
+    async releaseLease(release) {
+        return await (0, monitorLease_1.releaseLease)(this.knex, release);
+    }
+    // -----------------------
+    // Net-new methods (§3)
+    // -----------------------
+    /**
+     * #1 — Look up an action + its backing transaction by (userId, reference).
+     */
+    async findActionByReference(userId, reference) {
+        const actionRow = await this.knex('actions').where({ userId, reference }).first();
+        if (actionRow == null)
+            return undefined;
+        const action = (0, transactionCrud_1.mapActionRow)(actionRow);
+        const tx = await this.findById(action.transactionId);
+        if (tx == null)
+            return undefined;
+        return { action, transaction: tx };
+    }
+    /**
+     * #2 — Look up an action + its backing transaction by (userId, txid).
+     */
+    async findActionByUserTxid(userId, txid) {
+        const txRow = await this.knex('transactions').where({ txid }).first();
+        if (txRow == null)
+            return undefined;
+        const tx = (0, transactionCrud_1.mapTransactionRow)(txRow);
+        const actionRow = await this.knex('actions')
+            .where({ userId, transactionId: tx.transactionId })
+            .first();
+        if (actionRow == null)
+            return undefined;
+        return { action: (0, transactionCrud_1.mapActionRow)(actionRow), transaction: tx };
+    }
+    /**
+     * #3 — Upsert: find existing action for (userId, txid) or create both the new
+     * transaction row and the action row.
+     */
+    async findOrCreateActionForTxid(args) {
+        var _a, _b;
+        const now = (_a = args.now) !== null && _a !== void 0 ? _a : new Date();
+        // Try to find existing transaction
+        let tx = await this.findByTxid(args.txid);
+        let isNew = false;
+        if (tx == null) {
+            tx = await this.create({
+                txid: args.txid,
+                processing: (_b = args.processing) !== null && _b !== void 0 ? _b : 'queued',
+                rawTx: args.rawTx,
+                inputBeef: args.inputBeef,
+                now
+            });
+            isNew = true;
+        }
+        else {
+            // Patch rawTx / inputBeef if the caller is supplying them for the first time.
+            const patches = { updated_at: now };
+            if (args.rawTx != null && tx.rawTx == null)
+                patches.raw_tx = Buffer.from(args.rawTx);
+            if (args.inputBeef != null && tx.inputBeef == null)
+                patches.input_beef = Buffer.from(args.inputBeef);
+            if (Object.keys(patches).length > 1) {
+                await this.knex('transactions').where({ transactionId: tx.transactionId }).update(patches);
+                const refreshed = await this.findById(tx.transactionId);
+                if (refreshed != null)
+                    tx = refreshed;
+            }
+        }
+        // Find or create the action for this user.
+        let actionRow = await this.knex('actions')
+            .where({ userId: args.userId, transactionId: tx.transactionId })
+            .first();
+        if (actionRow == null) {
+            await (0, transactionCrud_1.insertAction)(this.knex, {
+                userId: args.userId,
+                transactionId: tx.transactionId,
+                reference: args.reference,
+                description: args.description,
+                isOutgoing: args.isOutgoing,
+                satoshisDelta: args.satoshisDelta,
+                userNosend: false,
+                hidden: false,
+                userAborted: false,
+                rowVersion: 0
+            }, now);
+            actionRow = await this.knex('actions')
+                .where({ userId: args.userId, transactionId: tx.transactionId })
+                .first();
+            isNew = true;
+        }
+        return { action: (0, transactionCrud_1.mapActionRow)(actionRow), transaction: tx, isNew };
+    }
+    /**
+     * #4 — Atomically update the satoshisDelta column on an action row.
+     */
+    async updateActionSatoshisDelta(actionId, delta, now) {
+        await this.knex('actions')
+            .where({ actionId })
+            .update({ satoshis_delta: delta, updated_at: now !== null && now !== void 0 ? now : new Date() });
+    }
+    /**
+     * #5 — Create a new transaction row already in `confirmed` state with all proof
+     * columns populated. Useful for internalised transactions that arrive with a
+     * Merkle proof (bump) already attached.
+     */
+    async createWithProof(args) {
+        var _a;
+        const now = (_a = args.now) !== null && _a !== void 0 ? _a : new Date();
+        const merkleIndex = indexFromMerklePath(args.merklePath, args.txid);
+        const row = {
+            txid: args.txid,
+            processing: 'confirmed',
+            processingChangedAt: now,
+            nextActionAt: undefined,
+            attempts: 0,
+            rebroadcastCycles: 0,
+            wasBroadcast: true,
+            idempotencyKey: undefined,
+            batch: undefined,
+            rawTx: args.rawTx,
+            inputBeef: args.inputBeef,
+            height: args.height,
+            merkleIndex,
+            merklePath: args.merklePath,
+            merkleRoot: args.merkleRoot,
+            blockHash: args.blockHash,
+            isCoinbase: args.isCoinbase === true,
+            lastProvider: undefined,
+            lastProviderStatus: undefined,
+            frozenReason: undefined,
+            rowVersion: 0
+        };
+        const id = await (0, transactionCrud_1.insertTransactionNew)(this.knex, row, now);
+        await (0, txAudit_1.auditProcessingTransition)(this.knex, id, 'confirmed', 'confirmed', { reason: 'createWithProof' }, now);
+        const stored = await this.findById(id);
+        if (stored == null)
+            throw new Error(`new transaction ${id} disappeared after createWithProof insert`);
+        return stored;
+    }
+    /**
+     * #6 — Find an existing new transaction row for the given txid (suitable for
+     * the broadcast queue) or create a new one in `queued` state.
+     */
+    async findOrCreateForBroadcast(args) {
+        var _a, _b;
+        const existing = await this.findByTxid(args.txid);
+        if (existing != null) {
+            // Patch rawTx / batch if the row was previously created without them.
+            const patches = { updated_at: (_a = args.now) !== null && _a !== void 0 ? _a : new Date() };
+            if (existing.rawTx == null)
+                patches.raw_tx = Buffer.from(args.rawTx);
+            if (args.inputBeef != null && existing.inputBeef == null)
+                patches.input_beef = Buffer.from(args.inputBeef);
+            if (args.batch != null && existing.batch == null)
+                patches.batch = args.batch;
+            if (Object.keys(patches).length > 1) {
+                await this.knex('transactions').where({ transactionId: existing.transactionId }).update(patches);
+                const refreshed = await this.findById(existing.transactionId);
+                return { transaction: refreshed !== null && refreshed !== void 0 ? refreshed : existing, isNew: false };
+            }
+            return { transaction: existing, isNew: false };
+        }
+        const tx = await this.create({
+            txid: args.txid,
+            processing: (_b = args.processing) !== null && _b !== void 0 ? _b : 'queued',
+            rawTx: args.rawTx,
+            inputBeef: args.inputBeef,
+            batch: args.batch,
+            now: args.now
+        });
+        return { transaction: tx, isNew: true };
+    }
+    /**
+     * #7 — Bulk transition: attempt `transition` for each id; collect results.
+     * When `expectedFrom` is omitted the current state of each row is used as
+     * the expected source (lenient mode — only the FSM is checked).
+     */
+    async transitionMany(args) {
+        var _a;
+        const updated = [];
+        const skipped = [];
+        const now = (_a = args.now) !== null && _a !== void 0 ? _a : new Date();
+        for (const id of args.transactionIds) {
+            let expectedFrom = args.expectedFrom;
+            if (expectedFrom == null) {
+                const row = await this.findById(id);
+                if (row == null) {
+                    skipped.push(id);
+                    continue;
+                }
+                expectedFrom = row.processing;
+            }
+            const result = await this.transition({
+                transactionId: id,
+                expectedFrom,
+                to: args.to,
+                provider: args.provider,
+                providerStatus: args.providerStatus,
+                details: args.details,
+                now
+            });
+            if (result != null) {
+                updated.push(id);
+            }
+            else {
+                skipped.push(id);
+            }
+        }
+        return { updated, skipped };
+    }
+    /**
+     * #8 — Bulk-set the `batch` column for a list of transaction ids.
+     * Pass `undefined` to clear the batch tag.
+     */
+    async setBatch(transactionIds, batch, now) {
+        if (transactionIds.length === 0)
+            return;
+        await this.knex('transactions')
+            .whereIn('transactionId', transactionIds)
+            .update({ batch: batch !== null && batch !== void 0 ? batch : null, updated_at: now !== null && now !== void 0 ? now : new Date() });
+    }
+    /**
+     * #9 — Atomically increment the `attempts` counter for one transaction and
+     * write an `attempts.incremented` audit entry.
+     */
+    async incrementAttempts(transactionId, now) {
+        const ts = now !== null && now !== void 0 ? now : new Date();
+        const updated = await this.knex('transactions')
+            .where({ transactionId })
+            .increment('attempts', 1)
+            .update({ updated_at: ts });
+        if (updated === 0)
+            return undefined;
+        await (0, txAudit_1.appendTxAudit)(this.knex, { transactionId, event: 'attempts.incremented' }, ts);
+        return await this.findById(transactionId);
+    }
+    /**
+     * #10 — Record the outcome of a broadcast attempt. Transitions processing
+     * state, updates `wasBroadcast` and `lastProvider*` columns, and writes an
+     * audit row.
+     */
+    async recordBroadcastResult(args) {
+        var _a;
+        const now = (_a = args.now) !== null && _a !== void 0 ? _a : new Date();
+        const current = await this.findById(args.transactionId);
+        if (current == null)
+            return undefined;
+        const next = await this.transition({
+            transactionId: args.transactionId,
+            expectedFrom: current.processing,
+            to: args.status,
+            provider: args.provider,
+            providerStatus: args.providerStatus,
+            details: args.details,
+            now
+        });
+        if (next == null)
+            return undefined;
+        // Update wasBroadcast if the broadcast actually reached the network.
+        if (args.wasBroadcast === true && !next.wasBroadcast) {
+            await this.knex('transactions')
+                .where({ transactionId: args.transactionId })
+                .update({ was_broadcast: true, updated_at: now });
+        }
+        return await this.findById(args.transactionId);
+    }
+    /**
+     * #11 — Append a free-form history note to the audit log for a transaction.
+     */
+    async recordHistoryNote(transactionId, note, now) {
+        const { what, ...rest } = note;
+        await (0, txAudit_1.appendTxAudit)(this.knex, {
+            transactionId,
+            event: 'history.note',
+            details: { what, ...rest }
+        }, now !== null && now !== void 0 ? now : new Date());
+    }
+    /**
+     * #12 — For each txid that exists in the new transactions table, merge the
+     * raw transaction bytes and (where available) the Merkle path into `beef`.
+     * Txids not present in new-schema are silently skipped.
+     */
+    async mergeBeefForTxids(beef, txids) {
+        if (txids.length === 0)
+            return;
+        const rows = await this.knex('transactions')
+            .whereIn('txid', txids)
+            .select('txid', 'raw_tx', 'merkle_path');
+        for (const row of rows) {
+            if (row.raw_tx != null) {
+                const rawBytes = Array.from(row.raw_tx.values());
+                beef.mergeRawTx(rawBytes);
+            }
+            if (row.merkle_path != null) {
+                const mp = sdk_1.MerklePath.fromBinary(Array.from(row.merkle_path.values()));
+                beef.mergeBump(mp);
+            }
+        }
+    }
+    /**
+     * #13 — Collect broadcast-readiness info and a populated Beef for a list of
+     * txids. Each entry is classified as:
+     *  - `readyToSend`  — queued/sending → still needs broadcast
+     *  - `alreadySent`  — sent/seen/seen_multi/unconfirmed/confirmed → already on network
+     *  - `error`        — invalid/doubleSpend → terminal failure
+     *  - `unknown`      — not found in new-schema
+     */
+    async collectReqsAndBeef(txids, extraTxids) {
+        const beef = new sdk_1.Beef();
+        const details = [];
+        const allTxids = Array.from(new Set([...txids, ...(extraTxids !== null && extraTxids !== void 0 ? extraTxids : [])]));
+        if (allTxids.length > 0) {
+            const rows = await this.knex('transactions')
+                .whereIn('txid', allTxids)
+                .select('txid', 'processing', 'raw_tx', 'merkle_path');
+            const rowByTxid = new Map();
+            for (const row of rows)
+                rowByTxid.set(row.txid, row);
+            for (const txid of txids) {
+                const row = rowByTxid.get(txid);
+                if (row == null) {
+                    details.push({ txid, status: 'unknown' });
+                    continue;
+                }
+                const p = row.processing;
+                let status;
+                if (p === 'queued' || p === 'sending' || p === 'nonfinal') {
+                    status = 'readyToSend';
+                }
+                else if (p === 'sent' || p === 'seen' || p === 'seen_multi' || p === 'unconfirmed' || p === 'confirmed') {
+                    status = 'alreadySent';
+                }
+                else if (p === 'invalid' || p === 'doubleSpend') {
+                    status = 'error';
+                }
+                else {
+                    status = 'readyToSend';
+                }
+                details.push({ txid, status, reason: p });
+                // Merge raw tx + proof bytes for txids that have them.
+                if (row.raw_tx != null) {
+                    beef.mergeRawTx(Array.from(row.raw_tx.values()));
+                }
+                if (row.merkle_path != null) {
+                    const mp = sdk_1.MerklePath.fromBinary(Array.from(row.merkle_path.values()));
+                    beef.mergeBump(mp);
+                }
+            }
+            // Also merge extra txids that may be input ancestors.
+            for (const txid of extraTxids !== null && extraTxids !== void 0 ? extraTxids : []) {
+                const row = rowByTxid.get(txid);
+                if (row == null)
+                    continue;
+                if (row.raw_tx != null) {
+                    beef.mergeRawTx(Array.from(row.raw_tx.values()));
+                }
+                if (row.merkle_path != null) {
+                    const mp = sdk_1.MerklePath.fromBinary(Array.from(row.merkle_path.values()));
+                    beef.mergeBump(mp);
+                }
+            }
+        }
+        return { beef, details };
+    }
+    /**
+     * #14 — Paginated list of actions (per-user transaction views) with optional
+     * status and label filters.
+     *
+     * After the the schema cutover `tx_labels_map.transactionId` references `actions.actionId`
+     * (not `transactions.transactionId`).
+     */
+    async listActionsForUser(args) {
+        let q = this.knex('actions as a')
+            .join('transactions as t', 't.transactionId', 'a.transactionId')
+            .where('a.userId', args.userId)
+            .where('a.hidden', false);
+        if (args.statusFilter != null && args.statusFilter.length > 0) {
+            q = q.whereIn('t.processing', args.statusFilter);
+        }
+        if (args.createdAtFrom != null) {
+            // IDB path uses >= for `from` (inclusive); mirror that here.
+            q = q.where('a.created_at', '>=', args.createdAtFrom);
+        }
+        if (args.createdAtTo != null) {
+            // IDB path uses EXCLUSIVE `to` semantics:
+            //   r.created_at.getTime() >= args.to.getTime() → exclude
+            // Mirror that: exclude rows where created_at >= createdAtTo (use '<' not '<=').
+            q = q.where('a.created_at', '<', args.createdAtTo);
+        }
+        // Label filtering via tx_labels_map (post-cutover: transactionId = actionId)
+        if (args.labelIds != null && args.labelIds.length > 0) {
+            if (args.labelQueryMode === 'all') {
+                // Must have ALL specified labels
+                for (const labelId of args.labelIds) {
+                    q = q.whereExists(this.knex('tx_labels_map as lm')
+                        .where('lm.transactionId', this.knex.ref('a.actionId'))
+                        .where('lm.txLabelId', labelId)
+                        .whereNot('lm.isDeleted', true)
+                        .select(this.knex.raw('1')));
+                }
+            }
+            else {
+                // Default: 'any' — must have at least one of the labels
+                q = q.whereExists(this.knex('tx_labels_map as lm')
+                    .where('lm.transactionId', this.knex.ref('a.actionId'))
+                    .whereIn('lm.txLabelId', args.labelIds)
+                    .whereNot('lm.isDeleted', true)
+                    .select(this.knex.raw('1')));
+            }
+        }
+        const countRow = await q.clone().count({ c: 'a.actionId' }).first();
+        const total = countRow != null ? Number(countRow.c) : undefined;
+        const rows = await q
+            .orderBy('a.created_at', 'desc')
+            .orderBy('a.actionId', 'asc')
+            .limit(args.limit)
+            .offset(args.offset)
+            .select('a.actionId', 'a.userId', 'a.transactionId', 'a.reference', 'a.description', 'a.isOutgoing', 'a.satoshis_delta', 'a.user_nosend', 'a.hidden', 'a.user_aborted', 'a.notify_json', 'a.row_version', 'a.created_at', 'a.updated_at', 't.txid', 't.processing', 't.height');
+        const mapped = rows.map((row) => {
+            var _a, _b;
+            return ({
+                actionId: row.actionId,
+                userId: row.userId,
+                transactionId: row.transactionId,
+                reference: row.reference,
+                description: row.description,
+                isOutgoing: !!row.isOutgoing,
+                satoshisDelta: row.satoshis_delta,
+                userNosend: !!row.user_nosend,
+                hidden: !!row.hidden,
+                userAborted: !!row.user_aborted,
+                notifyJson: (_a = row.notify_json) !== null && _a !== void 0 ? _a : undefined,
+                rowVersion: row.row_version,
+                created_at: new Date(row.created_at),
+                updated_at: new Date(row.updated_at),
+                txid: row.txid,
+                processing: row.processing,
+                height: (_b = row.height) !== null && _b !== void 0 ? _b : undefined
+            });
+        });
+        return { rows: mapped, total };
+    }
+    /**
+     * #15 — Paginated list of outputs with their backing transaction processing
+     * state. Optional filters: basket, tag set, processing state, spent flag.
+     */
+    async listOutputsForUser(args) {
+        let q = this.knex('outputs as o')
+            .join('transactions as t', 't.transactionId', 'o.transactionId')
+            .where('o.userId', args.userId);
+        if (args.processingFilter.length > 0) {
+            q = q.whereIn('t.processing', args.processingFilter);
+        }
+        if (!args.includeSpent) {
+            q = q.whereNull('o.spentBy');
+        }
+        if (args.basketId != null) {
+            q = q.where('o.basketId', args.basketId);
+        }
+        // Tag filtering via output_tags_map
+        if (args.tagIds != null && args.tagIds.length > 0) {
+            if (args.tagQueryMode === 'all') {
+                for (const tagId of args.tagIds) {
+                    q = q.whereExists(this.knex('output_tags_map as otm')
+                        .where('otm.outputId', this.knex.ref('o.outputId'))
+                        .where('otm.outputTagId', tagId)
+                        .whereNot('otm.isDeleted', true)
+                        .select(this.knex.raw('1')));
+                }
+            }
+            else {
+                q = q.whereExists(this.knex('output_tags_map as otm')
+                    .where('otm.outputId', this.knex.ref('o.outputId'))
+                    .whereIn('otm.outputTagId', args.tagIds)
+                    .whereNot('otm.isDeleted', true)
+                    .select(this.knex.raw('1')));
+            }
+        }
+        const countRow = await q.clone().count({ c: 'o.outputId' }).first();
+        const total = countRow != null ? Number(countRow.c) : undefined;
+        const columns = [
+            'o.outputId',
+            'o.userId',
+            'o.transactionId',
+            'o.basketId',
+            'o.spendable',
+            'o.change',
+            'o.outputDescription',
+            'o.vout',
+            'o.satoshis',
+            'o.providedBy',
+            'o.purpose',
+            'o.type',
+            'o.txid',
+            'o.senderIdentityKey',
+            'o.derivationPrefix',
+            'o.derivationSuffix',
+            'o.customInstructions',
+            'o.spentBy',
+            'o.sequenceNumber',
+            'o.spendingDescription',
+            'o.scriptLength',
+            'o.scriptOffset',
+            'o.created_at',
+            'o.updated_at',
+            't.processing'
+        ];
+        if (args.includeLockingScripts === true) {
+            columns.push('o.lockingScript');
+        }
+        const rows = await q
+            .orderBy('o.outputId', 'asc')
+            .limit(args.limit)
+            .offset(args.offset)
+            .select(columns);
+        const mapped = rows.map((row) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            const out = {
+                outputId: row.outputId,
+                userId: row.userId,
+                transactionId: row.transactionId,
+                basketId: (_a = row.basketId) !== null && _a !== void 0 ? _a : undefined,
+                spendable: !!row.spendable,
+                change: !!row.change,
+                outputDescription: row.outputDescription,
+                vout: row.vout,
+                satoshis: row.satoshis,
+                providedBy: row.providedBy,
+                purpose: row.purpose,
+                type: row.type,
+                txid: (_b = row.txid) !== null && _b !== void 0 ? _b : undefined,
+                senderIdentityKey: (_c = row.senderIdentityKey) !== null && _c !== void 0 ? _c : undefined,
+                derivationPrefix: (_d = row.derivationPrefix) !== null && _d !== void 0 ? _d : undefined,
+                derivationSuffix: (_e = row.derivationSuffix) !== null && _e !== void 0 ? _e : undefined,
+                customInstructions: (_f = row.customInstructions) !== null && _f !== void 0 ? _f : undefined,
+                spentBy: (_g = row.spentBy) !== null && _g !== void 0 ? _g : undefined,
+                sequenceNumber: (_h = row.sequenceNumber) !== null && _h !== void 0 ? _h : undefined,
+                spendingDescription: (_j = row.spendingDescription) !== null && _j !== void 0 ? _j : undefined,
+                scriptLength: (_k = row.scriptLength) !== null && _k !== void 0 ? _k : undefined,
+                scriptOffset: (_l = row.scriptOffset) !== null && _l !== void 0 ? _l : undefined,
+                lockingScript: args.includeLockingScripts === true && row.lockingScript != null
+                    ? Array.from(row.lockingScript.values())
+                    : undefined,
+                created_at: new Date(row.created_at),
+                updated_at: new Date(row.updated_at),
+                processing: row.processing
+            };
+            return out;
+        });
+        return { rows: mapped, total };
+    }
+    /**
+     * Post-cutover helper: rewrite `tx_labels_map.transactionId` rows that were
+     * written with the legacy transactionId (before the real txid + actionId were
+     * known) so that they now point at the new-schema `actions.actionId`.
+     *
+     * Call this once per new outgoing transaction immediately after
+     * `findOrCreateActionForTxid` resolves the actionId.
+     *
+     * This is a no-op when:
+     *  - `legacyTransactionId` has no rows in `tx_labels_map` (no labels on the tx)
+     *  - `legacyTransactionId === actionId` (should not happen in practice but
+     *    is safe to call anyway)
+     */
+    async repointLabelsToActionId(legacyTransactionId, actionId, now) {
+        if (legacyTransactionId === actionId)
+            return;
+        const ts = now !== null && now !== void 0 ? now : new Date();
+        await this.knex('tx_labels_map')
+            .where({ transactionId: legacyTransactionId })
+            .update({ transactionId: actionId, updated_at: ts });
+    }
+    /**
+     * After `processAction` creates the new `transactions` row, remap
+     * `outputs.transactionId` and `outputs.spentBy` from the bridge-period
+     * `transactions_legacy.transactionId` to the real `transactions.transactionId`.
+     *
+     * During `createAction`, new outputs are inserted with `transactionId =
+     * legacyTransactionId` (bypassing FK constraints). `listActionsKnex` queries
+     * outputs by new transactionId, so without this remap the outputs would be
+     * invisible to `listActions`.
+     *
+     * This is a no-op when `legacyTransactionId === newTransactionId`.
+     */
+    async repointOutputsToNewTransactionId(legacyTransactionId, newTransactionId, now) {
+        if (legacyTransactionId === newTransactionId)
+            return;
+        const ts = now !== null && now !== void 0 ? now : new Date();
+        // Remap outputs.transactionId (the new-schema FK for "which tx created this output")
+        await this.knex('outputs')
+            .where({ transactionId: legacyTransactionId })
+            .update({ transactionId: newTransactionId, updated_at: ts });
+        // Remap outputs.spentBy (the new-schema FK for "which tx spent this output")
+        await this.knex('outputs')
+            .where({ spentBy: legacyTransactionId })
+            .update({ spentBy: newTransactionId, updated_at: ts });
+        // Remap commissions.transactionId
+        await this.knex('commissions')
+            .where({ transactionId: legacyTransactionId })
+            .update({ transactionId: newTransactionId, updated_at: ts });
+    }
+}
+exports.TransactionService = TransactionService;
+//# sourceMappingURL=transactionService.js.map