@bopen-io/wallet-toolbox 2.1.21-parity-fix.2 → 2.6.2-brc153.2

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

@@ -8,24 +8,54 @@ const StorageProvider_1 = require("../StorageProvider");
 const WERR_errors_1 = require("../../sdk/WERR_errors");
 const utilityHelpers_1 = require("../../utility/utilityHelpers");
 const utilityHelpers_noBuffer_1 = require("../../utility/utilityHelpers.noBuffer");
+const brc153ReferenceLabels_1 = require("../../utility/brc153ReferenceLabels");
 const EntityProvenTx_1 = require("../schema/entities/EntityProvenTx");
 const Wallet_1 = require("../../Wallet");
 const offsetKey_1 = require("./offsetKey");
-const utils_1 = require("./utils");
+const sdk_2 = require("../../sdk");
+const managedChange_1 = require("./managedChange");
+const actionPlanning_1 = require("./actionPlanning");
 let disableDoubleSpendCheckForTest = true;
 function setDisableDoubleSpendCheckForTest(v) {
     disableDoubleSpendCheckForTest = v;
 }
-async function createAction(storage, auth, vargs, originator) {
+async function createAction(storage, auth, vargs, _originator) {
+    if (!storage.telemetry.enabled)
+        return await createActionCore(storage, auth, vargs);
+    return await storage.telemetry.withSpan('wallet.storage.create_action', {
+        component: 'wallet-storage',
+        carrier: vargs,
+        attributes: {
+            'action.fixed_input_count': vargs.inputs.length,
+            'action.fixed_output_count': vargs.outputs.length,
+            'action.known_txid_count': vargs.options.knownTxids?.length ?? 0,
+            'action.is_delayed': vargs.isDelayed,
+            'action.is_no_send': vargs.isNoSend
+        }
+    }, async (span) => {
+        const result = await createActionCore(storage, auth, vargs, span);
+        span.end({
+            attributes: {
+                'action.result_input_count': result.inputs.length,
+                'action.result_output_count': result.outputs.length,
+                'action.input_beef_bytes': result.inputBeef?.length ?? 0
+            }
+        });
+        return result;
+    });
+}
+async function createActionCore(storage, auth, vargs, parent) {
     const logger = vargs.logger;
-    logger === null || logger === void 0 ? void 0 : logger.group(`storage createAction`);
-    //stampLog(vargs, `start storage createTransactionSdk`)
+    logger?.group('storage createAction');
+    // stampLog(vargs, `start storage createTransactionSdk`)
     if (vargs.isTestWerrReviewActions)
         (0, Wallet_1.throwDummyReviewActions)();
-    if (!vargs.isNewTx)
-        // The purpose of this function is to create the initial storage records associated
-        // with a new transaction. It's an error if we have no new inputs or outputs...
+    if (!vargs.isNewTx) 
+    // The purpose of this function is to create the initial storage records associated
+    // with a new transaction. It's an error if we have no new inputs or outputs...
+    {
         throw new WERR_errors_1.WERR_INTERNAL();
+    }
     /**
      * Steps to create a transaction:
      * - Verify that all inputs either have proof in vargs.inputBEEF or that options.trustSelf === 'known' and input txid.vout are known valid to storage.
@@ -39,66 +69,143 @@ async function createAction(storage, auth, vargs, originator) {
      * - Create result inputs with source locking scripts
      * - Create result outputs with new locking scripts.
      * - Create and return result.
-     */
+    */
     const userId = auth.userId;
-    const { storageBeef, beef, xinputs } = await validateRequiredInputs(storage, userId, vargs);
-    logger === null || logger === void 0 ? void 0 : logger.log('validated required inputs');
-    const xoutputs = validateRequiredOutputs(storage, userId, vargs);
-    logger === null || logger === void 0 ? void 0 : logger.log('validated required outputs');
-    const changeBasketName = 'default';
-    const changeBasket = (0, utilityHelpers_1.verifyOne)(await storage.findOutputBaskets({
-        partial: { userId, name: changeBasketName }
-    }), `Invalid outputGeneration basket "${changeBasketName}"`);
-    logger === null || logger === void 0 ? void 0 : logger.log('found change basket');
-    const noSendChangeIn = await validateNoSendChange(storage, userId, vargs, changeBasket);
-    logger === null || logger === void 0 ? void 0 : logger.log('validated noSendChange');
-    const availableChangeCount = await storage.countChangeInputs(userId, changeBasket.basketId, !vargs.isDelayed);
-    logger === null || logger === void 0 ? void 0 : logger.log(`counted change inputs ${availableChangeCount}`);
+    const validated = await traceStorageStep(storage, 'wallet.storage.create_action.validate', parent, {
+        'action.fixed_input_count': vargs.inputs.length,
+        'action.fixed_output_count': vargs.outputs.length
+    }, async (span) => {
+        const requiredInputs = await validateRequiredInputs(storage, userId, vargs);
+        logger?.log('validated required inputs');
+        const xoutputs = validateRequiredOutputs(storage, userId, vargs);
+        logger?.log('validated required outputs');
+        const changeBasketName = 'default';
+        const changeBasket = (0, utilityHelpers_1.verifyOne)(await storage.findOutputBaskets({
+            partial: { userId, name: changeBasketName }
+        }), `Invalid outputGeneration basket "${changeBasketName}"`);
+        logger?.log('found change basket');
+        const noSendChangeIn = await validateNoSendChange(storage, userId, vargs, changeBasket);
+        logger?.log('validated noSendChange');
+        span?.end({
+            attributes: {
+                'action.validated_input_count': requiredInputs.xinputs.length,
+                'action.validated_output_count': xoutputs.length,
+                'action.no_send_change_input_count': noSendChangeIn.length,
+                'action.validated_beef_tx_count': requiredInputs.beef.txs.length
+            }
+        });
+        return { ...requiredInputs, xoutputs, changeBasket, noSendChangeIn };
+    });
+    const { storageBeef, beef, xinputs, xoutputs, changeBasket, noSendChangeIn } = validated;
     const feeModel = (0, StorageProvider_1.validateStorageFeeModel)(storage.feeModel);
-    logger === null || logger === void 0 ? void 0 : logger.log(`validated fee model ${JSON.stringify(feeModel)}`);
-    await preflightInsufficientFundsFastPath(vargs, xinputs, xoutputs, noSendChangeIn, availableChangeCount, feeModel);
-    logger === null || logger === void 0 ? void 0 : logger.log('passed insufficient-funds preflight');
-    const newTx = await createNewTxRecord(storage, userId, vargs, storageBeef);
-    logger === null || logger === void 0 ? void 0 : logger.log(`created new transaction record`);
-    const ctx = {
-        xinputs,
-        xoutputs,
-        changeBasket,
-        noSendChangeIn,
-        availableChangeCount,
-        feeModel,
-        transactionId: newTx.transactionId
-    };
-    const { allocatedChange, changeOutputs, derivationPrefix, maxPossibleSatoshisAdjustment } = await fundNewTransactionSdk(storage, userId, vargs, ctx);
-    logger === null || logger === void 0 ? void 0 : logger.log(`funded new transaction`);
-    if (maxPossibleSatoshisAdjustment) {
-        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 === null || logger === void 0 ? void 0 : 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);
-    await storage.updateTransaction(newTx.transactionId, { satoshis });
-    const { outputs, changeVouts } = await createNewOutputs(storage, userId, vargs, ctx, changeOutputs);
-    logger === null || logger === void 0 ? void 0 : logger.log(`created new output records`);
-    const inputBeef = await mergeAllocatedChangeBeefs(storage, userId, vargs, allocatedChange, beef);
-    logger === null || logger === void 0 ? void 0 : logger.log(`merged allocated change beefs`);
-    const inputs = await createNewInputs(storage, userId, vargs, ctx, allocatedChange);
-    logger === null || logger === void 0 ? void 0 : logger.log(`created new inputs`);
-    const r = {
-        reference: newTx.reference,
-        version: newTx.version,
-        lockTime: newTx.lockTime,
-        inputs,
-        outputs,
-        derivationPrefix,
-        inputBeef,
-        noSendChangeOutputVouts: vargs.isNoSend ? changeVouts : undefined
-    };
-    logger === null || logger === void 0 ? void 0 : logger.groupEnd();
-    return r;
+    logger?.log(`validated fee model ${JSON.stringify(feeModel)}`);
+    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 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, 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,
+            'action.funding_input_count': allocatedChange.length,
+            'action.include_source_transactions': vargs.includeAllSourceTransactions
+        }, async (span) => {
+            const assembled = await createNewInputs(storage, userId, vargs, ctx, allocatedChange);
+            span?.end({ attributes: { 'action.result_input_count': assembled.length } });
+            return assembled;
+        });
+        logger?.log('created new inputs');
+        const r = {
+            reference: committedTx.reference,
+            version: committedTx.version,
+            lockTime: committedTx.lockTime,
+            inputs,
+            outputs,
+            derivationPrefix,
+            inputBeef,
+            noSendChangeOutputVouts: vargs.isNoSend ? changeVouts : undefined
+        };
+        logger?.groupEnd();
+        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 {
+                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)}`);
+            }
+        }
+        logger?.groupEnd();
+        throw error;
+    }
 }
 function makeDefaultOutput(userId, transactionId, satoshis, vout) {
     const now = new Date();
@@ -108,7 +215,7 @@ function makeDefaultOutput(userId, transactionId, satoshis, vout) {
         outputId: 0,
         userId,
         transactionId,
-        satoshis: satoshis,
+        satoshis,
         vout,
         basketId: undefined,
         change: false,
@@ -128,118 +235,157 @@ function makeDefaultOutput(userId, transactionId, satoshis, vout) {
     };
     return output;
 }
+/** Check known outputs for double-spend, mark them spent, return competing txid if found. */
+async function markKnownInputsSpent(storage, knownInputRows, transactionId) {
+    let doubleSpendTxid;
+    await storage.transaction(async (trx) => {
+        const outputIds = knownInputRows.map(ni => (0, utilityHelpers_1.verifyId)(ni.o.outputId));
+        const knownOutputsById = await storage.findOutputsByIds(outputIds, trx);
+        for (const ni of knownInputRows) {
+            const { i, o } = ni;
+            const o2 = knownOutputsById[(0, utilityHelpers_1.verifyId)(o.outputId)];
+            if (!o2)
+                throw new WERR_errors_1.WERR_INTERNAL(`missing outputId ${o.outputId}`);
+            if (o2.spentBy !== undefined && o2.spentBy !== null) {
+                const spendingTx = await storage.findTransactionById((0, utilityHelpers_1.verifyId)(o2.spentBy), trx);
+                if (spendingTx?.txid) {
+                    doubleSpendTxid = spendingTx.txid;
+                    return;
+                }
+            }
+            if (!o2.spendable) {
+                throw new WERR_errors_1.WERR_INVALID_PARAMETER(`inputs[${i.vin}]`, `spendable output. output ${o.txid}:${o.vout} appears to have been spent (spendable=${o2.spendable}).`);
+            }
+            await storage.updateOutput((0, utilityHelpers_1.verifyId)(o.outputId), { spendable: false, spentBy: transactionId, spendingDescription: i.inputDescription }, trx);
+            o.spendable = false;
+            o.spentBy = transactionId;
+            o.spendingDescription = i.inputDescription;
+        }
+    });
+    return doubleSpendTxid;
+}
+/** Build an SDK input record for a new-input row that has a backing output. */
+async function buildSdkInputFromOutput(storage, vargs, vin, i, o, unlockLen) {
+    if (i == null && !unlockLen)
+        throw new WERR_errors_1.WERR_INTERNAL(`vin ${vin} non-fixedInput without unlockLen`);
+    const sourceTransaction = vargs.includeAllSourceTransactions && vargs.isSignAction
+        ? await storage.getRawTxOfKnownValidTransaction(o.txid)
+        : undefined;
+    return {
+        vin,
+        sourceTxid: o.txid,
+        sourceVout: o.vout,
+        sourceSatoshis: o.satoshis,
+        sourceLockingScript: (0, utilityHelpers_noBuffer_1.asString)(o.lockingScript),
+        sourceTransaction,
+        unlockingScriptLength: unlockLen || i.unlockingScriptLength,
+        providedBy: i != null && o.providedBy === 'storage' ? 'you-and-storage' : o.providedBy,
+        type: o.type,
+        spendingDescription: o.spendingDescription || undefined,
+        derivationPrefix: o.derivationPrefix || undefined,
+        derivationSuffix: o.derivationSuffix || undefined,
+        senderIdentityKey: o.senderIdentityKey || undefined
+    };
+}
+/** Build an SDK input record for a user-specified input with no corresponding stored output. */
+function buildSdkInputFromXInput(vin, i) {
+    return {
+        vin,
+        sourceTxid: i.outpoint.txid,
+        sourceVout: i.outpoint.vout,
+        sourceSatoshis: i.satoshis,
+        sourceLockingScript: i.lockingScript.toHex(),
+        unlockingScriptLength: i.unlockingScriptLength,
+        providedBy: 'you',
+        type: 'custom',
+        spendingDescription: undefined,
+        derivationPrefix: undefined,
+        derivationSuffix: undefined,
+        senderIdentityKey: undefined
+    };
+}
 async function createNewInputs(storage, userId, vargs, ctx, allocatedChange) {
     const r = [];
     const newInputs = [];
-    for (const i of ctx.xinputs) {
-        const o = i.output;
-        newInputs.push({ i, o });
-    }
-    const knownInputRows = newInputs.filter((ni) => !!ni.i && !!ni.o);
+    for (const i of ctx.xinputs)
+        newInputs.push({ i, o: i.output });
+    const knownInputRows = newInputs.filter((ni) => ni.i != null && ni.o != null);
     if (knownInputRows.length > 0) {
-        let doubleSpendTxid;
-        await storage.transaction(async (trx) => {
-            const outputIds = knownInputRows.map(ni => (0, utilityHelpers_1.verifyId)(ni.o.outputId));
-            const knownOutputsById = await storage.findOutputsByIds(outputIds, trx);
-            for (const ni of knownInputRows) {
-                const { i, o } = ni;
-                const o2 = knownOutputsById[(0, utilityHelpers_1.verifyId)(o.outputId)];
-                if (!o2)
-                    throw new WERR_errors_1.WERR_INTERNAL(`missing outputId ${o.outputId}`);
-                if (o2.spentBy !== undefined) {
-                    const spendingTx = await storage.findTransactionById((0, utilityHelpers_1.verifyId)(o2.spentBy), trx);
-                    if (spendingTx === null || spendingTx === void 0 ? void 0 : spendingTx.txid) {
-                        doubleSpendTxid = spendingTx.txid;
-                        return;
-                    }
-                }
-                if (o2.spendable != true) {
-                    throw new WERR_errors_1.WERR_INVALID_PARAMETER(`inputs[${i.vin}]`, `spendable output. output ${o.txid}:${o.vout} appears to have been spent (spendable=${o2.spendable}).`);
-                }
-                await storage.updateOutput((0, utilityHelpers_1.verifyId)(o.outputId), {
-                    spendable: false,
-                    spentBy: ctx.transactionId,
-                    spendingDescription: i.inputDescription
-                }, trx);
-                o.spendable = false;
-                o.spentBy = ctx.transactionId;
-                o.spendingDescription = i.inputDescription;
-            }
-        });
+        const doubleSpendTxid = await markKnownInputsSpent(storage, knownInputRows, ctx.transactionId);
         if (doubleSpendTxid) {
-            const beef = await storage.getBeefForTransaction(doubleSpendTxid, {});
-            const rar = {
-                txid: '',
-                status: 'doubleSpend',
-                competingTxs: [doubleSpendTxid],
-                competingBeef: beef.toBinary()
-            };
-            throw new WERR_errors_1.WERR_REVIEW_ACTIONS([rar], []);
+            const beef = await getCompetingBeefForReview(storage, doubleSpendTxid);
+            throw new WERR_errors_1.WERR_REVIEW_ACTIONS([{ txid: '', status: 'doubleSpend', competingTxs: [doubleSpendTxid], competingBeef: beef.toBinary() }], []);
         }
     }
-    for (const o of allocatedChange) {
+    for (const o of allocatedChange)
         newInputs.push({ o, unlockLen: 107 });
-    }
     let vin = -1;
     for (const { i, o, unlockLen } of newInputs) {
         vin++;
-        if (o) {
-            if (!i && !unlockLen)
-                throw new WERR_errors_1.WERR_INTERNAL(`vin ${vin} non-fixedInput without unlockLen`);
-            const sourceTransaction = vargs.includeAllSourceTransactions && vargs.isSignAction
-                ? await storage.getRawTxOfKnownValidTransaction(o.txid)
-                : undefined;
-            const ri = {
-                vin,
-                sourceTxid: o.txid,
-                sourceVout: o.vout,
-                sourceSatoshis: o.satoshis,
-                sourceLockingScript: (0, utilityHelpers_noBuffer_1.asString)(o.lockingScript),
-                sourceTransaction,
-                unlockingScriptLength: unlockLen ? unlockLen : i.unlockingScriptLength,
-                providedBy: i && o.providedBy === 'storage' ? 'you-and-storage' : o.providedBy,
-                type: o.type,
-                spendingDescription: o.spendingDescription || undefined,
-                derivationPrefix: o.derivationPrefix || undefined,
-                derivationSuffix: o.derivationSuffix || undefined,
-                senderIdentityKey: o.senderIdentityKey || undefined
-            };
-            r.push(ri);
+        if (o != null) {
+            r.push(await buildSdkInputFromOutput(storage, vargs, vin, i, o, unlockLen));
         }
         else {
-            if (!i)
+            if (i == null)
                 throw new WERR_errors_1.WERR_INTERNAL(`vin ${vin} without output or xinput`);
-            // user specified input with no corresponding output being spent.
-            const ri = {
-                vin,
-                sourceTxid: i.outpoint.txid,
-                sourceVout: i.outpoint.vout,
-                sourceSatoshis: i.satoshis,
-                sourceLockingScript: i.lockingScript.toHex(),
-                unlockingScriptLength: i.unlockingScriptLength,
-                providedBy: 'you',
-                type: 'custom',
-                spendingDescription: undefined,
-                derivationPrefix: undefined,
-                derivationSuffix: undefined,
-                senderIdentityKey: undefined
-            };
-            r.push(ri);
+            r.push(buildSdkInputFromXInput(vin, i));
         }
     }
     return r;
 }
-async function createNewOutputs(storage, userId, vargs, ctx, changeOutputs) {
-    var _a;
-    const outputs = [];
-    // Lookup output baskets
+async function getCompetingBeefForReview(storage, txid) {
+    try {
+        return await storage.getBeefForTransaction(txid, {});
+    }
+    catch (e) {
+        const walletError = sdk_2.WalletError.fromUnknown(e);
+        if (walletError instanceof WERR_errors_1.WERR_INVALID_PARAMETER || walletError.code === 'WERR_INVALID_PARAMETER') {
+            const beef = new sdk_1.Beef();
+            beef.mergeTxidOnly(txid);
+            return beef;
+        }
+        throw e;
+    }
+}
+/** 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;
+    const ro = {
+        vout: (0, utilityHelpers_1.verifyInteger)(o.vout),
+        satoshis: sdk_1.Validation.validateSatoshis(o.satoshis, 'o.satoshis'),
+        lockingScript: o.lockingScript == null ? '' : (0, utilityHelpers_noBuffer_1.asString)(o.lockingScript),
+        providedBy: (0, utilityHelpers_1.verifyTruthy)(o.providedBy),
+        purpose: o.purpose || undefined,
+        basket: Object.values(txBaskets).find(b => b.basketId === o.basketId)?.name,
+        tags,
+        outputDescription: o.outputDescription,
+        derivationSuffix: o.derivationSuffix,
+        customInstructions: o.customInstructions
+    };
+    return { changeVout, ro };
+}
+/** 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));
-    // Lookup output tags
+    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);
@@ -255,7 +401,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';
@@ -265,11 +411,9 @@ async function createNewOutputs(storage, userId, vargs, ctx, changeOutputs) {
             newOutputs.push({ o, tags: [] });
         }
         else {
-            // The user wants tracking if they put their output in a basket
-            const basketId = !xo.basket ? undefined : txBaskets[xo.basket].basketId;
             const o = makeDefaultOutput(userId, ctx.transactionId, xo.satoshis, xo.vout);
             o.lockingScript = lockingScript;
-            o.basketId = basketId;
+            o.basketId = xo.basket ? txBaskets[xo.basket].basketId : undefined;
             o.customInstructions = xo.customInstructions;
             o.outputDescription = xo.outputDescription;
             o.providedBy = xo.providedBy;
@@ -282,79 +426,27 @@ async function createNewOutputs(storage, userId, vargs, ctx, changeOutputs) {
         o.spendable = true;
         newOutputs.push({ o, tags: [] });
     }
-    if (vargs.options.randomizeOutputs) {
-        const randomVals = [];
-        const nextRandomVal = () => {
-            let val = 0;
-            if (!randomVals || randomVals.length === 0) {
-                const bytes = (0, sdk_1.Random)(4);
-                val = (((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0) / 0x100000000;
-            }
-            else {
-                val = randomVals.shift() || 0;
-                randomVals.push(val);
-            }
-            return val;
-        };
-        /** In-place array shuffle */
-        const shuffleArray = (array) => {
-            let currentIndex = array.length;
-            let temporaryValue;
-            let randomIndex;
-            while (currentIndex !== 0) {
-                randomIndex = Math.floor(nextRandomVal() * currentIndex);
-                currentIndex -= 1;
-                temporaryValue = array[currentIndex];
-                array[currentIndex] = array[randomIndex];
-                array[randomIndex] = temporaryValue;
-            }
-            return array;
-        };
-        let vout = -1;
-        const newVouts = Array(newOutputs.length);
-        for (let i = 0; i < newVouts.length; i++)
-            newVouts[i] = i;
-        shuffleArray(newVouts);
-        for (const no of newOutputs) {
-            vout++;
-            if (no.o.vout !== vout)
-                throw new WERR_errors_1.WERR_INTERNAL(`new output ${vout} has out of order vout ${no.o.vout}`);
-            no.o.vout = newVouts[vout];
-        }
-    }
+    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) {
-        o.outputId = await storage.insertOutput(o);
-        if (o.change && o.purpose === 'change' && o.providedBy === 'storage')
-            changeVouts.push(o.vout);
-        // Add tags to the output
-        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'),
-            lockingScript: !o.lockingScript ? '' : (0, utilityHelpers_noBuffer_1.asString)(o.lockingScript),
-            providedBy: (0, utilityHelpers_1.verifyTruthy)(o.providedBy),
-            purpose: o.purpose || undefined,
-            basket: (_a = Object.values(txBaskets).find(b => b.basketId === o.basketId)) === null || _a === void 0 ? void 0 : _a.name,
-            tags: tags,
-            outputDescription: o.outputDescription,
-            derivationSuffix: o.derivationSuffix,
-            customInstructions: o.customInstructions
-        };
+        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,
@@ -362,20 +454,22 @@ 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.toBinary(),
+        inputBEEF: storageBeef,
         description: vargs.description,
         txid: undefined,
         rawTx: undefined
     };
-    newTx.transactionId = await storage.insertTransaction(newTx);
-    for (const label of vargs.labels) {
-        const txLabel = await storage.findOrInsertTxLabel(userId, label);
-        await storage.findOrInsertTxLabelMap((0, utilityHelpers_1.verifyId)(newTx.transactionId), (0, utilityHelpers_1.verifyId)(txLabel.txLabelId));
+    newTx.transactionId = await storage.insertTransaction(newTx, trx);
+    const labelNames = [...new Set((0, brc153ReferenceLabels_1.stripBrc153ReferenceLabels)(vargs.labels))];
+    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), trx);
     }
     return newTx;
 }
@@ -455,11 +549,11 @@ function validateRequiredOutputs(storage, userId, vargs) {
  * @returns {xinputs} extended validated required inputs.
  */
 async function validateRequiredInputs(storage, userId, vargs) {
-    //stampLog(vargs, `start storage verifyInputBeef`)
+    // stampLog(vargs, `start storage verifyInputBeef`)
     const beef = new sdk_1.Beef();
     if (vargs.inputs.length === 0)
         return { storageBeef: beef, beef, xinputs: [] };
-    if (vargs.inputBEEF)
+    if (vargs.inputBEEF != null)
         beef.mergeBeef(vargs.inputBEEF);
     const xinputs = vargs.inputs.map((input, vin) => ({
         ...input,
@@ -469,101 +563,109 @@ async function validateRequiredInputs(storage, userId, vargs) {
         output: undefined
     }));
     const trustSelf = vargs.options.trustSelf === 'known';
-    const inputTxids = {};
-    for (const input of xinputs)
-        inputTxids[input.outpoint.txid] = true;
-    // Check beef from user that either there are no txidOnly entries,
-    // or that we can trust storage data and it does indeed vouch
-    // for any txidOnly entries
+    const preloadedOutputsByOutpoint = await storage.findOutputsByOutpoints(userId, xinputs.map(i => ({ txid: i.outpoint.txid, vout: i.outpoint.vout })));
+    const preloadedOutputIds = Object.values(preloadedOutputsByOutpoint).map(output => output.outputId);
+    if ((await storage.findReservedActionBatchOutputIds(preloadedOutputIds)).length > 0) {
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER('inputs', 'outputs not reserved by an active action batch');
+    }
+    const inputsByTxid = {};
+    for (const input of xinputs) {
+        inputsByTxid[input.outpoint.txid] ||= [];
+        inputsByTxid[input.outpoint.txid].push(input);
+    }
+    const localKnownInputTxids = {};
+    for (const [txid, txInputs] of Object.entries(inputsByTxid)) {
+        localKnownInputTxids[txid] = txInputs.every(input => {
+            const output = preloadedOutputsByOutpoint[`${input.outpoint.txid}.${input.outpoint.vout}`];
+            return output?.lockingScript !== undefined && Number.isInteger(output?.satoshis);
+        });
+    }
+    await validateBeefTxidOnlyEntries(beef, inputsByTxid, trustSelf, storage);
+    await ensureBeefContainsAllInputTxids(beef, inputsByTxid, localKnownInputTxids, trustSelf, storage);
+    if (!(await beef.verify(await storage.getServices().getChainTracker(), true))) {
+        console.log(`verifyInputBeef failed, inputBEEF failed to verify.\n${beef.toLogString()}\n`);
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER('inputBEEF', 'valid Beef when factoring options.trustSelf');
+    }
+    const storageBeef = beef.clone();
+    for (const input of xinputs) {
+        await resolveInputScript(storage, userId, vargs, input, beef, preloadedOutputsByOutpoint);
+    }
+    return { beef, storageBeef, xinputs };
+}
+/** Check all txidOnly entries in beef: require either trustSelf vouch or throw. */
+async function validateBeefTxidOnlyEntries(beef, inputsByTxid, trustSelf, storage) {
     for (const btx of beef.txs) {
-        if (btx.isTxidOnly) {
-            if (!trustSelf)
-                throw new WERR_errors_1.WERR_INVALID_PARAMETER('inputBEEF', `valid and contain complete proof data for ${btx.txid}`);
-            if (!inputTxids[btx.txid]) {
-                // inputTxids are checked next
-                const isKnown = await storage.verifyKnownValidTransaction(btx.txid);
-                if (!isKnown)
-                    throw new WERR_errors_1.WERR_INVALID_PARAMETER('inputBEEF', `valid and contain complete proof data for unknown ${btx.txid}`);
-            }
+        if (!btx.isTxidOnly)
+            continue;
+        if (!trustSelf)
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('inputBEEF', `valid and contain complete proof data for ${btx.txid}`);
+        if (inputsByTxid[btx.txid] == null) {
+            const isKnown = await storage.verifyKnownValidTransaction(btx.txid);
+            if (!isKnown)
+                throw new WERR_errors_1.WERR_INVALID_PARAMETER('inputBEEF', `valid and contain complete proof data for unknown ${btx.txid}`);
         }
     }
-    // Make sure that there's an entry for all inputs txid values:
-    for (const txid of Object.keys(inputTxids)) {
+}
+/** Ensure beef has an entry (or txidOnly) for every input txid. */
+async function ensureBeefContainsAllInputTxids(beef, inputsByTxid, localKnownInputTxids, trustSelf, storage) {
+    for (const txid of Object.keys(inputsByTxid)) {
         let btx = beef.findTxid(txid);
-        if (!btx && trustSelf) {
+        if (btx == null && localKnownInputTxids[txid])
+            continue;
+        if (btx == null && trustSelf) {
             if (await storage.verifyKnownValidTransaction(txid))
                 btx = beef.mergeTxidOnly(txid);
         }
-        if (!btx) {
+        if (btx == null) {
             throw new WERR_errors_1.WERR_INVALID_PARAMETER('inputBEEF', `valid and contain proof data for possibly known ${txid}, beef ${beef.toLogString()}`);
         }
     }
-    if (!(await beef.verify(await storage.getServices().getChainTracker(), true))) {
-        console.log(`verifyInputBeef failed, inputBEEF failed to verify.\n${beef.toLogString()}\n`);
-        //console.log(`verifyInputBeef failed, inputBEEF failed to verify.\n${stampLogFormat(vargs.log)}\n${beef.toLogString()}\n`)
-        throw new WERR_errors_1.WERR_INVALID_PARAMETER('inputBEEF', 'valid Beef when factoring options.trustSelf');
+}
+/** Resolve satoshis and lockingScript for one xinput from either storage or the beef. */
+function applyStoredInputScript(output, input, vargs) {
+    const { txid, vout } = input.outpoint;
+    if (output.change) {
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER(`inputs[${input.vin}]`, 'an unmanaged input. Change outputs are managed by your wallet.');
     }
-    // beef may now be trusted and has a BeefTx for every input txid.
-    const storageBeef = beef.clone();
-    const preloadedOutputsByOutpoint = await storage.findOutputsByOutpoints(userId, xinputs.map(i => ({ txid: i.outpoint.txid, vout: i.outpoint.vout })));
-    for (const input of xinputs) {
-        const { txid, vout } = input.outpoint;
-        let output = preloadedOutputsByOutpoint[`${txid}.${vout}`];
-        if (!output)
-            output = (0, utilityHelpers_1.verifyOneOrNone)(await storage.findOutputs({ partial: { userId, txid, vout } }));
-        if (output) {
-            if (output.change) {
-                throw new WERR_errors_1.WERR_INVALID_PARAMETER(`inputs[${input.vin}]`, 'an unmanaged input. Change outputs are managed by your wallet.');
-            }
-            input.output = output;
-            if (!Array.isArray(output.lockingScript) || !Number.isInteger(output.satoshis))
-                throw new WERR_errors_1.WERR_INVALID_PARAMETER(`${txid}.${vout}`, 'output with valid lockingScript and satoshis');
-            if (!disableDoubleSpendCheckForTest && !output.spendable && !vargs.isNoSend)
-                throw new WERR_errors_1.WERR_INVALID_PARAMETER(`${txid}.${vout}`, 'spendable output unless noSend is true');
-            // input is spending an existing user output which has an lockingScript
-            input.satoshis = sdk_1.Validation.validateSatoshis(output.satoshis, 'output.satoshis');
-            input.lockingScript = sdk_1.Script.fromBinary((0, utilityHelpers_noBuffer_1.asArray)(output.lockingScript));
-        }
-        else {
-            let btx = beef.findTxid(txid);
-            if (btx.isTxidOnly) {
-                const { rawTx, proven } = await storage.getProvenOrRawTx(txid);
-                //stampLog(vargs, `... storage verifyInputBeef getProvenOrRawTx ${txid} ${proven ? 'proven' : rawTx ? 'rawTx' : 'unknown'}`)
-                if (!rawTx)
-                    throw new WERR_errors_1.WERR_INVALID_PARAMETER('inputBEEF', `valid and contain proof data for ${txid}`);
-                btx = beef.mergeRawTx((0, utilityHelpers_noBuffer_1.asArray)(rawTx));
-                if (proven)
-                    beef.mergeBump(new EntityProvenTx_1.EntityProvenTx(proven).getMerklePath());
-            }
-            // btx is valid has parsed transaction data.
-            if (vout >= btx.tx.outputs.length)
-                throw new WERR_errors_1.WERR_INVALID_PARAMETER(`${txid}.${vout}`, 'valid outpoint');
-            const so = btx.tx.outputs[vout];
-            input.satoshis = sdk_1.Validation.validateSatoshis(so.satoshis, 'so.satoshis');
-            input.lockingScript = so.lockingScript;
+    input.output = output;
+    if (output.lockingScript === undefined || !Number.isInteger(output.satoshis)) {
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER(`${txid}.${vout}`, 'output with valid lockingScript and satoshis');
+    }
+    if (!disableDoubleSpendCheckForTest && !output.spendable && !vargs.isNoSend) {
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER(`${txid}.${vout}`, 'spendable output unless noSend is true');
+    }
+    input.satoshis = sdk_1.Validation.validateSatoshis(output.satoshis, 'output.satoshis');
+    input.lockingScript = sdk_1.Script.fromBinary((0, utilityHelpers_noBuffer_1.asArray)(output.lockingScript));
+}
+async function applyBeefInputScript(storage, beef, input) {
+    const { txid, vout } = input.outpoint;
+    let beefTx = beef.findTxid(txid);
+    if (beefTx.isTxidOnly) {
+        const { rawTx, proven } = await storage.getProvenOrRawTx(txid);
+        if (rawTx == null) {
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('inputBEEF', `valid and contain proof data for ${txid}`);
         }
+        beefTx = beef.mergeRawTx((0, utilityHelpers_noBuffer_1.asArray)(rawTx));
+        if (proven != null)
+            beef.mergeBump(new EntityProvenTx_1.EntityProvenTx(proven).getMerklePath());
     }
-    return { beef, storageBeef, xinputs };
+    if (vout >= beefTx.tx.outputs.length) {
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER(`${txid}.${vout}`, 'valid outpoint');
+    }
+    const sourceOutput = beefTx.tx.outputs[vout];
+    input.satoshis = sdk_1.Validation.validateSatoshis(sourceOutput.satoshis, 'so.satoshis');
+    input.lockingScript = sourceOutput.lockingScript;
 }
-async function verifyBeefFixOrhpans(beef, storage) {
-    const r = beef.verifyValid();
-    if (!r.valid) {
-        // Beef is structurally invalid.
-        return false;
+async function resolveInputScript(storage, userId, vargs, input, beef, preloadedOutputsByOutpoint) {
+    const { txid, vout } = input.outpoint;
+    let output = preloadedOutputsByOutpoint[`${txid}.${vout}`];
+    output ??= (0, utilityHelpers_1.verifyOneOrNone)(await storage.findOutputs({ partial: { userId, txid, vout } }));
+    if (output != null) {
+        applyStoredInputScript(output, input, vargs);
     }
-    const heights = Object.keys(r.roots);
-    const services = storage.getServices();
-    const chainTracker = await services.getChainTracker();
-    let rootsAreValid = true;
-    for (const height of heights) {
-        const isValid = await chainTracker.isValidRootForHeight(r.roots[height], Number(height));
-        if (isValid)
-            continue;
-        // The original block may have been orphaned, check for a new proof.
-        const mp = beef.bumps.find(b => b.blockHeight === Number(height));
-        //const p = await services.getMerklePath()
+    else {
+        await applyBeefInputScript(storage, beef, input);
     }
-    return false;
 }
 async function validateNoSendChange(storage, userId, vargs, changeBasket) {
     const r = [];
@@ -571,111 +673,267 @@ async function validateNoSendChange(storage, userId, vargs, changeBasket) {
         return [];
     const noSendChange = vargs.options.noSendChange;
     if (noSendChange && noSendChange.length > 0) {
+        const byOutpoint = await storage.findOutputsByOutpoints(userId, noSendChange);
         for (const op of noSendChange) {
-            const output = (0, utilityHelpers_1.verifyOneOrNone)(await storage.findOutputs({
-                partial: { userId, txid: op.txid, vout: op.vout }
-            }));
-            // noSendChange is not marked spendable until sent, may not already be spent, and must have a valid greater than zero satoshis
-            if (!output ||
-                output.providedBy !== 'storage' ||
-                output.purpose !== 'change' ||
-                output.spendable === false ||
-                Number.isInteger(output.spentBy) ||
+            const output = byOutpoint[`${op.txid}.${op.vout}`];
+            // noSendChange is signed through the same BRC-29 path as allocated change.
+            // It must satisfy the full managed-change policy, not merely share the
+            // default basket or have a P2PKH-shaped locking script.
+            if (!(0, managedChange_1.isAutoSpendableChangeOutput)(output) ||
                 !(0, utilityHelpers_1.verifyNumber)(output.satoshis) ||
-                output.basketId !== changeBasket.basketId)
-                throw new WERR_errors_1.WERR_INVALID_PARAMETER('noSendChange outpoint', 'valid');
-            if (-1 < r.findIndex(o => o.outputId === output.outputId))
-                // noSendChange duplicate OutPoints are not allowed.
+                output.basketId !== changeBasket.basketId) {
+                throw new WERR_errors_1.WERR_INVALID_PARAMETER('noSendChange outpoint', 'wallet-managed BRC-29 change');
+            }
+            if (r.some(o => o.outputId === output.outputId)) 
+            // noSendChange duplicate OutPoints are not allowed.
+            {
                 throw new WERR_errors_1.WERR_INVALID_PARAMETER('noSendChange outpoint', 'unique. Duplicates are not allowed.');
+            }
             r.push(output);
         }
     }
+    if ((await storage.findReservedActionBatchOutputIds(r.map(output => output.outputId))).length > 0) {
+        throw new WERR_errors_1.WERR_INVALID_PARAMETER('noSendChange', 'outputs not reserved by an active action batch');
+    }
     return r;
 }
-async function preflightInsufficientFundsFastPath(vargs, xinputs, xoutputs, noSendChangeIn, availableChangeCount, feeModel) {
-    if (feeModel.model !== 'sat/kb' || !feeModel.value)
-        return;
-    const fixedInputSatoshis = xinputs.reduce((a, e) => a + e.satoshis, 0);
-    const noSendSatoshis = noSendChangeIn.reduce((a, e) => a + Number(e.satoshis || 0), 0);
-    const spending = xoutputs.reduce((a, e) => a + e.satoshis, 0);
-    const minSize = (0, utils_1.transactionSize)(xinputs.map(i => i.unlockingScriptLength || 0), xoutputs.map(o => Math.floor(o.lockingScript.length / 2)));
-    const minFee = Math.ceil((minSize / 1000) * feeModel.value);
-    const minRequired = spending + minFee;
-    const fixedAvailable = fixedInputSatoshis + noSendSatoshis;
-    if (fixedAvailable >= minRequired)
-        return;
-    // Keep common successful path cheap:
-    // - If there are zero change candidates, failure is certain.
-    // Otherwise, defer to the main funding allocator.
-    const deficit = minRequired - fixedAvailable;
-    if (availableChangeCount <= 0) {
-        throw new WERR_errors_1.WERR_INSUFFICIENT_FUNDS(minRequired, deficit);
-    }
-}
-async function fundNewTransactionSdk(storage, userId, vargs, ctx) {
-    const params = {
-        fixedInputs: ctx.xinputs.map(xi => ({
-            satoshis: xi.satoshis,
-            unlockingScriptLength: xi.unlockingScriptLength
+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) {
+        super('createAction funding claim changed concurrently');
+        this.conflict = conflict;
+    }
+}
+async function traceStorageStep(storage, name, parent, attributes, callback) {
+    if (!storage.telemetry.enabled)
+        return await callback();
+    return await storage.telemetry.withSpan(name, { component: 'wallet-storage', parent: parent?.context, attributes }, async (span) => await callback(span));
+}
+function makeFundingParams(vargs, xinputs, xoutputs, changeBasket, feeModel, availableChangeCount) {
+    return {
+        fixedInputs: xinputs.map(input => ({
+            satoshis: input.satoshis,
+            unlockingScriptLength: input.unlockingScriptLength
         })),
-        fixedOutputs: ctx.xoutputs.map(xo => ({
-            satoshis: xo.satoshis,
-            lockingScriptLength: xo.lockingScript.length / 2
+        fixedOutputs: xoutputs.map(output => ({
+            satoshis: output.satoshis,
+            lockingScriptLength: output.lockingScript.length / 2
         })),
-        feeModel: ctx.feeModel,
-        changeInitialSatoshis: Math.max(1, ctx.changeBasket.minimumDesiredUTXOValue),
-        changeFirstSatoshis: Math.max(1, Math.round(ctx.changeBasket.minimumDesiredUTXOValue / 4)),
+        feeModel,
+        changeInitialSatoshis: Math.max(1, changeBasket.minimumDesiredUTXOValue),
+        changeFirstSatoshis: Math.max(1, Math.round(changeBasket.minimumDesiredUTXOValue / 4)),
         changeLockingScriptLength: 25,
         changeUnlockingScriptLength: 107,
-        targetNetCount: ctx.changeBasket.numberOfDesiredUTXOs - ctx.availableChangeCount,
+        targetNetCount: changeBasket.numberOfDesiredUTXOs - availableChangeCount,
         randomVals: vargs.randomVals
     };
-    const noSendChange = [...ctx.noSendChangeIn];
-    const outputs = {};
-    const allocateChangeInput = async (targetSatoshis, exactSatoshis) => {
-        // noSendChange gets allocated first...typically only one input...just allocate in order...
-        if (noSendChange.length > 0) {
-            const o = noSendChange.pop();
-            outputs[o.outputId] = o;
-            // allocate the output in storage, noSendChange is by definition spendable false and part of noSpend transaction batch.
-            await storage.updateOutput(o.outputId, {
-                spendable: false,
-                spentBy: ctx.transactionId
-            });
-            o.spendable = false;
-            o.spentBy = ctx.transactionId;
-            const r = {
-                outputId: o.outputId,
-                satoshis: o.satoshis
-            };
-            return r;
-        }
-        const basketId = ctx.changeBasket.basketId;
-        const o = await storage.allocateChangeInput(userId, basketId, targetSatoshis, exactSatoshis, !vargs.isDelayed, ctx.transactionId);
-        if (!o)
-            return undefined;
-        outputs[o.outputId] = o;
-        const r = {
-            outputId: o.outputId,
-            satoshis: o.satoshis
+}
+async function prepareFundingPlan(storage, 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.findAvailableManagedChangeInputCandidates(userId, changeBasket.basketId, excludeSending, trx);
+        span?.end({
+            attributes: {
+                'funding.candidate_count': outputs.length,
+                'funding.candidate_satoshis': outputs.reduce((sum, output) => sum + output.satoshis, 0)
+            }
+        });
+        return outputs;
+    });
+    const noSendIds = new Set(noSendChangeIn.map(output => output.outputId));
+    const available = candidates.filter(output => !noSendIds.has(output.outputId));
+    // Preserve the legacy target-net-count input: noSendChange was included in
+    // countChangeInputs before it was consumed by the allocator.
+    const params = makeFundingParams(vargs, xinputs, xoutputs, changeBasket, feeModel, candidates.length);
+    return await traceStorageStep(storage, 'wallet.storage.create_action.funding_plan', parent, {
+        'funding.candidate_count': available.length,
+        '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 ??= availableSelector.take(targetSatoshis, exactSatoshis);
+            if (output == null)
+                return undefined;
+            allocated.set(output.outputId, output);
+            return { outputId: output.outputId, satoshis: output.satoshis };
         };
-        return r;
+        const release = async (outputId) => {
+            const output = allocated.get(outputId);
+            if (output == null)
+                return;
+            allocated.delete(outputId);
+            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)));
+        span?.end({
+            attributes: {
+                'funding.allocated_input_count': selected.length,
+                'funding.change_output_count': result.changeOutputs.length,
+                'funding.fee_satoshis': result.fee,
+                'funding.transaction_size_bytes': result.size
+            }
+        });
+        return {
+            params,
+            result,
+            selected,
+            availableChangeCount: candidates.length
+        };
+    });
+}
+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 };
+    }
+    const noSendIds = new Set(noSendChangeIn.map(output => output.outputId));
+    const statuses = ['completed', 'unproven'];
+    if (!excludeSending)
+        statuses.push('sending');
+    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 current = currentById[planned.outputId];
+            if (current?.outputId !== planned.outputId ||
+                current?.satoshis !== planned.satoshis ||
+                current?.basketId !== basketId ||
+                !(0, managedChange_1.isAutoSpendableChangeOutput)(current) ||
+                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, claimTrx);
+        if (updated !== claimed.length) {
+            throw new FundingClaimConflict(claimed.some(output => noSendIds.has(output.outputId)) ? 'noSendChange' : 'candidate');
+        }
+        for (const output of claimed) {
+            output.spendable = false;
+            output.spentBy = transactionId;
+        }
+        return { outputs: claimed, sourceTransactionCount: transactionIds.length };
+    }, 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, trx);
+    return {
+        outputs: claim.outputs,
+        sourceTransactionCount: claim.sourceTransactionCount,
+        ...hydration
     };
-    const releaseChangeInput = async (outputId) => {
-        const nsco = ctx.noSendChangeIn.find(o => o.outputId === outputId);
-        if (nsco) {
-            noSendChange.push(nsco);
-            return;
+}
+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 &&
+        output.txid != null && output.txid !== '');
+    if (missing.length === 0)
+        return { hydratedScriptCount: 0, scriptSourceTransactionCount: 0 };
+    const byTxid = new Map();
+    for (const output of missing) {
+        const txid = (0, utilityHelpers_1.verifyTruthy)(output.txid);
+        const group = byTxid.get(txid) ?? [];
+        group.push(output);
+        byTxid.set(txid, group);
+    }
+    const groups = [...byTxid.entries()];
+    let cursor = 0;
+    await Promise.all(Array.from({ length: Math.min(8, groups.length) }, async () => {
+        while (cursor < groups.length) {
+            const [txid, group] = groups[cursor++];
+            if (group.length === 1) {
+                await storage.validateOutputScript(group[0], trx);
+                continue;
+            }
+            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);
+                }
+            }
+            else {
+                for (const output of group)
+                    await storage.validateOutputScript(output, trx);
+            }
         }
-        await storage.updateOutput(outputId, {
-            spendable: true,
-            spentBy: undefined
-        });
+    }));
+    return {
+        hydratedScriptCount: missing.filter(output => output.lockingScript?.length === output.scriptLength).length,
+        scriptSourceTransactionCount: groups.length
     };
-    const gcr = await (0, generateChange_1.generateChangeSdk)(params, allocateChangeInput, releaseChangeInput, vargs.logger);
+}
+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,
+                trx
+            ]);
+            if (claim.outputs != null) {
+                allocatedChange = claim.outputs;
+                span?.end({
+                    attributes: {
+                        'funding.claim_retry_count': retryCount,
+                        'funding.source_transaction_count': claim.sourceTransactionCount,
+                        'funding.hydrated_script_count': claim.hydratedScriptCount,
+                        'funding.script_source_transaction_count': claim.scriptSourceTransactionCount
+                    }
+                });
+                return;
+            }
+            if (claim.conflict === 'noSendChange') {
+                throw new WERR_errors_1.WERR_INVALID_PARAMETER('noSendChange', 'outputs that remain spendable during action planning');
+            }
+            retryCount++;
+            plan = await prepareFundingPlan(storage, [
+                userId,
+                vargs,
+                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');
+    });
+    if (allocatedChange == null)
+        throw new WERR_errors_1.WERR_INTERNAL('funding plan was not claimed');
+    const params = plan.params;
+    const gcr = plan.result;
     const nextRandomVal = () => {
         let val = 0;
-        if (!vargs.randomVals || vargs.randomVals.length === 0) {
+        if (vargs.randomVals == null || vargs.randomVals.length === 0) {
             const bytes = (0, sdk_1.Random)(4);
             val = (((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0) / 0x100000000;
         }
@@ -695,7 +953,7 @@ async function fundNewTransactionSdk(storage, userId, vargs, ctx) {
     };
     const randomDerivation = (count) => {
         let val = [];
-        if (!vargs.randomVals || vargs.randomVals.length === 0) {
+        if (vargs.randomVals == null || vargs.randomVals.length === 0) {
             val = (0, sdk_1.Random)(count);
         }
         else {
@@ -708,7 +966,7 @@ async function fundNewTransactionSdk(storage, userId, vargs, ctx) {
     const derivationPrefix = randomDerivation(16);
     const r = {
         maxPossibleSatoshisAdjustment: gcr.maxPossibleSatoshisAdjustment,
-        allocatedChange: gcr.allocatedChangeInputs.map(i => outputs[i.outputId]),
+        allocatedChange,
         changeOutputs: gcr.changeOutputs.map((o, i) => ({
             // what we knnow now and can insert into the database for this new transaction's change output
             created_at: new Date(),
@@ -748,15 +1006,73 @@ async function fundNewTransactionSdk(storage, userId, vargs, ctx) {
 function trimInputBeef(beef, vargs) {
     if (vargs.options.returnTXIDOnly)
         return undefined;
-    const knownTxids = {};
-    for (const txid of vargs.options.knownTxids || [])
-        knownTxids[txid] = true;
-    for (const txid of beef.txs.map(btx => btx.txid))
-        if (knownTxids[txid])
-            beef.makeTxidOnly(txid);
-    return beef.toBinary();
-}
-async function mergeAllocatedChangeBeefs(storage, userId, vargs, allocatedChange, beef) {
+    const knownTxids = vargs.options.knownTxids ?? [];
+    const hasKnownTxid = makeKnownTxidLookup(knownTxids);
+    // The returned BEEF normally contains only a handful of transactions. A
+    // direct scan avoids materializing a second full index of a potentially
+    // very large wallet history on every successful action.
+    for (const btx of beef.txs)
+        if (hasKnownTxid(btx.txid))
+            beef.makeTxidOnly(btx.txid);
+    return beef.toUint8Array();
+}
+function makeKnownTxidLookup(knownTxids) {
+    let lookups = 0;
+    let indexed;
+    return txid => {
+        lookups++;
+        if (indexed != null)
+            return indexed.has(txid);
+        if (knownTxids.length > 64 && lookups > 4) {
+            indexed = new Set(knownTxids);
+            return indexed.has(txid);
+        }
+        return knownTxids.includes(txid);
+    };
+}
+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,
@@ -768,11 +1084,62 @@ async function mergeAllocatedChangeBeefs(storage, userId, vargs, allocatedChange
     };
     if (vargs.options.returnTXIDOnly)
         return undefined;
-    for (const o of allocatedChange) {
-        if (!beef.findTxid(o.txid) && !(vargs.options.knownTxids || []).find(txid => txid === o.txid)) {
-            await storage.getBeefForTransaction(o.txid, options);
+    const knownTxids = vargs.options.knownTxids ?? [];
+    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': 1,
+        'beef.prefetch_reused': usePrefetch
+    }, async (span) => {
+        if (missing.length > 0) {
+            fetched = await storage.getBeefForTransactions(missing, { ...options, mergeToBeef: undefined });
         }
-    }
-    return trimInputBeef(beef, vargs);
+        span?.end({
+            attributes: {
+                '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': (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,
+                'beef.merged_bump_count': beef.bumps.length
+            }
+        });
+    });
+    return await traceStorageStep(storage, 'wallet.storage.create_action.beef_trim_serialize', parent, {
+        'beef.tx_count': beef.txs.length,
+        'beef.bump_count': beef.bumps.length,
+        'beef.known_txid_count': knownTxids.length
+    }, async (span) => {
+        const result = trimInputBeef(beef, vargs);
+        span?.end({ attributes: { 'beef.result_bytes': result?.length ?? 0 } });
+        return result;
+    });
 }
 //# sourceMappingURL=createAction.js.map