@bsv/wallet-toolbox 2.4.22 → 2.5.0

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

@@ -98,50 +98,66 @@ async function createActionCore(storage, auth, vargs, parent) {
     const { storageBeef, beef, xinputs, xoutputs, changeBasket, noSendChangeIn } = validated;
     const feeModel = (0, StorageProvider_1.validateStorageFeeModel)(storage.feeModel);
     logger?.log(`validated fee model ${JSON.stringify(feeModel)}`);
-    const initialFundingPlan = await prepareFundingPlan(storage, { userId, vargs, xinputs, xoutputs, changeBasket, noSendChangeIn, feeModel, parent });
+    const initialFundingPlan = await prepareFundingPlan(storage, [userId, vargs, xinputs, xoutputs, changeBasket, noSendChangeIn, feeModel, parent]);
     logger?.log(`planned funding from ${initialFundingPlan.availableChangeCount} change inputs`);
+    // The selected source txids are known before the write transaction begins.
+    // Start their one batched proof read now so PXC/network wait and BEEF
+    // assembly overlap the independent transaction-record/funding/output writes.
+    // A funding-claim retry is handled below by fetching only any residual roots.
+    const allocatedBeefPrefetch = startAllocatedChangeBeefPrefetch(storage, vargs, initialFundingPlan.selected, beef, parent);
+    const storageBeefBytes = storageBeef.toBinary();
     let newTx;
+    let newTxCommitted = false;
     try {
-        const storageBeefBytes = storageBeef.toBinary();
-        newTx = await traceStorageStep(storage, 'wallet.storage.create_action.create_record', parent, {
-            'action.label_count': vargs.labels.length,
-            'action.storage_beef_bytes': storageBeefBytes.length
-        }, async (span) => {
-            const transaction = await createNewTxRecord(storage, userId, vargs, storageBeefBytes);
-            span?.end({ attributes: { 'action.transaction_record_created': true } });
-            return transaction;
-        });
-        logger?.log('created new transaction record');
-        const ctx = {
-            xinputs,
-            xoutputs,
-            changeBasket,
-            noSendChangeIn,
-            feeModel,
-            transactionId: newTx.transactionId
-        };
-        const { allocatedChange, changeOutputs, derivationPrefix, maxPossibleSatoshisAdjustment } = await fundNewTransactionSdk(storage, userId, vargs, ctx, initialFundingPlan, parent);
-        logger?.log('funded new transaction');
-        if (maxPossibleSatoshisAdjustment != null) {
-            const a = maxPossibleSatoshisAdjustment;
-            if (ctx.xoutputs[a.fixedOutputIndex].satoshis !== generateChange_1.maxPossibleSatoshis)
-                throw new WERR_errors_1.WERR_INTERNAL();
-            ctx.xoutputs[a.fixedOutputIndex].satoshis = a.satoshis;
-            logger?.log('adjusted change outputs to max possible');
-        }
-        // The satoshis of the transaction is the satoshis we get back in change minus the satoshis we spend.
-        const satoshis = changeOutputs.reduce((a, e) => a + e.satoshis, 0) - allocatedChange.reduce((a, e) => a + e.satoshis, 0);
-        const { outputs, changeVouts } = await traceStorageStep(storage, 'wallet.storage.create_action.persist_outputs', parent, {
-            'action.fixed_output_count': ctx.xoutputs.length,
-            'action.change_output_count': changeOutputs.length
-        }, async (span) => {
-            await storage.updateTransaction(newTx.transactionId, { satoshis });
-            const persisted = await createNewOutputs(storage, userId, vargs, ctx, changeOutputs);
-            span?.end({ attributes: { 'action.persisted_output_count': persisted.outputs.length } });
-            return persisted;
+        const persisted = await storage.transaction(async (trx) => {
+            const initialSatoshis = fundingPlanSatoshis(initialFundingPlan);
+            newTx = await traceStorageStep(storage, 'wallet.storage.create_action.create_record', parent, {
+                'action.label_count': vargs.labels.length,
+                'action.storage_beef_bytes': storageBeefBytes.length
+            }, async (span) => {
+                const transaction = await createNewTxRecord(storage, userId, vargs, storageBeefBytes, initialSatoshis, trx);
+                span?.end({ attributes: { 'action.transaction_record_created': true } });
+                return transaction;
+            });
+            logger?.log('created new transaction record');
+            const ctx = {
+                xinputs,
+                xoutputs,
+                changeBasket,
+                noSendChangeIn,
+                feeModel,
+                transactionId: newTx.transactionId
+            };
+            const funded = await fundNewTransactionSdk(storage, userId, vargs, ctx, initialFundingPlan, parent, trx);
+            logger?.log('funded new transaction');
+            if (funded.maxPossibleSatoshisAdjustment != null) {
+                const adjustment = funded.maxPossibleSatoshisAdjustment;
+                if (ctx.xoutputs[adjustment.fixedOutputIndex].satoshis !== generateChange_1.maxPossibleSatoshis)
+                    throw new WERR_errors_1.WERR_INTERNAL();
+                ctx.xoutputs[adjustment.fixedOutputIndex].satoshis = adjustment.satoshis;
+                logger?.log('adjusted change outputs to max possible');
+            }
+            const satoshis = funded.changeOutputs.reduce((sum, output) => sum + output.satoshis, 0) -
+                funded.allocatedChange.reduce((sum, output) => sum + output.satoshis, 0);
+            if (satoshis !== initialSatoshis) {
+                await storage.updateTransaction(newTx.transactionId, { satoshis }, trx);
+                newTx.satoshis = satoshis;
+            }
+            const storedOutputs = await traceStorageStep(storage, 'wallet.storage.create_action.persist_outputs', parent, {
+                'action.fixed_output_count': ctx.xoutputs.length,
+                'action.change_output_count': funded.changeOutputs.length
+            }, async (span) => {
+                const result = await createNewOutputs(storage, userId, vargs, ctx, funded.changeOutputs, trx);
+                span?.end({ attributes: { 'action.persisted_output_count': result.outputs.length } });
+                return result;
+            });
+            return { ...funded, ...storedOutputs, ctx };
         });
+        newTxCommitted = true;
+        const committedTx = (0, utilityHelpers_1.verifyTruthy)(newTx);
+        const { allocatedChange, derivationPrefix, outputs, changeVouts, ctx } = persisted;
         logger?.log('created new output records');
-        const inputBeef = await mergeAllocatedChangeBeefs(storage, vargs, allocatedChange, beef, parent);
+        const inputBeef = await mergeAllocatedChangeBeefs(storage, vargs, allocatedChange, beef, allocatedBeefPrefetch, parent);
         logger?.log('merged allocated change beefs');
         const inputs = await traceStorageStep(storage, 'wallet.storage.create_action.assemble_inputs', parent, {
             'action.fixed_input_count': ctx.xinputs.length,
@@ -154,9 +170,9 @@ async function createActionCore(storage, auth, vargs, parent) {
         });
         logger?.log('created new inputs');
         const r = {
-            reference: newTx.reference,
-            version: newTx.version,
-            lockTime: newTx.lockTime,
+            reference: committedTx.reference,
+            version: committedTx.version,
+            lockTime: committedTx.lockTime,
             inputs,
             outputs,
             derivationPrefix,
@@ -167,10 +183,20 @@ async function createActionCore(storage, auth, vargs, parent) {
         return r;
     }
     catch (error) {
+        // Always let an overlapped database read settle before cleanup destroys or
+        // reuses the provider. Its error is surfaced on the success path above;
+        // here the construction error remains authoritative.
+        await allocatedBeefPrefetch;
         if (newTx?.transactionId != null) {
             try {
-                await storage.updateTransactionStatus('failed', newTx.transactionId);
-                logger?.log(`marked failed createAction transaction ${newTx.transactionId} after construction error`);
+                if (newTxCommitted) {
+                    await storage.updateTransactionStatus('failed', newTx.transactionId);
+                    logger?.log(`marked failed createAction transaction ${newTx.transactionId} after construction error`);
+                }
+                else {
+                    const failed = await createNewTxRecord(storage, userId, vargs, storageBeefBytes, 0, undefined, 'failed');
+                    logger?.log(`recorded failed createAction transaction ${failed.transactionId} after rollback`);
+                }
             }
             catch (cleanupError) {
                 logger?.log(`failed to clean up createAction transaction ${newTx.transactionId}: ${String(cleanupError)}`);
@@ -320,21 +346,9 @@ async function getCompetingBeefForReview(storage, txid) {
         throw e;
     }
 }
-/** Randomly reassign vout values across newOutputs using either the provided randomVals or crypto-random bytes. */
-/** Insert the output and attach its tags; return the SDK output descriptor. */
-async function persistNewOutput(storage, o, tags, txTags, txBaskets) {
-    o.outputId = await storage.insertOutput(o);
+/** Build the SDK descriptor for a persisted output. */
+function describeNewOutput(o, tags, txBaskets) {
     const changeVout = o.change && o.purpose === 'change' && o.providedBy === 'storage' ? o.vout : undefined;
-    for (const tagName of new Set(tags)) {
-        const tag = txTags[tagName];
-        await storage.insertOutputTagMap({
-            outputId: (0, utilityHelpers_1.verifyId)(o.outputId),
-            outputTagId: (0, utilityHelpers_1.verifyId)(tag.outputTagId),
-            created_at: new Date(),
-            updated_at: new Date(),
-            isDeleted: false
-        });
-    }
     const ro = {
         vout: (0, utilityHelpers_1.verifyInteger)(o.vout),
         satoshis: sdk_1.Validation.validateSatoshis(o.satoshis, 'o.satoshis'),
@@ -349,13 +363,28 @@ async function persistNewOutput(storage, o, tags, txTags, txBaskets) {
     };
     return { changeVout, ro };
 }
-async function createNewOutputs(storage, userId, vargs, ctx, changeOutputs) {
+/** Insert the output and attach its tags; return the SDK output descriptor. */
+async function persistNewOutput(storage, o, tags, txTags, txBaskets, trx) {
+    o.outputId = await storage.insertOutput(o, trx);
+    for (const tagName of new Set(tags)) {
+        const tag = txTags[tagName];
+        await storage.insertOutputTagMap({
+            outputId: (0, utilityHelpers_1.verifyId)(o.outputId),
+            outputTagId: (0, utilityHelpers_1.verifyId)(tag.outputTagId),
+            created_at: new Date(),
+            updated_at: new Date(),
+            isDeleted: false
+        }, trx);
+    }
+    return describeNewOutput(o, tags, txBaskets);
+}
+async function createNewOutputs(storage, userId, vargs, ctx, changeOutputs, trx) {
     const txBaskets = {};
     const basketNames = [...new Set(ctx.xoutputs.map(x => x.basket).filter((v) => !!v))];
-    Object.assign(txBaskets, await storage.findOrInsertOutputBasketsBulk(userId, basketNames));
+    Object.assign(txBaskets, await storage.findOrInsertOutputBasketsBulk(userId, basketNames, trx));
     const txTags = {};
     const tagNames = [...new Set(ctx.xoutputs.flatMap(x => x.tags))];
-    Object.assign(txTags, await storage.findOrInsertOutputTagsBulk(userId, tagNames));
+    Object.assign(txTags, await storage.findOrInsertOutputTagsBulk(userId, tagNames, trx));
     const newOutputs = [];
     for (const xo of ctx.xoutputs) {
         const lockingScript = (0, utilityHelpers_noBuffer_1.asArray)(xo.lockingScript);
@@ -371,7 +400,7 @@ async function createNewOutputs(storage, userId, vargs, ctx, changeOutputs) {
                 created_at: now,
                 updated_at: now,
                 commissionId: 0
-            });
+            }, trx);
             const o = makeDefaultOutput(userId, ctx.transactionId, xo.satoshis, xo.vout);
             o.lockingScript = lockingScript;
             o.providedBy = 'storage';
@@ -398,17 +427,25 @@ async function createNewOutputs(storage, userId, vargs, ctx, changeOutputs) {
     }
     if (vargs.options.randomizeOutputs)
         (0, actionPlanning_1.randomizeOutputVouts)(newOutputs.map(output => output.o), vargs.randomVals);
+    // The overwhelmingly common path has no output tags. Those rows do not
+    // need generated outputIds, so Knex can persist fixed and change outputs in
+    // one multi-row statement. Tagged rows retain the established id-dependent
+    // insertion path below.
+    const untagged = newOutputs.filter(output => output.tags.length === 0);
+    await storage.insertOutputs(untagged.map(output => output.o), trx);
     const outputs = [];
     const changeVouts = [];
     for (const { o, tags } of newOutputs) {
-        const { changeVout, ro } = await persistNewOutput(storage, o, tags, txTags, txBaskets);
+        const { changeVout, ro } = tags.length === 0
+            ? describeNewOutput(o, tags, txBaskets)
+            : await persistNewOutput(storage, o, tags, txTags, txBaskets, trx);
         if (changeVout !== undefined)
             changeVouts.push(changeVout);
         outputs.push(ro);
     }
     return { outputs, changeVouts };
 }
-async function createNewTxRecord(storage, userId, vargs, storageBeef) {
+async function createNewTxRecord(storage, userId, vargs, storageBeef, satoshis = 0, trx, status = 'unsigned') {
     const now = new Date();
     const newTx = {
         created_at: now,
@@ -416,9 +453,9 @@ async function createNewTxRecord(storage, userId, vargs, storageBeef) {
         transactionId: 0,
         version: vargs.version,
         lockTime: vargs.lockTime,
-        status: 'unsigned',
+        status,
         reference: (0, utilityHelpers_1.randomBytesBase64)(12),
-        satoshis: 0, // updated after fundingTransaction
+        satoshis,
         userId,
         isOutgoing: true,
         inputBEEF: storageBeef,
@@ -426,12 +463,12 @@ async function createNewTxRecord(storage, userId, vargs, storageBeef) {
         txid: undefined,
         rawTx: undefined
     };
-    newTx.transactionId = await storage.insertTransaction(newTx);
+    newTx.transactionId = await storage.insertTransaction(newTx, trx);
     const labelNames = [...new Set(vargs.labels)];
-    const labels = await storage.findOrInsertTxLabelsBulk(userId, labelNames);
+    const labels = await storage.findOrInsertTxLabelsBulk(userId, labelNames, trx);
     for (const label of labelNames) {
         const txLabel = labels[label];
-        await storage.findOrInsertTxLabelMap((0, utilityHelpers_1.verifyId)(newTx.transactionId), (0, utilityHelpers_1.verifyId)(txLabel.txLabelId));
+        await storage.findOrInsertTxLabelMap((0, utilityHelpers_1.verifyId)(newTx.transactionId), (0, utilityHelpers_1.verifyId)(txLabel.txLabelId), trx);
     }
     return newTx;
 }
@@ -659,6 +696,10 @@ async function validateNoSendChange(storage, userId, vargs, changeBasket) {
     }
     return r;
 }
+function fundingPlanSatoshis(plan) {
+    return plan.result.changeOutputs.reduce((sum, output) => sum + output.satoshis, 0) -
+        plan.selected.reduce((sum, output) => sum + output.satoshis, 0);
+}
 class FundingClaimConflict extends Error {
     conflict;
     constructor(conflict) {
@@ -691,10 +732,10 @@ function makeFundingParams(vargs, xinputs, xoutputs, changeBasket, feeModel, ava
     };
 }
 async function prepareFundingPlan(storage, context) {
-    const { userId, vargs, xinputs, xoutputs, changeBasket, noSendChangeIn, feeModel, parent } = context;
+    const [userId, vargs, xinputs, xoutputs, changeBasket, noSendChangeIn, feeModel, parent, trx] = context;
     const excludeSending = !vargs.isDelayed;
     const candidates = await traceStorageStep(storage, 'wallet.storage.create_action.funding_candidates', parent, { 'funding.exclude_sending': excludeSending }, async (span) => {
-        const outputs = await storage.findAvailableManagedChangeInputs(userId, changeBasket.basketId, excludeSending);
+        const outputs = await storage.findAvailableManagedChangeInputCandidates(userId, changeBasket.basketId, excludeSending, trx);
         span?.end({
             attributes: {
                 'funding.candidate_count': outputs.length,
@@ -713,10 +754,12 @@ async function prepareFundingPlan(storage, context) {
         'funding.no_send_change_count': noSendChangeIn.length
     }, async (span) => {
         const allocated = new Map();
+        const availableSelector = new actionPlanning_1.CanonicalChangeSelector(available);
         const noSend = [...noSendChangeIn];
+        const noSendById = new Map(noSendChangeIn.map(output => [output.outputId, output]));
         const allocate = async (targetSatoshis, exactSatoshis) => {
             let output = noSend.pop();
-            output ??= (0, actionPlanning_1.selectCanonicalChange)(available.filter(candidate => !allocated.has(candidate.outputId)), targetSatoshis, exactSatoshis);
+            output ??= availableSelector.take(targetSatoshis, exactSatoshis);
             if (output == null)
                 return undefined;
             allocated.set(output.outputId, output);
@@ -727,8 +770,10 @@ async function prepareFundingPlan(storage, context) {
             if (output == null)
                 return;
             allocated.delete(outputId);
-            if (noSendIds.has(outputId))
-                noSend.push(output);
+            availableSelector.release(outputId);
+            const noSendOutput = noSendById.get(outputId);
+            if (noSendOutput != null)
+                noSend.push(noSendOutput);
         };
         const result = await (0, generateChange_1.generateChangeSdk)(params, allocate, release, vargs.logger, storage.telemetry);
         const selected = result.allocatedChangeInputs.map(input => (0, utilityHelpers_1.verifyTruthy)(allocated.get(input.outputId)));
@@ -748,7 +793,8 @@ async function prepareFundingPlan(storage, context) {
         };
     });
 }
-async function claimFundingPlan(storage, userId, basketId, excludeSending, transactionId, noSendChangeIn, plan) {
+async function claimFundingPlan(storage, request) {
+    const [userId, basketId, excludeSending, transactionId, noSendChangeIn, plan, trx] = request;
     if (plan.selected.length === 0) {
         return { outputs: [], sourceTransactionCount: 0, hydratedScriptCount: 0, scriptSourceTransactionCount: 0 };
     }
@@ -756,33 +802,23 @@ async function claimFundingPlan(storage, userId, basketId, excludeSending, trans
     const statuses = ['completed', 'unproven'];
     if (!excludeSending)
         statuses.push('sending');
-    const claim = await storage.transaction(async (trx) => {
-        const outpoints = plan.selected.map(output => {
-            if (output.txid == null)
-                throw new WERR_errors_1.WERR_INTERNAL('planned change input is missing txid');
-            return { txid: output.txid, vout: output.vout };
-        });
-        const currentByOutpoint = await storage.findOutputsByOutpointsForUpdate(userId, outpoints, trx, true);
-        const reserved = new Set(await storage.findReservedActionBatchOutputIds(plan.selected.map(output => output.outputId), trx));
-        const transactionIds = [...new Set(Object.values(currentByOutpoint).map(output => output.transactionId))];
-        const transactionStatuses = await storage.findTransactionStatusesByIds(userId, transactionIds, trx);
+    const claim = await storage.transaction(async (claimTrx) => {
+        const currentById = await storage.findFundingOutputsForUpdate(userId, plan.selected.map(output => output.outputId), statuses, claimTrx);
+        const transactionIds = [...new Set(Object.values(currentById).map(output => output.transactionId))];
         const claimed = [];
         for (const planned of plan.selected) {
-            const key = `${String(planned.txid)}.${planned.vout}`;
-            const current = currentByOutpoint[key];
-            const currentStatus = current == null ? undefined : transactionStatuses.get(current.transactionId);
-            const validTransaction = currentStatus != null && statuses.includes(currentStatus);
+            const current = currentById[planned.outputId];
             if (current?.outputId !== planned.outputId ||
                 current?.satoshis !== planned.satoshis ||
                 current?.basketId !== basketId ||
                 !(0, managedChange_1.isAutoSpendableChangeOutput)(current) ||
-                reserved.has(current?.outputId ?? -1) ||
-                validTransaction !== true) {
+                current?.txid !== planned.txid ||
+                current?.vout !== planned.vout) {
                 return { conflict: noSendIds.has(planned.outputId) ? 'noSendChange' : 'candidate' };
             }
             claimed.push(current);
         }
-        const updated = await storage.markChangeInputsSpent(claimed.map(output => output.outputId), transactionId, trx);
+        const updated = await storage.markChangeInputsSpent(claimed.map(output => output.outputId), transactionId, claimTrx);
         if (updated !== claimed.length) {
             throw new FundingClaimConflict(claimed.some(output => noSendIds.has(output.outputId)) ? 'noSendChange' : 'candidate');
         }
@@ -791,21 +827,21 @@ async function claimFundingPlan(storage, userId, basketId, excludeSending, trans
             output.spentBy = transactionId;
         }
         return { outputs: claimed, sourceTransactionCount: transactionIds.length };
-    }).catch(error => {
+    }, trx).catch(error => {
         if (error instanceof FundingClaimConflict)
             return { conflict: error.conflict };
         throw error;
     });
     if (claim.outputs == null)
         return claim;
-    const hydration = await hydrateFundingInputScripts(storage, claim.outputs);
+    const hydration = await hydrateFundingInputScripts(storage, claim.outputs, trx);
     return {
         outputs: claim.outputs,
         sourceTransactionCount: claim.sourceTransactionCount,
         ...hydration
     };
 }
-async function hydrateFundingInputScripts(storage, outputs) {
+async function hydrateFundingInputScripts(storage, outputs, trx) {
     const missing = outputs.filter(output => output.lockingScript?.length !== output.scriptLength &&
         output.scriptLength != null && output.scriptLength > 0 &&
         output.scriptOffset != null && output.scriptOffset > 0 &&
@@ -825,10 +861,10 @@ async function hydrateFundingInputScripts(storage, outputs) {
         while (cursor < groups.length) {
             const [txid, group] = groups[cursor++];
             if (group.length === 1) {
-                await storage.validateOutputScript(group[0]);
+                await storage.validateOutputScript(group[0], trx);
                 continue;
             }
-            const rawTx = await storage.getRawTxOfKnownValidTransaction(txid);
+            const rawTx = await storage.getRawTxOfKnownValidTransaction(txid, undefined, undefined, trx);
             if (rawTx != null) {
                 for (const output of group) {
                     output.lockingScript = rawTx.slice(output.scriptOffset, output.scriptOffset + output.scriptLength);
@@ -836,7 +872,7 @@ async function hydrateFundingInputScripts(storage, outputs) {
             }
             else {
                 for (const output of group)
-                    await storage.validateOutputScript(output);
+                    await storage.validateOutputScript(output, trx);
             }
         }
     }));
@@ -845,13 +881,21 @@ async function hydrateFundingInputScripts(storage, outputs) {
         scriptSourceTransactionCount: groups.length
     };
 }
-async function fundNewTransactionSdk(storage, userId, vargs, ctx, initialPlan, parent) {
+async function fundNewTransactionSdk(storage, userId, vargs, ctx, initialPlan, parent, trx) {
     let plan = initialPlan;
     let allocatedChange;
     let retryCount = 0;
     await traceStorageStep(storage, 'wallet.storage.create_action.funding_claim', parent, { 'funding.planned_input_count': initialPlan.selected.length }, async (span) => {
         for (let attempt = 0; attempt < 3; attempt++) {
-            const claim = await claimFundingPlan(storage, userId, ctx.changeBasket.basketId, !vargs.isDelayed, ctx.transactionId, ctx.noSendChangeIn, plan);
+            const claim = await claimFundingPlan(storage, [
+                userId,
+                ctx.changeBasket.basketId,
+                !vargs.isDelayed,
+                ctx.transactionId,
+                ctx.noSendChangeIn,
+                plan,
+                trx
+            ]);
             if (claim.outputs != null) {
                 allocatedChange = claim.outputs;
                 span?.end({
@@ -868,16 +912,17 @@ async function fundNewTransactionSdk(storage, userId, vargs, ctx, initialPlan, p
                 throw new WERR_errors_1.WERR_INVALID_PARAMETER('noSendChange', 'outputs that remain spendable during action planning');
             }
             retryCount++;
-            plan = await prepareFundingPlan(storage, {
+            plan = await prepareFundingPlan(storage, [
                 userId,
                 vargs,
-                xinputs: ctx.xinputs,
-                xoutputs: ctx.xoutputs,
-                changeBasket: ctx.changeBasket,
-                noSendChangeIn: ctx.noSendChangeIn,
-                feeModel: ctx.feeModel,
-                parent
-            });
+                ctx.xinputs,
+                ctx.xoutputs,
+                ctx.changeBasket,
+                ctx.noSendChangeIn,
+                ctx.feeModel,
+                parent,
+                trx
+            ]);
         }
         throw new WERR_errors_1.WERR_INVALID_OPERATION('wallet funding changed repeatedly during action planning; retry createAction');
     });
@@ -984,7 +1029,49 @@ function makeKnownTxidLookup(knownTxids) {
         return knownTxids.includes(txid);
     };
 }
-async function mergeAllocatedChangeBeefs(storage, vargs, allocatedChange, beef, parent) {
+function missingAllocatedChangeTxids(allocatedChange, beef, knownTxids) {
+    const hasKnownTxid = makeKnownTxidLookup(knownTxids);
+    return Array.from(new Set(allocatedChange
+        .map(output => (0, utilityHelpers_1.verifyTruthy)(output.txid))
+        .filter(txid => beef.findTxid(txid) == null && !hasKnownTxid(txid))));
+}
+function startAllocatedChangeBeefPrefetch(storage, vargs, allocatedChange, beef, parent) {
+    if (vargs.options.returnTXIDOnly)
+        return Promise.resolve({ sourceCount: 0, txids: [] });
+    const knownTxids = vargs.options.knownTxids ?? [];
+    const missing = missingAllocatedChangeTxids(allocatedChange, beef, knownTxids);
+    if (missing.length === 0)
+        return Promise.resolve({ sourceCount: 0, txids: [] });
+    const options = {
+        trustSelf: undefined,
+        knownTxids,
+        ignoreStorage: false,
+        ignoreServices: true,
+        ignoreNewProven: false,
+        minProofLevel: undefined
+    };
+    return traceStorageStep(storage, 'wallet.storage.create_action.beef_prefetch', parent, {
+        'beef.planned_source_count': allocatedChange.length,
+        'beef.missing_source_count': missing.length,
+        'beef.storage_batch_count': missing.length === 0 ? 0 : 1
+    }, async (span) => {
+        const fetched = await storage.getBeefForTransactions(missing, options);
+        span?.end({
+            attributes: {
+                'beef.fetched_tx_count': fetched.txs.length,
+                'beef.fetched_bump_count': fetched.bumps.length
+            }
+        });
+        return fetched;
+    }).then(prefetched => ({ beef: prefetched, sourceCount: missing.length, txids: missing }), error => ({ error, sourceCount: missing.length, txids: missing }));
+}
+function sameTxids(left, right) {
+    if (left.length !== right.length)
+        return false;
+    const expected = new Set(left);
+    return right.every(txid => expected.has(txid));
+}
+async function mergeAllocatedChangeBeefs(storage, vargs, allocatedChange, beef, prefetch, parent) {
     const options = {
         trustSelf: undefined,
         knownTxids: vargs.options.knownTxids,
@@ -997,39 +1084,46 @@ async function mergeAllocatedChangeBeefs(storage, vargs, allocatedChange, beef,
     if (vargs.options.returnTXIDOnly)
         return undefined;
     const knownTxids = vargs.options.knownTxids ?? [];
-    const hasKnownTxid = makeKnownTxidLookup(knownTxids);
-    const missing = Array.from(new Set(allocatedChange
-        .map(output => (0, utilityHelpers_1.verifyTruthy)(output.txid))
-        .filter(txid => beef.findTxid(txid) == null && !hasKnownTxid(txid))));
-    const fetched = Array.from({ length: missing.length });
-    const concurrency = Math.min(8, Math.max(1, missing.length));
-    let cursor = 0;
+    const requiredBeforePrefetch = missingAllocatedChangeTxids(allocatedChange, beef, knownTxids);
+    const prefetched = await traceStorageStep(storage, 'wallet.storage.create_action.beef_prefetch_join', parent, { 'beef.prefetch_source_count': 0 }, async (span) => {
+        const result = await prefetch;
+        span?.end({ attributes: { 'beef.prefetch_source_count': result.sourceCount } });
+        return result;
+    });
+    // A claim retry may replace only part of the initial funding plan. Never
+    // merge proofs for outputs the final transaction does not spend: apart from
+    // unnecessary bytes, that would disclose unrelated wallet history.
+    const usePrefetch = sameTxids(prefetched.txids, requiredBeforePrefetch);
+    if (usePrefetch && prefetched.error != null)
+        throw prefetched.error;
+    if (usePrefetch && prefetched.beef != null)
+        beef.mergeBeef(prefetched.beef);
+    // If a concurrent spender forced the funding claim to be replanned, only
+    // the newly selected roots remain. The normal uncontended path is empty.
+    const missing = missingAllocatedChangeTxids(allocatedChange, beef, knownTxids);
+    let fetched;
     await traceStorageStep(storage, 'wallet.storage.create_action.beef_fetch', parent, {
         'beef.allocated_change_count': allocatedChange.length,
         'beef.distinct_source_count': new Set(allocatedChange.map(output => output.txid)).size,
         'beef.known_txid_count': knownTxids.length,
         'beef.missing_source_count': missing.length,
-        'beef.fetch_concurrency': concurrency
+        'beef.fetch_concurrency': 1,
+        'beef.prefetch_reused': usePrefetch
     }, async (span) => {
-        await Promise.all(Array.from({ length: concurrency }, async () => {
-            while (cursor < missing.length) {
-                const index = cursor++;
-                fetched[index] = await storage.getBeefForTransaction(missing[index], { ...options, mergeToBeef: undefined });
-            }
-        }));
+        if (missing.length > 0) {
+            fetched = await storage.getBeefForTransactions(missing, { ...options, mergeToBeef: undefined });
+        }
         span?.end({
             attributes: {
-                'beef.fetched_tx_count': fetched.reduce((sum, item) => sum + (item?.txs.length ?? 0), 0),
-                'beef.fetched_bump_count': fetched.reduce((sum, item) => sum + (item?.bumps.length ?? 0), 0)
+                'beef.fetched_tx_count': fetched?.txs.length ?? 0,
+                'beef.fetched_bump_count': fetched?.bumps.length ?? 0,
+                'beef.storage_batch_count': missing.length === 0 ? 0 : 1
             }
         });
     });
-    await traceStorageStep(storage, 'wallet.storage.create_action.beef_merge', parent, { 'beef.fragment_count': fetched.length }, async (span) => {
-        for (const fetchedBeef of fetched) {
-            if (fetchedBeef == null)
-                continue;
-            beef.mergeBeef(fetchedBeef);
-        }
+    await traceStorageStep(storage, 'wallet.storage.create_action.beef_merge', parent, { 'beef.fragment_count': (usePrefetch && prefetched.beef != null ? 1 : 0) + (fetched == null ? 0 : 1) }, async (span) => {
+        if (fetched != null)
+            beef.mergeBeef(fetched);
         span?.end({
             attributes: {
                 'beef.merged_tx_count': beef.txs.length,