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

package/out/src/storage/StorageProvider.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageProvider = void 0;
 exports.validateStorageFeeModel = validateStorageFeeModel;
 const sdk_1 = require("@bsv/sdk");
+const storageProviderHelpers_1 = require("./storageProviderHelpers");
 const getBeefForTransaction_1 = require("./methods/getBeefForTransaction");
 const processAction_1 = require("./methods/processAction");
 const attemptToPostReqsToNetwork_1 = require("./methods/attemptToPostReqsToNetwork");
@@ -50,7 +51,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
     async findStaleMerkleRoots(args) {
         let provenTxs = await this.findProvenTxs({ partial: { height: args.height } });
         provenTxs = provenTxs.filter(ptx => ptx.merkleRoot !== args.merkleRoot);
-        let roots = Array.from(new Set(provenTxs.map(ptx => ptx.merkleRoot)));
+        const roots = Array.from(new Set(provenTxs.map(ptx => ptx.merkleRoot)));
         return roots;
     }
     async findOutputsByOutpoints(userId, outpoints, trx) {
@@ -98,7 +99,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
                 continue;
             const createdAt = this.validateDate(output.created_at);
             const prior = latestByUserId.get(output.userId);
-            if (!prior || createdAt > prior) {
+            if ((prior == null) || createdAt > prior) {
                 latestByUserId.set(output.userId, createdAt);
             }
         }
@@ -106,8 +107,8 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
             .sort((a, b) => b[1].getTime() - a[1].getTime())
             .slice(0, limit)
             .map(([userId]) => userId);
-        const users = await Promise.all(sortedUserIds.map(userId => this.findUserById(userId, trx)));
-        return users.filter((user) => !!user);
+        const users = await Promise.all(sortedUserIds.map(async (userId) => await this.findUserById(userId, trx)));
+        return users.filter((user) => user != null);
     }
     isStorageProvider() {
         return true;
@@ -116,39 +117,194 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
         this._services = v;
     }
     getServices() {
-        if (!this._services)
+        if (this._services == null)
             throw new WERR_errors_1.WERR_INVALID_OPERATION('Must setServices first.');
         return this._services;
     }
+    /**
+     * Returns a TransactionService instance if this storage provider supports
+     * the the new schema (i.e. has a Knex handle). Returns undefined for providers
+     * that do not support the new schema layer (e.g. StorageIdb).
+     *
+     * StorageKnex overrides this to return `new TransactionService(this.knex)`.
+     */
+    getTransactionService() {
+        return undefined;
+    }
+    /**
+     * Insert a legacy-shaped transaction row.
+     *
+     * Post-cutover: writes into `transactions_legacy` (the renamed legacy table)
+     * so that `createAction` can still store unsigned rows before the real txid is
+     * known, without touching the new `transactions` table (which requires a non-null txid).
+     *
+     * Pre-cutover (or on providers that do not support the the new schema): falls back
+     * to the standard `insertTransaction` which targets the `transactions` table.
+     *
+     * StorageKnex overrides this to route to `transactions_legacy` when the table
+     * exists, otherwise falls through to the standard `transactions` insert.
+     */
+    async insertLegacyTransaction(tx, trx) {
+        return await this.insertTransaction(tx, trx);
+    }
+    /**
+     * Insert a `tx_labels_map` row for a legacy transaction that does not yet
+     * have a `actions.actionId`.
+     *
+     * Post-cutover the `tx_labels_map.transactionId` column has a FK to
+     * `actions.actionId`. When `createAction` writes labels against a legacy
+     * transactionId (before processAction creates the actions row), the FK
+     * cannot be satisfied. This shim bypasses that constraint temporarily.
+     * `processAction` later rewrites the rows to the real actionId via
+     * `TransactionService.repointLabelsToActionId`.
+     *
+     * Pre-cutover: delegates to `insertTxLabelMap` with no FK bypass needed.
+     *
+     * StorageKnex overrides this to temporarily disable FK checks on SQLite
+     * when `transactions_legacy` is present (indicating post-cutover).
+     */
+    async insertLegacyTxLabelMap(labelMap, trx) {
+        return await this.insertTxLabelMap(labelMap, trx);
+    }
+    /**
+     * Find-or-insert a `tx_labels_map` row using `insertLegacyTxLabelMap` so
+     * that post-cutover FK constraints are bypassed for new unsigned transactions.
+     *
+     * Mirrors the logic of `findOrInsertTxLabelMap` (StorageReaderWriter) but
+     * delegates the insert step to `insertLegacyTxLabelMap`.
+     */
+    async findOrInsertLegacyTxLabelMap(transactionId, txLabelId, trx) {
+        const partial = { transactionId, txLabelId };
+        for (let retry = 0;; retry++) {
+            try {
+                const now = new Date();
+                let txLabelMap = (0, utilityHelpers_1.verifyOneOrNone)(await this.findTxLabelMaps({ partial, trx }));
+                if (txLabelMap == null) {
+                    txLabelMap = {
+                        ...partial,
+                        created_at: now,
+                        updated_at: now,
+                        isDeleted: false
+                    };
+                    await this.insertLegacyTxLabelMap(txLabelMap, trx);
+                }
+                if (txLabelMap.isDeleted) {
+                    await this.updateTxLabelMap(transactionId, txLabelId, { isDeleted: false });
+                }
+                return txLabelMap;
+            }
+            catch (error_) {
+                if (retry > 0)
+                    throw error_;
+            }
+        }
+    }
+    /**
+     * Find legacy-shaped transaction rows from the appropriate table.
+     *
+     * Post-cutover: queries `transactions_legacy` (the renamed legacy schema
+     * table that holds unsigned/unprocessed rows without a real txid).
+     * Pre-cutover (or on providers that do not support the the new schema): falls back
+     * to the standard `findTransactions` which targets the `transactions` table.
+     *
+     * Used by `processAction.validateCommitNewTxToStorageArgs` to locate the
+     * unsigned transaction row created by `createAction` via `insertLegacyTransaction`.
+     *
+     * StorageKnex overrides this to route to `transactions_legacy` when the
+     * table exists (post-cutover), otherwise falls through to `findTransactions`.
+     */
+    async findLegacyTransactions(args) {
+        return await this.findTransactions(args);
+    }
+    /**
+     * Update a legacy-shaped transaction row in the appropriate table.
+     *
+     * Post-cutover: updates `transactions_legacy` (where unsigned rows live).
+     * Pre-cutover: delegates to the standard `updateTransaction`.
+     *
+     * Used by `processAction.commitNewTxToStorage` to write back the final txid
+     * and status to the legacy row that was created by `createAction`.
+     *
+     * StorageKnex overrides this to route to `transactions_legacy` when the
+     * table exists (post-cutover), otherwise falls through to `updateTransaction`.
+     */
+    async updateLegacyTransaction(id, update, trx) {
+        return await this.updateTransaction(id, update, trx);
+    }
+    /**
+     * Mark an output as spent by a (potentially legacy) transaction.
+     *
+     * Post-cutover on SQLite: setting `outputs.spentBy = legacyTransactionId`
+     * violates the FK `outputs.spentBy → transactions.transactionId` because
+     * unsigned transactions created by `createAction` live in `transactions_legacy`.
+     * This method disables the FK constraint for the duration of the update.
+     * The constraint will be satisfied once `processAction` creates the new schema row and
+     * the bridge-period is complete.
+     *
+     * Pre-cutover: delegates to `updateOutput` with no FK bypass.
+     *
+     * StorageKnex overrides this to toggle `PRAGMA foreign_keys` around the UPDATE
+     * when `isPostCutover()` and the dbtype is `SQLite`.
+     *
+     * Mapping §2: bridge-period `outputs.spentBy` temporarily references
+     * `transactions_legacy.transactionId` during `createAction`; new-schema FK is bypassed.
+     */
+    async markOutputAsSpentBy(outputId, update, trx) {
+        await this.updateOutput(outputId, update, trx);
+    }
+    /**
+     * Disable FK enforcement on the underlying database connection.
+     *
+     * No-op on non-SQLite or pre-cutover databases. On post-cutover SQLite,
+     * `StorageKnex` overrides this to run `PRAGMA foreign_keys = OFF` on the
+     * bare knex connection BEFORE a transaction is opened (since PRAGMA changes
+     * inside SQLite transactions are silently ignored).
+     *
+     * Must be paired with a `enableForeignKeys()` call in a finally block.
+     */
+    async disableForeignKeys() {
+        // no-op by default (non-SQLite or pre-cutover)
+    }
+    /**
+     * Re-enable FK enforcement on the underlying database connection.
+     * Counterpart to `disableForeignKeys()`.
+     */
+    async enableForeignKeys() {
+        // no-op by default
+    }
     async abortAction(auth, args) {
         if (!auth.userId)
             throw new WERR_errors_1.WERR_INVALID_PARAMETER('auth.userId', 'valid');
         const userId = auth.userId;
         let reference = args.reference;
-        let txid = undefined;
+        let txid;
         const r = await this.transaction(async (trx) => {
-            let tx = (0, utilityHelpers_1.verifyOneOrNone)(await this.findTransactions({
+            // Post-cutover: unsigned/unprocessed rows live in transactions_legacy.
+            // findLegacyTransactions routes to the correct table.
+            // Mapping §2: legacy `unsigned` → no equivalent in new schema; must check transactions_legacy.
+            let tx = (0, utilityHelpers_1.verifyOneOrNone)(await this.findLegacyTransactions({
                 partial: { reference, userId },
                 noRawTx: true,
                 trx
             }));
-            if (!tx && args.reference.length === 64) {
+            if ((tx == null) && args.reference.length === 64) {
                 // reference may also be a txid
                 txid = reference;
                 reference = undefined;
-                tx = (0, utilityHelpers_1.verifyOneOrNone)(await this.findTransactions({
+                tx = (0, utilityHelpers_1.verifyOneOrNone)(await this.findLegacyTransactions({
                     partial: { txid, userId },
                     noRawTx: true,
                     trx
                 }));
             }
             const unAbortableStatus = ['completed', 'failed', 'sending', 'unproven'];
-            if (!tx || !tx.isOutgoing || -1 < unAbortableStatus.findIndex(s => s === tx.status))
+            if ((tx == null) || !tx.isOutgoing || unAbortableStatus.findIndex(s => s === tx.status) > -1) {
                 throw new WERR_errors_1.WERR_INVALID_PARAMETER('reference', 'an inprocess, outgoing action that has not been signed and shared to the network.');
+            }
             await this.updateTransactionStatus('failed', tx.transactionId, userId, reference, trx);
             if (tx.txid) {
                 const req = await entities_1.EntityProvenTxReq.fromStorageTxid(this, tx.txid, trx);
-                if (req) {
+                if (req != null) {
                     req.addHistoryNote({ what: 'abortAction', reference: args.reference });
                     req.status = 'invalid';
                     await req.updateStorageDynamicProperties(this, trx);
@@ -190,43 +346,24 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
             r.details.push(d);
             try {
                 d.proven = (0, utilityHelpers_1.verifyOneOrNone)(await this.findProvenTxs({ partial: { txid }, trx }));
-                if (d.proven)
+                if (d.proven != null) {
                     d.status = 'alreadySent';
+                    continue;
+                }
+                d.req = (0, utilityHelpers_1.verifyOneOrNone)(await this.findProvenTxReqs({ partial: { txid }, trx }));
+                if (d.req == null) {
+                    d.status = 'error';
+                    d.error = `ERR_UNKNOWN_TXID: ${txid} was not found.`;
+                }
                 else {
-                    const alreadySentStatus = ['unmined', 'callback', 'unconfirmed', 'completed'];
-                    const readyToSendStatus = ['sending', 'unsent', 'nosend', 'unprocessed'];
-                    const errorStatus = ['unknown', 'nonfinal', 'invalid', 'doubleSpend'];
-                    d.req = (0, utilityHelpers_1.verifyOneOrNone)(await this.findProvenTxReqs({ partial: { txid }, trx }));
-                    if (!d.req) {
-                        d.status = 'error';
-                        d.error = `ERR_UNKNOWN_TXID: ${txid} was not found.`;
-                    }
-                    else if (errorStatus.indexOf(d.req.status) > -1) {
-                        d.status = 'error';
-                        d.error = `ERR_INVALID_PARAMETER: ${txid} is not ready to send.`;
-                    }
-                    else if (alreadySentStatus.indexOf(d.req.status) > -1) {
-                        d.status = 'alreadySent';
-                    }
-                    else if (readyToSendStatus.indexOf(d.req.status) > -1) {
-                        if (!d.req.rawTx || !d.req.inputBEEF) {
-                            d.status = 'error';
-                            d.error = `ERR_INTERNAL: ${txid} req is missing rawTx or beef.`;
-                        }
-                        else
-                            d.status = 'readyToSend';
-                    }
-                    else {
-                        d.status = 'error';
-                        d.error = `ERR_INTERNAL: ${txid} has unexpected req status ${d.req.status}`;
-                    }
-                    if (d.status === 'readyToSend') {
-                        await this.mergeReqToBeefToShareExternally(d.req, r.beef, knownTxids, trx);
-                    }
+                    (0, storageProviderHelpers_1.classifyReqStatus)(d, d.req);
+                }
+                if (d.status === 'readyToSend') {
+                    await this.mergeReqToBeefToShareExternally(d.req, r.beef, knownTxids, trx);
                 }
             }
-            catch (eu) {
-                const e = WalletError_1.WalletError.fromUnknown(eu);
+            catch (error_) {
+                const e = WalletError_1.WalletError.fromUnknown(error_);
                 d.error = `${e.name}: ${e.message}`;
             }
         }
@@ -234,23 +371,11 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
     }
     async mergeReqToBeefToShareExternally(req, mergeToBeef, knownTxids, trx) {
         const { rawTx, inputBEEF: beef } = req;
-        if (!rawTx || !beef)
-            throw new WERR_errors_1.WERR_INTERNAL(`req rawTx and beef must be valid.`);
+        if (!rawTx || (beef == null))
+            throw new WERR_errors_1.WERR_INTERNAL('req rawTx and beef must be valid.');
         mergeToBeef.mergeRawTx((0, utilityHelpers_noBuffer_1.asArray)(rawTx));
         mergeToBeef.mergeBeef((0, utilityHelpers_noBuffer_1.asArray)(beef));
-        const tx = sdk_1.Transaction.fromBinary((0, utilityHelpers_noBuffer_1.asArray)(rawTx));
-        for (const input of tx.inputs) {
-            if (!input.sourceTXID)
-                throw new WERR_errors_1.WERR_INTERNAL(`req all transaction inputs must have valid sourceTXID`);
-            const txid = input.sourceTXID;
-            const btx = mergeToBeef.findTxid(txid);
-            if (!btx) {
-                if (knownTxids && knownTxids.indexOf(txid) > -1)
-                    mergeToBeef.mergeTxidOnly(txid);
-                else
-                    await this.getValidBeefForKnownTxid(txid, mergeToBeef, undefined, knownTxids, trx);
-            }
-        }
+        await (0, storageProviderHelpers_1.mergeInputsIntoBeef)((0, utilityHelpers_noBuffer_1.asArray)(rawTx), mergeToBeef, knownTxids, trx, async (txid, beef, _trust, knownTxids, trx) => { await this.getValidBeefForKnownTxid(txid, beef, undefined, knownTxids, trx); });
     }
     /**
      * Checks if txid is a known valid ProvenTx and returns it if found.
@@ -266,33 +391,37 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
      * @param trx
      * @returns
      */
+    async upsertProvenTxReq(txid, newReq, trx) {
+        const existing = (0, utilityHelpers_1.verifyOneOrNone)(await this.findProvenTxReqs({ partial: { txid }, trx }));
+        if (existing == null && newReq == null)
+            return undefined;
+        if (existing == null) {
+            await this.insertProvenTxReq(newReq, trx);
+            return newReq;
+        }
+        if (newReq != null) {
+            const req1 = new entities_1.EntityProvenTxReq(existing);
+            req1.mergeHistory(newReq, undefined, true);
+            req1.mergeNotifyTransactionIds(newReq);
+            await req1.updateStorageDynamicProperties(this, trx);
+        }
+        return existing;
+    }
     async getProvenOrReq(txid, newReq, trx) {
-        if (newReq && txid !== newReq.txid)
-            throw new WERR_errors_1.WERR_INVALID_PARAMETER('newReq', `same txid`);
+        if ((newReq != null) && txid !== newReq.txid)
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('newReq', 'same txid');
         const r = { proven: undefined, req: undefined };
         r.proven = (0, utilityHelpers_1.verifyOneOrNone)(await this.findProvenTxs({ partial: { txid }, trx }));
-        if (r.proven)
+        if (r.proven != null)
             return r;
         for (let retry = 0;; retry++) {
             try {
-                r.req = (0, utilityHelpers_1.verifyOneOrNone)(await this.findProvenTxReqs({ partial: { txid }, trx }));
-                if (!r.req && !newReq)
-                    break;
-                if (!r.req && newReq) {
-                    await this.insertProvenTxReq(newReq, trx);
-                }
-                if (r.req && newReq) {
-                    // Merge history and notify into existing
-                    const req1 = new entities_1.EntityProvenTxReq(r.req);
-                    req1.mergeHistory(newReq, undefined, true);
-                    req1.mergeNotifyTransactionIds(newReq);
-                    await req1.updateStorageDynamicProperties(this, trx);
-                }
+                r.req = await this.upsertProvenTxReq(txid, newReq, trx);
                 break;
             }
-            catch (eu) {
+            catch (error_) {
                 if (retry > 0)
-                    throw eu;
+                    throw error_;
             }
         }
         return r;
@@ -316,8 +445,9 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
      * @param trx
      */
     async updateTransactionStatus(status, transactionId, userId, reference, trx) {
-        if (!transactionId && !(userId && reference))
+        if (!transactionId && !(userId && reference)) {
             throw new WERR_errors_1.WERR_MISSING_PARAMETER('either transactionId or userId and reference');
+        }
         await this.transaction(async (trx) => {
             const where = {};
             if (transactionId)
@@ -326,16 +456,23 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
                 where.userId = userId;
             if (reference)
                 where.reference = reference;
-            const tx = (0, utilityHelpers_1.verifyOne)(await this.findTransactions({ partial: where, noRawTx: true, trx }));
-            //if (tx.status === status)
+            // Post-cutover: unsigned/unprocessed rows live in transactions_legacy.
+            // findLegacyTransactions routes to transactions_legacy when post-cutover,
+            // falls back to findTransactions pre-cutover.
+            // Mapping §2: legacy `unsigned`/`unprocessed` rows only exist in
+            // transactions_legacy post-cutover; new `transactions` has `processing`.
+            const tx = (0, utilityHelpers_1.verifyOne)(await this.findLegacyTransactions({ partial: where, noRawTx: true, trx }));
+            // if (tx.status === status)
             // no change required. Assume inputs and outputs spendable and spentBy are valid for status.
-            //return
+            // return
             // Once completed, this method cannot be used to "uncomplete" transaction.
-            if ((status !== 'completed' && tx.status === 'completed') || tx.provenTxId)
+            if ((status !== 'completed' && tx.status === 'completed') || tx.provenTxId) {
                 throw new WERR_errors_1.WERR_INVALID_OPERATION('The status of a "completed" transaction cannot be changed.');
+            }
             // It is not possible to un-fail a transaction. Information is lost and not recoverable.
-            if (status !== 'failed' && tx.status === 'failed')
-                throw new WERR_errors_1.WERR_INVALID_OPERATION(`A "failed" transaction may not be un-failed by this method.`);
+            if (status !== 'failed' && tx.status === 'failed') {
+                throw new WERR_errors_1.WERR_INVALID_OPERATION('A "failed" transaction may not be un-failed by this method.');
+            }
             switch (status) {
                 case 'failed':
                     {
@@ -360,7 +497,8 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
                 default:
                     throw new WERR_errors_1.WERR_INVALID_PARAMETER('status', `not be ${status}`);
             }
-            await this.updateTransaction(tx.transactionId, { status }, trx);
+            // Post-cutover: updateLegacyTransaction routes to transactions_legacy.
+            await this.updateLegacyTransaction(tx.transactionId, { status }, trx);
         }, trx);
     }
     async createAction(auth, args) {
@@ -399,64 +537,69 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
      */
     async getValidBeefForKnownTxid(txid, mergeToBeef, trustSelf, knownTxids, trx, requiredLevels) {
         const beef = await this.getValidBeefForTxid(txid, mergeToBeef, trustSelf, knownTxids, trx, requiredLevels);
-        if (!beef)
+        if (beef == null)
             throw new WERR_errors_1.WERR_INVALID_PARAMETER('txid', `known to storage. ${txid} is not known.`);
         return beef;
     }
-    async getValidBeefForTxid(txid, mergeToBeef, trustSelf, knownTxids, trx, requiredLevels, chainTracker, skipInvalidProofs) {
-        const beef = mergeToBeef || new sdk_1.Beef();
-        const r = await this.getProvenOrRawTx(txid, trx);
-        if (r.proven) {
-            if (requiredLevels) {
+    /**
+     * Handles the proven-tx branch of getValidBeefForTxid.
+     *
+     * Returns the beef if the proof was merged and we can stop, or `undefined` to
+     * signal that the caller should fall through to the rawTx path.  May also
+     * populate `r.rawTx` so the rawTx path can proceed without re-fetching.
+     */
+    async handleProvenTxBranch(txid, r, beef, trustSelf, requiredLevels, chainTracker, skipInvalidProofs) {
+        if (requiredLevels) {
+            // Need more levels — caller should proceed via rawTx path
+            r.rawTx = r.proven.rawTx;
+            return undefined;
+        }
+        if (trustSelf === 'known') {
+            beef.mergeTxidOnly(txid);
+            return beef;
+        }
+        const mp = new entities_1.EntityProvenTx(r.proven).getMerklePath();
+        if (chainTracker != null) {
+            const root = mp.computeRoot();
+            const isValid = await chainTracker.isValidRootForHeight(root, r.proven.height);
+            if (!isValid) {
+                if (!skipInvalidProofs)
+                    throw new WERR_errors_1.WERR_INVALID_MERKLE_ROOT(r.proven.blockHash, r.proven.height, root, txid);
+                // Proof is currently invalid — recurse deeper via rawTx path
                 r.rawTx = r.proven.rawTx;
-            }
-            else {
-                if (trustSelf === 'known')
-                    beef.mergeTxidOnly(txid);
-                else {
-                    const mp = new entities_1.EntityProvenTx(r.proven).getMerklePath();
-                    if (chainTracker) {
-                        const root = mp.computeRoot();
-                        const isValid = await chainTracker.isValidRootForHeight(root, r.proven.height);
-                        if (!isValid) {
-                            if (!skipInvalidProofs) {
-                                throw new WERR_errors_1.WERR_INVALID_MERKLE_ROOT(r.proven.blockHash, r.proven.height, root, txid);
-                            }
-                            // ignore this currently invalid proof and try to recurse deeper
-                            r.rawTx = r.proven.rawTx;
-                            r.proven = undefined;
-                        }
-                    }
-                    if (r.proven) {
-                        // If we still like this proof, merge it and return
-                        beef.mergeRawTx(r.proven.rawTx);
-                        beef.mergeBump(mp);
-                        return beef;
-                    }
-                }
+                r.proven = undefined;
+                return undefined;
             }
         }
-        if (!r.rawTx)
+        // Proof is good — merge and return
+        beef.mergeRawTx(r.proven.rawTx);
+        beef.mergeBump(mp);
+        return beef;
+    }
+    async getValidBeefForTxid(txid, mergeToBeef, trustSelf, knownTxids, trx, requiredLevels, chainTracker, skipInvalidProofs) {
+        const beef = mergeToBeef !== null && mergeToBeef !== void 0 ? mergeToBeef : new sdk_1.Beef();
+        const r = await this.getProvenOrRawTx(txid, trx);
+        // --- proven-tx path ---
+        if (r.proven != null) {
+            const result = await this.handleProvenTxBranch(txid, r, beef, trustSelf, requiredLevels, chainTracker, skipInvalidProofs);
+            if (result != null || r.rawTx == null)
+                return result;
+        }
+        // --- rawTx path ---
+        if (r.rawTx == null)
             return undefined;
         if (trustSelf === 'known') {
             beef.mergeTxidOnly(txid);
         }
         else {
             beef.mergeRawTx(r.rawTx);
-            if (r.inputBEEF)
+            if (r.inputBEEF != null)
                 beef.mergeBeef(r.inputBEEF);
-            const tx = sdk_1.Transaction.fromBinary(r.rawTx);
             if (requiredLevels)
                 requiredLevels--;
-            for (const input of tx.inputs) {
-                const btx = beef.findTxid(input.sourceTXID);
-                if (!btx) {
-                    if (!requiredLevels && knownTxids && knownTxids.indexOf(input.sourceTXID) > -1)
-                        beef.mergeTxidOnly(input.sourceTXID);
-                    else
-                        await this.getValidBeefForKnownTxid(input.sourceTXID, beef, trustSelf, knownTxids, trx, requiredLevels);
-                }
-            }
+            await (0, storageProviderHelpers_1.mergeInputBeefs)(r.rawTx, beef, trustSelf, knownTxids, trx, requiredLevels, async (sourceTXID, beef, trustSelf, knownTxids, trx, requiredLevels) => {
+                await this.getValidBeefForKnownTxid(sourceTXID, beef, trustSelf, knownTxids, trx, requiredLevels);
+            });
         }
         return beef;
     }
@@ -511,6 +654,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
      * Alterations of "typically" to handle:
      */
     async updateProvenTxReqWithNewProvenTx(args) {
+        var _a;
         const req = await entities_1.EntityProvenTxReq.fromStorageId(this, args.provenTxReqId);
         let proven;
         if (req.provenTxId) {
@@ -542,24 +686,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
                 return { proven, isNew };
             }));
             if (isNew) {
-                const ids = req.notify.transactionIds || [];
-                if (ids.length > 0) {
-                    for (const id of ids) {
-                        try {
-                            await this.updateTransaction(id, {
-                                provenTxId: proven.provenTxId,
-                                status: 'completed'
-                            });
-                            req.addHistoryNote({ what: 'notifyTxOfProof', transactionId: id });
-                        }
-                        catch (eu) {
-                            const { code, description } = WalletError_1.WalletError.fromUnknown(eu);
-                            const { provenTxId } = proven;
-                            req.addHistoryNote({ what: 'notifyTxOfProofError', id, provenTxId, code, description });
-                        }
-                    }
-                    await req.updateStorageDynamicProperties(this);
-                }
+                await (0, storageProviderHelpers_1.notifyTransactionsOfProof)((_a = req.notify.transactionIds) !== null && _a !== void 0 ? _a : [], proven.provenTxId, note => req.addHistoryNote(note), async () => { await req.updateStorageDynamicProperties(this); }, async (id, update) => { await this.updateTransaction(id, update); });
             }
         }
         const r = {
@@ -579,51 +706,53 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
     async confirmSpendableOutputs() {
         const invalidSpendableOutputs = [];
         const users = await this.findUsers({ partial: {} });
+        const services = this.getServices();
         for (const { userId } of users) {
             const defaultBasket = (0, utilityHelpers_1.verifyOne)(await this.findOutputBaskets({ partial: { userId, name: 'default' } }));
-            const where = {
-                userId,
-                basketId: defaultBasket.basketId,
-                spendable: true
-            };
-            const outputs = await this.findOutputs({ partial: where });
-            const services = this.getServices();
-            for (let i = outputs.length - 1; i >= 0; i--) {
-                const o = outputs[i];
-                const oid = (0, utilityHelpers_1.verifyId)(o.outputId);
-                if (o.spendable) {
-                    let ok = false;
-                    if (o.lockingScript && o.lockingScript.length > 0) {
-                        const hash = services.hashOutputScript((0, utilityHelpers_noBuffer_1.asString)(o.lockingScript));
-                        const r = await services.getUtxoStatus(hash, undefined, `${o.txid}.${o.vout}`);
-                        if (r.isUtxo === true)
-                            ok = true;
-                    }
-                    if (!ok)
-                        invalidSpendableOutputs.push(o);
-                }
+            const outputs = await this.findOutputs({
+                partial: { userId, basketId: defaultBasket.basketId, spendable: true }
+            });
+            for (const o of outputs) {
+                if (!o.spendable)
+                    continue;
+                const isUtxo = await this.checkOutputIsUtxo(o, services);
+                if (!isUtxo)
+                    invalidSpendableOutputs.push(o);
             }
         }
         return { invalidSpendableOutputs };
     }
+    async checkOutputIsUtxo(o, services) {
+        var _a, _b;
+        if ((o.lockingScript == null) || o.lockingScript.length === 0)
+            return false;
+        const hash = services.hashOutputScript((0, utilityHelpers_noBuffer_1.asString)(o.lockingScript));
+        const r = await services.getUtxoStatus(hash, undefined, `${(_a = o.txid) !== null && _a !== void 0 ? _a : ''}.${(_b = o.vout) !== null && _b !== void 0 ? _b : ''}`);
+        return r.isUtxo === true;
+    }
     async updateProvenTxReqDynamics(id, update, trx) {
+        var _a, _b;
         const partial = {};
-        if (update['updated_at'])
-            partial['updated_at'] = update['updated_at'];
-        if (update['provenTxId'])
-            partial['provenTxId'] = update['provenTxId'];
-        if (update['status'])
-            partial['status'] = update['status'];
-        if (Number.isInteger(update['attempts']))
-            partial['attempts'] = update['attempts'];
-        if (update['notified'] !== undefined)
-            partial['notified'] = update['notified'];
-        if (update['batch'])
-            partial['batch'] = update['batch'];
-        if (update['history'])
-            partial['history'] = update['history'];
-        if (update['notify'])
-            partial['notify'] = update['notify'];
+        if (update.updated_at != null)
+            partial.updated_at = update.updated_at;
+        if (update.provenTxId)
+            partial.provenTxId = update.provenTxId;
+        if (update.status)
+            partial.status = update.status;
+        if (Number.isInteger(update.attempts))
+            partial.attempts = update.attempts;
+        if (update.notified !== undefined)
+            partial.notified = update.notified;
+        if (update.batch)
+            partial.batch = update.batch;
+        if (update.history)
+            partial.history = update.history;
+        if (update.notify)
+            partial.notify = update.notify;
+        if (update.wasBroadcast !== undefined)
+            partial.wasBroadcast = (_a = update.wasBroadcast) !== null && _a !== void 0 ? _a : false;
+        if (Number.isInteger(update.rebroadcastAttempts))
+            partial.rebroadcastAttempts = (_b = update.rebroadcastAttempts) !== null && _b !== void 0 ? _b : 0;
         return await this.updateProvenTxReq(id, partial, trx);
     }
     async extendOutput(o, includeBasket = false, includeTags = false, trx) {
@@ -636,15 +765,16 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
         return o;
     }
     async validateOutputScript(o, trx) {
+        var _a;
         // without offset and length values return what we have (make no changes)
         if (!o.scriptLength || !o.scriptOffset || !o.txid)
             return;
         // if there is an outputScript and its length is the expected length return what we have.
-        if (o.lockingScript && o.lockingScript.length === o.scriptLength)
+        if (((_a = o.lockingScript) === null || _a === void 0 ? void 0 : _a.length) === o.scriptLength)
             return;
         // outputScript is missing or has incorrect length...
         const script = await this.getRawTxOfKnownValidTransaction(o.txid, o.scriptOffset, o.scriptLength, trx);
-        if (!script)
+        if (script == null)
             return;
         o.lockingScript = script;
     }
@@ -657,7 +787,7 @@ function validateStorageFeeModel(v) {
     };
     if (typeof v === 'object') {
         if (v.model !== 'sat/kb')
-            throw new WERR_errors_1.WERR_INVALID_PARAMETER('StorageFeeModel.model', `"sat/kb"`);
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('StorageFeeModel.model', '"sat/kb"');
         if (typeof v.value === 'number') {
             r.value = v.value;
         }