@bsv/wallet-toolbox 2.1.24 → 2.1.26

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");
@@ -17,11 +18,12 @@ const WalletError_1 = require("../sdk/WalletError");
 const utilityHelpers_noBuffer_1 = require("../utility/utilityHelpers.noBuffer");
 class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
     static defaultOptions() {
-        return {
+        const opts = {
             feeModel: { model: 'sat/kb', value: 1 },
             commissionSatoshis: 0,
             commissionPubKeyHex: undefined
         };
+        return opts;
     }
     static createStorageBaseOptions(chain) {
         const options = {
@@ -50,7 +52,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) {
@@ -84,7 +86,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
             noScript: true,
             trx
         });
-        return rows.reduce((a, r) => a + Number(r.satoshis || 0), 0);
+        return rows.reduce((a, r) => { var _a; return a + ((_a = r.satoshis) !== null && _a !== void 0 ? _a : 0); }, 0);
     }
     async recentlyActiveUsers(limit = 50, trx) {
         const outputs = await this.findOutputs({
@@ -98,7 +100,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 +108,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,23 +118,23 @@ 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;
     }
     async abortAction(auth, args) {
-        if (!auth.userId)
+        if (auth.userId == null)
             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({
                 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;
@@ -143,12 +145,13 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
                 }));
             }
             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) {
+            if (tx.txid != null && 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 +193,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 +218,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 == null || 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 +238,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,26 +292,29 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
      * @param trx
      */
     async updateTransactionStatus(status, transactionId, userId, reference, trx) {
-        if (!transactionId && !(userId && reference))
+        if (transactionId == null && !(userId != null && reference != null && reference !== '')) {
             throw new WERR_errors_1.WERR_MISSING_PARAMETER('either transactionId or userId and reference');
+        }
         await this.transaction(async (trx) => {
             const where = {};
-            if (transactionId)
+            if (transactionId != null)
                 where.transactionId = transactionId;
-            if (userId)
+            if (userId != null)
                 where.userId = userId;
-            if (reference)
+            if (reference != null && reference !== '')
                 where.reference = reference;
             const tx = (0, utilityHelpers_1.verifyOne)(await this.findTransactions({ partial: where, noRawTx: true, trx }));
-            //if (tx.status === status)
+            // 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 != null) {
                 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':
                     {
@@ -364,12 +343,12 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
         }, trx);
     }
     async createAction(auth, args) {
-        if (!auth.userId)
+        if (auth.userId == null)
             throw new WERR_errors_1.WERR_UNAUTHORIZED();
         return await (0, createAction_1.createAction)(this, auth, args);
     }
     async processAction(auth, args) {
-        if (!auth.userId)
+        if (auth.userId == null)
             throw new WERR_errors_1.WERR_UNAUTHORIZED();
         return await (0, processAction_1.processAction)(this, auth, args);
     }
@@ -381,7 +360,7 @@ class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
     }
     async verifyKnownValidTransaction(txid, trx) {
         const { proven, rawTx } = await this.getProvenOrRawTx(txid, trx);
-        return proven != undefined || rawTx != undefined;
+        return proven !== undefined || rawTx !== undefined;
     }
     /**
      * Pulls data from storage to build a valid beef for a txid.
@@ -399,64 +378,72 @@ 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;
     }
+    /**
+     * 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) {
+        const proven = r.proven;
+        if (proven == null)
+            return undefined;
+        if ((requiredLevels !== null && requiredLevels !== void 0 ? requiredLevels : 0) > 0) {
+            // Need more levels — caller should proceed via rawTx path
+            r.rawTx = proven.rawTx;
+            return undefined;
+        }
+        if (trustSelf === 'known') {
+            beef.mergeTxidOnly(txid);
+            return beef;
+        }
+        const mp = new entities_1.EntityProvenTx(proven).getMerklePath();
+        if (chainTracker != null) {
+            const root = mp.computeRoot();
+            const isValid = await chainTracker.isValidRootForHeight(root, proven.height);
+            if (!isValid) {
+                if (skipInvalidProofs !== true)
+                    throw new WERR_errors_1.WERR_INVALID_MERKLE_ROOT(proven.blockHash, proven.height, root, txid);
+                // Proof is currently invalid — recurse deeper via rawTx path
+                r.rawTx = proven.rawTx;
+                r.proven = undefined;
+                return undefined;
+            }
+        }
+        // Proof is good — merge and return
+        beef.mergeRawTx(proven.rawTx);
+        beef.mergeBump(mp);
+        return beef;
+    }
     async getValidBeefForTxid(txid, mergeToBeef, trustSelf, knownTxids, trx, requiredLevels, chainTracker, skipInvalidProofs) {
-        const beef = mergeToBeef || new sdk_1.Beef();
+        const beef = mergeToBeef !== null && mergeToBeef !== void 0 ? mergeToBeef : new sdk_1.Beef();
         const r = await this.getProvenOrRawTx(txid, trx);
-        if (r.proven) {
-            if (requiredLevels) {
-                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;
-                    }
-                }
-            }
+        // --- 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;
         }
-        if (!r.rawTx)
+        // --- 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);
-                }
-            }
+            if ((requiredLevels !== null && requiredLevels !== void 0 ? requiredLevels : 0) > 0)
+                requiredLevels = requiredLevels - 1;
+            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,9 +498,10 @@ 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) {
+        if (req.provenTxId != null && req.provenTxId > 0) {
             // Someone beat us to it, grab what we need for results...
             proven = new entities_1.EntityProvenTx((0, utilityHelpers_1.verifyOne)(await this.findProvenTxs({ partial: { txid: args.txid } })));
         }
@@ -542,24 +530,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,56 +550,58 @@ 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 != null && update.provenTxId > 0)
+            partial.provenTxId = update.provenTxId;
+        if (update.status != null)
+            partial.status = update.status;
+        if (Number.isInteger(update.attempts))
+            partial.attempts = update.attempts;
+        if (update.notified !== undefined)
+            partial.notified = update.notified;
+        if (update.batch != null && update.batch !== '')
+            partial.batch = update.batch;
+        if (update.history != null && update.history !== '')
+            partial.history = update.history;
+        if (update.notify != null && 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) {
         const ox = o;
-        if (includeBasket && ox.basketId)
+        if (includeBasket && ox.basketId != null && ox.basketId > 0)
             ox.basket = await this.findOutputBasketById(o.basketId, trx);
         if (includeTags) {
             ox.tags = await this.getTagsForOutputId(o.outputId);
@@ -636,15 +609,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)
+        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 && 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 +631,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;
         }