@bsv/wallet-toolbox-client 2.4.22 → 2.6.0

package/out/index.client.cjs

@@ -1005,6 +1005,7 @@ function toWalletNetwork(chain) {
 	switch (chain) {
 		case "main": return "mainnet";
 		case "test":
+		case "stn":
 		case "ttn":
 		case "tstn":
 		case "mock": return "testnet";
@@ -1018,6 +1019,7 @@ function toLookupNetworkPreset(chain) {
 	switch (chain) {
 		case "main": return "mainnet";
 		case "test": return "testnet";
+		case "stn":
 		case "ttn":
 		case "tstn":
 		case "mock": return "local";
@@ -1257,7 +1259,11 @@ var ScriptTemplateBRC29 = class {
 		return `${this.params.derivationPrefix ?? ""} ${this.params.derivationSuffix ?? ""}`;
 	}
 	getKeyDeriver(privKey) {
-		if (typeof privKey === "string") privKey = _bsv_sdk.PrivateKey.fromHex(privKey);
+		if (this.params.keyDeriver?.rootKey === privKey) return this.params.keyDeriver;
+		if (typeof privKey === "string") {
+			if (this.params.keyDeriver?.rootKey.toHex() === privKey) return this.params.keyDeriver;
+			privKey = _bsv_sdk.PrivateKey.fromHex(privKey);
+		}
 		if (this.params.keyDeriver == null || this.params.keyDeriver.rootKey.toHex() !== privKey.toHex()) return new _bsv_sdk.CachedKeyDeriver(privKey);
 		return this.params.keyDeriver;
 	}
@@ -1266,8 +1272,11 @@ var ScriptTemplateBRC29 = class {
 		return this.p2pkh.lock(address);
 	}
 	unlock(unlockerPrivKey, lockerPubKey, sourceSatoshis, lockingScript) {
-		const derivedPrivateKey = this.getKeyDeriver(unlockerPrivKey).derivePrivateKey(brc29ProtocolID, this.getKeyID(), lockerPubKey).toHex();
-		return this.p2pkh.unlock(asBsvSdkPrivateKey(derivedPrivateKey), "all", false, sourceSatoshis, lockingScript);
+		const derivedPrivateKey = this.getKeyDeriver(unlockerPrivKey).derivePrivateKey(brc29ProtocolID, this.getKeyID(), lockerPubKey);
+		return this.unlockWithDerivedPrivateKey(derivedPrivateKey, sourceSatoshis, lockingScript);
+	}
+	unlockWithDerivedPrivateKey(derivedPrivateKey, sourceSatoshis, lockingScript) {
+		return this.p2pkh.unlock(derivedPrivateKey, "all", false, sourceSatoshis, lockingScript);
 	}
 	/**
 	* P2PKH unlock estimateLength is a constant
@@ -2461,11 +2470,16 @@ var EntityProvenTx = class EntityProvenTx extends EntityBase {
 	/**
 	* @returns desirialized `MerklePath` object, value is cached.
 	*/
-	getMerklePath() {
-		this._mp ??= _bsv_sdk.MerklePath.fromBinary(this.api.merklePath);
-		return this._mp;
+	getMerklePath(validateRoots = true) {
+		if (validateRoots) {
+			this._mp ??= _bsv_sdk.MerklePath.fromBinary(this.api.merklePath);
+			return this._mp;
+		}
+		this._mpUnchecked ??= _bsv_sdk.MerklePath.fromBinary(this.api.merklePath, true, false);
+		return this._mpUnchecked;
 	}
 	_mp;
+	_mpUnchecked;
 	get provenTxId() {
 		return this.api.provenTxId;
 	}
@@ -5062,8 +5076,10 @@ async function mergeInputBeefs(rawTx, beef, trustSelf, knownTxids, trx, required
 	for (const input of tx.inputs) {
 		const sourceTXID = input.sourceTXID ?? "";
 		if (sourceTXID === "") throw new WERR_INTERNAL("req all transaction inputs must have valid sourceTXID");
-		if (beef.findTxid(sourceTXID) != null) continue;
-		if ((requiredLevels == null || requiredLevels === 0) && knownTxids?.includes(sourceTXID) === true) beef.mergeTxidOnly(sourceTXID);
+		const existing = beef.findTxid(sourceTXID);
+		const callerKnows = (requiredLevels == null || requiredLevels === 0) && knownTxids?.includes(sourceTXID) === true;
+		if (existing != null && (!existing.isTxidOnly || callerKnows || trustSelf === "known")) continue;
+		if (callerKnows) beef.mergeTxidOnly(sourceTXID);
 		else await getValidBeef(sourceTXID, beef, trustSelf, knownTxids, trx, requiredLevels);
 	}
 }
@@ -5127,26 +5143,22 @@ async function notifyTransactionsOfProof(ids, provenTxId, addNote, updateTransac
 * @param options
 */
 async function getBeefForTransaction(storage, txid, options) {
-	let beef;
-	if (options.mergeToBeef instanceof _bsv_sdk.Beef) beef = options.mergeToBeef;
-	else if (options.mergeToBeef != null) beef = _bsv_sdk.Beef.fromBinary(options.mergeToBeef);
-	else beef = new _bsv_sdk.Beef();
+	const beef = mergeTarget(options);
 	const hasKnownTxid = makeKnownTxidLookup$1(options.knownTxids ?? []);
 	const scheduled = /* @__PURE__ */ new Set([txid]);
 	let frontier = [{
 		txid,
 		depth: 0
 	}];
-	const requestedConcurrency = options.maxConcurrency ?? 8;
-	const concurrency = Number.isFinite(requestedConcurrency) ? Math.max(1, Math.min(32, Math.floor(requestedConcurrency))) : 8;
+	const concurrency = normalizeConcurrency(options.maxConcurrency);
 	while (frontier.length > 0) {
-		const current = frontier.filter((item) => beef.findTxid(item.txid) == null);
+		const current = frontier.filter((item) => needsResolution(beef, item.txid, hasKnownTxid));
 		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];
 			beef.mergeBeef(result.beef);
-			for (const dependency of result.dependencies) if (!scheduled.has(dependency) && beef.findTxid(dependency) == null) {
+			for (const dependency of result.dependencies) if (!scheduled.has(dependency) && needsResolution(beef, dependency, hasKnownTxid)) {
 				scheduled.add(dependency);
 				next.push({
 					txid: dependency,
@@ -5158,6 +5170,172 @@ async function getBeefForTransaction(storage, txid, options) {
 	}
 	return beef;
 }
+/**
+* Build one aggregate BEEF for several roots while resolving each storage
+* frontier as a set. This avoids one proof query per funding input on the
+* createAction success path. Complex proof-level and chain-tracker policies
+* retain the established single-root implementation.
+*/
+async function getBeefForTransactions(storage, txids, options) {
+	const beef = mergeTarget(options);
+	const roots = [...new Set(txids)];
+	if (roots.length === 0) return beef;
+	if (requiresSingleRootPolicy(options)) return await mergeSingleRootFragments(storage, roots, options, beef);
+	const hasKnownTxid = makeKnownTxidLookup$1(options.knownTxids ?? []);
+	const scheduled = new Set(roots);
+	let frontier = roots.map((txid) => ({
+		txid,
+		depth: 0
+	}));
+	while (frontier.length > 0) {
+		const unresolved = collectUnresolvedFrontier(storage, frontier, beef, hasKnownTxid);
+		if (unresolved.length === 0) break;
+		const stored = await storage.getProvenOrRawTxs(unresolved.map((item) => item.txid));
+		if (options.trustSelf !== "known" && unresolved.every((item) => stored.get(item.txid)?.proven != null)) {
+			mergeAllProven(storage, beef, unresolved, stored);
+			break;
+		}
+		const [next, missing] = mergeStoredFrontier(beef, unresolved, stored, options, scheduled, hasKnownTxid);
+		await mergeMissingFragments(storage, beef, missing, options);
+		frontier = next;
+	}
+	return beef;
+}
+function mergeTarget(options) {
+	if (options.mergeToBeef instanceof _bsv_sdk.Beef) return options.mergeToBeef;
+	if (options.mergeToBeef != null) return _bsv_sdk.Beef.fromBinary(options.mergeToBeef);
+	return new _bsv_sdk.Beef();
+}
+function requiresSingleRootPolicy(options) {
+	return options.ignoreStorage === true || options.minProofLevel !== void 0 || options.chainTracker != null || options.skipInvalidProofs === true;
+}
+async function mergeSingleRootFragments(storage, roots, options, beef) {
+	const fragments = await mapWithConcurrency(roots.filter((txid) => beef.findTxid(txid) == null), normalizeConcurrency(options.maxConcurrency), async (txid) => await getBeefForTransaction(storage, txid, {
+		...options,
+		mergeToBeef: void 0
+	}));
+	for (const fragment of fragments) beef.mergeBeef(fragment);
+	return beef;
+}
+function collectUnresolvedFrontier(storage, frontier, beef, hasKnownTxid) {
+	const unresolved = [];
+	for (const item of frontier) {
+		if (!needsResolution(beef, item.txid, hasKnownTxid)) continue;
+		if (storage.maxRecursionDepth && storage.maxRecursionDepth <= item.depth) throw new WERR_INVALID_OPERATION(`Maximum BEEF depth exceeded. Limit is ${storage.maxRecursionDepth}`);
+		if (hasKnownTxid(item.txid)) beef.mergeTxidOnly(item.txid);
+		else unresolved.push(item);
+	}
+	return unresolved;
+}
+function decodeProvenEntries(storage, unresolved, stored) {
+	const span = storage.telemetry.enabled ? storage.telemetry.startSpan("wallet.storage.beef.decode_proven_batch", {
+		component: "wallet-storage",
+		attributes: { "beef.proven_tx_count": unresolved.length }
+	}) : void 0;
+	try {
+		const entries = unresolved.map((item) => {
+			const proven = stored.get(item.txid).proven;
+			return {
+				rawTx: proven.rawTx,
+				merklePath: new EntityProvenTx(proven).getMerklePath(false),
+				merkleRoot: proven.merkleRoot
+			};
+		});
+		span?.end({ attributes: { "beef.decoded_proof_count": entries.length } });
+		return entries;
+	} catch (error) {
+		span?.end({
+			status: "error",
+			error
+		});
+		throw error;
+	}
+}
+function mergeAllProven(storage, beef, unresolved, stored) {
+	const entries = decodeProvenEntries(storage, unresolved, stored);
+	const span = storage.telemetry.enabled ? storage.telemetry.startSpan("wallet.storage.beef.merge_proven_batch", {
+		component: "wallet-storage",
+		attributes: { "beef.proven_tx_count": entries.length }
+	}) : void 0;
+	try {
+		mergeProvenEntries(beef, entries, unresolved, stored);
+		span?.end({ attributes: {
+			"beef.merged_tx_count": entries.length,
+			"beef.result_tx_count": beef.txs.length,
+			"beef.result_bump_count": beef.bumps.length
+		} });
+	} catch (error) {
+		span?.end({
+			status: "error",
+			error
+		});
+		throw error;
+	}
+}
+function mergeProvenEntries(beef, entries, unresolved, stored) {
+	if (typeof beef.mergeProvenTxs === "function") {
+		beef.mergeProvenTxs(entries);
+		return;
+	}
+	for (const item of unresolved) {
+		const proven = stored.get(item.txid).proven;
+		beef.mergeRawTx(proven.rawTx);
+		beef.mergeBump(new EntityProvenTx(proven).getMerklePath());
+	}
+}
+function mergeStoredFrontier(beef, unresolved, stored, options, scheduled, hasKnownTxid) {
+	const next = [];
+	const missing = [];
+	for (const item of unresolved) {
+		const result = stored.get(item.txid);
+		if (result?.proven != null) mergeStoredProven(beef, item, result, options);
+		else if (result?.rawTx != null) mergeStoredRaw(beef, item, result, options, scheduled, next, hasKnownTxid);
+		else missing.push(item);
+	}
+	return [next, missing];
+}
+function mergeStoredProven(beef, item, result, options) {
+	if (options.trustSelf === "known") {
+		beef.mergeTxidOnly(item.txid);
+		return;
+	}
+	const proven = result.proven;
+	beef.mergeRawTx(proven.rawTx);
+	beef.mergeBump(new EntityProvenTx(proven).getMerklePath());
+}
+function mergeStoredRaw(beef, item, result, options, scheduled, next, hasKnownTxid) {
+	if (options.trustSelf === "known") {
+		beef.mergeTxidOnly(item.txid);
+		return;
+	}
+	const transaction = beef.mergeRawTx(result.rawTx);
+	if (result.inputBEEF != null) beef.mergeBeef(result.inputBEEF);
+	appendNewDependencies(transaction.inputTxids, item.depth + 1, beef, scheduled, next, hasKnownTxid);
+}
+function appendNewDependencies(dependencies, depth, beef, scheduled, next, hasKnownTxid) {
+	for (const txid of dependencies) {
+		if (scheduled.has(txid) || !needsResolution(beef, txid, hasKnownTxid)) continue;
+		scheduled.add(txid);
+		next.push({
+			txid,
+			depth
+		});
+	}
+}
+function needsResolution(beef, txid, hasKnownTxid) {
+	const entry = beef.findTxid(txid);
+	return entry == null || entry.isTxidOnly && !hasKnownTxid(txid);
+}
+async function mergeMissingFragments(storage, beef, missing, options) {
+	if (missing.length === 0) return;
+	if (options.ignoreServices === true) throw new WERR_INVALID_PARAMETER(`txid ${missing[0].txid}`, `valid transaction on chain ${storage.chain}`);
+	const fragments = await mapWithConcurrency(missing, normalizeConcurrency(options.maxConcurrency), async (item) => await getBeefForTransaction(storage, item.txid, {
+		...options,
+		ignoreStorage: true,
+		mergeToBeef: void 0
+	}));
+	for (const fragment of fragments) beef.mergeBeef(fragment);
+}
 function makeKnownTxidLookup$1(knownTxids) {
 	let lookups = 0;
 	let indexed;
@@ -5171,6 +5349,9 @@ function makeKnownTxidLookup$1(knownTxids) {
 		return knownTxids.includes(txid);
 	};
 }
+function normalizeConcurrency(value = 8) {
+	return Number.isFinite(value) ? Math.max(1, Math.min(32, Math.floor(value))) : 8;
+}
 async function mapWithConcurrency(values, concurrency, mapper) {
 	const results = Array.from({ length: values.length }, () => void 0);
 	let cursor = 0;
@@ -5299,6 +5480,23 @@ async function createMergedBeefOfTxids(txids, storage) {
 //#endregion
 //#region ../src/storage/methods/processAction.ts
 async function processAction$1(storage, auth, args) {
+	if (!storage.telemetry.enabled) return await processActionCore(storage, auth, args);
+	return await storage.telemetry.withSpan("wallet.storage.process_action", {
+		component: "wallet-storage",
+		carrier: args,
+		attributes: {
+			"action.is_new_transaction": args.isNewTx,
+			"action.is_no_send": args.isNoSend,
+			"action.is_delayed": args.isDelayed,
+			"action.send_with_count": args.sendWith.length
+		}
+	}, async (span) => {
+		const result = await processActionCore(storage, auth, args, span);
+		span.end({ attributes: { "action.send_result_count": result.sendWithResults?.length ?? 0 } });
+		return result;
+	});
+}
+async function processActionCore(storage, auth, args, parent) {
 	const logger = args.logger;
 	logger?.group("storage processAction");
 	const userId = verifyId(auth.userId);
@@ -5306,9 +5504,9 @@ async function processAction$1(storage, auth, args) {
 	let req;
 	const txidsOfReqsToShareWithWorld = [...args.sendWith];
 	if (args.isNewTx) {
-		const vargs = await validateCommitNewTxToStorageArgs(storage, userId, args);
+		const vargs = await traceProcessStep(storage, "wallet.storage.process_action.validate", parent, async () => await validateCommitNewTxToStorageArgs(storage, userId, args));
 		logger?.log("validated new tx updates to storage");
-		({req} = await commitNewTxToStorage(storage, userId, vargs));
+		({req} = await traceProcessStep(storage, "wallet.storage.process_action.commit", parent, async () => await commitNewTxToStorage(storage, userId, vargs)));
 		logger?.log("committed new tx updates to storage ");
 		if (!req) throw new WERR_INTERNAL();
 		if (args.isNoSend && !args.isSendWith) logger?.log(`noSend txid ${req.txid}`);
@@ -5317,12 +5515,19 @@ async function processAction$1(storage, auth, args) {
 			logger?.log(`sending txid ${req.txid}`);
 		}
 	}
-	const { swr, ndr } = await shareReqsWithWorld(storage, userId, txidsOfReqsToShareWithWorld, args.isDelayed, void 0, logger);
+	const { swr, ndr } = await traceProcessStep(storage, "wallet.storage.process_action.share", parent, async () => await shareReqsWithWorld(storage, userId, txidsOfReqsToShareWithWorld, args.isDelayed, void 0, logger));
 	r.sendWithResults = swr;
 	r.notDelayedResults = ndr;
 	logger?.groupEnd();
 	return r;
 }
+async function traceProcessStep(storage, name, parent, callback) {
+	if (parent == null) return await callback();
+	return await storage.telemetry.withSpan(name, {
+		component: "wallet-storage",
+		parent: parent.context
+	}, callback);
+}
 /**
 * Verifies that all the txids are known reqs with ready-to-share status.
 * Assigns a batch identifier and updates all the provenTxReqs.
@@ -5493,21 +5698,16 @@ async function validateCommitNewTxToStorageArgs(storage, userId, params) {
 	} }));
 	if (!transaction.isOutgoing) throw new WERR_INVALID_OPERATION("isOutgoing is not true");
 	if (transaction.inputBEEF == null) throw new WERR_INVALID_OPERATION();
-	const beef = _bsv_sdk.Beef.fromBinary(asArray(transaction.inputBEEF));
 	if (transaction.status !== "unsigned" && transaction.status !== "unprocessed") throw new WERR_INVALID_OPERATION(`invalid transaction status ${transaction.status}`);
 	const transactionId = verifyId(transaction.transactionId);
-	const outputOutputs = await storage.findOutputs({ partial: {
+	const [outputOutputs, commissionRows] = await Promise.all([storage.findOutputs({ partial: {
 		userId,
 		transactionId
-	} });
-	const inputOutputs = await storage.findOutputs({ partial: {
-		userId,
-		spentBy: transactionId
-	} });
-	const commission = verifyOneOrNone(await storage.findCommissions({ partial: {
+	} }), storage.commissionSatoshis > 0 ? storage.findCommissions({ partial: {
 		transactionId,
 		userId
-	} }));
+	} }) : Promise.resolve([])]);
+	const commission = verifyOneOrNone(commissionRows);
 	if (storage.commissionSatoshis > 0) {
 		if (commission == null) throw new WERR_INTERNAL();
 		if (!tx.outputs.some((x) => x.satoshis === commission.satoshis && x.lockingScript.toHex() === asString(commission.lockingScript))) throw new WERR_INVALID_OPERATION("Transaction did not include an output to cover service fee.");
@@ -5527,10 +5727,7 @@ async function validateCommitNewTxToStorageArgs(storage, userId, params) {
 		txScriptOffsets,
 		transactionId,
 		transaction,
-		inputOutputs,
 		outputOutputs,
-		commission,
-		beef,
 		req,
 		outputUpdates: [],
 		transactionUpdate: {
@@ -6208,17 +6405,24 @@ async function generateChangeSdkCore(params, allocateChangeInput, releaseChangeI
 		};
 		const fixedInputs = params.fixedInputs;
 		const fixedOutputs = params.fixedOutputs;
+		const fixedFunding = fixedInputs.reduce((sum, input) => sum + input.satoshis, 0);
+		let fixedSpending = fixedOutputs.reduce((sum, output) => sum + output.satoshis, 0);
+		const fixedInputSize = fixedInputs.reduce((sum, input) => sum + transactionInputSize(input.unlockingScriptLength), 0);
+		const fixedOutputSize = fixedOutputs.reduce((sum, output) => sum + transactionOutputSize(output.lockingScriptLength), 0);
+		const changeInputSize = transactionInputSize(params.changeUnlockingScriptLength);
+		const changeOutputSize = transactionOutputSize(params.changeLockingScriptLength);
+		let allocatedFunding = 0;
 		/**
 		* @returns sum of transaction fixedInputs satoshis and fundingInputs satoshis
 		*/
 		const funding = () => {
-			return fixedInputs.reduce((a, e) => a + e.satoshis, 0) + r.allocatedChangeInputs.reduce((a, e) => a + e.satoshis, 0);
+			return fixedFunding + allocatedFunding;
 		};
 		/**
 		* @returns sum of transaction fixedOutputs satoshis
 		*/
 		const spending = () => {
-			return fixedOutputs.reduce((a, e) => a + e.satoshis, 0);
+			return fixedSpending;
 		};
 		/**
 		* @returns sum of transaction changeOutputs satoshis
@@ -6228,7 +6432,9 @@ async function generateChangeSdkCore(params, allocateChangeInput, releaseChangeI
 		};
 		const fee = () => funding() - spending() - change();
 		const size = (addedChangeInputs, addedChangeOutputs) => {
-			return transactionSize([...fixedInputs.map((x) => x.unlockingScriptLength), ...Array.from({ length: r.allocatedChangeInputs.length + (addedChangeInputs || 0) }, () => params.changeUnlockingScriptLength)], [...fixedOutputs.map((x) => x.lockingScriptLength), ...Array.from({ length: r.changeOutputs.length + (addedChangeOutputs || 0) }, () => params.changeLockingScriptLength)]);
+			const inputCount = fixedInputs.length + r.allocatedChangeInputs.length + (addedChangeInputs || 0);
+			const outputCount = fixedOutputs.length + r.changeOutputs.length + (addedChangeOutputs || 0);
+			return 4 + varUintSize(inputCount) + fixedInputSize + (r.allocatedChangeInputs.length + (addedChangeInputs || 0)) * changeInputSize + varUintSize(outputCount) + fixedOutputSize + (r.changeOutputs.length + (addedChangeOutputs || 0)) * changeOutputSize + 4;
 		};
 		/**
 		* @returns the target fee required for the transaction as currently configured under feeModel.
@@ -6267,7 +6473,10 @@ async function generateChangeSdkCore(params, allocateChangeInput, releaseChangeI
 		const releaseAllocatedChangeInputs = async () => {
 			while (r.allocatedChangeInputs.length > 0) {
 				const i = r.allocatedChangeInputs.pop();
-				if (i != null) await releaseChangeInput(i.outputId);
+				if (i != null) {
+					allocatedFunding -= i.satoshis;
+					await releaseChangeInput(i.outputId);
+				}
 			}
 			feeExcessNow = feeExcess();
 		};
@@ -6302,6 +6511,7 @@ async function generateChangeSdkCore(params, allocateChangeInput, releaseChangeI
 				const allocatedChangeInput = await allocateChangeInput(-feeExcess(1, ao) + (ao === 1 ? 2 * params.changeInitialSatoshis : 0) + changeBuffer, exactSatoshis);
 				if (allocatedChangeInput == null) return false;
 				r.allocatedChangeInputs.push(allocatedChangeInput);
+				allocatedFunding += allocatedChangeInput.satoshis;
 				maybeAddChangeOutput(ao);
 				return true;
 			};
@@ -6313,6 +6523,7 @@ async function generateChangeSdkCore(params, allocateChangeInput, releaseChangeI
 				while (r.changeOutputs.length > 0 && feeExcess() < 0) r.changeOutputs.pop();
 				if (feeExcess() < 0) break;
 				removeChurnPairs(r.allocatedChangeInputs, r.changeOutputs);
+				allocatedFunding = r.allocatedChangeInputs.reduce((sum, input) => sum + input.satoshis, 0);
 			}
 		};
 		/**
@@ -6321,7 +6532,9 @@ async function generateChangeSdkCore(params, allocateChangeInput, releaseChangeI
 		await fundTransaction();
 		if (feeExcess() < 0 && vgcpr.hasMaxPossibleOutput !== void 0) {
 			if (fixedOutputs[vgcpr.hasMaxPossibleOutput].satoshis !== 0x775f05a073fff) throw new WERR_INTERNAL();
-			fixedOutputs[vgcpr.hasMaxPossibleOutput].satoshis += feeExcess();
+			const adjustment = feeExcess();
+			fixedOutputs[vgcpr.hasMaxPossibleOutput].satoshis += adjustment;
+			fixedSpending += adjustment;
 			r.maxPossibleSatoshisAdjustment = {
 				fixedOutputIndex: vgcpr.hasMaxPossibleOutput,
 				satoshis: fixedOutputs[vgcpr.hasMaxPossibleOutput].satoshis
@@ -6340,8 +6553,11 @@ async function generateChangeSdkCore(params, allocateChangeInput, releaseChangeI
 		* If needed, seek funding to avoid overspending on fees without a change output to recapture it.
 		*/
 		if (r.changeOutputs.length === 0 && feeExcessNow > 0) {
+			const minimumChange = Math.max(dustFloor, params.changeFirstSatoshis);
+			const totalSatoshisNeeded = spending() + feeTarget(0, 1) + minimumChange;
+			const moreSatoshisNeeded = Math.max(1, totalSatoshisNeeded - funding());
 			await releaseAllocatedChangeInputs();
-			throw new WERR_INSUFFICIENT_FUNDS(spending() + feeTarget(), params.changeFirstSatoshis);
+			throw new WERR_INSUFFICIENT_FUNDS(totalSatoshisNeeded, moreSatoshisNeeded);
 		}
 		/**
 		* Distribute the excess fees across the changeOutputs added.
@@ -6665,6 +6881,8 @@ function makeChangeLock(out, dctr, args, changeKeys, wallet) {
 }
 //#endregion
 //#region ../src/signer/methods/verifyUnlockScripts.ts
+const postChronicleHeightFallback = 943816;
+const canonicalP2PKHScope = _bsv_sdk.TransactionSignature.SIGHASH_ALL + _bsv_sdk.TransactionSignature.SIGHASH_FORKID;
 const javaScriptOnlyVerifier = {
 	shouldVerifySpend: () => false,
 	verifySpend: async () => {
@@ -6676,10 +6894,11 @@ function invalidUnlockingScript(inputIndex, detail) {
 	return new WERR_INVALID_PARAMETER(`inputs[${inputIndex}].unlockScript`, `valid.${suffix}`);
 }
 async function verifyOneSpend(pending, verifier) {
+	const [inputIndex, , spend, context] = pending;
 	try {
-		if (!(verifier === void 0 ? pending.spend.validate(pending.context) : await pending.spend.validateWith(verifier, pending.context))) throw invalidUnlockingScript(pending.inputIndex);
+		if (!(verifier === void 0 ? spend.validate(context) : await spend.validateWith(verifier, context))) throw invalidUnlockingScript(inputIndex);
 	} catch (error) {
-		if (error instanceof _bsv_sdk.ScriptEvaluationError) throw invalidUnlockingScript(pending.inputIndex, error.message);
+		if (error instanceof _bsv_sdk.ScriptEvaluationError) throw invalidUnlockingScript(inputIndex, error.message);
 		throw error;
 	}
 }
@@ -6689,33 +6908,157 @@ async function verifyPendingSpends(pending, verifier) {
 		return;
 	}
 	const batched = [];
-	for (const item of pending) if (verifier.shouldVerifySpend?.(item.spend, item.context) !== false) batched.push(item);
+	for (const item of pending) if (verifier.shouldVerifySpend?.(item[2], item[3]) !== false) batched.push(item);
 	else await verifyOneSpend(item, javaScriptOnlyVerifier);
 	if (batched.length === 0) return;
 	let verdicts;
 	try {
 		verdicts = await verifier.verifySpendsBatch(batched.map((item) => ({
-			spend: item.spend,
-			...item.context
+			spend: item[2],
+			...item[3]
 		})));
 	} catch (error) {
-		if (error instanceof _bsv_sdk.ScriptEvaluationError) throw invalidUnlockingScript(batched[0].inputIndex, error.message);
+		if (error instanceof _bsv_sdk.ScriptEvaluationError) throw invalidUnlockingScript(batched[0][0], error.message);
 		throw error;
 	}
 	if (verdicts.length !== batched.length) throw new Error("Script verifier returned an invalid batch result count");
 	verdicts.forEach((valid, index) => {
-		if (!valid) throw invalidUnlockingScript(batched[index].inputIndex);
+		if (!valid) throw invalidUnlockingScript(batched[index][0]);
 	});
 }
-function collectTransactionSpends(txid, resultIndex, beef, result, pending) {
-	const tx = beef.findTxid(txid)?.tx;
+function wholeTransactionVerifier(verifier) {
+	const candidate = verifier;
+	return typeof candidate?.verifyScripts === "function" ? candidate : void 0;
+}
+function digestBatchVerifier(verifier) {
+	const candidate = verifier;
+	if (typeof candidate?.verifyDigestBatch !== "function") return void 0;
+	if (candidate.isReady?.() === false) return void 0;
+	if (candidate.supportsCrypto?.("verifyDigestBatch") === false) return void 0;
+	return candidate;
+}
+function equalBytes(left, right) {
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index++) if (left[index] !== right[index]) return false;
+	return true;
+}
+function isCanonicalP2PKHLock(lock) {
+	return lock.length === 25 && lock[0] === 118 && lock[1] === 169 && lock[2] === 20 && lock[23] === 136 && lock[24] === 172;
+}
+function parseCanonicalP2PKHUnlock(unlock, lock) {
+	const signatureLength = unlock[0];
+	if (signatureLength == null || signatureLength < 9 || signatureLength > 73 || unlock.length !== 1 + signatureLength + 1 + 33 || unlock[1 + signatureLength] !== 33) return void 0;
+	const checksig = Array.from(unlock.subarray(1, 1 + signatureLength));
+	const publicKey = unlock.subarray(1 + signatureLength + 1);
+	if (publicKey[0] !== 2 && publicKey[0] !== 3 || !equalBytes(_bsv_sdk.Hash.hash160(publicKey), lock.subarray(3, 23))) return void 0;
+	let signature;
+	try {
+		signature = _bsv_sdk.TransactionSignature.fromChecksigFormat(checksig);
+	} catch {
+		return;
+	}
+	if (signature.scope !== canonicalP2PKHScope || !signature.hasLowS() || !equalBytes(signature.toChecksigFormat(), checksig)) return void 0;
+	return [
+		checksig,
+		publicKey,
+		signature
+	];
+}
+/**
+* Recognizes only the exact canonical P2PKH shape generated by this wallet.
+* Anything else retains the general-purpose script interpreter/backend path.
+*/
+function standardP2PKHDigests(tx) {
+	const cache = { hashOutputsSingle: /* @__PURE__ */ new Map() };
+	const items = [];
+	for (let inputIndex = 0; inputIndex < tx.inputs.length; inputIndex++) {
+		const input = tx.inputs[inputIndex];
+		const sourceTransaction = input.sourceTransaction;
+		const sourceTXID = input.sourceTXID;
+		const unlockingScript = input.unlockingScript;
+		if (sourceTransaction == null || sourceTXID == null || unlockingScript == null) return void 0;
+		const sourceOutput = sourceTransaction.outputs[input.sourceOutputIndex];
+		if (sourceOutput == null) return void 0;
+		const lock = sourceOutput.lockingScript.toUint8Array();
+		if (!isCanonicalP2PKHLock(lock)) return void 0;
+		const parsed = parseCanonicalP2PKHUnlock(unlockingScript.toUint8Array(), lock);
+		if (parsed == null) return void 0;
+		const [checksig, publicKey, signature] = parsed;
+		const preimage = _bsv_sdk.TransactionSignature.formatBytes({
+			sourceTXID,
+			sourceOutputIndex: input.sourceOutputIndex,
+			sourceSatoshis: sourceOutput.satoshis ?? 0,
+			transactionVersion: tx.version,
+			otherInputs: [],
+			allInputs: tx.inputs,
+			outputs: tx.outputs,
+			inputIndex,
+			subscript: sourceOutput.lockingScript,
+			inputSequence: input.sequence ?? 4294967295,
+			lockTime: tx.lockTime,
+			scope: signature.scope,
+			cache
+		});
+		items.push({
+			publicKey,
+			digest: Uint8Array.from(_bsv_sdk.Hash.hash256(preimage)),
+			signature: Uint8Array.from(checksig.slice(0, -1))
+		});
+	}
+	return items;
+}
+async function verifyStandardP2PKHDigests(pending, verifier) {
+	if (pending.length === 0) return /* @__PURE__ */ new Set();
+	const items = pending.flatMap((entry) => entry[1]);
+	const verdicts = await verifier.verifyDigestBatch(items);
+	if (verdicts.length !== items.length) throw new Error("Script verifier returned an invalid digest batch result count");
+	const verified = /* @__PURE__ */ new Set();
+	let offset = 0;
+	for (const entry of pending) {
+		const end = offset + entry[1].length;
+		if (verdicts.slice(offset, end).every(Boolean)) verified.add(entry[0]);
+		offset = end;
+	}
+	return verified;
+}
+function hydrateTransactionSources(txid, transactions) {
+	const tx = transactions.get(txid);
+	if (tx == null) throw new WERR_INVALID_PARAMETER("txid", `contained in beef, txid ${txid}`);
+	for (let inputIndex = 0; inputIndex < tx.inputs.length; inputIndex++) {
+		const input = tx.inputs[inputIndex];
+		if (input.sourceTXID == null) throw new WERR_INVALID_PARAMETER(`inputs[${inputIndex}].sourceTXID`, "valid");
+		if (input.unlockingScript == null) throw new WERR_INVALID_PARAMETER(`inputs[${inputIndex}].unlockingScript`, "valid");
+		input.sourceTransaction = transactions.get(input.sourceTXID);
+		if (input.sourceTransaction == null) return void 0;
+		if (input.sourceTransaction.outputs[input.sourceOutputIndex] == null) throw new WERR_INVALID_PARAMETER(`inputs[${inputIndex}].sourceOutputIndex`, "reference an output in the source transaction");
+	}
+	return tx;
+}
+function transactionIndex(txids, beef) {
+	if (txids.length > 0) beef.findTxid(txids[0]);
+	return new Map(beef.txs.map((item) => [item.txid, item.tx]));
+}
+async function verifyWholeTransactions(pending, verifier) {
+	if (pending.length === 0) return /* @__PURE__ */ new Set();
+	let verdicts;
+	try {
+		verdicts = verifier.verifyScriptsBatch === void 0 ? await Promise.all(pending.map(async (item) => await verifier.verifyScripts(item[1]))) : await verifier.verifyScriptsBatch(pending.map((item) => item[1]));
+	} catch (error) {
+		if (error instanceof _bsv_sdk.ScriptEvaluationError) return /* @__PURE__ */ new Set();
+		throw error;
+	}
+	if (verdicts.length !== pending.length) throw new Error("Script verifier returned an invalid transaction batch result count");
+	return new Set(pending.filter((_, index) => verdicts[index]).map((item) => item[0]));
+}
+function collectTransactionSpends(txid, resultIndex, transactions, result, pending) {
+	const tx = transactions.get(txid);
 	if (tx == null) throw new WERR_INVALID_PARAMETER("txid", `contained in beef, txid ${txid}`);
 	const sigHashCache = { hashOutputsSingle: /* @__PURE__ */ new Map() };
 	for (let inputIndex = 0; inputIndex < tx.inputs.length; inputIndex++) {
 		const input = tx.inputs[inputIndex];
 		if (input.sourceTXID == null) throw new WERR_INVALID_PARAMETER(`inputs[${inputIndex}].sourceTXID`, "valid");
 		if (input.unlockingScript == null) throw new WERR_INVALID_PARAMETER(`inputs[${inputIndex}].unlockingScript`, "valid");
-		input.sourceTransaction = beef.findTxid(input.sourceTXID)?.tx;
+		input.sourceTransaction = transactions.get(input.sourceTXID);
 		if (input.sourceTransaction == null) {
 			result.skippedInputs++;
 			continue;
@@ -6727,11 +7070,10 @@ function collectTransactionSpends(txid, resultIndex, beef, result, pending) {
 			consensus: true,
 			utxoHeight
 		};
-		pending.push({
+		pending.push([
 			inputIndex,
 			resultIndex,
-			context,
-			spend: new _bsv_sdk.Spend({
+			new _bsv_sdk.Spend({
 				sourceTXID: input.sourceTXID,
 				sourceOutputIndex: input.sourceOutputIndex,
 				lockingScript: sourceOutput.lockingScript,
@@ -6745,9 +7087,52 @@ function collectTransactionSpends(txid, resultIndex, beef, result, pending) {
 				outputs: tx.outputs,
 				lockTime: tx.lockTime,
 				sigHashCache
-			})
-		});
+			}),
+			context
+		]);
+	}
+}
+function collectAcceleratedTransactions(txids, transactions, digestVerifier, enabled) {
+	const hydrated = /* @__PURE__ */ new Map();
+	const digests = [];
+	if (!enabled) return [hydrated, digests];
+	for (let resultIndex = 0; resultIndex < txids.length; resultIndex++) {
+		const tx = hydrateTransactionSources(txids[resultIndex], transactions);
+		if (tx == null) continue;
+		hydrated.set(resultIndex, tx);
+		if (digestVerifier === void 0) continue;
+		const items = standardP2PKHDigests(tx);
+		if (items != null) digests.push([resultIndex, items]);
 	}
+	return [hydrated, digests];
+}
+function collectWholeTransactionVerifications(hydrated, digestAttempted, verifier) {
+	if (verifier === void 0) return [];
+	const pending = [];
+	for (const [resultIndex, tx] of hydrated) {
+		if (digestAttempted.has(resultIndex)) continue;
+		const params = {
+			tx,
+			blockHeight: postChronicleHeightFallback,
+			consensus: true
+		};
+		if (verifier.shouldVerifyScripts?.(params) === false) continue;
+		pending.push([resultIndex, params]);
+	}
+	return pending;
+}
+function collectFallbackSpends(txids, transactions, accelerated, results) {
+	const pending = [];
+	for (let resultIndex = 0; resultIndex < txids.length; resultIndex++) {
+		if (!accelerated.has(resultIndex)) {
+			collectTransactionSpends(txids[resultIndex], resultIndex, transactions, results[resultIndex], pending);
+			continue;
+		}
+		const tx = transactions.get(txids[resultIndex]);
+		if (tx == null) throw new WERR_INVALID_PARAMETER("txid", `contained in beef, txid ${txids[resultIndex]}`);
+		results[resultIndex].verifiedInputs = tx.inputs.length;
+	}
+	return pending;
 }
 /**
 * Verifies every resolvable input from several transactions in one optional
@@ -6758,10 +7143,17 @@ async function verifyUnlockScriptsBatch(txids, beef, verifier) {
 		verifiedInputs: 0,
 		skippedInputs: 0
 	}));
-	const pending = [];
-	for (let resultIndex = 0; resultIndex < txids.length; resultIndex++) collectTransactionSpends(txids[resultIndex], resultIndex, beef, results[resultIndex], pending);
+	const transactions = transactionIndex(txids, beef);
+	const digestVerifier = digestBatchVerifier(verifier);
+	const wholeVerifier = wholeTransactionVerifier(verifier);
+	const [hydrated, digestPending] = collectAcceleratedTransactions(txids, transactions, digestVerifier, digestVerifier !== void 0 || wholeVerifier !== void 0);
+	const digestAttempted = new Set(digestPending.map((item) => item[0]));
+	const digestVerified = digestVerifier === void 0 ? /* @__PURE__ */ new Set() : await verifyStandardP2PKHDigests(digestPending, digestVerifier);
+	const wholePending = collectWholeTransactionVerifications(hydrated, digestAttempted, wholeVerifier);
+	const wholeVerified = wholeVerifier === void 0 ? /* @__PURE__ */ new Set() : await verifyWholeTransactions(wholePending, wholeVerifier);
+	const pending = collectFallbackSpends(txids, transactions, /* @__PURE__ */ new Set([...digestVerified, ...wholeVerified]), results);
 	await verifyPendingSpends(pending, verifier);
-	for (const item of pending) results[item.resultIndex].verifiedInputs++;
+	for (const item of pending) results[item[1]].verifiedInputs++;
 	return results;
 }
 /**
@@ -6784,21 +7176,56 @@ async function completeSignedTransaction(prior, spends, wallet) {
 		input.unlockingScript = asBsvSdkScript(spend.unlockingScript);
 		if (spend.sequenceNumber !== void 0) input.sequence = spend.sequenceNumber;
 	}
-	for (const pdi of prior.pdi) {
-		const sabppp = new ScriptTemplateBRC29({
-			derivationPrefix: pdi.derivationPrefix,
-			derivationSuffix: pdi.derivationSuffix,
-			keyDeriver: wallet.keyDeriver
-		});
-		const keys = wallet.getClientChangeKeyPair();
-		const lockerPrivKey = keys.privateKey;
-		const unlockerPubKey = pdi.unlockerPubKey || keys.publicKey;
-		const sourceSatoshis = pdi.sourceSatoshis;
-		const lockingScript = asBsvSdkScript(pdi.lockingScript);
-		const unlockTemplate = sabppp.unlock(lockerPrivKey, unlockerPubKey, sourceSatoshis, lockingScript);
-		const input = prior.tx.inputs[pdi.vin];
-		input.unlockingScriptTemplate = unlockTemplate;
-	}
+	const prepareUnlockingTemplates = (keys) => {
+		const counterparties = /* @__PURE__ */ new Map();
+		const counterparty = (publicKey) => {
+			let parsed = counterparties.get(publicKey);
+			if (parsed == null) {
+				parsed = _bsv_sdk.PublicKey.fromString(publicKey);
+				counterparties.set(publicKey, parsed);
+			}
+			return parsed;
+		};
+		const prepared = prior.pdi.map((pdi) => {
+			return {
+				pdi,
+				template: new ScriptTemplateBRC29({
+					derivationPrefix: pdi.derivationPrefix,
+					derivationSuffix: pdi.derivationSuffix,
+					keyDeriver: wallet.keyDeriver
+				}),
+				unlockerPubKey: counterparty(pdi.unlockerPubKey || keys.publicKey)
+			};
+		});
+		const derivations = prepared.map(({ template, unlockerPubKey }) => ({
+			protocolID: brc29ProtocolID,
+			keyID: template.getKeyID(),
+			counterparty: unlockerPubKey
+		}));
+		const derivedPrivateKeys = wallet.keyDeriver.derivePrivateKeys?.(derivations) ?? derivations.map((derivation) => wallet.keyDeriver.derivePrivateKey(derivation.protocolID, derivation.keyID, derivation.counterparty));
+		for (let index = 0; index < prepared.length; index++) {
+			const { pdi, template } = prepared[index];
+			const unlockTemplate = template.unlockWithDerivedPrivateKey(derivedPrivateKeys[index], pdi.sourceSatoshis, asBsvSdkScript(pdi.lockingScript));
+			const input = prior.tx.inputs[pdi.vin];
+			input.unlockingScriptTemplate = unlockTemplate;
+		}
+	};
+	if (wallet.telemetry.enabled && prior.pdi.length > 0) await wallet.telemetry.withSpan("wallet.crypto.prepare_unlocking_templates", {
+		component: "wallet-toolbox",
+		carrier: prior.args,
+		attributes: { "crypto.managed_input_count": prior.pdi.length }
+	}, async (span) => {
+		const keys = await wallet.telemetry.withSpan("wallet.crypto.client_change_key", {
+			component: "wallet-toolbox",
+			parent: span.context
+		}, () => wallet.getClientChangeKeyPair());
+		await wallet.telemetry.withSpan("wallet.crypto.derive_unlocking_templates", {
+			component: "wallet-toolbox",
+			parent: span.context,
+			attributes: { "crypto.managed_input_count": prior.pdi.length }
+		}, () => prepareUnlockingTemplates(keys));
+	});
+	else if (prior.pdi.length > 0) prepareUnlockingTemplates(wallet.getClientChangeKeyPair());
 	if (wallet.telemetry.enabled) await wallet.telemetry.withSpan("wallet.crypto.transaction_sign", {
 		component: "wallet-toolbox",
 		carrier: prior.args,
@@ -6854,19 +7281,22 @@ async function createActionCore$1(wallet, auth, vargs, parent) {
 		prior.tx = await traceActionStep(wallet, "wallet.create_action.complete_signing", parent, async () => await completeSignedTransaction(prior, {}, wallet));
 		logger?.log("completed signed transaction");
 		r.txid = prior.tx.id("hex");
-		const beef = new _bsv_sdk.Beef();
-		if (prior.dcr.inputBeef != null) {
-			const inputBeef = prior.dcr.inputBeef instanceof Uint8Array ? _bsv_sdk.Beef.fromBinaryView(prior.dcr.inputBeef) : _bsv_sdk.Beef.fromBinary(prior.dcr.inputBeef);
-			beef.mergeBeef(inputBeef);
-		}
-		beef.mergeTransaction(prior.tx);
+		const beef = await traceActionStep(wallet, "wallet.create_action.assemble_result_beef", parent, () => {
+			const result = new _bsv_sdk.Beef();
+			if (prior.dcr.inputBeef != null) {
+				const inputBeef = prior.dcr.inputBeef instanceof Uint8Array ? _bsv_sdk.Beef.fromBinaryView(prior.dcr.inputBeef) : _bsv_sdk.Beef.fromBinary(prior.dcr.inputBeef);
+				result.mergeBeef(inputBeef);
+			}
+			result.mergeTransaction(prior.tx);
+			return result;
+		});
 		logger?.log("merged beef");
 		await traceActionStep(wallet, "wallet.create_action.verify_unlock_scripts", parent, async () => await verifyUnlockScripts(r.txid, beef, wallet.scriptVerifier));
 		logger?.log("verified unlock scripts");
 		r.noSendChange = prior.dcr.noSendChangeOutputVouts?.map((vout) => `${r.txid}.${vout}`);
 		beef.atomicTxid = r.txid;
 		setResultBeef(r, beef);
-		if (!vargs.options.returnTXIDOnly) r.tx = beef.toUint8ArrayAtomic(r.txid);
+		if (!vargs.options.returnTXIDOnly) r.tx = await traceActionStep(wallet, "wallet.create_action.serialize_result_beef", parent, () => beef.toUint8ArrayAtomic(r.txid));
 	}
 	const { sendWithResults, notDelayedResults } = await traceActionStep(wallet, "wallet.create_action.process", parent, async () => await processAction(prior, wallet, auth, vargs));
 	logger?.log("processed transaction");
@@ -7484,6 +7914,50 @@ function selectCanonicalChange(outputs, targetSatoshis, exactSatoshis) {
 	if (over != null) return over;
 	return outputs.filter((output) => output.satoshis < targetSatoshis).sort((a, b) => b.satoshis - a.satoshis || b.outputId - a.outputId)[0];
 }
+/**
+* Stateful form of the canonical selector for allocating many inputs from one
+* candidate set. It preserves exact / least-over / largest-under ordering but
+* sorts once instead of filtering and sorting the full set per input.
+*/
+var CanonicalChangeSelector = class {
+	sorted;
+	allocated = /* @__PURE__ */ new Set();
+	constructor(outputs) {
+		this.sorted = [...outputs].sort((a, b) => a.satoshis - b.satoshis || a.outputId - b.outputId);
+	}
+	take(targetSatoshis, exactSatoshis) {
+		if (exactSatoshis !== void 0) for (let index = this.lowerBound(exactSatoshis); index < this.sorted.length; index++) {
+			const output = this.sorted[index];
+			if (output.satoshis !== exactSatoshis) break;
+			if (!this.allocated.has(output.outputId)) return this.allocate(output);
+		}
+		for (let index = this.lowerBound(targetSatoshis); index < this.sorted.length; index++) {
+			const output = this.sorted[index];
+			if (!this.allocated.has(output.outputId)) return this.allocate(output);
+		}
+		for (let index = this.lowerBound(targetSatoshis) - 1; index >= 0; index--) {
+			const output = this.sorted[index];
+			if (!this.allocated.has(output.outputId)) return this.allocate(output);
+		}
+	}
+	release(outputId) {
+		this.allocated.delete(outputId);
+	}
+	allocate(output) {
+		this.allocated.add(output.outputId);
+		return output;
+	}
+	lowerBound(satoshis) {
+		let low = 0;
+		let high = this.sorted.length;
+		while (low < high) {
+			const middle = low + high >>> 1;
+			if (this.sorted[middle].satoshis < satoshis) low = middle + 1;
+			else high = middle;
+		}
+		return low;
+	}
+};
 function repeatableRandom(randomVals) {
 	const values = [...randomVals ?? []];
 	return () => {
@@ -8619,6 +9093,22 @@ var ActionBatchController = class {
 };
 //#endregion
 //#region ../src/Wallet.ts
+function prepareKnownTxidsForCreateAction(wallet, args) {
+	if (!wallet.autoKnownTxids || args.options?.knownTxids != null) return;
+	if (!wallet.telemetry.enabled) {
+		args.options.knownTxids = wallet.getKnownTxids(args.options?.knownTxids);
+		return;
+	}
+	args.options.knownTxids = wallet.telemetry.withSpan("wallet.create_action.prepare_known_txids", {
+		component: "wallet-toolbox",
+		carrier: args,
+		attributes: { "beef.tx_count": wallet.beef.txs.length }
+	}, (span) => {
+		const knownTxids = wallet.getKnownTxids(args.options?.knownTxids);
+		span.end({ attributes: { "beef.known_txid_count": knownTxids.length } });
+		return knownTxids;
+	});
+}
 /**
 * Build a {@link DiscoverCertificatesResult} from contact records so {@link Wallet.discoverByIdentityKey}
 * and {@link Wallet.discoverByAttributes} can short-circuit on a local contacts hit. The synthetic
@@ -9092,6 +9582,7 @@ var Wallet = class {
 		if (this.returnTxidOnly) return beef;
 		const b = parsedBeef ?? _bsv_sdk.Beef.fromBinary(beef);
 		if (!b.atomicTxid) throw new WERR_INTERNAL();
+		if (!b.txs.some((btx) => btx.isTxidOnly && !knownTxids?.includes(btx.txid))) return beef;
 		return this.verifyReturnedTxidOnly(b, knownTxids).toBinaryAtomic(b.atomicTxid);
 	}
 	verifyReturnedTxidOnlyBEEF(beef) {
@@ -9123,16 +9614,7 @@ var Wallet = class {
 			_bsv_sdk.Validation.validateOriginator(originator);
 			args.options ??= {};
 			args.options.trustSelf ||= this.trustSelf;
-			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);
+			prepareKnownTxidsForCreateAction(this, args);
 			const { auth, vargs } = this.validateAuthAndArgs(args, _bsv_sdk.Validation.validateCreateActionArgs, logger);
 			logger?.log("validated args");
 			vargs.includeAllSourceTransactions = this.includeAllSourceTransactions;
@@ -9140,9 +9622,25 @@ var Wallet = class {
 			const r = await createAction$1(this, auth, vargs);
 			logger?.log("action created");
 			const resultBeef = getResultBeef(r);
-			if (r.tx != null) this.beef.mergeBeefFromParty(this.storageParty, resultBeef ?? r.tx);
 			if (r.tx != null) {
-				r.tx = this.verifyReturnedTxidOnlyAtomicBEEF(r.tx, args.options?.knownTxids, resultBeef);
+				const merge = () => this.beef.mergeBeefFromParty(this.storageParty, resultBeef ?? r.tx);
+				if (this.telemetry.enabled) this.telemetry.withSpan("wallet.create_action.merge_result_beef", {
+					component: "wallet-toolbox",
+					carrier: args,
+					attributes: {
+						"beef.retained_tx_count_before": this.beef.txs.length,
+						"beef.result_byte_count": r.tx.length
+					}
+				}, merge);
+				else merge();
+			}
+			if (r.tx != null) {
+				const verify = () => this.verifyReturnedTxidOnlyAtomicBEEF(r.tx, args.options?.knownTxids, resultBeef);
+				r.tx = this.telemetry.enabled ? this.telemetry.withSpan("wallet.create_action.verify_result_beef", {
+					component: "wallet-toolbox",
+					carrier: args,
+					attributes: { "beef.result_byte_count": r.tx.length }
+				}, verify) : verify();
 				logger?.log("verify returned AtomicBEEF");
 			}
 			if (!vargs.isDelayed) throwIfAnyUnsuccessfulCreateActions(r);
@@ -9523,7 +10021,7 @@ async function createActionCore(storage, auth, vargs, parent) {
 	});
 	const feeModel = validateStorageFeeModel(storage.feeModel);
 	logger?.log(`validated fee model ${JSON.stringify(feeModel)}`);
-	const initialFundingPlan = await prepareFundingPlan(storage, {
+	const initialFundingPlan = await prepareFundingPlan(storage, [
 		userId,
 		vargs,
 		xinputs,
@@ -9532,48 +10030,64 @@ async function createActionCore(storage, auth, vargs, parent) {
 		noSendChangeIn,
 		feeModel,
 		parent
-	});
+	]);
 	logger?.log(`planned funding from ${initialFundingPlan.availableChangeCount} change inputs`);
+	const allocatedBeefPrefetch = startAllocatedChangeBeefPrefetch(storage, vargs, initialFundingPlan.selected, beef, parent);
+	const storageBeefBytes = storageBeef.toBinary();
 	let newTx;
+	let newTxCommitted = false;
 	try {
-		const storageBeefBytes = storageBeef.toBinary();
-		newTx = await traceStorageStep(storage, "wallet.storage.create_action.create_record", parent, {
-			"action.label_count": vargs.labels.length,
-			"action.storage_beef_bytes": storageBeefBytes.length
-		}, async (span) => {
-			const transaction = await createNewTxRecord(storage, userId, vargs, storageBeefBytes);
-			span?.end({ attributes: { "action.transaction_record_created": true } });
-			return transaction;
-		});
-		logger?.log("created new transaction record");
-		const ctx = {
-			xinputs,
-			xoutputs,
-			changeBasket,
-			noSendChangeIn,
-			feeModel,
-			transactionId: newTx.transactionId
-		};
-		const { allocatedChange, changeOutputs, derivationPrefix, maxPossibleSatoshisAdjustment } = await fundNewTransactionSdk(storage, userId, vargs, ctx, initialFundingPlan, parent);
-		logger?.log("funded new transaction");
-		if (maxPossibleSatoshisAdjustment != null) {
-			const a = maxPossibleSatoshisAdjustment;
-			if (ctx.xoutputs[a.fixedOutputIndex].satoshis !== 0x775f05a073fff) throw new WERR_INTERNAL();
-			ctx.xoutputs[a.fixedOutputIndex].satoshis = a.satoshis;
-			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);
-		const { outputs, changeVouts } = await traceStorageStep(storage, "wallet.storage.create_action.persist_outputs", parent, {
-			"action.fixed_output_count": ctx.xoutputs.length,
-			"action.change_output_count": changeOutputs.length
-		}, async (span) => {
-			await storage.updateTransaction(newTx.transactionId, { satoshis });
-			const persisted = await createNewOutputs(storage, userId, vargs, ctx, changeOutputs);
-			span?.end({ attributes: { "action.persisted_output_count": persisted.outputs.length } });
-			return persisted;
+		const persisted = await storage.transaction(async (trx) => {
+			const initialSatoshis = fundingPlanSatoshis(initialFundingPlan);
+			newTx = await traceStorageStep(storage, "wallet.storage.create_action.create_record", parent, {
+				"action.label_count": vargs.labels.length,
+				"action.storage_beef_bytes": storageBeefBytes.length
+			}, async (span) => {
+				const transaction = await createNewTxRecord(storage, userId, vargs, storageBeefBytes, initialSatoshis, trx);
+				span?.end({ attributes: { "action.transaction_record_created": true } });
+				return transaction;
+			});
+			logger?.log("created new transaction record");
+			const ctx = {
+				xinputs,
+				xoutputs,
+				changeBasket,
+				noSendChangeIn,
+				feeModel,
+				transactionId: newTx.transactionId
+			};
+			const funded = await fundNewTransactionSdk(storage, userId, vargs, ctx, initialFundingPlan, parent, trx);
+			logger?.log("funded new transaction");
+			if (funded.maxPossibleSatoshisAdjustment != null) {
+				const adjustment = funded.maxPossibleSatoshisAdjustment;
+				if (ctx.xoutputs[adjustment.fixedOutputIndex].satoshis !== 0x775f05a073fff) throw new 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 = verifyTruthy(newTx);
+		const { allocatedChange, derivationPrefix, outputs, changeVouts, ctx } = persisted;
 		logger?.log("created new output records");
-		const inputBeef = await mergeAllocatedChangeBeefs(storage, vargs, allocatedChange, beef, parent);
+		const inputBeef = await mergeAllocatedChangeBeefs(storage, vargs, allocatedChange, beef, allocatedBeefPrefetch, parent);
 		logger?.log("merged allocated change beefs");
 		const inputs = await traceStorageStep(storage, "wallet.storage.create_action.assemble_inputs", parent, {
 			"action.fixed_input_count": ctx.xinputs.length,
@@ -9586,9 +10100,9 @@ async function createActionCore(storage, auth, vargs, parent) {
 		});
 		logger?.log("created new inputs");
 		const r = {
-			reference: newTx.reference,
-			version: newTx.version,
-			lockTime: newTx.lockTime,
+			reference: committedTx.reference,
+			version: committedTx.version,
+			lockTime: committedTx.lockTime,
 			inputs,
 			outputs,
 			derivationPrefix,
@@ -9598,9 +10112,15 @@ async function createActionCore(storage, auth, vargs, parent) {
 		logger?.groupEnd();
 		return r;
 	} catch (error) {
+		await allocatedBeefPrefetch;
 		if (newTx?.transactionId != null) try {
-			await storage.updateTransactionStatus("failed", newTx.transactionId);
-			logger?.log(`marked failed createAction transaction ${newTx.transactionId} after construction error`);
+			if (newTxCommitted) {
+				await storage.updateTransactionStatus("failed", newTx.transactionId);
+				logger?.log(`marked failed createAction transaction ${newTx.transactionId} after construction error`);
+			} else {
+				const failed = await createNewTxRecord(storage, userId, vargs, storageBeefBytes, 0, void 0, "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)}`);
 		}
@@ -9750,23 +10270,10 @@ async function getCompetingBeefForReview(storage, txid) {
 		throw e;
 	}
 }
-/** Randomly reassign vout values across newOutputs using either the provided randomVals or crypto-random bytes. */
-/** Insert the output and attach its tags; return the SDK output descriptor. */
-async function persistNewOutput(storage, o, tags, txTags, txBaskets) {
-	o.outputId = await storage.insertOutput(o);
-	const changeVout = o.change && o.purpose === "change" && o.providedBy === "storage" ? o.vout : void 0;
-	for (const tagName of new Set(tags)) {
-		const tag = txTags[tagName];
-		await storage.insertOutputTagMap({
-			outputId: verifyId(o.outputId),
-			outputTagId: verifyId(tag.outputTagId),
-			created_at: /* @__PURE__ */ new Date(),
-			updated_at: /* @__PURE__ */ new Date(),
-			isDeleted: false
-		});
-	}
+/** Build the SDK descriptor for a persisted output. */
+function describeNewOutput(o, tags, txBaskets) {
 	return {
-		changeVout,
+		changeVout: o.change && o.purpose === "change" && o.providedBy === "storage" ? o.vout : void 0,
 		ro: {
 			vout: verifyInteger(o.vout),
 			satoshis: _bsv_sdk.Validation.validateSatoshis(o.satoshis, "o.satoshis"),
@@ -9781,13 +10288,28 @@ async function persistNewOutput(storage, o, tags, txTags, txBaskets) {
 		}
 	};
 }
-async function createNewOutputs(storage, userId, vargs, ctx, changeOutputs) {
+/** Insert the output and attach its tags; return the SDK output descriptor. */
+async function persistNewOutput(storage, o, tags, txTags, txBaskets, trx) {
+	o.outputId = await storage.insertOutput(o, trx);
+	for (const tagName of new Set(tags)) {
+		const tag = txTags[tagName];
+		await storage.insertOutputTagMap({
+			outputId: verifyId(o.outputId),
+			outputTagId: verifyId(tag.outputTagId),
+			created_at: /* @__PURE__ */ new Date(),
+			updated_at: /* @__PURE__ */ new Date(),
+			isDeleted: false
+		}, trx);
+	}
+	return describeNewOutput(o, tags, txBaskets);
+}
+async function createNewOutputs(storage, userId, vargs, ctx, changeOutputs, trx) {
 	const txBaskets = {};
 	const basketNames = [...new Set(ctx.xoutputs.map((x) => x.basket).filter((v) => !!v))];
-	Object.assign(txBaskets, await storage.findOrInsertOutputBasketsBulk(userId, basketNames));
+	Object.assign(txBaskets, await storage.findOrInsertOutputBasketsBulk(userId, basketNames, trx));
 	const txTags = {};
 	const tagNames = [...new Set(ctx.xoutputs.flatMap((x) => x.tags))];
-	Object.assign(txTags, await storage.findOrInsertOutputTagsBulk(userId, tagNames));
+	Object.assign(txTags, await storage.findOrInsertOutputTagsBulk(userId, tagNames, trx));
 	const newOutputs = [];
 	for (const xo of ctx.xoutputs) {
 		const lockingScript = asArray(xo.lockingScript);
@@ -9803,7 +10325,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";
@@ -9837,10 +10359,12 @@ async function createNewOutputs(storage, userId, vargs, ctx, changeOutputs) {
 		});
 	}
 	if (vargs.options.randomizeOutputs) randomizeOutputVouts(newOutputs.map((output) => output.o), vargs.randomVals);
+	const untagged = newOutputs.filter((output) => output.tags.length === 0);
+	await storage.insertOutputs(untagged.map((output) => output.o), trx);
 	const outputs = [];
 	const changeVouts = [];
 	for (const { o, tags } of newOutputs) {
-		const { changeVout, ro } = await persistNewOutput(storage, o, tags, txTags, txBaskets);
+		const { changeVout, ro } = tags.length === 0 ? describeNewOutput(o, tags, txBaskets) : await persistNewOutput(storage, o, tags, txTags, txBaskets, trx);
 		if (changeVout !== void 0) changeVouts.push(changeVout);
 		outputs.push(ro);
 	}
@@ -9849,7 +10373,7 @@ async function createNewOutputs(storage, userId, vargs, ctx, changeOutputs) {
 		changeVouts
 	};
 }
-async function createNewTxRecord(storage, userId, vargs, storageBeef) {
+async function createNewTxRecord(storage, userId, vargs, storageBeef, satoshis = 0, trx, status = "unsigned") {
 	const now = /* @__PURE__ */ new Date();
 	const newTx = {
 		created_at: now,
@@ -9857,9 +10381,9 @@ async function createNewTxRecord(storage, userId, vargs, storageBeef) {
 		transactionId: 0,
 		version: vargs.version,
 		lockTime: vargs.lockTime,
-		status: "unsigned",
+		status,
 		reference: randomBytesBase64(12),
-		satoshis: 0,
+		satoshis,
 		userId,
 		isOutgoing: true,
 		inputBEEF: storageBeef,
@@ -9867,12 +10391,12 @@ async function createNewTxRecord(storage, userId, vargs, storageBeef) {
 		txid: void 0,
 		rawTx: void 0
 	};
-	newTx.transactionId = await storage.insertTransaction(newTx);
+	newTx.transactionId = await storage.insertTransaction(newTx, trx);
 	const labelNames = [...new Set(vargs.labels)];
-	const labels = await storage.findOrInsertTxLabelsBulk(userId, labelNames);
+	const labels = await storage.findOrInsertTxLabelsBulk(userId, labelNames, trx);
 	for (const label of labelNames) {
 		const txLabel = labels[label];
-		await storage.findOrInsertTxLabelMap(verifyId(newTx.transactionId), verifyId(txLabel.txLabelId));
+		await storage.findOrInsertTxLabelMap(verifyId(newTx.transactionId), verifyId(txLabel.txLabelId), trx);
 	}
 	return newTx;
 }
@@ -10068,6 +10592,9 @@ async function validateNoSendChange(storage, userId, vargs, changeBasket) {
 	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;
 }
+function fundingPlanSatoshis(plan) {
+	return plan.result.changeOutputs.reduce((sum, output) => sum + output.satoshis, 0) - plan.selected.reduce((sum, output) => sum + output.satoshis, 0);
+}
 var FundingClaimConflict = class extends Error {
 	conflict;
 	constructor(conflict) {
@@ -10103,10 +10630,10 @@ function makeFundingParams(vargs, xinputs, xoutputs, changeBasket, feeModel, ava
 	};
 }
 async function prepareFundingPlan(storage, context) {
-	const { userId, vargs, xinputs, xoutputs, changeBasket, noSendChangeIn, feeModel, parent } = context;
+	const [userId, vargs, xinputs, xoutputs, changeBasket, noSendChangeIn, feeModel, parent, trx] = context;
 	const excludeSending = !vargs.isDelayed;
 	const candidates = await traceStorageStep(storage, "wallet.storage.create_action.funding_candidates", parent, { "funding.exclude_sending": excludeSending }, async (span) => {
-		const outputs = await storage.findAvailableManagedChangeInputs(userId, changeBasket.basketId, excludeSending);
+		const outputs = await storage.findAvailableManagedChangeInputCandidates(userId, changeBasket.basketId, excludeSending, trx);
 		span?.end({ attributes: {
 			"funding.candidate_count": outputs.length,
 			"funding.candidate_satoshis": outputs.reduce((sum, output) => sum + output.satoshis, 0)
@@ -10121,10 +10648,12 @@ async function prepareFundingPlan(storage, context) {
 		"funding.no_send_change_count": noSendChangeIn.length
 	}, async (span) => {
 		const allocated = /* @__PURE__ */ new Map();
+		const availableSelector = new 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 ??= selectCanonicalChange(available.filter((candidate) => !allocated.has(candidate.outputId)), targetSatoshis, exactSatoshis);
+			output ??= availableSelector.take(targetSatoshis, exactSatoshis);
 			if (output == null) return void 0;
 			allocated.set(output.outputId, output);
 			return {
@@ -10133,10 +10662,11 @@ async function prepareFundingPlan(storage, context) {
 			};
 		};
 		const release = async (outputId) => {
-			const output = allocated.get(outputId);
-			if (output == null) return;
+			if (allocated.get(outputId) == null) return;
 			allocated.delete(outputId);
-			if (noSendIds.has(outputId)) noSend.push(output);
+			availableSelector.release(outputId);
+			const noSendOutput = noSendById.get(outputId);
+			if (noSendOutput != null) noSend.push(noSendOutput);
 		};
 		const result = await generateChangeSdk(params, allocate, release, vargs.logger, storage.telemetry);
 		const selected = result.allocatedChangeInputs.map((input) => verifyTruthy(allocated.get(input.outputId)));
@@ -10154,7 +10684,8 @@ async function prepareFundingPlan(storage, context) {
 		};
 	});
 }
-async function claimFundingPlan(storage, userId, basketId, excludeSending, transactionId, noSendChangeIn, plan) {
+async function claimFundingPlan(storage, request) {
+	const [userId, basketId, excludeSending, transactionId, noSendChangeIn, plan, trx] = request;
 	if (plan.selected.length === 0) return {
 		outputs: [],
 		sourceTransactionCount: 0,
@@ -10164,27 +10695,16 @@ async function claimFundingPlan(storage, userId, basketId, excludeSending, trans
 	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 {
-				txid: output.txid,
-				vout: output.vout
-			};
-		});
-		const currentByOutpoint = await storage.findOutputsByOutpointsForUpdate(userId, outpoints, trx, true);
-		const reserved = new Set(await storage.findReservedActionBatchOutputIds(plan.selected.map((output) => output.outputId), trx));
-		const transactionIds = [...new Set(Object.values(currentByOutpoint).map((output) => output.transactionId))];
-		const transactionStatuses = await storage.findTransactionStatusesByIds(userId, transactionIds, trx);
+	const claim = await storage.transaction(async (claimTrx) => {
+		const currentById = await storage.findFundingOutputsForUpdate(userId, plan.selected.map((output) => output.outputId), statuses, claimTrx);
+		const transactionIds = [...new Set(Object.values(currentById).map((output) => output.transactionId))];
 		const claimed = [];
 		for (const planned of plan.selected) {
-			const 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" };
+			const current = currentById[planned.outputId];
+			if (current?.outputId !== planned.outputId || current?.satoshis !== planned.satoshis || current?.basketId !== basketId || !isAutoSpendableChangeOutput(current) || current?.txid !== planned.txid || current?.vout !== planned.vout) 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");
+		if (await storage.markChangeInputsSpent(claimed.map((output) => output.outputId), transactionId, claimTrx) !== 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;
@@ -10193,19 +10713,19 @@ async function claimFundingPlan(storage, userId, basketId, excludeSending, trans
 			outputs: claimed,
 			sourceTransactionCount: transactionIds.length
 		};
-	}).catch((error) => {
+	}, trx).catch((error) => {
 		if (error instanceof FundingClaimConflict) return { conflict: error.conflict };
 		throw error;
 	});
 	if (claim.outputs == null) return claim;
-	const hydration = await hydrateFundingInputScripts(storage, claim.outputs);
+	const hydration = await hydrateFundingInputScripts(storage, claim.outputs, trx);
 	return {
 		outputs: claim.outputs,
 		sourceTransactionCount: claim.sourceTransactionCount,
 		...hydration
 	};
 }
-async function hydrateFundingInputScripts(storage, outputs) {
+async function hydrateFundingInputScripts(storage, outputs, trx) {
 	const missing = outputs.filter((output) => output.lockingScript?.length !== output.scriptLength && output.scriptLength != null && output.scriptLength > 0 && output.scriptOffset != null && output.scriptOffset > 0 && output.txid != null && output.txid !== "");
 	if (missing.length === 0) return {
 		hydratedScriptCount: 0,
@@ -10224,12 +10744,12 @@ async function hydrateFundingInputScripts(storage, outputs) {
 		while (cursor < groups.length) {
 			const [txid, group] = groups[cursor++];
 			if (group.length === 1) {
-				await storage.validateOutputScript(group[0]);
+				await storage.validateOutputScript(group[0], trx);
 				continue;
 			}
-			const rawTx = await storage.getRawTxOfKnownValidTransaction(txid);
+			const rawTx = await storage.getRawTxOfKnownValidTransaction(txid, void 0, void 0, 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);
+			else for (const output of group) await storage.validateOutputScript(output, trx);
 		}
 	}));
 	return {
@@ -10237,13 +10757,21 @@ async function hydrateFundingInputScripts(storage, outputs) {
 		scriptSourceTransactionCount: groups.length
 	};
 }
-async function fundNewTransactionSdk(storage, userId, vargs, ctx, initialPlan, parent) {
+async function fundNewTransactionSdk(storage, userId, vargs, ctx, initialPlan, parent, trx) {
 	let plan = initialPlan;
 	let allocatedChange;
 	let retryCount = 0;
 	await traceStorageStep(storage, "wallet.storage.create_action.funding_claim", parent, { "funding.planned_input_count": initialPlan.selected.length }, async (span) => {
 		for (let attempt = 0; attempt < 3; attempt++) {
-			const claim = await claimFundingPlan(storage, userId, ctx.changeBasket.basketId, !vargs.isDelayed, ctx.transactionId, ctx.noSendChangeIn, plan);
+			const claim = await claimFundingPlan(storage, [
+				userId,
+				ctx.changeBasket.basketId,
+				!vargs.isDelayed,
+				ctx.transactionId,
+				ctx.noSendChangeIn,
+				plan,
+				trx
+			]);
 			if (claim.outputs != null) {
 				allocatedChange = claim.outputs;
 				span?.end({ attributes: {
@@ -10256,16 +10784,17 @@ async function fundNewTransactionSdk(storage, userId, vargs, ctx, initialPlan, p
 			}
 			if (claim.conflict === "noSendChange") throw new WERR_INVALID_PARAMETER("noSendChange", "outputs that remain spendable during action planning");
 			retryCount++;
-			plan = await prepareFundingPlan(storage, {
+			plan = await prepareFundingPlan(storage, [
 				userId,
 				vargs,
-				xinputs: ctx.xinputs,
-				xoutputs: ctx.xoutputs,
-				changeBasket: ctx.changeBasket,
-				noSendChangeIn: ctx.noSendChangeIn,
-				feeModel: ctx.feeModel,
-				parent
-			});
+				ctx.xinputs,
+				ctx.xoutputs,
+				ctx.changeBasket,
+				ctx.noSendChangeIn,
+				ctx.feeModel,
+				parent,
+				trx
+			]);
 		}
 		throw new WERR_INVALID_OPERATION("wallet funding changed repeatedly during action planning; retry createAction");
 	});
@@ -10351,7 +10880,56 @@ function makeKnownTxidLookup(knownTxids) {
 		return knownTxids.includes(txid);
 	};
 }
-async function mergeAllocatedChangeBeefs(storage, vargs, allocatedChange, beef, parent) {
+function missingAllocatedChangeTxids(allocatedChange, beef, knownTxids) {
+	const hasKnownTxid = makeKnownTxidLookup(knownTxids);
+	return Array.from(new Set(allocatedChange.map((output) => 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: void 0,
+		knownTxids,
+		ignoreStorage: false,
+		ignoreServices: true,
+		ignoreNewProven: false,
+		minProofLevel: void 0
+	};
+	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: void 0,
 		knownTxids: vargs.options.knownTxids,
@@ -10363,37 +10941,37 @@ async function mergeAllocatedChangeBeefs(storage, vargs, allocatedChange, beef,
 	};
 	if (vargs.options.returnTXIDOnly) return void 0;
 	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;
+	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;
+	});
+	const usePrefetch = sameTxids(prefetched.txids, requiredBeforePrefetch);
+	if (usePrefetch && prefetched.error != null) throw prefetched.error;
+	if (usePrefetch && prefetched.beef != null) beef.mergeBeef(prefetched.beef);
+	const missing = missingAllocatedChangeTxids(allocatedChange, beef, knownTxids);
+	let fetched;
 	await traceStorageStep(storage, "wallet.storage.create_action.beef_fetch", parent, {
 		"beef.allocated_change_count": allocatedChange.length,
 		"beef.distinct_source_count": new Set(allocatedChange.map((output) => output.txid)).size,
 		"beef.known_txid_count": knownTxids.length,
 		"beef.missing_source_count": missing.length,
-		"beef.fetch_concurrency": concurrency
+		"beef.fetch_concurrency": 1,
+		"beef.prefetch_reused": usePrefetch
 	}, async (span) => {
-		await Promise.all(Array.from({ length: concurrency }, async () => {
-			while (cursor < missing.length) {
-				const index = cursor++;
-				fetched[index] = await storage.getBeefForTransaction(missing[index], {
-					...options,
-					mergeToBeef: void 0
-				});
-			}
-		}));
+		if (missing.length > 0) fetched = await storage.getBeefForTransactions(missing, {
+			...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)
+			"beef.fetched_tx_count": fetched?.txs.length ?? 0,
+			"beef.fetched_bump_count": fetched?.bumps.length ?? 0,
+			"beef.storage_batch_count": missing.length === 0 ? 0 : 1
 		} });
 	});
-	await traceStorageStep(storage, "wallet.storage.create_action.beef_merge", parent, { "beef.fragment_count": fetched.length }, async (span) => {
-		for (const fetchedBeef of fetched) {
-			if (fetchedBeef == null) continue;
-			beef.mergeBeef(fetchedBeef);
-		}
+	await traceStorageStep(storage, "wallet.storage.create_action.beef_merge", parent, { "beef.fragment_count": (usePrefetch && prefetched.beef != null ? 1 : 0) + (fetched == null ? 0 : 1) }, async (span) => {
+		if (fetched != null) beef.mergeBeef(fetched);
 		span?.end({ attributes: {
 			"beef.merged_tx_count": beef.txs.length,
 			"beef.merged_bump_count": beef.bumps.length
@@ -11191,9 +11769,7 @@ function genesisHeader(chain) {
 			height: 0,
 			hash: "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
 		};
-		case "test":
-		case "ttn":
-		case "tstn": return {
+		case "test": return {
 			version: 1,
 			previousHash: "0000000000000000000000000000000000000000000000000000000000000000",
 			merkleRoot: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
@@ -11203,6 +11779,36 @@ function genesisHeader(chain) {
 			height: 0,
 			hash: "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"
 		};
+		case "stn": return {
+			version: 1,
+			previousHash: "0000000000000000000000000000000000000000000000000000000000000000",
+			merkleRoot: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
+			time: 1296688602,
+			bits: 486604799,
+			nonce: 173779992,
+			height: 0,
+			hash: "6b38bdbcd73a19f7889d23e1fa6166a9de71affceca60ca3bb1b28af8135c594"
+		};
+		case "ttn": return {
+			version: 1,
+			previousHash: "0000000000000000000000000000000000000000000000000000000000000000",
+			merkleRoot: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
+			time: 1755606836,
+			bits: 486604799,
+			nonce: 1092578460,
+			height: 0,
+			hash: "000000000499eabba0a88f5b3747231c74b9191c1a4a04b2c2ea817976b7776d"
+		};
+		case "tstn": return {
+			version: 1,
+			previousHash: "0000000000000000000000000000000000000000000000000000000000000000",
+			merkleRoot: "64452e5b25c65e492ad6a4f5ce9f427ca986626c28315d88de920d66e28cc98f",
+			time: 1782864e3,
+			bits: 486604799,
+			nonce: 1780488216,
+			height: 0,
+			hash: "000000005d221c0e023cb56b5682cf094f32cd959958b40bc931e5797cae706c"
+		};
 		case "mock": throw new Error("genesisHeader does not support 'mock' chain. Mock chain generates its own genesis block.");
 	}
 }
@@ -13675,10 +14281,28 @@ var StorageProvider = class StorageProvider extends StorageReaderWriter {
 		}
 		return updated;
 	}
+	/**
+	* Insert outputs that do not need their generated ids returned to the
+	* caller. Engines with a multi-row insert override this common-path helper;
+	* the fallback preserves existing storage implementations unchanged.
+	*/
+	async insertOutputs(outputs, trx) {
+		for (const output of outputs) await this.insertOutput(output, trx);
+	}
 	/** Return unreserved wallet-managed outputs eligible for automatic funding. */
 	async findAvailableManagedChangeInputs(userId, basketId, excludeSending, trx) {
 		return await availableManagedChange(this, userId, basketId, excludeSending, trx);
 	}
+	/** Read only the fields needed by the in-memory funding planner. */
+	async findAvailableManagedChangeInputCandidates(userId, basketId, excludeSending, trx) {
+		return (await this.findAvailableManagedChangeInputs(userId, basketId, excludeSending, trx)).map(({ outputId, transactionId, satoshis, txid, vout }) => ({
+			outputId,
+			transactionId,
+			satoshis,
+			txid,
+			vout
+		}));
+	}
 	/** 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();
@@ -13688,6 +14312,36 @@ var StorageProvider = class StorageProvider extends StorageReaderWriter {
 		}
 		return statuses;
 	}
+	/**
+	* Lock and return the selected funding rows whose source transaction and
+	* action-batch reservation state still permit allocation.
+	*/
+	async findFundingOutputsForUpdate(userId, outputIds, statuses, trx) {
+		const rows = await this.findOutputsByIds(outputIds, trx);
+		const reserved = new Set(await this.findReservedActionBatchOutputIds(outputIds, trx));
+		const transactionIds = [...new Set(Object.values(rows).map((output) => output.transactionId))];
+		const transactionStatuses = await this.findTransactionStatusesByIds(userId, transactionIds, trx);
+		const eligible = {};
+		for (const output of Object.values(rows)) if (output.userId === userId && !reserved.has(output.outputId) && statuses.includes(transactionStatuses.get(output.transactionId))) eligible[output.outputId] = output;
+		return eligible;
+	}
+	/**
+	* Resolve several transaction proofs in one storage operation when the
+	* backend supports it. The default preserves compatibility for custom
+	* providers; SQL and IndexedDB providers override this hot path.
+	*/
+	async getProvenOrRawTxs(txids, trx) {
+		const results = /* @__PURE__ */ new Map();
+		const unique = [...new Set(txids)];
+		let cursor = 0;
+		await Promise.all(Array.from({ length: Math.min(8, unique.length) }, async () => {
+			while (cursor < unique.length) {
+				const txid = unique[cursor++];
+				results.set(txid, await this.getProvenOrRawTx(txid, trx));
+			}
+		}));
+		return results;
+	}
 	async insertActionBatch(_batch, _trx) {
 		throw new WERR_NOT_IMPLEMENTED();
 	}
@@ -13739,6 +14393,10 @@ var StorageProvider = class StorageProvider extends StorageReaderWriter {
 	supportsActionBatchPersistence() {
 		return false;
 	}
+	/** Custom providers may require physical expiry cleanup before reservations are queried. */
+	requiresActionBatchCleanupBeforeCreateAction() {
+		return true;
+	}
 	async beginActionBatch(auth, args) {
 		if (!this.supportsActionBatchPersistence()) throw new WERR_NOT_IMPLEMENTED("actionBatch capability is not available");
 		return await beginActionBatch(this, auth, args);
@@ -14127,7 +14785,7 @@ var StorageProvider = class StorageProvider extends StorageReaderWriter {
 	}
 	async createAction(auth, args) {
 		if (auth.userId == null) throw new WERR_UNAUTHORIZED();
-		if (this.supportsActionBatchPersistence()) await cleanupExpiredActionBatches(this);
+		if (this.supportsActionBatchPersistence() && this.requiresActionBatchCleanupBeforeCreateAction()) await cleanupExpiredActionBatches(this);
 		return await createAction(this, auth, args);
 	}
 	async processAction(auth, args) {
@@ -14217,6 +14875,9 @@ var StorageProvider = class StorageProvider extends StorageReaderWriter {
 	async getBeefForTransaction(txid, options) {
 		return await getBeefForTransaction(this, txid, options);
 	}
+	async getBeefForTransactions(txids, options) {
+		return await getBeefForTransactions(this, txids, options);
+	}
 	async findMonitorEventById(id, trx) {
 		return verifyOneOrNone(await this.findMonitorEvents({
 			partial: { id },
@@ -15175,6 +15836,9 @@ var StorageIdb = class extends StorageProvider {
 	supportsActionBatchPersistence() {
 		return true;
 	}
+	requiresActionBatchCleanupBeforeCreateAction() {
+		return false;
+	}
 	/**
 	* This method must be called at least once before any other method accesses the database,
 	* and each time the schema may have updated.
@@ -15354,6 +16018,50 @@ var StorageIdb = class extends StorageProvider {
 		}
 		return r;
 	}
+	async getProvenOrRawTxs(txids, trx) {
+		const results = /* @__PURE__ */ new Map();
+		const unique = [...new Set(txids)];
+		if (unique.length === 0) return results;
+		const dbTrx = this.toDbTrx(["proven_txs", "proven_tx_reqs"], "readonly", trx);
+		const provenIndex = dbTrx.objectStore("proven_txs").index("txid");
+		const requestIndex = dbTrx.objectStore("proven_tx_reqs").index("txid");
+		const usableStatuses = /* @__PURE__ */ new Set([
+			"unsent",
+			"unmined",
+			"unconfirmed",
+			"sending",
+			"nosend",
+			"completed"
+		]);
+		await Promise.all(unique.map(async (txid) => {
+			const proven = await provenIndex.get(txid);
+			if (proven != null) {
+				results.set(txid, {
+					proven: this.validateEntity(proven),
+					rawTx: void 0,
+					inputBEEF: void 0
+				});
+				return;
+			}
+			const request = await requestIndex.get(txid);
+			if (request != null && usableStatuses.has(request.status)) {
+				const validated = this.validateEntity(request);
+				results.set(txid, {
+					proven: void 0,
+					rawTx: Array.from(validated.rawTx),
+					inputBEEF: validated.inputBEEF == null ? void 0 : Array.from(validated.inputBEEF)
+				});
+				return;
+			}
+			results.set(txid, {
+				proven: void 0,
+				rawTx: void 0,
+				inputBEEF: void 0
+			});
+		}));
+		if (trx == null) await dbTrx.done;
+		return results;
+	}
 	async getRawTxOfKnownValidTransaction(txid, offset, length, trx) {
 		if (txid == null || txid === "") return void 0;
 		if (!this.isAvailable()) await this.makeAvailable();
@@ -15615,6 +16323,7 @@ var StorageIdb = class extends StorageProvider {
 		else cursor = await store.openCursor(null, direction);
 		await scanCursor(cursor, args.since, args.paged?.offset ?? 0, args.paged?.limit, async (r) => {
 			if (!matchesProvenTxPartial(r, args.partial)) return false;
+			if (args.txids != null && args.txids.length > 0 && !args.txids.includes(r.txid)) return false;
 			if (userId !== void 0) {
 				if (await this.countTransactions({
 					partial: {
@@ -16059,11 +16768,18 @@ var StorageIdb = class extends StorageProvider {
 		return rows.map((r) => r.outputId);
 	}
 	async findReservedActionBatchOutputIds(outputIds, trx) {
-		const tx = this.toDbTrx(["action_batch_outputs"], "readonly", trx);
+		const tx = this.toDbTrx(["action_batch_outputs", "action_batches"], "readonly", trx);
 		const store = tx.objectStore("action_batch_outputs");
+		const batchStore = tx.objectStore("action_batches");
 		if (store.get == null) throw new WERR_INTERNAL("IndexedDB action_batch_outputs store does not support get");
 		const reserved = [];
-		for (const outputId of outputIds) if (await store.get(outputId) != null) reserved.push(outputId);
+		const now = Date.now();
+		for (const outputId of outputIds) {
+			const reservation = await store.get(outputId);
+			if (reservation == null) continue;
+			const batch = await batchStore.get(reservation.actionBatchId);
+			if (batch != null && (batch.status === "active" || batch.status === "prepared") && batch.expiresAt.getTime() > now && batch.hardExpiresAt.getTime() > now) reserved.push(outputId);
+		}
 		if (trx == null) await tx.done;
 		return reserved;
 	}
@@ -18620,10 +19336,11 @@ var Chaintracks = class {
 	startupError = null;
 	subscriberCallbacksEnabled = false;
 	stopMainThread = true;
-	lastPresentHeight = 0;
+	lastPresentHeight = -1;
 	lastPresentHeightMsecs = 0;
 	lastPresentHeightMaxAge = 60 * 1e3;
 	lock = new SingleWriterMultiReaderLock();
+	sourceStatus = /* @__PURE__ */ new Map();
 	constructor(options) {
 		this.options = options;
 		if (options.storage == null) throw new Error("storage is required.");
@@ -18634,6 +19351,22 @@ var Chaintracks = class {
 		this.storage = options.storage;
 		this.bulkIngestors = options.bulkIngestors;
 		this.liveIngestors = options.liveIngestors;
+		for (const [index, source] of this.bulkIngestors.entries()) {
+			const name = this.sourceName("bulk", index, source);
+			this.sourceStatus.set(name, {
+				name,
+				role: "bulk",
+				state: "unknown"
+			});
+		}
+		for (const [index, source] of this.liveIngestors.entries()) {
+			const name = this.sourceName("live", index, source);
+			this.sourceStatus.set(name, {
+				name,
+				role: "live",
+				state: "unknown"
+			});
+		}
 		this.addLiveRecursionLimit = options.addLiveRecursionLimit;
 		if (options.logging != null) this.log = options.logging;
 		this.storage.log = this.log;
@@ -18648,19 +19381,36 @@ var Chaintracks = class {
 	*/
 	async getPresentHeight() {
 		const now = Date.now();
-		if (this.lastPresentHeight && now - this.lastPresentHeightMsecs < this.lastPresentHeightMaxAge) return this.lastPresentHeight;
-		const presentHeights = [];
-		for (const bulk of this.bulkIngestors) try {
-			const presentHeight = await bulk.getPresentHeight();
-			if (presentHeight) presentHeights.push(presentHeight);
-		} catch (uerr) {
-			console.error(uerr);
-		}
-		const presentHeight = presentHeights.length > 0 ? Math.max(...presentHeights) : void 0;
-		if (!presentHeight) throw new Error("At least one bulk ingestor must implement getPresentHeight.");
-		this.lastPresentHeight = presentHeight;
-		this.lastPresentHeightMsecs = now;
-		return presentHeight;
+		if (this.lastPresentHeight >= 0 && now - this.lastPresentHeightMsecs < this.lastPresentHeightMaxAge) return this.lastPresentHeight;
+		for (const [index, bulk] of this.bulkIngestors.entries()) {
+			const source = this.sourceName("bulk", index, bulk);
+			try {
+				const presentHeight = await bulk.getPresentHeight();
+				if (presentHeight != null && Number.isInteger(presentHeight) && presentHeight >= 0) {
+					this.markSourceSuccess(source, "bulk");
+					this.lastPresentHeight = presentHeight;
+					this.lastPresentHeightMsecs = now;
+					return presentHeight;
+				}
+			} catch (uerr) {
+				const error = WalletError.fromUnknown(uerr);
+				this.markSourceFailure(source, "bulk", error);
+				this.log(`Present-height source ${source} failed: ${error.message}`);
+			}
+		}
+		if (this.lastPresentHeight >= 0) return this.lastPresentHeight;
+		try {
+			const ranges = await this.storage.getAvailableHeightRanges();
+			const localHeight = Math.max(ranges.bulk.maxHeight, ranges.live.maxHeight);
+			if (localHeight >= 0) {
+				this.lastPresentHeight = localHeight;
+				this.lastPresentHeightMsecs = now;
+				return localHeight;
+			}
+		} catch (error) {
+			this.log(`Unable to read the locally validated ChainTracks height: ${WalletError.fromUnknown(error).message}`);
+		}
+		throw new Error("No present-height source or locally validated headers are available.");
 	}
 	async currentHeight() {
 		return await this.getPresentHeight();
@@ -18711,7 +19461,7 @@ var Chaintracks = class {
 			for (const bulkIn of this.bulkIngestors) await bulkIn.setStorage(this.storage, this.log);
 			for (const liveIn of this.liveIngestors) await liveIn.setStorage(this.storage, this.log);
 			this.stopMainThread = false;
-			for (const liveIngestor of this.liveIngestors) this.promises.push(this.runLiveIngestor(liveIngestor));
+			for (const [index, liveIngestor] of this.liveIngestors.entries()) this.promises.push(this.runLiveIngestor(liveIngestor, index));
 			this.promises.push(this.mainThreadShiftLiveHeaders());
 			while (!this.available && this.startupError == null) await wait(100);
 			if (this.startupError != null) throw this.startupError;
@@ -18738,10 +19488,12 @@ var Chaintracks = class {
 	async listening() {
 		return await this.makeAvailable();
 	}
-	async runLiveIngestor(liveIngestor) {
+	async runLiveIngestor(liveIngestor, index) {
 		let restartCount = 0;
 		const name = liveIngestor.constructor.name;
+		const source = this.sourceName("live", index, liveIngestor);
 		while (!this.stopMainThread) try {
+			this.markSourceSuccess(source, "live");
 			await liveIngestor.startListening(this.liveHeaders);
 			if (this.stopMainThread) return;
 			restartCount++;
@@ -18752,6 +19504,7 @@ var Chaintracks = class {
 			if (this.stopMainThread) return;
 			restartCount++;
 			const e = WalletError.fromUnknown(error_);
+			this.markSourceFailure(source, "live", e);
 			const waitMsecs = this.liveIngestorRestartWaitMsecs(restartCount);
 			this.log(`Live ingestor ${name} failed restart=${restartCount} retryMsecs=${waitMsecs}: ${e.stack ?? e.message}`);
 			await wait(waitMsecs);
@@ -18799,7 +19552,8 @@ var Chaintracks = class {
 			storage: this.storage.constructor.name,
 			bulkIngestors: this.bulkIngestors.map((bulkIngestor) => bulkIngestor.constructor.name),
 			liveIngestors: this.liveIngestors.map((liveIngestor) => liveIngestor.constructor.name),
-			packages: []
+			packages: [],
+			sources: Array.from(this.sourceStatus.values()).map((status) => ({ ...status }))
 		};
 	}
 	async getHeaders(height, count) {
@@ -18882,26 +19636,30 @@ var Chaintracks = class {
 		let madeProgress = false;
 		let hadSuccess = false;
 		let done = false;
-		for (const bulk of this.bulkIngestors) try {
-			const beforeBulkMax = before.bulk.maxHeight;
-			const beforeLiveRange = HeightRange.from(newLiveHeaders);
-			const r = await bulk.synchronize(presentHeight, before, newLiveHeaders);
-			hadSuccess = true;
-			newLiveHeaders = r.liveHeaders;
-			after = await this.storage.getAvailableHeightRanges();
-			const added = after.bulk.above(before.bulk);
-			const afterLiveRange = HeightRange.from(newLiveHeaders);
-			if (after.bulk.maxHeight > beforeBulkMax || afterLiveRange.maxHeight > beforeLiveRange.maxHeight) madeProgress = true;
-			before = after;
-			this.log(`Bulk Ingestor: ${added.length} added with ${newLiveHeaders.length} live headers from ${bulk.constructor.name}`);
-			if (r.done) {
-				done = true;
-				break;
+		for (const [index, bulk] of this.bulkIngestors.entries()) {
+			const source = this.sourceName("bulk", index, bulk);
+			try {
+				const beforeBulkMax = before.bulk.maxHeight;
+				const beforeLiveRange = HeightRange.from(newLiveHeaders);
+				const r = await bulk.synchronize(presentHeight, before, newLiveHeaders);
+				hadSuccess = true;
+				this.markSourceSuccess(source, "bulk");
+				newLiveHeaders = r.liveHeaders;
+				after = await this.storage.getAvailableHeightRanges();
+				const added = after.bulk.above(before.bulk);
+				const afterLiveRange = HeightRange.from(newLiveHeaders);
+				if (after.bulk.maxHeight > beforeBulkMax || afterLiveRange.maxHeight > beforeLiveRange.maxHeight) madeProgress = true;
+				before = after;
+				this.log(`Bulk Ingestor: ${added.length} added with ${newLiveHeaders.length} live headers from ${bulk.constructor.name}`);
+				if (r.done) {
+					done = true;
+					break;
+				}
+			} catch (error_) {
+				const e = bulkSyncError = WalletError.fromUnknown(error_);
+				this.markSourceFailure(source, "bulk", e);
+				this.log(`bulk sync error: ${e.message}`);
 			}
-		} catch (error_) {
-			const e = bulkSyncError = WalletError.fromUnknown(error_);
-			this.log(`bulk sync error: ${e.message}`);
-			if (!this.available) break;
 		}
 		if (!this.available && bulkSyncError != null && !hadSuccess) this.startupError = bulkSyncError;
 		return {
@@ -18911,10 +19669,41 @@ var Chaintracks = class {
 			madeProgress
 		};
 	}
+	sourceName(role, index, source) {
+		return `${role}[${index}]:${source.constructor.name}`;
+	}
+	markSourceSuccess(name, role) {
+		this.sourceStatus.set(name, {
+			...this.sourceStatus.get(name),
+			name,
+			role,
+			state: "healthy",
+			lastSuccess: (/* @__PURE__ */ new Date()).toISOString(),
+			error: void 0
+		});
+	}
+	markSourceFailure(name, role, error) {
+		this.sourceStatus.set(name, {
+			...this.sourceStatus.get(name),
+			name,
+			role,
+			state: "degraded",
+			lastFailure: (/* @__PURE__ */ new Date()).toISOString(),
+			error: error.message
+		});
+	}
 	async getMissingBlockHeader(hash) {
-		for (const live of this.liveIngestors) {
-			const header = await live.getHeaderByHash(hash);
-			if (header != null) return header;
+		for (const [index, live] of this.liveIngestors.entries()) {
+			const source = this.sourceName("live", index, live);
+			try {
+				const header = await live.getHeaderByHash(hash);
+				this.markSourceSuccess(source, "live");
+				if (header != null) return header;
+			} catch (error) {
+				const resolved = WalletError.fromUnknown(error);
+				this.markSourceFailure(source, "live", resolved);
+				this.log(`Header lookup source ${source} failed: ${resolved.message}`);
+			}
 		}
 	}
 	invalidInsertHeaderResult(ihr) {
@@ -19247,6 +20036,9 @@ var GoChaintracksServiceClient = class {
 	chain;
 	baseUrl;
 	fetcher;
+	requestTimeoutMsecs;
+	reconnectWaitMsecs;
+	reconnectWaitMaxMsecs;
 	subscriptions = /* @__PURE__ */ new Map();
 	nextSubscriptionId = 1;
 	constructor(chain, serviceUrl, options = {}) {
@@ -19260,6 +20052,15 @@ var GoChaintracksServiceClient = class {
 		}
 		this.baseUrl = `${base}${prefix}`;
 		this.fetcher = options.fetch ?? fetch;
+		this.requestTimeoutMsecs = options.requestTimeoutMsecs ?? 3e4;
+		this.reconnectWaitMsecs = options.reconnectWaitMsecs ?? 1e3;
+		this.reconnectWaitMaxMsecs = options.reconnectWaitMaxMsecs ?? 6e4;
+		for (const [name, value] of [
+			["requestTimeoutMsecs", this.requestTimeoutMsecs],
+			["reconnectWaitMsecs", this.reconnectWaitMsecs],
+			["reconnectWaitMaxMsecs", this.reconnectWaitMaxMsecs]
+		]) if (!Number.isSafeInteger(value) || value < 1) throw new Error(`${name} must be a positive integer.`);
+		if (this.reconnectWaitMaxMsecs < this.reconnectWaitMsecs) throw new Error("reconnectWaitMaxMsecs must be greater than or equal to reconnectWaitMsecs.");
 	}
 	async currentHeight() {
 		return await this.getPresentHeight();
@@ -19269,12 +20070,8 @@ var GoChaintracksServiceClient = class {
 		return h != null && root === asString(h.merkleRoot);
 	}
 	async getChain() {
-		try {
-			const r = await this.getJson("/network");
-			return this.normalizeChain(r.network);
-		} catch {
-			return this.chain;
-		}
+		const r = await this.getJson("/network");
+		return this.normalizeChain(typeof r === "string" ? r : r.network);
 	}
 	async getInfo() {
 		const tip = await this.findChainTipHeader();
@@ -19289,11 +20086,11 @@ var GoChaintracksServiceClient = class {
 		};
 	}
 	async getPresentHeight() {
-		return (await this.getJson("/height")).height;
+		const result = await this.getJson("/height");
+		return typeof result === "number" ? result : result.height;
 	}
 	async getHeaders(height, count) {
-		const bytes = await this.getBinary(`/headers.bin?height=${height}&count=${count}`);
-		return Buffer.from(bytes).toString("hex");
+		return asString(await this.getBinary(`/headers.bin?height=${height}&count=${count}`));
 	}
 	async findChainTipHeader() {
 		return await this.getJson("/tip");
@@ -19349,7 +20146,7 @@ var GoChaintracksServiceClient = class {
 	async subscribe(type, path, onPayload) {
 		const id = `${type}-${this.nextSubscriptionId++}`;
 		const abort = new AbortController();
-		const done = this.runSse(path, abort.signal, onPayload);
+		const done = this.runSseWithReconnect(path, abort.signal, onPayload);
 		this.subscriptions.set(id, {
 			id,
 			type,
@@ -19361,30 +20158,75 @@ var GoChaintracksServiceClient = class {
 		});
 		return id;
 	}
-	async runSse(path, signal, onPayload) {
-		const response = await this.fetcher(this.url(path), {
-			headers: { Accept: "text/event-stream" },
-			signal
+	async runSseWithReconnect(path, signal, onPayload) {
+		let failures = 0;
+		while (!signal.aborted) {
+			try {
+				failures = await this.runSse(path, signal, onPayload) ? 0 : failures + 1;
+			} catch {
+				if (signal.aborted) return;
+				failures++;
+			}
+			const multiplier = Math.min(2 ** Math.max(0, failures - 1), 64);
+			const delay = Math.min(this.reconnectWaitMsecs * multiplier, this.reconnectWaitMaxMsecs);
+			await this.waitForReconnect(delay, signal);
+		}
+	}
+	async waitForReconnect(msecs, signal) {
+		if (signal.aborted || msecs <= 0) return;
+		await new Promise((resolve) => {
+			let timeout;
+			const onAbort = () => done();
+			const done = () => {
+				clearTimeout(timeout);
+				signal.removeEventListener("abort", onAbort);
+				resolve();
+			};
+			timeout = setTimeout(done, msecs);
+			signal.addEventListener("abort", onAbort, { once: true });
 		});
-		if (!response.ok) throw new Error(`GET ${this.url(path)} failed ${response.status} ${response.statusText}`);
-		if (response.body == null) throw new Error(`GET ${this.url(path)} returned no response body`);
-		const reader = response.body.getReader();
-		const decoder = new TextDecoder();
-		let buffer = "";
+	}
+	async runSse(path, signal, onPayload) {
+		const controller = new AbortController();
+		const onAbort = () => controller.abort();
+		signal.addEventListener("abort", onAbort, { once: true });
+		const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMsecs);
+		let receivedEvent = false;
+		const observePayload = (payload) => {
+			receivedEvent = true;
+			onPayload(payload);
+		};
 		try {
-			for (;;) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				buffer += decoder.decode(value, { stream: true });
-				buffer = this.processSseBuffer(buffer, onPayload);
+			const response = await this.fetcher(this.url(path), {
+				headers: { Accept: "text/event-stream" },
+				signal: controller.signal
+			});
+			clearTimeout(timeout);
+			if (!response.ok) throw new Error(`GET ${this.url(path)} failed ${response.status} ${response.statusText}`);
+			if (response.body == null) throw new Error(`GET ${this.url(path)} returned no response body`);
+			const reader = response.body.getReader();
+			const decoder = new TextDecoder();
+			let buffer = "";
+			try {
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					buffer = this.processSseBuffer(buffer, observePayload);
+				}
+				buffer += decoder.decode();
+				this.processSseBuffer(`${buffer}\n\n`, observePayload);
+			} finally {
+				reader.releaseLock();
 			}
-			buffer += decoder.decode();
-			this.processSseBuffer(`${buffer}\n\n`, onPayload);
 		} finally {
-			reader.releaseLock();
+			clearTimeout(timeout);
+			signal.removeEventListener("abort", onAbort);
 		}
+		return receivedEvent;
 	}
 	processSseBuffer(buffer, onPayload) {
+		buffer = buffer.replaceAll("\r\n", "\n");
 		for (;;) {
 			const boundary = buffer.indexOf("\n\n");
 			if (boundary < 0) return buffer;
@@ -19403,32 +20245,51 @@ var GoChaintracksServiceClient = class {
 		return r;
 	}
 	async getJsonOrUndefined(path) {
-		const response = await this.fetcher(this.url(path), { headers: { Accept: "application/json" } });
+		const response = await this.fetchWithTimeout(this.url(path), { headers: { Accept: "application/json" } });
 		if (response.status === 404) return void 0;
 		if (!response.ok) throw new Error(`GET ${this.url(path)} failed ${response.status} ${response.statusText}`);
-		return await response.json();
+		const value = await response.json();
+		if (value != null && typeof value === "object" && "status" in value) {
+			const envelope = value;
+			if (envelope.status === "success") return envelope.value;
+			if (envelope.status === "error") throw new Error(envelope.description ?? `GET ${this.url(path)} failed`);
+		}
+		return value;
 	}
 	async getBinary(path) {
-		const response = await this.fetcher(this.url(path), { headers: { Accept: "application/octet-stream" } });
+		const response = await this.fetchWithTimeout(this.url(path), { headers: { Accept: "application/octet-stream" } });
 		if (!response.ok) throw new Error(`GET ${this.url(path)} failed ${response.status} ${response.statusText}`);
 		return new Uint8Array(await response.arrayBuffer());
 	}
+	async fetchWithTimeout(url, init) {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMsecs);
+		try {
+			return await this.fetcher(url, {
+				...init,
+				signal: controller.signal
+			});
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
 	url(path) {
 		return `${this.baseUrl}${path}`;
 	}
 	normalizeChain(network) {
-		switch (network) {
+		switch (network.trim().toLowerCase()) {
 			case "main":
 			case "mainnet": return "main";
 			case "test":
 			case "testnet": return "test";
+			case "stn":
+			case "scalingtestnet": return "stn";
 			case "ttn":
 			case "teratest":
 			case "teratestnet": return "ttn";
 			case "tstn":
-			case "teranodescalingtestnet":
-			case "scalingtestnet": return "tstn";
-			default: return this.chain;
+			case "teranodescalingtestnet": return "tstn";
+			default: throw new Error(`Unsupported ChainTracks upstream network '${network}'.`);
 		}
 	}
 };
@@ -20761,31 +21622,45 @@ var ServiceCollection = class ServiceCollection {
 //#endregion
 //#region ../src/services/networkConfig.ts
 /**
-* Runtime service-endpoint configuration for the `tstn` (Teranode Scaling Test Net) network.
+* Runtime service-endpoint configuration for Teranode networks that do not
+* have a public, operator-independent service endpoint.
 *
-* Unlike `main`, `test`, and `ttn`, the tstn service endpoints are not public and must not be
+* Unlike `main`, `test`, and `ttn`, the stn/tstn service endpoints are not public and must not be
 * hardcoded in this (public) source tree. They are supplied at runtime through environment
 * variables:
 *
+*   STN_ARCADE_URL        STN Arcade broadcaster / ARC endpoint base.
+*   STN_CHAINTRACKS_URL   STN ChainTracks service URL.
 *   TSTN_ARCADE_URL       Arcade broadcaster / ARC endpoint base. Also the fallback host for
 *                         ChainTracks when TSTN_CHAINTRACKS_URL is unset
 *                         (`${TSTN_ARCADE_URL}/chaintracks/v1`, mirroring the ttn layout).
 *   TSTN_CHAINTRACKS_URL  ChainTracks service URL.
 *
-* tstn runs only Arcade (broadcast + merkle proofs) and ChainTracks (headers); there is no
-* WhatsOnChain / block-explorer service for tstn, so no WhatsOnChain endpoint is configured and
+* stn/tstn run only operator-configured Arcade and ChainTracks services; there is no
+* documented WhatsOnChain service for them, so no WhatsOnChain endpoint is configured and
 * the WhatsOnChain-only lookups (raw tx, utxo status, txid status, script-hash history) are not
-* available on tstn.
+* available on stn/tstn.
 *
-* `process` is accessed defensively so importing this module remains safe in browser bundles;
-* tstn is a server-side network and these variables are only read when the selected chain is
-* tstn.
+* `process` is accessed defensively so importing this module remains safe in
+* browser bundles. Browser applications can still supply an explicit
+* ChaintracksClientApi without relying on environment variables.
 */
 function readEnv(name) {
 	const value = (typeof process !== "undefined" ? process.env : void 0)?.[name];
 	return value != null && value.trim() !== "" ? value.trim() : void 0;
 }
-const stripTrailingSlash = (url) => {
+/** Credential-free public Arcade host for supported networks. */
+function publicArcadeUrl(chain) {
+	switch (chain) {
+		case "main": return "https://arcade-v2-us-1.bsvblockchain.tech";
+		case "test": return "https://arcade-v2-testnet-us-1.bsvblockchain.tech";
+		case "ttn": return "https://arcade-v2-ttn-us-1.bsvblockchain.tech";
+		case "stn":
+		case "tstn":
+		case "mock": return;
+	}
+}
+const stripTrailingSlash$1 = (url) => {
 	let end = url.length;
 	while (end > 0 && url[end - 1] === "/") end--;
 	return url.slice(0, end);
@@ -20794,6 +21669,10 @@ const stripTrailingSlash = (url) => {
 function tstnArcadeUrl() {
 	return readEnv("TSTN_ARCADE_URL");
 }
+/** Arcade broadcaster / ARC endpoint for stn, or `undefined` when unset. */
+function stnArcadeUrl() {
+	return readEnv("STN_ARCADE_URL");
+}
 /**
 * ChainTracks service URL for tstn. Falls back to `${TSTN_ARCADE_URL}/chaintracks/v1` when
 * `TSTN_CHAINTRACKS_URL` is unset (mirrors the ttn layout). Throws when neither is configured.
@@ -20802,20 +21681,53 @@ function tstnChaintracksUrl() {
 	const explicit = readEnv("TSTN_CHAINTRACKS_URL");
 	if (explicit != null) return explicit;
 	const arcade = tstnArcadeUrl();
-	if (arcade != null) return `${stripTrailingSlash(arcade)}/chaintracks/v1`;
+	if (arcade != null) return `${stripTrailingSlash$1(arcade)}/chaintracks/v1`;
 	throw new Error("tstn chain requires a ChainTracks URL: set TSTN_CHAINTRACKS_URL (or TSTN_ARCADE_URL) in the environment.");
 }
+/**
+* ChainTracks service URL for stn. Falls back to the configured Arcade host's
+* legacy-compatible path when STN_CHAINTRACKS_URL is unset.
+*/
+function stnChaintracksUrl() {
+	const explicit = readEnv("STN_CHAINTRACKS_URL");
+	if (explicit != null) return explicit;
+	const arcade = stnArcadeUrl();
+	if (arcade != null) return `${stripTrailingSlash$1(arcade)}/chaintracks/v1`;
+	throw new Error("stn chain requires a ChainTracks URL: set STN_CHAINTRACKS_URL (or STN_ARCADE_URL) in the environment.");
+}
 //#endregion
 //#region ../src/services/createDefaultWalletServicesOptions.ts
+function stripTrailingSlash(value) {
+	let end = value.length;
+	while (end > 0 && value[end - 1] === "/") end--;
+	return value.slice(0, end);
+}
+function configuredChaintracksClient(chain, serviceUrl) {
+	let path = "";
+	try {
+		path = stripTrailingSlash(new URL(serviceUrl).pathname);
+	} catch {}
+	if (path.endsWith("/v2")) return new GoChaintracksServiceClient(chain, serviceUrl);
+	return new ChaintracksServiceClient(chain, serviceUrl);
+}
+/**
+* Returns the credential-free default ChainTracks client for a supported
+* public network, or an operator-configured client for stn/tstn.
+*/
+function createDefaultChaintracksClient(chain) {
+	switch (chain) {
+		case "main":
+		case "test":
+		case "ttn": return new GoChaintracksServiceClient(chain, arcadeDefaultUrl(chain), { apiPrefix: "/chaintracks/v2" });
+		case "stn": return configuredChaintracksClient(chain, stnChaintracksUrl());
+		case "tstn": return configuredChaintracksClient(chain, tstnChaintracksUrl());
+	}
+}
 function createDefaultWalletServicesOptions(...[chain, arcCallbackUrl, arcCallbackToken, taalArcApiKey, gorillaPoolArcApiKey, bitailsApiKey, deploymentId, chaintracks, arcadeUrl, arcadeApiKey, arcadeCallbackToken]) {
 	if (chain === "mock") throw new Error("createDefaultWalletServicesOptions does not support 'mock' chain. Use MockServices directly.");
 	deploymentId ||= `wallet-toolbox-${randomBytesHex(16)}`;
-	let chaintracksUrl;
-	if (chain === "ttn") chaintracksUrl = "https://arcade-v2-ttn-us-1.bsvblockchain.tech/chaintracks/v1";
-	else if (chain === "tstn") chaintracksUrl = tstnChaintracksUrl();
-	else chaintracksUrl = `https://${chain}net-chaintracks.babbage.systems`;
 	const chaintracksFiatExchangeRatesUrl = "https://mainnet-chaintracks.babbage.systems/getFiatExchangeRates";
-	chaintracks ||= new ChaintracksServiceClient(chain, chaintracksUrl);
+	chaintracks ||= createDefaultChaintracksClient(chain);
 	const o = {
 		chain,
 		taalApiKey: void 0,
@@ -20873,14 +21785,15 @@ function createDefaultWalletServicesOptions(...[chain, arcCallbackUrl, arcCallba
 }
 /**
 * Default Arcade (bsv-blockchain/arcade) endpoint per chain.
-* Returns undefined when no public default is known for the chain (e.g. testnet not yet deployed).
+* Returns undefined when no public default is known for the chain.
 */
 function arcadeDefaultUrl(chain) {
 	switch (chain) {
-		case "main": return "https://arcade-v2-us-1.bsvblockchain.tech";
-		case "ttn": return "https://arcade-v2-ttn-us-1.bsvblockchain.tech";
+		case "main":
+		case "test":
+		case "ttn": return publicArcadeUrl(chain);
+		case "stn": return stnArcadeUrl();
 		case "tstn": return tstnArcadeUrl();
-		case "test": return;
 		case "mock": return;
 	}
 }
@@ -20888,6 +21801,7 @@ function arcDefaultUrl(chain) {
 	switch (chain) {
 		case "main": return "https://arc.taal.com";
 		case "test": return "https://arc-test.taal.com";
+		case "stn": return stnArcadeUrl() ?? "";
 		case "ttn": return "https://arcade-v2-ttn-us-1.bsvblockchain.tech/";
 		case "tstn": return tstnArcadeUrl() ?? "";
 		case "mock": return "";
@@ -22269,7 +23183,7 @@ var Services = class Services {
 	telemetry;
 	constructor(optionsOrChain) {
 		this.chain = typeof optionsOrChain === "string" ? optionsOrChain : optionsOrChain.chain;
-		if (this.chain === "mock") throw new WERR_INVALID_PARAMETER("chain", "'main', 'test', 'ttn', or 'tstn'. Use MockServices for 'mock' chain.");
+		if (this.chain === "mock") throw new WERR_INVALID_PARAMETER("chain", "'main', 'test', 'stn', 'ttn', or 'tstn'. Use MockServices for 'mock' chain.");
 		this.options = typeof optionsOrChain === "string" ? Services.createDefaultOptions(this.chain) : optionsOrChain;
 		this.telemetry = new _bsv_sdk.Telemetry(this.options.telemetry);
 		this.whatsonchain = new WhatsOnChain(this.chain, { apiKey: this.options.whatsOnChainApiKey }, this);
@@ -22283,7 +23197,7 @@ var Services = class Services {
 		if (this.options.arcGorillaPoolUrl != null && this.options.arcGorillaPoolUrl !== "") this.arcGorillaPool = new ARC(this.options.arcGorillaPoolUrl, this.options.arcGorillaPoolConfig, "arcGorillaPool");
 		if (this.options.arcadeUrl != null && this.options.arcadeUrl !== "") this.arcade = new Arcade(this.options.arcadeUrl, this.options.arcadeConfig, "arcade");
 		const hasBitails = this.chain === "main" || this.chain === "test";
-		const hasWhatsOnChain = this.chain !== "tstn";
+		const hasWhatsOnChain = this.chain === "main" || this.chain === "test";
 		if (hasBitails) this.bitails = new Bitails(this.chain, { apiKey: this.options.bitailsApiKey });
 		return {
 			hasBitails,
@@ -22997,9 +23911,22 @@ function classifyMerklePathResponse(status, statusText, retry) {
 //#endregion
 //#region ../src/services/providers/WhatsOnChain.ts
 var WhatsOnChainNoServices = class extends SdkWhatsOnChain {
+	requestGate;
 	constructor(chain = "main", config = {}) {
 		if (chain === "mock") throw new Error("WhatsOnChain does not support 'mock' chain. Use MockServices directly.");
 		super(chain, config);
+		this.requestGate = config.requestGate;
+	}
+	async requestWithAnonymousAuthFallback(url, requestOptions) {
+		await this.requestGate?.();
+		const response = await this.httpClient.request(url, requestOptions);
+		if (response.status !== 401 && response.status !== 403 || this.apiKey.trim() === "") return response;
+		if (this.requestGate != null) await this.requestGate();
+		else await wait(350);
+		return await this.httpClient.request(url, {
+			method: "GET",
+			headers: { Accept: "application/json" }
+		});
 	}
 	/**
 	* POST
@@ -23408,7 +24335,7 @@ var WhatsOnChainNoServices = class extends SdkWhatsOnChain {
 		};
 		const url = `${this.URL}/block/${hash}/header`;
 		for (let retry = 0; retry < 2; retry++) {
-			const response = await this.httpClient.request(url, requestOptions);
+			const response = await this.requestWithAnonymousAuthFallback(url, requestOptions);
 			if (response.statusText === "Too Many Requests" && retry < 2) {
 				await wait(2e3);
 				continue;
@@ -23426,7 +24353,7 @@ var WhatsOnChainNoServices = class extends SdkWhatsOnChain {
 		};
 		const url = `${this.URL}/chain/info`;
 		for (let retry = 0; retry < 2; retry++) {
-			const response = await this.httpClient.request(url, requestOptions);
+			const response = await this.requestWithAnonymousAuthFallback(url, requestOptions);
 			if (response.statusText === "Too Many Requests" && retry < 2) {
 				await wait(2e3);
 				continue;
@@ -23612,12 +24539,16 @@ var WhatsOnChainServices = class WhatsOnChainServices {
 			timeout: 3e4,
 			userAgent: "BabbageWhatsOnChainServices",
 			enableCache: true,
-			chainInfoMsecs: 5e3
+			chainInfoMsecs: 5e3,
+			minRequestIntervalMsecs: 350
 		};
 	}
 	static chainInfo = [];
 	static chainInfoTime = [];
 	static chainInfoMsecs = [];
+	static chainInfoPromise = {};
+	static requestTail = Promise.resolve();
+	static nextRequestMsecs = 0;
 	chain;
 	woc;
 	constructor(options) {
@@ -23626,7 +24557,8 @@ var WhatsOnChainServices = class WhatsOnChainServices {
 			apiKey: this.options.apiKey,
 			timeout: this.options.timeout,
 			userAgent: this.options.userAgent,
-			enableCache: this.options.enableCache
+			enableCache: this.options.enableCache,
+			requestGate: async () => await this.waitForRateLimit()
 		};
 		this.chain = options.chain;
 		const chainInfoMsecs = WhatsOnChainServices.chainInfoMsecs;
@@ -23644,7 +24576,16 @@ var WhatsOnChainServices = class WhatsOnChainServices {
 		let update = chainInfo[this.chain] === void 0;
 		if (!update && chainInfoTime[this.chain] !== void 0) update = now.getTime() - chainInfoTime[this.chain].getTime() > chainInfoMsecs[this.chain];
 		if (update) {
-			chainInfo[this.chain] = await this.woc.getChainInfo();
+			let pending = WhatsOnChainServices.chainInfoPromise[this.chain];
+			if (pending == null) {
+				pending = this.woc.getChainInfo();
+				WhatsOnChainServices.chainInfoPromise[this.chain] = pending;
+			}
+			try {
+				chainInfo[this.chain] = await pending;
+			} finally {
+				if (WhatsOnChainServices.chainInfoPromise[this.chain] === pending) delete WhatsOnChainServices.chainInfoPromise[this.chain];
+			}
 			chainInfoTime[this.chain] = now;
 		}
 		if (!chainInfo[this.chain]) throw new Error("Unexpected failure to update chainInfo.");
@@ -23662,10 +24603,12 @@ var WhatsOnChainServices = class WhatsOnChainServices {
 	*/
 	async getHeaders(fetch) {
 		fetch ||= new ChaintracksFetch();
+		await this.waitForRateLimit();
 		return await fetch.fetchJson(`https://api.whatsonchain.com/v1/bsv/${this.chain}/block/headers`);
 	}
 	async getHeaderByteFileLinks(neededRange, fetch) {
 		fetch ||= new ChaintracksFetch();
+		await this.waitForRateLimit();
 		const files = await fetch.fetchJson(`https://api.whatsonchain.com/v1/bsv/${this.chain}/block/headers/resources`);
 		const r = [];
 		let range;
@@ -23678,6 +24621,21 @@ var WhatsOnChainServices = class WhatsOnChainServices {
 		}
 		return r;
 	}
+	async waitForRateLimit() {
+		let release;
+		const previous = WhatsOnChainServices.requestTail;
+		WhatsOnChainServices.requestTail = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		try {
+			const delay = Math.max(0, WhatsOnChainServices.nextRequestMsecs - Date.now());
+			if (delay > 0) await wait(delay);
+			WhatsOnChainServices.nextRequestMsecs = Date.now() + (this.options.minRequestIntervalMsecs ?? 350);
+		} finally {
+			release();
+		}
+	}
 };
 function wocGetHeadersHeaderToBlockHeader(h) {
 	const bits = typeof h.bits === "string" ? Number.parseInt(h.bits, 16) : h.bits;
@@ -23738,6 +24696,51 @@ var BulkIngestorWhatsOnChainCdn = class extends BulkIngestorBase {
 	}
 };
 //#endregion
+//#region ../src/services/chaintracker/chaintracks/Ingest/BulkIngestorChaintracks.ts
+/**
+* Uses a go-chaintracks/Arcade-compatible service as a validated bulk source.
+* Retrieved bytes still pass through ChainTracks' local serialization, hash,
+* continuity, and genesis checks before storage.
+*/
+var BulkIngestorChaintracks = class extends BulkIngestorBase {
+	chaintracks;
+	maxHeadersPerRequest;
+	networkChecked = false;
+	constructor(options) {
+		super(options);
+		this.chaintracks = options.chaintracks;
+		this.maxHeadersPerRequest = options.maxHeadersPerRequest ?? 1e3;
+		if (!Number.isInteger(this.maxHeadersPerRequest) || this.maxHeadersPerRequest < 1) throw new Error("maxHeadersPerRequest must be a positive integer.");
+	}
+	async getPresentHeight() {
+		await this.ensureNetwork();
+		return await this.chaintracks.getPresentHeight();
+	}
+	async fetchHeaders(_before, fetchRange, bulkRange, priorLiveHeaders) {
+		if (fetchRange.isEmpty) return priorLiveHeaders;
+		await this.ensureNetwork();
+		let liveHeaders = priorLiveHeaders;
+		let height = fetchRange.minHeight;
+		while (height <= fetchRange.maxHeight) {
+			const requested = Math.min(this.maxHeadersPerRequest, fetchRange.maxHeight - height + 1);
+			const bytes = asUint8Array(await this.chaintracks.getHeaders(height, requested));
+			if (bytes.length === 0) throw new Error(`ChainTracks upstream returned no headers at height ${height}.`);
+			if (bytes.length % 80 !== 0 || bytes.length > requested * 80) throw new Error(`ChainTracks upstream returned ${bytes.length} bytes for ${requested} headers at height ${height}.`);
+			const headers = deserializeBlockHeaders(height, bytes);
+			liveHeaders = await this.storage().addBulkHeaders(headers, bulkRange, liveHeaders);
+			height += headers.length;
+			if (headers.length < requested && height <= fetchRange.maxHeight) throw new Error(`ChainTracks upstream returned ${headers.length} of ${requested} headers at height ${height - headers.length}.`);
+		}
+		return liveHeaders;
+	}
+	async ensureNetwork() {
+		if (this.networkChecked) return;
+		const actual = await this.chaintracks.getChain();
+		if (actual !== this.chain) throw new Error(`ChainTracks upstream network '${actual}' does not match configured chain '${this.chain}'.`);
+		this.networkChecked = true;
+	}
+};
+//#endregion
 //#region ../src/services/chaintracker/chaintracks/Ingest/LiveIngestorWhatsOnChainPoll.ts
 /**
 * Reports new headers by polling periodically.
@@ -23844,9 +24847,17 @@ var LiveIngestorChaintracksSSE = class extends LiveIngestorBase {
 	}
 	async startListening(liveHeaders) {
 		this.stopped = false;
-		this.subscriptionId = await this.options.chaintracks.subscribeHeaders((header) => {
+		const actual = await this.options.chaintracks.getChain();
+		if (actual !== this.chain) throw new Error(`ChainTracks upstream network '${actual}' does not match configured chain '${this.chain}'.`);
+		if (this.stopped) return;
+		const subscriptionId = await this.options.chaintracks.subscribeHeaders((header) => {
 			if (!this.stopped) liveHeaders.push(header);
 		});
+		if (this.stopped) {
+			await this.options.chaintracks.unsubscribe(subscriptionId);
+			return;
+		}
+		this.subscriptionId = subscriptionId;
 		await new Promise((resolve) => {
 			this.resolveStopped = resolve;
 			if (this.stopped) resolve();
@@ -23859,7 +24870,9 @@ var LiveIngestorChaintracksSSE = class extends LiveIngestorBase {
 		if (subscriptionId != null) this.options.chaintracks.unsubscribe(subscriptionId).catch((e) => {
 			this.log(`LiveIngestorChaintracksSSE unsubscribe failed: ${e}`);
 		});
-		this.resolveStopped?.();
+		const resolveStopped = this.resolveStopped;
+		this.resolveStopped = void 0;
+		resolveStopped?.();
 	}
 	async shutdown() {
 		this.stopListening();
@@ -24555,6 +25568,27 @@ var ChaintracksStorageNoDb = class ChaintracksStorageNoDb extends ChaintracksSto
 		tipHeaderId: 0,
 		hashToHeaderId: /* @__PURE__ */ new Map()
 	};
+	static stnData = {
+		chain: "stn",
+		liveHeaders: /* @__PURE__ */ new Map(),
+		maxHeaderId: 0,
+		tipHeaderId: 0,
+		hashToHeaderId: /* @__PURE__ */ new Map()
+	};
+	static ttnData = {
+		chain: "ttn",
+		liveHeaders: /* @__PURE__ */ new Map(),
+		maxHeaderId: 0,
+		tipHeaderId: 0,
+		hashToHeaderId: /* @__PURE__ */ new Map()
+	};
+	static tstnData = {
+		chain: "tstn",
+		liveHeaders: /* @__PURE__ */ new Map(),
+		maxHeaderId: 0,
+		tipHeaderId: 0,
+		hashToHeaderId: /* @__PURE__ */ new Map()
+	};
 	constructor(options) {
 		super(options);
 	}
@@ -24562,10 +25596,11 @@ var ChaintracksStorageNoDb = class ChaintracksStorageNoDb extends ChaintracksSto
 	async getData() {
 		switch (this.chain) {
 			case "main": return ChaintracksStorageNoDb.mainData;
-			case "test":
-			case "ttn":
-			case "tstn": return ChaintracksStorageNoDb.testData;
-			default: throw new WERR_INVALID_PARAMETER("chain", `'main', 'test', 'ttn', or 'tstn'. '${this.chain}' is unsupported.`);
+			case "test": return ChaintracksStorageNoDb.testData;
+			case "stn": return ChaintracksStorageNoDb.stnData;
+			case "ttn": return ChaintracksStorageNoDb.ttnData;
+			case "tstn": return ChaintracksStorageNoDb.tstnData;
+			default: throw new WERR_INVALID_PARAMETER("chain", `'main', 'test', 'stn', 'ttn', or 'tstn'. '${this.chain}' is unsupported.`);
 		}
 	}
 	async deleteLiveBlockHeaders() {
@@ -25154,7 +26189,7 @@ var ChaintracksStorageIdb = class extends ChaintracksStorageBase {
 //#endregion
 //#region ../src/services/chaintracker/chaintracks/configureChaintracksIngestors.ts
 function resolveDefaultChaintracksArguments(args) {
-	const [chain, whatsonchainApiKey = "", maxPerFile = 1e5, maxRetained = 2, fetch = new ChaintracksFetch(), cdnUrl = "https://cdn.projectbabbage.com/blockheaders/", liveHeightThreshold = 2e3, reorgHeightThreshold = 400, bulkMigrationChunkSize = 500, batchInsertLimit = 400, addLiveRecursionLimit = 36] = args;
+	const [chain, whatsonchainApiKey = "", maxPerFile = 1e5, maxRetained = 2, fetch = new ChaintracksFetch(), cdnUrl = chain === "main" || chain === "test" ? "https://cdn.projectbabbage.com/blockheaders/" : "", liveHeightThreshold = 2e3, reorgHeightThreshold = 400, bulkMigrationChunkSize = 500, batchInsertLimit = 400, addLiveRecursionLimit = 36, sources = {}] = args;
 	return {
 		chain,
 		whatsonchainApiKey,
@@ -25166,11 +26201,12 @@ function resolveDefaultChaintracksArguments(args) {
 		reorgHeightThreshold,
 		bulkMigrationChunkSize,
 		batchInsertLimit,
-		addLiveRecursionLimit
+		addLiveRecursionLimit,
+		sources
 	};
 }
 function toDefaultChaintracksArguments(params) {
-	return [
+	const args = [
 		params.chain,
 		params.whatsonchainApiKey,
 		params.maxPerFile,
@@ -25183,6 +26219,8 @@ function toDefaultChaintracksArguments(params) {
 		params.batchInsertLimit,
 		params.addLiveRecursionLimit
 	];
+	if (Object.keys(params.sources).length > 0) args.push(params.sources);
+	return args;
 }
 function createDefaultBulkFileDataManager(params) {
 	return new BulkFileDataManager({
@@ -25225,7 +26263,7 @@ function createAndStartDefaultChaintracks(args, createOptions) {
 * The caller is responsible for providing the storage implementation.
 */
 function buildChaintracksOptionsWithIngestors(params, storage) {
-	const { chain, whatsonchainApiKey, maxPerFile, fetch, cdnUrl, addLiveRecursionLimit } = params;
+	const { chain, whatsonchainApiKey, maxPerFile, fetch, cdnUrl, addLiveRecursionLimit, sources } = params;
 	const co = {
 		chain,
 		storage,
@@ -25236,35 +26274,58 @@ function buildChaintracksOptionsWithIngestors(params, storage) {
 		readonly: false
 	};
 	const jsonResource = `${chain}NetBlockHeaders.json`;
-	const bulkCdnOptions = {
-		chain,
-		jsonResource,
-		fetch,
-		cdnUrl,
-		maxPerFile
-	};
-	co.bulkIngestors.push(new BulkIngestorCDNBabbage(bulkCdnOptions));
-	const wocOptions = {
-		chain,
-		apiKey: whatsonchainApiKey,
-		timeout: 3e4,
-		userAgent: "BabbageWhatsOnChainServices",
-		enableCache: true,
-		chainInfoMsecs: 5e3
-	};
-	const bulkOptions = {
-		...wocOptions,
-		jsonResource,
-		idleWait: 5e3
-	};
-	co.bulkIngestors.push(new BulkIngestorWhatsOnChainCdn(bulkOptions));
-	const liveOptions = {
-		...wocOptions,
-		idleWait: 1e5
-	};
-	co.liveIngestors.push(new LiveIngestorWhatsOnChainPoll(liveOptions));
+	if (!sources.disableCdn && cdnUrl !== "") {
+		const bulkCdnOptions = {
+			chain,
+			jsonResource,
+			fetch,
+			cdnUrl,
+			maxPerFile
+		};
+		co.bulkIngestors.push(new BulkIngestorCDNBabbage(bulkCdnOptions));
+	}
+	const chaintracksSource = sources.chaintracks ?? (sources.disableChaintracks ? void 0 : createPublicChaintracksSource(chain));
+	if (chaintracksSource != null) {
+		co.bulkIngestors.push(new BulkIngestorChaintracks({
+			chain,
+			jsonResource,
+			chaintracks: chaintracksSource,
+			maxHeadersPerRequest: sources.remoteMaxHeadersPerRequest
+		}));
+		co.liveIngestors.push(new LiveIngestorChaintracksSSE({
+			chain,
+			chaintracks: chaintracksSource
+		}));
+	}
+	if ((chain === "main" || chain === "test") && !sources.disableWhatsOnChain) {
+		const wocOptions = {
+			chain,
+			apiKey: whatsonchainApiKey,
+			timeout: 3e4,
+			userAgent: "BabbageWhatsOnChainServices",
+			enableCache: true,
+			chainInfoMsecs: 5e3
+		};
+		const bulkOptions = {
+			...wocOptions,
+			jsonResource,
+			idleWait: 5e3
+		};
+		co.bulkIngestors.push(new BulkIngestorWhatsOnChainCdn(bulkOptions));
+		const liveOptions = {
+			...wocOptions,
+			idleWait: 1e5
+		};
+		co.liveIngestors.push(new LiveIngestorWhatsOnChainPoll(liveOptions));
+	}
+	if (co.bulkIngestors.length === 0 || co.liveIngestors.length === 0) throw new Error(`ChainTracks ${chain} requires at least one bulk and live source. Configure sources.chaintracks for Teranode networks.`);
 	return co;
 }
+function createPublicChaintracksSource(chain) {
+	const serviceUrl = publicArcadeUrl(chain);
+	if (serviceUrl == null) return void 0;
+	return new GoChaintracksServiceClient(chain, serviceUrl, { apiPrefix: "/chaintracks/v2" });
+}
 //#endregion
 //#region ../src/services/chaintracker/chaintracks/createDefaultNoDbChaintracksOptions.ts
 function createDefaultNoDbChaintracksOptions(...args) {
@@ -27993,7 +29054,7 @@ function isValidProfile(value) {
 	return typeof profile.name === "string" && profile.name.length > 0 && profile.name.length <= 250 && isByteArrayOfLength(profile.id, 16) && isByteArrayOfLength(profile.primaryPad, 32) && isByteArrayOfLength(profile.privilegedPad, 32) && typeof profile.createdAt === "number" && Number.isFinite(profile.createdAt) && profile.createdAt >= 0;
 }
 /**
-* Raised when UMP absence cannot be established authoritatively.
+* Raised when a UMP lookup yields neither a verified token nor a clean empty response.
 *
 * Callers must offer retry/recovery rather than treating this error as a new
 * account. Diagnostics contain counts only and never hashes, keys, or tokens.
@@ -28091,49 +29152,119 @@ var OverlayUMPTokenInteractor = class {
 			throw new UMPTokenLookupError("lookup-unavailable", diagnostics, { cause: error });
 		}
 		const diagnostics = this.toLookupDiagnostics(resolution);
-		if (resolution.answer.outputs.length === 0) {
-			if (!(resolution.progress.isFinal && resolution.progress.hostCount > 0 && resolution.progress.completedHosts === resolution.progress.hostCount && resolution.progress.successfulHosts === resolution.progress.hostCount && resolution.progress.emptyHosts === resolution.progress.hostCount && resolution.progress.failedHosts === 0 && resolution.progress.rejectedHosts === 0 && resolution.progress.freeformHosts === 0)) {
-				this.captureLookupFailure(lookupKind, "lookup-incomplete", diagnostics, startedAt);
-				throw new UMPTokenLookupError("lookup-incomplete", diagnostics);
-			}
-			this.telemetry.capture({
-				name: "wallet-toolbox.ump.lookup.completed",
-				component: "wallet-toolbox.ump",
-				severity: "info",
-				correlationId: diagnostics.correlationId,
-				attributes: {
-					lookupKind,
-					result: "not-found",
-					durationMs: Date.now() - startedAt,
-					...this.lookupDiagnosticAttributes(diagnostics)
-				}
-			});
-			return;
-		}
 		const tokens = this.parseLookupAnswers(resolution.answer);
 		const expectedHash = question.query[lookupKind === "presentation" ? "presentationHash" : "recoveryHash"].toLowerCase();
-		if (!(tokens.length === resolution.answer.outputs.length && tokens.every((token) => _bsv_sdk.Utils.toHex(lookupKind === "presentation" ? token.presentationHash : token.recoveryHash).toLowerCase() === expectedHash)) || tokens.length === 0) {
-			this.captureLookupFailure(lookupKind, "token-malformed", diagnostics, startedAt);
-			throw new UMPTokenLookupError("token-malformed", diagnostics);
-		}
-		if (tokens.length !== 1) {
+		const matchingTokens = tokens.filter((token) => _bsv_sdk.Utils.toHex(lookupKind === "presentation" ? token.presentationHash : token.recoveryHash).toLowerCase() === expectedHash);
+		if (matchingTokens.length > 1) {
+			const newest = this.resolveNewestToken(matchingTokens, resolution.answer.outputs);
+			if (newest != null) {
+				this.captureLookupCompleted(lookupKind, "found", diagnostics, startedAt, { supersededTokens: matchingTokens.length - 1 });
+				return newest;
+			}
 			const reason = "token-ambiguous";
 			this.captureLookupFailure(lookupKind, reason, diagnostics, startedAt);
 			throw new UMPTokenLookupError(reason, diagnostics);
 		}
-		this.telemetry.capture({
-			name: "wallet-toolbox.ump.lookup.completed",
-			component: "wallet-toolbox.ump",
-			severity: "info",
-			correlationId: diagnostics.correlationId,
-			attributes: {
-				lookupKind,
-				result: "found",
-				durationMs: Date.now() - startedAt,
-				...this.lookupDiagnosticAttributes(diagnostics)
+		if (matchingTokens.length === 1) {
+			this.captureLookupCompleted(lookupKind, "found", diagnostics, startedAt);
+			return matchingTokens[0];
+		}
+		if (resolution.progress.emptyHosts > 0) {
+			this.captureLookupCompleted(lookupKind, "not-found", diagnostics, startedAt);
+			return;
+		}
+		const reason = resolution.answer.outputs.length > 0 ? "token-malformed" : "lookup-incomplete";
+		this.captureLookupFailure(lookupKind, reason, diagnostics, startedAt);
+		throw new UMPTokenLookupError(reason, diagnostics);
+	}
+	/**
+	* Picks the newest rendition among distinct verified tokens, when possible.
+	*
+	* The on-chain UMP protocol expresses token updates by consumption: the
+	* transaction creating a new rendition spends the previous rendition's
+	* outpoint (there is no rendition counter field in the current format).
+	* A candidate is therefore superseded when any other candidate's ancestry
+	* (available from its BEEF) spends the candidate's outpoint.
+	*
+	* @returns The single unsuperseded candidate, or undefined when supersession
+	* cannot be established for every stale candidate (e.g. forked tokens).
+	*/
+	resolveNewestToken(matchingTokens, outputs) {
+		const candidates = /* @__PURE__ */ new Map();
+		for (const token of matchingTokens) {
+			if (token.currentOutpoint == null) return void 0;
+			candidates.set(token.currentOutpoint, token);
+		}
+		const evidenceByCandidate = /* @__PURE__ */ new Map();
+		for (const output of outputs) try {
+			const tx = _bsv_sdk.Transaction.fromBEEF(output.beef);
+			const outpoint = `${tx.id("hex")}.${output.outputIndex}`;
+			if (!candidates.has(outpoint)) continue;
+			const evidence = evidenceByCandidate.get(outpoint) ?? {
+				txs: [],
+				spent: /* @__PURE__ */ new Set()
+			};
+			evidence.txs.push(tx);
+			this.collectSpentOutpoints(tx, evidence.spent, /* @__PURE__ */ new Set());
+			evidenceByCandidate.set(outpoint, evidence);
+		} catch {}
+		if (evidenceByCandidate.size !== candidates.size) return void 0;
+		const survivors = [...candidates.keys()].filter((outpoint) => ![...evidenceByCandidate.entries()].some(([other, { spent }]) => other !== outpoint && spent.has(outpoint)));
+		if (survivors.length === 1) return candidates.get(survivors[0]);
+		const provenContinuations = survivors.filter((outpoint) => {
+			const evidence = evidenceByCandidate.get(outpoint);
+			const token = candidates.get(outpoint);
+			return evidence != null && token != null && evidence.txs.some((tx) => this.consumesSameIdentityToken(tx, token));
+		});
+		if (provenContinuations.length !== 1) return void 0;
+		return candidates.get(provenContinuations[0]);
+	}
+	/**
+	* Whether `tx` spends an input whose source output (available in the BEEF)
+	* decodes as a UMP token sharing the candidate's presentation or recovery
+	* hash — on-chain proof that the candidate is an update of a same-identity
+	* predecessor rather than an independently minted token.
+	*/
+	consumesSameIdentityToken(tx, token) {
+		const presentationHash = _bsv_sdk.Utils.toHex(token.presentationHash);
+		const recoveryHash = _bsv_sdk.Utils.toHex(token.recoveryHash);
+		for (const input of tx.inputs) {
+			const source = input.sourceTransaction;
+			if (source == null || input.sourceOutputIndex == null) continue;
+			const sourceOutput = source.outputs[input.sourceOutputIndex];
+			if (sourceOutput == null) continue;
+			try {
+				const decoded = _bsv_sdk.PushDrop.decode(sourceOutput.lockingScript);
+				if (decoded.fields == null) continue;
+				const fields = stripVerifiedPushDropSignature(decoded.fields, decoded.lockingPublicKey);
+				if (fields.length < 11 || fields[6]?.length !== 32 || fields[7]?.length !== 32) continue;
+				if (_bsv_sdk.Utils.toHex(fields[6]) === presentationHash || _bsv_sdk.Utils.toHex(fields[7]) === recoveryHash) return true;
+			} catch {
+				continue;
 			}
-		});
-		return tokens[0];
+		}
+		return false;
+	}
+	/**
+	* Accumulates every outpoint spent by `tx` and by the ancestor transactions
+	* embedded in its BEEF, so supersession is detected even when intermediate
+	* renditions are absent from the lookup answer. Iterative so arbitrarily
+	* long update chains cannot exhaust the call stack.
+	*/
+	collectSpentOutpoints(tx, spent, visited) {
+		const pending = [tx];
+		while (pending.length > 0) {
+			const current = pending.pop();
+			const txid = current.id("hex");
+			if (visited.has(txid)) continue;
+			visited.add(txid);
+			for (const input of current.inputs) {
+				const sourceTxid = input.sourceTXID ?? input.sourceTransaction?.id("hex");
+				if (sourceTxid == null || input.sourceOutputIndex == null) continue;
+				spent.add(`${sourceTxid}.${input.sourceOutputIndex}`);
+				if (input.sourceTransaction != null) pending.push(input.sourceTransaction);
+			}
+		}
 	}
 	emptyLookupDiagnostics(correlationId) {
 		return {
@@ -28174,6 +29305,21 @@ var OverlayUMPTokenInteractor = class {
 			outputCount: diagnostics.outputCount
 		};
 	}
+	captureLookupCompleted(lookupKind, result, diagnostics, startedAt, extraAttributes = {}) {
+		this.telemetry.capture({
+			name: "wallet-toolbox.ump.lookup.completed",
+			component: "wallet-toolbox.ump",
+			severity: "info",
+			correlationId: diagnostics.correlationId,
+			attributes: {
+				lookupKind,
+				result,
+				durationMs: Date.now() - startedAt,
+				...this.lookupDiagnosticAttributes(diagnostics),
+				...extraAttributes
+			}
+		});
+	}
 	captureLookupFailure(lookupKind, reason, diagnostics, startedAt, error) {
 		this.telemetry.capture({
 			name: "wallet-toolbox.ump.lookup.indeterminate",
@@ -28414,8 +29560,7 @@ var OverlayUMPTokenInteractor = class {
 			throw new UMPTokenLookupError("lookup-unavailable", diagnostics, { cause: error });
 		}
 		if (resolution.answer.outputs.length === 0) {
-			const p = resolution.progress;
-			if (!(p.isFinal && p.hostCount > 0 && p.completedHosts === p.hostCount && p.successfulHosts === p.hostCount && p.emptyHosts === p.hostCount && p.failedHosts === 0 && p.rejectedHosts === 0 && p.freeformHosts === 0)) {
+			if (resolution.progress.emptyHosts === 0) {
 				const diagnostics = this.toLookupDiagnostics(resolution);
 				this.captureLookupFailure("outpoint", "lookup-incomplete", diagnostics, startedAt);
 				throw new UMPTokenLookupError("lookup-incomplete", diagnostics);
@@ -33776,6 +34921,7 @@ exports.BulkFilesReaderStorage = BulkFilesReaderStorage;
 exports.BulkIngestorBase = BulkIngestorBase;
 exports.BulkIngestorCDN = BulkIngestorCDN;
 exports.BulkIngestorCDNBabbage = BulkIngestorCDNBabbage;
+exports.BulkIngestorChaintracks = BulkIngestorChaintracks;
 exports.BulkIngestorWhatsOnChainCdn = BulkIngestorWhatsOnChainCdn;
 exports.BulkStorageBase = BulkStorageBase;
 exports.CWIStyleWalletManager = CWIStyleWalletManager;
@@ -33854,7 +35000,12 @@ exports.asBsvSdkTx = asBsvSdkTx;
 exports.asString = asString;
 exports.asUint8Array = asUint8Array;
 exports.brc29ProtocolID = brc29ProtocolID;
+exports.buildChaintracksOptionsWithIngestors = buildChaintracksOptionsWithIngestors;
 exports.convertProofToMerklePath = convertProofToMerklePath;
+exports.createAndStartDefaultChaintracks = createAndStartDefaultChaintracks;
+exports.createDefaultBulkFileDataManager = createDefaultBulkFileDataManager;
+exports.createDefaultChaintracksClient = createDefaultChaintracksClient;
+exports.createDefaultChaintracksStorageOptions = createDefaultChaintracksStorageOptions;
 exports.createDefaultIdbChaintracksOptions = createDefaultIdbChaintracksOptions;
 exports.createDefaultNoDbChaintracksOptions = createDefaultNoDbChaintracksOptions;
 exports.createDefaultWalletServicesOptions = createDefaultWalletServicesOptions;
@@ -33896,6 +35047,7 @@ exports.partitionActionLabels = partitionActionLabels;
 exports.randomBytes = randomBytes;
 exports.randomBytesBase64 = randomBytesBase64;
 exports.randomBytesHex = randomBytesHex;
+exports.resolveDefaultChaintracksArguments = resolveDefaultChaintracksArguments;
 Object.defineProperty(exports, "sdk", {
 	enumerable: true,
 	get: function() {
@@ -33906,9 +35058,11 @@ exports.selectBulkHeaderFiles = selectBulkHeaderFiles;
 exports.sha256Hash = sha256Hash;
 exports.stampLog = stampLog;
 exports.stampLogFormat = stampLogFormat;
+exports.startChaintracks = startChaintracks;
 exports.tableAuthSessionToPeerSession = tableAuthSessionToPeerSession;
 exports.throwDummyReviewActions = throwDummyReviewActions;
 exports.toBinaryBaseBlockHeader = toBinaryBaseBlockHeader;
+exports.toDefaultChaintracksArguments = toDefaultChaintracksArguments;
 exports.toLookupNetworkPreset = toLookupNetworkPreset;
 exports.toWalletNetwork = toWalletNetwork;
 exports.transactionColumnsWithoutRawTx = transactionColumnsWithoutRawTx;