@bsv/wallet-toolbox 2.4.4 → 2.4.20

package/out/src/storage/StorageProvider.js

@@ -25,6 +25,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
     commissionSatoshis;
     commissionPubKeyHex;
     maxRecursionDepth;
+    scriptVerifier;
     static defaultOptions() {
         const opts = {
             feeModel: { model: 'sat/kb', value: 100 },
@@ -46,26 +47,60 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
         this.commissionPubKeyHex = options.commissionPubKeyHex;
         this.commissionSatoshis = options.commissionSatoshis;
         this.maxRecursionDepth = 12;
+        this.scriptVerifier = options.scriptVerifier;
+    }
+    async insertActionBatch(_batch, _trx) {
+        throw new WERR_errors_1.WERR_NOT_IMPLEMENTED();
+    }
+    async findActionBatch(_userId, _batchId, _trx) {
+        throw new WERR_errors_1.WERR_NOT_IMPLEMENTED();
     }
-    async insertActionBatch(batch, trx) { throw new WERR_errors_1.WERR_NOT_IMPLEMENTED(); }
-    async findActionBatch(userId, batchId, trx) { throw new WERR_errors_1.WERR_NOT_IMPLEMENTED(); }
     async findActionBatchForUpdate(userId, batchId, trx) {
         return await this.findActionBatch(userId, batchId, trx);
     }
-    async findExpiredActionBatches(now, trx) { throw new WERR_errors_1.WERR_NOT_IMPLEMENTED(); }
-    async updateActionBatch(actionBatchId, update, trx) { throw new WERR_errors_1.WERR_NOT_IMPLEMENTED(); }
-    async deleteActionBatch(actionBatchId, trx) { throw new WERR_errors_1.WERR_NOT_IMPLEMENTED(); }
-    async reserveActionBatchOutputs(reservations, trx) { throw new WERR_errors_1.WERR_NOT_IMPLEMENTED(); }
-    async findActionBatchOutputIds(actionBatchId, trx) { throw new WERR_errors_1.WERR_NOT_IMPLEMENTED(); }
-    async findReservedActionBatchOutputIds(_outputIds, _trx) { return []; }
-    async deleteActionBatchOutputReservations(actionBatchId, trx) { throw new WERR_errors_1.WERR_NOT_IMPLEMENTED(); }
-    async putActionBatchBlobRecord(blob, trx) { throw new WERR_errors_1.WERR_NOT_IMPLEMENTED(); }
-    async findActionBatchBlobRecord(actionBatchId, digest, trx) { throw new WERR_errors_1.WERR_NOT_IMPLEMENTED(); }
-    async deleteActionBatchBlobRecords(actionBatchId, trx) { throw new WERR_errors_1.WERR_NOT_IMPLEMENTED(); }
+    async findExpiredActionBatches(_now, _trx) {
+        throw new WERR_errors_1.WERR_NOT_IMPLEMENTED();
+    }
+    async updateActionBatch(_actionBatchId, _update, _trx) {
+        throw new WERR_errors_1.WERR_NOT_IMPLEMENTED();
+    }
+    async deleteActionBatch(_actionBatchId, _trx) {
+        throw new WERR_errors_1.WERR_NOT_IMPLEMENTED();
+    }
+    async reserveActionBatchOutputs(_reservations, _trx) {
+        throw new WERR_errors_1.WERR_NOT_IMPLEMENTED();
+    }
+    async findActionBatchOutputIds(_actionBatchId, _trx) {
+        throw new WERR_errors_1.WERR_NOT_IMPLEMENTED();
+    }
+    async findReservedActionBatchOutputIds(_outputIds, _trx) {
+        return [];
+    }
+    async deleteActionBatchOutputReservations(_actionBatchId, _trx) {
+        throw new WERR_errors_1.WERR_NOT_IMPLEMENTED();
+    }
+    async putActionBatchBlobRecord(_blob, _trx) {
+        throw new WERR_errors_1.WERR_NOT_IMPLEMENTED();
+    }
+    async findActionBatchBlobRecord(_actionBatchId, _digest, _trx) {
+        throw new WERR_errors_1.WERR_NOT_IMPLEMENTED();
+    }
+    async findActionBatchBlobRecords(actionBatchId, digests, trx) {
+        return (await Promise.all(digests.map(async (digest) => await this.findActionBatchBlobRecord(actionBatchId, digest, trx)))).filter((blob) => blob != null);
+    }
+    async putActionBatchBlobRecords(blobs, trx) {
+        for (const blob of blobs)
+            await this.putActionBatchBlobRecord(blob, trx);
+    }
+    async deleteActionBatchBlobRecords(_actionBatchId, _trx) {
+        throw new WERR_errors_1.WERR_NOT_IMPLEMENTED();
+    }
     async getCapabilities() {
         return this.supportsActionBatchPersistence() ? (0, actionBatch_1.getActionBatchCapabilities)() : {};
     }
-    supportsActionBatchPersistence() { return false; }
+    supportsActionBatchPersistence() {
+        return false;
+    }
     async beginActionBatch(auth, args) {
         if (!this.supportsActionBatchPersistence())
             throw new WERR_errors_1.WERR_NOT_IMPLEMENTED('actionBatch capability is not available');
@@ -83,9 +118,15 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
     async putActionBatchBlob(auth, args) {
         return await (0, actionBatchBlobs_1.putActionBatchBlob)(this, auth, args);
     }
+    async putActionBatchPack(auth, args) {
+        return await (0, actionBatchBlobs_1.putActionBatchPack)(this, auth, args);
+    }
     async commitActionBatch(auth, manifest) {
         return await (0, actionBatch_1.commitActionBatch)(this, auth, manifest);
     }
+    async commitActionBatchByDigest(auth, args) {
+        return await (0, actionBatch_1.commitActionBatchByDigest)(this, auth, args);
+    }
     async abortActionBatch(auth, batchId) {
         return await (0, actionBatch_1.abortActionBatch)(this, auth, batchId);
     }
@@ -128,6 +169,12 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
             byTag[tag] = await this.findOrInsertOutputTag(userId, tag, trx);
         return byTag;
     }
+    async findOrInsertTxLabelsBulk(userId, labels, trx) {
+        const byLabel = {};
+        for (const label of labels)
+            byLabel[label] ??= await this.findOrInsertTxLabel(userId, label, trx);
+        return byLabel;
+    }
     async sumSpendableSatoshisInBasket(userId, basketId, excludeSending, trx) {
         const status = ['completed', 'unproven'];
         if (!excludeSending)
@@ -152,7 +199,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
                 continue;
             const createdAt = this.validateDate(output.created_at);
             const prior = latestByUserId.get(output.userId);
-            if ((prior == null) || createdAt > prior) {
+            if (prior == null || createdAt > prior) {
                 latestByUserId.set(output.userId, createdAt);
             }
         }
@@ -174,32 +221,79 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
             throw new WERR_errors_1.WERR_INVALID_OPERATION('Must setServices first.');
         return this._services;
     }
-    async abortAction(auth, args) {
-        if (auth.userId == null)
-            throw new WERR_errors_1.WERR_INVALID_PARAMETER('auth.userId', 'valid');
-        const userId = auth.userId;
+    async findAbortableTransaction(userId, args, trx) {
         let reference = args.reference;
-        let txid;
-        const r = await this.transaction(async (trx) => {
-            let tx = (0, utilityHelpers_1.verifyOneOrNone)(await this.findTransactions({
-                partial: { reference, userId },
+        let tx = (0, utilityHelpers_1.verifyOneOrNone)(await this.findTransactions({
+            partial: { reference, userId },
+            noRawTx: true,
+            trx
+        }));
+        if (tx == null && args.reference.length === 64) {
+            reference = undefined;
+            tx = (0, utilityHelpers_1.verifyOneOrNone)(await this.findTransactions({
+                partial: { txid: args.reference, userId },
                 noRawTx: true,
                 trx
             }));
-            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({
-                    partial: { txid, userId },
-                    noRawTx: true,
-                    trx
-                }));
+        }
+        const unAbortableStatus = ['completed', 'failed', 'sending', 'unproven'];
+        if (tx == null || !tx.isOutgoing || unAbortableStatus.includes(tx.status)) {
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('reference', 'an inprocess, outgoing action that has not been signed and shared to the network.');
+        }
+        return { tx, reference };
+    }
+    async checkAbortChainProtection(tx, args, trx) {
+        if (tx.txid == null || tx.txid === '' || tx.status !== 'nosend') {
+            return { skipped: false, serviceUnreachable: false };
+        }
+        let serviceUnreachable = false;
+        let chainStatus;
+        try {
+            const result = await this.getServices().getStatusForTxids([tx.txid]);
+            if (result.status !== 'success') {
+                serviceUnreachable = true;
             }
-            const unAbortableStatus = ['completed', 'failed', 'sending', 'unproven'];
-            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.');
+            else {
+                chainStatus = result.results.find(item => item.txid === tx.txid)?.status;
             }
+        }
+        catch {
+            serviceUnreachable = true;
+        }
+        if (chainStatus !== 'mined' && chainStatus !== 'known') {
+            return { skipped: false, serviceUnreachable };
+        }
+        const req = await entities_1.EntityProvenTxReq.fromStorageTxid(this, tx.txid, trx);
+        if (req != null) {
+            req.addHistoryNote({
+                what: 'abortAction-skipped-onchain',
+                reference: args.reference,
+                chainStatus
+            });
+            await req.updateStorageDynamicProperties(this, trx);
+        }
+        return { skipped: true, serviceUnreachable };
+    }
+    async invalidateAbortedTransaction(tx, userId, reference, originalReference, serviceUnreachable, trx) {
+        await this.updateTransactionStatus('failed', tx.transactionId, userId, reference, trx);
+        if (tx.txid != null && tx.txid !== '') {
+            const req = await entities_1.EntityProvenTxReq.fromStorageTxid(this, tx.txid, trx);
+            if (req != null) {
+                req.addHistoryNote(serviceUnreachable
+                    ? { what: 'abortAction-offline-fallback', reference: originalReference }
+                    : { what: 'abortAction', reference: originalReference });
+                req.status = 'invalid';
+                await req.updateStorageDynamicProperties(this, trx);
+            }
+        }
+        return { aborted: true };
+    }
+    async abortAction(auth, args) {
+        if (auth.userId == null)
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('auth.userId', 'valid');
+        const userId = auth.userId;
+        const r = await this.transaction(async (trx) => {
+            const { tx, reference } = await this.findAbortableTransaction(userId, args, trx);
             // Chain-status protection for signed nosend txs.
             //
             // Background: a nosend tx (created via createAction({noSend:true}))
@@ -231,57 +325,12 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
             // hole can never be 100% closed against externally-broadcast
             // chain-confirmed txs while offline; the audit trail makes it
             // recoverable.
-            let serviceUnreachable = false;
-            if (tx.txid != null && tx.txid !== '' && tx.status === 'nosend') {
-                const services = this.getServices();
-                let chainStatus;
-                try {
-                    const r = await services.getStatusForTxids([tx.txid]);
-                    if (r.status !== 'success') {
-                        serviceUnreachable = true;
-                    }
-                    else {
-                        chainStatus = r.results.find(x => x.txid === tx.txid)?.status;
-                    }
-                }
-                catch {
-                    serviceUnreachable = true;
-                }
-                if (chainStatus === 'mined' || chainStatus === 'known') {
-                    const req = await entities_1.EntityProvenTxReq.fromStorageTxid(this, tx.txid, trx);
-                    if (req != null) {
-                        req.addHistoryNote({
-                            what: 'abortAction-skipped-onchain',
-                            reference: args.reference,
-                            chainStatus
-                        });
-                        await req.updateStorageDynamicProperties(this, trx);
-                    }
-                    // Surface the refusal via a sentinel so the surrounding
-                    // transaction commits the history note BEFORE returning
-                    // the aborted:false result. Returning directly from inside
-                    // the transaction would still work, but the sentinel keeps
-                    // the audit-write / result-shape decision on the same
-                    // commit-then-return path that existed when this surface
-                    // threw, minimizing diff churn.
-                    return { __abortAction: 'skipped-onchain', chainStatus };
-                }
-            }
-            await this.updateTransactionStatus('failed', tx.transactionId, userId, reference, trx);
-            if (tx.txid != null && tx.txid !== '') {
-                const req = await entities_1.EntityProvenTxReq.fromStorageTxid(this, tx.txid, trx);
-                if (req != null) {
-                    req.addHistoryNote(serviceUnreachable
-                        ? { what: 'abortAction-offline-fallback', reference: args.reference }
-                        : { what: 'abortAction', reference: args.reference });
-                    req.status = 'invalid';
-                    await req.updateStorageDynamicProperties(this, trx);
-                }
+            const protection = await this.checkAbortChainProtection(tx, args, trx);
+            if (protection.skipped) {
+                // Commit the audit note before translating this sentinel to aborted:false.
+                return { __abortAction: 'skipped-onchain' };
             }
-            const r = {
-                aborted: true
-            };
-            return r;
+            return await this.invalidateAbortedTransaction(tx, userId, reference, args.reference, protection.serviceUnreachable, trx);
         });
         if ('__abortAction' in r) {
             // Tone Engel review feedback (PR #122 comment 4444566147 item 3):
@@ -351,7 +400,9 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
             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));
-        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); });
+        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.
@@ -384,7 +435,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
         return existing;
     }
     async getProvenOrReq(txid, newReq, trx) {
-        if ((newReq != null) && txid !== newReq.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 }));
@@ -563,7 +614,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
         beef.mergeBump(mp);
         return beef;
     }
-    async getValidBeefForTxid(txid, mergeToBeef, trustSelf, knownTxids, trx, requiredLevels, chainTracker, skipInvalidProofs) {
+    async getValidBeefForTxid(...[txid, mergeToBeef, trustSelf, knownTxids, trx, requiredLevels, chainTracker, skipInvalidProofs]) {
         const beef = mergeToBeef ?? new sdk_1.Beef();
         const r = await this.getProvenOrRawTx(txid, trx);
         // --- proven-tx path ---
@@ -716,6 +767,94 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
         }
         return { log };
     }
+    async prepareProofRecoveryOutputVerdicts(transactions) {
+        const verdicts = new Map();
+        if (transactions.length === 0)
+            return verdicts;
+        const services = this.getServices();
+        for (const transaction of transactions) {
+            const outputs = await this.findOutputs({
+                partial: {
+                    userId: transaction.userId,
+                    transactionId: transaction.transactionId
+                }
+            });
+            for (const output of outputs) {
+                const outputId = (0, utilityHelpers_1.verifyId)(output.outputId);
+                await this.validateOutputScript(output);
+                verdicts.set(outputId, output.lockingScript == null ? undefined : await services.isUtxo(output));
+            }
+        }
+        return verdicts;
+    }
+    async restoreProofRecoveryInputs(tx, bsvtx, indent, trx) {
+        let log = '';
+        for (const [vin, input] of bsvtx.inputs.entries()) {
+            const sourceTXID = input.sourceTXID;
+            if (sourceTXID == null) {
+                log += ' '.repeat(indent + 2) + `input ${vin} has no source transaction id\n`;
+                continue;
+            }
+            const outputs = await this.findOutputs({
+                partial: {
+                    userId: tx.userId,
+                    txid: sourceTXID,
+                    vout: input.sourceOutputIndex
+                },
+                trx
+            });
+            if (outputs.length !== 1) {
+                log += ' '.repeat(indent + 2) + `input ${vin} not matched to user's outputs\n`;
+                continue;
+            }
+            const output = outputs[0];
+            log +=
+                ' '.repeat(indent + 2) +
+                    `input ${vin} matched to output ${output.outputId} updated spentBy ${tx.transactionId}\n`;
+            await this.updateOutput((0, utilityHelpers_1.verifyId)(output.outputId), { spendable: false, spentBy: tx.transactionId }, trx);
+        }
+        return log;
+    }
+    async restoreProofRecoveryOutputs(tx, outputVerdicts, indent, trx) {
+        let log = '';
+        const outputs = await this.findOutputs({
+            partial: { userId: tx.userId, transactionId: tx.transactionId },
+            trx
+        });
+        for (const output of outputs) {
+            const outputId = (0, utilityHelpers_1.verifyId)(output.outputId);
+            if (!outputVerdicts.has(outputId)) {
+                throw new WERR_errors_1.WERR_INTERNAL(`Output ${outputId} changed while preparing proof recovery.`);
+            }
+            const isUtxo = outputVerdicts.get(outputId);
+            if (isUtxo == null) {
+                log +=
+                    ' '.repeat(indent + 2) +
+                        `output ${output.outputId} does not have a valid locking script\n`;
+                continue;
+            }
+            if (isUtxo === output.spendable) {
+                log += ' '.repeat(indent + 2) + `output ${output.outputId} unchanged\n`;
+                continue;
+            }
+            log +=
+                ' '.repeat(indent + 2) +
+                    `output ${output.outputId} set to ${isUtxo ? 'spendable' : 'spent'}\n`;
+            await this.updateOutput(outputId, { spendable: isUtxo }, trx);
+        }
+        return log;
+    }
+    async restoreTransactionForProof(tx, bsvtx, preparedTransactionIds, outputVerdicts, indent, trx) {
+        if (bsvtx == null || !preparedTransactionIds.has(tx.transactionId)) {
+            throw new WERR_errors_1.WERR_INTERNAL(`Transaction ${tx.transactionId} changed while preparing proof recovery.`);
+        }
+        await this.updateTransaction(tx.transactionId, { status: 'unproven' }, trx);
+        let log = ' '.repeat(indent) +
+            `transaction ${tx.transactionId} status is now 'unproven'\n`;
+        log += await this.restoreProofRecoveryInputs(tx, bsvtx, indent, trx);
+        log += await this.restoreProofRecoveryOutputs(tx, outputVerdicts, indent, trx);
+        return log;
+    }
     /**
      * Restore every failed local copy of a transaction before proof completion.
      * Also heals the request's notification set from the authoritative txid
@@ -737,23 +876,10 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
         // transition separately so it is persisted atomically with bookkeeping.
         await req.refreshFromStorage(this);
         const preparedTransactionIds = new Set(transactionsToRepair.map(transaction => transaction.transactionId));
-        const outputVerdicts = new Map();
         const bsvtx = transactionsToRepair.length > 0 ? sdk_1.Transaction.fromBinary(req.rawTx) : undefined;
         // UTXO checks can call external services. Complete every check before
         // opening the write transaction so network latency never holds DB locks.
-        if (transactionsToRepair.length > 0) {
-            const services = this.getServices();
-            for (const transaction of transactionsToRepair) {
-                const outputs = await this.findOutputs({
-                    partial: { userId: transaction.userId, transactionId: transaction.transactionId }
-                });
-                for (const output of outputs) {
-                    const outputId = (0, utilityHelpers_1.verifyId)(output.outputId);
-                    await this.validateOutputScript(output);
-                    outputVerdicts.set(outputId, output.lockingScript == null ? undefined : await services.isUtxo(output));
-                }
-            }
-        }
+        const outputVerdicts = await this.prepareProofRecoveryOutputVerdicts(transactionsToRepair);
         return await this.transaction(async (trx) => {
             let log = '';
             await req.refreshFromStorage(this, trx);
@@ -775,59 +901,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
                 const shouldRepair = requestUpdate != null || tx.status === 'failed';
                 if (!shouldRepair)
                     continue;
-                if (bsvtx == null || !preparedTransactionIds.has(tx.transactionId)) {
-                    throw new WERR_errors_1.WERR_INTERNAL(`Transaction ${tx.transactionId} changed while preparing proof recovery.`);
-                }
-                await this.updateTransaction(tx.transactionId, { status: 'unproven' }, trx);
-                log += ' '.repeat(indent) + `transaction ${tx.transactionId} status is now 'unproven'\n`;
-                let vin = -1;
-                for (const input of bsvtx.inputs) {
-                    vin++;
-                    const sourceTXID = input.sourceTXID;
-                    if (sourceTXID == null) {
-                        log += ' '.repeat(indent + 2) + `input ${vin} has no source transaction id\n`;
-                        continue;
-                    }
-                    const outputs = await this.findOutputs({
-                        partial: {
-                            userId: tx.userId,
-                            txid: sourceTXID,
-                            vout: input.sourceOutputIndex
-                        },
-                        trx
-                    });
-                    if (outputs.length === 1) {
-                        const output = outputs[0];
-                        log += ' '.repeat(indent + 2) +
-                            `input ${vin} matched to output ${output.outputId} updated spentBy ${tx.transactionId}\n`;
-                        await this.updateOutput((0, utilityHelpers_1.verifyId)(output.outputId), { spendable: false, spentBy: tx.transactionId }, trx);
-                    }
-                    else {
-                        log += ' '.repeat(indent + 2) + `input ${vin} not matched to user's outputs\n`;
-                    }
-                }
-                const outputs = await this.findOutputs({
-                    partial: { userId: tx.userId, transactionId: tx.transactionId },
-                    trx
-                });
-                for (const output of outputs) {
-                    const outputId = (0, utilityHelpers_1.verifyId)(output.outputId);
-                    if (!outputVerdicts.has(outputId)) {
-                        throw new WERR_errors_1.WERR_INTERNAL(`Output ${outputId} changed while preparing proof recovery.`);
-                    }
-                    const isUtxo = outputVerdicts.get(outputId);
-                    if (isUtxo == null) {
-                        log += ' '.repeat(indent + 2) + `output ${output.outputId} does not have a valid locking script\n`;
-                    }
-                    else if (isUtxo === output.spendable) {
-                        log += ' '.repeat(indent + 2) + `output ${output.outputId} unchanged\n`;
-                    }
-                    else {
-                        log += ' '.repeat(indent + 2) +
-                            `output ${output.outputId} set to ${isUtxo ? 'spendable' : 'spent'}\n`;
-                        await this.updateOutput(outputId, { spendable: isUtxo }, trx);
-                    }
-                }
+                log += await this.restoreTransactionForProof(tx, bsvtx, preparedTransactionIds, outputVerdicts, indent, trx);
             }
             await req.updateStorageDynamicProperties(this, trx);
             return log;
@@ -860,9 +934,13 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
                 const transactionIdsNeedingProof = transactions
                     .filter(transaction => transaction.status !== 'completed' || transaction.provenTxId !== proven.provenTxId)
                     .map(transaction => transaction.transactionId);
-                const updatesSucceeded = await (0, storageProviderHelpers_1.notifyTransactionsOfProof)(transactionIdsNeedingProof, proven.provenTxId, note => req.addHistoryNote(note), async (id, update) => { await this.updateTransaction(id, update, trx); });
+                const updatesSucceeded = await (0, storageProviderHelpers_1.notifyTransactionsOfProof)(transactionIdsNeedingProof, proven.provenTxId, note => req.addHistoryNote(note), async (id, update) => {
+                    await this.updateTransaction(id, update, trx);
+                });
                 const completedTransactions = await this.findTransactions({ partial: { txid: req.txid }, trx });
-                req.notified = updatesSucceeded && completedTransactions.every(transaction => transaction.status === 'completed' && transaction.provenTxId === proven.provenTxId);
+                req.notified =
+                    updatesSucceeded &&
+                        completedTransactions.every(transaction => transaction.status === 'completed' && transaction.provenTxId === proven.provenTxId);
                 await req.updateStorageDynamicProperties(this, trx);
                 return false;
             });
@@ -902,7 +980,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
         return { invalidSpendableOutputs };
     }
     async checkOutputIsUtxo(o, services) {
-        if ((o.lockingScript == null) || o.lockingScript.length === 0)
+        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, `${o.txid ?? ''}.${o.vout ?? ''}`);
@@ -943,7 +1021,12 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
     }
     async validateOutputScript(o, trx) {
         // without offset and length values return what we have (make no changes)
-        if (o.scriptLength == null || o.scriptLength === 0 || o.scriptOffset == null || o.scriptOffset === 0 || o.txid == null || o.txid === '')
+        if (o.scriptLength == null ||
+            o.scriptLength === 0 ||
+            o.scriptOffset == null ||
+            o.scriptOffset === 0 ||
+            o.txid == null ||
+            o.txid === '')
             return;
         // if there is an outputScript and its length is the expected length return what we have.
         if (o.lockingScript?.length === o.scriptLength)