@bsv/wallet-toolbox-client 2.4.4 → 2.4.20

package/out/src/storage/methods/actionBatch.js

@@ -1,644 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ACTION_BATCH_MAX_RESERVATION_EXTENSION_OUTPUTS = exports.ACTION_BATCH_HARD_LIFETIME_MS = exports.ACTION_BATCH_LEASE_MS = void 0;
-exports.getActionBatchCapabilities = getActionBatchCapabilities;
-exports.cleanupExpiredActionBatches = cleanupExpiredActionBatches;
-exports.beginActionBatch = beginActionBatch;
-exports.extendActionBatch = extendActionBatch;
-exports.renewActionBatch = renewActionBatch;
-exports.commitActionBatch = commitActionBatch;
-exports.abortActionBatch = abortActionBatch;
-const sdk_1 = require("@bsv/sdk");
-const WERR_errors_1 = require("../../sdk/WERR_errors");
-const utilityHelpers_1 = require("../../utility/utilityHelpers");
-const actionBatchDigest_1 = require("../../utility/actionBatchDigest");
-const StorageProvider_1 = require("../StorageProvider");
-const EntityProvenTxReq_1 = require("../schema/entities/EntityProvenTxReq");
-const managedChange_1 = require("./managedChange");
-const parseTxScriptOffsets_1 = require("../../utility/parseTxScriptOffsets");
-const processAction_1 = require("./processAction");
-const utils_1 = require("./utils");
-const actionPlanning_1 = require("./actionPlanning");
-const actionBatchBlobs_1 = require("./actionBatchBlobs");
-const actionBatchValidation_1 = require("./actionBatchValidation");
-exports.ACTION_BATCH_LEASE_MS = 15 * 60 * 1000;
-exports.ACTION_BATCH_HARD_LIFETIME_MS = 60 * 60 * 1000;
-const INITIAL_RESERVATION_LIMIT = 8;
-const INITIAL_EXTRA_OUTPUTS = 3;
-exports.ACTION_BATCH_MAX_RESERVATION_EXTENSION_OUTPUTS = 64;
-function getActionBatchCapabilities() {
-    return {
-        actionBatch: {
-            version: 1,
-            maxInlineBytes: actionBatchBlobs_1.ACTION_BATCH_MAX_INLINE_BYTES,
-            maxBlobBytes: actionBatchBlobs_1.ACTION_BATCH_MAX_BLOB_BYTES,
-            maxConcurrentUploads: actionBatchBlobs_1.ACTION_BATCH_MAX_CONCURRENT_UPLOADS,
-            leaseMs: exports.ACTION_BATCH_LEASE_MS,
-            hardLifetimeMs: exports.ACTION_BATCH_HARD_LIFETIME_MS
-        }
-    };
-}
-function activeExpiry(batch, now = new Date()) {
-    return batch.status !== 'active' && batch.status !== 'prepared' ||
-        batch.expiresAt.getTime() <= now.getTime() ||
-        batch.hardExpiresAt.getTime() <= now.getTime();
-}
-function canExpire(batch, now = new Date()) {
-    return (batch.status === 'active' || batch.status === 'prepared') &&
-        (batch.expiresAt.getTime() <= now.getTime() || batch.hardExpiresAt.getTime() <= now.getTime());
-}
-async function releaseBatchState(storage, batch, status, trx) {
-    await storage.deleteActionBatchOutputReservations(batch.actionBatchId, trx);
-    await storage.deleteActionBatchBlobRecords(batch.actionBatchId, trx);
-    await storage.updateActionBatch(batch.actionBatchId, { status }, trx);
-}
-async function cleanupExpiredActionBatches(storage) {
-    const now = new Date();
-    const expired = await storage.findExpiredActionBatches(now);
-    let released = 0;
-    for (const batch of expired) {
-        await storage.transaction(async (trx) => {
-            const current = await storage.findActionBatchForUpdate(batch.userId, batch.batchId, trx);
-            if (current == null || !canExpire(current, now))
-                return;
-            await releaseBatchState(storage, current, 'expired', trx);
-            released++;
-        });
-    }
-    return released;
-}
-async function availableManagedChange(storage, userId, basketId, excludeSending, trx) {
-    const statuses = ['completed', 'unproven'];
-    if (!excludeSending)
-        statuses.push('sending');
-    const outputs = (await storage.findOutputs({
-        partial: { userId, basketId, spendable: true },
-        txStatus: statuses,
-        trx
-    })).filter(managedChange_1.isAutoSpendableChangeOutput);
-    const reserved = new Set(await storage.findReservedActionBatchOutputIds(outputs.map(o => o.outputId), trx));
-    return outputs.filter(output => output.spentBy == null && !reserved.has(output.outputId));
-}
-function sourceOutputFromBeef(beef, outpoint) {
-    const tx = beef.findTxid(outpoint.txid)?.tx;
-    const output = tx?.outputs[outpoint.vout];
-    if (output == null)
-        return undefined;
-    return { satoshis: sdk_1.Validation.validateSatoshis(output.satoshis, 'source output satoshis'), lockingScript: output.lockingScript };
-}
-async function resolveExplicitOutputs(storage, userId, args) {
-    const byOutpoint = await storage.findOutputsByOutpoints(userId, args.inputs.map(input => input.outpoint));
-    const beef = args.inputBEEF == null ? new sdk_1.Beef() : sdk_1.Beef.fromBinary(args.inputBEEF);
-    const outputs = [];
-    let inputSatoshis = 0;
-    for (const input of args.inputs) {
-        const output = byOutpoint[`${input.outpoint.txid}.${input.outpoint.vout}`];
-        if (output != null) {
-            await storage.validateOutputScript(output);
-            outputs.push(output);
-            inputSatoshis += output.satoshis;
-            continue;
-        }
-        const source = sourceOutputFromBeef(beef, input.outpoint);
-        if (source == null) {
-            throw new WERR_errors_1.WERR_INVALID_PARAMETER('inputBEEF', `proof data for ${input.outpoint.txid}.${input.outpoint.vout}`);
-        }
-        inputSatoshis += source.satoshis;
-    }
-    return { outputs, inputSatoshis };
-}
-async function resolveNoSendChangeOutputs(storage, userId, args) {
-    const outpoints = args.options.noSendChange;
-    const byOutpoint = await storage.findOutputsByOutpoints(userId, outpoints);
-    const outputs = [];
-    let inputSatoshis = 0;
-    for (const outpoint of outpoints) {
-        const key = `${outpoint.txid}.${outpoint.vout}`;
-        const output = byOutpoint[key];
-        if (output == null || !output.spendable || output.spentBy != null || !(0, managedChange_1.isAutoSpendableChangeOutput)(output)) {
-            throw new WERR_errors_1.WERR_INVALID_PARAMETER('noSendChange', `spendable wallet-managed output ${key}`);
-        }
-        await storage.validateOutputScript(output);
-        outputs.push(output);
-        inputSatoshis += output.satoshis;
-    }
-    return { outputs, inputSatoshis };
-}
-function estimateFirstActionTarget(storage, args, inputSatoshis) {
-    const outputSatoshis = args.outputs.reduce((sum, output) => sum + output.satoshis, 0) + storage.commissionSatoshis;
-    const inputLengths = args.inputs.map(input => input.unlockingScriptLength);
-    const outputLengths = args.outputs.map(output => output.lockingScript.length / 2);
-    if (storage.commissionSatoshis > 0)
-        outputLengths.push(25);
-    outputLengths.push(25);
-    const fee = (0, StorageProvider_1.validateStorageFeeModel)(storage.feeModel).value ?? 0;
-    const minFee = Math.ceil((0, utils_1.transactionSize)([...inputLengths, 107], outputLengths) * fee / 1000);
-    return Math.max(1, outputSatoshis + minFee - inputSatoshis);
-}
-function chooseReservationPool(candidates, targetSatoshis, limit, extras, fillLimit, planningCosts) {
-    const remaining = candidates
-        .filter(output => output.satoshis > planningCosts.marginalInputFee);
-    const chosen = [];
-    // A reservation is useful to generateChangeSdk only after it also covers
-    // the marginal funding-input fee and leaves an economically viable first
-    // change output. Without this buffer, a tiny target repeatedly selects dust
-    // that satisfies the nominal deficit but can never close the real plan.
-    let deficit = targetSatoshis + planningCosts.firstChangeCost;
-    while (deficit > 0 && chosen.length < limit) {
-        const output = (0, actionPlanning_1.selectCanonicalChange)(remaining, deficit + planningCosts.marginalInputFee);
-        if (output == null)
-            break;
-        chosen.push(output);
-        remaining.splice(remaining.indexOf(output), 1);
-        deficit -= output.satoshis - planningCosts.marginalInputFee;
-    }
-    const desiredCount = fillLimit ? limit : Math.min(limit, chosen.length + extras);
-    while (remaining.length > 0 && chosen.length < desiredCount) {
-        const output = (0, actionPlanning_1.selectCanonicalChange)(remaining, targetSatoshis);
-        if (output == null)
-            break;
-        chosen.push(output);
-        remaining.splice(remaining.indexOf(output), 1);
-    }
-    return chosen;
-}
-function reservationPlanningCosts(storage, basket) {
-    const satsPerKb = (0, StorageProvider_1.validateStorageFeeModel)(storage.feeModel).value ?? 0;
-    const minimumSpendSize = (0, utils_1.transactionSize)([107], [25]);
-    const minimumSpendFee = Math.ceil(minimumSpendSize * satsPerKb / 1000);
-    const dustFloor = Math.max(1, minimumSpendFee * 2);
-    const marginalInputSize = (0, utils_1.transactionSize)([107], []) - (0, utils_1.transactionSize)([], []);
-    const marginalOutputSize = (0, utils_1.transactionSize)([], [25]) - (0, utils_1.transactionSize)([], []);
-    const desiredFirstChange = Math.max(dustFloor, Math.max(1, Math.round(basket.minimumDesiredUTXOValue / 4)));
-    return {
-        firstChangeCost: desiredFirstChange + Math.ceil(marginalOutputSize * satsPerKb / 1000),
-        marginalInputFee: Math.ceil(marginalInputSize * satsPerKb / 1000)
-    };
-}
-async function reserveOutputs(storage, batch, outputs, trx) {
-    const now = new Date();
-    const unique = [...new Map(outputs.map(output => [output.outputId, output])).values()];
-    const reserve = async (transaction) => {
-        const outpoints = unique.map(output => {
-            if (output.txid == null)
-                throw new WERR_errors_1.WERR_INVALID_OPERATION('action batch output is missing its txid');
-            return { txid: output.txid, vout: output.vout };
-        });
-        const current = await storage.findOutputsByOutpointsForUpdate(batch.userId, outpoints, transaction);
-        for (const output of unique) {
-            const stored = output.txid == null ? undefined : current[`${output.txid}.${output.vout}`];
-            if (stored == null || !stored.spendable || stored.spentBy != null) {
-                throw new WERR_errors_1.WERR_INVALID_OPERATION('one or more action batch outputs are no longer spendable');
-            }
-        }
-        const conflicts = await storage.findReservedActionBatchOutputIds(unique.map(output => output.outputId), transaction);
-        if (conflicts.length > 0)
-            throw new WERR_errors_1.WERR_INVALID_OPERATION('one or more action batch outputs were concurrently reserved');
-        await storage.reserveActionBatchOutputs(unique.map(output => ({
-            actionBatchId: batch.actionBatchId,
-            outputId: output.outputId,
-            created_at: now,
-            updated_at: now
-        })), transaction);
-    };
-    if (trx != null)
-        await reserve(trx);
-    else
-        await storage.transaction(reserve);
-}
-async function makeFundingResult(storage, args, outputs) {
-    const beef = new sdk_1.Beef();
-    const result = [];
-    for (const output of outputs) {
-        await storage.validateOutputScript(output);
-        const copy = { ...output };
-        if (args.isSignAction && args.includeAllSourceTransactions) {
-            copy.sourceTransaction = await storage.getRawTxOfKnownValidTransaction(output.txid);
-        }
-        if (output.txid != null && beef.findTxid(output.txid) == null) {
-            beef.mergeBeef(await storage.getBeefForTransaction(output.txid, {
-                knownTxids: args.options.knownTxids,
-                ignoreServices: true
-            }));
-        }
-        result.push(copy);
-    }
-    return { outputs: result, beef: beef.toUint8Array() };
-}
-function newBatch(userId, batchId) {
-    const now = new Date();
-    return {
-        actionBatchId: 0,
-        userId,
-        batchId,
-        status: 'active',
-        expiresAt: new Date(now.getTime() + exports.ACTION_BATCH_LEASE_MS),
-        hardExpiresAt: new Date(now.getTime() + exports.ACTION_BATCH_HARD_LIFETIME_MS),
-        created_at: now,
-        updated_at: now
-    };
-}
-async function beginActionBatch(storage, auth, args) {
-    const userId = (0, utilityHelpers_1.verifyId)(auth.userId);
-    await cleanupExpiredActionBatches(storage);
-    if (await storage.findActionBatch(userId, args.batchId) != null) {
-        throw new WERR_errors_1.WERR_INVALID_PARAMETER('batchId', 'unique');
-    }
-    const changeBasket = (0, utilityHelpers_1.verifyOne)(await storage.findOutputBaskets({ partial: { userId, name: 'default' } }));
-    const explicit = await resolveExplicitOutputs(storage, userId, args.firstAction);
-    const noSendChange = await resolveNoSendChangeOutputs(storage, userId, args.firstAction);
-    const fixedOutputIds = new Set([...explicit.outputs, ...noSendChange.outputs].map(output => output.outputId));
-    const available = (await availableManagedChange(storage, userId, changeBasket.basketId, !args.firstAction.isDelayed)).filter(output => !fixedOutputIds.has(output.outputId));
-    const target = estimateFirstActionTarget(storage, args.firstAction, explicit.inputSatoshis + noSendChange.inputSatoshis);
-    const fixedOutputs = [...explicit.outputs, ...noSendChange.outputs];
-    const requiredCapacity = Math.max(0, INITIAL_RESERVATION_LIMIT - fixedOutputs.length);
-    const funding = chooseReservationPool(available, target, requiredCapacity, INITIAL_EXTRA_OUTPUTS, false, reservationPlanningCosts(storage, changeBasket));
-    const batch = newBatch(userId, args.batchId);
-    await storage.transaction(async (trx) => {
-        await storage.insertActionBatch(batch, trx);
-        await reserveOutputs(storage, batch, [...fixedOutputs, ...funding], trx);
-    });
-    let fundingResult;
-    try {
-        fundingResult = await makeFundingResult(storage, args.firstAction, [...funding, ...fixedOutputs]);
-    }
-    catch (error) {
-        await storage.transaction(async (trx) => await releaseBatchState(storage, batch, 'aborted', trx));
-        throw error;
-    }
-    const explicitIds = new Set(fixedOutputs.map(output => output.outputId));
-    return {
-        batchId: batch.batchId,
-        expiresAt: batch.expiresAt.toISOString(),
-        hardExpiresAt: batch.hardExpiresAt.toISOString(),
-        changeBasket,
-        feeModel: (0, StorageProvider_1.validateStorageFeeModel)(storage.feeModel),
-        commissionSatoshis: storage.commissionSatoshis,
-        commissionPubKeyHex: storage.commissionPubKeyHex,
-        availableChangeCount: available.length,
-        reservedOutputs: fundingResult.outputs.filter(output => funding.some(candidate => candidate.outputId === output.outputId)),
-        explicitOutputs: fundingResult.outputs.filter(output => explicitIds.has(output.outputId)),
-        inputBeef: fundingResult.beef
-    };
-}
-function requireLiveBatch(batch) {
-    if (batch == null || activeExpiry(batch))
-        throw new WERR_errors_1.WERR_INVALID_OPERATION('action batch is not active');
-    return batch;
-}
-async function extendActionBatch(storage, auth, args) {
-    const userId = (0, utilityHelpers_1.verifyId)(auth.userId);
-    await cleanupExpiredActionBatches(storage);
-    const batch = requireLiveBatch(await storage.findActionBatch(userId, args.batchId));
-    const basket = (0, utilityHelpers_1.verifyOne)(await storage.findOutputBaskets({ partial: { userId, name: 'default' } }));
-    const alreadyReserved = await storage.findActionBatchOutputIds(batch.actionBatchId);
-    const available = await availableManagedChange(storage, userId, basket.basketId, false);
-    if (!Number.isSafeInteger(args.requestedOutputs) || args.requestedOutputs < 0) {
-        throw new WERR_errors_1.WERR_INVALID_PARAMETER('requestedOutputs', 'non-negative safe integer');
-    }
-    const requestedCount = Math.min(args.requestedOutputs, exports.ACTION_BATCH_MAX_RESERVATION_EXTENSION_OUTPUTS);
-    const funding = chooseReservationPool(available, Math.max(1, args.targetSatoshis), requestedCount, 0, true, reservationPlanningCosts(storage, basket));
-    const explicitByOutpoint = await storage.findOutputsByOutpoints(userId, args.explicitOutpoints);
-    const explicit = Object.values(explicitByOutpoint)
-        .filter(output => !alreadyReserved.includes(output.outputId));
-    const fundingShape = argsToFundingShape(args.includeSourceTransactions);
-    const fundingResult = await makeFundingResult(storage, fundingShape, [...funding, ...explicit]);
-    const expiresAt = new Date(Math.min(batch.hardExpiresAt.getTime(), Date.now() + exports.ACTION_BATCH_LEASE_MS));
-    await storage.transaction(async (trx) => {
-        const current = requireLiveBatch(await storage.findActionBatchForUpdate(userId, args.batchId, trx));
-        await reserveOutputs(storage, current, [...funding, ...explicit], trx);
-        await storage.updateActionBatch(current.actionBatchId, { expiresAt }, trx);
-    });
-    return {
-        expiresAt: expiresAt.toISOString(),
-        reservedOutputs: fundingResult.outputs.filter(output => funding.some(candidate => candidate.outputId === output.outputId)),
-        explicitOutputs: fundingResult.outputs.filter(output => explicit.some(candidate => candidate.outputId === output.outputId)),
-        inputBeef: fundingResult.beef
-    };
-}
-function argsToFundingShape(includeSourceTransactions) {
-    return {
-        inputs: [], outputs: [], labels: [], description: 'action batch extension', version: 1, lockTime: 0,
-        options: {
-            acceptDelayedBroadcast: true, returnTXIDOnly: false, noSend: true, sendWith: [], signAndProcess: true,
-            knownTxids: [], noSendChange: [], randomizeOutputs: true
-        },
-        isSendWith: false, isNewTx: true, isRemixChange: false, isNoSend: true, isDelayed: true,
-        isTestWerrReviewActions: false,
-        isSignAction: includeSourceTransactions,
-        includeAllSourceTransactions: includeSourceTransactions
-    };
-}
-async function renewActionBatch(storage, auth, batchId) {
-    const userId = (0, utilityHelpers_1.verifyId)(auth.userId);
-    return await storage.transaction(async (trx) => {
-        const batch = requireLiveBatch(await storage.findActionBatchForUpdate(userId, batchId, trx));
-        const expiresAt = new Date(Math.min(batch.hardExpiresAt.getTime(), Date.now() + exports.ACTION_BATCH_LEASE_MS));
-        await storage.updateActionBatch(batch.actionBatchId, { expiresAt }, trx);
-        return { expiresAt: expiresAt.toISOString() };
-    });
-}
-async function reacquireManifestInputs(storage, userId, batch, validated, trx) {
-    if (batch.hardExpiresAt.getTime() <= Date.now()) {
-        throw new WERR_errors_1.WERR_INVALID_OPERATION('action batch hard lifetime has expired');
-    }
-    const stagedTxids = new Set(validated.actions.map(({ action }) => action.txid));
-    const outpoints = [...new Map(validated.actions.flatMap(({ action }) => action.plan.inputs)
-            .filter(input => !stagedTxids.has(input.sourceTxid))
-            .map(input => [`${input.sourceTxid}.${input.sourceVout}`, {
-                txid: input.sourceTxid,
-                vout: input.sourceVout,
-                providedBy: input.providedBy
-            }])).values()];
-    const stored = await storage.findOutputsByOutpointsForUpdate(userId, outpoints, trx);
-    await storage.deleteActionBatchOutputReservations(batch.actionBatchId, trx);
-    const outputs = [];
-    for (const outpoint of outpoints) {
-        const key = `${outpoint.txid}.${outpoint.vout}`;
-        const output = stored[key];
-        if (output == null) {
-            if (outpoint.providedBy === 'storage' || outpoint.providedBy === 'you-and-storage') {
-                throw new WERR_errors_1.WERR_INVALID_OPERATION(`reserved input ${key} is no longer available`);
-            }
-            continue;
-        }
-        if (!output.spendable || output.spentBy != null) {
-            throw new WERR_errors_1.WERR_INVALID_OPERATION(`input ${key} is no longer spendable`);
-        }
-        outputs.push(output);
-    }
-    const conflicts = await storage.findReservedActionBatchOutputIds(outputs.map(output => output.outputId), trx);
-    if (conflicts.length > 0) {
-        throw new WERR_errors_1.WERR_INVALID_OPERATION('one or more expired action batch inputs were reserved elsewhere');
-    }
-    const now = new Date();
-    await storage.reserveActionBatchOutputs(outputs.map(output => ({
-        actionBatchId: batch.actionBatchId,
-        outputId: output.outputId,
-        created_at: now,
-        updated_at: now
-    })), trx);
-    await storage.updateActionBatch(batch.actionBatchId, {
-        status: 'active',
-        expiresAt: new Date(Math.min(batch.hardExpiresAt.getTime(), now.getTime() + exports.ACTION_BATCH_LEASE_MS))
-    }, trx);
-}
-function transactionStatuses(action) {
-    if (action.metadata.isNoSend)
-        return { tx: 'nosend', req: 'nosend' };
-    if (action.metadata.isDelayed)
-        return { tx: 'unprocessed', req: 'unsent' };
-    return { tx: 'unprocessed', req: 'unprocessed' };
-}
-async function persistLabels(storage, userId, transactionId, labels, trx) {
-    for (const label of new Set(labels)) {
-        const row = await storage.findOrInsertTxLabel(userId, label, trx);
-        await storage.findOrInsertTxLabelMap(transactionId, (0, utilityHelpers_1.verifyId)(row.txLabelId), trx);
-    }
-}
-async function persistOutputs(storage, userId, transactionId, validated, trx) {
-    const { action, tx, rawTx } = validated;
-    const basketNames = [...new Set(action.plan.outputs.map(output => output.basket).filter((name) => name != null))];
-    if (action.plan.outputs.some(output => output.purpose === 'change'))
-        basketNames.push('default');
-    const baskets = await storage.findOrInsertOutputBasketsBulk(userId, [...new Set(basketNames)], trx);
-    const tagNames = [...new Set(action.plan.outputs.flatMap(output => output.tags))];
-    const tags = await storage.findOrInsertOutputTagsBulk(userId, tagNames, trx);
-    const offsets = (0, parseTxScriptOffsets_1.parseTxScriptOffsets)(rawTx);
-    const rows = [];
-    for (let index = 0; index < action.plan.outputs.length; index++) {
-        const planned = action.plan.outputs[index];
-        const output = tx.outputs[planned.vout];
-        const isChange = planned.providedBy === 'storage' && planned.purpose === 'change';
-        const isCommission = planned.providedBy === 'storage' &&
-            (planned.purpose === 'storage-commission' || planned.purpose === 'service-charge');
-        const offset = offsets.outputs[planned.vout];
-        const lockingScript = output.lockingScript.toBinary();
-        const now = new Date();
-        const row = {
-            outputId: 0,
-            userId,
-            transactionId,
-            basketId: isChange ? baskets.default?.basketId : (planned.basket == null ? undefined : baskets[planned.basket].basketId),
-            spendable: !isCommission,
-            change: isChange,
-            outputDescription: planned.outputDescription,
-            vout: planned.vout,
-            satoshis: planned.satoshis,
-            providedBy: planned.providedBy,
-            purpose: isCommission ? 'storage-commission' : (planned.purpose ?? ''),
-            type: isChange ? 'P2PKH' : 'custom',
-            txid: action.txid,
-            derivationPrefix: isChange ? action.plan.derivationPrefix : undefined,
-            derivationSuffix: isChange ? planned.derivationSuffix : undefined,
-            customInstructions: planned.customInstructions,
-            scriptLength: offset.length,
-            scriptOffset: offset.offset,
-            lockingScript: offset.length > storage.getSettings().maxOutputScript ? undefined : lockingScript,
-            created_at: now,
-            updated_at: now
-        };
-        row.outputId = await storage.insertOutput(row, trx);
-        for (const tagName of new Set(planned.tags)) {
-            const tag = tags[tagName];
-            await storage.findOrInsertOutputTagMap(row.outputId, (0, utilityHelpers_1.verifyId)(tag.outputTagId), trx);
-        }
-        if (isCommission) {
-            const commission = {
-                commissionId: 0,
-                userId,
-                transactionId,
-                satoshis: planned.satoshis,
-                keyOffset: action.commissionKeyOffset ?? '',
-                isRedeemed: false,
-                lockingScript,
-                created_at: now,
-                updated_at: now
-            };
-            await storage.insertCommission(commission, trx);
-        }
-        rows.push(row);
-    }
-    return rows;
-}
-async function persistAction(storage, userId, validated, reservedOutputIds, stagedByOutpoint, trx) {
-    const { action, tx, rawTx } = validated;
-    const statuses = transactionStatuses(action);
-    const managedInputSatoshis = action.plan.inputs
-        .filter(input => input.vin >= action.metadata.inputs.length)
-        .reduce((sum, input) => sum + input.sourceSatoshis, 0);
-    const changeOutputSatoshis = action.plan.outputs
-        .filter(output => output.purpose === 'change')
-        .reduce((sum, output) => sum + output.satoshis, 0);
-    const now = new Date();
-    const transaction = {
-        transactionId: 0,
-        userId,
-        status: statuses.tx,
-        reference: action.reference,
-        isOutgoing: true,
-        satoshis: changeOutputSatoshis - managedInputSatoshis,
-        description: action.metadata.description,
-        version: tx.version,
-        lockTime: tx.lockTime,
-        txid: action.txid,
-        created_at: now,
-        updated_at: now
-    };
-    transaction.transactionId = await storage.insertTransaction(transaction, trx);
-    await persistLabels(storage, userId, transaction.transactionId, action.metadata.labels, trx);
-    for (const input of action.plan.inputs) {
-        const outpoint = `${input.sourceTxid}.${input.sourceVout}`;
-        let output = stagedByOutpoint.get(outpoint);
-        output ??= (await storage.findOutputsByOutpoints(userId, [{ txid: input.sourceTxid, vout: input.sourceVout }], trx))[outpoint];
-        if (output == null)
-            continue;
-        if (output.spentBy != null || !output.spendable)
-            throw new WERR_errors_1.WERR_INVALID_OPERATION(`input ${outpoint} is no longer spendable`);
-        if (!stagedByOutpoint.has(outpoint) && !reservedOutputIds.has(output.outputId)) {
-            throw new WERR_errors_1.WERR_INVALID_OPERATION(`input ${outpoint} was not reserved by this action batch`);
-        }
-        await storage.updateOutput(output.outputId, {
-            spendable: false,
-            spentBy: transaction.transactionId,
-            spendingDescription: action.metadata.inputs[input.vin]?.inputDescription
-        }, trx);
-        output.spendable = false;
-        output.spentBy = transaction.transactionId;
-    }
-    const outputRows = await persistOutputs(storage, userId, transaction.transactionId, validated, trx);
-    for (const output of outputRows)
-        stagedByOutpoint.set(`${action.txid}.${output.vout}`, output);
-    const req = EntityProvenTxReq_1.EntityProvenTxReq.fromTxid(action.txid, rawTx, validated.inputBeef);
-    req.status = statuses.req;
-    req.addNotifyTransactionId(transaction.transactionId);
-    await req.insertOrMerge(storage, trx);
-}
-async function persistManifestAtomically(storage, userId, batch, manifest, validated) {
-    return await storage.transaction(async (trx) => {
-        const current = await storage.findActionBatchForUpdate(userId, batch.batchId, trx);
-        if (current == null)
-            throw new WERR_errors_1.WERR_INVALID_OPERATION('action batch was not found');
-        if (current.status === 'committed') {
-            if (current.manifestDigest !== manifest.digest) {
-                throw new WERR_errors_1.WERR_INVALID_OPERATION('batch committed with another manifest');
-            }
-            return { batch: current, alreadyCommitted: true };
-        }
-        if (current.status === 'aborted')
-            throw new WERR_errors_1.WERR_INVALID_OPERATION('aborted action batch cannot be committed');
-        if (current.manifestDigest != null && current.manifestDigest !== manifest.digest) {
-            throw new WERR_errors_1.WERR_INVALID_OPERATION('batch prepared with another manifest');
-        }
-        const needsReacquire = current.status === 'expired' || activeExpiry(current);
-        if (needsReacquire) {
-            if (current.hardExpiresAt.getTime() <= Date.now()) {
-                throw new WERR_errors_1.WERR_INVALID_OPERATION('action batch hard lifetime has expired');
-            }
-            await reacquireManifestInputs(storage, userId, current, validated, trx);
-        }
-        else {
-            requireLiveBatch(current);
-        }
-        const reservedOutputIds = new Set(await storage.findActionBatchOutputIds(current.actionBatchId, trx));
-        const stagedByOutpoint = new Map();
-        for (const action of validated.actions) {
-            await persistAction(storage, userId, action, reservedOutputIds, stagedByOutpoint, trx);
-        }
-        await storage.deleteActionBatchOutputReservations(current.actionBatchId, trx);
-        await storage.deleteActionBatchBlobRecords(current.actionBatchId, trx);
-        await storage.updateActionBatch(current.actionBatchId, {
-            status: 'committed',
-            manifestDigest: manifest.digest
-        }, trx);
-        current.status = 'committed';
-        current.manifestDigest = manifest.digest;
-        return { batch: current, alreadyCommitted: false };
-    });
-}
-async function completeCommittedBatch(storage, userId, batch, manifest, alreadyCommitted) {
-    if (batch.result != null) {
-        const saved = JSON.parse(batch.result);
-        return {
-            batchId: saved.batchId,
-            manifestDigest: saved.manifestDigest,
-            committedTxids: saved.committedTxids,
-            alreadyCommitted: true,
-            sendWithResults: saved.sendWithResults,
-            notDelayedResults: saved.notDelayedResults,
-            log: saved.log
-        };
-    }
-    const { swr, ndr } = await (0, processAction_1.shareReqsWithWorld)(storage, userId, manifest.sendWith, manifest.isDelayed);
-    const result = {
-        batchId: manifest.batchId,
-        manifestDigest: manifest.digest,
-        committedTxids: manifest.actions.map(action => action.txid),
-        alreadyCommitted,
-        sendWithResults: swr,
-        notDelayedResults: ndr
-    };
-    await storage.updateActionBatch(batch.actionBatchId, { result: JSON.stringify(result) });
-    return result;
-}
-async function commitActionBatchOnce(storage, userId, manifest) {
-    const batch = await storage.findActionBatch(userId, manifest.batchId);
-    if (batch == null)
-        throw new WERR_errors_1.WERR_INVALID_OPERATION('action batch was not found');
-    if (batch.status === 'committed') {
-        if (batch.manifestDigest !== manifest.digest)
-            throw new WERR_errors_1.WERR_INVALID_OPERATION('batch committed with another manifest');
-        return await completeCommittedBatch(storage, userId, batch, manifest, true);
-    }
-    if (batch.status === 'aborted')
-        throw new WERR_errors_1.WERR_INVALID_OPERATION('aborted action batch cannot be committed');
-    const needsReacquire = batch.status === 'expired' || activeExpiry(batch);
-    if (!needsReacquire)
-        requireLiveBatch(batch);
-    else if (batch.hardExpiresAt.getTime() <= Date.now()) {
-        throw new WERR_errors_1.WERR_INVALID_OPERATION('action batch hard lifetime has expired');
-    }
-    if (batch.manifestDigest != null && batch.manifestDigest !== manifest.digest) {
-        throw new WERR_errors_1.WERR_INVALID_OPERATION('batch prepared with another manifest');
-    }
-    const validated = await (0, actionBatchValidation_1.validateManifestActions)(storage, batch, manifest);
-    const persisted = await persistManifestAtomically(storage, userId, batch, manifest, validated);
-    return await completeCommittedBatch(storage, userId, persisted.batch, manifest, persisted.alreadyCommitted);
-}
-const activeBatchCommits = new WeakMap();
-async function commitActionBatch(storage, auth, manifest) {
-    (0, actionBatchBlobs_1.validateActionBatchInlinePayload)(manifest);
-    if (!(0, actionBatchDigest_1.verifyActionBatchManifestDigest)(manifest))
-        throw new WERR_errors_1.WERR_INVALID_PARAMETER('manifest.digest', 'valid');
-    const userId = (0, utilityHelpers_1.verifyId)(auth.userId);
-    let commits = activeBatchCommits.get(storage);
-    if (commits == null) {
-        commits = new Map();
-        activeBatchCommits.set(storage, commits);
-    }
-    const key = `${userId}:${manifest.batchId}`;
-    const active = commits.get(key);
-    if (active != null) {
-        if (active.digest !== manifest.digest) {
-            throw new WERR_errors_1.WERR_INVALID_OPERATION('action batch commit is active with another manifest');
-        }
-        return await active.promise;
-    }
-    const promise = commitActionBatchOnce(storage, userId, manifest)
-        .finally(() => { commits?.delete(key); });
-    commits.set(key, { digest: manifest.digest, promise });
-    return await promise;
-}
-async function abortActionBatch(storage, auth, batchId) {
-    const userId = (0, utilityHelpers_1.verifyId)(auth.userId);
-    return await storage.transaction(async (trx) => {
-        const batch = await storage.findActionBatchForUpdate(userId, batchId, trx);
-        if (batch == null || batch.status === 'aborted')
-            return { aborted: true };
-        if (batch.status === 'committed')
-            return { aborted: false };
-        await releaseBatchState(storage, batch, 'aborted', trx);
-        return { aborted: true };
-    });
-}
-//# sourceMappingURL=actionBatch.js.map