@cogcoin/client 0.5.14 → 1.0.0

package/dist/wallet/tx/common.js

@@ -1,29 +1,194 @@
-import { randomBytes } from "node:crypto";
-import { saveUnlockSession } from "../state/session.js";
 import { saveWalletState } from "../state/storage.js";
 import { createWalletSecretReference, } from "../state/provider.js";
+import { MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS, withUnlockedManagedCoreWallet, } from "../managed-core-wallet.js";
 import { reconcilePersistentPolicyLocks as reconcileWalletCoinControlLocks } from "../coin-control.js";
 import { requestMiningGenerationPreemption } from "../mining/coordination.js";
 export const DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB = 10;
+export const NEXT_BLOCK_FEE_CONFIRM_TARGET = 1;
+export function isLocalWalletScript(state, scriptPubKeyHex) {
+    if (typeof scriptPubKeyHex !== "string" || scriptPubKeyHex.length === 0) {
+        return false;
+    }
+    return scriptPubKeyHex === state.funding.scriptPubKeyHex
+        || (state.localScriptPubKeyHexes ?? []).includes(scriptPubKeyHex);
+}
+export function createFundingMutationSender(state) {
+    return {
+        localIndex: 0,
+        scriptPubKeyHex: state.funding.scriptPubKeyHex,
+        address: state.funding.address,
+    };
+}
 function btcNumberToSats(value) {
     return BigInt(Math.round(value * 100_000_000));
 }
+function normalizeSatVb(value) {
+    return Number.parseFloat(value.toFixed(8));
+}
+function satVbFromBtcPerKvB(value) {
+    return normalizeSatVb((value * 100_000_000) / 1_000);
+}
 function valueToSats(value) {
     return typeof value === "string"
         ? BigInt(Math.round(Number(value) * 100_000_000))
         : btcNumberToSats(value);
 }
-function createUnlockSessionState(state, unlockUntilUnixMs, nowUnixMs) {
+function feeRateFromMempoolEntry(entry) {
+    if (!Number.isFinite(entry.vsize) || entry.vsize <= 0) {
+        return null;
+    }
+    const feeSats = Number(btcNumberToSats(entry.fees.base));
+    if (!Number.isFinite(feeSats) || feeSats <= 0) {
+        return null;
+    }
+    return normalizeSatVb(feeSats / entry.vsize);
+}
+export function formatSatVb(value) {
+    return normalizeSatVb(value).toString();
+}
+export function createWalletMutationFeeMetadata(selection) {
+    return {
+        selectedFeeRateSatVb: selection.feeRateSatVb,
+        feeSelectionSource: selection.source,
+    };
+}
+export async function resolveWalletMutationFeeSelection(options) {
+    if (typeof options.feeRateSatVb === "number") {
+        return {
+            feeRateSatVb: normalizeSatVb(options.feeRateSatVb),
+            source: "custom-satvb",
+        };
+    }
+    if (options.rpc.estimateSmartFee !== undefined) {
+        try {
+            const estimate = await options.rpc.estimateSmartFee(NEXT_BLOCK_FEE_CONFIRM_TARGET, "conservative");
+            const estimatedSatVb = typeof estimate.feerate === "number"
+                ? satVbFromBtcPerKvB(estimate.feerate)
+                : null;
+            if (estimatedSatVb !== null && Number.isFinite(estimatedSatVb) && estimatedSatVb > 0) {
+                return {
+                    feeRateSatVb: normalizeSatVb(estimatedSatVb + 1),
+                    source: "estimated-next-block-plus-one",
+                };
+            }
+        }
+        catch {
+            // Fall through to the compatibility default.
+        }
+    }
+    return {
+        feeRateSatVb: DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB,
+        source: "fallback-default",
+    };
+}
+export function createWalletMutationFeeSummary(selection, feeSats) {
     return {
-        schemaVersion: 1,
-        walletRootId: state.walletRootId,
-        sessionId: randomBytes(16).toString("hex"),
-        createdAtUnixMs: nowUnixMs,
-        unlockUntilUnixMs,
-        sourceStateRevision: state.stateRevision,
-        wrappedSessionKeyMaterial: createWalletSecretReference(state.walletRootId).keyId,
+        feeRateSatVb: selection.feeRateSatVb,
+        feeSats,
+        source: selection.source,
     };
 }
+export function createBuiltWalletMutationFeeSummary(options) {
+    return createWalletMutationFeeSummary(options.selection, btcNumberToSats(options.built.funded.fee).toString());
+}
+export async function resolvePendingMutationFeeSummary(options) {
+    const source = options.mutation.feeSelectionSource ?? "fallback-default";
+    const selectedFeeRateSatVb = typeof options.mutation.selectedFeeRateSatVb === "number"
+        && Number.isFinite(options.mutation.selectedFeeRateSatVb)
+        && options.mutation.selectedFeeRateSatVb > 0
+        ? normalizeSatVb(options.mutation.selectedFeeRateSatVb)
+        : DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB;
+    if (options.mutation.attemptedTxid !== null && options.rpc.getMempoolEntry !== undefined) {
+        try {
+            const entry = await options.rpc.getMempoolEntry(options.mutation.attemptedTxid);
+            const feeRateSatVb = feeRateFromMempoolEntry(entry);
+            if (feeRateSatVb !== null) {
+                return {
+                    feeRateSatVb,
+                    feeSats: btcNumberToSats(entry.fees.base).toString(),
+                    source,
+                };
+            }
+        }
+        catch {
+            // Fall back to stored metadata or the historical default.
+        }
+    }
+    return {
+        feeRateSatVb: selectedFeeRateSatVb,
+        feeSats: null,
+        source,
+    };
+}
+export async function loadAttemptedMutationFixedInputs(options) {
+    if (options.mutation.attemptedTxid === null) {
+        return null;
+    }
+    const txid = options.mutation.attemptedTxid;
+    let decoded = null;
+    if (options.rpc.getTransaction !== undefined) {
+        try {
+            decoded = (await options.rpc.getTransaction(options.walletName, txid)).decoded ?? null;
+        }
+        catch {
+            decoded = null;
+        }
+    }
+    if (decoded === null && options.rpc.getRawTransaction !== undefined) {
+        try {
+            decoded = await options.rpc.getRawTransaction(txid, true);
+        }
+        catch {
+            decoded = null;
+        }
+    }
+    if (decoded === null) {
+        return null;
+    }
+    const fixedInputs = decoded.vin
+        .filter((input) => typeof input.txid === "string" && typeof input.vout === "number")
+        .map((input) => ({
+        txid: input.txid,
+        vout: input.vout,
+    }));
+    return fixedInputs.length > 0 ? fixedInputs : null;
+}
+export async function resolvePendingMutationReuseDecision(options) {
+    const fees = await resolvePendingMutationFeeSummary({
+        rpc: options.rpc,
+        mutation: options.mutation,
+    });
+    if (options.mutation.status === "confirmed"
+        || options.nextFeeSelection.feeRateSatVb <= fees.feeRateSatVb) {
+        return {
+            reuseExisting: true,
+            fees,
+            replacementFixedInputs: null,
+        };
+    }
+    return {
+        reuseExisting: false,
+        fees,
+        replacementFixedInputs: await loadAttemptedMutationFixedInputs({
+            rpc: options.rpc,
+            walletName: options.walletName,
+            mutation: options.mutation,
+        }),
+    };
+}
+export function mergeFixedWalletInputs(fixedInputs, replacementInputs) {
+    if (replacementInputs === null || replacementInputs.length === 0) {
+        return [...fixedInputs];
+    }
+    const merged = new Map();
+    for (const input of fixedInputs) {
+        merged.set(outpointKey(input), { txid: input.txid, vout: input.vout });
+    }
+    for (const input of replacementInputs) {
+        merged.set(outpointKey(input), { txid: input.txid, vout: input.vout });
+    }
+    return [...merged.values()];
+}
 export async function saveWalletStatePreservingUnlock(options) {
     const secretReference = createWalletSecretReference(options.state.walletRootId);
     await saveWalletState({
@@ -33,10 +198,6 @@ export async function saveWalletStatePreservingUnlock(options) {
         provider: options.provider,
         secretReference,
     });
-    await saveUnlockSession(options.paths.walletUnlockSessionPath, createUnlockSessionState(options.state, options.unlockUntilUnixMs, options.nowUnixMs), {
-        provider: options.provider,
-        secretReference,
-    });
 }
 export function formatCogAmount(value) {
     const sign = value < 0n ? "-" : "";
@@ -48,12 +209,24 @@ export function formatCogAmount(value) {
 export function outpointKey(outpoint) {
     return `${outpoint.txid}:${outpoint.vout}`;
 }
-function isSpendableConfirmedFundingUtxo(entry, fundingScriptPubKeyHex) {
+function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex, minConf) {
     return entry.scriptPubKey === fundingScriptPubKeyHex
-        && entry.confirmations >= 1
+        && entry.confirmations >= minConf
         && entry.spendable !== false
         && entry.safe !== false;
 }
+export function findSpendableFundingInputsFromTransaction(options) {
+    const minConf = options.minConf ?? 0;
+    return options.allUtxos
+        .filter((entry) => entry.txid === options.txid
+        && isSpendableFundingUtxo(entry, options.fundingScriptPubKeyHex, minConf))
+        .sort((left, right) => left.vout - right.vout
+        || left.txid.localeCompare(right.txid))
+        .map((entry) => ({
+        txid: entry.txid,
+        vout: entry.vout,
+    }));
+}
 export function updateMutationRecord(mutation, status, nowUnixMs, options = {}) {
     return {
         ...mutation,
@@ -62,10 +235,12 @@ export function updateMutationRecord(mutation, status, nowUnixMs, options = {})
         attemptedTxid: options.attemptedTxid ?? mutation.attemptedTxid,
         attemptedWtxid: options.attemptedWtxid ?? mutation.attemptedWtxid,
         temporaryBuilderLockedOutpoints: options.temporaryBuilderLockedOutpoints ?? mutation.temporaryBuilderLockedOutpoints,
+        selectedFeeRateSatVb: options.selectedFeeRateSatVb ?? mutation.selectedFeeRateSatVb,
+        feeSelectionSource: options.feeSelectionSource ?? mutation.feeSelectionSource,
     };
 }
 export async function unlockTemporaryBuilderLocks(rpc, walletName, outpoints) {
-    if (outpoints.length === 0) {
+    if (outpoints.length === 0 || rpc.lockUnspent === undefined) {
         return;
     }
     await rpc.lockUnspent(walletName, true, outpoints).catch(() => undefined);
@@ -79,51 +254,50 @@ export function diffTemporaryLockedOutpoints(before, after) {
         vout: entry.vout,
     }));
 }
-export function getDecodedInputScriptPubKeyHex(input) {
-    return input.prevout?.scriptPubKey?.hex ?? null;
-}
 export function getDecodedInputVout(input) {
-    const vout = input.vout;
-    return typeof vout === "number" ? vout : null;
+    return typeof input.vout === "number" ? input.vout : null;
+}
+export function getDecodedInputScriptPubKeyHex(decoded, inputIndex) {
+    const input = decoded.tx.vin[inputIndex];
+    if (input === undefined) {
+        return null;
+    }
+    const prevoutScriptPubKeyHex = input.prevout?.scriptPubKey?.hex;
+    if (typeof prevoutScriptPubKeyHex === "string" && prevoutScriptPubKeyHex.length > 0) {
+        return prevoutScriptPubKeyHex;
+    }
+    const psbtInput = decoded.inputs?.[inputIndex];
+    const witnessScriptPubKeyHex = psbtInput?.witness_utxo?.scriptPubKey?.hex;
+    if (typeof witnessScriptPubKeyHex === "string" && witnessScriptPubKeyHex.length > 0) {
+        return witnessScriptPubKeyHex;
+    }
+    const vout = getDecodedInputVout(input);
+    if (vout === null) {
+        return null;
+    }
+    const nonWitnessScriptPubKeyHex = psbtInput?.non_witness_utxo?.vout
+        .find((output) => output.n === vout)
+        ?.scriptPubKey?.hex;
+    return typeof nonWitnessScriptPubKeyHex === "string" && nonWitnessScriptPubKeyHex.length > 0
+        ? nonWitnessScriptPubKeyHex
+        : null;
 }
 export function inputMatchesOutpoint(input, outpoint) {
     return input.txid === outpoint.txid && getDecodedInputVout(input) === outpoint.vout;
 }
 export function assertFixedInputPrefixMatches(inputs, fixedInputs, errorCode) {
-    if (inputs.length < fixedInputs.length) {
-        throw new Error(errorCode);
-    }
-    for (const [index, fixedInput] of fixedInputs.entries()) {
-        if (!inputMatchesOutpoint(inputs[index], fixedInput)) {
-            throw new Error(errorCode);
-        }
-    }
+    void inputs;
+    void fixedInputs;
+    void errorCode;
 }
 export function assertFundingInputsAfterFixedPrefix(options) {
-    for (let index = options.fixedInputs.length; index < options.inputs.length; index += 1) {
-        const input = options.inputs[index];
-        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(input);
-        const vout = getDecodedInputVout(input);
-        if (scriptPubKeyHex !== options.allowedFundingScriptPubKeyHex || vout === null || typeof input.txid !== "string") {
-            throw new Error(options.errorCode);
-        }
-        const key = outpointKey({
-            txid: input.txid,
-            vout,
-        });
-        if (!options.eligibleFundingOutpointKeys.has(key)) {
-            throw new Error(options.errorCode);
-        }
-    }
+    void options;
 }
 export async function reconcilePersistentPolicyLocks(options) {
     await reconcileWalletCoinControlLocks({
         rpc: options.rpc,
         walletName: options.walletName,
         state: options.state,
-        fixedInputs: options.fixedInputs,
-        temporarilyUnlockedOutpoints: options.temporarilyUnlockedOutpoints,
-        cleanupInactiveTemporaryBuilderLocks: options.cleanupInactiveTemporaryBuilderLocks,
     });
 }
 export function isBroadcastUnknownError(error) {
@@ -147,16 +321,16 @@ export function isInsufficientFundsError(error) {
     return message.includes("insufficient funds");
 }
 function isReserveFloorFundingError(error) {
-    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-    return message.includes("insufficient_funding_after_reserve");
+    void error;
+    return false;
 }
 function computeRemainingFundingValueSats(options) {
     let remaining = 0n;
     for (const value of options.availableFundingValueByKey.values()) {
         remaining += value;
     }
-    for (const input of options.transaction.vin) {
-        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(input);
+    for (const [index, input] of options.decoded.tx.vin.entries()) {
+        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(options.decoded, index);
         const vout = getDecodedInputVout(input);
         if (scriptPubKeyHex !== options.fundingScriptPubKeyHex || vout === null || typeof input.txid !== "string") {
             continue;
@@ -166,7 +340,7 @@ function computeRemainingFundingValueSats(options) {
             vout,
         })) ?? 0n;
     }
-    for (const output of options.transaction.vout) {
+    for (const output of options.decoded.tx.vout) {
         if (output.scriptPubKey?.hex !== options.fundingScriptPubKeyHex) {
             continue;
         }
@@ -178,11 +352,20 @@ export function assertWalletMutationContextReady(context, errorPrefix) {
     if (context.localState.availability === "uninitialized") {
         throw new Error("wallet_uninitialized");
     }
+    if (context.localState.clientPasswordReadiness === "setup-required") {
+        throw new Error("wallet_client_password_setup_required");
+    }
+    if (context.localState.clientPasswordReadiness === "migration-required") {
+        throw new Error("wallet_client_password_migration_required");
+    }
+    if (context.localState.unlockRequired) {
+        throw new Error("wallet_client_password_locked");
+    }
     if (context.localState.availability === "local-state-corrupt") {
         throw new Error("local-state-corrupt");
     }
-    if (context.localState.availability !== "ready" || context.localState.state === null || context.localState.unlockUntilUnixMs === null) {
-        throw new Error("wallet_locked");
+    if (context.localState.availability !== "ready" || context.localState.state === null) {
+        throw new Error("wallet_secret_provider_unavailable");
     }
     if (context.bitcoind.health !== "ready") {
         throw new Error(`${errorPrefix}_bitcoind_${context.bitcoind.health.replaceAll("-", "_")}`);
@@ -197,6 +380,35 @@ export function assertWalletMutationContextReady(context, errorPrefix) {
         throw new Error(`${errorPrefix}_core_replica_not_ready`);
     }
 }
+export function assertWalletBitcoinTransferContextReady(context, errorPrefix) {
+    if (context.localState.availability === "uninitialized") {
+        throw new Error("wallet_uninitialized");
+    }
+    if (context.localState.clientPasswordReadiness === "setup-required") {
+        throw new Error("wallet_client_password_setup_required");
+    }
+    if (context.localState.clientPasswordReadiness === "migration-required") {
+        throw new Error("wallet_client_password_migration_required");
+    }
+    if (context.localState.unlockRequired) {
+        throw new Error("wallet_client_password_locked");
+    }
+    if (context.localState.availability === "local-state-corrupt") {
+        throw new Error("local-state-corrupt");
+    }
+    if (context.localState.availability !== "ready" || context.localState.state === null) {
+        throw new Error("wallet_secret_provider_unavailable");
+    }
+    if (context.bitcoind.health !== "ready") {
+        throw new Error(`${errorPrefix}_bitcoind_${context.bitcoind.health.replaceAll("-", "_")}`);
+    }
+    if (context.nodeHealth !== "synced") {
+        throw new Error(`${errorPrefix}_node_${context.nodeHealth.replaceAll("-", "_")}`);
+    }
+    if (context.nodeStatus?.walletReplica?.proofStatus !== "ready") {
+        throw new Error(`${errorPrefix}_core_replica_not_ready`);
+    }
+}
 export async function pauseMiningForWalletMutation(options) {
     return requestMiningGenerationPreemption({
         paths: options.paths,
@@ -204,15 +416,9 @@ export async function pauseMiningForWalletMutation(options) {
     });
 }
 export async function buildWalletMutationTransaction(options) {
-    await reconcilePersistentPolicyLocks({
-        rpc: options.rpc,
-        walletName: options.walletName,
-        state: options.state,
-        fixedInputs: options.plan.fixedInputs,
-        temporarilyUnlockedOutpoints: options.temporarilyUnlockedPolicyOutpoints,
-    });
-    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, 1))
-        .filter((entry) => isSpendableConfirmedFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex));
+    const availableFundingMinConf = options.availableFundingMinConf ?? 1;
+    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, availableFundingMinConf))
+        .filter((entry) => isSpendableFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex, availableFundingMinConf));
     const availableFundingValueByKey = new Map(availableFundingUtxos.map((entry) => [
         outpointKey({ txid: entry.txid, vout: entry.vout }),
         btcNumberToSats(entry.amount),
@@ -224,58 +430,56 @@ export async function buildWalletMutationTransaction(options) {
             ...availableFundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout })),
         ]),
     };
-    const lockedBefore = await options.rpc.listLockUnspent(options.walletName);
-    let temporaryBuilderLockedOutpoints = [];
+    const temporaryBuilderLockedOutpoints = [];
     try {
         const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.fixedInputs, options.plan.outputs, 0, {
             add_inputs: true,
             include_unsafe: false,
             minconf: 1,
             changeAddress: options.plan.changeAddress,
-            changePosition: options.plan.changePosition,
-            lockUnspents: true,
+            ...(options.plan.changePosition == null ? {} : { changePosition: options.plan.changePosition }),
+            lockUnspents: false,
             fee_rate: options.feeRate ?? DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB,
             replaceable: true,
             subtractFeeFromOutputs: [],
         });
-        const lockedAfter = await options.rpc.listLockUnspent(options.walletName);
-        temporaryBuilderLockedOutpoints = diffTemporaryLockedOutpoints(lockedBefore, lockedAfter);
         const decoded = await options.rpc.decodePsbt(funded.psbt);
         options.validateFundedDraft(decoded, funded, validationPlan);
-        if (options.state.proactiveReserveSats > 0) {
-            const remainingFundingValueSats = computeRemainingFundingValueSats({
-                transaction: decoded.tx,
-                fundingScriptPubKeyHex: options.plan.allowedFundingScriptPubKeyHex,
-                availableFundingValueByKey,
-            });
-            if (remainingFundingValueSats < BigInt(options.state.proactiveReserveSats)) {
-                throw new Error("wallet_mutation_insufficient_funding_after_reserve");
-            }
-        }
-        const signed = await options.rpc.walletProcessPsbt(options.walletName, funded.psbt, true, "DEFAULT");
-        const finalized = await options.rpc.finalizePsbt(signed.psbt, true);
-        if (!finalized.complete || finalized.hex == null) {
-            throw new Error(options.finalizeErrorCode);
-        }
-        const decodedRaw = await options.rpc.decodeRawTransaction(finalized.hex);
-        const mempoolResult = await options.rpc.testMempoolAccept([finalized.hex]);
-        const accepted = mempoolResult[0];
-        if (accepted == null || !accepted.allowed) {
-            throw new Error(`${options.mempoolRejectPrefix}_${accepted?.["reject-reason"] ?? "unknown"}`);
-        }
-        if ((options.temporarilyUnlockedPolicyOutpoints?.length ?? 0) > 0) {
-            await reconcilePersistentPolicyLocks({
-                rpc: options.rpc,
-                walletName: options.walletName,
-                state: options.state,
-                fixedInputs: options.plan.fixedInputs,
-            });
-        }
+        let signed;
+        let finalized;
+        let rawHex;
+        let decodedRaw;
+        ({ signed, finalized, rawHex, decodedRaw } = await withUnlockedManagedCoreWallet({
+            rpc: options.rpc,
+            walletName: options.walletName,
+            internalPassphrase: options.state.managedCoreWallet.internalPassphrase,
+            timeoutSeconds: MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS,
+            run: async () => {
+                const signed = await options.rpc.walletProcessPsbt(options.walletName, funded.psbt, true, "DEFAULT");
+                const finalized = await options.rpc.finalizePsbt(signed.psbt, true);
+                if (!finalized.complete || finalized.hex == null) {
+                    throw new Error(options.finalizeErrorCode);
+                }
+                const rawHex = finalized.hex;
+                const decodedRaw = await options.rpc.decodeRawTransaction(rawHex);
+                const mempoolResult = await options.rpc.testMempoolAccept([rawHex]);
+                const accepted = mempoolResult[0];
+                if (accepted == null || !accepted.allowed) {
+                    throw new Error(`${options.mempoolRejectPrefix}_${accepted?.["reject-reason"] ?? "unknown"}`);
+                }
+                return {
+                    signed,
+                    finalized,
+                    rawHex,
+                    decodedRaw,
+                };
+            },
+        }));
         return {
             funded,
             decoded,
             psbt: signed.psbt,
-            rawHex: finalized.hex,
+            rawHex,
             txid: decodedRaw.txid,
             wtxid: decodedRaw.hash ?? null,
             temporaryBuilderLockedOutpoints,
@@ -283,46 +487,19 @@ export async function buildWalletMutationTransaction(options) {
     }
     catch (error) {
         await unlockTemporaryBuilderLocks(options.rpc, options.walletName, temporaryBuilderLockedOutpoints);
-        if ((options.temporarilyUnlockedPolicyOutpoints?.length ?? 0) > 0) {
-            await reconcilePersistentPolicyLocks({
-                rpc: options.rpc,
-                walletName: options.walletName,
-                state: options.state,
-                fixedInputs: options.plan.fixedInputs,
-            });
-        }
         throw error;
     }
 }
 export async function buildWalletMutationTransactionWithReserveFallback(options) {
-    let unlockedReserveOutpoints = [];
-    let lastError = null;
-    for (let attempt = 0; attempt <= options.reserveCandidates.length; attempt += 1) {
-        if (attempt > 0) {
-            unlockedReserveOutpoints = [
-                ...unlockedReserveOutpoints,
-                options.reserveCandidates[attempt - 1],
-            ];
-        }
-        try {
-            return await buildWalletMutationTransaction({
-                rpc: options.rpc,
-                walletName: options.walletName,
-                state: options.state,
-                plan: options.plan,
-                validateFundedDraft: options.validateFundedDraft,
-                finalizeErrorCode: options.finalizeErrorCode,
-                mempoolRejectPrefix: options.mempoolRejectPrefix,
-                feeRate: options.feeRate,
-                temporarilyUnlockedPolicyOutpoints: unlockedReserveOutpoints,
-            });
-        }
-        catch (error) {
-            lastError = error;
-            if ((!isInsufficientFundsError(error) && !isReserveFloorFundingError(error)) || attempt === options.reserveCandidates.length) {
-                throw error;
-            }
-        }
-    }
-    throw lastError;
+    return buildWalletMutationTransaction({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        state: options.state,
+        plan: options.plan,
+        validateFundedDraft: options.validateFundedDraft,
+        finalizeErrorCode: options.finalizeErrorCode,
+        mempoolRejectPrefix: options.mempoolRejectPrefix,
+        feeRate: options.feeRate,
+        availableFundingMinConf: options.availableFundingMinConf,
+    });
 }

package/dist/wallet/tx/domain-admin.d.ts

@@ -5,7 +5,7 @@ import type { WalletPrompter } from "../lifecycle.js";
 import { type WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import { openWalletReadContext } from "../read/index.js";
-import { type WalletMutationRpcClient } from "./common.js";
+import { type WalletMutationFeeSummary, type WalletMutationRpcClient } from "./common.js";
 type DomainAdminKind = "endpoint" | "delegate" | "miner" | "canonical";
 interface DomainAdminRpcClient extends WalletMutationRpcClient {
     getBlockchainInfo(): Promise<{
@@ -55,9 +55,11 @@ export interface DomainAdminMutationResult {
     recipientScriptPubKeyHex?: string | null;
     endpointValueHex?: string | null;
     resolved?: DomainAdminResolvedSummary | null;
+    fees: WalletMutationFeeSummary;
 }
 interface DomainAdminBaseOptions {
     domainName: string;
+    feeRateSatVb?: number | null;
     dataDir: string;
     databasePath: string;
     provider?: WalletSecretProvider;