@bsv/wallet-toolbox 2.6.5 → 2.7.1

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

@@ -1,11 +1,12 @@
 "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.ACTION_BATCH_MAX_RESERVED_OUTPUTS = 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.resumeActionBatch = resumeActionBatch;
 exports.commitActionBatch = commitActionBatch;
 exports.commitActionBatchByDigest = commitActionBatchByDigest;
 exports.abortActionBatch = abortActionBatch;
@@ -29,7 +30,14 @@ 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() {
+exports.ACTION_BATCH_MAX_RESERVED_OUTPUTS = 256;
+function isValidOutpoint(outpoint) {
+    // Storage keys and canonical transaction IDs are lowercase. Rejecting an
+    // alternate spelling here is preferable to validating it and then silently
+    // missing the case-sensitive lookup below.
+    return /^[0-9a-f]{64}$/.test(outpoint.txid) && Number.isSafeInteger(outpoint.vout) && outpoint.vout >= 0;
+}
+function getActionBatchCapabilities(maxReservedOutputs = exports.ACTION_BATCH_MAX_RESERVED_OUTPUTS, supportsResume = false) {
     return {
         actionBatch: {
             version: 1,
@@ -38,6 +46,8 @@ function getActionBatchCapabilities() {
             maxConcurrentUploads: actionBatchBlobs_1.ACTION_BATCH_MAX_CONCURRENT_UPLOADS,
             leaseMs: exports.ACTION_BATCH_LEASE_MS,
             hardLifetimeMs: exports.ACTION_BATCH_HARD_LIFETIME_MS,
+            resume: supportsResume ? true : undefined,
+            maxReservedOutputs,
             compactBegin: true,
             manifestVersion: 2,
             commitByDigest: true,
@@ -55,13 +65,28 @@ function getActionBatchCapabilities() {
     };
 }
 function activeExpiry(batch, now = new Date()) {
-    return batch.status !== 'active' && batch.status !== 'prepared' ||
+    return ((batch.status !== 'active' && batch.status !== 'prepared') ||
         batch.expiresAt.getTime() <= now.getTime() ||
-        batch.hardExpiresAt.getTime() <= now.getTime();
+        batch.hardExpiresAt.getTime() <= now.getTime());
+}
+function actionBatchErrorState(batch, now = new Date()) {
+    if (batch == null)
+        return 'missing';
+    if (batch.hardExpiresAt.getTime() <= now.getTime())
+        return 'hard-expired';
+    if (batch.status === 'aborted')
+        return 'aborted';
+    if (batch.status === 'committed')
+        return 'committed';
+    if (batch.status === 'expired' || batch.expiresAt.getTime() <= now.getTime())
+        return 'expired';
+    if (batch.status !== 'active' && batch.status !== 'prepared')
+        return 'inactive';
+    return undefined;
 }
 function canExpire(batch, now = new Date()) {
-    return (batch.status === 'active' || batch.status === 'prepared') &&
-        (batch.expiresAt.getTime() <= now.getTime() || batch.hardExpiresAt.getTime() <= now.getTime());
+    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);
@@ -92,7 +117,10 @@ function sourceOutputFromBeef(beef, outpoint) {
     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 };
+    return {
+        satoshis: sdk_1.Validation.validateSatoshis(output.satoshis, 'source output satoshis'),
+        lockingScript: output.lockingScript
+    };
 }
 async function resolveExplicitOutputs(storage, userId, args, allowDeferredProofs) {
     const byOutpoint = await storage.findOutputsByOutpoints(userId, args.inputs.map(input => input.outpoint));
@@ -142,12 +170,19 @@ function estimateFirstActionTarget(storage, args, inputSatoshis, outputScriptLen
         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);
+    const minFee = Math.ceil(((0, utils_1.transactionSize)([...inputLengths, 107], outputLengths) * fee) / 1000);
     return Math.max(1, outputSatoshis + minFee - inputSatoshis);
 }
+function selectReservationChange(candidates, targetSatoshis) {
+    for (const status of ['completed', 'unproven', 'sending']) {
+        const selected = (0, actionPlanning_1.selectCanonicalChange)(candidates.filter(candidate => candidate.transactionStatus === status), targetSatoshis);
+        if (selected != null)
+            return selected;
+    }
+    return undefined;
+}
 function chooseReservationPool(candidates, targetSatoshis, limit, extras, fillLimit, planningCosts) {
-    const remaining = candidates
-        .filter(output => output.satoshis > planningCosts.marginalInputFee);
+    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
@@ -155,7 +190,7 @@ function chooseReservationPool(candidates, targetSatoshis, limit, extras, fillLi
     // 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);
+        const output = selectReservationChange(remaining, deficit + planningCosts.marginalInputFee);
         if (output == null)
             break;
         chosen.push(output);
@@ -164,7 +199,7 @@ function chooseReservationPool(candidates, targetSatoshis, limit, extras, fillLi
     }
     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);
+        const output = selectReservationChange(remaining, targetSatoshis);
         if (output == null)
             break;
         chosen.push(output);
@@ -172,17 +207,24 @@ function chooseReservationPool(candidates, targetSatoshis, limit, extras, fillLi
     }
     return chosen;
 }
-function reservationPlanningCosts(storage, basket) {
+function reservationOutput(candidate) {
+    const { transactionStatus: _transactionStatus, ...output } = candidate;
+    return output;
+}
+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 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)));
+    // Reserving inputs is compulsory-funding work, not pool shaping. Requiring
+    // the preferred liquidity value here could consume reservation capacity or
+    // reject a batch solely to manufacture optional change.
+    const desiredFirstChange = dustFloor;
     return {
-        firstChangeCost: desiredFirstChange + Math.ceil(marginalOutputSize * satsPerKb / 1000),
-        marginalInputFee: Math.ceil(marginalInputSize * satsPerKb / 1000)
+        firstChangeCost: desiredFirstChange + Math.ceil((marginalOutputSize * satsPerKb) / 1000),
+        marginalInputFee: Math.ceil((marginalInputSize * satsPerKb) / 1000)
     };
 }
 async function reserveOutputs(storage, batch, outputs, trx) {
@@ -251,33 +293,48 @@ function newBatch(userId, batchId) {
 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) {
+    if ((await storage.findActionBatch(userId, args.batchId)) != null) {
         throw new WERR_errors_1.WERR_INVALID_PARAMETER('batchId', 'unique');
     }
     const outputScriptLengths = args.firstActionOutputScriptLengths;
-    if (outputScriptLengths != null && (outputScriptLengths.length !== args.firstAction.outputs.length ||
-        outputScriptLengths.some(length => !Number.isSafeInteger(length) || length < 0) ||
-        args.firstAction.outputs.some((output, index) => output.lockingScript.length > 0 &&
-            output.lockingScript.length / 2 !== outputScriptLengths[index]))) {
+    if (outputScriptLengths != null &&
+        (outputScriptLengths.length !== args.firstAction.outputs.length ||
+            outputScriptLengths.some(length => !Number.isSafeInteger(length) || length < 0) ||
+            args.firstAction.outputs.some((output, index) => output.lockingScript.length > 0 && output.lockingScript.length / 2 !== outputScriptLengths[index]))) {
         throw new WERR_errors_1.WERR_INVALID_PARAMETER('firstActionOutputScriptLengths', 'valid byte lengths aligned with firstAction outputs');
     }
     const changeBasket = (0, utilityHelpers_1.verifyOne)(await storage.findOutputBaskets({ partial: { userId, name: 'default' } }));
     const explicit = await resolveExplicitOutputs(storage, userId, args.firstAction, outputScriptLengths != null);
     const noSendChange = await resolveNoSendChangeOutputs(storage, userId, args.firstAction);
     const fixedOutputIds = new Set([...explicit.outputs, ...noSendChange.outputs].map(output => output.outputId));
-    const available = (await storage.findAvailableManagedChangeInputs(userId, changeBasket.basketId, !args.firstAction.isDelayed)).filter(output => !fixedOutputIds.has(output.outputId));
+    const availableOutputs = (await storage.findAvailableManagedChangeInputs(userId, changeBasket.basketId, false)).filter(output => !fixedOutputIds.has(output.outputId));
+    const availableStatuses = await storage.findTransactionStatusesByIds(userId, availableOutputs.map(output => output.transactionId));
+    const available = availableOutputs.map(output => ({
+        ...output,
+        // An orphaned/missing status is never promoted ahead of known settled
+        // ancestry. Retain it only in the final last-resort reservation tier.
+        transactionStatus: availableStatuses.get(output.transactionId) ?? 'sending'
+    }));
     const target = estimateFirstActionTarget(storage, args.firstAction, explicit.inputSatoshis + noSendChange.inputSatoshis, outputScriptLengths);
-    const fixedOutputs = [...explicit.outputs, ...noSendChange.outputs];
-    const requiredCapacity = Math.max(0, INITIAL_RESERVATION_LIMIT - fixedOutputs.length);
+    const fixedOutputs = [
+        ...new Map([...explicit.outputs, ...noSendChange.outputs].map(output => [output.outputId, output])).values()
+    ];
+    const maxReservedOutputs = storage.actionBatchMaxReservedOutputs;
+    if (maxReservedOutputs >= 0 && fixedOutputs.length > maxReservedOutputs) {
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER('firstAction', `no more than ${maxReservedOutputs} persisted inputs`);
+    }
+    const initialCapacity = maxReservedOutputs < 0 ? INITIAL_RESERVATION_LIMIT : Math.min(INITIAL_RESERVATION_LIMIT, maxReservedOutputs);
+    const requiredCapacity = Math.max(0, initialCapacity - fixedOutputs.length);
     const funding = chooseReservationPool(available, target, requiredCapacity, INITIAL_EXTRA_OUTPUTS, false, reservationPlanningCosts(storage, changeBasket));
+    const fundingOutputs = funding.map(reservationOutput);
     const batch = newBatch(userId, args.batchId);
     await storage.transaction(async (trx) => {
         await storage.insertActionBatch(batch, trx);
-        await reserveOutputs(storage, batch, [...fixedOutputs, ...funding], trx);
+        await reserveOutputs(storage, batch, [...fixedOutputs, ...fundingOutputs], trx);
     });
     let fundingResult;
     try {
-        fundingResult = await makeFundingResult(storage, args.firstAction, [...funding, ...fixedOutputs]);
+        fundingResult = await makeFundingResult(storage, args.firstAction, [...fundingOutputs, ...fixedOutputs]);
     }
     catch (error) {
         await storage.transaction(async (trx) => await releaseBatchState(storage, batch, 'aborted', trx));
@@ -292,55 +349,110 @@ async function beginActionBatch(storage, auth, args) {
         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)),
+        availableChangeCount: available.filter(output => output.satoshis >= Math.max(1, changeBasket.minimumDesiredUTXOValue)).length,
+        managedChangePolicy: {
+            maxOutputsPerAction: storage.managedChangePolicy.maxOutputsPerAction,
+            migrationInputsPerAction: storage.managedChangePolicy.migrationInputsPerAction
+        },
+        reservedOutputs: fundingResult.outputs.filter(output => fundingOutputs.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');
+function requireLiveBatch(batch, batchId) {
+    const state = actionBatchErrorState(batch);
+    if (state != null)
+        throw new WERR_errors_1.WERR_ACTION_BATCH_STATE(state, batchId ?? batch?.batchId);
+    if (batch == null)
+        throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('missing', batchId);
     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 batch = requireLiveBatch(await storage.findActionBatch(userId, args.batchId), 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 storage.findAvailableManagedChangeInputs(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));
+    if (!Number.isSafeInteger(args.targetSatoshis) || args.targetSatoshis < 0) {
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER('targetSatoshis', 'non-negative safe integer');
+    }
+    const maxReservedOutputs = storage.actionBatchMaxReservedOutputs;
+    if ((maxReservedOutputs >= 0 && args.explicitOutpoints.length > maxReservedOutputs) ||
+        new Set(args.explicitOutpoints.map(outpoint => `${outpoint.txid}.${outpoint.vout}`)).size !==
+            args.explicitOutpoints.length ||
+        args.explicitOutpoints.some(outpoint => !isValidOutpoint(outpoint))) {
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER('explicitOutpoints', `at most ${maxReservedOutputs < 0 ? 'the configured request capacity' : maxReservedOutputs} valid outpoints`);
+    }
+    const remainingCapacity = maxReservedOutputs < 0 ? Number.MAX_SAFE_INTEGER : maxReservedOutputs - alreadyReserved.length;
+    if (remainingCapacity <= 0 && (args.requestedOutputs > 0 || args.explicitOutpoints.length > 0)) {
+        throw new WERR_errors_1.WERR_INVALID_OPERATION(`action batch already holds the maximum of ${maxReservedOutputs} outputs`);
+    }
     const explicitByOutpoint = await storage.findOutputsByOutpoints(userId, args.explicitOutpoints);
-    const explicit = Object.values(explicitByOutpoint)
-        .filter(output => !alreadyReserved.includes(output.outputId));
+    const explicit = [
+        ...new Map(Object.values(explicitByOutpoint)
+            .filter(output => !alreadyReserved.includes(output.outputId))
+            .map(output => [output.outputId, output])).values()
+    ];
+    if (explicit.length > remainingCapacity) {
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER('explicitOutpoints', `no more than ${remainingCapacity} additional reserved outputs`);
+    }
+    const explicitIds = new Set(explicit.map(output => output.outputId));
+    const availableOutputs = (await storage.findAvailableManagedChangeInputs(userId, basket.basketId, false)).filter(output => !explicitIds.has(output.outputId));
+    const availableStatuses = await storage.findTransactionStatusesByIds(userId, availableOutputs.map(output => output.transactionId));
+    const available = availableOutputs.map(output => ({
+        ...output,
+        transactionStatus: availableStatuses.get(output.transactionId) ?? 'sending'
+    }));
+    const requestedCount = Math.min(args.requestedOutputs, exports.ACTION_BATCH_MAX_RESERVATION_EXTENSION_OUTPUTS, remainingCapacity - explicit.length);
+    const funding = chooseReservationPool(available, Math.max(1, args.targetSatoshis), requestedCount, 0, true, reservationPlanningCosts(storage, basket));
+    const fundingOutputs = funding.map(reservationOutput);
     const fundingShape = argsToFundingShape(args.includeSourceTransactions);
-    const fundingResult = await makeFundingResult(storage, fundingShape, [...funding, ...explicit]);
+    const fundingResult = await makeFundingResult(storage, fundingShape, [...fundingOutputs, ...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);
+        const current = requireLiveBatch(await storage.findActionBatchForUpdate(userId, args.batchId, trx), args.batchId);
+        const additions = [...new Map([...fundingOutputs, ...explicit].map(output => [output.outputId, output])).values()];
+        const currentReserved = new Set(await storage.findActionBatchOutputIds(current.actionBatchId, trx));
+        const newAdditions = additions.filter(output => !currentReserved.has(output.outputId));
+        if (maxReservedOutputs >= 0 && currentReserved.size + newAdditions.length > maxReservedOutputs) {
+            throw new WERR_errors_1.WERR_INVALID_OPERATION(`action batch cannot reserve more than ${maxReservedOutputs} outputs`);
+        }
+        await reserveOutputs(storage, current, newAdditions, trx);
         await storage.updateActionBatch(current.actionBatchId, { expiresAt }, trx);
     });
     return {
         expiresAt: expiresAt.toISOString(),
-        reservedOutputs: fundingResult.outputs.filter(output => funding.some(candidate => candidate.outputId === output.outputId)),
+        reservedOutputs: fundingResult.outputs.filter(output => fundingOutputs.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,
+        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
+            acceptDelayedBroadcast: true,
+            returnTXIDOnly: false,
+            noSend: true,
+            sendWith: [],
+            signAndProcess: true,
+            knownTxids: [],
+            noSendChange: [],
+            randomizeOutputs: true
         },
-        isSendWith: false, isNewTx: true, isRemixChange: false, isNoSend: true, isDelayed: true,
+        isSendWith: false,
+        isNewTx: true,
+        isRemixChange: false,
+        isNoSend: true,
+        isDelayed: true,
         isTestWerrReviewActions: false,
         isSignAction: includeSourceTransactions,
         includeAllSourceTransactions: includeSourceTransactions
@@ -349,24 +461,95 @@ function argsToFundingShape(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 batch = requireLiveBatch(await storage.findActionBatchForUpdate(userId, batchId, trx), batchId);
         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() };
     });
 }
+function validateResumeOutpoints(storage, args) {
+    const unique = new Set(args.outpoints.map(outpoint => `${outpoint.txid}.${outpoint.vout}`));
+    const maxReservedOutputs = storage.actionBatchMaxReservedOutputs;
+    if ((maxReservedOutputs >= 0 && args.outpoints.length > maxReservedOutputs) ||
+        unique.size !== args.outpoints.length ||
+        args.outpoints.some(outpoint => !isValidOutpoint(outpoint))) {
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER('outpoints', `at most ${maxReservedOutputs < 0 ? 'the configured request capacity' : maxReservedOutputs} unique valid outpoints`);
+    }
+}
+/**
+ * Reacquire exactly the persisted inputs owned by one expired client
+ * workspace. This is deliberately explicit: another action may not become a
+ * member merely because it happens to use the same Wallet instance.
+ */
+async function resumeActionBatch(storage, auth, args) {
+    const userId = (0, utilityHelpers_1.verifyId)(auth.userId);
+    validateResumeOutpoints(storage, args);
+    await cleanupExpiredActionBatches(storage);
+    return await storage.transaction(async (trx) => {
+        const batch = await storage.findActionBatchForUpdate(userId, args.batchId, trx);
+        const state = actionBatchErrorState(batch);
+        if (state != null && state !== 'expired') {
+            throw new WERR_errors_1.WERR_ACTION_BATCH_STATE(state, args.batchId);
+        }
+        if (batch == null)
+            throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('missing', args.batchId);
+        const expiresAt = new Date(Math.min(batch.hardExpiresAt.getTime(), Date.now() + exports.ACTION_BATCH_LEASE_MS));
+        if (state == null) {
+            const reserved = new Set(await storage.findActionBatchOutputIds(batch.actionBatchId, trx));
+            const current = await storage.findOutputsByOutpointsForUpdate(userId, args.outpoints, trx);
+            if (Object.values(current).some(output => !reserved.has(output.outputId)) ||
+                Object.keys(current).length !== args.outpoints.length ||
+                reserved.size !== args.outpoints.length) {
+                throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('conflicted', args.batchId);
+            }
+            await storage.updateActionBatch(batch.actionBatchId, { expiresAt }, trx);
+            return { expiresAt: expiresAt.toISOString() };
+        }
+        const stored = await storage.findOutputsByOutpointsForUpdate(userId, args.outpoints, trx);
+        const outputs = args.outpoints.map(outpoint => stored[`${outpoint.txid}.${outpoint.vout}`]);
+        if (outputs.some(output => output == null || !output.spendable || output.spentBy != null)) {
+            throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('conflicted', args.batchId);
+        }
+        await storage.deleteActionBatchOutputReservations(batch.actionBatchId, trx);
+        const exactOutputs = outputs;
+        const conflicts = await storage.findReservedActionBatchOutputIds(exactOutputs.map(output => output.outputId), trx);
+        if (conflicts.length > 0)
+            throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('conflicted', args.batchId);
+        const now = new Date();
+        await storage.reserveActionBatchOutputs(exactOutputs.map(output => ({
+            actionBatchId: batch.actionBatchId,
+            outputId: output.outputId,
+            created_at: now,
+            updated_at: now
+        })), trx);
+        await storage.updateActionBatch(batch.actionBatchId, {
+            status: 'active',
+            expiresAt,
+            manifest: undefined,
+            manifestDigest: undefined,
+            uploadDigests: undefined
+        }, 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');
+        throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('hard-expired', batch.batchId);
     }
     const stagedTxids = new Set(validated.actions.map(({ action }) => action.txid));
-    const outpoints = [...new Map(validated.actions.flatMap(({ action }) => action.plan.inputs)
+    const outpoints = [
+        ...new Map(validated.actions
+            .flatMap(({ action }) => action.plan.inputs)
             .filter(input => !stagedTxids.has(input.sourceTxid))
-            .map(input => [`${input.sourceTxid}.${input.sourceVout}`, {
+            .map(input => [
+            `${input.sourceTxid}.${input.sourceVout}`,
+            {
                 txid: input.sourceTxid,
                 vout: input.sourceVout,
                 providedBy: input.providedBy
-            }])).values()];
+            }
+        ])).values()
+    ];
     const stored = await storage.findOutputsByOutpointsForUpdate(userId, outpoints, trx);
     await storage.deleteActionBatchOutputReservations(batch.actionBatchId, trx);
     const outputs = [];
@@ -545,7 +728,7 @@ async function persistManifestAtomically(storage, userId, batch, manifest, valid
     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');
+            throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('missing', batch.batchId);
         if (current.status === 'committed') {
             if (current.manifestDigest !== manifest.digest) {
                 throw new WERR_errors_1.WERR_INVALID_OPERATION('batch committed with another manifest');
@@ -553,30 +736,36 @@ async function persistManifestAtomically(storage, userId, batch, manifest, valid
             return { batch: current, alreadyCommitted: true };
         }
         if (current.status === 'aborted')
-            throw new WERR_errors_1.WERR_INVALID_OPERATION('aborted action batch cannot be committed');
+            throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('aborted', batch.batchId);
         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');
+                throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('hard-expired', batch.batchId);
             }
             await reacquireManifestInputs(storage, userId, current, validated, trx);
         }
         else {
-            requireLiveBatch(current);
+            requireLiveBatch(current, batch.batchId);
         }
         const reservedOutputIds = new Set(await storage.findActionBatchOutputIds(current.actionBatchId, trx));
         const stagedTxids = new Set(validated.actions.map(({ action }) => action.txid));
-        const inputOutpoints = [...new Map(validated.actions.flatMap(({ action }) => action.plan.inputs)
+        const inputOutpoints = [
+            ...new Map(validated.actions
+                .flatMap(({ action }) => action.plan.inputs)
                 .filter(input => !stagedTxids.has(input.sourceTxid))
-                .map(input => [`${input.sourceTxid}.${input.sourceVout}`, {
+                .map(input => [
+                `${input.sourceTxid}.${input.sourceVout}`,
+                {
                     txid: input.sourceTxid,
                     vout: input.sourceVout
-                }])).values()];
+                }
+            ])).values()
+        ];
         const storedByOutpoint = await storage.findOutputsByOutpointsForUpdate(userId, inputOutpoints, trx);
-        const allBasketNames = validated.actions.flatMap(({ action }) => action.plan.outputs.flatMap(output => output.basket == null ? [] : [output.basket]));
+        const allBasketNames = validated.actions.flatMap(({ action }) => action.plan.outputs.flatMap(output => (output.basket == null ? [] : [output.basket])));
         if (validated.actions.some(({ action }) => action.plan.outputs.some(output => output.purpose === 'change')))
             allBasketNames.push('default');
         const baskets = await storage.findOrInsertOutputBasketsBulk(userId, [...new Set(allBasketNames)], trx);
@@ -651,19 +840,19 @@ async function completeCommittedBatch(storage, userId, batch, manifest, alreadyC
 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');
+        throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('missing', manifest.batchId);
     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');
+        throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('aborted', manifest.batchId);
     const needsReacquire = batch.status === 'expired' || activeExpiry(batch);
     if (!needsReacquire)
-        requireLiveBatch(batch);
+        requireLiveBatch(batch, manifest.batchId);
     else if (batch.hardExpiresAt.getTime() <= Date.now()) {
-        throw new WERR_errors_1.WERR_INVALID_OPERATION('action batch hard lifetime has expired');
+        throw new WERR_errors_1.WERR_ACTION_BATCH_STATE('hard-expired', manifest.batchId);
     }
     if (batch.manifestDigest != null && batch.manifestDigest !== manifest.digest) {
         throw new WERR_errors_1.WERR_INVALID_OPERATION('batch prepared with another manifest');
@@ -692,8 +881,9 @@ async function commitActionBatch(storage, auth, manifest) {
         }
         return await active.promise;
     }
-    const promise = commitActionBatchOnce(storage, userId, manifest)
-        .finally(() => { commits?.delete(key); });
+    const promise = commitActionBatchOnce(storage, userId, manifest).finally(() => {
+        commits?.delete(key);
+    });
     commits.set(key, { digest: manifest.digest, promise });
     return await promise;
 }
@@ -704,7 +894,9 @@ async function commitActionBatchByDigest(storage, auth, args) {
         throw new WERR_errors_1.WERR_INVALID_OPERATION('prepared action batch manifest was not found');
     }
     const manifest = JSON.parse(batch.manifest);
-    if (manifest.format !== 2 || manifest.batchId !== args.batchId || manifest.digest !== args.digest ||
+    if (manifest.format !== 2 ||
+        manifest.batchId !== args.batchId ||
+        manifest.digest !== args.digest ||
         !(0, actionBatchDigest_1.verifyActionBatchManifestDigest)(manifest)) {
         throw new WERR_errors_1.WERR_INVALID_OPERATION('prepared action batch manifest is invalid');
     }