@bsv/wallet-toolbox-client 2.4.4 → 2.4.20

package/out/src/storage/StorageProvider.js

@@ -1,973 +0,0 @@
-"use strict";
-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");
-const listCertificates_1 = require("./methods/listCertificates");
-const createAction_1 = require("./methods/createAction");
-const internalizeAction_1 = require("./methods/internalizeAction");
-const StorageReaderWriter_1 = require("./StorageReaderWriter");
-const entities_1 = require("./schema/entities");
-const WERR_errors_1 = require("../sdk/WERR_errors");
-const utilityHelpers_1 = require("../utility/utilityHelpers");
-const WalletError_1 = require("../sdk/WalletError");
-const utilityHelpers_noBuffer_1 = require("../utility/utilityHelpers.noBuffer");
-const actionBatch_1 = require("./methods/actionBatch");
-const actionBatchBlobs_1 = require("./methods/actionBatchBlobs");
-class StorageProvider extends StorageReaderWriter_1.StorageReaderWriter {
-    isDirty = false;
-    _services;
-    feeModel;
-    commissionSatoshis;
-    commissionPubKeyHex;
-    maxRecursionDepth;
-    static defaultOptions() {
-        const opts = {
-            feeModel: { model: 'sat/kb', value: 100 },
-            commissionSatoshis: 0,
-            commissionPubKeyHex: undefined
-        };
-        return opts;
-    }
-    static createStorageBaseOptions(chain) {
-        const options = {
-            ...StorageProvider.defaultOptions(),
-            chain
-        };
-        return options;
-    }
-    constructor(options) {
-        super(options);
-        this.feeModel = options.feeModel;
-        this.commissionPubKeyHex = options.commissionPubKeyHex;
-        this.commissionSatoshis = options.commissionSatoshis;
-        this.maxRecursionDepth = 12;
-    }
-    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 getCapabilities() {
-        return this.supportsActionBatchPersistence() ? (0, actionBatch_1.getActionBatchCapabilities)() : {};
-    }
-    supportsActionBatchPersistence() { return false; }
-    async beginActionBatch(auth, args) {
-        if (!this.supportsActionBatchPersistence())
-            throw new WERR_errors_1.WERR_NOT_IMPLEMENTED('actionBatch capability is not available');
-        return await (0, actionBatch_1.beginActionBatch)(this, auth, args);
-    }
-    async extendActionBatch(auth, args) {
-        return await (0, actionBatch_1.extendActionBatch)(this, auth, args);
-    }
-    async renewActionBatch(auth, batchId) {
-        return await (0, actionBatch_1.renewActionBatch)(this, auth, batchId);
-    }
-    async prepareActionBatchCommit(auth, manifest) {
-        return await (0, actionBatchBlobs_1.prepareActionBatchCommit)(this, auth, manifest);
-    }
-    async putActionBatchBlob(auth, args) {
-        return await (0, actionBatchBlobs_1.putActionBatchBlob)(this, auth, args);
-    }
-    async commitActionBatch(auth, manifest) {
-        return await (0, actionBatch_1.commitActionBatch)(this, auth, manifest);
-    }
-    async abortActionBatch(auth, batchId) {
-        return await (0, actionBatch_1.abortActionBatch)(this, auth, batchId);
-    }
-    async findOutputsByIds(outputIds, trx) {
-        const byId = {};
-        for (const outputId of outputIds) {
-            const o = (0, utilityHelpers_1.verifyOneOrNone)(await this.findOutputs({ partial: { outputId }, trx }));
-            if (o?.outputId !== undefined)
-                byId[o.outputId] = o;
-        }
-        return byId;
-    }
-    async findStaleMerkleRoots(args) {
-        let provenTxs = await this.findProvenTxs({ partial: { height: args.height } });
-        provenTxs = provenTxs.filter(ptx => ptx.merkleRoot !== args.merkleRoot);
-        const roots = Array.from(new Set(provenTxs.map(ptx => ptx.merkleRoot)));
-        return roots;
-    }
-    async findOutputsByOutpoints(userId, outpoints, trx) {
-        const byOutpoint = {};
-        for (const { txid, vout } of outpoints) {
-            const o = (0, utilityHelpers_1.verifyOneOrNone)(await this.findOutputs({ partial: { userId, txid, vout }, trx }));
-            if (o?.txid !== undefined && o.vout !== undefined)
-                byOutpoint[`${o.txid}.${o.vout}`] = o;
-        }
-        return byOutpoint;
-    }
-    async findOutputsByOutpointsForUpdate(userId, outpoints, trx) {
-        return await this.findOutputsByOutpoints(userId, outpoints, trx);
-    }
-    async findOrInsertOutputBasketsBulk(userId, names, trx) {
-        const byName = {};
-        for (const name of names)
-            byName[name] = await this.findOrInsertOutputBasket(userId, name, trx);
-        return byName;
-    }
-    async findOrInsertOutputTagsBulk(userId, tags, trx) {
-        const byTag = {};
-        for (const tag of tags)
-            byTag[tag] = await this.findOrInsertOutputTag(userId, tag, trx);
-        return byTag;
-    }
-    async sumSpendableSatoshisInBasket(userId, basketId, excludeSending, trx) {
-        const status = ['completed', 'unproven'];
-        if (!excludeSending)
-            status.push('sending');
-        const rows = await this.findOutputs({
-            partial: { userId, spendable: true, basketId },
-            txStatus: status,
-            noScript: true,
-            trx
-        });
-        return rows.filter(r => r.spentBy == null).reduce((a, r) => a + (r.satoshis ?? 0), 0);
-    }
-    async recentlyActiveUsers(limit = 50, trx) {
-        const outputs = await this.findOutputs({
-            partial: {},
-            noScript: true,
-            trx
-        });
-        const latestByUserId = new Map();
-        for (const output of outputs) {
-            if (output.userId === undefined)
-                continue;
-            const createdAt = this.validateDate(output.created_at);
-            const prior = latestByUserId.get(output.userId);
-            if ((prior == null) || createdAt > prior) {
-                latestByUserId.set(output.userId, createdAt);
-            }
-        }
-        const sortedUserIds = Array.from(latestByUserId.entries())
-            .sort((a, b) => b[1].getTime() - a[1].getTime())
-            .slice(0, limit)
-            .map(([userId]) => userId);
-        const users = await Promise.all(sortedUserIds.map(async (userId) => await this.findUserById(userId, trx)));
-        return users.filter((user) => user != null);
-    }
-    isStorageProvider() {
-        return true;
-    }
-    setServices(v) {
-        this._services = v;
-    }
-    getServices() {
-        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 == null)
-            throw new WERR_errors_1.WERR_INVALID_PARAMETER('auth.userId', 'valid');
-        const userId = auth.userId;
-        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 },
-                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.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.');
-            }
-            // Chain-status protection for signed nosend txs.
-            //
-            // Background: a nosend tx (created via createAction({noSend:true}))
-            // can be externally broadcast by the caller and reach 'mined' or
-            // mempool-'known' status before any internalizeAction or Monitor
-            // cycle has retired its 'nosend' status in storage. If abortAction
-            // is invoked on it in that window, the destructive transitions
-            // below (transactions.status='failed' + proven_tx_reqs.status='invalid')
-            // orphan every output the tx produced — including auto-fund change
-            // outputs the wallet itself emitted — because listOutputs filters
-            // them out of the spendable set on parent-tx 'failed' status.
-            //
-            // Protection: if the tx has a txid AND status is 'nosend', ask
-            // the network whether it already knows about the tx before
-            // invalidating. getStatusForTxids returns 'mined' | 'known' |
-            // 'unknown' per StatusForTxidResult (WalletServices.interfaces.ts).
-            // Refuse the abort for 'mined' OR 'known' — a tx that's broadcast
-            // and propagating in mempool returns 'known' (depth===0) and
-            // protecting it avoids orphaning during the propagation window.
-            //
-            // Service-unreachable handling: proceed with abort. Refusal is
-            // reserved for positive on-chain confirmation. When the network
-            // confirmation pathway is itself unavailable (services throw or
-            // gracefully return r.status !== 'success'), confirmation is not
-            // possible — and per the BRC-100 contract callers retain the
-            // ability to abort offline. The fallback writes a forensic
-            // history note ('abortAction-offline-fallback') so an operator
-            // can grep for aborts that proceeded under uncertainty. This
-            // 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 r = {
-                aborted: true
-            };
-            return r;
-        });
-        if ('__abortAction' in r) {
-            // Tone Engel review feedback (PR #122 comment 4444566147 item 3):
-            // do not throw on chain-confirmed refusal — surface it via the
-            // return value so callers can branch on it. Refusal is positive
-            // chain confirmation only; service-unreachable proceeds with
-            // abort and returns aborted:true with an audit-trail note.
-            return { aborted: false };
-        }
-        return r;
-    }
-    async internalizeAction(auth, args) {
-        return await (0, internalizeAction_1.internalizeAction)(this, auth, args);
-    }
-    /**
-     * Given an array of transaction txids with current ProvenTxReq ready-to-share status,
-     * lookup their ProvenTxReqApi req records.
-     * For the txids with reqs and status still ready to send construct a single merged beef.
-     *
-     * @param txids
-     * @param knownTxids
-     * @param trx
-     */
-    async getReqsAndBeefToShareWithWorld(txids, knownTxids, trx) {
-        const r = {
-            beef: new sdk_1.Beef(),
-            details: []
-        };
-        for (const txid of txids) {
-            const d = {
-                txid,
-                // status: 'readyToSend' | 'alreadySent' | 'error' | 'unknown'
-                status: 'unknown'
-                // req?: TableProvenTxReq
-                // proven?: TableProvenTx
-                // error?: string
-            };
-            r.details.push(d);
-            try {
-                d.proven = (0, utilityHelpers_1.verifyOneOrNone)(await this.findProvenTxs({ partial: { txid }, trx }));
-                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 {
-                    (0, storageProviderHelpers_1.classifyReqStatus)(d, d.req);
-                }
-                if (d.status === 'readyToSend') {
-                    await this.mergeReqToBeefToShareExternally(d.req, r.beef, knownTxids, trx);
-                }
-            }
-            catch (error_) {
-                const e = WalletError_1.WalletError.fromUnknown(error_);
-                d.error = `${e.name}: ${e.message}`;
-            }
-        }
-        return r;
-    }
-    async mergeReqToBeefToShareExternally(req, mergeToBeef, knownTxids, trx) {
-        const { rawTx, inputBEEF: beef } = req;
-        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));
-        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.
-     * Next checks if txid is a current ProvenTxReq and returns that if found.
-     * If `newReq` is provided and an existing ProvenTxReq isn't found,
-     * use `newReq` to create a new ProvenTxReq.
-     *
-     * This is safe "findOrInsert" operation using retry if unique index constraint
-     * is violated by a race condition insert.
-     *
-     * @param txid
-     * @param newReq
-     * @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 != 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 != null)
-            return r;
-        for (let retry = 0;; retry++) {
-            try {
-                r.req = await this.upsertProvenTxReq(txid, newReq, trx);
-                break;
-            }
-            catch (error_) {
-                if (retry > 0)
-                    throw error_;
-            }
-        }
-        return r;
-    }
-    async updateTransactionsStatus(transactionIds, status, trx) {
-        await this.transaction(async (trx) => {
-            for (const id of transactionIds) {
-                await this.updateTransactionStatus(status, id, undefined, undefined, trx);
-            }
-        }, trx);
-    }
-    async releaseInputsAllocatedToFailedTransaction(tx, trx) {
-        const t = new entities_1.EntityTransaction(tx);
-        const inputs = await t.getInputs(this, trx);
-        for (const input of inputs) {
-            // input is a prior output belonging to userId that references this transaction either by `spentBy`
-            // or by txid and vout.
-            await this.updateOutput((0, utilityHelpers_1.verifyId)(input.outputId), { spendable: true, spentBy: undefined }, trx);
-        }
-    }
-    async markFailedTransactionOutputsNotSpendable(tx, trx) {
-        const outputs = await this.findOutputs({
-            partial: { transactionId: (0, utilityHelpers_1.verifyId)(tx.transactionId) },
-            trx
-        });
-        for (const output of outputs) {
-            if (!output.spendable && output.spentBy == null)
-                continue;
-            await this.updateOutput((0, utilityHelpers_1.verifyId)(output.outputId), { spendable: false, spentBy: undefined }, trx);
-        }
-    }
-    /**
-     * For all `status` values besides 'failed', just updates the transaction records status property.
-     *
-     * For 'status' of 'failed', attempts to make outputs previously allocated as inputs to this transaction usable again
-     * and makes outputs generated by this transaction non-spendable.
-     *
-     * @param status
-     * @param transactionId
-     * @param userId
-     * @param reference
-     * @param trx
-     */
-    async updateTransactionStatus(status, transactionId, userId, reference, trx) {
-        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 != null)
-                where.transactionId = transactionId;
-            if (userId != null)
-                where.userId = userId;
-            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)
-            // no change required. Assume inputs and outputs spendable and spentBy are valid for status.
-            // return
-            // Once completed, this method cannot be used to "uncomplete" transaction.
-            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.');
-            }
-            switch (status) {
-                case 'failed':
-                    await this.releaseInputsAllocatedToFailedTransaction(tx, trx);
-                    await this.markFailedTransactionOutputsNotSpendable(tx, trx);
-                    break;
-                case 'nosend':
-                case 'unsigned':
-                case 'unprocessed':
-                case 'sending':
-                case 'unproven':
-                case 'completed':
-                    break;
-                default:
-                    throw new WERR_errors_1.WERR_INVALID_PARAMETER('status', `not be ${status}`);
-            }
-            await this.updateTransaction(tx.transactionId, { status }, trx);
-        }, trx);
-    }
-    async createAction(auth, args) {
-        if (auth.userId == null)
-            throw new WERR_errors_1.WERR_UNAUTHORIZED();
-        if (this.supportsActionBatchPersistence())
-            await (0, actionBatch_1.cleanupExpiredActionBatches)(this);
-        return await (0, createAction_1.createAction)(this, auth, args);
-    }
-    async processAction(auth, args) {
-        if (auth.userId == null)
-            throw new WERR_errors_1.WERR_UNAUTHORIZED();
-        return await (0, processAction_1.processAction)(this, auth, args);
-    }
-    async attemptToPostReqsToNetwork(reqs, trx, logger) {
-        return await (0, attemptToPostReqsToNetwork_1.attemptToPostReqsToNetwork)(this, reqs, trx, logger);
-    }
-    async listCertificates(auth, args) {
-        return await (0, listCertificates_1.listCertificates)(this, auth, args);
-    }
-    async verifyKnownValidTransaction(txid, trx) {
-        const { proven, rawTx } = await this.getProvenOrRawTx(txid, trx);
-        return proven !== undefined || rawTx !== undefined;
-    }
-    /**
-     * Pulls data from storage to build a valid beef for a txid.
-     *
-     * Optionally merges the data into an existing beef.
-     * Optionally requires a minimum number of proof levels.
-     *
-     * @param txid
-     * @param mergeToBeef
-     * @param trustSelf
-     * @param knownTxids
-     * @param trx
-     * @param requiredLevels
-     * @returns
-     */
-    async getValidBeefForKnownTxid(txid, mergeToBeef, trustSelf, knownTxids, trx, requiredLevels) {
-        const beef = await this.getValidBeefForTxid(txid, mergeToBeef, trustSelf, knownTxids, trx, requiredLevels);
-        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 ?? 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 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 != null)
-                beef.mergeBeef(r.inputBEEF);
-            if ((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;
-    }
-    async getBeefForTransaction(txid, options) {
-        const beef = await (0, getBeefForTransaction_1.getBeefForTransaction)(this, txid, options);
-        return beef;
-    }
-    async findMonitorEventById(id, trx) {
-        return (0, utilityHelpers_1.verifyOneOrNone)(await this.findMonitorEvents({ partial: { id }, trx }));
-    }
-    async relinquishCertificate(auth, args) {
-        const vargs = sdk_1.Validation.validateRelinquishCertificateArgs(args);
-        const cert = (0, utilityHelpers_1.verifyOne)(await this.findCertificates({
-            partial: {
-                certifier: vargs.certifier,
-                serialNumber: vargs.serialNumber,
-                type: vargs.type
-            }
-        }));
-        return await this.updateCertificate(cert.certificateId, {
-            isDeleted: true
-        });
-    }
-    async relinquishOutput(auth, args) {
-        const vargs = sdk_1.Validation.validateRelinquishOutputArgs(args);
-        const { txid, vout } = sdk_1.Validation.parseWalletOutpoint(vargs.output);
-        const output = (0, utilityHelpers_1.verifyOne)(await this.findOutputs({ partial: { userId: auth.userId, txid, vout } }));
-        return await this.updateOutput(output.outputId, { basketId: undefined });
-    }
-    async processSyncChunk(args, chunk) {
-        const user = (0, utilityHelpers_1.verifyTruthy)(await this.findUserByIdentityKey(args.identityKey));
-        const ss = new entities_1.EntitySyncState((0, utilityHelpers_1.verifyOne)(await this.findSyncStates({
-            partial: {
-                storageIdentityKey: args.fromStorageIdentityKey,
-                userId: user.userId
-            }
-        })));
-        const r = await ss.processSyncChunk(this, args, chunk);
-        return r;
-    }
-    /**
-     * Handles storage changes when a valid MerklePath and mined block header are found for a ProvenTxReq txid.
-     *
-     * Performs the following storage updates (typically):
-     * 1. Lookup the exising `ProvenTxReq` record for its rawTx
-     * 2. Insert a new ProvenTx record using properties from `args` and rawTx, yielding a new provenTxId
-     * 3. Update ProvenTxReq record with status 'completed' and new provenTxId value (and history of status changed)
-     * 4. Unpack notify transactionIds from req and update each transaction's status to 'completed', provenTxId value.
-     * 5. Update ProvenTxReq history again to record that transactions have been notified.
-     * 6. Return results...
-     *
-     * Alterations of "typically" to handle:
-     */
-    async updateProvenTxReqWithNewProvenTx(args) {
-        const req = await entities_1.EntityProvenTxReq.fromStorageId(this, args.provenTxReqId);
-        let proven;
-        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 } })));
-            if (req.status !== 'completed' || req.provenTxId !== proven.provenTxId) {
-                req.status = 'completed';
-                req.provenTxId = proven.provenTxId;
-                await req.updateStorageDynamicProperties(this);
-            }
-        }
-        else {
-            proven = await this.transaction(async (trx) => {
-                const { proven: api } = await this.findOrInsertProvenTx({
-                    created_at: new Date(),
-                    updated_at: new Date(),
-                    provenTxId: 0,
-                    txid: args.txid,
-                    height: args.height,
-                    index: args.index,
-                    merklePath: args.merklePath,
-                    rawTx: req.rawTx,
-                    blockHash: args.blockHash,
-                    merkleRoot: args.merkleRoot
-                }, trx);
-                const found = new entities_1.EntityProvenTx(api);
-                if (req.status !== 'completed' || req.provenTxId !== found.provenTxId) {
-                    req.status = 'completed';
-                    req.provenTxId = found.provenTxId;
-                    await req.updateStorageDynamicProperties(this, trx);
-                }
-                return found;
-            });
-        }
-        await this.reconcileProvenTxReqTransactions(req, proven);
-        const r = {
-            status: req.status,
-            history: req.apiHistory,
-            provenTxId: proven.provenTxId,
-            notified: req.notified,
-            notify: req.apiNotify
-        };
-        return r;
-    }
-    /**
-     * Reconcile completed proof requests whose transaction fan-out previously
-     * failed or whose durable notification state drifted.
-     *
-     * This is called by TaskReviewStatus so a completed request with
-     * `notified = false` is retried and can become eligible for normal purge.
-     */
-    async reconcileCompletedProvenTxReqs() {
-        let log = '';
-        const reqs = await this.findProvenTxReqs({
-            partial: { status: 'completed', notified: false }
-        });
-        for (const reqApi of reqs) {
-            const req = new entities_1.EntityProvenTxReq(reqApi);
-            if (req.provenTxId == null || req.provenTxId <= 0) {
-                log += `completed req ${req.id} cannot reconcile without provenTxId\n`;
-                continue;
-            }
-            const provenApi = (0, utilityHelpers_1.verifyOneOrNone)(await this.findProvenTxs({
-                partial: { provenTxId: req.provenTxId }
-            }));
-            if (provenApi == null) {
-                log += `completed req ${req.id} cannot reconcile missing provenTx ${req.provenTxId}\n`;
-                continue;
-            }
-            await this.reconcileProvenTxReqTransactions(req, new entities_1.EntityProvenTx(provenApi));
-            if (req.notified)
-                log += `completed req ${req.id} transaction notifications reconciled\n`;
-        }
-        return { log };
-    }
-    /**
-     * Restore every failed local copy of a transaction before proof completion.
-     * Also heals the request's notification set from the authoritative txid
-     * lookup so TaskUnFail cannot omit a local copy after notification drift.
-     */
-    async unfailTransactionsForProof(req, indent = 0, requestUpdate) {
-        const transactions = await this.findTransactions({
-            partial: { txid: req.txid },
-            noRawTx: true
-        });
-        const transactionsToRepair = transactions.filter(transaction => requestUpdate != null || transaction.status === 'failed');
-        // Proof completion is the hot path. If no failed transaction needs repair,
-        // notification reconciliation below will perform the required atomic work;
-        // avoid an otherwise empty refresh/write transaction here.
-        if (transactionsToRepair.length === 0 && requestUpdate == null)
-            return '';
-        // Refresh only after deciding recovery is required, while the caller has
-        // not yet applied an intended request transition. TaskUnFail passes that
-        // 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));
-                }
-            }
-        }
-        return await this.transaction(async (trx) => {
-            let log = '';
-            await req.refreshFromStorage(this, trx);
-            const currentTransactions = await this.findTransactions({
-                partial: { txid: req.txid },
-                noRawTx: true,
-                trx
-            });
-            const knownNotificationIds = new Set(req.notify.transactionIds ?? []);
-            if (requestUpdate != null) {
-                req.status = requestUpdate.status;
-                req.attempts = requestUpdate.attempts;
-            }
-            for (const tx of currentTransactions) {
-                if (!knownNotificationIds.has(tx.transactionId)) {
-                    req.addNotifyTransactionId(tx.transactionId);
-                    knownNotificationIds.add(tx.transactionId);
-                }
-                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);
-                    }
-                }
-            }
-            await req.updateStorageDynamicProperties(this, trx);
-            return log;
-        });
-    }
-    async reconcileProvenTxReqTransactions(req, proven) {
-        // A transaction can be internalized concurrently by several users. Their
-        // transaction rows share a txid but race while merging the JSON notify
-        // list, so a last-writer-wins update can omit one local copy. A valid proof
-        // is authoritative for every local transaction with this txid: discover
-        // them from the indexed transaction table and atomically heal both the
-        // durable notify set and any row that missed the original completion.
-        // Keep the clean proof-completion path identical to the normal notification
-        // transaction. Only leave it when failed rows require external UTXO checks,
-        // which must run without an open transaction.
-        let repairAttempts = 0;
-        for (;;) {
-            const needsRepair = await this.transaction(async (trx) => {
-                await req.refreshFromStorage(this, trx);
-                const transactions = await this.findTransactions({ partial: { txid: req.txid }, trx });
-                if (transactions.some(transaction => transaction.status === 'failed'))
-                    return true;
-                const knownNotificationIds = new Set(req.notify.transactionIds ?? []);
-                for (const transaction of transactions) {
-                    if (!knownNotificationIds.has(transaction.transactionId)) {
-                        req.addNotifyTransactionId(transaction.transactionId);
-                        knownNotificationIds.add(transaction.transactionId);
-                    }
-                }
-                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 completedTransactions = await this.findTransactions({ partial: { txid: req.txid }, trx });
-                req.notified = updatesSucceeded && completedTransactions.every(transaction => transaction.status === 'completed' && transaction.provenTxId === proven.provenTxId);
-                await req.updateStorageDynamicProperties(this, trx);
-                return false;
-            });
-            if (!needsRepair)
-                return;
-            if (repairAttempts >= 2) {
-                throw new WERR_errors_1.WERR_INTERNAL(`Transactions for ${req.txid} repeatedly changed to failed during proof recovery.`);
-            }
-            repairAttempts++;
-            await this.unfailTransactionsForProof(req);
-        }
-    }
-    /**
-     * For each spendable output in the 'default' basket of the authenticated user,
-     * verify that the output script, satoshis, vout and txid match that of an output
-     * still in the mempool of at least one service provider.
-     *
-     * @returns object with invalidSpendableOutputs array. A good result is an empty array.
-     */
-    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 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) {
-        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 ?? ''}`);
-        return r.isUtxo === true;
-    }
-    async updateProvenTxReqDynamics(id, update, trx) {
-        const partial = {};
-        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 = update.wasBroadcast ?? false;
-        if (Number.isInteger(update.rebroadcastAttempts))
-            partial.rebroadcastAttempts = update.rebroadcastAttempts ?? 0;
-        return await this.updateProvenTxReq(id, partial, trx);
-    }
-    async extendOutput(o, includeBasket = false, includeTags = false, trx) {
-        const ox = o;
-        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);
-        }
-        return o;
-    }
-    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 === '')
-            return;
-        // if there is an outputScript and its length is the expected length return what we have.
-        if (o.lockingScript?.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 == null)
-            return;
-        o.lockingScript = script;
-    }
-}
-exports.StorageProvider = StorageProvider;
-function validateStorageFeeModel(v) {
-    const r = {
-        model: 'sat/kb',
-        value: 100
-    };
-    if (typeof v === 'object') {
-        if (v.model !== 'sat/kb')
-            throw new WERR_errors_1.WERR_INVALID_PARAMETER('StorageFeeModel.model', '"sat/kb"');
-        if (typeof v.value === 'number') {
-            r.value = v.value;
-        }
-    }
-    return r;
-}
-//# sourceMappingURL=StorageProvider.js.map