@bsv/wallet-toolbox-client 2.4.21 → 2.4.22

package/out/index.client.mjs

@@ -4888,6 +4888,12 @@ function upgradeOutputs(db) {
 		autoIncrement: true
 	});
 	store.createIndex("userId", "userId");
+	store.createIndex("userId_basketId", ["userId", "basketId"]);
+	store.createIndex("txid_vout_userId", [
+		"txid",
+		"vout",
+		"userId"
+	], { unique: true });
 	store.createIndex("transactionId", "transactionId");
 	store.createIndex("basketId", "basketId");
 	store.createIndex("spentBy", "spentBy");
@@ -5090,7 +5096,7 @@ async function getBeefForTransaction(storage, txid, options) {
 	if (options.mergeToBeef instanceof Beef) beef = options.mergeToBeef;
 	else if (options.mergeToBeef != null) beef = Beef.fromBinary(options.mergeToBeef);
 	else beef = new Beef();
-	const knownTxids = new Set(options.knownTxids ?? []);
+	const hasKnownTxid = makeKnownTxidLookup$1(options.knownTxids ?? []);
 	const scheduled = /* @__PURE__ */ new Set([txid]);
 	let frontier = [{
 		txid,
@@ -5100,7 +5106,7 @@ async function getBeefForTransaction(storage, txid, options) {
 	const concurrency = Number.isFinite(requestedConcurrency) ? Math.max(1, Math.min(32, Math.floor(requestedConcurrency))) : 8;
 	while (frontier.length > 0) {
 		const current = frontier.filter((item) => beef.findTxid(item.txid) == null);
-		const resolved = await mapWithConcurrency(current, concurrency, async (item) => await resolveBeefForTransaction(storage, item.txid, options, knownTxids, item.depth));
+		const resolved = await mapWithConcurrency(current, concurrency, async (item) => await resolveBeefForTransaction(storage, item.txid, options, hasKnownTxid, item.depth));
 		const next = [];
 		for (let i = 0; i < resolved.length; i++) {
 			const result = resolved[i];
@@ -5117,6 +5123,19 @@ async function getBeefForTransaction(storage, txid, options) {
 	}
 	return beef;
 }
+function makeKnownTxidLookup$1(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 mapWithConcurrency(values, concurrency, mapper) {
 	const results = Array.from({ length: values.length }, () => void 0);
 	let cursor = 0;
@@ -5160,11 +5179,11 @@ async function mergeUsableProvenTransaction(beef, txid, result, options, recursi
 	beef.mergeBump(merklePath);
 	return beef;
 }
-async function resolveBeefForTransaction(storage, txid, options, knownTxids, recursionDepth) {
+async function resolveBeefForTransaction(storage, txid, options, hasKnownTxid, recursionDepth) {
 	const maxDepth = storage.maxRecursionDepth;
 	if (maxDepth && maxDepth <= recursionDepth) throw new WERR_INVALID_OPERATION(`Maximum BEEF depth exceeded. Limit is ${storage.maxRecursionDepth}`);
 	const beef = new Beef();
-	if (knownTxids.has(txid)) {
+	if (hasKnownTxid(txid)) {
 		beef.mergeTxidOnly(txid);
 		return {
 			beef,
@@ -6765,7 +6784,7 @@ function getResultBeef(result) {
 //#endregion
 //#region ../src/signer/methods/createAction.ts
 async function createAction$1(wallet, auth, vargs) {
-	if (!wallet.telemetry.enabled) return await createActionCore(wallet, auth, vargs);
+	if (!wallet.telemetry.enabled) return await createActionCore$1(wallet, auth, vargs);
 	return await wallet.telemetry.withSpan("wallet.create_action", {
 		component: "wallet-toolbox",
 		carrier: vargs,
@@ -6776,7 +6795,7 @@ async function createAction$1(wallet, auth, vargs) {
 			"action.is_sign_action": vargs.isSignAction
 		}
 	}, async (span) => {
-		const result = await createActionCore(wallet, auth, vargs, span);
+		const result = await createActionCore$1(wallet, auth, vargs, span);
 		span.end({ attributes: {
 			"action.has_transaction": result.tx != null,
 			"action.has_signable_transaction": result.signableTransaction != null,
@@ -6785,7 +6804,7 @@ async function createAction$1(wallet, auth, vargs) {
 		return result;
 	});
 }
-async function createActionCore(wallet, auth, vargs, parent) {
+async function createActionCore$1(wallet, auth, vargs, parent) {
 	const r = {};
 	const logger = vargs.logger;
 	let prior;
@@ -9069,7 +9088,16 @@ var Wallet = class {
 			Validation.validateOriginator(originator);
 			args.options ??= {};
 			args.options.trustSelf ||= this.trustSelf;
-			if (this.autoKnownTxids && args.options.knownTxids == null) args.options.knownTxids = this.getKnownTxids(args.options.knownTxids);
+			if (this.autoKnownTxids && args.options.knownTxids == null) if (this.telemetry.enabled) args.options.knownTxids = this.telemetry.withSpan("wallet.create_action.prepare_known_txids", {
+				component: "wallet-toolbox",
+				carrier: args,
+				attributes: { "beef.tx_count": this.beef.txs.length }
+			}, (span) => {
+				const knownTxids = this.getKnownTxids(args.options?.knownTxids);
+				span.end({ attributes: { "beef.known_txid_count": knownTxids.length } });
+				return knownTxids;
+			});
+			else args.options.knownTxids = this.getKnownTxids(args.options.knownTxids);
 			const { auth, vargs } = this.validateAuthAndArgs(args, Validation.validateCreateActionArgs, logger);
 			logger?.log("validated args");
 			vargs.includeAllSourceTransactions = this.includeAllSourceTransactions;
@@ -9388,6 +9416,28 @@ function isAutoSpendableChangeOutput(output) {
 	return isManagedChangeOutput(output) && output.spendable && output.spentBy == null;
 }
 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");
 	if (vargs.isTestWerrReviewActions) throwDummyReviewActions();
@@ -9407,38 +9457,69 @@ async function createAction(storage, auth, vargs, _originator) {
 	* - 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 = 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 { storageBeef, beef, xinputs, xoutputs, changeBasket, noSendChangeIn } = 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 = 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 feeModel = 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;
@@ -9447,12 +9528,27 @@ async function createAction(storage, auth, vargs, _originator) {
 			logger?.log("adjusted change outputs to max possible");
 		}
 		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,
@@ -9731,14 +9827,16 @@ async function createNewTxRecord(storage, userId, vargs, storageBeef) {
 		satoshis: 0,
 		userId,
 		isOutgoing: true,
-		inputBEEF: storageBeef.toBinary(),
+		inputBEEF: storageBeef,
 		description: vargs.description,
 		txid: void 0,
 		rawTx: void 0
 	};
 	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(verifyId(newTx.transactionId), verifyId(txLabel.txLabelId));
 	}
 	return newTx;
@@ -9923,87 +10021,222 @@ async function validateNoSendChange(storage, userId, vargs, changeBasket) {
 	const r = [];
 	if (!vargs.isNoSend) return [];
 	const noSendChange = vargs.options.noSendChange;
-	if (noSendChange && noSendChange.length > 0) for (const op of noSendChange) {
-		const output = verifyOneOrNone(await storage.findOutputs({ partial: {
-			userId,
-			txid: op.txid,
-			vout: op.vout
-		} }));
-		if (!isAutoSpendableChangeOutput(output) || !verifyNumber(output.satoshis) || output.basketId !== changeBasket.basketId) throw new WERR_INVALID_PARAMETER("noSendChange outpoint", "wallet-managed BRC-29 change");
-		if (r.some((o) => o.outputId === output.outputId)) throw new WERR_INVALID_PARAMETER("noSendChange outpoint", "unique. Duplicates are not allowed.");
-		r.push(output);
+	if (noSendChange && noSendChange.length > 0) {
+		const byOutpoint = await storage.findOutputsByOutpoints(userId, noSendChange);
+		for (const op of noSendChange) {
+			const output = byOutpoint[`${op.txid}.${op.vout}`];
+			if (!isAutoSpendableChangeOutput(output) || !verifyNumber(output.satoshis) || output.basketId !== changeBasket.basketId) throw new WERR_INVALID_PARAMETER("noSendChange outpoint", "wallet-managed BRC-29 change");
+			if (r.some((o) => o.outputId === output.outputId)) throw new 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_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 = transactionSize(xinputs.map((i) => i.unlockingScriptLength || 0), xoutputs.map((o) => Math.floor(o.lockingScript.length / 2)));
-	const minRequired = spending + Math.ceil(minSize / 1e3 * feeModel.value);
-	const fixedAvailable = fixedInputSatoshis + noSendSatoshis;
-	if (fixedAvailable >= minRequired) return;
-	const deficit = minRequired - fixedAvailable;
-	if (availableChangeCount <= 0) throw new 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
+var FundingClaimConflict = class 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) => {
-		if (noSendChange.length > 0) {
-			const o = noSendChange.pop();
-			outputs[o.outputId] = o;
-			await storage.updateOutput(o.outputId, {
-				spendable: false,
-				spentBy: ctx.transactionId
-			});
-			o.spendable = false;
-			o.spentBy = ctx.transactionId;
+}
+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));
+	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 = /* @__PURE__ */ new Map();
+		const noSend = [...noSendChangeIn];
+		const allocate = async (targetSatoshis, exactSatoshis) => {
+			let output = noSend.pop();
+			output ??= selectCanonicalChange(available.filter((candidate) => !allocated.has(candidate.outputId)), targetSatoshis, exactSatoshis);
+			if (output == null) return void 0;
+			allocated.set(output.outputId, output);
+			return {
+				outputId: output.outputId,
+				satoshis: output.satoshis
+			};
+		};
+		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 generateChangeSdk(params, allocate, release, vargs.logger, storage.telemetry);
+		const selected = result.allocatedChangeInputs.map((input) => 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_INTERNAL("planned change input is missing txid");
 			return {
-				outputId: o.outputId,
-				satoshis: o.satoshis
+				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 current = currentByOutpoint[`${String(planned.txid)}.${planned.vout}`];
+			const currentStatus = current == null ? void 0 : transactionStatuses.get(current.transactionId);
+			const validTransaction = currentStatus != null && statuses.includes(currentStatus);
+			if (current?.outputId !== planned.outputId || current?.satoshis !== planned.satoshis || current?.basketId !== basketId || !isAutoSpendableChangeOutput(current) || reserved.has(current?.outputId ?? -1) || validTransaction !== true) return { conflict: noSendIds.has(planned.outputId) ? "noSendChange" : "candidate" };
+			claimed.push(current);
+		}
+		if (await storage.markChangeInputsSpent(claimed.map((output) => output.outputId), transactionId, trx) !== 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;
 		}
-		const basketId = ctx.changeBasket.basketId;
-		const o = await storage.allocateChangeInput(userId, basketId, targetSatoshis, exactSatoshis, !vargs.isDelayed, ctx.transactionId);
-		if (o == null) return void 0;
-		outputs[o.outputId] = o;
 		return {
-			outputId: o.outputId,
-			satoshis: o.satoshis
+			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 = /* @__PURE__ */ new Map();
+	for (const output of missing) {
+		const txid = 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: void 0
-		});
+	}));
+	return {
+		hydratedScriptCount: missing.filter((output) => output.lockingScript?.length === output.scriptLength).length,
+		scriptSourceTransactionCount: groups.length
 	};
-	const gcr = await 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_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_INVALID_OPERATION("wallet funding changed repeatedly during action planning; retry createAction");
+	});
+	if (allocatedChange == null) throw new 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) {
@@ -10031,7 +10264,7 @@ async function fundNewTransactionSdk(storage, userId, vargs, ctx) {
 	const derivationPrefix = randomDerivation(16);
 	return {
 		maxPossibleSatoshisAdjustment: gcr.maxPossibleSatoshisAdjustment,
-		allocatedChange: gcr.allocatedChangeInputs.map((i) => outputs[i.outputId]),
+		allocatedChange,
 		changeOutputs: gcr.changeOutputs.map((o, i) => ({
 			created_at: /* @__PURE__ */ new Date(),
 			updated_at: /* @__PURE__ */ new Date(),
@@ -10066,12 +10299,24 @@ async function fundNewTransactionSdk(storage, userId, vargs, ctx) {
 */
 function trimInputBeef(beef, vargs) {
 	if (vargs.options.returnTXIDOnly) return void 0;
-	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 hasKnownTxid = makeKnownTxidLookup(vargs.options.knownTxids ?? []);
+	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: void 0,
 		knownTxids: vargs.options.knownTxids,
@@ -10082,25 +10327,52 @@ async function mergeAllocatedChangeBeefs(storage, userId, vargs, allocatedChange
 		minProofLevel: void 0
 	};
 	if (vargs.options.returnTXIDOnly) return void 0;
-	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) => 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: void 0
-			});
-		}
-	}));
-	for (const fetchedBeef of fetched) {
-		if (fetchedBeef == null) continue;
-		beef.mergeBeef(fetchedBeef);
-	}
-	return trimInputBeef(beef, vargs);
+	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: void 0
+				});
+			}
+		}));
+		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);
+		}
+		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;
+	});
 }
 const dirtyHashLookup = {
 	"00000000000000000019f112ec0a9982926f1258cdcc558dd7c3b7e5dc7fa148": "This is the first header of the invalid SegWit chain.",
@@ -12715,21 +12987,6 @@ async function cleanupExpiredActionBatches(storage) {
 	});
 	return released;
 }
-async function availableManagedChange(storage, userId, basketId, excludeSending, trx) {
-	const statuses = ["completed", "unproven"];
-	if (!excludeSending) statuses.push("sending");
-	const outputs = (await storage.findOutputs({
-		partial: {
-			userId,
-			basketId,
-			spendable: true
-		},
-		txStatus: statuses,
-		trx
-	})).filter(isAutoSpendableChangeOutput);
-	const reserved = new Set(await storage.findReservedActionBatchOutputIds(outputs.map((o) => o.outputId), trx));
-	return outputs.filter((output) => output.spentBy == null && !reserved.has(output.outputId));
-}
 function sourceOutputFromBeef(beef, outpoint) {
 	const output = (beef.findTxid(outpoint.txid)?.tx)?.outputs[outpoint.vout];
 	if (output == null) return void 0;
@@ -12894,7 +13151,7 @@ async function beginActionBatch(storage, auth, args) {
 	const explicit = await resolveExplicitOutputs(storage, userId, args.firstAction, outputScriptLengths != null);
 	const noSendChange = await resolveNoSendChangeOutputs(storage, userId, args.firstAction);
 	const fixedOutputIds = new Set([...explicit.outputs, ...noSendChange.outputs].map((output) => output.outputId));
-	const available = (await availableManagedChange(storage, userId, changeBasket.basketId, !args.firstAction.isDelayed)).filter((output) => !fixedOutputIds.has(output.outputId));
+	const available = (await storage.findAvailableManagedChangeInputs(userId, changeBasket.basketId, !args.firstAction.isDelayed)).filter((output) => !fixedOutputIds.has(output.outputId));
 	const target = estimateFirstActionTarget(storage, args.firstAction, explicit.inputSatoshis + noSendChange.inputSatoshis, outputScriptLengths);
 	const fixedOutputs = [...explicit.outputs, ...noSendChange.outputs];
 	const funding = chooseReservationPool(available, target, Math.max(0, INITIAL_RESERVATION_LIMIT - fixedOutputs.length), INITIAL_EXTRA_OUTPUTS, false, reservationPlanningCosts(storage, changeBasket));
@@ -12938,7 +13195,7 @@ async function extendActionBatch(storage, auth, args) {
 		name: "default"
 	} }));
 	const alreadyReserved = await storage.findActionBatchOutputIds(batch.actionBatchId);
-	const available = await availableManagedChange(storage, userId, basket.basketId, false);
+	const available = await storage.findAvailableManagedChangeInputs(userId, basket.basketId, false);
 	if (!Number.isSafeInteger(args.requestedOutputs) || args.requestedOutputs < 0) throw new WERR_INVALID_PARAMETER("requestedOutputs", "non-negative safe integer");
 	const requestedCount = Math.min(args.requestedOutputs, 64);
 	const funding = chooseReservationPool(available, Math.max(1, args.targetSatoshis), requestedCount, 0, true, reservationPlanningCosts(storage, basket));
@@ -13311,6 +13568,31 @@ async function abortActionBatch(storage, auth, batchId) {
 	});
 }
 //#endregion
+//#region ../src/storage/methods/availableManagedChange.ts
+/**
+* Return the exact set of wallet-managed outputs currently eligible for
+* automatic funding. Keeping this predicate shared prevents the planner,
+* allocator, action-batch reservations, and availability count from drifting.
+*/
+async function availableManagedChange(storage, userId, basketId, excludeSending, trx) {
+	const statuses = ["completed", "unproven"];
+	if (!excludeSending) statuses.push("sending");
+	const outputs = (await storage.findOutputs({
+		partial: {
+			userId,
+			basketId,
+			spendable: true,
+			...managedChangeOutputFields
+		},
+		txStatus: statuses,
+		noScript: true,
+		trx
+	})).filter(isAutoSpendableChangeOutput);
+	if (outputs.length === 0) return outputs;
+	const reserved = new Set(await storage.findReservedActionBatchOutputIds(outputs.map((output) => output.outputId), trx));
+	return outputs.filter((output) => !reserved.has(output.outputId));
+}
+//#endregion
 //#region ../src/storage/StorageProvider.ts
 var StorageProvider = class StorageProvider extends StorageReaderWriter {
 	isDirty = false;
@@ -13344,6 +13626,33 @@ var StorageProvider = class StorageProvider extends StorageReaderWriter {
 		this.maxRecursionDepth = 12;
 		this.scriptVerifier = options.scriptVerifier;
 	}
+	/** Mark a planned set of change inputs spent within the caller's transaction. */
+	async markChangeInputsSpent(outputIds, transactionId, trx) {
+		let updated = 0;
+		const current = await this.findOutputsByIds(outputIds, trx);
+		for (const outputId of outputIds) {
+			const output = current[outputId];
+			if (output == null || !output.spendable || output.spentBy != null) continue;
+			updated += await this.updateOutput(outputId, {
+				spendable: false,
+				spentBy: transactionId
+			}, trx);
+		}
+		return updated;
+	}
+	/** Return unreserved wallet-managed outputs eligible for automatic funding. */
+	async findAvailableManagedChangeInputs(userId, basketId, excludeSending, trx) {
+		return await availableManagedChange(this, userId, basketId, excludeSending, trx);
+	}
+	/** Read the current status of a set of source transactions without loading raw transaction bytes. */
+	async findTransactionStatusesByIds(userId, transactionIds, trx) {
+		const statuses = /* @__PURE__ */ new Map();
+		for (const transactionId of new Set(transactionIds)) {
+			const transaction = await this.findTransactionById(transactionId, trx, true);
+			if (transaction?.userId === userId) statuses.set(transactionId, transaction.status);
+		}
+		return statuses;
+	}
 	async insertActionBatch(_batch, _trx) {
 		throw new WERR_NOT_IMPLEMENTED();
 	}
@@ -13454,7 +13763,7 @@ var StorageProvider = class StorageProvider extends StorageReaderWriter {
 		}
 		return byOutpoint;
 	}
-	async findOutputsByOutpointsForUpdate(userId, outpoints, trx) {
+	async findOutputsByOutpointsForUpdate(userId, outpoints, trx, _noScript = false) {
 		return await this.findOutputsByOutpoints(userId, outpoints, trx);
 	}
 	async findOrInsertOutputBasketsBulk(userId, names, trx) {
@@ -14891,9 +15200,16 @@ var StorageIdb = class extends StorageProvider {
 	async initDB(storageName, storageIdentityKey) {
 		const chain = this.chain;
 		const maxOutputScript = 1024;
-		return await openDB(this.dbName, 2, { upgrade(db) {
+		return await openDB(this.dbName, 3, { upgrade(db, _oldVersion, _newVersion, transaction) {
 			upgradeAllStoresV1(db);
 			upgradeActionBatchStoresV2(db);
+			const outputs = transaction.objectStore("outputs");
+			if (!outputs.indexNames.contains("userId_basketId")) outputs.createIndex("userId_basketId", ["userId", "basketId"]);
+			if (!outputs.indexNames.contains("txid_vout_userId")) outputs.createIndex("txid_vout_userId", [
+				"txid",
+				"vout",
+				"userId"
+			], { unique: true });
 			if (!db.objectStoreNames.contains("settings")) {
 				if (storageName == null || storageName === "" || storageIdentityKey == null || storageIdentityKey === "") throw new WERR_INVALID_OPERATION("migrate must be called before first access");
 				const settings = db.createObjectStore("settings", { keyPath: "storageIdentityKey" });
@@ -15099,11 +15415,53 @@ var StorageIdb = class extends StorageProvider {
 			txStatus,
 			noScript: true
 		};
-		let count = 0;
+		const outputIds = [];
 		await this.filterOutputs(args, (r) => {
-			if (isAutoSpendableChangeOutput(r)) count++;
+			if (isAutoSpendableChangeOutput(r)) outputIds.push(r.outputId);
 		});
-		return count;
+		const reserved = await this.findReservedActionBatchOutputIds(outputIds);
+		return outputIds.length - reserved.length;
+	}
+	async findTransactionStatusesByIds(userId, transactionIds, trx) {
+		const statuses = /* @__PURE__ */ new Map();
+		if (transactionIds.length === 0) return statuses;
+		const dbTrx = this.toDbTrx(["transactions"], "readonly", trx);
+		const store = dbTrx.objectStore("transactions");
+		for (const transactionId of new Set(transactionIds)) {
+			const transaction = await store.get(transactionId);
+			if (transaction?.userId === userId) statuses.set(transactionId, transaction.status);
+		}
+		if (trx == null) await dbTrx.done;
+		return statuses;
+	}
+	async findOutputsByOutpointsInternal(userId, outpoints, trx, noScript = false) {
+		const byOutpoint = {};
+		if (outpoints.length === 0) return byOutpoint;
+		const dbTrx = this.toDbTrx(noScript ? ["outputs"] : [
+			"outputs",
+			"proven_txs",
+			"proven_tx_reqs"
+		], "readonly", trx);
+		const index = dbTrx.objectStore("outputs").index("txid_vout_userId");
+		const unique = [...new Map(outpoints.map((outpoint) => [`${outpoint.txid}.${outpoint.vout}`, outpoint])).values()];
+		const rows = await Promise.all(unique.map(async (outpoint) => await index.get([
+			outpoint.txid,
+			outpoint.vout,
+			userId
+		])));
+		for (const row of rows) {
+			if (row == null) continue;
+			if (!noScript) await this.validateOutputScript(row, dbTrx);
+			byOutpoint[`${String(row.txid)}.${row.vout}`] = this.validateEntity(row);
+		}
+		if (trx == null) await dbTrx.done;
+		return byOutpoint;
+	}
+	async findOutputsByOutpoints(userId, outpoints, trx) {
+		return await this.findOutputsByOutpointsInternal(userId, outpoints, trx);
+	}
+	async findOutputsByOutpointsForUpdate(userId, outpoints, trx, noScript = false) {
+		return await this.findOutputsByOutpointsInternal(userId, outpoints, trx, noScript);
 	}
 	async findCertificatesAuth(auth, args) {
 		if (auth.userId == null || args.partial.userId != null && args.partial.userId !== 0 && args.partial.userId !== auth.userId) throw new WERR_UNAUTHORIZED();
@@ -15866,6 +16224,12 @@ var StorageIdb = class extends StorageProvider {
 				partial.vout,
 				partial.userId
 			], direction);
+			if (partial?.txid != null && partial.txid !== "" && partial?.vout !== void 0) return store.index("txid_vout_userId").openCursor([
+				partial.txid,
+				partial.vout,
+				partial.userId
+			], direction);
+			if (partial?.basketId !== void 0) return store.index("userId_basketId").openCursor([partial.userId, partial.basketId], direction);
 			return store.index("userId").openCursor(partial.userId, direction);
 		}
 		if (partial?.transactionId !== void 0) return store.index("transactionId").openCursor(partial.transactionId, direction);
@@ -15873,6 +16237,17 @@ var StorageIdb = class extends StorageProvider {
 		if (partial?.spentBy !== void 0) return store.index("spentBy").openCursor(partial.spentBy, direction);
 		return store.openCursor(null, direction);
 	}
+	async eligibleOutputTransactionIds(args, dbTrx) {
+		if (args.txStatus == null) return void 0;
+		const validTransactionIds = /* @__PURE__ */ new Set();
+		const transactions = dbTrx.objectStore("transactions");
+		for (const status of args.txStatus) {
+			const index = args.partial.userId === void 0 ? transactions.index("status") : transactions.index("status_userId");
+			const key = args.partial.userId === void 0 ? status : [status, args.partial.userId];
+			for (const transactionId of await index.getAllKeys(key)) validTransactionIds.add(Number(transactionId));
+		}
+		return validTransactionIds;
+	}
 	async filterOutputs(args, filtered, tagIds, isQueryModeAll) {
 		this.assertNoUndefinedInPartial(args.partial);
 		if (args.partial.lockingScript != null) throw new WERR_INVALID_PARAMETER("args.partial.lockingScript", "undefined. Outputs may not be found by lockingScript value.");
@@ -15882,15 +16257,10 @@ var StorageIdb = class extends StorageProvider {
 		const dbTrx = this.toDbTrx(stores, "readonly", args.trx);
 		const direction = args.orderDescending === true ? "prev" : "next";
 		const store = dbTrx.objectStore("outputs");
+		const validTransactionIds = await this.eligibleOutputTransactionIds(args, dbTrx);
 		await scanCursor(await this.openOutputsCursor(store, args.partial, direction), args.since, args.paged?.offset ?? 0, args.paged?.limit, async (r) => {
 			if (!matchesOutputPartial(r, args.partial)) return false;
-			if (args.txStatus !== void 0) {
-				if (await this.countTransactions({
-					partial: { transactionId: r.transactionId },
-					status: args.txStatus,
-					trx: dbTrx
-				}) === 0) return false;
-			}
+			if (validTransactionIds != null && !validTransactionIds.has(r.transactionId)) return false;
 			if (tagIds != null && tagIds.length > 0 && !await this.outputMatchesTags(r.outputId, tagIds, isQueryModeAll, dbTrx)) return false;
 			return true;
 		}, (r) => {