@bsv/wallet-toolbox 2.4.20 → 2.4.22

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

@@ -11,7 +11,6 @@ const utilityHelpers_noBuffer_1 = require("../../utility/utilityHelpers.noBuffer
 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");
@@ -20,6 +19,31 @@ function setDisableDoubleSpendCheckForTest(v) {
     disableDoubleSpendCheckForTest = v;
 }
 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?.group('storage createAction');
     // stampLog(vargs, `start storage createTransactionSdk`)
@@ -44,39 +68,59 @@ 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?.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');
-    const availableChangeCount = await storage.countChangeInputs(userId, changeBasket.basketId, !vargs.isDelayed);
-    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?.log(`validated fee model ${JSON.stringify(feeModel)}`);
-    await preflightInsufficientFundsFastPath(vargs, xinputs, xoutputs, noSendChangeIn, availableChangeCount, feeModel);
-    logger?.log('passed insufficient-funds preflight');
+    const initialFundingPlan = await prepareFundingPlan(storage, { userId, vargs, xinputs, xoutputs, changeBasket, noSendChangeIn, feeModel, parent });
+    logger?.log(`planned funding from ${initialFundingPlan.availableChangeCount} change inputs`);
     let newTx;
     try {
-        newTx = await createNewTxRecord(storage, userId, vargs, storageBeef);
+        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,
-            availableChangeCount,
             feeModel,
             transactionId: newTx.transactionId
         };
-        const { allocatedChange, changeOutputs, derivationPrefix, maxPossibleSatoshisAdjustment } = await fundNewTransactionSdk(storage, userId, vargs, ctx);
+        const { allocatedChange, changeOutputs, derivationPrefix, maxPossibleSatoshisAdjustment } = await fundNewTransactionSdk(storage, userId, vargs, ctx, initialFundingPlan, parent);
         logger?.log('funded new transaction');
         if (maxPossibleSatoshisAdjustment != null) {
             const a = maxPossibleSatoshisAdjustment;
@@ -87,12 +131,27 @@ async function createAction(storage, auth, vargs, _originator) {
         }
         // 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);
+        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;
+        });
         logger?.log('created new output records');
-        const inputBeef = await mergeAllocatedChangeBeefs(storage, userId, vargs, allocatedChange, beef);
+        const inputBeef = await mergeAllocatedChangeBeefs(storage, vargs, allocatedChange, beef, parent);
         logger?.log('merged allocated change beefs');
-        const inputs = await createNewInputs(storage, userId, vargs, ctx, allocatedChange);
+        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: newTx.reference,
@@ -362,14 +421,16 @@ async function createNewTxRecord(storage, userId, vargs, storageBeef) {
         satoshis: 0, // updated after fundingTransaction
         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);
+    const labelNames = [...new Set(vargs.labels)];
+    const labels = await storage.findOrInsertTxLabelsBulk(userId, labelNames);
+    for (const label of labelNames) {
+        const txLabel = labels[label];
         await storage.findOrInsertTxLabelMap((0, utilityHelpers_1.verifyId)(newTx.transactionId), (0, utilityHelpers_1.verifyId)(txLabel.txLabelId));
     }
     return newTx;
@@ -574,10 +635,9 @@ 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 }
-            }));
+            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.
@@ -599,87 +659,232 @@ async function validateNoSendChange(storage, userId, vargs, changeBasket) {
     }
     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);
+class FundingClaimConflict extends Error {
+    conflict;
+    constructor(conflict) {
+        super('createAction funding claim changed concurrently');
+        this.conflict = conflict;
     }
 }
-async function fundNewTransactionSdk(storage, userId, vargs, ctx) {
-    const params = {
-        fixedInputs: ctx.xinputs.map(xi => ({
-            satoshis: xi.satoshis,
-            unlockingScriptLength: xi.unlockingScriptLength
+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 == null)
-            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 } = 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);
+        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 noSend = [...noSendChangeIn];
+        const allocate = async (targetSatoshis, exactSatoshis) => {
+            let output = noSend.pop();
+            output ??= (0, actionPlanning_1.selectCanonicalChange)(available.filter(candidate => !allocated.has(candidate.outputId)), 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);
+            if (noSendIds.has(outputId))
+                noSend.push(output);
+        };
+        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, userId, basketId, excludeSending, transactionId, noSendChangeIn, plan) {
+    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 (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 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);
+            if (current?.outputId !== planned.outputId ||
+                current?.satoshis !== planned.satoshis ||
+                current?.basketId !== basketId ||
+                !(0, managedChange_1.isAutoSpendableChangeOutput)(current) ||
+                reserved.has(current?.outputId ?? -1) ||
+                validTransaction !== true) {
+                return { conflict: noSendIds.has(planned.outputId) ? 'noSendChange' : 'candidate' };
+            }
+            claimed.push(current);
+        }
+        const updated = await storage.markChangeInputsSpent(claimed.map(output => output.outputId), transactionId, trx);
+        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 };
+    }).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);
+    return {
+        outputs: claim.outputs,
+        sourceTransactionCount: claim.sourceTransactionCount,
+        ...hydration
     };
-    const releaseChangeInput = async (outputId) => {
-        const nsco = ctx.noSendChangeIn.find(o => o.outputId === outputId);
-        if (nsco != null) {
-            noSendChange.push(nsco);
-            return;
+}
+async function hydrateFundingInputScripts(storage, outputs) {
+    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]);
+                continue;
+            }
+            const rawTx = await storage.getRawTxOfKnownValidTransaction(txid);
+            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);
+            }
         }
-        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, storage.telemetry);
+}
+async function fundNewTransactionSdk(storage, userId, vargs, ctx, initialPlan, parent) {
+    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);
+            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,
+                xinputs: ctx.xinputs,
+                xoutputs: ctx.xoutputs,
+                changeBasket: ctx.changeBasket,
+                noSendChangeIn: ctx.noSendChangeIn,
+                feeModel: ctx.feeModel,
+                parent
+            });
+        }
+        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 == null || vargs.randomVals.length === 0) {
@@ -715,7 +920,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(),
@@ -755,15 +960,31 @@ 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);
+    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();
 }
-async function mergeAllocatedChangeBeefs(storage, userId, vargs, allocatedChange, beef) {
+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);
+    };
+}
+async function mergeAllocatedChangeBeefs(storage, vargs, allocatedChange, beef, parent) {
     const options = {
         trustSelf: undefined,
         knownTxids: vargs.options.knownTxids,
@@ -775,22 +996,55 @@ async function mergeAllocatedChangeBeefs(storage, userId, vargs, allocatedChange
     };
     if (vargs.options.returnTXIDOnly)
         return undefined;
-    const known = new Set(vargs.options.knownTxids ?? []);
-    const missing = Array.from(new Set(allocatedChange.map(o => o.txid).filter(txid => beef.findTxid(txid) == null && !known.has(txid))));
+    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;
-    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 });
+    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
+    }, 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 });
+            }
+        }));
+        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)
+            }
+        });
+    });
+    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);
         }
-    }));
-    for (const fetchedBeef of fetched) {
-        if (fetchedBeef == null)
-            continue;
-        beef.mergeBeef(fetchedBeef);
-    }
-    return trimInputBeef(beef, vargs);
+        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